[Reproducers] Add SBReproducer macros

[JDevlieghere]

Summary

This patch adds the SBReproducer macros needed to capture and reply the corresponding calls.

The patch was generated using the SBRepro tool (D56822).

[labath]

BTW, it would be nice to mention somewhere how to use this tool. Do you just run it, or does it needs some special arguments, or something?

source/API/SBBlock.cpp

52–58 ↗

(On Diff #184371)

It looks like some functions have a newline after the macro, and some don't. What's the reason for that?

[JDevlieghere]

source/API/SBBlock.cpp

52–58 ↗

(On Diff #184371)

It depends on whether there was a newline before or not. So

foo { bar }

will not have the newline, while

foo {
bar;
}

This happens because we insert the macro at the first loc, before the potentially existing \n. Getting this right for all cases and coding styles is tricky, so the tool doesn't try to get it right. It just inserts it there and relies on clang-format to fix the formatting.

[labath]

source/API/SBBlock.cpp

52–58 ↗

(On Diff #184371)

Aha. That's funny.

How about changing to tool to always add *two* newlines after the macro invocation? clang-format removes multiple empty lines, so if this results in creates them, clang-format should always coalesce into one.

[JDevlieghere]

• Rebase
• Re-ran the latest version of the tool to insert LLDB_RECORD_RESULT

[labath]

lgtm

[tatyana-krasnukha]

Run into a few compilation errors building on Windows with msvc.

source/API/SBReproducer.cpp

40 ↗

(On Diff #189419)

Array size must be compile-time constant.

1120 ↗

(On Diff #189419)

lldb::thread_t is just a void* on Windows, so

return new UnderlyingT(Deserialize<UnderlyingT>());

tries to allocate void object.

[JDevlieghere]

Thanks Tatyana!

source/API/SBReproducer.cpp

40 ↗

(On Diff #189419)

Fixed in rL355518

1120 ↗

(On Diff #189419)

Fixed in rL355519.

[mgorny]

This is still breaking NetBSD buildbot: http://lab.llvm.org:8011/builders/netbsd-amd64/builds/19339/steps/ninja%20build%20local/logs/stdio

FAILED: tools/lldb/source/API/CMakeFiles/liblldb.dir/SBHostOS.cpp.o 
/usr/bin/g++  -DGTEST_HAS_RTTI=0 -DHAVE_ROUND -DLIBXML2_DEFINED -DLLDB_CONFIGURATION_RELEASE -D__STDC_CONSTANT_MACROS -D__STDC_FORMAT_MACROS -D__STDC_LIMIT_MACROS -Itools/lldb/source/API -I/home/motus/netbsd8/netbsd8/llvm/tools/lldb/source/API -Itools/lldb/include -I/home/motus/netbsd8/netbsd8/llvm/tools/lldb/include -Iinclude -I/home/motus/netbsd8/netbsd8/llvm/include -I/usr/pkg/include/python2.7 -I/home/motus/netbsd8/netbsd8/llvm/tools/clang/include -Itools/lldb/../clang/include -I/usr/pkg/include/libxml2 -I/home/motus/netbsd8/netbsd8/llvm/tools/lldb/source/. -fPIC -fvisibility-inlines-hidden -Werror=date-time -std=c++11 -Wall -Wextra -Wno-unused-parameter -Wwrite-strings -Wcast-qual -Wno-missing-field-initializers -pedantic -Wno-long-long -Wno-maybe-uninitialized -Wdelete-non-virtual-dtor -Wno-comment -fdiagnostics-color -ffunction-sections -fdata-sections -Wno-deprecated-declarations -Wno-unknown-pragmas -Wno-strict-aliasing -Wno-deprecated-register -Wno-vla-extension -O3 -DNDEBUG -fPIC    -fno-exceptions -fno-rtti -MD -MT tools/lldb/source/API/CMakeFiles/liblldb.dir/SBHostOS.cpp.o -MF tools/lldb/source/API/CMakeFiles/liblldb.dir/SBHostOS.cpp.o.d -o tools/lldb/source/API/CMakeFiles/liblldb.dir/SBHostOS.cpp.o -c /home/motus/netbsd8/netbsd8/llvm/tools/lldb/source/API/SBHostOS.cpp
In file included from /home/motus/netbsd8/netbsd8/llvm/tools/lldb/source/API/SBReproducerPrivate.h:18:0,
                 from /home/motus/netbsd8/netbsd8/llvm/tools/lldb/source/API/SBHostOS.cpp:13:
/home/motus/netbsd8/netbsd8/llvm/tools/lldb/include/lldb/Utility/ReproducerInstrumentation.h: In instantiation of 'void lldb_private::repro::Serializer::Serialize(T&) [with T = __pthread_st]':
/home/motus/netbsd8/netbsd8/llvm/tools/lldb/include/lldb/Utility/ReproducerInstrumentation.h:518:7:   required from 'void lldb_private::repro::Serializer::Serialize(T*) [with T = __pthread_st]'
/home/motus/netbsd8/netbsd8/llvm/tools/lldb/include/lldb/Utility/ReproducerInstrumentation.h:506:5:   required from 'void lldb_private::repro::Serializer::SerializeAll(const Head&, const Tail& ...) [with Head = __pthread_st*; Tail = {lldb::SBError*}]'
/home/motus/netbsd8/netbsd8/llvm/tools/lldb/include/lldb/Utility/ReproducerInstrumentation.h:601:5:   required from 'void lldb_private::repro::Recorder::Record(Result (*)(FArgs ...), const RArgs& ...) [with Result = bool; FArgs = {__pthread_st*, lldb::SBError*}; RArgs = {__pthread_st*, lldb::SBError*}]'
/home/motus/netbsd8/netbsd8/llvm/tools/lldb/source/API/SBHostOS.cpp:135:3:   required from here
/home/motus/netbsd8/netbsd8/llvm/tools/lldb/include/lldb/Utility/ReproducerInstrumentation.h:530:64: error: invalid application of 'sizeof' to incomplete type '__pthread_st'
       m_stream.write(reinterpret_cast<const char *>(&t), sizeof(T));
                                                                ^

It looks like it's trying to serialize opaque types.

[labath]

Jonas, would it be possible to just not intercept the functions which work with thread IDs and similar stuff (an all OSs)?
Using the naive serialization approach will not be correct for these, even if the types happen to be implemented as primitive types (most likely we will need some runtime remapping of thread id's or something), so I am hoping it would not affect the ability to record&replay the recordings which don't use these functions.

lldb/source/API/SBAddress.cpp

 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBAddress.h"
+#include "SBReproducerPrivate.h"
 #include "lldb/API/SBProcess.h"
 #include "lldb/API/SBSection.h"
 #include "lldb/API/SBStream.h"

 using namespace lldb;
 using namespace lldb_private;
 
-SBAddress::SBAddress() : m_opaque_up(new Address()) {}
+SBAddress::SBAddress() : m_opaque_up(new Address()) {
+  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBAddress);
+}
 
 SBAddress::SBAddress(const Address *lldb_object_ptr)
     : m_opaque_up(new Address()) {

 }
 
 SBAddress::SBAddress(const SBAddress &rhs) : m_opaque_up(new Address()) {
+  LLDB_RECORD_CONSTRUCTOR(SBAddress, (const lldb::SBAddress &), rhs);
+
   if (rhs.IsValid())
     ref() = rhs.ref();
 }
 
 SBAddress::SBAddress(lldb::SBSection section, lldb::addr_t offset)
-    : m_opaque_up(new Address(section.GetSP(), offset)) {}
+    : m_opaque_up(new Address(section.GetSP(), offset)) {
+  LLDB_RECORD_CONSTRUCTOR(SBAddress, (lldb::SBSection, lldb::addr_t), 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);
+
   SetLoadAddress(load_addr, target);
 }
 
 SBAddress::~SBAddress() {}
 
 const SBAddress &SBAddress::operator=(const SBAddress &rhs) {
+  LLDB_RECORD_METHOD(const lldb::SBAddress &,
+                     SBAddress, operator=,(const lldb::SBAddress &), rhs);
+
   if (this != &rhs) {
     if (rhs.IsValid())
       ref() = rhs.ref();

 }
 
 bool SBAddress::IsValid() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBAddress, IsValid);
+
   return m_opaque_up != NULL && m_opaque_up->IsValid();
 }
 
-void SBAddress::Clear() { m_opaque_up.reset(new Address()); }
+void SBAddress::Clear() {
+  LLDB_RECORD_METHOD_NO_ARGS(void, SBAddress, Clear);
+
+  m_opaque_up.reset(new Address());
+}
 
 void SBAddress::SetAddress(lldb::SBSection section, lldb::addr_t offset) {
+  LLDB_RECORD_METHOD(void, SBAddress, SetAddress,
+                     (lldb::SBSection, lldb::addr_t), section, offset);
+
   Address &addr = ref();
   addr.SetSection(section.GetSP());
   addr.SetOffset(offset);

 }
 
 lldb::addr_t SBAddress::GetFileAddress() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::addr_t, SBAddress, GetFileAddress);
+
   if (m_opaque_up->IsValid())
     return m_opaque_up->GetFileAddress();
   else

 }
 
 lldb::addr_t SBAddress::GetLoadAddress(const SBTarget &target) const {
+  LLDB_RECORD_METHOD_CONST(lldb::addr_t, SBAddress, GetLoadAddress,
+                           (const lldb::SBTarget &), target);
+
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   lldb::addr_t addr = LLDB_INVALID_ADDRESS;

 }
 
 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);
+
   // Create the address object if we don't already have one
   ref();
   if (target.IsValid())

 }
 
 bool SBAddress::OffsetAddress(addr_t offset) {
+  LLDB_RECORD_METHOD(bool, SBAddress, OffsetAddress, (lldb::addr_t), offset);
+
   if (m_opaque_up->IsValid()) {
     addr_t addr_offset = m_opaque_up->GetOffset();
     if (addr_offset != LLDB_INVALID_ADDRESS) {

 }
 
 lldb::SBSection SBAddress::GetSection() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBSection, SBAddress, GetSection);
+
   lldb::SBSection sb_section;
   if (m_opaque_up->IsValid())
     sb_section.SetSP(m_opaque_up->GetSection());
-  return sb_section;
+  return LLDB_RECORD_RESULT(sb_section);
 }
 
 lldb::addr_t SBAddress::GetOffset() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::addr_t, SBAddress, GetOffset);
+
   if (m_opaque_up->IsValid())
     return m_opaque_up->GetOffset();
   return 0;

 Address *SBAddress::get() { return m_opaque_up.get(); }
 
 bool SBAddress::GetDescription(SBStream &description) {
+  LLDB_RECORD_METHOD(bool, SBAddress, GetDescription, (lldb::SBStream &),
+                     description);
+
   // Call "ref()" on the stream to make sure it creates a backing stream in
   // case there isn't one already...
   Stream &strm = description.ref();

 }
 
 SBModule SBAddress::GetModule() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBModule, SBAddress, GetModule);
+
   SBModule sb_module;
   if (m_opaque_up->IsValid())
     sb_module.SetSP(m_opaque_up->GetModule());
-  return sb_module;
+  return LLDB_RECORD_RESULT(sb_module);
 }
 
 SBSymbolContext SBAddress::GetSymbolContext(uint32_t resolve_scope) {
+  LLDB_RECORD_METHOD(lldb::SBSymbolContext, SBAddress, GetSymbolContext,
+                     (uint32_t), 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 sb_sc;
+  return LLDB_RECORD_RESULT(sb_sc);
 }
 
 SBCompileUnit SBAddress::GetCompileUnit() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBCompileUnit, SBAddress, GetCompileUnit);
+
   SBCompileUnit sb_comp_unit;
   if (m_opaque_up->IsValid())
     sb_comp_unit.reset(m_opaque_up->CalculateSymbolContextCompileUnit());
-  return sb_comp_unit;
+  return LLDB_RECORD_RESULT(sb_comp_unit);
 }
 
 SBFunction SBAddress::GetFunction() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBFunction, SBAddress, GetFunction);
+
   SBFunction sb_function;
   if (m_opaque_up->IsValid())
     sb_function.reset(m_opaque_up->CalculateSymbolContextFunction());
-  return sb_function;
+  return LLDB_RECORD_RESULT(sb_function);
 }
 
 SBBlock SBAddress::GetBlock() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBBlock, SBAddress, GetBlock);
+
   SBBlock sb_block;
   if (m_opaque_up->IsValid())
     sb_block.SetPtr(m_opaque_up->CalculateSymbolContextBlock());
-  return sb_block;
+  return LLDB_RECORD_RESULT(sb_block);
 }
 
 SBSymbol SBAddress::GetSymbol() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBSymbol, SBAddress, GetSymbol);
+
   SBSymbol sb_symbol;
   if (m_opaque_up->IsValid())
     sb_symbol.reset(m_opaque_up->CalculateSymbolContextSymbol());
-  return sb_symbol;
+  return LLDB_RECORD_RESULT(sb_symbol);
 }
 
 SBLineEntry SBAddress::GetLineEntry() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBLineEntry, SBAddress, GetLineEntry);
+
   SBLineEntry sb_line_entry;
   if (m_opaque_up->IsValid()) {
     LineEntry line_entry;
     if (m_opaque_up->CalculateSymbolContextLineEntry(line_entry))
       sb_line_entry.SetLineEntry(line_entry);
   }
-  return sb_line_entry;
+  return LLDB_RECORD_RESULT(sb_line_entry);
 }

lldb/source/API/SBAttachInfo.cpp

 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBAttachInfo.h"
+#include "SBReproducerPrivate.h"
 
 #include "lldb/API/SBFileSpec.h"
 #include "lldb/API/SBListener.h"

 using namespace lldb;
 using namespace lldb_private;
 
-SBAttachInfo::SBAttachInfo() : m_opaque_sp(new ProcessAttachInfo()) {}
+SBAttachInfo::SBAttachInfo() : m_opaque_sp(new ProcessAttachInfo()) {
+  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBAttachInfo);
+}
 
 SBAttachInfo::SBAttachInfo(lldb::pid_t pid)
     : m_opaque_sp(new ProcessAttachInfo()) {
+  LLDB_RECORD_CONSTRUCTOR(SBAttachInfo, (lldb::pid_t), 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);
+
   if (path && path[0])
     m_opaque_sp->GetExecutableFile().SetFile(path, FileSpec::Style::native);
   m_opaque_sp->SetWaitForLaunch(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);
+
   if (path && path[0])
     m_opaque_sp->GetExecutableFile().SetFile(path, FileSpec::Style::native);
   m_opaque_sp->SetWaitForLaunch(wait_for);

 
 SBAttachInfo::SBAttachInfo(const SBAttachInfo &rhs)
     : m_opaque_sp(new ProcessAttachInfo()) {
+  LLDB_RECORD_CONSTRUCTOR(SBAttachInfo, (const lldb::SBAttachInfo &), rhs);
+
   *m_opaque_sp = *rhs.m_opaque_sp;
 }
 

 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);
+
   if (this != &rhs)
     *m_opaque_sp = *rhs.m_opaque_sp;
   return *this;
 }
 
-lldb::pid_t SBAttachInfo::GetProcessID() { return m_opaque_sp->GetProcessID(); }
+lldb::pid_t SBAttachInfo::GetProcessID() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::pid_t, SBAttachInfo, GetProcessID);
+
+  return m_opaque_sp->GetProcessID();
+}
 
 void SBAttachInfo::SetProcessID(lldb::pid_t pid) {
+  LLDB_RECORD_METHOD(void, SBAttachInfo, SetProcessID, (lldb::pid_t), pid);
+
   m_opaque_sp->SetProcessID(pid);
 }
 
 uint32_t SBAttachInfo::GetResumeCount() {
+  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBAttachInfo, GetResumeCount);
+
   return m_opaque_sp->GetResumeCount();
 }
 
 void SBAttachInfo::SetResumeCount(uint32_t c) {
+  LLDB_RECORD_METHOD(void, SBAttachInfo, SetResumeCount, (uint32_t), c);
+
   m_opaque_sp->SetResumeCount(c);
 }
 
 const char *SBAttachInfo::GetProcessPluginName() {
+  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBAttachInfo, GetProcessPluginName);
+
   return m_opaque_sp->GetProcessPluginName();
 }
 
 void SBAttachInfo::SetProcessPluginName(const char *plugin_name) {
+  LLDB_RECORD_METHOD(void, SBAttachInfo, SetProcessPluginName, (const char *),
+                     plugin_name);
+
   return m_opaque_sp->SetProcessPluginName(plugin_name);
 }
 
 void SBAttachInfo::SetExecutable(const char *path) {
+  LLDB_RECORD_METHOD(void, SBAttachInfo, SetExecutable, (const char *), path);
+
   if (path && path[0])
     m_opaque_sp->GetExecutableFile().SetFile(path, FileSpec::Style::native);
   else

 }
 
 void SBAttachInfo::SetExecutable(SBFileSpec exe_file) {
+  LLDB_RECORD_METHOD(void, SBAttachInfo, SetExecutable, (lldb::SBFileSpec),
+                     exe_file);
+
   if (exe_file.IsValid())
     m_opaque_sp->GetExecutableFile() = exe_file.ref();
   else

 }
 
 bool SBAttachInfo::GetWaitForLaunch() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBAttachInfo, GetWaitForLaunch);
+
   return m_opaque_sp->GetWaitForLaunch();
 }
 
 void SBAttachInfo::SetWaitForLaunch(bool b) {
+  LLDB_RECORD_METHOD(void, SBAttachInfo, SetWaitForLaunch, (bool), b);
+
   m_opaque_sp->SetWaitForLaunch(b);
 }
 
 void SBAttachInfo::SetWaitForLaunch(bool b, bool async) {
+  LLDB_RECORD_METHOD(void, SBAttachInfo, SetWaitForLaunch, (bool, bool), b,
+                     async);
+
   m_opaque_sp->SetWaitForLaunch(b);
   m_opaque_sp->SetAsync(async);
 }
 
 bool SBAttachInfo::GetIgnoreExisting() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBAttachInfo, GetIgnoreExisting);
+
   return m_opaque_sp->GetIgnoreExisting();
 }
 
 void SBAttachInfo::SetIgnoreExisting(bool b) {
+  LLDB_RECORD_METHOD(void, SBAttachInfo, SetIgnoreExisting, (bool), b);
+
   m_opaque_sp->SetIgnoreExisting(b);
 }
 
-uint32_t SBAttachInfo::GetUserID() { return m_opaque_sp->GetUserID(); }
+uint32_t SBAttachInfo::GetUserID() {
+  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBAttachInfo, GetUserID);
 
-uint32_t SBAttachInfo::GetGroupID() { return m_opaque_sp->GetGroupID(); }
+  return m_opaque_sp->GetUserID();
+}
 
-bool SBAttachInfo::UserIDIsValid() { return m_opaque_sp->UserIDIsValid(); }
+uint32_t SBAttachInfo::GetGroupID() {
+  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBAttachInfo, GetGroupID);
 
-bool SBAttachInfo::GroupIDIsValid() { return m_opaque_sp->GroupIDIsValid(); }
+  return m_opaque_sp->GetGroupID();
+}
 
-void SBAttachInfo::SetUserID(uint32_t uid) { m_opaque_sp->SetUserID(uid); }
+bool SBAttachInfo::UserIDIsValid() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBAttachInfo, UserIDIsValid);
 
-void SBAttachInfo::SetGroupID(uint32_t gid) { m_opaque_sp->SetGroupID(gid); }
+  return m_opaque_sp->UserIDIsValid();
+}
+
+bool SBAttachInfo::GroupIDIsValid() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBAttachInfo, GroupIDIsValid);
+
+  return m_opaque_sp->GroupIDIsValid();
+}
+
+void SBAttachInfo::SetUserID(uint32_t uid) {
+  LLDB_RECORD_METHOD(void, SBAttachInfo, SetUserID, (uint32_t), uid);
+
+  m_opaque_sp->SetUserID(uid);
+}
+
+void SBAttachInfo::SetGroupID(uint32_t gid) {
+  LLDB_RECORD_METHOD(void, SBAttachInfo, SetGroupID, (uint32_t), gid);
+
+  m_opaque_sp->SetGroupID(gid);
+}
 
 uint32_t SBAttachInfo::GetEffectiveUserID() {
+  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBAttachInfo, GetEffectiveUserID);
+
   return m_opaque_sp->GetEffectiveUserID();
 }
 
 uint32_t SBAttachInfo::GetEffectiveGroupID() {
+  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBAttachInfo, GetEffectiveGroupID);
+
   return m_opaque_sp->GetEffectiveGroupID();
 }
 
 bool SBAttachInfo::EffectiveUserIDIsValid() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBAttachInfo, EffectiveUserIDIsValid);
+
   return m_opaque_sp->EffectiveUserIDIsValid();
 }
 
 bool SBAttachInfo::EffectiveGroupIDIsValid() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBAttachInfo, EffectiveGroupIDIsValid);
+
   return m_opaque_sp->EffectiveGroupIDIsValid();
 }
 
 void SBAttachInfo::SetEffectiveUserID(uint32_t uid) {
+  LLDB_RECORD_METHOD(void, SBAttachInfo, SetEffectiveUserID, (uint32_t), uid);
+
   m_opaque_sp->SetEffectiveUserID(uid);
 }
 
 void SBAttachInfo::SetEffectiveGroupID(uint32_t gid) {
+  LLDB_RECORD_METHOD(void, SBAttachInfo, SetEffectiveGroupID, (uint32_t), gid);
+
   m_opaque_sp->SetEffectiveGroupID(gid);
 }
 
 lldb::pid_t SBAttachInfo::GetParentProcessID() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::pid_t, SBAttachInfo, GetParentProcessID);
+
   return m_opaque_sp->GetParentProcessID();
 }
 
 void SBAttachInfo::SetParentProcessID(lldb::pid_t pid) {
+  LLDB_RECORD_METHOD(void, SBAttachInfo, SetParentProcessID, (lldb::pid_t),
+                     pid);
+
   m_opaque_sp->SetParentProcessID(pid);
 }
 
 bool SBAttachInfo::ParentProcessIDIsValid() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBAttachInfo, ParentProcessIDIsValid);
+
   return m_opaque_sp->ParentProcessIDIsValid();
 }
 
 SBListener SBAttachInfo::GetListener() {
-  return SBListener(m_opaque_sp->GetListener());
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBListener, SBAttachInfo, GetListener);
+
+  return LLDB_RECORD_RESULT(SBListener(m_opaque_sp->GetListener()));
 }
 
 void SBAttachInfo::SetListener(SBListener &listener) {
+  LLDB_RECORD_METHOD(void, SBAttachInfo, SetListener, (lldb::SBListener &),
+                     listener);
+
   m_opaque_sp->SetListener(listener.GetSP());
 }

lldb/source/API/SBBlock.cpp

 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBBlock.h"
+#include "SBReproducerPrivate.h"
 #include "lldb/API/SBAddress.h"
 #include "lldb/API/SBFileSpec.h"
 #include "lldb/API/SBFrame.h"

 using namespace lldb;
 using namespace lldb_private;
 
-SBBlock::SBBlock() : m_opaque_ptr(NULL) {}
+SBBlock::SBBlock() : m_opaque_ptr(NULL) {
+  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBBlock);
+}
 
 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) {}
+SBBlock::SBBlock(const SBBlock &rhs) : m_opaque_ptr(rhs.m_opaque_ptr) {
+  LLDB_RECORD_CONSTRUCTOR(SBBlock, (const lldb::SBBlock &), rhs);
+}
 
 const SBBlock &SBBlock::operator=(const SBBlock &rhs) {
+  LLDB_RECORD_METHOD(const lldb::SBBlock &,
+                     SBBlock, operator=,(const lldb::SBBlock &), rhs);
+
   m_opaque_ptr = rhs.m_opaque_ptr;
   return *this;
 }
 
 SBBlock::~SBBlock() { m_opaque_ptr = NULL; }
 
-bool SBBlock::IsValid() const { return m_opaque_ptr != NULL; }
+bool SBBlock::IsValid() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBlock, IsValid);
+
+  return m_opaque_ptr != NULL;
+}
 
 bool SBBlock::IsInlined() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBlock, IsInlined);
+
   if (m_opaque_ptr)
     return m_opaque_ptr->GetInlinedFunctionInfo() != NULL;
   return false;
 }
 
 const char *SBBlock::GetInlinedName() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBBlock, GetInlinedName);
+
   if (m_opaque_ptr) {
     const InlineFunctionInfo *inlined_info =
         m_opaque_ptr->GetInlinedFunctionInfo();

 }
 
 SBFileSpec SBBlock::GetInlinedCallSiteFile() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBFileSpec, SBBlock,
+                                   GetInlinedCallSiteFile);
+
   SBFileSpec sb_file;
   if (m_opaque_ptr) {
     const InlineFunctionInfo *inlined_info =

     if (inlined_info)
       sb_file.SetFileSpec(inlined_info->GetCallSite().GetFile());
   }
-  return sb_file;
+  return LLDB_RECORD_RESULT(sb_file);
 }
 
 uint32_t SBBlock::GetInlinedCallSiteLine() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBBlock, GetInlinedCallSiteLine);
+
   if (m_opaque_ptr) {
     const InlineFunctionInfo *inlined_info =
         m_opaque_ptr->GetInlinedFunctionInfo();

 }
 
 uint32_t SBBlock::GetInlinedCallSiteColumn() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBBlock, GetInlinedCallSiteColumn);
+
   if (m_opaque_ptr) {
     const InlineFunctionInfo *inlined_info =
         m_opaque_ptr->GetInlinedFunctionInfo();

 }
 
 SBBlock SBBlock::GetParent() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBBlock, SBBlock, GetParent);
+
   SBBlock sb_block;
   if (m_opaque_ptr)
     sb_block.m_opaque_ptr = m_opaque_ptr->GetParent();
-  return sb_block;
+  return LLDB_RECORD_RESULT(sb_block);
 }
 
 lldb::SBBlock SBBlock::GetContainingInlinedBlock() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBBlock, SBBlock, GetContainingInlinedBlock);
+
   SBBlock sb_block;
   if (m_opaque_ptr)
     sb_block.m_opaque_ptr = m_opaque_ptr->GetContainingInlinedBlock();
-  return sb_block;
+  return LLDB_RECORD_RESULT(sb_block);
 }
 
 SBBlock SBBlock::GetSibling() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBBlock, SBBlock, GetSibling);
+
   SBBlock sb_block;
   if (m_opaque_ptr)
     sb_block.m_opaque_ptr = m_opaque_ptr->GetSibling();
-  return sb_block;
+  return LLDB_RECORD_RESULT(sb_block);
 }
 
 SBBlock SBBlock::GetFirstChild() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBBlock, SBBlock, GetFirstChild);
+
   SBBlock sb_block;
   if (m_opaque_ptr)
     sb_block.m_opaque_ptr = m_opaque_ptr->GetFirstChild();
-  return sb_block;
+  return LLDB_RECORD_RESULT(sb_block);
 }
 
 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);
+
   Stream &strm = description.ref();
 
   if (m_opaque_ptr) {

 }
 
 uint32_t SBBlock::GetNumRanges() {
+  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBBlock, GetNumRanges);
+
   if (m_opaque_ptr)
     return m_opaque_ptr->GetNumRanges();
   return 0;
 }
 
 lldb::SBAddress SBBlock::GetRangeStartAddress(uint32_t idx) {
+  LLDB_RECORD_METHOD(lldb::SBAddress, SBBlock, GetRangeStartAddress, (uint32_t),
+                     idx);
+
   lldb::SBAddress sb_addr;
   if (m_opaque_ptr) {
     AddressRange range;

       sb_addr.ref() = range.GetBaseAddress();
     }
   }
-  return sb_addr;
+  return LLDB_RECORD_RESULT(sb_addr);
 }
 
 lldb::SBAddress SBBlock::GetRangeEndAddress(uint32_t idx) {
+  LLDB_RECORD_METHOD(lldb::SBAddress, SBBlock, GetRangeEndAddress, (uint32_t),
+                     idx);
+
   lldb::SBAddress sb_addr;
   if (m_opaque_ptr) {
     AddressRange range;

       sb_addr.ref().Slide(range.GetByteSize());
     }
   }
-  return sb_addr;
+  return LLDB_RECORD_RESULT(sb_addr);
 }
 
 uint32_t SBBlock::GetRangeIndexForBlockAddress(lldb::SBAddress block_addr) {
+  LLDB_RECORD_METHOD(uint32_t, SBBlock, GetRangeIndexForBlockAddress,
+                     (lldb::SBAddress), block_addr);
+
   if (m_opaque_ptr && block_addr.IsValid()) {
     return m_opaque_ptr->GetRangeIndexContainingAddress(block_addr.ref());
   }

 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);
+
   Block *block = GetPtr();
   SBValueList value_list;
   if (block) {

       }
     }
   }
-  return value_list;
+  return LLDB_RECORD_RESULT(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);
+
   Block *block = GetPtr();
 
   SBValueList value_list;

       }
     }
   }
-  return value_list;
+  return LLDB_RECORD_RESULT(value_list);
 }

lldb/source/API/SBBreakpoint.cpp

 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBBreakpoint.h"
+#include "SBReproducerPrivate.h"
 #include "lldb/API/SBBreakpointLocation.h"
 #include "lldb/API/SBDebugger.h"
 #include "lldb/API/SBEvent.h"

 using namespace lldb;
 using namespace lldb_private;
 
-SBBreakpoint::SBBreakpoint() {}
+SBBreakpoint::SBBreakpoint() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBBreakpoint); }
 
 SBBreakpoint::SBBreakpoint(const SBBreakpoint &rhs)
-    : m_opaque_wp(rhs.m_opaque_wp) {}
+    : m_opaque_wp(rhs.m_opaque_wp) {
+  LLDB_RECORD_CONSTRUCTOR(SBBreakpoint, (const lldb::SBBreakpoint &), rhs);
+}
 
 SBBreakpoint::SBBreakpoint(const lldb::BreakpointSP &bp_sp)
-    : m_opaque_wp(bp_sp) {}
+    : m_opaque_wp(bp_sp) {
+  LLDB_RECORD_CONSTRUCTOR(SBBreakpoint, (const lldb::BreakpointSP &), bp_sp);
+}
 
 SBBreakpoint::~SBBreakpoint() = default;
 
 const SBBreakpoint &SBBreakpoint::operator=(const SBBreakpoint &rhs) {
+  LLDB_RECORD_METHOD(const lldb::SBBreakpoint &,
+                     SBBreakpoint, operator=,(const lldb::SBBreakpoint &), rhs);
+
   m_opaque_wp = rhs.m_opaque_wp;
   return *this;
 }
 
 bool SBBreakpoint::operator==(const lldb::SBBreakpoint &rhs) {
+  LLDB_RECORD_METHOD(
+      bool, SBBreakpoint, operator==,(const lldb::SBBreakpoint &), 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);
+
   return m_opaque_wp.lock() != rhs.m_opaque_wp.lock();
 }
 
 break_id_t SBBreakpoint::GetID() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::break_id_t, SBBreakpoint, GetID);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   break_id_t break_id = LLDB_INVALID_BREAK_ID;

 }
 
 bool SBBreakpoint::IsValid() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBreakpoint, IsValid);
+
   BreakpointSP bkpt_sp = GetSP();
   if (!bkpt_sp)
     return false;

 }
 
 void SBBreakpoint::ClearAllBreakpointSites() {
+  LLDB_RECORD_METHOD_NO_ARGS(void, SBBreakpoint, ClearAllBreakpointSites);
+
   BreakpointSP bkpt_sp = GetSP();
   if (bkpt_sp) {
     std::lock_guard<std::recursive_mutex> guard(

 }
 
 SBBreakpointLocation SBBreakpoint::FindLocationByAddress(addr_t vm_addr) {
+  LLDB_RECORD_METHOD(lldb::SBBreakpointLocation, SBBreakpoint,
+                     FindLocationByAddress, (lldb::addr_t), vm_addr);
+
   SBBreakpointLocation sb_bp_location;
 
   BreakpointSP bkpt_sp = GetSP();

       sb_bp_location.SetLocation(bkpt_sp->FindLocationByAddress(address));
     }
   }
-  return sb_bp_location;
+  return LLDB_RECORD_RESULT(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);
+
   break_id_t break_id = LLDB_INVALID_BREAK_ID;
   BreakpointSP bkpt_sp = GetSP();
 

 }
 
 SBBreakpointLocation SBBreakpoint::FindLocationByID(break_id_t bp_loc_id) {
+  LLDB_RECORD_METHOD(lldb::SBBreakpointLocation, SBBreakpoint, FindLocationByID,
+                     (lldb::break_id_t), bp_loc_id);
+
   SBBreakpointLocation sb_bp_location;
   BreakpointSP bkpt_sp = GetSP();
 

     sb_bp_location.SetLocation(bkpt_sp->FindLocationByID(bp_loc_id));
   }
 
-  return sb_bp_location;
+  return LLDB_RECORD_RESULT(sb_bp_location);
 }
 
 SBBreakpointLocation SBBreakpoint::GetLocationAtIndex(uint32_t index) {
+  LLDB_RECORD_METHOD(lldb::SBBreakpointLocation, SBBreakpoint,
+                     GetLocationAtIndex, (uint32_t), index);
+
   SBBreakpointLocation sb_bp_location;
   BreakpointSP bkpt_sp = GetSP();
 

     sb_bp_location.SetLocation(bkpt_sp->GetLocationAtIndex(index));
   }
 
-  return sb_bp_location;
+  return LLDB_RECORD_RESULT(sb_bp_location);
 }
 
 void SBBreakpoint::SetEnabled(bool enable) {
+  LLDB_RECORD_METHOD(void, SBBreakpoint, SetEnabled, (bool), enable);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   BreakpointSP bkpt_sp = GetSP();
 

 }
 
 bool SBBreakpoint::IsEnabled() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBBreakpoint, IsEnabled);
+
   BreakpointSP bkpt_sp = GetSP();
   if (bkpt_sp) {
     std::lock_guard<std::recursive_mutex> guard(

 }
 
 void SBBreakpoint::SetOneShot(bool one_shot) {
+  LLDB_RECORD_METHOD(void, SBBreakpoint, SetOneShot, (bool), one_shot);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   BreakpointSP bkpt_sp = GetSP();
 

 }
 
 bool SBBreakpoint::IsOneShot() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBreakpoint, IsOneShot);
+
   BreakpointSP bkpt_sp = GetSP();
   if (bkpt_sp) {
     std::lock_guard<std::recursive_mutex> guard(

 }
 
 bool SBBreakpoint::IsInternal() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBBreakpoint, IsInternal);
+
   BreakpointSP bkpt_sp = GetSP();
   if (bkpt_sp) {
     std::lock_guard<std::recursive_mutex> guard(

 }
 
 void SBBreakpoint::SetIgnoreCount(uint32_t count) {
+  LLDB_RECORD_METHOD(void, SBBreakpoint, SetIgnoreCount, (uint32_t), count);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   BreakpointSP bkpt_sp = GetSP();
 

 }
 
 void SBBreakpoint::SetCondition(const char *condition) {
+  LLDB_RECORD_METHOD(void, SBBreakpoint, SetCondition, (const char *),
+                     condition);
+
   BreakpointSP bkpt_sp = GetSP();
   if (bkpt_sp) {
     std::lock_guard<std::recursive_mutex> guard(

 }
 
 const char *SBBreakpoint::GetCondition() {
+  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBBreakpoint, GetCondition);
+
   BreakpointSP bkpt_sp = GetSP();
   if (bkpt_sp) {
     std::lock_guard<std::recursive_mutex> guard(

 }
 
 void SBBreakpoint::SetAutoContinue(bool auto_continue) {
+  LLDB_RECORD_METHOD(void, SBBreakpoint, SetAutoContinue, (bool),
+                     auto_continue);
+
   BreakpointSP bkpt_sp = GetSP();
   if (bkpt_sp) {
     std::lock_guard<std::recursive_mutex> guard(

 }
 
 bool SBBreakpoint::GetAutoContinue() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBBreakpoint, GetAutoContinue);
+
   BreakpointSP bkpt_sp = GetSP();
   if (bkpt_sp) {
     std::lock_guard<std::recursive_mutex> guard(

 }
 
 uint32_t SBBreakpoint::GetHitCount() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBBreakpoint, GetHitCount);
+
   uint32_t count = 0;
   BreakpointSP bkpt_sp = GetSP();
   if (bkpt_sp) {

 }
 
 uint32_t SBBreakpoint::GetIgnoreCount() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBBreakpoint, GetIgnoreCount);
+
   uint32_t count = 0;
   BreakpointSP bkpt_sp = GetSP();
   if (bkpt_sp) {

 }
 
 void SBBreakpoint::SetThreadID(tid_t tid) {
+  LLDB_RECORD_METHOD(void, SBBreakpoint, SetThreadID, (lldb::tid_t), tid);
+
   BreakpointSP bkpt_sp = GetSP();
   if (bkpt_sp) {
     std::lock_guard<std::recursive_mutex> guard(

 }
 
 tid_t SBBreakpoint::GetThreadID() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::tid_t, SBBreakpoint, GetThreadID);
+
   tid_t tid = LLDB_INVALID_THREAD_ID;
   BreakpointSP bkpt_sp = GetSP();
   if (bkpt_sp) {

 }
 
 void SBBreakpoint::SetThreadIndex(uint32_t index) {
+  LLDB_RECORD_METHOD(void, SBBreakpoint, SetThreadIndex, (uint32_t), index);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   BreakpointSP bkpt_sp = GetSP();
   LLDB_LOG(log, "breakpoint = {0}, index = {1}", bkpt_sp.get(), index);

 }
 
 uint32_t SBBreakpoint::GetThreadIndex() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBBreakpoint, GetThreadIndex);
+
   uint32_t thread_idx = UINT32_MAX;
   BreakpointSP bkpt_sp = GetSP();
   if (bkpt_sp) {

 }
 
 void SBBreakpoint::SetThreadName(const char *thread_name) {
+  LLDB_RECORD_METHOD(void, SBBreakpoint, SetThreadName, (const char *),
+                     thread_name);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   BreakpointSP bkpt_sp = GetSP();
   LLDB_LOG(log, "breakpoint = {0}, name = {1}", bkpt_sp.get(), thread_name);

 }
 
 const char *SBBreakpoint::GetThreadName() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBBreakpoint, GetThreadName);
+
   const char *name = nullptr;
   BreakpointSP bkpt_sp = GetSP();
   if (bkpt_sp) {

 }
 
 void SBBreakpoint::SetQueueName(const char *queue_name) {
+  LLDB_RECORD_METHOD(void, SBBreakpoint, SetQueueName, (const char *),
+                     queue_name);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   BreakpointSP bkpt_sp = GetSP();
   LLDB_LOG(log, "breakpoint = {0}, queue_name = {1}", bkpt_sp.get(),

 }
 
 const char *SBBreakpoint::GetQueueName() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBBreakpoint, GetQueueName);
+
   const char *name = nullptr;
   BreakpointSP bkpt_sp = GetSP();
   if (bkpt_sp) {

 }
 
 size_t SBBreakpoint::GetNumResolvedLocations() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(size_t, SBBreakpoint,
+                                   GetNumResolvedLocations);
+
   size_t num_resolved = 0;
   BreakpointSP bkpt_sp = GetSP();
   if (bkpt_sp) {

 }
 
 size_t SBBreakpoint::GetNumLocations() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(size_t, SBBreakpoint, GetNumLocations);
+
   BreakpointSP bkpt_sp = GetSP();
   size_t num_locs = 0;
   if (bkpt_sp) {

 }
 
 void SBBreakpoint::SetCommandLineCommands(SBStringList &commands) {
+  LLDB_RECORD_METHOD(void, SBBreakpoint, SetCommandLineCommands,
+                     (lldb::SBStringList &), commands);
+
   BreakpointSP bkpt_sp = GetSP();
   if (!bkpt_sp)
     return;

 }
 
 bool SBBreakpoint::GetCommandLineCommands(SBStringList &commands) {
+  LLDB_RECORD_METHOD(bool, SBBreakpoint, GetCommandLineCommands,
+                     (lldb::SBStringList &), commands);
+
   BreakpointSP bkpt_sp = GetSP();
   if (!bkpt_sp)
     return false;

 }
 
 bool SBBreakpoint::GetDescription(SBStream &s) {
+  LLDB_RECORD_METHOD(bool, SBBreakpoint, GetDescription, (lldb::SBStream &), 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);
+
   BreakpointSP bkpt_sp = GetSP();
   if (bkpt_sp) {
     std::lock_guard<std::recursive_mutex> guard(

   return false;
 }
 
-SBError
-SBBreakpoint::AddLocation(SBAddress &address) {
-    BreakpointSP bkpt_sp = GetSP();
-    SBError error;
-  
-    if (!address.IsValid()) {
-      error.SetErrorString("Can't add an invalid address.");
-      return error;
-    }
-  
-    if (!bkpt_sp) {
-      error.SetErrorString("No breakpoint to add a location to.");
-      return error;
-    }
-  
-    if (!llvm::isa<BreakpointResolverScripted>(bkpt_sp->GetResolver().get())) {
-      error.SetErrorString("Only a scripted resolver can add locations.");
-      return error;
-    }
-  
-    if (bkpt_sp->GetSearchFilter()->AddressPasses(address.ref()))
-      bkpt_sp->AddLocation(address.ref());
-    else
-    {
-      StreamString s;
-      address.get()->Dump(&s, &bkpt_sp->GetTarget(),
-                          Address::DumpStyleModuleWithFileAddress);
-      error.SetErrorStringWithFormat("Address: %s didn't pass the filter.",
-                                     s.GetData());
-    }
-    return error;
-}
+SBError SBBreakpoint::AddLocation(SBAddress &address) {
+  LLDB_RECORD_METHOD(lldb::SBError, SBBreakpoint, AddLocation,
+                     (lldb::SBAddress &), address);
 
+  BreakpointSP bkpt_sp = GetSP();
+  SBError error;
+
+  if (!address.IsValid()) {
+    error.SetErrorString("Can't add an invalid address.");
+    return LLDB_RECORD_RESULT(error);
+  }
+
+  if (!bkpt_sp) {
+    error.SetErrorString("No breakpoint to add a location to.");
+    return LLDB_RECORD_RESULT(error);
+  }
+
+  if (!llvm::isa<BreakpointResolverScripted>(bkpt_sp->GetResolver().get())) {
+    error.SetErrorString("Only a scripted resolver can add locations.");
+    return LLDB_RECORD_RESULT(error);
+  }
+
+  if (bkpt_sp->GetSearchFilter()->AddressPasses(address.ref()))
+    bkpt_sp->AddLocation(address.ref());
+  else {
+    StreamString s;
+    address.get()->Dump(&s, &bkpt_sp->GetTarget(),
+                        Address::DumpStyleModuleWithFileAddress);
+    error.SetErrorStringWithFormat("Address: %s didn't pass the filter.",
+                                   s.GetData());
+  }
+  return LLDB_RECORD_RESULT(error);
+}
 
 void SBBreakpoint
   ::SetCallback(SBBreakpointHitCallback callback,

 
 void SBBreakpoint::SetScriptCallbackFunction(
     const char *callback_function_name) {
+  LLDB_RECORD_METHOD(void, SBBreakpoint, SetScriptCallbackFunction,
+                     (const char *), callback_function_name);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   BreakpointSP bkpt_sp = GetSP();
   LLDB_LOG(log, "breakpoint = {0}, callback = {1}", bkpt_sp.get(),

 }
 
 SBError SBBreakpoint::SetScriptCallbackBody(const char *callback_body_text) {
+  LLDB_RECORD_METHOD(lldb::SBError, SBBreakpoint, SetScriptCallbackBody,
+                     (const char *), callback_body_text);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   BreakpointSP bkpt_sp = GetSP();
   LLDB_LOG(log, "breakpoint = {0}, callback body:\n{1}", bkpt_sp.get(),

   } else
     sb_error.SetErrorString("invalid breakpoint");
 
-  return sb_error;
+  return LLDB_RECORD_RESULT(sb_error);
 }
 
 bool SBBreakpoint::AddName(const char *new_name) {
+  LLDB_RECORD_METHOD(bool, SBBreakpoint, AddName, (const char *), new_name);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   BreakpointSP bkpt_sp = GetSP();
   LLDB_LOG(log, "breakpoint = {0}, name = {1}", bkpt_sp.get(), new_name);

 }
 
 void SBBreakpoint::RemoveName(const char *name_to_remove) {
+  LLDB_RECORD_METHOD(void, SBBreakpoint, RemoveName, (const char *),
+                     name_to_remove);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   BreakpointSP bkpt_sp = GetSP();
   LLDB_LOG(log, "breakpoint = {0}, name = {1}", bkpt_sp.get(), name_to_remove);

 }
 
 bool SBBreakpoint::MatchesName(const char *name) {
+  LLDB_RECORD_METHOD(bool, SBBreakpoint, MatchesName, (const char *), name);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   BreakpointSP bkpt_sp = GetSP();
   LLDB_LOG(log, "breakpoint = {0}, name = {1}", bkpt_sp.get(), name);

 }
 
 void SBBreakpoint::GetNames(SBStringList &names) {
+  LLDB_RECORD_METHOD(void, SBBreakpoint, GetNames, (lldb::SBStringList &),
+                     names);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   BreakpointSP bkpt_sp = GetSP();
   LLDB_LOG(log, "breakpoint = {0}", bkpt_sp.get());

 }
 
 bool SBBreakpoint::EventIsBreakpointEvent(const lldb::SBEvent &event) {
+  LLDB_RECORD_STATIC_METHOD(bool, SBBreakpoint, EventIsBreakpointEvent,
+                            (const lldb::SBEvent &), event);
+
   return Breakpoint::BreakpointEventData::GetEventDataFromEvent(event.get()) !=
          nullptr;
 }
 
 BreakpointEventType
 SBBreakpoint::GetBreakpointEventTypeFromEvent(const SBEvent &event) {
+  LLDB_RECORD_STATIC_METHOD(lldb::BreakpointEventType, SBBreakpoint,
+                            GetBreakpointEventTypeFromEvent,
+                            (const lldb::SBEvent &), event);
+
   if (event.IsValid())
     return Breakpoint::BreakpointEventData::GetBreakpointEventTypeFromEvent(
         event.GetSP());

 }
 
 SBBreakpoint SBBreakpoint::GetBreakpointFromEvent(const lldb::SBEvent &event) {
+  LLDB_RECORD_STATIC_METHOD(lldb::SBBreakpoint, SBBreakpoint,
+                            GetBreakpointFromEvent, (const lldb::SBEvent &),
+                            event);
+
   if (event.IsValid())
-    return SBBreakpoint(
-        Breakpoint::BreakpointEventData::GetBreakpointFromEvent(event.GetSP()));
-  return SBBreakpoint();
+    return LLDB_RECORD_RESULT(
+        SBBreakpoint(Breakpoint::BreakpointEventData::GetBreakpointFromEvent(
+            event.GetSP())));
+  return LLDB_RECORD_RESULT(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);
+
   SBBreakpointLocation sb_breakpoint_loc;
   if (event.IsValid())
     sb_breakpoint_loc.SetLocation(
         Breakpoint::BreakpointEventData::GetBreakpointLocationAtIndexFromEvent(
             event.GetSP(), loc_idx));
-  return sb_breakpoint_loc;
+  return LLDB_RECORD_RESULT(sb_breakpoint_loc);
 }
 
 uint32_t
 SBBreakpoint::GetNumBreakpointLocationsFromEvent(const lldb::SBEvent &event) {
+  LLDB_RECORD_STATIC_METHOD(uint32_t, SBBreakpoint,
+                            GetNumBreakpointLocationsFromEvent,
+                            (const lldb::SBEvent &), event);
+
   uint32_t num_locations = 0;
   if (event.IsValid())
     num_locations =

 }
 
 bool SBBreakpoint::IsHardware() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBreakpoint, IsHardware);
+
   BreakpointSP bkpt_sp = GetSP();
   if (bkpt_sp)
     return bkpt_sp->IsHardware();

 };
 
 SBBreakpointList::SBBreakpointList(SBTarget &target)
-    : m_opaque_sp(new SBBreakpointListImpl(target.GetSP())) {}
+    : m_opaque_sp(new SBBreakpointListImpl(target.GetSP())) {
+  LLDB_RECORD_CONSTRUCTOR(SBBreakpointList, (lldb::SBTarget &), target);
+}
 
 SBBreakpointList::~SBBreakpointList() {}
 
 size_t SBBreakpointList::GetSize() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(size_t, SBBreakpointList, GetSize);
+
   if (!m_opaque_sp)
     return 0;
   else

 }
 
 SBBreakpoint SBBreakpointList::GetBreakpointAtIndex(size_t idx) {
+  LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBBreakpointList, GetBreakpointAtIndex,
+                     (size_t), idx);
+
   if (!m_opaque_sp)
-    return SBBreakpoint();
+    return LLDB_RECORD_RESULT(SBBreakpoint());
 
   BreakpointSP bkpt_sp = m_opaque_sp->GetBreakpointAtIndex(idx);
-  return SBBreakpoint(bkpt_sp);
+  return LLDB_RECORD_RESULT(SBBreakpoint(bkpt_sp));
 }
 
 SBBreakpoint SBBreakpointList::FindBreakpointByID(lldb::break_id_t id) {
+  LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBBreakpointList, FindBreakpointByID,
+                     (lldb::break_id_t), id);
+
   if (!m_opaque_sp)
-    return SBBreakpoint();
+    return LLDB_RECORD_RESULT(SBBreakpoint());
   BreakpointSP bkpt_sp = m_opaque_sp->FindBreakpointByID(id);
-  return SBBreakpoint(bkpt_sp);
+  return LLDB_RECORD_RESULT(SBBreakpoint(bkpt_sp));
 }
 
 void SBBreakpointList::Append(const SBBreakpoint &sb_bkpt) {
+  LLDB_RECORD_METHOD(void, SBBreakpointList, Append,
+                     (const lldb::SBBreakpoint &), sb_bkpt);
+
   if (!sb_bkpt.IsValid())
     return;
   if (!m_opaque_sp)

 }
 
 void SBBreakpointList::AppendByID(lldb::break_id_t id) {
+  LLDB_RECORD_METHOD(void, SBBreakpointList, AppendByID, (lldb::break_id_t),
+                     id);
+
   if (!m_opaque_sp)
     return;
   m_opaque_sp->AppendByID(id);
 }
 
 bool SBBreakpointList::AppendIfUnique(const SBBreakpoint &sb_bkpt) {
+  LLDB_RECORD_METHOD(bool, SBBreakpointList, AppendIfUnique,
+                     (const lldb::SBBreakpoint &), sb_bkpt);
+
   if (!sb_bkpt.IsValid())
     return false;
   if (!m_opaque_sp)

 }
 
 void SBBreakpointList::Clear() {
+  LLDB_RECORD_METHOD_NO_ARGS(void, SBBreakpointList, Clear);
+
   if (m_opaque_sp)
     m_opaque_sp->Clear();
 }

lldb/source/API/SBBreakpointLocation.cpp

 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBBreakpointLocation.h"
+#include "SBReproducerPrivate.h"
 #include "lldb/API/SBAddress.h"
 #include "lldb/API/SBDebugger.h"
 #include "lldb/API/SBDefines.h"

 using namespace lldb;
 using namespace lldb_private;
 
-SBBreakpointLocation::SBBreakpointLocation() {}
+SBBreakpointLocation::SBBreakpointLocation() {
+  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBBreakpointLocation);
+}
 
 SBBreakpointLocation::SBBreakpointLocation(
     const lldb::BreakpointLocationSP &break_loc_sp)
     : m_opaque_wp(break_loc_sp) {
+  LLDB_RECORD_CONSTRUCTOR(SBBreakpointLocation,
+                          (const lldb::BreakpointLocationSP &), break_loc_sp);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   if (log) {

 }
 
 SBBreakpointLocation::SBBreakpointLocation(const SBBreakpointLocation &rhs)
-    : m_opaque_wp(rhs.m_opaque_wp) {}
+    : m_opaque_wp(rhs.m_opaque_wp) {
+  LLDB_RECORD_CONSTRUCTOR(SBBreakpointLocation,
+                          (const lldb::SBBreakpointLocation &), rhs);
+}
 
 const SBBreakpointLocation &SBBreakpointLocation::
 operator=(const SBBreakpointLocation &rhs) {
+  LLDB_RECORD_METHOD(
+      const lldb::SBBreakpointLocation &,
+      SBBreakpointLocation, operator=,(const lldb::SBBreakpointLocation &),
+      rhs);
+
   m_opaque_wp = rhs.m_opaque_wp;
   return *this;
 }

   return m_opaque_wp.lock();
 }
 
-bool SBBreakpointLocation::IsValid() const { return bool(GetSP()); }
+bool SBBreakpointLocation::IsValid() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBreakpointLocation, IsValid);
+
+  return bool(GetSP());
+}
 
 SBAddress SBBreakpointLocation::GetAddress() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBAddress, SBBreakpointLocation, GetAddress);
+
   BreakpointLocationSP loc_sp = GetSP();
-  if (loc_sp)
-    return SBAddress(&loc_sp->GetAddress());
-  else
-    return SBAddress();
+  if (loc_sp) {
+    return LLDB_RECORD_RESULT(SBAddress(&loc_sp->GetAddress()));
+  }
+
+  return LLDB_RECORD_RESULT(SBAddress());
 }
 
 addr_t SBBreakpointLocation::GetLoadAddress() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::addr_t, SBBreakpointLocation,
+                             GetLoadAddress);
+
   addr_t ret_addr = LLDB_INVALID_ADDRESS;
   BreakpointLocationSP loc_sp = GetSP();
 

 }
 
 void SBBreakpointLocation::SetEnabled(bool enabled) {
+  LLDB_RECORD_METHOD(void, SBBreakpointLocation, SetEnabled, (bool), enabled);
+
   BreakpointLocationSP loc_sp = GetSP();
   if (loc_sp) {
     std::lock_guard<std::recursive_mutex> guard(

 }
 
 bool SBBreakpointLocation::IsEnabled() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBBreakpointLocation, IsEnabled);
+
   BreakpointLocationSP loc_sp = GetSP();
   if (loc_sp) {
     std::lock_guard<std::recursive_mutex> guard(

 }
 
 uint32_t SBBreakpointLocation::GetHitCount() {
+  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBBreakpointLocation, GetHitCount);
+
   BreakpointLocationSP loc_sp = GetSP();
   if (loc_sp) {
     std::lock_guard<std::recursive_mutex> guard(

 }
 
 uint32_t SBBreakpointLocation::GetIgnoreCount() {
+  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBBreakpointLocation, GetIgnoreCount);
+
   BreakpointLocationSP loc_sp = GetSP();
   if (loc_sp) {
     std::lock_guard<std::recursive_mutex> guard(

 }
 
 void SBBreakpointLocation::SetIgnoreCount(uint32_t n) {
+  LLDB_RECORD_METHOD(void, SBBreakpointLocation, SetIgnoreCount, (uint32_t), n);
+
   BreakpointLocationSP loc_sp = GetSP();
   if (loc_sp) {
     std::lock_guard<std::recursive_mutex> guard(

 }
 
 void SBBreakpointLocation::SetCondition(const char *condition) {
+  LLDB_RECORD_METHOD(void, SBBreakpointLocation, SetCondition, (const char *),
+                     condition);
+
   BreakpointLocationSP loc_sp = GetSP();
   if (loc_sp) {
     std::lock_guard<std::recursive_mutex> guard(

 }
 
 const char *SBBreakpointLocation::GetCondition() {
+  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBBreakpointLocation, GetCondition);
+
   BreakpointLocationSP loc_sp = GetSP();
   if (loc_sp) {
     std::lock_guard<std::recursive_mutex> guard(

 }
 
 void SBBreakpointLocation::SetAutoContinue(bool auto_continue) {
+  LLDB_RECORD_METHOD(void, SBBreakpointLocation, SetAutoContinue, (bool),
+                     auto_continue);
+
   BreakpointLocationSP loc_sp = GetSP();
   if (loc_sp) {
     std::lock_guard<std::recursive_mutex> guard(

 }
 
 bool SBBreakpointLocation::GetAutoContinue() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBBreakpointLocation, GetAutoContinue);
+
   BreakpointLocationSP loc_sp = GetSP();
   if (loc_sp) {
     std::lock_guard<std::recursive_mutex> guard(

 
 void SBBreakpointLocation::SetScriptCallbackFunction(
     const char *callback_function_name) {
+  LLDB_RECORD_METHOD(void, SBBreakpointLocation, SetScriptCallbackFunction,
+                     (const char *), callback_function_name);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   BreakpointLocationSP loc_sp = GetSP();
   LLDB_LOG(log, "location = {0}, callback = {1}", loc_sp.get(),

 
 SBError
 SBBreakpointLocation::SetScriptCallbackBody(const char *callback_body_text) {
+  LLDB_RECORD_METHOD(lldb::SBError, SBBreakpointLocation, SetScriptCallbackBody,
+                     (const char *), callback_body_text);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   BreakpointLocationSP loc_sp = GetSP();
   LLDB_LOG(log, "location = {0}: callback body:\n{1}", loc_sp.get(),

   } else
     sb_error.SetErrorString("invalid breakpoint");
 
-  return sb_error;
+  return LLDB_RECORD_RESULT(sb_error);
 }
 
 void SBBreakpointLocation::SetCommandLineCommands(SBStringList &commands) {
+  LLDB_RECORD_METHOD(void, SBBreakpointLocation, SetCommandLineCommands,
+                     (lldb::SBStringList &), commands);
+
   BreakpointLocationSP loc_sp = GetSP();
   if (!loc_sp)
     return;

 }
 
 bool SBBreakpointLocation::GetCommandLineCommands(SBStringList &commands) {
+  LLDB_RECORD_METHOD(bool, SBBreakpointLocation, GetCommandLineCommands,
+                     (lldb::SBStringList &), commands);
+
   BreakpointLocationSP loc_sp = GetSP();
   if (!loc_sp)
     return false;

 }
 
 void SBBreakpointLocation::SetThreadID(tid_t thread_id) {
+  LLDB_RECORD_METHOD(void, SBBreakpointLocation, SetThreadID, (lldb::tid_t),
+                     thread_id);
+
   BreakpointLocationSP loc_sp = GetSP();
   if (loc_sp) {
     std::lock_guard<std::recursive_mutex> guard(

 }
 
 tid_t SBBreakpointLocation::GetThreadID() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::tid_t, SBBreakpointLocation, GetThreadID);
+
   tid_t tid = LLDB_INVALID_THREAD_ID;
   BreakpointLocationSP loc_sp = GetSP();
   if (loc_sp) {

 }
 
 void SBBreakpointLocation::SetThreadIndex(uint32_t index) {
+  LLDB_RECORD_METHOD(void, SBBreakpointLocation, SetThreadIndex, (uint32_t),
+                     index);
+
   BreakpointLocationSP loc_sp = GetSP();
   if (loc_sp) {
     std::lock_guard<std::recursive_mutex> guard(

 }
 
 uint32_t SBBreakpointLocation::GetThreadIndex() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBBreakpointLocation,
+                                   GetThreadIndex);
+
   uint32_t thread_idx = UINT32_MAX;
   BreakpointLocationSP loc_sp = GetSP();
   if (loc_sp) {

 }
 
 void SBBreakpointLocation::SetThreadName(const char *thread_name) {
+  LLDB_RECORD_METHOD(void, SBBreakpointLocation, SetThreadName, (const char *),
+                     thread_name);
+
   BreakpointLocationSP loc_sp = GetSP();
   if (loc_sp) {
     std::lock_guard<std::recursive_mutex> guard(

 }
 
 const char *SBBreakpointLocation::GetThreadName() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBBreakpointLocation,
+                                   GetThreadName);
+
   BreakpointLocationSP loc_sp = GetSP();
   if (loc_sp) {
     std::lock_guard<std::recursive_mutex> guard(

 }
 
 void SBBreakpointLocation::SetQueueName(const char *queue_name) {
+  LLDB_RECORD_METHOD(void, SBBreakpointLocation, SetQueueName, (const char *),
+                     queue_name);
+
   BreakpointLocationSP loc_sp = GetSP();
   if (loc_sp) {
     std::lock_guard<std::recursive_mutex> guard(

 }
 
 const char *SBBreakpointLocation::GetQueueName() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBBreakpointLocation,
+                                   GetQueueName);
+
   BreakpointLocationSP loc_sp = GetSP();
   if (loc_sp) {
     std::lock_guard<std::recursive_mutex> guard(

 }
 
 bool SBBreakpointLocation::IsResolved() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBBreakpointLocation, IsResolved);
+
   BreakpointLocationSP loc_sp = GetSP();
   if (loc_sp) {
     std::lock_guard<std::recursive_mutex> guard(

 
 bool SBBreakpointLocation::GetDescription(SBStream &description,
                                           DescriptionLevel level) {
+  LLDB_RECORD_METHOD(bool, SBBreakpointLocation, GetDescription,
+                     (lldb::SBStream &, lldb::DescriptionLevel), description,
+                     level);
+
   Stream &strm = description.ref();
   BreakpointLocationSP loc_sp = GetSP();
 

 }
 
 break_id_t SBBreakpointLocation::GetID() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::break_id_t, SBBreakpointLocation, GetID);
+
   BreakpointLocationSP loc_sp = GetSP();
   if (loc_sp) {
     std::lock_guard<std::recursive_mutex> guard(

 }
 
 SBBreakpoint SBBreakpointLocation::GetBreakpoint() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBBreakpoint, SBBreakpointLocation,
+                             GetBreakpoint);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   BreakpointLocationSP loc_sp = GetSP();
 

     LLDB_LOG(log, "location = {0}, breakpoint = {1} ({2})", loc_sp.get(),
              sb_bp.GetSP().get(), sstr.GetData());
   }
-  return sb_bp;
+  return LLDB_RECORD_RESULT(sb_bp);
 }

lldb/source/API/SBBreakpointName.cpp

 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBBreakpointName.h"
+#include "SBReproducerPrivate.h"
 #include "lldb/API/SBDebugger.h"
 #include "lldb/API/SBError.h"
 #include "lldb/API/SBStream.h"

 
 } // namespace lldb
 
-SBBreakpointName::SBBreakpointName() {}
+SBBreakpointName::SBBreakpointName() {
+  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBBreakpointName);
+}
+
+SBBreakpointName::SBBreakpointName(SBTarget &sb_target, const char *name) {
+  LLDB_RECORD_CONSTRUCTOR(SBBreakpointName, (lldb::SBTarget &, const char *),
+                          sb_target, name);
 
-SBBreakpointName::SBBreakpointName(SBTarget &sb_target, const char *name)
-{
   m_impl_up.reset(new SBBreakpointNameImpl(sb_target, name));
   // Call FindBreakpointName here to make sure the name is valid, reset if not:
   BreakpointName *bp_name = GetBreakpointName();

     m_impl_up.reset();
 }
 
-SBBreakpointName::SBBreakpointName(SBBreakpoint &sb_bkpt, const char *name)
-{
+SBBreakpointName::SBBreakpointName(SBBreakpoint &sb_bkpt, const char *name) {
+  LLDB_RECORD_CONSTRUCTOR(SBBreakpointName,
+                          (lldb::SBBreakpoint &, const char *), sb_bkpt, name);
+
   if (!sb_bkpt.IsValid()) {
     m_impl_up.reset();
     return;

                                  BreakpointName::Permissions());
 }
 
-SBBreakpointName::SBBreakpointName(const SBBreakpointName &rhs)
-{
+SBBreakpointName::SBBreakpointName(const SBBreakpointName &rhs) {
+  LLDB_RECORD_CONSTRUCTOR(SBBreakpointName, (const lldb::SBBreakpointName &),
+                          rhs);
+
   if (!rhs.m_impl_up)
     return;
   else

 
 SBBreakpointName::~SBBreakpointName() = default;
 
-const SBBreakpointName &SBBreakpointName::operator=(const SBBreakpointName &rhs) 
-{
+const SBBreakpointName &SBBreakpointName::
+operator=(const SBBreakpointName &rhs) {
+  LLDB_RECORD_METHOD(
+      const lldb::SBBreakpointName &,
+      SBBreakpointName, operator=,(const lldb::SBBreakpointName &), rhs);
+
   if (!rhs.m_impl_up) {
     m_impl_up.reset();
     return *this;

 }
 
 bool SBBreakpointName::operator==(const lldb::SBBreakpointName &rhs) {
+  LLDB_RECORD_METHOD(
+      bool, SBBreakpointName, operator==,(const lldb::SBBreakpointName &), 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);
+
   return *m_impl_up != *rhs.m_impl_up;
 }
 
 bool SBBreakpointName::IsValid() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBreakpointName, IsValid);
+
   if (!m_impl_up)
     return false;
   return m_impl_up->IsValid();
 }
 
 const char *SBBreakpointName::GetName() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBBreakpointName, GetName);
+
   if (!m_impl_up)
     return "<Invalid Breakpoint Name Object>";
   return m_impl_up->GetName();
 }
 
 void SBBreakpointName::SetEnabled(bool enable) {
+  LLDB_RECORD_METHOD(void, SBBreakpointName, SetEnabled, (bool), enable);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   
   BreakpointName *bp_name = GetBreakpointName();

 }
 
 bool SBBreakpointName::IsEnabled() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBBreakpointName, IsEnabled);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   
   BreakpointName *bp_name = GetBreakpointName();

 }
 
 void SBBreakpointName::SetOneShot(bool one_shot) {
+  LLDB_RECORD_METHOD(void, SBBreakpointName, SetOneShot, (bool), one_shot);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   
   BreakpointName *bp_name = GetBreakpointName();

 }
 
 bool SBBreakpointName::IsOneShot() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBreakpointName, IsOneShot);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   
   const BreakpointName *bp_name = GetBreakpointName();

 }
 
 void SBBreakpointName::SetIgnoreCount(uint32_t count) {
+  LLDB_RECORD_METHOD(void, SBBreakpointName, SetIgnoreCount, (uint32_t), count);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   
   BreakpointName *bp_name = GetBreakpointName();

 }
 
 uint32_t SBBreakpointName::GetIgnoreCount() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBBreakpointName, GetIgnoreCount);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   
   BreakpointName *bp_name = GetBreakpointName();

 }
 
 void SBBreakpointName::SetCondition(const char *condition) {
+  LLDB_RECORD_METHOD(void, SBBreakpointName, SetCondition, (const char *),
+                     condition);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   
   BreakpointName *bp_name = GetBreakpointName();

 }
 
 const char *SBBreakpointName::GetCondition() {
+  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBBreakpointName, GetCondition);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   
   BreakpointName *bp_name = GetBreakpointName();

 }
 
 void SBBreakpointName::SetAutoContinue(bool auto_continue) {
+  LLDB_RECORD_METHOD(void, SBBreakpointName, SetAutoContinue, (bool),
+                     auto_continue);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   
   BreakpointName *bp_name = GetBreakpointName();

 }
 
 bool SBBreakpointName::GetAutoContinue() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBBreakpointName, GetAutoContinue);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   
   BreakpointName *bp_name = GetBreakpointName();

 }
 
 void SBBreakpointName::SetThreadID(tid_t tid) {
+  LLDB_RECORD_METHOD(void, SBBreakpointName, SetThreadID, (lldb::tid_t), tid);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   
   BreakpointName *bp_name = GetBreakpointName();

 }
 
 tid_t SBBreakpointName::GetThreadID() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::tid_t, SBBreakpointName, GetThreadID);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   
   BreakpointName *bp_name = GetBreakpointName();

 }
 
 void SBBreakpointName::SetThreadIndex(uint32_t index) {
+  LLDB_RECORD_METHOD(void, SBBreakpointName, SetThreadIndex, (uint32_t), index);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   
   BreakpointName *bp_name = GetBreakpointName();

 }
 
 uint32_t SBBreakpointName::GetThreadIndex() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBBreakpointName, GetThreadIndex);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   
   BreakpointName *bp_name = GetBreakpointName();

 }
 
 void SBBreakpointName::SetThreadName(const char *thread_name) {
+  LLDB_RECORD_METHOD(void, SBBreakpointName, SetThreadName, (const char *),
+                     thread_name);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   
   BreakpointName *bp_name = GetBreakpointName();

 }
 
 const char *SBBreakpointName::GetThreadName() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBBreakpointName,
+                                   GetThreadName);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   
   BreakpointName *bp_name = GetBreakpointName();

 }
 
 void SBBreakpointName::SetQueueName(const char *queue_name) {
+  LLDB_RECORD_METHOD(void, SBBreakpointName, SetQueueName, (const char *),
+                     queue_name);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   
   BreakpointName *bp_name = GetBreakpointName();

 }
 
 const char *SBBreakpointName::GetQueueName() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBBreakpointName,
+                                   GetQueueName);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   
   BreakpointName *bp_name = GetBreakpointName();

 }
 
 void SBBreakpointName::SetCommandLineCommands(SBStringList &commands) {
+  LLDB_RECORD_METHOD(void, SBBreakpointName, SetCommandLineCommands,
+                     (lldb::SBStringList &), commands);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   BreakpointName *bp_name = GetBreakpointName();
   if (!bp_name)

 }
 
 bool SBBreakpointName::GetCommandLineCommands(SBStringList &commands) {
+  LLDB_RECORD_METHOD(bool, SBBreakpointName, GetCommandLineCommands,
+                     (lldb::SBStringList &), commands);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   
   BreakpointName *bp_name = GetBreakpointName();

 }
 
 const char *SBBreakpointName::GetHelpString() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBBreakpointName,
+                                   GetHelpString);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   
   BreakpointName *bp_name = GetBreakpointName();

 }
 
 void SBBreakpointName::SetHelpString(const char *help_string) {
+  LLDB_RECORD_METHOD(void, SBBreakpointName, SetHelpString, (const char *),
+                     help_string);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   BreakpointName *bp_name = GetBreakpointName();
   if (!bp_name)

 }
 
 bool SBBreakpointName::GetDescription(SBStream &s) {
+  LLDB_RECORD_METHOD(bool, SBBreakpointName, GetDescription, (lldb::SBStream &),
+                     s);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   
   BreakpointName *bp_name = GetBreakpointName();

 
 void SBBreakpointName::SetScriptCallbackFunction(
     const char *callback_function_name) {
+  LLDB_RECORD_METHOD(void, SBBreakpointName, SetScriptCallbackFunction,
+                     (const char *), callback_function_name);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   
   BreakpointName *bp_name = GetBreakpointName();

   UpdateName(*bp_name);
 }
 
-SBError SBBreakpointName::SetScriptCallbackBody(const char *callback_body_text)
-{
+SBError
+SBBreakpointName::SetScriptCallbackBody(const char *callback_body_text) {
+  LLDB_RECORD_METHOD(lldb::SBError, SBBreakpointName, SetScriptCallbackBody,
+                     (const char *), callback_body_text);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   SBError sb_error;
   BreakpointName *bp_name = GetBreakpointName();
   if (!bp_name)
-    return sb_error;
- 
+    return LLDB_RECORD_RESULT(sb_error);
   LLDB_LOG(log, "Name: {0} callback: {1}\n", bp_name->GetName(),
            callback_body_text);
   

   if (!sb_error.Fail())
     UpdateName(*bp_name);
 
-  return sb_error;
+  return LLDB_RECORD_RESULT(sb_error);
 }
 
-bool SBBreakpointName::GetAllowList() const
-{
+bool SBBreakpointName::GetAllowList() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBreakpointName, GetAllowList);
+
   BreakpointName *bp_name = GetBreakpointName();
   if (!bp_name)
     return false;
   return bp_name->GetPermissions().GetAllowList();
 }
 
-void SBBreakpointName::SetAllowList(bool value)
-{
+void SBBreakpointName::SetAllowList(bool value) {
+  LLDB_RECORD_METHOD(void, SBBreakpointName, SetAllowList, (bool), value);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   BreakpointName *bp_name = GetBreakpointName();

                 bp_name->GetName().AsCString());
   bp_name->GetPermissions().SetAllowList(value);
 }
-  
-bool SBBreakpointName::GetAllowDelete()
-{
+bool SBBreakpointName::GetAllowDelete() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBBreakpointName, GetAllowDelete);
+
   BreakpointName *bp_name = GetBreakpointName();
   if (!bp_name)
     return false;
   return bp_name->GetPermissions().GetAllowDelete();
 }
 
-void SBBreakpointName::SetAllowDelete(bool value)
-{
+void SBBreakpointName::SetAllowDelete(bool value) {
+  LLDB_RECORD_METHOD(void, SBBreakpointName, SetAllowDelete, (bool), value);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   BreakpointName *bp_name = GetBreakpointName();

                 bp_name->GetName().AsCString());
   bp_name->GetPermissions().SetAllowDelete(value);
 }
-  
-bool SBBreakpointName::GetAllowDisable()
-{
+bool SBBreakpointName::GetAllowDisable() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBBreakpointName, GetAllowDisable);
+
   BreakpointName *bp_name = GetBreakpointName();
   if (!bp_name)
     return false;
   return bp_name->GetPermissions().GetAllowDisable();
 }
 
-void SBBreakpointName::SetAllowDisable(bool value)
-{
+void SBBreakpointName::SetAllowDisable(bool value) {
+  LLDB_RECORD_METHOD(void, SBBreakpointName, SetAllowDisable, (bool), value);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   BreakpointName *bp_name = GetBreakpointName();

lldb/source/API/SBBroadcaster.cpp

 //
 //===----------------------------------------------------------------------===//
 
+#include "SBReproducerPrivate.h"
 #include "lldb/Utility/Broadcaster.h"
 #include "lldb/Utility/Log.h"
 

 using namespace lldb;
 using namespace lldb_private;
 
-SBBroadcaster::SBBroadcaster() : m_opaque_sp(), m_opaque_ptr(NULL) {}
+SBBroadcaster::SBBroadcaster() : m_opaque_sp(), m_opaque_ptr(NULL) {
+  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBBroadcaster);
+}
 
 SBBroadcaster::SBBroadcaster(const char *name)
     : m_opaque_sp(new Broadcaster(NULL, name)), m_opaque_ptr(NULL) {
+  LLDB_RECORD_CONSTRUCTOR(SBBroadcaster, (const char *), name);
+
   m_opaque_ptr = m_opaque_sp.get();
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   LLDB_LOGV(log, "(name=\"{0}\") => SBBroadcaster({1})", name, m_opaque_ptr);

 }
 
 SBBroadcaster::SBBroadcaster(const SBBroadcaster &rhs)
-    : m_opaque_sp(rhs.m_opaque_sp), m_opaque_ptr(rhs.m_opaque_ptr) {}
+    : m_opaque_sp(rhs.m_opaque_sp), m_opaque_ptr(rhs.m_opaque_ptr) {
+  LLDB_RECORD_CONSTRUCTOR(SBBroadcaster, (const lldb::SBBroadcaster &), rhs);
+}
 
 const SBBroadcaster &SBBroadcaster::operator=(const SBBroadcaster &rhs) {
+  LLDB_RECORD_METHOD(const lldb::SBBroadcaster &,
+                     SBBroadcaster, operator=,(const lldb::SBBroadcaster &),
+                     rhs);
+
   if (this != &rhs) {
     m_opaque_sp = rhs.m_opaque_sp;
     m_opaque_ptr = rhs.m_opaque_ptr;

 SBBroadcaster::~SBBroadcaster() { reset(NULL, false); }
 
 void SBBroadcaster::BroadcastEventByType(uint32_t event_type, bool unique) {
+  LLDB_RECORD_METHOD(void, SBBroadcaster, BroadcastEventByType,
+                     (uint32_t, bool), event_type, unique);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   if (log)

 }
 
 void SBBroadcaster::BroadcastEvent(const SBEvent &event, bool unique) {
+  LLDB_RECORD_METHOD(void, SBBroadcaster, BroadcastEvent,
+                     (const lldb::SBEvent &, bool), event, unique);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   if (log)

 
 void SBBroadcaster::AddInitialEventsToListener(const SBListener &listener,
                                                uint32_t requested_events) {
+  LLDB_RECORD_METHOD(void, SBBroadcaster, AddInitialEventsToListener,
+                     (const lldb::SBListener &, uint32_t), listener,
+                     requested_events);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   if (log)
     log->Printf("SBBroadcaster(%p)::AddInitialEventsToListener "

 
 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);
+
   if (m_opaque_ptr)
     return m_opaque_ptr->AddListener(listener.m_opaque_sp, event_mask);
   return 0;
 }
 
 const char *SBBroadcaster::GetName() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBBroadcaster, GetName);
+
   if (m_opaque_ptr)
     return m_opaque_ptr->GetBroadcasterName().GetCString();
   return NULL;
 }
 
 bool SBBroadcaster::EventTypeHasListeners(uint32_t event_type) {
+  LLDB_RECORD_METHOD(bool, SBBroadcaster, EventTypeHasListeners, (uint32_t),
+                     event_type);
+
   if (m_opaque_ptr)
     return m_opaque_ptr->EventTypeHasListeners(event_type);
   return false;

 
 bool SBBroadcaster::RemoveListener(const SBListener &listener,
                                    uint32_t event_mask) {
+  LLDB_RECORD_METHOD(bool, SBBroadcaster, RemoveListener,
+                     (const lldb::SBListener &, uint32_t), listener,
+                     event_mask);
+
   if (m_opaque_ptr)
     return m_opaque_ptr->RemoveListener(listener.m_opaque_sp, event_mask);
   return false;

   m_opaque_ptr = broadcaster;
 }
 
-bool SBBroadcaster::IsValid() const { return m_opaque_ptr != NULL; }
+bool SBBroadcaster::IsValid() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBroadcaster, IsValid);
+
+  return m_opaque_ptr != NULL;
+}
 
 void SBBroadcaster::Clear() {
+  LLDB_RECORD_METHOD_NO_ARGS(void, SBBroadcaster, Clear);
+
   m_opaque_sp.reset();
   m_opaque_ptr = NULL;
 }
 
 bool SBBroadcaster::operator==(const SBBroadcaster &rhs) const {
+  LLDB_RECORD_METHOD_CONST(
+      bool, SBBroadcaster, operator==,(const lldb::SBBroadcaster &), 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);
+
   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);
+
   return m_opaque_ptr < rhs.m_opaque_ptr;
 }

lldb/source/API/SBCommandInterpreter.cpp

 
 #include "lldb/lldb-types.h"
 
+#include "SBReproducerPrivate.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Interpreter/CommandObjectMultiword.h"
 #include "lldb/Interpreter/CommandReturnObject.h"

 using namespace lldb_private;
 
 SBCommandInterpreterRunOptions::SBCommandInterpreterRunOptions() {
+  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBCommandInterpreterRunOptions);
+
   m_opaque_up.reset(new CommandInterpreterRunOptions());
 }
 
 SBCommandInterpreterRunOptions::~SBCommandInterpreterRunOptions() = default;
 
 bool SBCommandInterpreterRunOptions::GetStopOnContinue() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions,
+                                   GetStopOnContinue);
+
   return m_opaque_up->GetStopOnContinue();
 }
 
 void SBCommandInterpreterRunOptions::SetStopOnContinue(bool stop_on_continue) {
+  LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions, SetStopOnContinue,
+                     (bool), stop_on_continue);
+
   m_opaque_up->SetStopOnContinue(stop_on_continue);
 }
 
 bool SBCommandInterpreterRunOptions::GetStopOnError() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions,
+                                   GetStopOnError);
+
   return m_opaque_up->GetStopOnError();
 }
 
 void SBCommandInterpreterRunOptions::SetStopOnError(bool stop_on_error) {
+  LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions, SetStopOnError,
+                     (bool), stop_on_error);
+
   m_opaque_up->SetStopOnError(stop_on_error);
 }
 
 bool SBCommandInterpreterRunOptions::GetStopOnCrash() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions,
+                                   GetStopOnCrash);
+
   return m_opaque_up->GetStopOnCrash();
 }
 
 void SBCommandInterpreterRunOptions::SetStopOnCrash(bool stop_on_crash) {
+  LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions, SetStopOnCrash,
+                     (bool), stop_on_crash);
+
   m_opaque_up->SetStopOnCrash(stop_on_crash);
 }
 
 bool SBCommandInterpreterRunOptions::GetEchoCommands() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions,
+                                   GetEchoCommands);
+
   return m_opaque_up->GetEchoCommands();
 }
 
 void SBCommandInterpreterRunOptions::SetEchoCommands(bool echo_commands) {
+  LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions, SetEchoCommands,
+                     (bool), echo_commands);
+
   m_opaque_up->SetEchoCommands(echo_commands);
 }
 
 bool SBCommandInterpreterRunOptions::GetEchoCommentCommands() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions,
+                                   GetEchoCommentCommands);
+
   return m_opaque_up->GetEchoCommentCommands();
 }
 
 void SBCommandInterpreterRunOptions::SetEchoCommentCommands(bool echo) {
+  LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions,
+                     SetEchoCommentCommands, (bool), echo);
+
   m_opaque_up->SetEchoCommentCommands(echo);
 }
 
 bool SBCommandInterpreterRunOptions::GetPrintResults() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions,
+                                   GetPrintResults);
+
   return m_opaque_up->GetPrintResults();
 }
 
 void SBCommandInterpreterRunOptions::SetPrintResults(bool print_results) {
+  LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions, SetPrintResults,
+                     (bool), print_results);
+
   m_opaque_up->SetPrintResults(print_results);
 }
 
 bool SBCommandInterpreterRunOptions::GetAddToHistory() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions,
+                                   GetAddToHistory);
+
   return m_opaque_up->GetAddToHistory();
 }
 
 void SBCommandInterpreterRunOptions::SetAddToHistory(bool add_to_history) {
+  LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions, SetAddToHistory,
+                     (bool), add_to_history);
+
   m_opaque_up->SetAddToHistory(add_to_history);
 }
 

 
 SBCommandInterpreter::SBCommandInterpreter(CommandInterpreter *interpreter)
     : m_opaque_ptr(interpreter) {
+  LLDB_RECORD_CONSTRUCTOR(SBCommandInterpreter,
+                          (lldb_private::CommandInterpreter *), interpreter);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   if (log)

 }
 
 SBCommandInterpreter::SBCommandInterpreter(const SBCommandInterpreter &rhs)
-    : m_opaque_ptr(rhs.m_opaque_ptr) {}
+    : m_opaque_ptr(rhs.m_opaque_ptr) {
+  LLDB_RECORD_CONSTRUCTOR(SBCommandInterpreter,
+                          (const lldb::SBCommandInterpreter &), rhs);
+}
 
 SBCommandInterpreter::~SBCommandInterpreter() = default;
 
 const SBCommandInterpreter &SBCommandInterpreter::
 operator=(const SBCommandInterpreter &rhs) {
+  LLDB_RECORD_METHOD(
+      const lldb::SBCommandInterpreter &,
+      SBCommandInterpreter, operator=,(const lldb::SBCommandInterpreter &),
+      rhs);
+
   m_opaque_ptr = rhs.m_opaque_ptr;
   return *this;
 }
 
-bool SBCommandInterpreter::IsValid() const { return m_opaque_ptr != nullptr; }
+bool SBCommandInterpreter::IsValid() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreter, IsValid);
+
+  return m_opaque_ptr != nullptr;
+}
 
 bool SBCommandInterpreter::CommandExists(const char *cmd) {
+  LLDB_RECORD_METHOD(bool, SBCommandInterpreter, CommandExists, (const char *),
+                     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);
+
   return (((cmd != nullptr) && IsValid()) ? m_opaque_ptr->AliasExists(cmd)
                                           : false);
 }
 
 bool SBCommandInterpreter::IsActive() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommandInterpreter, IsActive);
+
   return (IsValid() ? m_opaque_ptr->IsActive() : false);
 }
 
 bool SBCommandInterpreter::WasInterrupted() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreter, WasInterrupted);
+
   return (IsValid() ? m_opaque_ptr->WasInterrupted() : false);
 }
 
 const char *SBCommandInterpreter::GetIOHandlerControlSequence(char ch) {
+  LLDB_RECORD_METHOD(const char *, SBCommandInterpreter,
+                     GetIOHandlerControlSequence, (char), ch);
+
   return (IsValid()
               ? m_opaque_ptr->GetDebugger()
                     .GetTopIOHandlerControlSequence(ch)

 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);
+
   SBExecutionContext sb_exe_ctx;
   return HandleCommand(command_line, sb_exe_ctx, result, add_to_history);
 }

 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);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   if (log)

     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);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   if (log) {

 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,
+                     max_return_elements, matches);
+
   SBStringList dummy_descriptions;
   return HandleCompletionWithDescriptions(
       current_line, cursor, last_char, match_start_point, max_return_elements,

     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,
+                     max_return_elements, matches, descriptions);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   int num_completions = 0;
 

     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,
+                     max_return_elements, matches, descriptions);
+
   const char *cursor = current_line + cursor_pos;
   const char *last_char = current_line + strlen(current_line);
   return HandleCompletionWithDescriptions(

                                            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,
+                     max_return_elements, matches);
+
   const char *cursor = current_line + cursor_pos;
   const char *last_char = current_line + strlen(current_line);
   return HandleCompletion(current_line, cursor, last_char, match_start_point,

 }
 
 bool SBCommandInterpreter::HasCommands() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommandInterpreter, HasCommands);
+
   return (IsValid() ? m_opaque_ptr->HasCommands() : false);
 }
 
 bool SBCommandInterpreter::HasAliases() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommandInterpreter, HasAliases);
+
   return (IsValid() ? m_opaque_ptr->HasAliases() : false);
 }
 
 bool SBCommandInterpreter::HasAliasOptions() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommandInterpreter, HasAliasOptions);
+
   return (IsValid() ? m_opaque_ptr->HasAliasOptions() : false);
 }
 
 SBProcess SBCommandInterpreter::GetProcess() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBProcess, SBCommandInterpreter, GetProcess);
+
   SBProcess sb_process;
   ProcessSP process_sp;
   if (IsValid()) {

                 static_cast<void *>(m_opaque_ptr),
                 static_cast<void *>(process_sp.get()));
 
-  return sb_process;
+  return LLDB_RECORD_RESULT(sb_process);
 }
 
 SBDebugger SBCommandInterpreter::GetDebugger() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBDebugger, SBCommandInterpreter,
+                             GetDebugger);
+
   SBDebugger sb_debugger;
   if (IsValid())
     sb_debugger.reset(m_opaque_ptr->GetDebugger().shared_from_this());

                 static_cast<void *>(m_opaque_ptr),
                 static_cast<void *>(sb_debugger.get()));
 
-  return sb_debugger;
+  return LLDB_RECORD_RESULT(sb_debugger);
 }
 
 bool SBCommandInterpreter::GetPromptOnQuit() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommandInterpreter, GetPromptOnQuit);
+
   return (IsValid() ? m_opaque_ptr->GetPromptOnQuit() : false);
 }
 
 void SBCommandInterpreter::SetPromptOnQuit(bool b) {
+  LLDB_RECORD_METHOD(void, SBCommandInterpreter, SetPromptOnQuit, (bool), b);
+
   if (IsValid())
     m_opaque_ptr->SetPromptOnQuit(b);
 }
 
 void SBCommandInterpreter::AllowExitCodeOnQuit(bool allow) {
+  LLDB_RECORD_METHOD(void, SBCommandInterpreter, AllowExitCodeOnQuit, (bool),
+                     allow);
+
   if (m_opaque_ptr)
     m_opaque_ptr->AllowExitCodeOnQuit(allow);
 }
 
 bool SBCommandInterpreter::HasCustomQuitExitCode() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommandInterpreter, HasCustomQuitExitCode);
+
   bool exited = false;
   if (m_opaque_ptr)
     m_opaque_ptr->GetQuitExitCode(exited);

 }
 
 int SBCommandInterpreter::GetQuitStatus() {
+  LLDB_RECORD_METHOD_NO_ARGS(int, SBCommandInterpreter, GetQuitStatus);
+
   bool exited = false;
   return (m_opaque_ptr ? m_opaque_ptr->GetQuitExitCode(exited) : 0);
 }
 
 void SBCommandInterpreter::ResolveCommand(const char *command_line,
                                           SBCommandReturnObject &result) {
+  LLDB_RECORD_METHOD(void, SBCommandInterpreter, ResolveCommand,
+                     (const char *, lldb::SBCommandReturnObject &),
+                     command_line, result);
+
   result.Clear();
   if (command_line && IsValid()) {
     m_opaque_ptr->ResolveCommand(command_line, result.ref());

 
 void SBCommandInterpreter::SourceInitFileInHomeDirectory(
     SBCommandReturnObject &result) {
+  LLDB_RECORD_METHOD(void, SBCommandInterpreter, SourceInitFileInHomeDirectory,
+                     (lldb::SBCommandReturnObject &), result);
+
   result.Clear();
   if (IsValid()) {
     TargetSP target_sp(m_opaque_ptr->GetDebugger().GetSelectedTarget());

 
 void SBCommandInterpreter::SourceInitFileInCurrentWorkingDirectory(
     SBCommandReturnObject &result) {
+  LLDB_RECORD_METHOD(void, SBCommandInterpreter,
+                     SourceInitFileInCurrentWorkingDirectory,
+                     (lldb::SBCommandReturnObject &), result);
+
   result.Clear();
   if (IsValid()) {
     TargetSP target_sp(m_opaque_ptr->GetDebugger().GetSelectedTarget());

 }
 
 SBBroadcaster SBCommandInterpreter::GetBroadcaster() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBBroadcaster, SBCommandInterpreter,
+                             GetBroadcaster);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   SBBroadcaster broadcaster(m_opaque_ptr, false);

         static_cast<void *>(m_opaque_ptr),
         static_cast<void *>(broadcaster.get()));
 
-  return broadcaster;
+  return LLDB_RECORD_RESULT(broadcaster);
 }
 
 const char *SBCommandInterpreter::GetBroadcasterClass() {
+  LLDB_RECORD_STATIC_METHOD_NO_ARGS(const char *, SBCommandInterpreter,
+                                    GetBroadcasterClass);
+
   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);
+
   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);
+
   return CommandObject::GetArgumentDescriptionAsCString(arg_type);
 }
 
 bool SBCommandInterpreter::EventIsCommandInterpreterEvent(
     const lldb::SBEvent &event) {
+  LLDB_RECORD_STATIC_METHOD(bool, SBCommandInterpreter,
+                            EventIsCommandInterpreterEvent,
+                            (const lldb::SBEvent &), event);
+
   return event.GetBroadcasterClass() ==
          SBCommandInterpreter::GetBroadcasterClass();
 }

 
 lldb::SBCommand SBCommandInterpreter::AddMultiwordCommand(const char *name,
                                                           const char *help) {
+  LLDB_RECORD_METHOD(lldb::SBCommand, SBCommandInterpreter, AddMultiwordCommand,
+                     (const char *, const char *), name, help);
+
   CommandObjectMultiword *new_command =
       new CommandObjectMultiword(*m_opaque_ptr, name, help);
   new_command->SetRemovable(true);
   lldb::CommandObjectSP new_command_sp(new_command);
   if (new_command_sp &&
       m_opaque_ptr->AddUserCommand(name, new_command_sp, true))
-    return lldb::SBCommand(new_command_sp);
-  return lldb::SBCommand();
+    return LLDB_RECORD_RESULT(lldb::SBCommand(new_command_sp));
+  return LLDB_RECORD_RESULT(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::CommandObjectSP new_command_sp;
   new_command_sp = std::make_shared<CommandPluginInterfaceImplementation>(
       *m_opaque_ptr, name, impl, help);
 
   if (new_command_sp &&
       m_opaque_ptr->AddUserCommand(name, new_command_sp, true))
-    return lldb::SBCommand(new_command_sp);
-  return lldb::SBCommand();
+    return LLDB_RECORD_RESULT(lldb::SBCommand(new_command_sp));
+  return LLDB_RECORD_RESULT(lldb::SBCommand());
 }
 
 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);
+
   lldb::CommandObjectSP new_command_sp;
   new_command_sp = std::make_shared<CommandPluginInterfaceImplementation>(
       *m_opaque_ptr, name, impl, help, syntax);
 
   if (new_command_sp &&
       m_opaque_ptr->AddUserCommand(name, new_command_sp, true))
-    return lldb::SBCommand(new_command_sp);
-  return lldb::SBCommand();
+    return LLDB_RECORD_RESULT(lldb::SBCommand(new_command_sp));
+  return LLDB_RECORD_RESULT(lldb::SBCommand());
 }
 
-SBCommand::SBCommand() = default;
+SBCommand::SBCommand() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBCommand); }
 
 SBCommand::SBCommand(lldb::CommandObjectSP cmd_sp) : m_opaque_sp(cmd_sp) {}
 
-bool SBCommand::IsValid() { return m_opaque_sp.get() != nullptr; }
+bool SBCommand::IsValid() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommand, IsValid);
+
+  return m_opaque_sp.get() != nullptr;
+}
 
 const char *SBCommand::GetName() {
+  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBCommand, GetName);
+
   return (IsValid() ? ConstString(m_opaque_sp->GetCommandName()).AsCString() : nullptr);
 }
 
 const char *SBCommand::GetHelp() {
+  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBCommand, GetHelp);
+
   return (IsValid() ? ConstString(m_opaque_sp->GetHelp()).AsCString()
                     : nullptr);
 }
 
 const char *SBCommand::GetHelpLong() {
+  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBCommand, GetHelpLong);
+
   return (IsValid() ? ConstString(m_opaque_sp->GetHelpLong()).AsCString()
                     : nullptr);
 }
 
 void SBCommand::SetHelp(const char *help) {
+  LLDB_RECORD_METHOD(void, SBCommand, SetHelp, (const char *), help);
+
   if (IsValid())
     m_opaque_sp->SetHelp(help);
 }
 
 void SBCommand::SetHelpLong(const char *help) {
+  LLDB_RECORD_METHOD(void, SBCommand, SetHelpLong, (const char *), help);
+
   if (IsValid())
     m_opaque_sp->SetHelpLong(help);
 }
 
 lldb::SBCommand SBCommand::AddMultiwordCommand(const char *name,
                                                const char *help) {
+  LLDB_RECORD_METHOD(lldb::SBCommand, SBCommand, AddMultiwordCommand,
+                     (const char *, const char *), name, help);
+
   if (!IsValid())
-    return lldb::SBCommand();
+    return LLDB_RECORD_RESULT(lldb::SBCommand());
   if (!m_opaque_sp->IsMultiwordObject())
-    return lldb::SBCommand();
+    return LLDB_RECORD_RESULT(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::SBCommand(new_command_sp);
-  return lldb::SBCommand();
+    return LLDB_RECORD_RESULT(lldb::SBCommand(new_command_sp));
+  return LLDB_RECORD_RESULT(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);
+
   if (!IsValid())
-    return lldb::SBCommand();
+    return LLDB_RECORD_RESULT(lldb::SBCommand());
   if (!m_opaque_sp->IsMultiwordObject())
-    return lldb::SBCommand();
+    return LLDB_RECORD_RESULT(lldb::SBCommand());
   lldb::CommandObjectSP new_command_sp;
   new_command_sp = std::make_shared<CommandPluginInterfaceImplementation>(
       m_opaque_sp->GetCommandInterpreter(), name, impl, help);
   if (new_command_sp && m_opaque_sp->LoadSubCommand(name, new_command_sp))
-    return lldb::SBCommand(new_command_sp);
-  return lldb::SBCommand();
+    return LLDB_RECORD_RESULT(lldb::SBCommand(new_command_sp));
+  return LLDB_RECORD_RESULT(lldb::SBCommand());
 }
 
 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);
+
   if (!IsValid())
-    return lldb::SBCommand();
+    return LLDB_RECORD_RESULT(lldb::SBCommand());
   if (!m_opaque_sp->IsMultiwordObject())
-    return lldb::SBCommand();
+    return LLDB_RECORD_RESULT(lldb::SBCommand());
   lldb::CommandObjectSP new_command_sp;
   new_command_sp = std::make_shared<CommandPluginInterfaceImplementation>(
       m_opaque_sp->GetCommandInterpreter(), name, impl, help, syntax);
   if (new_command_sp && m_opaque_sp->LoadSubCommand(name, new_command_sp))
-    return lldb::SBCommand(new_command_sp);
-  return lldb::SBCommand();
+    return LLDB_RECORD_RESULT(lldb::SBCommand(new_command_sp));
+  return LLDB_RECORD_RESULT(lldb::SBCommand());
 }
 
 uint32_t SBCommand::GetFlags() {
+  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBCommand, GetFlags);
+
   return (IsValid() ? m_opaque_sp->GetFlags().Get() : 0);
 }
 
 void SBCommand::SetFlags(uint32_t flags) {
+  LLDB_RECORD_METHOD(void, SBCommand, SetFlags, (uint32_t), flags);
+
   if (IsValid())
     m_opaque_sp->GetFlags().Set(flags);
 }

lldb/source/API/SBCommandReturnObject.cpp

 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBCommandReturnObject.h"
+#include "SBReproducerPrivate.h"
 #include "lldb/API/SBError.h"
 #include "lldb/API/SBStream.h"
 

 using namespace lldb_private;
 
 SBCommandReturnObject::SBCommandReturnObject()
-    : m_opaque_up(new CommandReturnObject()) {}
+    : m_opaque_up(new CommandReturnObject()) {
+  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBCommandReturnObject);
+}
 
 SBCommandReturnObject::SBCommandReturnObject(const SBCommandReturnObject &rhs)
     : m_opaque_up() {
+  LLDB_RECORD_CONSTRUCTOR(SBCommandReturnObject,
+                          (const lldb::SBCommandReturnObject &), rhs);
+
   if (rhs.m_opaque_up)
     m_opaque_up.reset(new CommandReturnObject(*rhs.m_opaque_up));
 }
 
 SBCommandReturnObject::SBCommandReturnObject(CommandReturnObject *ptr)
-    : m_opaque_up(ptr) {}
+    : m_opaque_up(ptr) {
+  LLDB_RECORD_CONSTRUCTOR(SBCommandReturnObject,
+                          (lldb_private::CommandReturnObject *), ptr);
+}
 
 SBCommandReturnObject::~SBCommandReturnObject() = default;
 
 CommandReturnObject *SBCommandReturnObject::Release() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb_private::CommandReturnObject *,
+                             SBCommandReturnObject, Release);
+
   return m_opaque_up.release();
 }
 
 const SBCommandReturnObject &SBCommandReturnObject::
 operator=(const SBCommandReturnObject &rhs) {
+  LLDB_RECORD_METHOD(
+      const lldb::SBCommandReturnObject &,
+      SBCommandReturnObject, operator=,(const lldb::SBCommandReturnObject &),
+      rhs);
+
   if (this != &rhs) {
     if (rhs.m_opaque_up)
       m_opaque_up.reset(new CommandReturnObject(*rhs.m_opaque_up));

   return *this;
 }
 
-bool SBCommandReturnObject::IsValid() const { return m_opaque_up != nullptr; }
+bool SBCommandReturnObject::IsValid() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandReturnObject, IsValid);
+
+  return m_opaque_up != nullptr;
+}
 
 const char *SBCommandReturnObject::GetOutput() {
+  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBCommandReturnObject, GetOutput);
+
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   if (m_opaque_up) {

 }
 
 const char *SBCommandReturnObject::GetError() {
+  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBCommandReturnObject, GetError);
+
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   if (m_opaque_up) {

 }
 
 size_t SBCommandReturnObject::GetOutputSize() {
+  LLDB_RECORD_METHOD_NO_ARGS(size_t, SBCommandReturnObject, GetOutputSize);
+
   return (m_opaque_up ? m_opaque_up->GetOutputData().size() : 0);
 }
 
 size_t SBCommandReturnObject::GetErrorSize() {
+  LLDB_RECORD_METHOD_NO_ARGS(size_t, SBCommandReturnObject, GetErrorSize);
+
   return (m_opaque_up ? m_opaque_up->GetErrorData().size() : 0);
 }
 
 size_t SBCommandReturnObject::PutOutput(FILE *fh) {
+  LLDB_RECORD_METHOD(size_t, SBCommandReturnObject, PutOutput, (FILE *), fh);
+
   if (fh) {
     size_t num_bytes = GetOutputSize();
     if (num_bytes)

 }
 
 size_t SBCommandReturnObject::PutError(FILE *fh) {
+  LLDB_RECORD_METHOD(size_t, SBCommandReturnObject, PutError, (FILE *), fh);
+
   if (fh) {
     size_t num_bytes = GetErrorSize();
     if (num_bytes)

 }
 
 void SBCommandReturnObject::Clear() {
+  LLDB_RECORD_METHOD_NO_ARGS(void, SBCommandReturnObject, Clear);
+
   if (m_opaque_up)
     m_opaque_up->Clear();
 }
 
 lldb::ReturnStatus SBCommandReturnObject::GetStatus() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::ReturnStatus, SBCommandReturnObject,
+                             GetStatus);
+
   return (m_opaque_up ? m_opaque_up->GetStatus() : lldb::eReturnStatusInvalid);
 }
 
 void SBCommandReturnObject::SetStatus(lldb::ReturnStatus status) {
+  LLDB_RECORD_METHOD(void, SBCommandReturnObject, SetStatus,
+                     (lldb::ReturnStatus), status);
+
   if (m_opaque_up)
     m_opaque_up->SetStatus(status);
 }
 
 bool SBCommandReturnObject::Succeeded() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommandReturnObject, Succeeded);
+
   return (m_opaque_up ? m_opaque_up->Succeeded() : false);
 }
 
 bool SBCommandReturnObject::HasResult() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommandReturnObject, HasResult);
+
   return (m_opaque_up ? m_opaque_up->HasResult() : false);
 }
 
 void SBCommandReturnObject::AppendMessage(const char *message) {
+  LLDB_RECORD_METHOD(void, SBCommandReturnObject, AppendMessage, (const char *),
+                     message);
+
   if (m_opaque_up)
     m_opaque_up->AppendMessage(message);
 }
 
 void SBCommandReturnObject::AppendWarning(const char *message) {
+  LLDB_RECORD_METHOD(void, SBCommandReturnObject, AppendWarning, (const char *),
+                     message);
+
   if (m_opaque_up)
     m_opaque_up->AppendWarning(message);
 }

 }
 
 bool SBCommandReturnObject::GetDescription(SBStream &description) {
+  LLDB_RECORD_METHOD(bool, SBCommandReturnObject, GetDescription,
+                     (lldb::SBStream &), description);
+
   Stream &strm = description.ref();
 
   if (m_opaque_up) {

 }
 
 void SBCommandReturnObject::SetImmediateOutputFile(FILE *fh) {
+  LLDB_RECORD_METHOD(void, SBCommandReturnObject, SetImmediateOutputFile,
+                     (FILE *), fh);
+
   SetImmediateOutputFile(fh, false);
 }
 
 void SBCommandReturnObject::SetImmediateErrorFile(FILE *fh) {
+  LLDB_RECORD_METHOD(void, SBCommandReturnObject, SetImmediateErrorFile,
+                     (FILE *), fh);
+
   SetImmediateErrorFile(fh, false);
 }
 
 void SBCommandReturnObject::SetImmediateOutputFile(FILE *fh,
                                                    bool transfer_ownership) {
+  LLDB_RECORD_METHOD(void, SBCommandReturnObject, SetImmediateOutputFile,
+                     (FILE *, bool), fh, transfer_ownership);
+
   if (m_opaque_up)
     m_opaque_up->SetImmediateOutputFile(fh, transfer_ownership);
 }
 
 void SBCommandReturnObject::SetImmediateErrorFile(FILE *fh,
                                                   bool transfer_ownership) {
+  LLDB_RECORD_METHOD(void, SBCommandReturnObject, SetImmediateErrorFile,
+                     (FILE *, bool), fh, transfer_ownership);
+
   if (m_opaque_up)
     m_opaque_up->SetImmediateErrorFile(fh, transfer_ownership);
 }
 
 void SBCommandReturnObject::PutCString(const char *string, int len) {
+  LLDB_RECORD_METHOD(void, SBCommandReturnObject, PutCString,
+                     (const char *, int), string, len);
+
   if (m_opaque_up) {
     if (len == 0 || string == nullptr || *string == 0) {
       return;

 }
 
 const char *SBCommandReturnObject::GetOutput(bool only_if_no_immediate) {
+  LLDB_RECORD_METHOD(const char *, SBCommandReturnObject, GetOutput, (bool),
+                     only_if_no_immediate);
+
   if (!m_opaque_up)
     return nullptr;
   if (!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);
+
   if (!m_opaque_up)
     return nullptr;
   if (!only_if_no_immediate ||

 
 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);
+
   if (m_opaque_up) {
     if (error.IsValid())
       m_opaque_up->SetError(error.ref(), fallback_error_cstr);

 }
 
 void SBCommandReturnObject::SetError(const char *error_cstr) {
+  LLDB_RECORD_METHOD(void, SBCommandReturnObject, SetError, (const char *),
+                     error_cstr);
+
   if (m_opaque_up && error_cstr)
     m_opaque_up->SetError(error_cstr);
 }

lldb/source/API/SBCommunication.cpp

 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBCommunication.h"
+#include "SBReproducerPrivate.h"
 #include "lldb/API/SBBroadcaster.h"
 #include "lldb/Core/Communication.h"
 #include "lldb/Host/ConnectionFileDescriptor.h"

 using namespace lldb;
 using namespace lldb_private;
 
-SBCommunication::SBCommunication() : m_opaque(NULL), m_opaque_owned(false) {}
+SBCommunication::SBCommunication() : m_opaque(NULL), m_opaque_owned(false) {
+  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBCommunication);
+}
 
 SBCommunication::SBCommunication(const char *broadcaster_name)
     : m_opaque(new Communication(broadcaster_name)), m_opaque_owned(true) {
+  LLDB_RECORD_CONSTRUCTOR(SBCommunication, (const char *), broadcaster_name);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   if (log)

   m_opaque_owned = false;
 }
 
-bool SBCommunication::IsValid() const { return m_opaque != NULL; }
+bool SBCommunication::IsValid() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommunication, IsValid);
+
+  return m_opaque != NULL;
+}
 
 bool SBCommunication::GetCloseOnEOF() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommunication, GetCloseOnEOF);
+
   if (m_opaque)
     return m_opaque->GetCloseOnEOF();
   return false;
 }
 
 void SBCommunication::SetCloseOnEOF(bool b) {
+  LLDB_RECORD_METHOD(void, SBCommunication, SetCloseOnEOF, (bool), b);
+
   if (m_opaque)
     m_opaque->SetCloseOnEOF(b);
 }
 
 ConnectionStatus SBCommunication::Connect(const char *url) {
+  LLDB_RECORD_METHOD(lldb::ConnectionStatus, SBCommunication, Connect,
+                     (const char *), url);
+
   if (m_opaque) {
     if (!m_opaque->HasConnection())
       m_opaque->SetConnection(Host::CreateDefaultConnection(url).release());

 }
 
 ConnectionStatus SBCommunication::AdoptFileDesriptor(int fd, bool owns_fd) {
+  LLDB_RECORD_METHOD(lldb::ConnectionStatus, SBCommunication,
+                     AdoptFileDesriptor, (int, bool), fd, owns_fd);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   ConnectionStatus status = eConnectionStatusNoConnection;

 }
 
 ConnectionStatus SBCommunication::Disconnect() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::ConnectionStatus, SBCommunication,
+                             Disconnect);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   ConnectionStatus status = eConnectionStatusNoConnection;

 }
 
 bool SBCommunication::IsConnected() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommunication, IsConnected);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   bool result = false;
   if (m_opaque)

 }
 
 bool SBCommunication::ReadThreadStart() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommunication, ReadThreadStart);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   bool success = false;

 }
 
 bool SBCommunication::ReadThreadStop() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommunication, ReadThreadStop);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   if (log)
     log->Printf("SBCommunication(%p)::ReadThreadStop ()...",

 }
 
 bool SBCommunication::ReadThreadIsRunning() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommunication, ReadThreadIsRunning);
+
   bool result = false;
   if (m_opaque)
     result = m_opaque->ReadThreadIsRunning();

 }
 
 SBBroadcaster SBCommunication::GetBroadcaster() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBBroadcaster, SBCommunication,
+                             GetBroadcaster);
+
   SBBroadcaster broadcaster(m_opaque, false);
 
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));

                 static_cast<void *>(m_opaque),
                 static_cast<void *>(broadcaster.get()));
 
-  return broadcaster;
+  return LLDB_RECORD_RESULT(broadcaster);
 }
 
 const char *SBCommunication::GetBroadcasterClass() {
+  LLDB_RECORD_STATIC_METHOD_NO_ARGS(const char *, SBCommunication,
+                                    GetBroadcasterClass);
+
   return Communication::GetStaticBroadcasterClass().AsCString();
 }
 

lldb/source/API/SBCompileUnit.cpp

 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBCompileUnit.h"
+#include "SBReproducerPrivate.h"
 #include "lldb/API/SBLineEntry.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/Core/Module.h"

 using namespace lldb;
 using namespace lldb_private;
 
-SBCompileUnit::SBCompileUnit() : m_opaque_ptr(NULL) {}
+SBCompileUnit::SBCompileUnit() : m_opaque_ptr(NULL) {
+  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBCompileUnit);
+}
 
 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) {}
+    : m_opaque_ptr(rhs.m_opaque_ptr) {
+  LLDB_RECORD_CONSTRUCTOR(SBCompileUnit, (const lldb::SBCompileUnit &), rhs);
+}
 
 const SBCompileUnit &SBCompileUnit::operator=(const SBCompileUnit &rhs) {
+  LLDB_RECORD_METHOD(const lldb::SBCompileUnit &,
+                     SBCompileUnit, operator=,(const lldb::SBCompileUnit &),
+                     rhs);
+
   m_opaque_ptr = rhs.m_opaque_ptr;
   return *this;
 }

 SBCompileUnit::~SBCompileUnit() { m_opaque_ptr = NULL; }
 
 SBFileSpec SBCompileUnit::GetFileSpec() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBFileSpec, SBCompileUnit,
+                                   GetFileSpec);
+
   SBFileSpec file_spec;
   if (m_opaque_ptr)
     file_spec.SetFileSpec(*m_opaque_ptr);
-  return file_spec;
+  return LLDB_RECORD_RESULT(file_spec);
 }
 
 uint32_t SBCompileUnit::GetNumLineEntries() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBCompileUnit, GetNumLineEntries);
+
   if (m_opaque_ptr) {
     LineTable *line_table = m_opaque_ptr->GetLineTable();
     if (line_table)

 }
 
 SBLineEntry SBCompileUnit::GetLineEntryAtIndex(uint32_t idx) const {
+  LLDB_RECORD_METHOD_CONST(lldb::SBLineEntry, SBCompileUnit,
+                           GetLineEntryAtIndex, (uint32_t), idx);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   SBLineEntry sb_line_entry;

                 static_cast<void *>(sb_line_entry.get()), sstr.GetData());
   }
 
-  return sb_line_entry;
+  return LLDB_RECORD_RESULT(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);
+
   const bool exact = true;
   return FindLineEntryIndex(start_idx, line, inline_file_spec, exact);
 }

 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);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   uint32_t index = UINT32_MAX;

 }
 
 uint32_t SBCompileUnit::GetNumSupportFiles() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBCompileUnit, GetNumSupportFiles);
+
   if (m_opaque_ptr) {
     FileSpecList &support_files = m_opaque_ptr->GetSupportFiles();
     return support_files.GetSize();

 }
 
 lldb::SBTypeList SBCompileUnit::GetTypes(uint32_t type_mask) {
+  LLDB_RECORD_METHOD(lldb::SBTypeList, SBCompileUnit, GetTypes, (uint32_t),
+                     type_mask);
+
   SBTypeList sb_type_list;
 
   if (!m_opaque_ptr)
-    return sb_type_list;
+    return LLDB_RECORD_RESULT(sb_type_list);
 
   ModuleSP module_sp(m_opaque_ptr->GetModule());
   if (!module_sp)
-    return sb_type_list;
+    return LLDB_RECORD_RESULT(sb_type_list);
 
   SymbolVendor *vendor = module_sp->GetSymbolVendor();
   if (!vendor)
-    return sb_type_list;
+    return LLDB_RECORD_RESULT(sb_type_list);
 
   TypeClass type_class = static_cast<TypeClass>(type_mask);
   TypeList type_list;
   vendor->GetTypes(m_opaque_ptr, type_class, type_list);
   sb_type_list.m_opaque_up->Append(type_list);
-  return sb_type_list;
+  return LLDB_RECORD_RESULT(sb_type_list);
 }
 
 SBFileSpec SBCompileUnit::GetSupportFileAtIndex(uint32_t idx) const {
+  LLDB_RECORD_METHOD_CONST(lldb::SBFileSpec, SBCompileUnit,
+                           GetSupportFileAtIndex, (uint32_t), idx);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   SBFileSpec sb_file_spec;

                 static_cast<const void *>(sb_file_spec.get()), sstr.GetData());
   }
 
-  return sb_file_spec;
+  return LLDB_RECORD_RESULT(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);
+
   if (m_opaque_ptr) {
     FileSpecList &support_files = m_opaque_ptr->GetSupportFiles();
     return support_files.FindFileIndex(start_idx, sb_file.ref(), full);

 }
 
 lldb::LanguageType SBCompileUnit::GetLanguage() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::LanguageType, SBCompileUnit, GetLanguage);
+
   if (m_opaque_ptr)
     return m_opaque_ptr->GetLanguage();
   return lldb::eLanguageTypeUnknown;
 }
 
-bool SBCompileUnit::IsValid() const { return m_opaque_ptr != NULL; }
+bool SBCompileUnit::IsValid() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCompileUnit, IsValid);
+
+  return m_opaque_ptr != NULL;
+}
 
 bool SBCompileUnit::operator==(const SBCompileUnit &rhs) const {
+  LLDB_RECORD_METHOD_CONST(
+      bool, SBCompileUnit, operator==,(const lldb::SBCompileUnit &), 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);
+
   return m_opaque_ptr != rhs.m_opaque_ptr;
 }
 

 }
 
 bool SBCompileUnit::GetDescription(SBStream &description) {
+  LLDB_RECORD_METHOD(bool, SBCompileUnit, GetDescription, (lldb::SBStream &),
+                     description);
+
   Stream &strm = description.ref();
 
   if (m_opaque_ptr) {

lldb/source/API/SBData.cpp

 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBData.h"
+#include "SBReproducerPrivate.h"
 #include "lldb/API/SBError.h"
 #include "lldb/API/SBStream.h"
 

 using namespace lldb;
 using namespace lldb_private;
 
-SBData::SBData() : m_opaque_sp(new DataExtractor()) {}
+SBData::SBData() : m_opaque_sp(new DataExtractor()) {
+  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBData);
+}
 
 SBData::SBData(const lldb::DataExtractorSP &data_sp) : m_opaque_sp(data_sp) {}
 
-SBData::SBData(const SBData &rhs) : m_opaque_sp(rhs.m_opaque_sp) {}
+SBData::SBData(const SBData &rhs) : m_opaque_sp(rhs.m_opaque_sp) {
+  LLDB_RECORD_CONSTRUCTOR(SBData, (const lldb::SBData &), rhs);
+}
 
 const SBData &SBData::operator=(const SBData &rhs) {
+  LLDB_RECORD_METHOD(const lldb::SBData &,
+                     SBData, operator=,(const lldb::SBData &), rhs);
+
   if (this != &rhs)
     m_opaque_sp = rhs.m_opaque_sp;
   return *this;

 
 const lldb::DataExtractorSP &SBData::operator*() const { return m_opaque_sp; }
 
-bool SBData::IsValid() { return m_opaque_sp.get() != NULL; }
+bool SBData::IsValid() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBData, IsValid);
+
+  return m_opaque_sp.get() != NULL;
+}
 
 uint8_t SBData::GetAddressByteSize() {
+  LLDB_RECORD_METHOD_NO_ARGS(uint8_t, SBData, GetAddressByteSize);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   uint8_t value = 0;
   if (m_opaque_sp.get())

 }
 
 void SBData::SetAddressByteSize(uint8_t addr_byte_size) {
+  LLDB_RECORD_METHOD(void, SBData, SetAddressByteSize, (uint8_t),
+                     addr_byte_size);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   if (m_opaque_sp.get())
     m_opaque_sp->SetAddressByteSize(addr_byte_size);

 }
 
 void SBData::Clear() {
+  LLDB_RECORD_METHOD_NO_ARGS(void, SBData, Clear);
+
   if (m_opaque_sp.get())
     m_opaque_sp->Clear();
 }
 
 size_t SBData::GetByteSize() {
+  LLDB_RECORD_METHOD_NO_ARGS(size_t, SBData, GetByteSize);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   size_t value = 0;
   if (m_opaque_sp.get())

 }
 
 lldb::ByteOrder SBData::GetByteOrder() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::ByteOrder, SBData, GetByteOrder);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   lldb::ByteOrder value = eByteOrderInvalid;
   if (m_opaque_sp.get())

 }
 
 void SBData::SetByteOrder(lldb::ByteOrder endian) {
+  LLDB_RECORD_METHOD(void, SBData, SetByteOrder, (lldb::ByteOrder), endian);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   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);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   float value = 0;
   if (!m_opaque_sp.get()) {

 }
 
 double SBData::GetDouble(lldb::SBError &error, lldb::offset_t offset) {
+  LLDB_RECORD_METHOD(double, SBData, GetDouble,
+                     (lldb::SBError &, lldb::offset_t), error, offset);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   double value = 0;
   if (!m_opaque_sp.get()) {

 }
 
 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);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   long double value = 0;
   if (!m_opaque_sp.get()) {

 }
 
 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);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   lldb::addr_t value = 0;
   if (!m_opaque_sp.get()) {

 }
 
 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);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   uint8_t value = 0;
   if (!m_opaque_sp.get()) {

 }
 
 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);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   uint16_t value = 0;
   if (!m_opaque_sp.get()) {

 }
 
 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);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   uint32_t value = 0;
   if (!m_opaque_sp.get()) {

 }
 
 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);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   uint64_t value = 0;
   if (!m_opaque_sp.get()) {

 }
 
 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);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   int8_t value = 0;
   if (!m_opaque_sp.get()) {

 }
 
 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);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   int16_t value = 0;
   if (!m_opaque_sp.get()) {

 }
 
 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);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   int32_t value = 0;
   if (!m_opaque_sp.get()) {

 }
 
 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);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   int64_t value = 0;
   if (!m_opaque_sp.get()) {

 }
 
 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);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   const char *value = 0;
   if (!m_opaque_sp.get()) {

 
 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);
+
   Stream &strm = description.ref();
 
   if (m_opaque_sp) {

 }
 
 bool SBData::Append(const SBData &rhs) {
+  LLDB_RECORD_METHOD(bool, SBData, Append, (const lldb::SBData &), rhs);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   bool value = false;
   if (m_opaque_sp.get() && rhs.m_opaque_sp.get())

 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);
+
   if (!data || !data[0])
-    return SBData();
+    return LLDB_RECORD_RESULT(SBData());
 
   uint32_t data_len = strlen(data);
 

 
   SBData ret(data_sp);
 
-  return ret;
+  return LLDB_RECORD_RESULT(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);
+
   if (!array || array_len == 0)
-    return SBData();
+    return LLDB_RECORD_RESULT(SBData());
 
   size_t data_len = array_len * sizeof(uint64_t);
 

 
   SBData ret(data_sp);
 
-  return ret;
+  return LLDB_RECORD_RESULT(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);
+
   if (!array || array_len == 0)
-    return SBData();
+    return LLDB_RECORD_RESULT(SBData());
 
   size_t data_len = array_len * sizeof(uint32_t);
 

 
   SBData ret(data_sp);
 
-  return ret;
+  return LLDB_RECORD_RESULT(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);
+
   if (!array || array_len == 0)
-    return SBData();
+    return LLDB_RECORD_RESULT(SBData());
 
   size_t data_len = array_len * sizeof(int64_t);
 

 
   SBData ret(data_sp);
 
-  return ret;
+  return LLDB_RECORD_RESULT(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);
+
   if (!array || array_len == 0)
-    return SBData();
+    return LLDB_RECORD_RESULT(SBData());
 
   size_t data_len = array_len * sizeof(int32_t);
 

 
   SBData ret(data_sp);
 
-  return ret;
+  return LLDB_RECORD_RESULT(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);
+
   if (!array || array_len == 0)
-    return SBData();
+    return LLDB_RECORD_RESULT(SBData());
 
   size_t data_len = array_len * sizeof(double);
 

 
   SBData ret(data_sp);
 
-  return ret;
+  return LLDB_RECORD_RESULT(ret);
 }
 
 bool SBData::SetDataFromCString(const char *data) {
+  LLDB_RECORD_METHOD(bool, SBData, SetDataFromCString, (const char *), data);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   if (!data) {

 }
 
 bool SBData::SetDataFromUInt64Array(uint64_t *array, size_t array_len) {
+  LLDB_RECORD_METHOD(bool, SBData, SetDataFromUInt64Array, (uint64_t *, size_t),
+                     array, array_len);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   if (!array || array_len == 0) {

 }
 
 bool SBData::SetDataFromUInt32Array(uint32_t *array, size_t array_len) {
+  LLDB_RECORD_METHOD(bool, SBData, SetDataFromUInt32Array, (uint32_t *, size_t),
+                     array, array_len);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   if (!array || array_len == 0) {

 }
 
 bool SBData::SetDataFromSInt64Array(int64_t *array, size_t array_len) {
+  LLDB_RECORD_METHOD(bool, SBData, SetDataFromSInt64Array, (int64_t *, size_t),
+                     array, array_len);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   if (!array || array_len == 0) {

 }
 
 bool SBData::SetDataFromSInt32Array(int32_t *array, size_t array_len) {
+  LLDB_RECORD_METHOD(bool, SBData, SetDataFromSInt32Array, (int32_t *, size_t),
+                     array, array_len);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   if (!array || array_len == 0) {

 }
 
 bool SBData::SetDataFromDoubleArray(double *array, size_t array_len) {
+  LLDB_RECORD_METHOD(bool, SBData, SetDataFromDoubleArray, (double *, size_t),
+                     array, array_len);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   if (!array || array_len == 0) {

lldb/source/API/SBDebugger.cpp

 //
 //===----------------------------------------------------------------------===//
 
-
+#include "SBReproducerPrivate.h"
 #include "SystemInitializerFull.h"
 
 #include "lldb/API/SBDebugger.h"

   return SBError();
 }
 
-void SBInputReader::SetIsDone(bool) {}
+void SBInputReader::SetIsDone(bool b) {
+  LLDB_RECORD_METHOD(void, SBInputReader, SetIsDone, (bool), b);
+}
+
+bool SBInputReader::IsActive() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBInputReader, IsActive);
 
-bool SBInputReader::IsActive() const { return false; }
+  return false;
+}
 
-SBDebugger::SBDebugger() = default;
+SBDebugger::SBDebugger() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBDebugger); }
 
 SBDebugger::SBDebugger(const lldb::DebuggerSP &debugger_sp)
-    : m_opaque_sp(debugger_sp) {}
+    : m_opaque_sp(debugger_sp) {
+  LLDB_RECORD_CONSTRUCTOR(SBDebugger, (const lldb::DebuggerSP &), debugger_sp);
+}
 
-SBDebugger::SBDebugger(const SBDebugger &rhs) : m_opaque_sp(rhs.m_opaque_sp) {}
+SBDebugger::SBDebugger(const SBDebugger &rhs) : m_opaque_sp(rhs.m_opaque_sp) {
+  LLDB_RECORD_CONSTRUCTOR(SBDebugger, (const lldb::SBDebugger &), rhs);
+}
 
 SBDebugger::~SBDebugger() = default;
 
 SBDebugger &SBDebugger::operator=(const SBDebugger &rhs) {
+  LLDB_RECORD_METHOD(lldb::SBDebugger &,
+                     SBDebugger, operator=,(const lldb::SBDebugger &), rhs);
+
   if (this != &rhs) {
     m_opaque_sp = rhs.m_opaque_sp;
   }

 }
 
 void SBDebugger::Initialize() {
+  LLDB_RECORD_STATIC_METHOD_NO_ARGS(void, SBDebugger, Initialize);
   SBError ignored = SBDebugger::InitializeWithErrorHandling();
 }
 
 lldb::SBError SBDebugger::InitializeWithErrorHandling() {
+  LLDB_RECORD_STATIC_METHOD_NO_ARGS(lldb::SBError, SBDebugger,
+                                    InitializeWithErrorHandling);
+
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   if (log)

           llvm::make_unique<SystemInitializerFull>(), LoadPlugin)) {
     error.SetError(Status(std::move(e)));
   }
-  return error;
+  return LLDB_RECORD_RESULT(error);
 }
 
-void SBDebugger::Terminate() { g_debugger_lifetime->Terminate(); }
+void SBDebugger::Terminate() {
+  LLDB_RECORD_STATIC_METHOD_NO_ARGS(void, SBDebugger, Terminate);
+
+  g_debugger_lifetime->Terminate();
+}
 
 void SBDebugger::Clear() {
+  LLDB_RECORD_METHOD_NO_ARGS(void, SBDebugger, Clear);
+
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   if (log)

 }
 
 SBDebugger SBDebugger::Create() {
-  return SBDebugger::Create(false, nullptr, nullptr);
+  LLDB_RECORD_STATIC_METHOD_NO_ARGS(lldb::SBDebugger, SBDebugger, Create);
+
+  return LLDB_RECORD_RESULT(SBDebugger::Create(false, nullptr, nullptr));
 }
 
 SBDebugger SBDebugger::Create(bool source_init_files) {
-  return SBDebugger::Create(source_init_files, nullptr, nullptr);
+  LLDB_RECORD_STATIC_METHOD(lldb::SBDebugger, SBDebugger, Create, (bool),
+                            source_init_files);
+
+  return LLDB_RECORD_RESULT(
+      SBDebugger::Create(source_init_files, nullptr, nullptr));
 }
 
 SBDebugger SBDebugger::Create(bool source_init_files,

 }
 
 void SBDebugger::Destroy(SBDebugger &debugger) {
+  LLDB_RECORD_STATIC_METHOD(void, SBDebugger, Destroy, (lldb::SBDebugger &),
+                            debugger);
+
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   if (log) {

 }
 
 void SBDebugger::MemoryPressureDetected() {
+  LLDB_RECORD_STATIC_METHOD_NO_ARGS(void, SBDebugger, MemoryPressureDetected);
+
   // 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
   // need to safeguard against this until we can determine what is causing the

   ModuleList::RemoveOrphanSharedModules(mandatory);
 }
 
-bool SBDebugger::IsValid() const { return m_opaque_sp.get() != nullptr; }
+bool SBDebugger::IsValid() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBDebugger, IsValid);
+
+  return m_opaque_sp.get() != nullptr;
+}
 
 void SBDebugger::SetAsync(bool b) {
+  LLDB_RECORD_METHOD(void, SBDebugger, SetAsync, (bool), b);
+
   if (m_opaque_sp)
     m_opaque_sp->SetAsyncExecution(b);
 }
 
 bool SBDebugger::GetAsync() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBDebugger, GetAsync);
+
   return (m_opaque_sp ? m_opaque_sp->GetAsyncExecution() : false);
 }
 
 void SBDebugger::SkipLLDBInitFiles(bool b) {
+  LLDB_RECORD_METHOD(void, SBDebugger, SkipLLDBInitFiles, (bool), b);
+
   if (m_opaque_sp)
     m_opaque_sp->GetCommandInterpreter().SkipLLDBInitFiles(b);
 }
 
 void SBDebugger::SkipAppInitFiles(bool b) {
+  LLDB_RECORD_METHOD(void, SBDebugger, SkipAppInitFiles, (bool), b);
+
   if (m_opaque_sp)
     m_opaque_sp->GetCommandInterpreter().SkipAppInitFiles(b);
 }

 // of problems; don't want users trying to switch modes in the middle of a
 // debugging session.
 void SBDebugger::SetInputFileHandle(FILE *fh, bool transfer_ownership) {
+  LLDB_RECORD_METHOD(void, SBDebugger, SetInputFileHandle, (FILE *, bool), fh,
+                     transfer_ownership);
+
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   if (log)

 }
 
 void SBDebugger::SetOutputFileHandle(FILE *fh, bool transfer_ownership) {
+  LLDB_RECORD_METHOD(void, SBDebugger, SetOutputFileHandle, (FILE *, bool), fh,
+                     transfer_ownership);
+
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   if (log)

 }
 
 void SBDebugger::SetErrorFileHandle(FILE *fh, bool transfer_ownership) {
+  LLDB_RECORD_METHOD(void, SBDebugger, SetErrorFileHandle, (FILE *, bool), fh,
+                     transfer_ownership);
+
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   if (log)

 }
 
 FILE *SBDebugger::GetInputFileHandle() {
+  LLDB_RECORD_METHOD_NO_ARGS(FILE *, SBDebugger, GetInputFileHandle);
+
   if (m_opaque_sp) {
     StreamFileSP stream_file_sp(m_opaque_sp->GetInputFile());
     if (stream_file_sp)

 }
 
 FILE *SBDebugger::GetOutputFileHandle() {
+  LLDB_RECORD_METHOD_NO_ARGS(FILE *, SBDebugger, GetOutputFileHandle);
+
   if (m_opaque_sp) {
     StreamFileSP stream_file_sp(m_opaque_sp->GetOutputFile());
     if (stream_file_sp)

 }
 
 FILE *SBDebugger::GetErrorFileHandle() {
+  LLDB_RECORD_METHOD_NO_ARGS(FILE *, SBDebugger, GetErrorFileHandle);
+
   if (m_opaque_sp) {
     StreamFileSP stream_file_sp(m_opaque_sp->GetErrorFile());
     if (stream_file_sp)

 }
 
 void SBDebugger::SaveInputTerminalState() {
+  LLDB_RECORD_METHOD_NO_ARGS(void, SBDebugger, SaveInputTerminalState);
+
   if (m_opaque_sp)
     m_opaque_sp->SaveInputTerminalState();
 }
 
 void SBDebugger::RestoreInputTerminalState() {
+  LLDB_RECORD_METHOD_NO_ARGS(void, SBDebugger, RestoreInputTerminalState);
+
   if (m_opaque_sp)
     m_opaque_sp->RestoreInputTerminalState();
 }
 SBCommandInterpreter SBDebugger::GetCommandInterpreter() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBCommandInterpreter, SBDebugger,
+                             GetCommandInterpreter);
+
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   SBCommandInterpreter sb_interpreter;

         static_cast<void *>(m_opaque_sp.get()),
         static_cast<void *>(sb_interpreter.get()));
 
-  return sb_interpreter;
+  return LLDB_RECORD_RESULT(sb_interpreter);
 }
 
 void SBDebugger::HandleCommand(const char *command) {
+  LLDB_RECORD_METHOD(void, SBDebugger, HandleCommand, (const char *), command);
+
   if (m_opaque_sp) {
     TargetSP target_sp(m_opaque_sp->GetSelectedTarget());
     std::unique_lock<std::recursive_mutex> lock;

 }
 
 SBListener SBDebugger::GetListener() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBListener, SBDebugger, GetListener);
+
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   SBListener sb_listener;

                 static_cast<void *>(m_opaque_sp.get()),
                 static_cast<void *>(sb_listener.get()));
 
-  return sb_listener;
+  return LLDB_RECORD_RESULT(sb_listener);
 }
 
 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);
+
   if (!process.IsValid())
     return;
 

 }
 
 SBSourceManager SBDebugger::GetSourceManager() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBSourceManager, SBDebugger,
+                             GetSourceManager);
+
   SBSourceManager sb_source_manager(*this);
-  return sb_source_manager;
+  return LLDB_RECORD_RESULT(sb_source_manager);
 }
 
 bool SBDebugger::GetDefaultArchitecture(char *arch_name, size_t arch_name_len) {
+  LLDB_RECORD_STATIC_METHOD(bool, SBDebugger, GetDefaultArchitecture,
+                            (char *, size_t), "", arch_name_len);
+
   if (arch_name && arch_name_len) {
     ArchSpec default_arch = Target::GetDefaultArchitecture();
 

 }
 
 bool SBDebugger::SetDefaultArchitecture(const char *arch_name) {
+  LLDB_RECORD_STATIC_METHOD(bool, SBDebugger, SetDefaultArchitecture,
+                            (const char *), arch_name);
+
   if (arch_name) {
     ArchSpec arch(arch_name);
     if (arch.IsValid()) {

 
 ScriptLanguage
 SBDebugger::GetScriptingLanguage(const char *script_language_name) {
+  LLDB_RECORD_METHOD(lldb::ScriptLanguage, SBDebugger, GetScriptingLanguage,
+                     (const char *), script_language_name);
+
   if (!script_language_name) return eScriptLanguageDefault;
   return OptionArgParser::ToScriptLanguage(
       llvm::StringRef(script_language_name), eScriptLanguageDefault, nullptr);
 }
 
 const char *SBDebugger::GetVersionString() {
+  LLDB_RECORD_STATIC_METHOD_NO_ARGS(const char *, SBDebugger, GetVersionString);
+
   return lldb_private::GetVersion();
 }
 
 const char *SBDebugger::StateAsCString(StateType state) {
+  LLDB_RECORD_STATIC_METHOD(const char *, SBDebugger, StateAsCString,
+                            (lldb::StateType), state);
+
   return lldb_private::StateAsCString(state);
 }
 

 }
 
 SBStructuredData SBDebugger::GetBuildConfiguration() {
+  LLDB_RECORD_STATIC_METHOD_NO_ARGS(lldb::SBStructuredData, SBDebugger,
+                                    GetBuildConfiguration);
+
   auto config_up = llvm::make_unique<StructuredData::Dictionary>();
   AddBoolConfigEntry(
       *config_up, "xml", XMLDocument::XMLEnabled(),

 
   SBStructuredData data;
   data.m_impl_up->SetObjectSP(std::move(config_up));
-  return data;
+  return LLDB_RECORD_RESULT(data);
 }
 
 bool SBDebugger::StateIsRunningState(StateType state) {
+  LLDB_RECORD_STATIC_METHOD(bool, SBDebugger, StateIsRunningState,
+                            (lldb::StateType), state);
+
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   const bool result = lldb_private::StateIsRunningState(state);

 }
 
 bool SBDebugger::StateIsStoppedState(StateType state) {
+  LLDB_RECORD_STATIC_METHOD(bool, SBDebugger, StateIsStoppedState,
+                            (lldb::StateType), state);
+
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   const bool result = lldb_private::StateIsStoppedState(state, false);

                                         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);
+
   SBTarget sb_target;
   TargetSP target_sp;
   if (m_opaque_sp) {

                 platform_name, add_dependent_modules, sb_error.GetCString(),
                 static_cast<void *>(target_sp.get()));
 
-  return sb_target;
+  return LLDB_RECORD_RESULT(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);
+
   SBTarget sb_target;
   TargetSP target_sp;
   if (m_opaque_sp) {

                 static_cast<void *>(m_opaque_sp.get()), filename, target_triple,
                 static_cast<void *>(target_sp.get()));
 
-  return sb_target;
+  return LLDB_RECORD_RESULT(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);
+
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   SBTarget sb_target;

                 static_cast<void *>(m_opaque_sp.get()), filename, arch_cstr,
                 static_cast<void *>(target_sp.get()));
 
-  return sb_target;
+  return LLDB_RECORD_RESULT(sb_target);
 }
 
 SBTarget SBDebugger::CreateTarget(const char *filename) {
+  LLDB_RECORD_METHOD(lldb::SBTarget, SBDebugger, CreateTarget, (const char *),
+                     filename);
+
   SBTarget sb_target;
   TargetSP target_sp;
   if (m_opaque_sp) {

         "SBDebugger(%p)::CreateTarget (filename=\"%s\") => SBTarget(%p)",
         static_cast<void *>(m_opaque_sp.get()), filename,
         static_cast<void *>(target_sp.get()));
-  return sb_target;
+  return LLDB_RECORD_RESULT(sb_target);
 }
 
 SBTarget SBDebugger::GetDummyTarget() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTarget, SBDebugger, GetDummyTarget);
+
   SBTarget sb_target;
   if (m_opaque_sp) {
       sb_target.SetSP(m_opaque_sp->GetDummyTarget()->shared_from_this());

         "SBDebugger(%p)::GetDummyTarget() => SBTarget(%p)",
         static_cast<void *>(m_opaque_sp.get()),
         static_cast<void *>(sb_target.GetSP().get()));
-  return sb_target;
+  return LLDB_RECORD_RESULT(sb_target);
 }
 
 bool SBDebugger::DeleteTarget(lldb::SBTarget &target) {
+  LLDB_RECORD_METHOD(bool, SBDebugger, DeleteTarget, (lldb::SBTarget &),
+                     target);
+
   bool result = false;
   if (m_opaque_sp) {
     TargetSP target_sp(target.GetSP());

 }
 
 SBTarget SBDebugger::GetTargetAtIndex(uint32_t idx) {
+  LLDB_RECORD_METHOD(lldb::SBTarget, SBDebugger, GetTargetAtIndex, (uint32_t),
+                     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 sb_target;
+  return LLDB_RECORD_RESULT(sb_target);
 }
 
 uint32_t SBDebugger::GetIndexOfTarget(lldb::SBTarget target) {
+  LLDB_RECORD_METHOD(uint32_t, SBDebugger, GetIndexOfTarget, (lldb::SBTarget),
+                     target);
 
   lldb::TargetSP target_sp = target.GetSP();
   if (!target_sp)

 }
 
 SBTarget SBDebugger::FindTargetWithProcessID(lldb::pid_t pid) {
+  LLDB_RECORD_METHOD(lldb::SBTarget, SBDebugger, FindTargetWithProcessID,
+                     (lldb::pid_t), 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 sb_target;
+  return LLDB_RECORD_RESULT(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);
+
   SBTarget sb_target;
   if (m_opaque_sp && filename && filename[0]) {
     // No need to lock, the target list is thread safe

             FileSpec(filename), arch_name ? &arch : nullptr));
     sb_target.SetSP(target_sp);
   }
-  return sb_target;
+  return LLDB_RECORD_RESULT(sb_target);
 }
 
 SBTarget SBDebugger::FindTargetWithLLDBProcess(const ProcessSP &process_sp) {

 }
 
 uint32_t SBDebugger::GetNumTargets() {
+  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBDebugger, GetNumTargets);
+
   if (m_opaque_sp) {
     // No need to lock, the target list is thread safe
     return m_opaque_sp->GetTargetList().GetNumTargets();

 }
 
 SBTarget SBDebugger::GetSelectedTarget() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTarget, SBDebugger, GetSelectedTarget);
+
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   SBTarget sb_target;

                 static_cast<void *>(target_sp.get()), sstr.GetData());
   }
 
-  return sb_target;
+  return LLDB_RECORD_RESULT(sb_target);
 }
 
 void SBDebugger::SetSelectedTarget(SBTarget &sb_target) {
+  LLDB_RECORD_METHOD(void, SBDebugger, SetSelectedTarget, (lldb::SBTarget &),
+                     sb_target);
+
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   TargetSP target_sp(sb_target.GetSP());

 }
 
 SBPlatform SBDebugger::GetSelectedPlatform() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBPlatform, SBDebugger, GetSelectedPlatform);
+
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   SBPlatform sb_platform;

                 static_cast<void *>(m_opaque_sp.get()),
                 static_cast<void *>(sb_platform.GetSP().get()),
                 sb_platform.GetName());
-  return sb_platform;
+  return LLDB_RECORD_RESULT(sb_platform);
 }
 
 void SBDebugger::SetSelectedPlatform(SBPlatform &sb_platform) {
+  LLDB_RECORD_METHOD(void, SBDebugger, SetSelectedPlatform,
+                     (lldb::SBPlatform &), sb_platform);
+
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   DebuggerSP debugger_sp(m_opaque_sp);

 }
 
 uint32_t SBDebugger::GetNumPlatforms() {
+  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBDebugger, GetNumPlatforms);
+
   if (m_opaque_sp) {
     // No need to lock, the platform list is thread safe
     return m_opaque_sp->GetPlatformList().GetSize();

 }
 
 SBPlatform SBDebugger::GetPlatformAtIndex(uint32_t idx) {
+  LLDB_RECORD_METHOD(lldb::SBPlatform, SBDebugger, GetPlatformAtIndex,
+                     (uint32_t), 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 sb_platform;
+  return LLDB_RECORD_RESULT(sb_platform);
 }
 
 uint32_t SBDebugger::GetNumAvailablePlatforms() {
+  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBDebugger, GetNumAvailablePlatforms);
+
   uint32_t idx = 0;
   while (true) {
     if (!PluginManager::GetPlatformPluginNameAtIndex(idx)) {

 }
 
 SBStructuredData SBDebugger::GetAvailablePlatformInfoAtIndex(uint32_t idx) {
+  LLDB_RECORD_METHOD(lldb::SBStructuredData, SBDebugger,
+                     GetAvailablePlatformInfoAtIndex, (uint32_t), idx);
+
   SBStructuredData data;
   auto platform_dict = llvm::make_unique<StructuredData::Dictionary>();
   llvm::StringRef name_str("name"), desc_str("description");

     const char *plugin_name =
         PluginManager::GetPlatformPluginNameAtIndex(idx - 1);
     if (!plugin_name) {
-      return data;
+      return LLDB_RECORD_RESULT(data);
     }
     platform_dict->AddStringItem(name_str, llvm::StringRef(plugin_name));
 
     const char *plugin_desc =
         PluginManager::GetPlatformPluginDescriptionAtIndex(idx - 1);
     if (!plugin_desc) {
-      return data;
+      return LLDB_RECORD_RESULT(data);
     }
     platform_dict->AddStringItem(desc_str, llvm::StringRef(plugin_desc));
   }
 
   data.m_impl_up->SetObjectSP(
       StructuredData::ObjectSP(platform_dict.release()));
-  return data;
+  return LLDB_RECORD_RESULT(data);
 }
 
 void SBDebugger::DispatchInput(void *baton, const void *data, size_t data_len) {

 }
 
 void SBDebugger::DispatchInputInterrupt() {
+  LLDB_RECORD_METHOD_NO_ARGS(void, SBDebugger, DispatchInputInterrupt);
+
   if (m_opaque_sp)
     m_opaque_sp->DispatchInputInterrupt();
 }
 
 void SBDebugger::DispatchInputEndOfFile() {
+  LLDB_RECORD_METHOD_NO_ARGS(void, SBDebugger, DispatchInputEndOfFile);
+
   if (m_opaque_sp)
     m_opaque_sp->DispatchInputEndOfFile();
 }
 
-void SBDebugger::PushInputReader(SBInputReader &reader) {}
+void SBDebugger::PushInputReader(SBInputReader &reader) {
+  LLDB_RECORD_METHOD(void, SBDebugger, PushInputReader, (lldb::SBInputReader &),
+                     reader);
+}
 
 void SBDebugger::RunCommandInterpreter(bool auto_handle_events,
                                        bool spawn_thread) {
+  LLDB_RECORD_METHOD(void, SBDebugger, RunCommandInterpreter, (bool, bool),
+                     auto_handle_events, spawn_thread);
+
   if (m_opaque_sp) {
     CommandInterpreterRunOptions options;
 

                                        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);
+
   if (m_opaque_sp) {
     CommandInterpreter &interp = m_opaque_sp->GetCommandInterpreter();
     interp.RunCommandInterpreter(auto_handle_events, spawn_thread,

 
 SBError SBDebugger::RunREPL(lldb::LanguageType language,
                             const char *repl_options) {
+  LLDB_RECORD_METHOD(lldb::SBError, SBDebugger, RunREPL,
+                     (lldb::LanguageType, const char *), language,
+                     repl_options);
+
   SBError error;
   if (m_opaque_sp)
     error.ref() = m_opaque_sp->RunREPL(language, repl_options);
   else
     error.SetErrorString("invalid debugger");
-  return error;
+  return LLDB_RECORD_RESULT(error);
 }
 
 void SBDebugger::reset(const DebuggerSP &debugger_sp) {

 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);
+
   // 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 sb_debugger;
+  return LLDB_RECORD_RESULT(sb_debugger);
 }
 
 const char *SBDebugger::GetInstanceName() {
+  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBDebugger, GetInstanceName);
+
   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);
+
   SBError sb_error;
   DebuggerSP debugger_sp(Debugger::FindDebuggerWithInstanceName(
       ConstString(debugger_instance_name)));

   }
   if (error.Fail())
     sb_error.SetError(error);
-  return sb_error;
+  return LLDB_RECORD_RESULT(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);
+
   SBStringList ret_value;
   DebuggerSP debugger_sp(Debugger::FindDebuggerWithInstanceName(
       ConstString(debugger_instance_name)));

       if (!value_str.empty()) {
         StringList string_list;
         string_list.SplitIntoLines(value_str);
-        return SBStringList(&string_list);
+        return LLDB_RECORD_RESULT(SBStringList(&string_list));
       }
     }
   }
-  return SBStringList();
+  return LLDB_RECORD_RESULT(SBStringList());
 }
 
 uint32_t SBDebugger::GetTerminalWidth() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBDebugger, GetTerminalWidth);
+
   return (m_opaque_sp ? m_opaque_sp->GetTerminalWidth() : 0);
 }
 
 void SBDebugger::SetTerminalWidth(uint32_t term_width) {
+  LLDB_RECORD_METHOD(void, SBDebugger, SetTerminalWidth, (uint32_t),
+                     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);
+
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   if (log)

 }
 
 void SBDebugger::SetPrompt(const char *prompt) {
+  LLDB_RECORD_METHOD(void, SBDebugger, SetPrompt, (const char *), prompt);
+
   if (m_opaque_sp)
     m_opaque_sp->SetPrompt(llvm::StringRef::withNullAsEmpty(prompt));
 }
 
 const char *SBDebugger::GetReproducerPath() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBDebugger, GetReproducerPath);
+
   return (m_opaque_sp
               ? ConstString(m_opaque_sp->GetReproducerPath()).GetCString()
               : nullptr);
 }
 
 ScriptLanguage SBDebugger::GetScriptLanguage() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::ScriptLanguage, SBDebugger,
+                                   GetScriptLanguage);
+
   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);
+
   if (m_opaque_sp) {
     m_opaque_sp->SetScriptLanguage(script_lang);
   }
 }
 
 bool SBDebugger::SetUseExternalEditor(bool value) {
+  LLDB_RECORD_METHOD(bool, SBDebugger, SetUseExternalEditor, (bool), value);
+
   return (m_opaque_sp ? m_opaque_sp->SetUseExternalEditor(value) : false);
 }
 
 bool SBDebugger::GetUseExternalEditor() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBDebugger, GetUseExternalEditor);
+
   return (m_opaque_sp ? m_opaque_sp->GetUseExternalEditor() : false);
 }
 
 bool SBDebugger::SetUseColor(bool value) {
+  LLDB_RECORD_METHOD(bool, SBDebugger, SetUseColor, (bool), value);
+
   return (m_opaque_sp ? m_opaque_sp->SetUseColor(value) : false);
 }
 
 bool SBDebugger::GetUseColor() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBDebugger, GetUseColor);
+
   return (m_opaque_sp ? m_opaque_sp->GetUseColor() : false);
 }
 
 bool SBDebugger::GetDescription(SBStream &description) {
+  LLDB_RECORD_METHOD(bool, SBDebugger, GetDescription, (lldb::SBStream &),
+                     description);
+
   Stream &strm = description.ref();
 
   if (m_opaque_sp) {

 }
 
 user_id_t SBDebugger::GetID() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::user_id_t, SBDebugger, GetID);
+
   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);
+
   SBError sb_error;
   if (m_opaque_sp) {
     if (platform_name_cstr && platform_name_cstr[0]) {

   } else {
     sb_error.ref().SetErrorString("invalid debugger");
   }
-  return sb_error;
+  return LLDB_RECORD_RESULT(sb_error);
 }
 
 bool SBDebugger::SetCurrentPlatformSDKRoot(const char *sysroot) {
+  LLDB_RECORD_METHOD(bool, SBDebugger, SetCurrentPlatformSDKRoot,
+                     (const char *), sysroot);
+
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   if (m_opaque_sp) {
     PlatformSP platform_sp(

 }
 
 bool SBDebugger::GetCloseInputOnEOF() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBDebugger, GetCloseInputOnEOF);
+
   return (m_opaque_sp ? m_opaque_sp->GetCloseInputOnEOF() : false);
 }
 
 void SBDebugger::SetCloseInputOnEOF(bool b) {
+  LLDB_RECORD_METHOD(void, SBDebugger, SetCloseInputOnEOF, (bool), 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);
+
   if (!category_name || *category_name == 0)
-    return SBTypeCategory();
+    return LLDB_RECORD_RESULT(SBTypeCategory());
 
   TypeCategoryImplSP category_sp;
 
   if (DataVisualization::Categories::GetCategory(ConstString(category_name),
-                                                 category_sp, false))
-    return SBTypeCategory(category_sp);
-  else
-    return SBTypeCategory();
+                                                 category_sp, false)) {
+    return LLDB_RECORD_RESULT(SBTypeCategory(category_sp));
+  } else {
+    return LLDB_RECORD_RESULT(SBTypeCategory());
+  }
 }
 
 SBTypeCategory SBDebugger::GetCategory(lldb::LanguageType lang_type) {
+  LLDB_RECORD_METHOD(lldb::SBTypeCategory, SBDebugger, GetCategory,
+                     (lldb::LanguageType), lang_type);
+
   TypeCategoryImplSP category_sp;
-  if (DataVisualization::Categories::GetCategory(lang_type, category_sp))
-    return SBTypeCategory(category_sp);
-  else
-    return SBTypeCategory();
+  if (DataVisualization::Categories::GetCategory(lang_type, category_sp)) {
+    return LLDB_RECORD_RESULT(SBTypeCategory(category_sp));
+  } else {
+    return LLDB_RECORD_RESULT(SBTypeCategory());
+  }
 }
 
 SBTypeCategory SBDebugger::CreateCategory(const char *category_name) {
+  LLDB_RECORD_METHOD(lldb::SBTypeCategory, SBDebugger, CreateCategory,
+                     (const char *), category_name);
+
   if (!category_name || *category_name == 0)
-    return SBTypeCategory();
+    return LLDB_RECORD_RESULT(SBTypeCategory());
 
   TypeCategoryImplSP category_sp;
 
   if (DataVisualization::Categories::GetCategory(ConstString(category_name),
-                                                 category_sp, true))
-    return SBTypeCategory(category_sp);
-  else
-    return SBTypeCategory();
+                                                 category_sp, true)) {
+    return LLDB_RECORD_RESULT(SBTypeCategory(category_sp));
+  } else {
+    return LLDB_RECORD_RESULT(SBTypeCategory());
+  }
 }
 
 bool SBDebugger::DeleteCategory(const char *category_name) {
+  LLDB_RECORD_METHOD(bool, SBDebugger, DeleteCategory, (const char *),
+                     category_name);
+
   if (!category_name || *category_name == 0)
     return false;
 

 }
 
 uint32_t SBDebugger::GetNumCategories() {
+  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBDebugger, GetNumCategories);
+
   return DataVisualization::Categories::GetCount();
 }
 
 SBTypeCategory SBDebugger::GetCategoryAtIndex(uint32_t index) {
-  return SBTypeCategory(
-      DataVisualization::Categories::GetCategoryAtIndex(index));
+  LLDB_RECORD_METHOD(lldb::SBTypeCategory, SBDebugger, GetCategoryAtIndex,
+                     (uint32_t), index);
+
+  return LLDB_RECORD_RESULT(
+      SBTypeCategory(DataVisualization::Categories::GetCategoryAtIndex(index)));
 }
 
 SBTypeCategory SBDebugger::GetDefaultCategory() {
-  return GetCategory("default");
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTypeCategory, SBDebugger,
+                             GetDefaultCategory);
+
+  return LLDB_RECORD_RESULT(GetCategory("default"));
 }
 
 SBTypeFormat SBDebugger::GetFormatForType(SBTypeNameSpecifier type_name) {
+  LLDB_RECORD_METHOD(lldb::SBTypeFormat, SBDebugger, GetFormatForType,
+                     (lldb::SBTypeNameSpecifier), type_name);
+
   SBTypeCategory default_category_sb = GetDefaultCategory();
   if (default_category_sb.GetEnabled())
-    return default_category_sb.GetFormatForType(type_name);
-  return SBTypeFormat();
+    return LLDB_RECORD_RESULT(default_category_sb.GetFormatForType(type_name));
+  return LLDB_RECORD_RESULT(SBTypeFormat());
 }
 
 #ifndef LLDB_DISABLE_PYTHON
 SBTypeSummary SBDebugger::GetSummaryForType(SBTypeNameSpecifier type_name) {
+  LLDB_RECORD_METHOD(lldb::SBTypeSummary, SBDebugger, GetSummaryForType,
+                     (lldb::SBTypeNameSpecifier), type_name);
+
   if (!type_name.IsValid())
-    return SBTypeSummary();
-  return SBTypeSummary(DataVisualization::GetSummaryForType(type_name.GetSP()));
+    return LLDB_RECORD_RESULT(SBTypeSummary());
+  return LLDB_RECORD_RESULT(
+      SBTypeSummary(DataVisualization::GetSummaryForType(type_name.GetSP())));
 }
 #endif // LLDB_DISABLE_PYTHON
 
 SBTypeFilter SBDebugger::GetFilterForType(SBTypeNameSpecifier type_name) {
+  LLDB_RECORD_METHOD(lldb::SBTypeFilter, SBDebugger, GetFilterForType,
+                     (lldb::SBTypeNameSpecifier), type_name);
+
   if (!type_name.IsValid())
-    return SBTypeFilter();
-  return SBTypeFilter(DataVisualization::GetFilterForType(type_name.GetSP()));
+    return LLDB_RECORD_RESULT(SBTypeFilter());
+  return LLDB_RECORD_RESULT(
+      SBTypeFilter(DataVisualization::GetFilterForType(type_name.GetSP())));
 }
 
 #ifndef LLDB_DISABLE_PYTHON
 SBTypeSynthetic SBDebugger::GetSyntheticForType(SBTypeNameSpecifier type_name) {
+  LLDB_RECORD_METHOD(lldb::SBTypeSynthetic, SBDebugger, GetSyntheticForType,
+                     (lldb::SBTypeNameSpecifier), type_name);
+
   if (!type_name.IsValid())
-    return SBTypeSynthetic();
-  return SBTypeSynthetic(
-      DataVisualization::GetSyntheticForType(type_name.GetSP()));
+    return LLDB_RECORD_RESULT(SBTypeSynthetic());
+  return LLDB_RECORD_RESULT(SBTypeSynthetic(
+      DataVisualization::GetSyntheticForType(type_name.GetSP())));
 }
 #endif // LLDB_DISABLE_PYTHON
 

 }
 
 bool SBDebugger::EnableLog(const char *channel, const char **categories) {
+  LLDB_RECORD_METHOD(bool, SBDebugger, EnableLog, (const char *, const char **),
+                     channel, categories);
+
   if (m_opaque_sp) {
     uint32_t log_options =
         LLDB_LOG_OPTION_PREPEND_TIMESTAMP | LLDB_LOG_OPTION_PREPEND_THREAD_NAME;

lldb/source/API/SBDeclaration.cpp

 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBDeclaration.h"
+#include "SBReproducerPrivate.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/Host/PosixApi.h"
 #include "lldb/Symbol/Declaration.h"

 using namespace lldb;
 using namespace lldb_private;
 
-SBDeclaration::SBDeclaration() : m_opaque_up() {}
+SBDeclaration::SBDeclaration() : m_opaque_up() {
+  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBDeclaration);
+}
 
 SBDeclaration::SBDeclaration(const SBDeclaration &rhs) : m_opaque_up() {
+  LLDB_RECORD_CONSTRUCTOR(SBDeclaration, (const lldb::SBDeclaration &), rhs);
+
   if (rhs.IsValid())
     ref() = rhs.ref();
 }

 }
 
 const SBDeclaration &SBDeclaration::operator=(const SBDeclaration &rhs) {
+  LLDB_RECORD_METHOD(const lldb::SBDeclaration &,
+                     SBDeclaration, operator=,(const lldb::SBDeclaration &),
+                     rhs);
+
   if (this != &rhs) {
     if (rhs.IsValid())
       ref() = rhs.ref();

 SBDeclaration::~SBDeclaration() {}
 
 bool SBDeclaration::IsValid() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBDeclaration, IsValid);
+
   return m_opaque_up.get() && m_opaque_up->IsValid();
 }
 
 SBFileSpec SBDeclaration::GetFileSpec() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBFileSpec, SBDeclaration,
+                                   GetFileSpec);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   SBFileSpec sb_file_spec;

                 static_cast<const void *>(sb_file_spec.get()), sstr.GetData());
   }
 
-  return sb_file_spec;
+  return LLDB_RECORD_RESULT(sb_file_spec);
 }
 
 uint32_t SBDeclaration::GetLine() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBDeclaration, GetLine);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   uint32_t line = 0;

 }
 
 uint32_t SBDeclaration::GetColumn() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBDeclaration, GetColumn);
+
   if (m_opaque_up)
     return m_opaque_up->GetColumn();
   return 0;
 }
 
 void SBDeclaration::SetFileSpec(lldb::SBFileSpec filespec) {
+  LLDB_RECORD_METHOD(void, SBDeclaration, SetFileSpec, (lldb::SBFileSpec),
+                     filespec);
+
   if (filespec.IsValid())
     ref().SetFile(filespec.ref());
   else
     ref().SetFile(FileSpec());
 }
-void SBDeclaration::SetLine(uint32_t line) { ref().SetLine(line); }
+void SBDeclaration::SetLine(uint32_t line) {
+  LLDB_RECORD_METHOD(void, SBDeclaration, SetLine, (uint32_t), line);
 
-void SBDeclaration::SetColumn(uint32_t column) { ref().SetColumn(column); }
+  ref().SetLine(line);
+}
+
+void SBDeclaration::SetColumn(uint32_t column) {
+  LLDB_RECORD_METHOD(void, SBDeclaration, SetColumn, (uint32_t), column);
+
+  ref().SetColumn(column);
+}
 
 bool SBDeclaration::operator==(const SBDeclaration &rhs) const {
+  LLDB_RECORD_METHOD_CONST(
+      bool, SBDeclaration, operator==,(const lldb::SBDeclaration &), rhs);
+
   lldb_private::Declaration *lhs_ptr = m_opaque_up.get();
   lldb_private::Declaration *rhs_ptr = rhs.m_opaque_up.get();
 

 }
 
 bool SBDeclaration::operator!=(const SBDeclaration &rhs) const {
+  LLDB_RECORD_METHOD_CONST(
+      bool, SBDeclaration, operator!=,(const lldb::SBDeclaration &), rhs);
+
   lldb_private::Declaration *lhs_ptr = m_opaque_up.get();
   lldb_private::Declaration *rhs_ptr = rhs.m_opaque_up.get();
 

 }
 
 bool SBDeclaration::GetDescription(SBStream &description) {
+  LLDB_RECORD_METHOD(bool, SBDeclaration, GetDescription, (lldb::SBStream &),
+                     description);
+
   Stream &strm = description.ref();
 
   if (m_opaque_up) {

lldb/source/API/SBError.cpp

 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBError.h"
+#include "SBReproducerPrivate.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/Status.h"

 using namespace lldb;
 using namespace lldb_private;
 
-SBError::SBError() : m_opaque_up() {}
+SBError::SBError() : m_opaque_up() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBError); }
 
 SBError::SBError(const SBError &rhs) : m_opaque_up() {
+  LLDB_RECORD_CONSTRUCTOR(SBError, (const lldb::SBError &), rhs);
+
   if (rhs.IsValid())
     m_opaque_up.reset(new Status(*rhs));
 }

 SBError::~SBError() {}
 
 const SBError &SBError::operator=(const SBError &rhs) {
+  LLDB_RECORD_METHOD(const lldb::SBError &,
+                     SBError, operator=,(const lldb::SBError &), rhs);
+
   if (rhs.IsValid()) {
     if (m_opaque_up)
       *m_opaque_up = *rhs;

 }
 
 const char *SBError::GetCString() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBError, GetCString);
+
   if (m_opaque_up)
     return m_opaque_up->AsCString();
   return NULL;
 }
 
 void SBError::Clear() {
+  LLDB_RECORD_METHOD_NO_ARGS(void, SBError, Clear);
+
   if (m_opaque_up)
     m_opaque_up->Clear();
 }
 
 bool SBError::Fail() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBError, Fail);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   bool ret_value = false;

 }
 
 bool SBError::Success() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBError, Success);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   bool ret_value = true;
   if (m_opaque_up)

 }
 
 uint32_t SBError::GetError() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBError, GetError);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   uint32_t err = 0;

 }
 
 ErrorType SBError::GetType() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::ErrorType, SBError, GetType);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   ErrorType err_type = eErrorTypeInvalid;
   if (m_opaque_up)

 }
 
 void SBError::SetError(uint32_t err, ErrorType type) {
+  LLDB_RECORD_METHOD(void, SBError, SetError, (uint32_t, lldb::ErrorType), err,
+                     type);
+
   CreateIfNeeded();
   m_opaque_up->SetError(err, type);
 }

 }
 
 void SBError::SetErrorToErrno() {
+  LLDB_RECORD_METHOD_NO_ARGS(void, SBError, SetErrorToErrno);
+
   CreateIfNeeded();
   m_opaque_up->SetErrorToErrno();
 }
 
 void SBError::SetErrorToGenericError() {
+  LLDB_RECORD_METHOD_NO_ARGS(void, SBError, SetErrorToGenericError);
+
   CreateIfNeeded();
   m_opaque_up->SetErrorToErrno();
 }
 
 void SBError::SetErrorString(const char *err_str) {
+  LLDB_RECORD_METHOD(void, SBError, SetErrorString, (const char *), err_str);
+
   CreateIfNeeded();
   m_opaque_up->SetErrorString(err_str);
 }

   return num_chars;
 }
 
-bool SBError::IsValid() const { return m_opaque_up != NULL; }
+bool SBError::IsValid() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBError, IsValid);
+
+  return m_opaque_up != NULL;
+}
 
 void SBError::CreateIfNeeded() {
   if (m_opaque_up == NULL)

 }
 
 bool SBError::GetDescription(SBStream &description) {
+  LLDB_RECORD_METHOD(bool, SBError, GetDescription, (lldb::SBStream &),
+                     description);
+
   if (m_opaque_up) {
     if (m_opaque_up->Success())
       description.Printf("success");

lldb/source/API/SBEvent.cpp

 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBEvent.h"
+#include "SBReproducerPrivate.h"
 #include "lldb/API/SBBroadcaster.h"
 #include "lldb/API/SBStream.h"
 

 using namespace lldb;
 using namespace lldb_private;
 
-SBEvent::SBEvent() : m_event_sp(), m_opaque_ptr(NULL) {}
+SBEvent::SBEvent() : m_event_sp(), m_opaque_ptr(NULL) {
+  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBEvent);
+}
 
 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()) {}
+      m_opaque_ptr(m_event_sp.get()) {
+  LLDB_RECORD_CONSTRUCTOR(SBEvent, (uint32_t, const char *, uint32_t),
+                          event_type, cstr, cstr_len);
+}
 
 SBEvent::SBEvent(EventSP &event_sp)
-    : m_event_sp(event_sp), m_opaque_ptr(event_sp.get()) {}
+    : m_event_sp(event_sp), m_opaque_ptr(event_sp.get()) {
+  LLDB_RECORD_CONSTRUCTOR(SBEvent, (lldb::EventSP &), event_sp);
+}
 
-SBEvent::SBEvent(Event *event_ptr) : m_event_sp(), m_opaque_ptr(event_ptr) {}
+SBEvent::SBEvent(Event *event_ptr) : m_event_sp(), m_opaque_ptr(event_ptr) {
+  LLDB_RECORD_CONSTRUCTOR(SBEvent, (lldb_private::Event *), event_ptr);
+}
 
 SBEvent::SBEvent(const SBEvent &rhs)
-    : m_event_sp(rhs.m_event_sp), m_opaque_ptr(rhs.m_opaque_ptr) {}
+    : m_event_sp(rhs.m_event_sp), m_opaque_ptr(rhs.m_opaque_ptr) {
+  LLDB_RECORD_CONSTRUCTOR(SBEvent, (const lldb::SBEvent &), rhs);
+}
 
 const SBEvent &SBEvent::operator=(const SBEvent &rhs) {
+  LLDB_RECORD_METHOD(const lldb::SBEvent &,
+                     SBEvent, operator=,(const lldb::SBEvent &), rhs);
+
   if (this != &rhs) {
     m_event_sp = rhs.m_event_sp;
     m_opaque_ptr = rhs.m_opaque_ptr;

 SBEvent::~SBEvent() {}
 
 const char *SBEvent::GetDataFlavor() {
+  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBEvent, GetDataFlavor);
+
   Event *lldb_event = get();
   if (lldb_event) {
     EventData *event_data = lldb_event->GetData();

 }
 
 uint32_t SBEvent::GetType() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBEvent, GetType);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   const Event *lldb_event = get();

 }
 
 SBBroadcaster SBEvent::GetBroadcaster() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBBroadcaster, SBEvent,
+                                   GetBroadcaster);
+
   SBBroadcaster broadcaster;
   const Event *lldb_event = get();
   if (lldb_event)
     broadcaster.reset(lldb_event->GetBroadcaster(), false);
-  return broadcaster;
+  return LLDB_RECORD_RESULT(broadcaster);
 }
 
 const char *SBEvent::GetBroadcasterClass() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBEvent, GetBroadcasterClass);
+
   const Event *lldb_event = get();
   if (lldb_event)
     return lldb_event->GetBroadcaster()->GetBroadcasterClass().AsCString();

 }
 
 bool SBEvent::BroadcasterMatchesPtr(const SBBroadcaster *broadcaster) {
+  LLDB_RECORD_METHOD(bool, SBEvent, BroadcasterMatchesPtr,
+                     (const lldb::SBBroadcaster *), broadcaster);
+
   if (broadcaster)
     return BroadcasterMatchesRef(*broadcaster);
   return false;
 }
 
 bool SBEvent::BroadcasterMatchesRef(const SBBroadcaster &broadcaster) {
+  LLDB_RECORD_METHOD(bool, SBEvent, BroadcasterMatchesRef,
+                     (const lldb::SBBroadcaster &), broadcaster);
 
   Event *lldb_event = get();
   bool success = false;

 }
 
 void SBEvent::Clear() {
+  LLDB_RECORD_METHOD_NO_ARGS(void, SBEvent, Clear);
+
   Event *lldb_event = get();
   if (lldb_event)
     lldb_event->Clear();

 }
 
 bool SBEvent::IsValid() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBEvent, IsValid);
+
   // Do NOT use m_opaque_ptr directly!!! Must use the SBEvent::get() accessor.
   // See comments in SBEvent::get()....
   return SBEvent::get() != NULL;
 }
 
 const char *SBEvent::GetCStringFromEvent(const SBEvent &event) {
+  LLDB_RECORD_STATIC_METHOD(const char *, SBEvent, GetCStringFromEvent,
+                            (const lldb::SBEvent &), event);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   if (log)

 }
 
 bool SBEvent::GetDescription(SBStream &description) {
+  LLDB_RECORD_METHOD(bool, SBEvent, GetDescription, (lldb::SBStream &),
+                     description);
+
   Stream &strm = description.ref();
 
   if (get()) {

 }
 
 bool SBEvent::GetDescription(SBStream &description) const {
+  LLDB_RECORD_METHOD_CONST(bool, SBEvent, GetDescription, (lldb::SBStream &),
+                           description);
+
   Stream &strm = description.ref();
 
   if (get()) {

lldb/source/API/SBExecutionContext.cpp

 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBExecutionContext.h"
+#include "SBReproducerPrivate.h"
 
 #include "lldb/API/SBFrame.h"
 #include "lldb/API/SBProcess.h"

 using namespace lldb;
 using namespace lldb_private;
 
-SBExecutionContext::SBExecutionContext() : m_exe_ctx_sp() {}
+SBExecutionContext::SBExecutionContext() : m_exe_ctx_sp() {
+  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBExecutionContext);
+}
 
 SBExecutionContext::SBExecutionContext(const lldb::SBExecutionContext &rhs)
-    : m_exe_ctx_sp(rhs.m_exe_ctx_sp) {}
+    : m_exe_ctx_sp(rhs.m_exe_ctx_sp) {
+  LLDB_RECORD_CONSTRUCTOR(SBExecutionContext,
+                          (const lldb::SBExecutionContext &), rhs);
+}
 
 SBExecutionContext::SBExecutionContext(
     lldb::ExecutionContextRefSP exe_ctx_ref_sp)
-    : m_exe_ctx_sp(exe_ctx_ref_sp) {}
+    : m_exe_ctx_sp(exe_ctx_ref_sp) {
+  LLDB_RECORD_CONSTRUCTOR(SBExecutionContext, (lldb::ExecutionContextRefSP),
+                          exe_ctx_ref_sp);
+}
 
 SBExecutionContext::SBExecutionContext(const lldb::SBTarget &target)
     : m_exe_ctx_sp(new ExecutionContextRef()) {
+  LLDB_RECORD_CONSTRUCTOR(SBExecutionContext, (const lldb::SBTarget &), 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);
+
   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);
+
   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);
+
   m_exe_ctx_sp->SetFrameSP(frame.GetFrameSP());
 }
 

 
 const SBExecutionContext &SBExecutionContext::
 operator=(const lldb::SBExecutionContext &rhs) {
+  LLDB_RECORD_METHOD(
+      const lldb::SBExecutionContext &,
+      SBExecutionContext, operator=,(const lldb::SBExecutionContext &), rhs);
+
   m_exe_ctx_sp = rhs.m_exe_ctx_sp;
   return *this;
 }

 }
 
 SBTarget SBExecutionContext::GetTarget() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBTarget, SBExecutionContext,
+                                   GetTarget);
+
   SBTarget sb_target;
   if (m_exe_ctx_sp) {
     TargetSP target_sp(m_exe_ctx_sp->GetTargetSP());
     if (target_sp)
       sb_target.SetSP(target_sp);
   }
-  return sb_target;
+  return LLDB_RECORD_RESULT(sb_target);
 }
 
 SBProcess SBExecutionContext::GetProcess() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBProcess, SBExecutionContext,
+                                   GetProcess);
+
   SBProcess sb_process;
   if (m_exe_ctx_sp) {
     ProcessSP process_sp(m_exe_ctx_sp->GetProcessSP());
     if (process_sp)
       sb_process.SetSP(process_sp);
   }
-  return sb_process;
+  return LLDB_RECORD_RESULT(sb_process);
 }
 
 SBThread SBExecutionContext::GetThread() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBThread, SBExecutionContext,
+                                   GetThread);
+
   SBThread sb_thread;
   if (m_exe_ctx_sp) {
     ThreadSP thread_sp(m_exe_ctx_sp->GetThreadSP());
     if (thread_sp)
       sb_thread.SetThread(thread_sp);
   }
-  return sb_thread;
+  return LLDB_RECORD_RESULT(sb_thread);
 }
 
 SBFrame SBExecutionContext::GetFrame() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBFrame, SBExecutionContext, GetFrame);
+
   SBFrame sb_frame;
   if (m_exe_ctx_sp) {
     StackFrameSP frame_sp(m_exe_ctx_sp->GetFrameSP());
     if (frame_sp)
       sb_frame.SetFrameSP(frame_sp);
   }
-  return sb_frame;
+  return LLDB_RECORD_RESULT(sb_frame);
 }

lldb/source/API/SBExpressionOptions.cpp

 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBExpressionOptions.h"
+#include "SBReproducerPrivate.h"
 #include "lldb/API/SBStream.h"
 
 #include "lldb/Target/Target.h"

 using namespace lldb_private;
 
 SBExpressionOptions::SBExpressionOptions()
-    : m_opaque_up(new EvaluateExpressionOptions()) {}
+    : m_opaque_up(new EvaluateExpressionOptions()) {
+  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBExpressionOptions);
+}
 
 SBExpressionOptions::SBExpressionOptions(const SBExpressionOptions &rhs) {
+  LLDB_RECORD_CONSTRUCTOR(SBExpressionOptions,
+                          (const lldb::SBExpressionOptions &), rhs);
+
   m_opaque_up.reset(new EvaluateExpressionOptions());
   *(m_opaque_up.get()) = rhs.ref();
 }
 
 const SBExpressionOptions &SBExpressionOptions::
 operator=(const SBExpressionOptions &rhs) {
+  LLDB_RECORD_METHOD(
+      const lldb::SBExpressionOptions &,
+      SBExpressionOptions, operator=,(const lldb::SBExpressionOptions &), rhs);
+
   if (this != &rhs) {
     this->ref() = rhs.ref();
   }

 SBExpressionOptions::~SBExpressionOptions() {}
 
 bool SBExpressionOptions::GetCoerceResultToId() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBExpressionOptions,
+                                   GetCoerceResultToId);
+
   return m_opaque_up->DoesCoerceToId();
 }
 
 void SBExpressionOptions::SetCoerceResultToId(bool coerce) {
+  LLDB_RECORD_METHOD(void, SBExpressionOptions, SetCoerceResultToId, (bool),
+                     coerce);
+
   m_opaque_up->SetCoerceToId(coerce);
 }
 
 bool SBExpressionOptions::GetUnwindOnError() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBExpressionOptions, GetUnwindOnError);
+
   return m_opaque_up->DoesUnwindOnError();
 }
 
 void SBExpressionOptions::SetUnwindOnError(bool unwind) {
+  LLDB_RECORD_METHOD(void, SBExpressionOptions, SetUnwindOnError, (bool),
+                     unwind);
+
   m_opaque_up->SetUnwindOnError(unwind);
 }
 
 bool SBExpressionOptions::GetIgnoreBreakpoints() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBExpressionOptions,
+                                   GetIgnoreBreakpoints);
+
   return m_opaque_up->DoesIgnoreBreakpoints();
 }
 
 void SBExpressionOptions::SetIgnoreBreakpoints(bool ignore) {
+  LLDB_RECORD_METHOD(void, SBExpressionOptions, SetIgnoreBreakpoints, (bool),
+                     ignore);
+
   m_opaque_up->SetIgnoreBreakpoints(ignore);
 }
 
 lldb::DynamicValueType SBExpressionOptions::GetFetchDynamicValue() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::DynamicValueType, SBExpressionOptions,
+                                   GetFetchDynamicValue);
+
   return m_opaque_up->GetUseDynamic();
 }
 
 void SBExpressionOptions::SetFetchDynamicValue(lldb::DynamicValueType dynamic) {
+  LLDB_RECORD_METHOD(void, SBExpressionOptions, SetFetchDynamicValue,
+                     (lldb::DynamicValueType), dynamic);
+
   m_opaque_up->SetUseDynamic(dynamic);
 }
 
 uint32_t SBExpressionOptions::GetTimeoutInMicroSeconds() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBExpressionOptions,
+                                   GetTimeoutInMicroSeconds);
+
   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);
+
   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);
+
   return m_opaque_up->GetOneThreadTimeout()
              ? m_opaque_up->GetOneThreadTimeout()->count()
              : 0;
 }
 
 void SBExpressionOptions::SetOneThreadTimeoutInMicroSeconds(uint32_t timeout) {
+  LLDB_RECORD_METHOD(void, SBExpressionOptions,
+                     SetOneThreadTimeoutInMicroSeconds, (uint32_t), timeout);
+
   m_opaque_up->SetOneThreadTimeout(timeout == 0
                                        ? Timeout<std::micro>(llvm::None)
                                        : std::chrono::microseconds(timeout));
 }
 
 bool SBExpressionOptions::GetTryAllThreads() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBExpressionOptions, GetTryAllThreads);
+
   return m_opaque_up->GetTryAllThreads();
 }
 
 void SBExpressionOptions::SetTryAllThreads(bool run_others) {
+  LLDB_RECORD_METHOD(void, SBExpressionOptions, SetTryAllThreads, (bool),
+                     run_others);
+
   m_opaque_up->SetTryAllThreads(run_others);
 }
 
 bool SBExpressionOptions::GetStopOthers() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBExpressionOptions, GetStopOthers);
+
   return m_opaque_up->GetStopOthers();
 }
 
 void SBExpressionOptions::SetStopOthers(bool run_others) {
+  LLDB_RECORD_METHOD(void, SBExpressionOptions, SetStopOthers, (bool),
+                     run_others);
+
   m_opaque_up->SetStopOthers(run_others);
 }
 
 bool SBExpressionOptions::GetTrapExceptions() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBExpressionOptions,
+                                   GetTrapExceptions);
+
   return m_opaque_up->GetTrapExceptions();
 }
 
 void SBExpressionOptions::SetTrapExceptions(bool trap_exceptions) {
+  LLDB_RECORD_METHOD(void, SBExpressionOptions, SetTrapExceptions, (bool),
+                     trap_exceptions);
+
   m_opaque_up->SetTrapExceptions(trap_exceptions);
 }
 
 void SBExpressionOptions::SetLanguage(lldb::LanguageType language) {
+  LLDB_RECORD_METHOD(void, SBExpressionOptions, SetLanguage,
+                     (lldb::LanguageType), language);
+
   m_opaque_up->SetLanguage(language);
 }
 

 }
 
 bool SBExpressionOptions::GetGenerateDebugInfo() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBExpressionOptions, GetGenerateDebugInfo);
+
   return m_opaque_up->GetGenerateDebugInfo();
 }
 
 void SBExpressionOptions::SetGenerateDebugInfo(bool b) {
+  LLDB_RECORD_METHOD(void, SBExpressionOptions, SetGenerateDebugInfo, (bool),
+                     b);
+
   return m_opaque_up->SetGenerateDebugInfo(b);
 }
 
 bool SBExpressionOptions::GetSuppressPersistentResult() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBExpressionOptions,
+                             GetSuppressPersistentResult);
+
   return m_opaque_up->GetResultIsInternal();
 }
 
 void SBExpressionOptions::SetSuppressPersistentResult(bool b) {
+  LLDB_RECORD_METHOD(void, SBExpressionOptions, SetSuppressPersistentResult,
+                     (bool), b);
+
   return m_opaque_up->SetResultIsInternal(b);
 }
 
 const char *SBExpressionOptions::GetPrefix() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBExpressionOptions,
+                                   GetPrefix);
+
   return m_opaque_up->GetPrefix();
 }
 
 void SBExpressionOptions::SetPrefix(const char *prefix) {
+  LLDB_RECORD_METHOD(void, SBExpressionOptions, SetPrefix, (const char *),
+                     prefix);
+
   return m_opaque_up->SetPrefix(prefix);
 }
 
 bool SBExpressionOptions::GetAutoApplyFixIts() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBExpressionOptions, GetAutoApplyFixIts);
+
   return m_opaque_up->GetAutoApplyFixIts();
 }
 
 void SBExpressionOptions::SetAutoApplyFixIts(bool b) {
+  LLDB_RECORD_METHOD(void, SBExpressionOptions, SetAutoApplyFixIts, (bool), b);
+
   return m_opaque_up->SetAutoApplyFixIts(b);
 }
 
 bool SBExpressionOptions::GetTopLevel() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBExpressionOptions, GetTopLevel);
+
   return m_opaque_up->GetExecutionPolicy() == eExecutionPolicyTopLevel;
 }
 
 void SBExpressionOptions::SetTopLevel(bool b) {
+  LLDB_RECORD_METHOD(void, SBExpressionOptions, SetTopLevel, (bool), b);
+
   m_opaque_up->SetExecutionPolicy(b ? eExecutionPolicyTopLevel
                                     : m_opaque_up->default_execution_policy);
 }
 
 bool SBExpressionOptions::GetAllowJIT() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBExpressionOptions, GetAllowJIT);
+
   return m_opaque_up->GetExecutionPolicy() != eExecutionPolicyNever;
 }
 
 void SBExpressionOptions::SetAllowJIT(bool allow) {
+  LLDB_RECORD_METHOD(void, SBExpressionOptions, SetAllowJIT, (bool), allow);
+
   m_opaque_up->SetExecutionPolicy(allow ? m_opaque_up->default_execution_policy
                                         : eExecutionPolicyNever);
 }

lldb/source/API/SBFileSpec.cpp

 //
 //===----------------------------------------------------------------------===//
 
-#include <inttypes.h>
-#include <limits.h>
-
 #include "lldb/API/SBFileSpec.h"
+#include "SBReproducerPrivate.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/Host/FileSystem.h"
 #include "lldb/Host/PosixApi.h"

 
 #include "llvm/ADT/SmallString.h"
 
+#include <inttypes.h>
+#include <limits.h>
+
 using namespace lldb;
 using namespace lldb_private;
 
-SBFileSpec::SBFileSpec() : m_opaque_up(new lldb_private::FileSpec()) {}
+SBFileSpec::SBFileSpec() : m_opaque_up(new lldb_private::FileSpec()) {
+  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBFileSpec);
+}
 
 SBFileSpec::SBFileSpec(const SBFileSpec &rhs)
-    : m_opaque_up(new lldb_private::FileSpec(*rhs.m_opaque_up)) {}
+    : m_opaque_up(new lldb_private::FileSpec(*rhs.m_opaque_up)) {
+  LLDB_RECORD_CONSTRUCTOR(SBFileSpec, (const lldb::SBFileSpec &), rhs);
+}
 
 SBFileSpec::SBFileSpec(const lldb_private::FileSpec &fspec)
     : m_opaque_up(new lldb_private::FileSpec(fspec)) {}
 
 // Deprecated!!!
 SBFileSpec::SBFileSpec(const char *path) : m_opaque_up(new FileSpec(path)) {
+  LLDB_RECORD_CONSTRUCTOR(SBFileSpec, (const char *), 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);
+
   if (resolve)
     FileSystem::Instance().Resolve(*m_opaque_up);
 }

 SBFileSpec::~SBFileSpec() {}
 
 const SBFileSpec &SBFileSpec::operator=(const SBFileSpec &rhs) {
+  LLDB_RECORD_METHOD(const lldb::SBFileSpec &,
+                     SBFileSpec, operator=,(const lldb::SBFileSpec &), rhs);
+
   if (this != &rhs)
     *m_opaque_up = *rhs.m_opaque_up;
   return *this;
 }
 
-bool SBFileSpec::IsValid() const { return m_opaque_up->operator bool(); }
+bool SBFileSpec::IsValid() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBFileSpec, IsValid);
+
+  return m_opaque_up->operator bool();
+}
 
 bool SBFileSpec::Exists() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBFileSpec, Exists);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   bool result = FileSystem::Instance().Exists(*m_opaque_up);

 }
 
 bool SBFileSpec::ResolveExecutableLocation() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBFileSpec, ResolveExecutableLocation);
+
   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);
+
   llvm::SmallString<64> result(src_path);
   FileSystem::Instance().Resolve(result);
   ::snprintf(dst_path, dst_len, "%s", result.c_str());

 }
 
 const char *SBFileSpec::GetFilename() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBFileSpec, GetFilename);
+
   const char *s = m_opaque_up->GetFilename().AsCString();
 
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));

 }
 
 const char *SBFileSpec::GetDirectory() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBFileSpec, GetDirectory);
+
   FileSpec directory{*m_opaque_up};
   directory.GetFilename().Clear();
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));

 }
 
 void SBFileSpec::SetFilename(const char *filename) {
+  LLDB_RECORD_METHOD(void, SBFileSpec, SetFilename, (const char *), filename);
+
   if (filename && filename[0])
     m_opaque_up->GetFilename().SetCString(filename);
   else

 }
 
 void SBFileSpec::SetDirectory(const char *directory) {
+  LLDB_RECORD_METHOD(void, SBFileSpec, SetDirectory, (const char *), directory);
+
   if (directory && directory[0])
     m_opaque_up->GetDirectory().SetCString(directory);
   else

 }
 
 uint32_t SBFileSpec::GetPath(char *dst_path, size_t dst_len) const {
+  LLDB_RECORD_METHOD_CONST(uint32_t, SBFileSpec, GetPath, (char *, size_t),
+                           dst_path, dst_len);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   uint32_t result = m_opaque_up->GetPath(dst_path, dst_len);

 }
 
 bool SBFileSpec::GetDescription(SBStream &description) const {
+  LLDB_RECORD_METHOD_CONST(bool, SBFileSpec, GetDescription, (lldb::SBStream &),
+                           description);
+
   Stream &strm = description.ref();
   char path[PATH_MAX];
   if (m_opaque_up->GetPath(path, sizeof(path)))

 }
 
 void SBFileSpec::AppendPathComponent(const char *fn) {
+  LLDB_RECORD_METHOD(void, SBFileSpec, AppendPathComponent, (const char *), fn);
+
   m_opaque_up->AppendPathComponent(fn);
 }

lldb/source/API/SBFileSpecList.cpp

 //
 //===----------------------------------------------------------------------===//
 
-#include <limits.h>
-
-#include "lldb/API/SBFileSpec.h"
 #include "lldb/API/SBFileSpecList.h"
+#include "SBReproducerPrivate.h"
+#include "lldb/API/SBFileSpec.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/Core/FileSpecList.h"
 #include "lldb/Host/PosixApi.h"

 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/Stream.h"
 
+#include <limits.h>
+
 using namespace lldb;
 using namespace lldb_private;
 
-SBFileSpecList::SBFileSpecList() : m_opaque_up(new FileSpecList()) {}
+SBFileSpecList::SBFileSpecList() : m_opaque_up(new FileSpecList()) {
+  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBFileSpecList);
+}
 
 SBFileSpecList::SBFileSpecList(const SBFileSpecList &rhs) : m_opaque_up() {
+  LLDB_RECORD_CONSTRUCTOR(SBFileSpecList, (const lldb::SBFileSpecList &), rhs);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   if (rhs.m_opaque_up)

 SBFileSpecList::~SBFileSpecList() {}
 
 const SBFileSpecList &SBFileSpecList::operator=(const SBFileSpecList &rhs) {
+  LLDB_RECORD_METHOD(const lldb::SBFileSpecList &,
+                     SBFileSpecList, operator=,(const lldb::SBFileSpecList &),
+                     rhs);
+
   if (this != &rhs) {
     m_opaque_up.reset(new lldb_private::FileSpecList(*(rhs.get())));
   }
   return *this;
 }
 
-uint32_t SBFileSpecList::GetSize() const { return m_opaque_up->GetSize(); }
+uint32_t SBFileSpecList::GetSize() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBFileSpecList, GetSize);
+
+  return m_opaque_up->GetSize();
+}
 
 void SBFileSpecList::Append(const SBFileSpec &sb_file) {
+  LLDB_RECORD_METHOD(void, SBFileSpecList, Append, (const lldb::SBFileSpec &),
+                     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);
+
   return m_opaque_up->AppendIfUnique(sb_file.ref());
 }
 
-void SBFileSpecList::Clear() { m_opaque_up->Clear(); }
+void SBFileSpecList::Clear() {
+  LLDB_RECORD_METHOD_NO_ARGS(void, SBFileSpecList, Clear);
+
+  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);
+
   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);
+
   SBFileSpec new_spec;
   new_spec.SetFileSpec(m_opaque_up->GetFileSpecAtIndex(idx));
-  return new_spec;
+  return LLDB_RECORD_RESULT(new_spec);
 }
 
 const lldb_private::FileSpecList *SBFileSpecList::operator->() const {

 }
 
 bool SBFileSpecList::GetDescription(SBStream &description) const {
+  LLDB_RECORD_METHOD_CONST(bool, SBFileSpecList, GetDescription,
+                           (lldb::SBStream &), description);
+
   Stream &strm = description.ref();
 
   if (m_opaque_up) {

lldb/source/API/SBFrame.cpp

 #include "lldb/lldb-types.h"
 
 #include "Plugins/ExpressionParser/Clang/ClangPersistentVariables.h"
+#include "SBReproducerPrivate.h"
 #include "lldb/Core/Address.h"
 #include "lldb/Core/StreamFile.h"
 #include "lldb/Core/ValueObjectRegister.h"

 using namespace lldb;
 using namespace lldb_private;
 
-SBFrame::SBFrame() : m_opaque_sp(new ExecutionContextRef()) {}
+SBFrame::SBFrame() : m_opaque_sp(new ExecutionContextRef()) {
+  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBFrame);
+}
 
 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);
+
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   if (log) {

 }
 
 SBFrame::SBFrame(const SBFrame &rhs)
-    : m_opaque_sp(new ExecutionContextRef(*rhs.m_opaque_sp)) {}
+    : m_opaque_sp(new ExecutionContextRef(*rhs.m_opaque_sp)) {
+  LLDB_RECORD_CONSTRUCTOR(SBFrame, (const lldb::SBFrame &), rhs);
+}
 
 SBFrame::~SBFrame() = default;
 
 const SBFrame &SBFrame::operator=(const SBFrame &rhs) {
+  LLDB_RECORD_METHOD(const lldb::SBFrame &,
+                     SBFrame, operator=,(const lldb::SBFrame &), rhs);
+
   if (this != &rhs)
     *m_opaque_sp = *rhs.m_opaque_sp;
   return *this;

 }
 
 bool SBFrame::IsValid() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBFrame, IsValid);
+
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 

 }
 
 SBSymbolContext SBFrame::GetSymbolContext(uint32_t resolve_scope) const {
+  LLDB_RECORD_METHOD_CONST(lldb::SBSymbolContext, SBFrame, GetSymbolContext,
+                           (uint32_t), resolve_scope);
+
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   SBSymbolContext sb_sym_ctx;
   std::unique_lock<std::recursive_mutex> lock;

                 static_cast<void *>(frame), resolve_scope,
                 static_cast<void *>(sb_sym_ctx.get()));
 
-  return sb_sym_ctx;
+  return LLDB_RECORD_RESULT(sb_sym_ctx);
 }
 
 SBModule SBFrame::GetModule() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBModule, SBFrame, GetModule);
+
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   SBModule sb_module;
   ModuleSP module_sp;

                 static_cast<void *>(frame),
                 static_cast<void *>(module_sp.get()));
 
-  return sb_module;
+  return LLDB_RECORD_RESULT(sb_module);
 }
 
 SBCompileUnit SBFrame::GetCompileUnit() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBCompileUnit, SBFrame,
+                                   GetCompileUnit);
+
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   SBCompileUnit sb_comp_unit;
   std::unique_lock<std::recursive_mutex> lock;

                 static_cast<void *>(frame),
                 static_cast<void *>(sb_comp_unit.get()));
 
-  return sb_comp_unit;
+  return LLDB_RECORD_RESULT(sb_comp_unit);
 }
 
 SBFunction SBFrame::GetFunction() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBFunction, SBFrame, GetFunction);
+
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   SBFunction sb_function;
   std::unique_lock<std::recursive_mutex> lock;

                 static_cast<void *>(frame),
                 static_cast<void *>(sb_function.get()));
 
-  return sb_function;
+  return LLDB_RECORD_RESULT(sb_function);
 }
 
 SBSymbol SBFrame::GetSymbol() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBSymbol, SBFrame, GetSymbol);
+
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   SBSymbol sb_symbol;
   std::unique_lock<std::recursive_mutex> lock;

     log->Printf("SBFrame(%p)::GetSymbol () => SBSymbol(%p)",
                 static_cast<void *>(frame),
                 static_cast<void *>(sb_symbol.get()));
-  return sb_symbol;
+  return LLDB_RECORD_RESULT(sb_symbol);
 }
 
 SBBlock SBFrame::GetBlock() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBBlock, SBFrame, GetBlock);
+
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   SBBlock sb_block;
   std::unique_lock<std::recursive_mutex> lock;

     log->Printf("SBFrame(%p)::GetBlock () => SBBlock(%p)",
                 static_cast<void *>(frame),
                 static_cast<void *>(sb_block.GetPtr()));
-  return sb_block;
+  return LLDB_RECORD_RESULT(sb_block);
 }
 
 SBBlock SBFrame::GetFrameBlock() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBBlock, SBFrame, GetFrameBlock);
+
   SBBlock sb_block;
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);

     log->Printf("SBFrame(%p)::GetFrameBlock () => SBBlock(%p)",
                 static_cast<void *>(frame),
                 static_cast<void *>(sb_block.GetPtr()));
-  return sb_block;
+  return LLDB_RECORD_RESULT(sb_block);
 }
 
 SBLineEntry SBFrame::GetLineEntry() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBLineEntry, SBFrame, GetLineEntry);
+
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   SBLineEntry sb_line_entry;
   std::unique_lock<std::recursive_mutex> lock;

     log->Printf("SBFrame(%p)::GetLineEntry () => SBLineEntry(%p)",
                 static_cast<void *>(frame),
                 static_cast<void *>(sb_line_entry.get()));
-  return sb_line_entry;
+  return LLDB_RECORD_RESULT(sb_line_entry);
 }
 
 uint32_t SBFrame::GetFrameID() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBFrame, GetFrameID);
+
   uint32_t frame_idx = UINT32_MAX;
 
   std::unique_lock<std::recursive_mutex> lock;

 }
 
 lldb::addr_t SBFrame::GetCFA() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::addr_t, SBFrame, GetCFA);
+
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 

 }
 
 addr_t SBFrame::GetPC() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::addr_t, SBFrame, GetPC);
+
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   addr_t addr = LLDB_INVALID_ADDRESS;
   std::unique_lock<std::recursive_mutex> lock;

 }
 
 bool SBFrame::SetPC(addr_t new_pc) {
+  LLDB_RECORD_METHOD(bool, SBFrame, SetPC, (lldb::addr_t), new_pc);
+
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   bool ret_val = false;
   std::unique_lock<std::recursive_mutex> lock;

 }
 
 addr_t SBFrame::GetSP() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::addr_t, SBFrame, GetSP);
+
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   addr_t addr = LLDB_INVALID_ADDRESS;
   std::unique_lock<std::recursive_mutex> lock;

 }
 
 addr_t SBFrame::GetFP() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::addr_t, SBFrame, GetFP);
+
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   addr_t addr = LLDB_INVALID_ADDRESS;
   std::unique_lock<std::recursive_mutex> lock;

 }
 
 SBAddress SBFrame::GetPCAddress() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBAddress, SBFrame, GetPCAddress);
+
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   SBAddress sb_addr;
   std::unique_lock<std::recursive_mutex> lock;

   if (log)
     log->Printf("SBFrame(%p)::GetPCAddress () => SBAddress(%p)",
                 static_cast<void *>(frame), static_cast<void *>(sb_addr.get()));
-  return sb_addr;
+  return LLDB_RECORD_RESULT(sb_addr);
 }
 
-void SBFrame::Clear() { m_opaque_sp->Clear(); }
+void SBFrame::Clear() {
+  LLDB_RECORD_METHOD_NO_ARGS(void, SBFrame, Clear);
+
+  m_opaque_sp->Clear();
+}
 
 lldb::SBValue SBFrame::GetValueForVariablePath(const char *var_path) {
+  LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, GetValueForVariablePath,
+                     (const char *), var_path);
+
   SBValue sb_value;
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);

         frame->CalculateTarget()->GetPreferDynamicValue();
     sb_value = GetValueForVariablePath(var_path, use_dynamic);
   }
-  return sb_value;
+  return LLDB_RECORD_RESULT(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);
+
   SBValue sb_value;
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   if (var_path == nullptr || var_path[0] == '\0') {
     if (log)
       log->Printf(
           "SBFrame::GetValueForVariablePath called with empty variable path.");
-    return sb_value;
+    return LLDB_RECORD_RESULT(sb_value);
   }
 
   std::unique_lock<std::recursive_mutex> lock;

             "SBFrame::GetValueForVariablePath () => error: process is running");
     }
   }
-  return sb_value;
+  return LLDB_RECORD_RESULT(sb_value);
 }
 
 SBValue SBFrame::FindVariable(const char *name) {
+  LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, FindVariable, (const char *),
+                     name);
+
   SBValue value;
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);

         frame->CalculateTarget()->GetPreferDynamicValue();
     value = FindVariable(name, use_dynamic);
   }
-  return value;
+  return LLDB_RECORD_RESULT(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);
+
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   VariableSP var_sp;
   SBValue sb_value;

   if (name == nullptr || name[0] == '\0') {
     if (log)
       log->Printf("SBFrame::FindVariable called with empty name");
-    return sb_value;
+    return LLDB_RECORD_RESULT(sb_value);
   }
 
   ValueObjectSP value_sp;

                 static_cast<void *>(frame), name,
                 static_cast<void *>(value_sp.get()));
 
-  return sb_value;
+  return LLDB_RECORD_RESULT(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);
+
   SBValue value;
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);

         frame->CalculateTarget()->GetPreferDynamicValue();
     value = FindValue(name, value_type, use_dynamic);
   }
-  return value;
+  return LLDB_RECORD_RESULT(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);
+
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   SBValue sb_value;
 
   if (name == nullptr || name[0] == '\0') {
     if (log)
       log->Printf("SBFrame::FindValue called with empty name.");
-    return sb_value;
+    return LLDB_RECORD_RESULT(sb_value);
   }
 
   ValueObjectSP value_sp;

                 static_cast<void *>(frame), name, value_type,
                 static_cast<void *>(value_sp.get()));
 
-  return sb_value;
+  return LLDB_RECORD_RESULT(sb_value);
 }
 
 bool SBFrame::IsEqual(const SBFrame &that) const {
+  LLDB_RECORD_METHOD_CONST(bool, SBFrame, IsEqual, (const lldb::SBFrame &),
+                           that);
+
   lldb::StackFrameSP this_sp = GetFrameSP();
   lldb::StackFrameSP that_sp = that.GetFrameSP();
   return (this_sp && that_sp && this_sp->GetStackID() == that_sp->GetStackID());
 }
 
-bool SBFrame::operator==(const SBFrame &rhs) const { return IsEqual(rhs); }
+bool SBFrame::operator==(const SBFrame &rhs) const {
+  LLDB_RECORD_METHOD_CONST(bool, SBFrame, operator==,(const lldb::SBFrame &),
+                           rhs);
+
+  return IsEqual(rhs);
+}
 
-bool SBFrame::operator!=(const SBFrame &rhs) const { return !IsEqual(rhs); }
+bool SBFrame::operator!=(const SBFrame &rhs) const {
+  LLDB_RECORD_METHOD_CONST(bool, SBFrame, operator!=,(const lldb::SBFrame &),
+                           rhs);
+
+  return !IsEqual(rhs);
+}
 
 SBThread SBFrame::GetThread() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBThread, SBFrame, GetThread);
+
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   std::unique_lock<std::recursive_mutex> lock;

                 static_cast<void *>(thread_sp.get()), sstr.GetData());
   }
 
-  return sb_thread;
+  return LLDB_RECORD_RESULT(sb_thread);
 }
 
 const char *SBFrame::Disassemble() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBFrame, Disassemble);
+
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   const char *disassembly = nullptr;
   std::unique_lock<std::recursive_mutex> lock;

 
 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);
+
   SBValueList value_list;
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);

 
     value_list = GetVariables(options);
   }
-  return value_list;
+  return LLDB_RECORD_RESULT(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);
+
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 

   options.SetInScopeOnly(in_scope_only);
   options.SetIncludeRuntimeSupportValues(include_runtime_support_values);
   options.SetUseDynamic(use_dynamic);
-  return GetVariables(options);
+  return LLDB_RECORD_RESULT(GetVariables(options));
 }
 
 SBValueList SBFrame::GetVariables(const lldb::SBVariablesOptions &options) {
+  LLDB_RECORD_METHOD(lldb::SBValueList, SBFrame, GetVariables,
+                     (const lldb::SBVariablesOptions &), options);
+
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   SBValueList value_list;

                 static_cast<void *>(frame),
                 static_cast<void *>(value_list.opaque_ptr()));
 
-  return value_list;
+  return LLDB_RECORD_RESULT(value_list);
 }
 
 SBValueList SBFrame::GetRegisters() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBValueList, SBFrame, GetRegisters);
+
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   SBValueList value_list;

                 static_cast<void *>(frame),
                 static_cast<void *>(value_list.opaque_ptr()));
 
-  return value_list;
+  return LLDB_RECORD_RESULT(value_list);
 }
 
 SBValue SBFrame::FindRegister(const char *name) {
+  LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, FindRegister, (const char *),
+                     name);
+
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   SBValue result;

                 static_cast<void *>(frame),
                 static_cast<void *>(value_sp.get()));
 
-  return result;
+  return LLDB_RECORD_RESULT(result);
 }
 
 bool SBFrame::GetDescription(SBStream &description) {
+  LLDB_RECORD_METHOD(bool, SBFrame, GetDescription, (lldb::SBStream &),
+                     description);
+
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   Stream &strm = description.ref();
 

 }
 
 SBValue SBFrame::EvaluateExpression(const char *expr) {
+  LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, EvaluateExpression, (const char *),
+                     expr);
+
   SBValue result;
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);

       options.SetLanguage(target->GetLanguage());
     else
       options.SetLanguage(frame->GetLanguage());
-    return EvaluateExpression(expr, options);
+    return LLDB_RECORD_RESULT(EvaluateExpression(expr, options));
   }
-  return result;
+  return LLDB_RECORD_RESULT(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);
+
   SBExpressionOptions options;
   options.SetFetchDynamicValue(fetch_dynamic_value);
   options.SetUnwindOnError(true);

     options.SetLanguage(target->GetLanguage());
   else if (frame)
     options.SetLanguage(frame->GetLanguage());
-  return EvaluateExpression(expr, options);
+  return LLDB_RECORD_RESULT(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);
+
   SBExpressionOptions options;
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);

     options.SetLanguage(target->GetLanguage());
   else if (frame)
     options.SetLanguage(frame->GetLanguage());
-  return EvaluateExpression(expr, options);
+  return LLDB_RECORD_RESULT(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);
+
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
 #ifndef LLDB_DISABLE_PYTHON

     if (log)
       log->Printf(
           "SBFrame::EvaluateExpression called with an empty expression");
-    return expr_result;
+    return LLDB_RECORD_RESULT(expr_result);
   }
 
   ValueObjectSP expr_value_sp;

                 static_cast<void *>(expr_value_sp.get()), exe_results);
 #endif
 
-  return expr_result;
+  return LLDB_RECORD_RESULT(expr_result);
 }
 
 bool SBFrame::IsInlined() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBFrame, IsInlined);
+
   return static_cast<const SBFrame *>(this)->IsInlined();
 }
 
 bool SBFrame::IsInlined() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBFrame, IsInlined);
+
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);

 }
 
 bool SBFrame::IsArtificial() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBFrame, IsArtificial);
+
   return static_cast<const SBFrame *>(this)->IsArtificial();
 }
 
 bool SBFrame::IsArtificial() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBFrame, IsArtificial);
+
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 

 }
 
 const char *SBFrame::GetFunctionName() {
+  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBFrame, GetFunctionName);
+
   return static_cast<const SBFrame *>(this)->GetFunctionName();
 }
 
 lldb::LanguageType SBFrame::GuessLanguage() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::LanguageType, SBFrame, GuessLanguage);
+
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
   

 }
 
 const char *SBFrame::GetFunctionName() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBFrame, GetFunctionName);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   const char *name = nullptr;
   std::unique_lock<std::recursive_mutex> lock;

 }
 
 const char *SBFrame::GetDisplayFunctionName() {
+  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBFrame, GetDisplayFunctionName);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   const char *name = nullptr;
 

lldb/source/API/SBFunction.cpp

 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBFunction.h"
+#include "SBReproducerPrivate.h"
 #include "lldb/API/SBProcess.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/Core/Disassembler.h"

 using namespace lldb;
 using namespace lldb_private;
 
-SBFunction::SBFunction() : m_opaque_ptr(NULL) {}
+SBFunction::SBFunction() : m_opaque_ptr(NULL) {
+  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBFunction);
+}
 
 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) {}
+    : m_opaque_ptr(rhs.m_opaque_ptr) {
+  LLDB_RECORD_CONSTRUCTOR(SBFunction, (const lldb::SBFunction &), rhs);
+}
 
 const SBFunction &SBFunction::operator=(const SBFunction &rhs) {
+  LLDB_RECORD_METHOD(const lldb::SBFunction &,
+                     SBFunction, operator=,(const lldb::SBFunction &), rhs);
+
   m_opaque_ptr = rhs.m_opaque_ptr;
   return *this;
 }
 
 SBFunction::~SBFunction() { m_opaque_ptr = NULL; }
 
-bool SBFunction::IsValid() const { return m_opaque_ptr != NULL; }
+bool SBFunction::IsValid() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBFunction, IsValid);
+
+  return m_opaque_ptr != NULL;
+}
 
 const char *SBFunction::GetName() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBFunction, GetName);
+
   const char *cstr = NULL;
   if (m_opaque_ptr)
     cstr = m_opaque_ptr->GetName().AsCString();

 }
 
 const char *SBFunction::GetDisplayName() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBFunction, GetDisplayName);
+
   const char *cstr = NULL;
   if (m_opaque_ptr)
     cstr = m_opaque_ptr->GetMangled()

 }
 
 const char *SBFunction::GetMangledName() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBFunction, GetMangledName);
+
   const char *cstr = NULL;
   if (m_opaque_ptr)
     cstr = m_opaque_ptr->GetMangled().GetMangledName().AsCString();

 }
 
 bool SBFunction::operator==(const SBFunction &rhs) const {
+  LLDB_RECORD_METHOD_CONST(
+      bool, SBFunction, operator==,(const lldb::SBFunction &), 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);
+
   return m_opaque_ptr != rhs.m_opaque_ptr;
 }
 
 bool SBFunction::GetDescription(SBStream &s) {
+  LLDB_RECORD_METHOD(bool, SBFunction, GetDescription, (lldb::SBStream &), s);
+
   if (m_opaque_ptr) {
     s.Printf("SBFunction: id = 0x%8.8" PRIx64 ", name = %s",
              m_opaque_ptr->GetID(), m_opaque_ptr->GetName().AsCString());

 }
 
 SBInstructionList SBFunction::GetInstructions(SBTarget target) {
-  return GetInstructions(target, NULL);
+  LLDB_RECORD_METHOD(lldb::SBInstructionList, SBFunction, GetInstructions,
+                     (lldb::SBTarget), target);
+
+  return LLDB_RECORD_RESULT(GetInstructions(target, NULL));
 }
 
 SBInstructionList SBFunction::GetInstructions(SBTarget target,
                                               const char *flavor) {
+  LLDB_RECORD_METHOD(lldb::SBInstructionList, SBFunction, GetInstructions,
+                     (lldb::SBTarget, const char *), target, flavor);
+
   SBInstructionList sb_instructions;
   if (m_opaque_ptr) {
     ExecutionContext exe_ctx;

           m_opaque_ptr->GetAddressRange(), prefer_file_cache));
     }
   }
-  return sb_instructions;
+  return LLDB_RECORD_RESULT(sb_instructions);
 }
 
 lldb_private::Function *SBFunction::get() { return m_opaque_ptr; }

 }
 
 SBAddress SBFunction::GetStartAddress() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBAddress, SBFunction, GetStartAddress);
+
   SBAddress addr;
   if (m_opaque_ptr)
     addr.SetAddress(&m_opaque_ptr->GetAddressRange().GetBaseAddress());
-  return addr;
+  return LLDB_RECORD_RESULT(addr);
 }
 
 SBAddress SBFunction::GetEndAddress() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBAddress, SBFunction, GetEndAddress);
+
   SBAddress addr;
   if (m_opaque_ptr) {
     addr_t byte_size = m_opaque_ptr->GetAddressRange().GetByteSize();

       addr->Slide(byte_size);
     }
   }
-  return addr;
+  return LLDB_RECORD_RESULT(addr);
 }
 
 const char *SBFunction::GetArgumentName(uint32_t arg_idx) {
+  LLDB_RECORD_METHOD(const char *, SBFunction, GetArgumentName, (uint32_t),
+                     arg_idx);
+
   if (m_opaque_ptr) {
     Block &block = m_opaque_ptr->GetBlock(true);
     VariableListSP variable_list_sp = block.GetBlockVariableList(true);

 }
 
 uint32_t SBFunction::GetPrologueByteSize() {
+  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBFunction, GetPrologueByteSize);
+
   if (m_opaque_ptr)
     return m_opaque_ptr->GetPrologueByteSize();
   return 0;
 }
 
 SBType SBFunction::GetType() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBFunction, GetType);
+
   SBType sb_type;
   if (m_opaque_ptr) {
     Type *function_type = m_opaque_ptr->GetType();
     if (function_type)
       sb_type.ref().SetType(function_type->shared_from_this());
   }
-  return sb_type;
+  return LLDB_RECORD_RESULT(sb_type);
 }
 
 SBBlock SBFunction::GetBlock() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBBlock, SBFunction, GetBlock);
+
   SBBlock sb_block;
   if (m_opaque_ptr)
     sb_block.SetPtr(&m_opaque_ptr->GetBlock(true));
-  return sb_block;
+  return LLDB_RECORD_RESULT(sb_block);
 }
 
 lldb::LanguageType SBFunction::GetLanguage() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::LanguageType, SBFunction, GetLanguage);
+
   if (m_opaque_ptr) {
     if (m_opaque_ptr->GetCompileUnit())
       return m_opaque_ptr->GetCompileUnit()->GetLanguage();

 }
 
 bool SBFunction::GetIsOptimized() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBFunction, GetIsOptimized);
+
   if (m_opaque_ptr) {
     if (m_opaque_ptr->GetCompileUnit())
       return m_opaque_ptr->GetCompileUnit()->GetIsOptimized();

lldb/source/API/SBHostOS.cpp

 #include "Plugins/ScriptInterpreter/Python/lldb-python.h"
 #endif
 
+#include "SBReproducerPrivate.h"
 #include "lldb/API/SBError.h"
 #include "lldb/API/SBHostOS.h"
 #include "lldb/Host/FileSystem.h"

 using namespace lldb_private;
 
 SBFileSpec SBHostOS::GetProgramFileSpec() {
+  LLDB_RECORD_STATIC_METHOD_NO_ARGS(lldb::SBFileSpec, SBHostOS,
+                                    GetProgramFileSpec);
+
   SBFileSpec sb_filespec;
   sb_filespec.SetFileSpec(HostInfo::GetProgramFileSpec());
-  return sb_filespec;
+  return LLDB_RECORD_RESULT(sb_filespec);
 }
 
 SBFileSpec SBHostOS::GetLLDBPythonPath() {
-  return GetLLDBPath(ePathTypePythonDir);
+  LLDB_RECORD_STATIC_METHOD_NO_ARGS(lldb::SBFileSpec, SBHostOS,
+                                    GetLLDBPythonPath);
+
+  return LLDB_RECORD_RESULT(GetLLDBPath(ePathTypePythonDir));
 }
 
 SBFileSpec SBHostOS::GetLLDBPath(lldb::PathType path_type) {
+  LLDB_RECORD_STATIC_METHOD(lldb::SBFileSpec, SBHostOS, GetLLDBPath,
+                            (lldb::PathType), path_type);
+
   FileSpec fspec;
   switch (path_type) {
   case ePathTypeLLDBShlibDir:

 
   SBFileSpec sb_fspec;
   sb_fspec.SetFileSpec(fspec);
-  return sb_fspec;
+  return LLDB_RECORD_RESULT(sb_fspec);
 }
 
 SBFileSpec SBHostOS::GetUserHomeDirectory() {
+  LLDB_RECORD_STATIC_METHOD_NO_ARGS(lldb::SBFileSpec, SBHostOS,
+                                    GetUserHomeDirectory);
+
   SBFileSpec sb_fspec;
 
   llvm::SmallString<64> home_dir_path;

   FileSystem::Instance().Resolve(homedir);
 
   sb_fspec.SetFileSpec(homedir);
-  return sb_fspec;
+  return LLDB_RECORD_RESULT(sb_fspec);
 }
 
 lldb::thread_t SBHostOS::ThreadCreate(const char *name,

   return thread.Release();
 }
 
-void SBHostOS::ThreadCreated(const char *name) {}
+void SBHostOS::ThreadCreated(const char *name) {
+  LLDB_RECORD_STATIC_METHOD(void, SBHostOS, ThreadCreated, (const char *),
+                            name);
+}
 
 bool SBHostOS::ThreadCancel(lldb::thread_t thread, SBError *error_ptr) {
+  LLDB_RECORD_STATIC_METHOD(bool, SBHostOS, ThreadCancel,
+                            (lldb::thread_t, lldb::SBError *), thread,
+                            error_ptr);
+
   Status error;
   HostThread host_thread(thread);
   error = host_thread.Cancel();

 }
 
 bool SBHostOS::ThreadDetach(lldb::thread_t thread, SBError *error_ptr) {
+  LLDB_RECORD_STATIC_METHOD(bool, SBHostOS, ThreadDetach,
+                            (lldb::thread_t, lldb::SBError *), thread,
+                            error_ptr);
+
   Status error;
 #if defined(_WIN32)
   if (error_ptr)

 
 bool SBHostOS::ThreadJoin(lldb::thread_t thread, lldb::thread_result_t *result,
                           SBError *error_ptr) {
+  LLDB_RECORD_STATIC_METHOD(
+      bool, SBHostOS, ThreadJoin,
+      (lldb::thread_t, lldb::thread_result_t *, lldb::SBError *), thread,
+      result, error_ptr);
+
   Status error;
   HostThread host_thread(thread);
   error = host_thread.Join(result);

lldb/source/API/SBInstruction.cpp

 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBInstruction.h"
+#include "SBReproducerPrivate.h"
 
 #include "lldb/API/SBAddress.h"
 #include "lldb/API/SBFrame.h"

 using namespace lldb;
 using namespace lldb_private;
 
-SBInstruction::SBInstruction() : m_opaque_sp() {}
+SBInstruction::SBInstruction() : m_opaque_sp() {
+  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBInstruction);
+}
 
 SBInstruction::SBInstruction(const lldb::DisassemblerSP &disasm_sp,
                              const lldb::InstructionSP &inst_sp)
     : m_opaque_sp(new InstructionImpl(disasm_sp, inst_sp)) {}
 
 SBInstruction::SBInstruction(const SBInstruction &rhs)
-    : m_opaque_sp(rhs.m_opaque_sp) {}
+    : m_opaque_sp(rhs.m_opaque_sp) {
+  LLDB_RECORD_CONSTRUCTOR(SBInstruction, (const lldb::SBInstruction &), rhs);
+}
 
 const SBInstruction &SBInstruction::operator=(const SBInstruction &rhs) {
+  LLDB_RECORD_METHOD(const lldb::SBInstruction &,
+                     SBInstruction, operator=,(const lldb::SBInstruction &),
+                     rhs);
+
   if (this != &rhs)
     m_opaque_sp = rhs.m_opaque_sp;
   return *this;

 
 SBInstruction::~SBInstruction() {}
 
-bool SBInstruction::IsValid() { return m_opaque_sp && m_opaque_sp->IsValid(); }
+bool SBInstruction::IsValid() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBInstruction, IsValid);
+
+  return m_opaque_sp && m_opaque_sp->IsValid();
+}
 
 SBAddress SBInstruction::GetAddress() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBAddress, SBInstruction, GetAddress);
+
   SBAddress sb_addr;
   lldb::InstructionSP inst_sp(GetOpaque());
   if (inst_sp && inst_sp->GetAddress().IsValid())
     sb_addr.SetAddress(&inst_sp->GetAddress());
-  return sb_addr;
+  return LLDB_RECORD_RESULT(sb_addr);
 }
 
 const char *SBInstruction::GetMnemonic(SBTarget target) {
+  LLDB_RECORD_METHOD(const char *, SBInstruction, GetMnemonic, (lldb::SBTarget),
+                     target);
+
   lldb::InstructionSP inst_sp(GetOpaque());
   if (inst_sp) {
     ExecutionContext exe_ctx;

 }
 
 const char *SBInstruction::GetOperands(SBTarget target) {
+  LLDB_RECORD_METHOD(const char *, SBInstruction, GetOperands, (lldb::SBTarget),
+                     target);
+
   lldb::InstructionSP inst_sp(GetOpaque());
   if (inst_sp) {
     ExecutionContext exe_ctx;

 }
 
 const char *SBInstruction::GetComment(SBTarget target) {
+  LLDB_RECORD_METHOD(const char *, SBInstruction, GetComment, (lldb::SBTarget),
+                     target);
+
   lldb::InstructionSP inst_sp(GetOpaque());
   if (inst_sp) {
     ExecutionContext exe_ctx;

 }
 
 size_t SBInstruction::GetByteSize() {
+  LLDB_RECORD_METHOD_NO_ARGS(size_t, SBInstruction, GetByteSize);
+
   lldb::InstructionSP inst_sp(GetOpaque());
   if (inst_sp)
     return inst_sp->GetOpcode().GetByteSize();

 }
 
 SBData SBInstruction::GetData(SBTarget target) {
+  LLDB_RECORD_METHOD(lldb::SBData, SBInstruction, GetData, (lldb::SBTarget),
+                     target);
+
   lldb::SBData sb_data;
   lldb::InstructionSP inst_sp(GetOpaque());
   if (inst_sp) {

       sb_data.SetOpaque(data_extractor_sp);
     }
   }
-  return sb_data;
+  return LLDB_RECORD_RESULT(sb_data);
 }
 
 bool SBInstruction::DoesBranch() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBInstruction, DoesBranch);
+
   lldb::InstructionSP inst_sp(GetOpaque());
   if (inst_sp)
     return inst_sp->DoesBranch();

 }
 
 bool SBInstruction::HasDelaySlot() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBInstruction, HasDelaySlot);
+
   lldb::InstructionSP inst_sp(GetOpaque());
   if (inst_sp)
     return inst_sp->HasDelaySlot();
   return false;
 }
 
-bool SBInstruction::CanSetBreakpoint () {
+bool SBInstruction::CanSetBreakpoint() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBInstruction, CanSetBreakpoint);
+
   lldb::InstructionSP inst_sp(GetOpaque());
   if (inst_sp)
     return inst_sp->CanSetBreakpoint();

 }
 
 bool SBInstruction::GetDescription(lldb::SBStream &s) {
+  LLDB_RECORD_METHOD(bool, SBInstruction, GetDescription, (lldb::SBStream &),
+                     s);
+
   lldb::InstructionSP inst_sp(GetOpaque());
   if (inst_sp) {
     SymbolContext sc;

 }
 
 void SBInstruction::Print(FILE *out) {
+  LLDB_RECORD_METHOD(void, SBInstruction, Print, (FILE *), out);
+
   if (out == NULL)
     return;
 

 
 bool SBInstruction::EmulateWithFrame(lldb::SBFrame &frame,
                                      uint32_t evaluate_options) {
+  LLDB_RECORD_METHOD(bool, SBInstruction, EmulateWithFrame,
+                     (lldb::SBFrame &, uint32_t), frame, evaluate_options);
+
   lldb::InstructionSP inst_sp(GetOpaque());
   if (inst_sp) {
     lldb::StackFrameSP frame_sp(frame.GetFrameSP());

 }
 
 bool SBInstruction::DumpEmulation(const char *triple) {
+  LLDB_RECORD_METHOD(bool, SBInstruction, DumpEmulation, (const char *),
+                     triple);
+
   lldb::InstructionSP inst_sp(GetOpaque());
   if (inst_sp && triple) {
     return inst_sp->DumpEmulation(HostInfo::GetAugmentedArchSpec(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);
+
   if (!m_opaque_sp)
     SetOpaque(lldb::DisassemblerSP(),
               lldb::InstructionSP(new PseudoInstruction()));

lldb/source/API/SBInstructionList.cpp

 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBInstructionList.h"
-#include "lldb/API/SBInstruction.h"
+#include "SBReproducerPrivate.h"
 #include "lldb/API/SBAddress.h"
+#include "lldb/API/SBInstruction.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/Core/Disassembler.h"
 #include "lldb/Core/Module.h"

 using namespace lldb;
 using namespace lldb_private;
 
-SBInstructionList::SBInstructionList() : m_opaque_sp() {}
+SBInstructionList::SBInstructionList() : m_opaque_sp() {
+  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBInstructionList);
+}
 
 SBInstructionList::SBInstructionList(const SBInstructionList &rhs)
-    : m_opaque_sp(rhs.m_opaque_sp) {}
+    : m_opaque_sp(rhs.m_opaque_sp) {
+  LLDB_RECORD_CONSTRUCTOR(SBInstructionList, (const lldb::SBInstructionList &),
+                          rhs);
+}
 
 const SBInstructionList &SBInstructionList::
 operator=(const SBInstructionList &rhs) {
+  LLDB_RECORD_METHOD(
+      const lldb::SBInstructionList &,
+      SBInstructionList, operator=,(const lldb::SBInstructionList &), rhs);
+
   if (this != &rhs)
     m_opaque_sp = rhs.m_opaque_sp;
   return *this;

 
 SBInstructionList::~SBInstructionList() {}
 
-bool SBInstructionList::IsValid() const { return m_opaque_sp.get() != NULL; }
+bool SBInstructionList::IsValid() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBInstructionList, IsValid);
+
+  return m_opaque_sp.get() != NULL;
+}
 
 size_t SBInstructionList::GetSize() {
+  LLDB_RECORD_METHOD_NO_ARGS(size_t, SBInstructionList, GetSize);
+
   if (m_opaque_sp)
     return m_opaque_sp->GetInstructionList().GetSize();
   return 0;
 }
 
 SBInstruction SBInstructionList::GetInstructionAtIndex(uint32_t idx) {
+  LLDB_RECORD_METHOD(lldb::SBInstruction, SBInstructionList,
+                     GetInstructionAtIndex, (uint32_t), 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 inst;
+  return LLDB_RECORD_RESULT(inst);
 }
 
 size_t SBInstructionList::GetInstructionsCount(const SBAddress &start,
-                                              const SBAddress &end, 
+                                               const SBAddress &end,
                                                bool canSetBreakpoint) {
+  LLDB_RECORD_METHOD(size_t, SBInstructionList, GetInstructionsCount,
+                     (const lldb::SBAddress &, const lldb::SBAddress &, bool),
+                     start, end, canSetBreakpoint);
+
   size_t num_instructions = GetSize();
   size_t i = 0;
   SBAddress addr;

   return upper_index - lower_index - instructions_to_skip;
 }
 
-void SBInstructionList::Clear() { m_opaque_sp.reset(); }
+void SBInstructionList::Clear() {
+  LLDB_RECORD_METHOD_NO_ARGS(void, SBInstructionList, Clear);
+
+  m_opaque_sp.reset();
+}
 
-void SBInstructionList::AppendInstruction(SBInstruction insn) {}
+void SBInstructionList::AppendInstruction(SBInstruction insn) {
+  LLDB_RECORD_METHOD(void, SBInstructionList, AppendInstruction,
+                     (lldb::SBInstruction), insn);
+}
 
 void SBInstructionList::SetDisassembler(const lldb::DisassemblerSP &opaque_sp) {
   m_opaque_sp = opaque_sp;
 }
 
 void SBInstructionList::Print(FILE *out) {
+  LLDB_RECORD_METHOD(void, SBInstructionList, Print, (FILE *), out);
+
   if (out == NULL)
     return;
 }
 
 bool SBInstructionList::GetDescription(lldb::SBStream &description) {
+  LLDB_RECORD_METHOD(bool, SBInstructionList, GetDescription,
+                     (lldb::SBStream &), description);
+
   if (m_opaque_sp) {
     size_t num_instructions = GetSize();
     if (num_instructions) {

 }
 
 bool SBInstructionList::DumpEmulationForAllInstructions(const char *triple) {
+  LLDB_RECORD_METHOD(bool, SBInstructionList, DumpEmulationForAllInstructions,
+                     (const char *), triple);
+
   if (m_opaque_sp) {
     size_t len = GetSize();
     for (size_t i = 0; i < len; ++i) {

lldb/source/API/SBLanguageRuntime.cpp

 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBLanguageRuntime.h"
+#include "SBReproducerPrivate.h"
 #include "lldb/Target/Language.h"
 
 using namespace lldb;

 
 lldb::LanguageType
 SBLanguageRuntime::GetLanguageTypeFromString(const char *string) {
+  LLDB_RECORD_STATIC_METHOD(lldb::LanguageType, SBLanguageRuntime,
+                            GetLanguageTypeFromString, (const char *), string);
+
   return Language::GetLanguageTypeFromString(
       llvm::StringRef::withNullAsEmpty(string));
 }
 
 const char *
 SBLanguageRuntime::GetNameForLanguageType(lldb::LanguageType language) {
+  LLDB_RECORD_STATIC_METHOD(const char *, SBLanguageRuntime,
+                            GetNameForLanguageType, (lldb::LanguageType),
+                            language);
+
   return Language::GetNameForLanguageType(language);
 }

lldb/source/API/SBLaunchInfo.cpp

 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBLaunchInfo.h"
+#include "SBReproducerPrivate.h"
 
 #include "lldb/API/SBFileSpec.h"
 #include "lldb/API/SBListener.h"

 
 SBLaunchInfo::SBLaunchInfo(const char **argv)
     : m_opaque_sp(new SBLaunchInfoImpl()) {
+  LLDB_RECORD_CONSTRUCTOR(SBLaunchInfo, (const char **), argv);
+
   m_opaque_sp->GetFlags().Reset(eLaunchFlagDebug | eLaunchFlagDisableASLR);
   if (argv && argv[0])
     m_opaque_sp->GetArguments().SetArguments(argv);

   *m_opaque_sp = info;
 }
 
-lldb::pid_t SBLaunchInfo::GetProcessID() { return m_opaque_sp->GetProcessID(); }
+lldb::pid_t SBLaunchInfo::GetProcessID() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::pid_t, SBLaunchInfo, GetProcessID);
+
+  return m_opaque_sp->GetProcessID();
+}
+
+uint32_t SBLaunchInfo::GetUserID() {
+  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBLaunchInfo, GetUserID);
+
+  return m_opaque_sp->GetUserID();
+}
+
+uint32_t SBLaunchInfo::GetGroupID() {
+  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBLaunchInfo, GetGroupID);
+
+  return m_opaque_sp->GetGroupID();
+}
+
+bool SBLaunchInfo::UserIDIsValid() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBLaunchInfo, UserIDIsValid);
+
+  return m_opaque_sp->UserIDIsValid();
+}
 
-uint32_t SBLaunchInfo::GetUserID() { return m_opaque_sp->GetUserID(); }
+bool SBLaunchInfo::GroupIDIsValid() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBLaunchInfo, GroupIDIsValid);
 
-uint32_t SBLaunchInfo::GetGroupID() { return m_opaque_sp->GetGroupID(); }
+  return m_opaque_sp->GroupIDIsValid();
+}
 
-bool SBLaunchInfo::UserIDIsValid() { return m_opaque_sp->UserIDIsValid(); }
+void SBLaunchInfo::SetUserID(uint32_t uid) {
+  LLDB_RECORD_METHOD(void, SBLaunchInfo, SetUserID, (uint32_t), uid);
 
-bool SBLaunchInfo::GroupIDIsValid() { return m_opaque_sp->GroupIDIsValid(); }
+  m_opaque_sp->SetUserID(uid);
+}
 
-void SBLaunchInfo::SetUserID(uint32_t uid) { m_opaque_sp->SetUserID(uid); }
+void SBLaunchInfo::SetGroupID(uint32_t gid) {
+  LLDB_RECORD_METHOD(void, SBLaunchInfo, SetGroupID, (uint32_t), gid);
 
-void SBLaunchInfo::SetGroupID(uint32_t gid) { m_opaque_sp->SetGroupID(gid); }
+  m_opaque_sp->SetGroupID(gid);
+}
 
 SBFileSpec SBLaunchInfo::GetExecutableFile() {
-  return SBFileSpec(m_opaque_sp->GetExecutableFile());
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBFileSpec, SBLaunchInfo, GetExecutableFile);
+
+  return LLDB_RECORD_RESULT(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);
+
   m_opaque_sp->SetExecutableFile(exe_file.ref(), add_as_first_arg);
 }
 
 SBListener SBLaunchInfo::GetListener() {
-  return SBListener(m_opaque_sp->GetListener());
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBListener, SBLaunchInfo, GetListener);
+
+  return LLDB_RECORD_RESULT(SBListener(m_opaque_sp->GetListener()));
 }
 
 void SBLaunchInfo::SetListener(SBListener &listener) {
+  LLDB_RECORD_METHOD(void, SBLaunchInfo, SetListener, (lldb::SBListener &),
+                     listener);
+
   m_opaque_sp->SetListener(listener.GetSP());
 }
 
 uint32_t SBLaunchInfo::GetNumArguments() {
+  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBLaunchInfo, GetNumArguments);
+
   return m_opaque_sp->GetArguments().GetArgumentCount();
 }
 
 const char *SBLaunchInfo::GetArgumentAtIndex(uint32_t idx) {
+  LLDB_RECORD_METHOD(const char *, SBLaunchInfo, GetArgumentAtIndex, (uint32_t),
+                     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);
+
   if (append) {
     if (argv)
       m_opaque_sp->GetArguments().AppendArguments(argv);

 }
 
 uint32_t SBLaunchInfo::GetNumEnvironmentEntries() {
+  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBLaunchInfo, GetNumEnvironmentEntries);
+
   return m_opaque_sp->GetEnvironment().size();
 }
 
 const char *SBLaunchInfo::GetEnvironmentEntryAtIndex(uint32_t idx) {
+  LLDB_RECORD_METHOD(const char *, SBLaunchInfo, GetEnvironmentEntryAtIndex,
+                     (uint32_t), idx);
+
   if (idx > GetNumEnvironmentEntries())
     return nullptr;
   return m_opaque_sp->GetEnvp()[idx];
 }
 
 void SBLaunchInfo::SetEnvironmentEntries(const char **envp, bool append) {
+  LLDB_RECORD_METHOD(void, SBLaunchInfo, SetEnvironmentEntries,
+                     (const char **, bool), envp, append);
+
   Environment env(envp);
   if (append)
     m_opaque_sp->GetEnvironment().insert(env.begin(), env.end());

   m_opaque_sp->RegenerateEnvp();
 }
 
-void SBLaunchInfo::Clear() { m_opaque_sp->Clear(); }
+void SBLaunchInfo::Clear() {
+  LLDB_RECORD_METHOD_NO_ARGS(void, SBLaunchInfo, Clear);
+
+  m_opaque_sp->Clear();
+}
 
 const char *SBLaunchInfo::GetWorkingDirectory() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBLaunchInfo,
+                                   GetWorkingDirectory);
+
   return m_opaque_sp->GetWorkingDirectory().GetCString();
 }
 
 void SBLaunchInfo::SetWorkingDirectory(const char *working_dir) {
+  LLDB_RECORD_METHOD(void, SBLaunchInfo, SetWorkingDirectory, (const char *),
+                     working_dir);
+
   m_opaque_sp->SetWorkingDirectory(FileSpec(working_dir));
 }
 
 uint32_t SBLaunchInfo::GetLaunchFlags() {
+  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBLaunchInfo, GetLaunchFlags);
+
   return m_opaque_sp->GetFlags().Get();
 }
 
 void SBLaunchInfo::SetLaunchFlags(uint32_t flags) {
+  LLDB_RECORD_METHOD(void, SBLaunchInfo, SetLaunchFlags, (uint32_t), flags);
+
   m_opaque_sp->GetFlags().Reset(flags);
 }
 
 const char *SBLaunchInfo::GetProcessPluginName() {
+  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBLaunchInfo, GetProcessPluginName);
+
   return m_opaque_sp->GetProcessPluginName();
 }
 
 void SBLaunchInfo::SetProcessPluginName(const char *plugin_name) {
+  LLDB_RECORD_METHOD(void, SBLaunchInfo, SetProcessPluginName, (const char *),
+                     plugin_name);
+
   return m_opaque_sp->SetProcessPluginName(plugin_name);
 }
 
 const char *SBLaunchInfo::GetShell() {
+  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBLaunchInfo, GetShell);
+
   // Constify this string so that it is saved in the string pool.  Otherwise it
   // would be freed when this function goes out of scope.
   ConstString shell(m_opaque_sp->GetShell().GetPath().c_str());

 }
 
 void SBLaunchInfo::SetShell(const char *path) {
+  LLDB_RECORD_METHOD(void, SBLaunchInfo, SetShell, (const char *), path);
+
   m_opaque_sp->SetShell(FileSpec(path));
 }
 
 bool SBLaunchInfo::GetShellExpandArguments() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBLaunchInfo, GetShellExpandArguments);
+
   return m_opaque_sp->GetShellExpandArguments();
 }
 
 void SBLaunchInfo::SetShellExpandArguments(bool expand) {
+  LLDB_RECORD_METHOD(void, SBLaunchInfo, SetShellExpandArguments, (bool),
+                     expand);
+
   m_opaque_sp->SetShellExpandArguments(expand);
 }
 
 uint32_t SBLaunchInfo::GetResumeCount() {
+  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBLaunchInfo, GetResumeCount);
+
   return m_opaque_sp->GetResumeCount();
 }
 
 void SBLaunchInfo::SetResumeCount(uint32_t c) {
+  LLDB_RECORD_METHOD(void, SBLaunchInfo, SetResumeCount, (uint32_t), c);
+
   m_opaque_sp->SetResumeCount(c);
 }
 
 bool SBLaunchInfo::AddCloseFileAction(int fd) {
+  LLDB_RECORD_METHOD(bool, SBLaunchInfo, AddCloseFileAction, (int), 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);
+
   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);
+
   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);
+
   return m_opaque_sp->AppendSuppressFileAction(fd, read, write);
 }
 
 void SBLaunchInfo::SetLaunchEventData(const char *data) {
+  LLDB_RECORD_METHOD(void, SBLaunchInfo, SetLaunchEventData, (const char *),
+                     data);
+
   m_opaque_sp->SetLaunchEventData(data);
 }
 
 const char *SBLaunchInfo::GetLaunchEventData() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBLaunchInfo,
+                                   GetLaunchEventData);
+
   return m_opaque_sp->GetLaunchEventData();
 }
 
 void SBLaunchInfo::SetDetachOnError(bool enable) {
+  LLDB_RECORD_METHOD(void, SBLaunchInfo, SetDetachOnError, (bool), enable);
+
   m_opaque_sp->SetDetachOnError(enable);
 }
 
 bool SBLaunchInfo::GetDetachOnError() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBLaunchInfo, GetDetachOnError);
+
   return m_opaque_sp->GetDetachOnError();
 }

lldb/source/API/SBLineEntry.cpp

 
 #include <limits.h>
 
+#include "SBReproducerPrivate.h"
 #include "lldb/API/SBLineEntry.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/Host/PosixApi.h"

 using namespace lldb;
 using namespace lldb_private;
 
-SBLineEntry::SBLineEntry() : m_opaque_up() {}
+SBLineEntry::SBLineEntry() : m_opaque_up() {
+  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBLineEntry);
+}
 
 SBLineEntry::SBLineEntry(const SBLineEntry &rhs) : m_opaque_up() {
+  LLDB_RECORD_CONSTRUCTOR(SBLineEntry, (const lldb::SBLineEntry &), rhs);
+
   if (rhs.IsValid())
     ref() = rhs.ref();
 }

 }
 
 const SBLineEntry &SBLineEntry::operator=(const SBLineEntry &rhs) {
+  LLDB_RECORD_METHOD(const lldb::SBLineEntry &,
+                     SBLineEntry, operator=,(const lldb::SBLineEntry &), rhs);
+
   if (this != &rhs) {
     if (rhs.IsValid())
       ref() = rhs.ref();

 SBLineEntry::~SBLineEntry() {}
 
 SBAddress SBLineEntry::GetStartAddress() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBAddress, SBLineEntry,
+                                   GetStartAddress);
+
   SBAddress sb_address;
   if (m_opaque_up)
     sb_address.SetAddress(&m_opaque_up->range.GetBaseAddress());

                 static_cast<void *>(sb_address.get()), sstr.GetData());
   }
 
-  return sb_address;
+  return LLDB_RECORD_RESULT(sb_address);
 }
 
 SBAddress SBLineEntry::GetEndAddress() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBAddress, SBLineEntry, GetEndAddress);
+
   SBAddress sb_address;
   if (m_opaque_up) {
     sb_address.SetAddress(&m_opaque_up->range.GetBaseAddress());

                 static_cast<void *>(m_opaque_up.get()),
                 static_cast<void *>(sb_address.get()), sstr.GetData());
   }
-  return sb_address;
+  return LLDB_RECORD_RESULT(sb_address);
 }
 
 bool SBLineEntry::IsValid() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBLineEntry, IsValid);
+
   return m_opaque_up.get() && m_opaque_up->IsValid();
 }
 
 SBFileSpec SBLineEntry::GetFileSpec() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBFileSpec, SBLineEntry, GetFileSpec);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   SBFileSpec sb_file_spec;

                 static_cast<const void *>(sb_file_spec.get()), sstr.GetData());
   }
 
-  return sb_file_spec;
+  return LLDB_RECORD_RESULT(sb_file_spec);
 }
 
 uint32_t SBLineEntry::GetLine() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBLineEntry, GetLine);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   uint32_t line = 0;

 }
 
 uint32_t SBLineEntry::GetColumn() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBLineEntry, GetColumn);
+
   if (m_opaque_up)
     return m_opaque_up->column;
   return 0;
 }
 
 void SBLineEntry::SetFileSpec(lldb::SBFileSpec filespec) {
+  LLDB_RECORD_METHOD(void, SBLineEntry, SetFileSpec, (lldb::SBFileSpec),
+                     filespec);
+
   if (filespec.IsValid())
     ref().file = filespec.ref();
   else
     ref().file.Clear();
 }
-void SBLineEntry::SetLine(uint32_t line) { ref().line = line; }
+void SBLineEntry::SetLine(uint32_t line) {
+  LLDB_RECORD_METHOD(void, SBLineEntry, SetLine, (uint32_t), line);
+
+  ref().line = line;
+}
+
+void SBLineEntry::SetColumn(uint32_t column) {
+  LLDB_RECORD_METHOD(void, SBLineEntry, SetColumn, (uint32_t), column);
 
-void SBLineEntry::SetColumn(uint32_t column) { ref().line = column; }
+  ref().line = column;
+}
 
 bool SBLineEntry::operator==(const SBLineEntry &rhs) const {
+  LLDB_RECORD_METHOD_CONST(
+      bool, SBLineEntry, operator==,(const lldb::SBLineEntry &), rhs);
+
   lldb_private::LineEntry *lhs_ptr = m_opaque_up.get();
   lldb_private::LineEntry *rhs_ptr = rhs.m_opaque_up.get();
 

 }
 
 bool SBLineEntry::operator!=(const SBLineEntry &rhs) const {
+  LLDB_RECORD_METHOD_CONST(
+      bool, SBLineEntry, operator!=,(const lldb::SBLineEntry &), rhs);
+
   lldb_private::LineEntry *lhs_ptr = m_opaque_up.get();
   lldb_private::LineEntry *rhs_ptr = rhs.m_opaque_up.get();
 

 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);
+
   Stream &strm = description.ref();
 
   if (m_opaque_up) {

lldb/source/API/SBListener.cpp

 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBListener.h"
+#include "SBReproducerPrivate.h"
 #include "lldb/API/SBBroadcaster.h"
 #include "lldb/API/SBDebugger.h"
 #include "lldb/API/SBEvent.h"

 using namespace lldb;
 using namespace lldb_private;
 
-SBListener::SBListener() : m_opaque_sp(), m_unused_ptr(NULL) {}
+SBListener::SBListener() : m_opaque_sp(), m_unused_ptr(NULL) {
+  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBListener);
+}
 
 SBListener::SBListener(const char *name)
     : m_opaque_sp(Listener::MakeListener(name)), m_unused_ptr(nullptr) {
+  LLDB_RECORD_CONSTRUCTOR(SBListener, (const char *), name);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   if (log)

 }
 
 SBListener::SBListener(const SBListener &rhs)
-    : m_opaque_sp(rhs.m_opaque_sp), m_unused_ptr(nullptr) {}
+    : m_opaque_sp(rhs.m_opaque_sp), m_unused_ptr(nullptr) {
+  LLDB_RECORD_CONSTRUCTOR(SBListener, (const lldb::SBListener &), rhs);
+}
 
 const lldb::SBListener &SBListener::operator=(const lldb::SBListener &rhs) {
+  LLDB_RECORD_METHOD(const lldb::SBListener &,
+                     SBListener, operator=,(const lldb::SBListener &), rhs);
+
   if (this != &rhs) {
     m_opaque_sp = rhs.m_opaque_sp;
     m_unused_ptr = nullptr;

 
 SBListener::~SBListener() {}
 
-bool SBListener::IsValid() const { return m_opaque_sp != nullptr; }
+bool SBListener::IsValid() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBListener, IsValid);
+
+  return m_opaque_sp != nullptr;
+}
 
 void SBListener::AddEvent(const SBEvent &event) {
+  LLDB_RECORD_METHOD(void, SBListener, AddEvent, (const lldb::SBEvent &),
+                     event);
+
   EventSP &event_sp = event.GetSP();
   if (event_sp)
     m_opaque_sp->AddEvent(event_sp);
 }
 
 void SBListener::Clear() {
+  LLDB_RECORD_METHOD_NO_ARGS(void, SBListener, Clear);
+
   if (m_opaque_sp)
     m_opaque_sp->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);
+
   if (m_opaque_sp) {
     Debugger *lldb_debugger = debugger.get();
     if (!lldb_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);
+
   if (m_opaque_sp) {
     Debugger *lldb_debugger = debugger.get();
     if (!lldb_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);
+
   uint32_t acquired_event_mask = 0;
   if (m_opaque_sp && broadcaster.IsValid()) {
     acquired_event_mask =

 
 bool SBListener::StopListeningForEvents(const SBBroadcaster &broadcaster,
                                         uint32_t event_mask) {
+  LLDB_RECORD_METHOD(bool, SBListener, StopListeningForEvents,
+                     (const lldb::SBBroadcaster &, uint32_t), broadcaster,
+                     event_mask);
+
   if (m_opaque_sp && broadcaster.IsValid()) {
     return m_opaque_sp->StopListeningForEvents(broadcaster.get(), event_mask);
   }

 }
 
 bool SBListener::WaitForEvent(uint32_t timeout_secs, SBEvent &event) {
+  LLDB_RECORD_METHOD(bool, SBListener, WaitForEvent,
+                     (uint32_t, lldb::SBEvent &), timeout_secs, event);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   if (log) {
     if (timeout_secs == UINT32_MAX) {

 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);
+
   if (m_opaque_sp && broadcaster.IsValid()) {
     Timeout<std::micro> timeout(llvm::None);
     if (num_seconds != UINT32_MAX)

 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);
+
   if (m_opaque_sp && broadcaster.IsValid()) {
     Timeout<std::micro> timeout(llvm::None);
     if (num_seconds != UINT32_MAX)

 }
 
 bool SBListener::PeekAtNextEvent(SBEvent &event) {
+  LLDB_RECORD_METHOD(bool, SBListener, PeekAtNextEvent, (lldb::SBEvent &),
+                     event);
+
   if (m_opaque_sp) {
     event.reset(m_opaque_sp->PeekAtNextEvent());
     return event.IsValid();

 
 bool SBListener::PeekAtNextEventForBroadcaster(const SBBroadcaster &broadcaster,
                                                SBEvent &event) {
+  LLDB_RECORD_METHOD(bool, SBListener, PeekAtNextEventForBroadcaster,
+                     (const lldb::SBBroadcaster &, lldb::SBEvent &),
+                     broadcaster, event);
+
   if (m_opaque_sp && broadcaster.IsValid()) {
     event.reset(m_opaque_sp->PeekAtNextEventForBroadcaster(broadcaster.get()));
     return event.IsValid();

 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);
+
   if (m_opaque_sp && broadcaster.IsValid()) {
     event.reset(m_opaque_sp->PeekAtNextEventForBroadcasterWithType(
         broadcaster.get(), event_type_mask));

 }
 
 bool SBListener::GetNextEvent(SBEvent &event) {
+  LLDB_RECORD_METHOD(bool, SBListener, GetNextEvent, (lldb::SBEvent &), event);
+
   if (m_opaque_sp) {
     EventSP event_sp;
     if (m_opaque_sp->GetEvent(event_sp, std::chrono::seconds(0))) {

 
 bool SBListener::GetNextEventForBroadcaster(const SBBroadcaster &broadcaster,
                                             SBEvent &event) {
+  LLDB_RECORD_METHOD(bool, SBListener, GetNextEventForBroadcaster,
+                     (const lldb::SBBroadcaster &, lldb::SBEvent &),
+                     broadcaster, event);
+
   if (m_opaque_sp && broadcaster.IsValid()) {
     EventSP event_sp;
     if (m_opaque_sp->GetEventForBroadcaster(broadcaster.get(), event_sp,

 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);
+
   if (m_opaque_sp && broadcaster.IsValid()) {
     EventSP event_sp;
     if (m_opaque_sp->GetEventForBroadcasterWithType(broadcaster.get(),

 }
 
 bool SBListener::HandleBroadcastEvent(const SBEvent &event) {
+  LLDB_RECORD_METHOD(bool, SBListener, HandleBroadcastEvent,
+                     (const lldb::SBEvent &), event);
+
   if (m_opaque_sp)
     return m_opaque_sp->HandleBroadcastEvent(event.GetSP());
   return false;

lldb/source/API/SBMemoryRegionInfo.cpp

 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBMemoryRegionInfo.h"
+#include "SBReproducerPrivate.h"
 #include "lldb/API/SBDefines.h"
 #include "lldb/API/SBError.h"
 #include "lldb/API/SBStream.h"

 using namespace lldb;
 using namespace lldb_private;
 
-SBMemoryRegionInfo::SBMemoryRegionInfo()
-    : m_opaque_up(new MemoryRegionInfo()) {}
+SBMemoryRegionInfo::SBMemoryRegionInfo() : m_opaque_up(new MemoryRegionInfo()) {
+  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBMemoryRegionInfo);
+}
 
 SBMemoryRegionInfo::SBMemoryRegionInfo(const MemoryRegionInfo *lldb_object_ptr)
     : m_opaque_up(new MemoryRegionInfo()) {

 
 SBMemoryRegionInfo::SBMemoryRegionInfo(const SBMemoryRegionInfo &rhs)
     : m_opaque_up(new MemoryRegionInfo()) {
+  LLDB_RECORD_CONSTRUCTOR(SBMemoryRegionInfo,
+                          (const lldb::SBMemoryRegionInfo &), rhs);
+
   ref() = rhs.ref();
 }
 
 const SBMemoryRegionInfo &SBMemoryRegionInfo::
 operator=(const SBMemoryRegionInfo &rhs) {
+  LLDB_RECORD_METHOD(
+      const lldb::SBMemoryRegionInfo &,
+      SBMemoryRegionInfo, operator=,(const lldb::SBMemoryRegionInfo &), rhs);
+
   if (this != &rhs) {
     ref() = rhs.ref();
   }

 
 SBMemoryRegionInfo::~SBMemoryRegionInfo() {}
 
-void SBMemoryRegionInfo::Clear() { m_opaque_up->Clear(); }
+void SBMemoryRegionInfo::Clear() {
+  LLDB_RECORD_METHOD_NO_ARGS(void, SBMemoryRegionInfo, Clear);
+
+  m_opaque_up->Clear();
+}
 
 bool SBMemoryRegionInfo::operator==(const SBMemoryRegionInfo &rhs) const {
+  LLDB_RECORD_METHOD_CONST(
+      bool, SBMemoryRegionInfo, operator==,(const lldb::SBMemoryRegionInfo &),
+      rhs);
+
   return ref() == rhs.ref();
 }
 
 bool SBMemoryRegionInfo::operator!=(const SBMemoryRegionInfo &rhs) const {
+  LLDB_RECORD_METHOD_CONST(
+      bool, SBMemoryRegionInfo, operator!=,(const lldb::SBMemoryRegionInfo &),
+      rhs);
+
   return ref() != rhs.ref();
 }
 

 const MemoryRegionInfo &SBMemoryRegionInfo::ref() const { return *m_opaque_up; }
 
 lldb::addr_t SBMemoryRegionInfo::GetRegionBase() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::addr_t, SBMemoryRegionInfo, GetRegionBase);
+
   return m_opaque_up->GetRange().GetRangeBase();
 }
 
 lldb::addr_t SBMemoryRegionInfo::GetRegionEnd() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::addr_t, SBMemoryRegionInfo, GetRegionEnd);
+
   return m_opaque_up->GetRange().GetRangeEnd();
 }
 
 bool SBMemoryRegionInfo::IsReadable() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBMemoryRegionInfo, IsReadable);
+
   return m_opaque_up->GetReadable() == MemoryRegionInfo::eYes;
 }
 
 bool SBMemoryRegionInfo::IsWritable() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBMemoryRegionInfo, IsWritable);
+
   return m_opaque_up->GetWritable() == MemoryRegionInfo::eYes;
 }
 
 bool SBMemoryRegionInfo::IsExecutable() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBMemoryRegionInfo, IsExecutable);
+
   return m_opaque_up->GetExecutable() == MemoryRegionInfo::eYes;
 }
 
 bool SBMemoryRegionInfo::IsMapped() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBMemoryRegionInfo, IsMapped);
+
   return m_opaque_up->GetMapped() == MemoryRegionInfo::eYes;
 }
 
 const char *SBMemoryRegionInfo::GetName() {
+  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBMemoryRegionInfo, GetName);
+
   return m_opaque_up->GetName().AsCString();
 }
 
 bool SBMemoryRegionInfo::GetDescription(SBStream &description) {
+  LLDB_RECORD_METHOD(bool, SBMemoryRegionInfo, GetDescription,
+                     (lldb::SBStream &), description);
+
   Stream &strm = description.ref();
   const addr_t load_addr = m_opaque_up->GetRange().base;
 

lldb/source/API/SBMemoryRegionInfoList.cpp

 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBMemoryRegionInfoList.h"
+#include "SBReproducerPrivate.h"
 #include "lldb/API/SBMemoryRegionInfo.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/Target/MemoryRegionInfo.h"

 }
 
 SBMemoryRegionInfoList::SBMemoryRegionInfoList()
-    : m_opaque_up(new MemoryRegionInfoListImpl()) {}
+    : m_opaque_up(new MemoryRegionInfoListImpl()) {
+  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBMemoryRegionInfoList);
+}
 
 SBMemoryRegionInfoList::SBMemoryRegionInfoList(
     const SBMemoryRegionInfoList &rhs)
-    : m_opaque_up(new MemoryRegionInfoListImpl(*rhs.m_opaque_up)) {}
+    : m_opaque_up(new MemoryRegionInfoListImpl(*rhs.m_opaque_up)) {
+  LLDB_RECORD_CONSTRUCTOR(SBMemoryRegionInfoList,
+                          (const lldb::SBMemoryRegionInfoList &), rhs);
+}
 
 SBMemoryRegionInfoList::~SBMemoryRegionInfoList() {}
 
 const SBMemoryRegionInfoList &SBMemoryRegionInfoList::
 operator=(const SBMemoryRegionInfoList &rhs) {
+  LLDB_RECORD_METHOD(
+      const lldb::SBMemoryRegionInfoList &,
+      SBMemoryRegionInfoList, operator=,(const lldb::SBMemoryRegionInfoList &),
+      rhs);
+
   if (this != &rhs) {
     *m_opaque_up = *rhs.m_opaque_up;
   }

 }
 
 uint32_t SBMemoryRegionInfoList::GetSize() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBMemoryRegionInfoList, GetSize);
+
   return m_opaque_up->GetSize();
 }
 
 bool SBMemoryRegionInfoList::GetMemoryRegionAtIndex(
     uint32_t idx, SBMemoryRegionInfo &region_info) {
+  LLDB_RECORD_METHOD(bool, SBMemoryRegionInfoList, GetMemoryRegionAtIndex,
+                     (uint32_t, lldb::SBMemoryRegionInfo &), idx, region_info);
+
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   bool result = m_opaque_up->GetMemoryRegionInfoAtIndex(idx, region_info.ref());

   return result;
 }
 
-void SBMemoryRegionInfoList::Clear() { m_opaque_up->Clear(); }
+void SBMemoryRegionInfoList::Clear() {
+  LLDB_RECORD_METHOD_NO_ARGS(void, SBMemoryRegionInfoList, Clear);
+
+  m_opaque_up->Clear();
+}
 
 void SBMemoryRegionInfoList::Append(SBMemoryRegionInfo &sb_region) {
+  LLDB_RECORD_METHOD(void, SBMemoryRegionInfoList, Append,
+                     (lldb::SBMemoryRegionInfo &), 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);
+
   m_opaque_up->Append(*sb_region_list);
 }
 

lldb/source/API/SBModule.cpp

 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBModule.h"
+#include "SBReproducerPrivate.h"
 #include "lldb/API/SBAddress.h"
 #include "lldb/API/SBFileSpec.h"
 #include "lldb/API/SBModuleSpec.h"

 using namespace lldb;
 using namespace lldb_private;
 
-SBModule::SBModule() : m_opaque_sp() {}
+SBModule::SBModule() : m_opaque_sp() {
+  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBModule);
+}
 
 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);
+
   ModuleSP module_sp;
   Status error = ModuleList::GetSharedModule(*module_spec.m_opaque_up,
                                              module_sp, NULL, NULL, NULL);

     SetSP(module_sp);
 }
 
-SBModule::SBModule(const SBModule &rhs) : m_opaque_sp(rhs.m_opaque_sp) {}
+SBModule::SBModule(const SBModule &rhs) : m_opaque_sp(rhs.m_opaque_sp) {
+  LLDB_RECORD_CONSTRUCTOR(SBModule, (const lldb::SBModule &), 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);
+
   ProcessSP process_sp(process.GetSP());
   if (process_sp) {
     m_opaque_sp = process_sp->ReadModuleFromMemory(FileSpec(), header_addr);

 }
 
 const SBModule &SBModule::operator=(const SBModule &rhs) {
+  LLDB_RECORD_METHOD(const lldb::SBModule &,
+                     SBModule, operator=,(const lldb::SBModule &), rhs);
+
   if (this != &rhs)
     m_opaque_sp = rhs.m_opaque_sp;
   return *this;

 
 SBModule::~SBModule() {}
 
-bool SBModule::IsValid() const { return m_opaque_sp.get() != NULL; }
+bool SBModule::IsValid() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBModule, IsValid);
+
+  return m_opaque_sp.get() != NULL;
+}
+
+void SBModule::Clear() {
+  LLDB_RECORD_METHOD_NO_ARGS(void, SBModule, Clear);
 
-void SBModule::Clear() { m_opaque_sp.reset(); }
+  m_opaque_sp.reset();
+}
 
 SBFileSpec SBModule::GetFileSpec() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBFileSpec, SBModule, GetFileSpec);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   SBFileSpec file_spec;

                 static_cast<void *>(module_sp.get()),
                 static_cast<const void *>(file_spec.get()));
 
-  return file_spec;
+  return LLDB_RECORD_RESULT(file_spec);
 }
 
 lldb::SBFileSpec SBModule::GetPlatformFileSpec() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBFileSpec, SBModule,
+                                   GetPlatformFileSpec);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   SBFileSpec file_spec;

                 static_cast<void *>(module_sp.get()),
                 static_cast<const void *>(file_spec.get()));
 
-  return file_spec;
+  return LLDB_RECORD_RESULT(file_spec);
 }
 
 bool SBModule::SetPlatformFileSpec(const lldb::SBFileSpec &platform_file) {
+  LLDB_RECORD_METHOD(bool, SBModule, SetPlatformFileSpec,
+                     (const lldb::SBFileSpec &), platform_file);
+
   bool result = false;
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 

 }
 
 lldb::SBFileSpec SBModule::GetRemoteInstallFileSpec() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBFileSpec, SBModule,
+                             GetRemoteInstallFileSpec);
+
   SBFileSpec sb_file_spec;
   ModuleSP module_sp(GetSP());
   if (module_sp)
     sb_file_spec.SetFileSpec(module_sp->GetRemoteInstallFileSpec());
-  return sb_file_spec;
+  return LLDB_RECORD_RESULT(sb_file_spec);
 }
 
 bool SBModule::SetRemoteInstallFileSpec(lldb::SBFileSpec &file) {
+  LLDB_RECORD_METHOD(bool, SBModule, SetRemoteInstallFileSpec,
+                     (lldb::SBFileSpec &), file);
+
   ModuleSP module_sp(GetSP());
   if (module_sp) {
     module_sp->SetRemoteInstallFileSpec(file.ref());

 }
 
 const uint8_t *SBModule::GetUUIDBytes() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(const uint8_t *, SBModule, GetUUIDBytes);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   const uint8_t *uuid_bytes = NULL;

 }
 
 const char *SBModule::GetUUIDString() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBModule, GetUUIDString);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   const char *uuid_cstr = NULL;

 }
 
 bool SBModule::operator==(const SBModule &rhs) const {
+  LLDB_RECORD_METHOD_CONST(bool, SBModule, operator==,(const lldb::SBModule &),
+                           rhs);
+
   if (m_opaque_sp)
     return m_opaque_sp.get() == rhs.m_opaque_sp.get();
   return false;
 }
 
 bool SBModule::operator!=(const SBModule &rhs) const {
+  LLDB_RECORD_METHOD_CONST(bool, SBModule, operator!=,(const lldb::SBModule &),
+                           rhs);
+
   if (m_opaque_sp)
     return m_opaque_sp.get() != rhs.m_opaque_sp.get();
   return false;

 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::SBAddress sb_addr;
   ModuleSP module_sp(GetSP());
   if (module_sp) {

     if (module_sp->ResolveFileAddress(vm_addr, addr))
       sb_addr.ref() = addr;
   }
-  return sb_addr;
+  return LLDB_RECORD_RESULT(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);
+
   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 sb_sc;
+  return LLDB_RECORD_RESULT(sb_sc);
 }
 
 bool SBModule::GetDescription(SBStream &description) {
+  LLDB_RECORD_METHOD(bool, SBModule, GetDescription, (lldb::SBStream &),
+                     description);
+
   Stream &strm = description.ref();
 
   ModuleSP module_sp(GetSP());

 }
 
 uint32_t SBModule::GetNumCompileUnits() {
+  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBModule, GetNumCompileUnits);
+
   ModuleSP module_sp(GetSP());
   if (module_sp) {
     return module_sp->GetNumCompileUnits();

 }
 
 SBCompileUnit SBModule::GetCompileUnitAtIndex(uint32_t index) {
+  LLDB_RECORD_METHOD(lldb::SBCompileUnit, SBModule, GetCompileUnitAtIndex,
+                     (uint32_t), index);
+
   SBCompileUnit sb_cu;
   ModuleSP module_sp(GetSP());
   if (module_sp) {
     CompUnitSP cu_sp = module_sp->GetCompileUnitAtIndex(index);
     sb_cu.reset(cu_sp.get());
   }
-  return sb_cu;
+  return LLDB_RECORD_RESULT(sb_cu);
 }
 
-SBSymbolContextList
-SBModule::FindCompileUnits(const SBFileSpec &sb_file_spec) {
+SBSymbolContextList SBModule::FindCompileUnits(const SBFileSpec &sb_file_spec) {
+  LLDB_RECORD_METHOD(lldb::SBSymbolContextList, SBModule, FindCompileUnits,
+                     (const lldb::SBFileSpec &), sb_file_spec);
+
   SBSymbolContextList sb_sc_list;
   const ModuleSP module_sp(GetSP());
   if (sb_file_spec.IsValid() && module_sp) {
     const bool append = true;
     module_sp->FindCompileUnits(*sb_file_spec, append, *sb_sc_list);
   }
-  return sb_sc_list;
+  return LLDB_RECORD_RESULT(sb_sc_list);
 }
 
 static Symtab *GetUnifiedSymbolTable(const lldb::ModuleSP &module_sp) {

 }
 
 size_t SBModule::GetNumSymbols() {
+  LLDB_RECORD_METHOD_NO_ARGS(size_t, SBModule, GetNumSymbols);
+
   ModuleSP module_sp(GetSP());
   if (module_sp) {
     Symtab *symtab = GetUnifiedSymbolTable(module_sp);

 }
 
 SBSymbol SBModule::GetSymbolAtIndex(size_t idx) {
+  LLDB_RECORD_METHOD(lldb::SBSymbol, SBModule, GetSymbolAtIndex, (size_t), idx);
+
   SBSymbol sb_symbol;
   ModuleSP module_sp(GetSP());
   Symtab *symtab = GetUnifiedSymbolTable(module_sp);
   if (symtab)
     sb_symbol.SetSymbol(symtab->SymbolAtIndex(idx));
-  return sb_symbol;
+  return LLDB_RECORD_RESULT(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);
+
   SBSymbol sb_symbol;
   if (name && name[0]) {
     ModuleSP module_sp(GetSP());

           ConstString(name), symbol_type, Symtab::eDebugAny,
           Symtab::eVisibilityAny));
   }
-  return sb_symbol;
+  return LLDB_RECORD_RESULT(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);
+
   SBSymbolContextList sb_sc_list;
   if (name && name[0]) {
     ModuleSP module_sp(GetSP());

       }
     }
   }
-  return sb_sc_list;
+  return LLDB_RECORD_RESULT(sb_sc_list);
 }
 
 size_t SBModule::GetNumSections() {
+  LLDB_RECORD_METHOD_NO_ARGS(size_t, SBModule, GetNumSections);
+
   ModuleSP module_sp(GetSP());
   if (module_sp) {
     // Give the symbol vendor a chance to add to the unified section list.

 }
 
 SBSection SBModule::GetSectionAtIndex(size_t idx) {
+  LLDB_RECORD_METHOD(lldb::SBSection, SBModule, GetSectionAtIndex, (size_t),
+                     idx);
+
   SBSection sb_section;
   ModuleSP module_sp(GetSP());
   if (module_sp) {

     if (section_list)
       sb_section.SetSP(section_list->GetSectionAtIndex(idx));
   }
-  return sb_section;
+  return LLDB_RECORD_RESULT(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::SBSymbolContextList sb_sc_list;
   ModuleSP module_sp(GetSP());
   if (name && module_sp) {

     module_sp->FindFunctions(ConstString(name), NULL, type, symbols_ok,
                              inlines_ok, append, *sb_sc_list);
   }
-  return sb_sc_list;
+  return LLDB_RECORD_RESULT(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);
+
   SBValueList sb_value_list;
   ModuleSP module_sp(GetSP());
   if (name && module_sp) {

     }
   }
 
-  return sb_value_list;
+  return LLDB_RECORD_RESULT(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);
+
   SBValueList sb_value_list(FindGlobalVariables(target, name, 1));
   if (sb_value_list.IsValid() && sb_value_list.GetSize() > 0)
-    return sb_value_list.GetValueAtIndex(0);
-  return SBValue();
+    return LLDB_RECORD_RESULT(sb_value_list.GetValueAtIndex(0));
+  return LLDB_RECORD_RESULT(SBValue());
 }
 
 lldb::SBType SBModule::FindFirstType(const char *name_cstr) {
+  LLDB_RECORD_METHOD(lldb::SBType, SBModule, FindFirstType, (const char *),
+                     name_cstr);
+
   SBType sb_type;
   ModuleSP module_sp(GetSP());
   if (name_cstr && module_sp) {

         sb_type = SBType(type_system->GetBuiltinTypeByName(name));
     }
   }
-  return sb_type;
+  return LLDB_RECORD_RESULT(sb_type);
 }
 
 lldb::SBType SBModule::GetBasicType(lldb::BasicType type) {
+  LLDB_RECORD_METHOD(lldb::SBType, SBModule, GetBasicType, (lldb::BasicType),
+                     type);
+
   ModuleSP module_sp(GetSP());
   if (module_sp) {
     TypeSystem *type_system =
         module_sp->GetTypeSystemForLanguage(eLanguageTypeC);
     if (type_system)
-      return SBType(type_system->GetBasicTypeFromAST(type));
+      return LLDB_RECORD_RESULT(SBType(type_system->GetBasicTypeFromAST(type)));
   }
-  return SBType();
+  return LLDB_RECORD_RESULT(SBType());
 }
 
 lldb::SBTypeList SBModule::FindTypes(const char *type) {
+  LLDB_RECORD_METHOD(lldb::SBTypeList, SBModule, FindTypes, (const char *),
+                     type);
+
   SBTypeList retval;
 
   ModuleSP module_sp(GetSP());

     }
   }
 
-  return retval;
+  return LLDB_RECORD_RESULT(retval);
 }
 
 lldb::SBType SBModule::GetTypeByID(lldb::user_id_t uid) {
+  LLDB_RECORD_METHOD(lldb::SBType, SBModule, GetTypeByID, (lldb::user_id_t),
+                     uid);
+
   ModuleSP module_sp(GetSP());
   if (module_sp) {
     SymbolVendor *vendor = module_sp->GetSymbolVendor();
     if (vendor) {
       Type *type_ptr = vendor->ResolveTypeUID(uid);
       if (type_ptr)
-        return SBType(type_ptr->shared_from_this());
+        return LLDB_RECORD_RESULT(SBType(type_ptr->shared_from_this()));
     }
   }
-  return SBType();
+  return LLDB_RECORD_RESULT(SBType());
 }
 
 lldb::SBTypeList SBModule::GetTypes(uint32_t type_mask) {
+  LLDB_RECORD_METHOD(lldb::SBTypeList, SBModule, GetTypes, (uint32_t),
+                     type_mask);
+
   SBTypeList sb_type_list;
 
   ModuleSP module_sp(GetSP());
   if (!module_sp)
-    return sb_type_list;
+    return LLDB_RECORD_RESULT(sb_type_list);
   SymbolVendor *vendor = module_sp->GetSymbolVendor();
   if (!vendor)
-    return sb_type_list;
+    return LLDB_RECORD_RESULT(sb_type_list);
 
   TypeClass type_class = static_cast<TypeClass>(type_mask);
   TypeList type_list;
   vendor->GetTypes(NULL, type_class, type_list);
   sb_type_list.m_opaque_up->Append(type_list);
-  return sb_type_list;
+  return LLDB_RECORD_RESULT(sb_type_list);
 }
 
 SBSection SBModule::FindSection(const char *sect_name) {
+  LLDB_RECORD_METHOD(lldb::SBSection, SBModule, FindSection, (const char *),
+                     sect_name);
+
   SBSection sb_section;
 
   ModuleSP module_sp(GetSP());

       }
     }
   }
-  return sb_section;
+  return LLDB_RECORD_RESULT(sb_section);
 }
 
 lldb::ByteOrder SBModule::GetByteOrder() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::ByteOrder, SBModule, GetByteOrder);
+
   ModuleSP module_sp(GetSP());
   if (module_sp)
     return module_sp->GetArchitecture().GetByteOrder();

 }
 
 const char *SBModule::GetTriple() {
+  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBModule, GetTriple);
+
   ModuleSP module_sp(GetSP());
   if (module_sp) {
     std::string triple(module_sp->GetArchitecture().GetTriple().str());

 }
 
 uint32_t SBModule::GetAddressByteSize() {
+  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBModule, GetAddressByteSize);
+
   ModuleSP module_sp(GetSP());
   if (module_sp)
     return module_sp->GetArchitecture().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);
+
   llvm::VersionTuple version;
   if (ModuleSP module_sp = GetSP())
     version = module_sp->GetVersion();

 }
 
 lldb::SBFileSpec SBModule::GetSymbolFileSpec() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBFileSpec, SBModule,
+                                   GetSymbolFileSpec);
+
   lldb::SBFileSpec sb_file_spec;
   ModuleSP module_sp(GetSP());
   if (module_sp) {

     if (symbol_vendor_ptr)
       sb_file_spec.SetFileSpec(symbol_vendor_ptr->GetMainFileSpec());
   }
-  return sb_file_spec;
+  return LLDB_RECORD_RESULT(sb_file_spec);
 }
 
 lldb::SBAddress SBModule::GetObjectFileHeaderAddress() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBAddress, SBModule,
+                                   GetObjectFileHeaderAddress);
+
   lldb::SBAddress sb_addr;
   ModuleSP module_sp(GetSP());
   if (module_sp) {

     if (objfile_ptr)
       sb_addr.ref() = objfile_ptr->GetBaseAddress();
   }
-  return sb_addr;
+  return LLDB_RECORD_RESULT(sb_addr);
 }
 
 lldb::SBAddress SBModule::GetObjectFileEntryPointAddress() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBAddress, SBModule,
+                                   GetObjectFileEntryPointAddress);
+
   lldb::SBAddress sb_addr;
   ModuleSP module_sp(GetSP());
   if (module_sp) {

     if (objfile_ptr)
       sb_addr.ref() = objfile_ptr->GetEntryPointAddress();
   }
-  return sb_addr;
+  return LLDB_RECORD_RESULT(sb_addr);
 }

lldb/source/API/SBModuleSpec.cpp

 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBModuleSpec.h"
+#include "SBReproducerPrivate.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleSpec.h"

 using namespace lldb;
 using namespace lldb_private;
 
-SBModuleSpec::SBModuleSpec() : m_opaque_up(new lldb_private::ModuleSpec()) {}
+SBModuleSpec::SBModuleSpec() : m_opaque_up(new lldb_private::ModuleSpec()) {
+  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBModuleSpec);
+}
 
 SBModuleSpec::SBModuleSpec(const SBModuleSpec &rhs)
-    : m_opaque_up(new lldb_private::ModuleSpec(*rhs.m_opaque_up)) {}
+    : m_opaque_up(new lldb_private::ModuleSpec(*rhs.m_opaque_up)) {
+  LLDB_RECORD_CONSTRUCTOR(SBModuleSpec, (const lldb::SBModuleSpec &), rhs);
+}
 
 const SBModuleSpec &SBModuleSpec::operator=(const SBModuleSpec &rhs) {
+  LLDB_RECORD_METHOD(const lldb::SBModuleSpec &,
+                     SBModuleSpec, operator=,(const lldb::SBModuleSpec &), rhs);
+
   if (this != &rhs)
     *m_opaque_up = *(rhs.m_opaque_up);
   return *this;

 
 SBModuleSpec::~SBModuleSpec() {}
 
-bool SBModuleSpec::IsValid() const { return m_opaque_up->operator bool(); }
+bool SBModuleSpec::IsValid() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBModuleSpec, IsValid);
+
+  return m_opaque_up->operator bool();
+}
+
+void SBModuleSpec::Clear() {
+  LLDB_RECORD_METHOD_NO_ARGS(void, SBModuleSpec, Clear);
 
-void SBModuleSpec::Clear() { m_opaque_up->Clear(); }
+  m_opaque_up->Clear();
+}
 
 SBFileSpec SBModuleSpec::GetFileSpec() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBFileSpec, SBModuleSpec, GetFileSpec);
+
   SBFileSpec sb_spec(m_opaque_up->GetFileSpec());
-  return sb_spec;
+  return LLDB_RECORD_RESULT(sb_spec);
 }
 
 void SBModuleSpec::SetFileSpec(const lldb::SBFileSpec &sb_spec) {
+  LLDB_RECORD_METHOD(void, SBModuleSpec, SetFileSpec,
+                     (const lldb::SBFileSpec &), sb_spec);
+
   m_opaque_up->GetFileSpec() = *sb_spec;
 }
 
 lldb::SBFileSpec SBModuleSpec::GetPlatformFileSpec() {
-  return SBFileSpec(m_opaque_up->GetPlatformFileSpec());
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBFileSpec, SBModuleSpec,
+                             GetPlatformFileSpec);
+
+  return LLDB_RECORD_RESULT(SBFileSpec(m_opaque_up->GetPlatformFileSpec()));
 }
 
 void SBModuleSpec::SetPlatformFileSpec(const lldb::SBFileSpec &sb_spec) {
+  LLDB_RECORD_METHOD(void, SBModuleSpec, SetPlatformFileSpec,
+                     (const lldb::SBFileSpec &), sb_spec);
+
   m_opaque_up->GetPlatformFileSpec() = *sb_spec;
 }
 
 lldb::SBFileSpec SBModuleSpec::GetSymbolFileSpec() {
-  return SBFileSpec(m_opaque_up->GetSymbolFileSpec());
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBFileSpec, SBModuleSpec, GetSymbolFileSpec);
+
+  return LLDB_RECORD_RESULT(SBFileSpec(m_opaque_up->GetSymbolFileSpec()));
 }
 
 void SBModuleSpec::SetSymbolFileSpec(const lldb::SBFileSpec &sb_spec) {
+  LLDB_RECORD_METHOD(void, SBModuleSpec, SetSymbolFileSpec,
+                     (const lldb::SBFileSpec &), sb_spec);
+
   m_opaque_up->GetSymbolFileSpec() = *sb_spec;
 }
 
 const char *SBModuleSpec::GetObjectName() {
+  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBModuleSpec, GetObjectName);
+
   return m_opaque_up->GetObjectName().GetCString();
 }
 
 void SBModuleSpec::SetObjectName(const char *name) {
+  LLDB_RECORD_METHOD(void, SBModuleSpec, SetObjectName, (const char *), name);
+
   m_opaque_up->GetObjectName().SetCString(name);
 }
 
 const char *SBModuleSpec::GetTriple() {
+  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBModuleSpec, GetTriple);
+
   std::string triple(m_opaque_up->GetArchitecture().GetTriple().str());
   // Unique the string so we don't run into ownership issues since the const
   // strings put the string into the string pool once and the strings never

 }
 
 void SBModuleSpec::SetTriple(const char *triple) {
+  LLDB_RECORD_METHOD(void, SBModuleSpec, SetTriple, (const char *), triple);
+
   m_opaque_up->GetArchitecture().SetTriple(triple);
 }
 

 }
 
 size_t SBModuleSpec::GetUUIDLength() {
+  LLDB_RECORD_METHOD_NO_ARGS(size_t, SBModuleSpec, GetUUIDLength);
+
   return m_opaque_up->GetUUID().GetBytes().size();
 }
 

 }
 
 bool SBModuleSpec::GetDescription(lldb::SBStream &description) {
+  LLDB_RECORD_METHOD(bool, SBModuleSpec, GetDescription, (lldb::SBStream &),
+                     description);
+
   m_opaque_up->Dump(description.ref());
   return true;
 }
 
-SBModuleSpecList::SBModuleSpecList() : m_opaque_up(new ModuleSpecList()) {}
+SBModuleSpecList::SBModuleSpecList() : m_opaque_up(new ModuleSpecList()) {
+  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBModuleSpecList);
+}
 
 SBModuleSpecList::SBModuleSpecList(const SBModuleSpecList &rhs)
-    : m_opaque_up(new ModuleSpecList(*rhs.m_opaque_up)) {}
+    : m_opaque_up(new ModuleSpecList(*rhs.m_opaque_up)) {
+  LLDB_RECORD_CONSTRUCTOR(SBModuleSpecList, (const lldb::SBModuleSpecList &),
+                          rhs);
+}
 
 SBModuleSpecList &SBModuleSpecList::operator=(const SBModuleSpecList &rhs) {
+  LLDB_RECORD_METHOD(
+      lldb::SBModuleSpecList &,
+      SBModuleSpecList, operator=,(const lldb::SBModuleSpecList &), rhs);
+
   if (this != &rhs)
     *m_opaque_up = *rhs.m_opaque_up;
   return *this;

 SBModuleSpecList::~SBModuleSpecList() {}
 
 SBModuleSpecList SBModuleSpecList::GetModuleSpecifications(const char *path) {
+  LLDB_RECORD_STATIC_METHOD(lldb::SBModuleSpecList, SBModuleSpecList,
+                            GetModuleSpecifications, (const char *), 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 specs;
+  return LLDB_RECORD_RESULT(specs);
 }
 
 void SBModuleSpecList::Append(const SBModuleSpec &spec) {
+  LLDB_RECORD_METHOD(void, SBModuleSpecList, Append,
+                     (const lldb::SBModuleSpec &), 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);
+
   m_opaque_up->Append(*spec_list.m_opaque_up);
 }
 
-size_t SBModuleSpecList::GetSize() { return m_opaque_up->GetSize(); }
+size_t SBModuleSpecList::GetSize() {
+  LLDB_RECORD_METHOD_NO_ARGS(size_t, SBModuleSpecList, GetSize);
+
+  return m_opaque_up->GetSize();
+}
 
 SBModuleSpec SBModuleSpecList::GetSpecAtIndex(size_t i) {
+  LLDB_RECORD_METHOD(lldb::SBModuleSpec, SBModuleSpecList, GetSpecAtIndex,
+                     (size_t), i);
+
   SBModuleSpec sb_module_spec;
   m_opaque_up->GetModuleSpecAtIndex(i, *sb_module_spec.m_opaque_up);
-  return sb_module_spec;
+  return LLDB_RECORD_RESULT(sb_module_spec);
 }
 
 SBModuleSpec
 SBModuleSpecList::FindFirstMatchingSpec(const SBModuleSpec &match_spec) {
+  LLDB_RECORD_METHOD(lldb::SBModuleSpec, SBModuleSpecList,
+                     FindFirstMatchingSpec, (const lldb::SBModuleSpec &),
+                     match_spec);
+
   SBModuleSpec sb_module_spec;
   m_opaque_up->FindMatchingModuleSpec(*match_spec.m_opaque_up,
                                       *sb_module_spec.m_opaque_up);
-  return sb_module_spec;
+  return LLDB_RECORD_RESULT(sb_module_spec);
 }
 
 SBModuleSpecList
 SBModuleSpecList::FindMatchingSpecs(const SBModuleSpec &match_spec) {
+  LLDB_RECORD_METHOD(lldb::SBModuleSpecList, SBModuleSpecList,
+                     FindMatchingSpecs, (const lldb::SBModuleSpec &),
+                     match_spec);
+
   SBModuleSpecList specs;
   m_opaque_up->FindMatchingModuleSpecs(*match_spec.m_opaque_up,
                                        *specs.m_opaque_up);
-  return specs;
+  return LLDB_RECORD_RESULT(specs);
 }
 
 bool SBModuleSpecList::GetDescription(lldb::SBStream &description) {
+  LLDB_RECORD_METHOD(bool, SBModuleSpecList, GetDescription, (lldb::SBStream &),
+                     description);
+
   m_opaque_up->Dump(description.ref());
   return true;
 }

lldb/source/API/SBPlatform.cpp

 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBPlatform.h"
+#include "SBReproducerPrivate.h"
 #include "lldb/API/SBError.h"
 #include "lldb/API/SBFileSpec.h"
 #include "lldb/API/SBLaunchInfo.h"

 // SBPlatformConnectOptions
 //----------------------------------------------------------------------
 SBPlatformConnectOptions::SBPlatformConnectOptions(const char *url)
-    : m_opaque_ptr(new PlatformConnectOptions(url)) {}
+    : m_opaque_ptr(new PlatformConnectOptions(url)) {
+  LLDB_RECORD_CONSTRUCTOR(SBPlatformConnectOptions, (const char *), url);
+}
 
 SBPlatformConnectOptions::SBPlatformConnectOptions(
     const SBPlatformConnectOptions &rhs)
     : m_opaque_ptr(new PlatformConnectOptions()) {
+  LLDB_RECORD_CONSTRUCTOR(SBPlatformConnectOptions,
+                          (const lldb::SBPlatformConnectOptions &), rhs);
+
   *m_opaque_ptr = *rhs.m_opaque_ptr;
 }
 
 SBPlatformConnectOptions::~SBPlatformConnectOptions() { delete m_opaque_ptr; }
 
 void SBPlatformConnectOptions::operator=(const SBPlatformConnectOptions &rhs) {
+  LLDB_RECORD_METHOD(
+      void,
+      SBPlatformConnectOptions, operator=,(
+                                    const lldb::SBPlatformConnectOptions &),
+      rhs);
+
   *m_opaque_ptr = *rhs.m_opaque_ptr;
 }
 
 const char *SBPlatformConnectOptions::GetURL() {
+  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBPlatformConnectOptions, GetURL);
+
   if (m_opaque_ptr->m_url.empty())
     return NULL;
   return m_opaque_ptr->m_url.c_str();
 }
 
 void SBPlatformConnectOptions::SetURL(const char *url) {
+  LLDB_RECORD_METHOD(void, SBPlatformConnectOptions, SetURL, (const char *),
+                     url);
+
   if (url && url[0])
     m_opaque_ptr->m_url = url;
   else

 }
 
 bool SBPlatformConnectOptions::GetRsyncEnabled() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBPlatformConnectOptions, GetRsyncEnabled);
+
   return m_opaque_ptr->m_rsync_enabled;
 }
 
 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);
+
   m_opaque_ptr->m_rsync_enabled = true;
   m_opaque_ptr->m_rsync_omit_hostname_from_remote_path =
       omit_hostname_from_remote_path;

 }
 
 void SBPlatformConnectOptions::DisableRsync() {
+  LLDB_RECORD_METHOD_NO_ARGS(void, SBPlatformConnectOptions, DisableRsync);
+
   m_opaque_ptr->m_rsync_enabled = false;
 }
 
 const char *SBPlatformConnectOptions::GetLocalCacheDirectory() {
+  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBPlatformConnectOptions,
+                             GetLocalCacheDirectory);
+
   return m_opaque_ptr->m_local_cache_directory.GetCString();
 }
 
 void SBPlatformConnectOptions::SetLocalCacheDirectory(const char *path) {
+  LLDB_RECORD_METHOD(void, SBPlatformConnectOptions, SetLocalCacheDirectory,
+                     (const char *), path);
+
   if (path && path[0])
     m_opaque_ptr->m_local_cache_directory.SetCString(path);
   else

 // SBPlatformShellCommand
 //----------------------------------------------------------------------
 SBPlatformShellCommand::SBPlatformShellCommand(const char *shell_command)
-    : m_opaque_ptr(new PlatformShellCommand(shell_command)) {}
+    : m_opaque_ptr(new PlatformShellCommand(shell_command)) {
+  LLDB_RECORD_CONSTRUCTOR(SBPlatformShellCommand, (const char *),
+                          shell_command);
+}
 
 SBPlatformShellCommand::SBPlatformShellCommand(
     const SBPlatformShellCommand &rhs)
     : m_opaque_ptr(new PlatformShellCommand()) {
+  LLDB_RECORD_CONSTRUCTOR(SBPlatformShellCommand,
+                          (const lldb::SBPlatformShellCommand &), rhs);
+
   *m_opaque_ptr = *rhs.m_opaque_ptr;
 }
 
 SBPlatformShellCommand::~SBPlatformShellCommand() { delete m_opaque_ptr; }
 
 void SBPlatformShellCommand::Clear() {
+  LLDB_RECORD_METHOD_NO_ARGS(void, SBPlatformShellCommand, Clear);
+
   m_opaque_ptr->m_output = std::string();
   m_opaque_ptr->m_status = 0;
   m_opaque_ptr->m_signo = 0;
 }
 
 const char *SBPlatformShellCommand::GetCommand() {
+  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBPlatformShellCommand, GetCommand);
+
   if (m_opaque_ptr->m_command.empty())
     return NULL;
   return m_opaque_ptr->m_command.c_str();
 }
 
 void SBPlatformShellCommand::SetCommand(const char *shell_command) {
+  LLDB_RECORD_METHOD(void, SBPlatformShellCommand, SetCommand, (const char *),
+                     shell_command);
+
   if (shell_command && shell_command[0])
     m_opaque_ptr->m_command = shell_command;
   else

 }
 
 const char *SBPlatformShellCommand::GetWorkingDirectory() {
+  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBPlatformShellCommand,
+                             GetWorkingDirectory);
+
   if (m_opaque_ptr->m_working_dir.empty())
     return NULL;
   return m_opaque_ptr->m_working_dir.c_str();
 }
 
 void SBPlatformShellCommand::SetWorkingDirectory(const char *path) {
+  LLDB_RECORD_METHOD(void, SBPlatformShellCommand, SetWorkingDirectory,
+                     (const char *), path);
+
   if (path && path[0])
     m_opaque_ptr->m_working_dir = path;
   else

 }
 
 uint32_t SBPlatformShellCommand::GetTimeoutSeconds() {
+  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBPlatformShellCommand,
+                             GetTimeoutSeconds);
+
   if (m_opaque_ptr->m_timeout)
     return m_opaque_ptr->m_timeout->count();
   return UINT32_MAX;
 }
 
 void SBPlatformShellCommand::SetTimeoutSeconds(uint32_t sec) {
+  LLDB_RECORD_METHOD(void, SBPlatformShellCommand, SetTimeoutSeconds,
+                     (uint32_t), sec);
+
   if (sec == UINT32_MAX)
     m_opaque_ptr->m_timeout = llvm::None;
   else
     m_opaque_ptr->m_timeout = std::chrono::seconds(sec);
 }
 
-int SBPlatformShellCommand::GetSignal() { return m_opaque_ptr->m_signo; }
+int SBPlatformShellCommand::GetSignal() {
+  LLDB_RECORD_METHOD_NO_ARGS(int, SBPlatformShellCommand, GetSignal);
+
+  return m_opaque_ptr->m_signo;
+}
+
+int SBPlatformShellCommand::GetStatus() {
+  LLDB_RECORD_METHOD_NO_ARGS(int, SBPlatformShellCommand, GetStatus);
 
-int SBPlatformShellCommand::GetStatus() { return m_opaque_ptr->m_status; }
+  return m_opaque_ptr->m_status;
+}
 
 const char *SBPlatformShellCommand::GetOutput() {
+  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBPlatformShellCommand, GetOutput);
+
   if (m_opaque_ptr->m_output.empty())
     return NULL;
   return m_opaque_ptr->m_output.c_str();

 //----------------------------------------------------------------------
 // SBPlatform
 //----------------------------------------------------------------------
-SBPlatform::SBPlatform() : m_opaque_sp() {}
+SBPlatform::SBPlatform() : m_opaque_sp() {
+  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBPlatform);
+}
 
 SBPlatform::SBPlatform(const char *platform_name) : m_opaque_sp() {
+  LLDB_RECORD_CONSTRUCTOR(SBPlatform, (const char *), platform_name);
+
   Status error;
   if (platform_name && platform_name[0])
     m_opaque_sp = Platform::Create(ConstString(platform_name), error);

 
 SBPlatform::~SBPlatform() {}
 
-bool SBPlatform::IsValid() const { return m_opaque_sp.get() != NULL; }
+bool SBPlatform::IsValid() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBPlatform, IsValid);
+
+  return m_opaque_sp.get() != NULL;
+}
+
+void SBPlatform::Clear() {
+  LLDB_RECORD_METHOD_NO_ARGS(void, SBPlatform, Clear);
 
-void SBPlatform::Clear() { m_opaque_sp.reset(); }
+  m_opaque_sp.reset();
+}
 
 const char *SBPlatform::GetName() {
+  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBPlatform, GetName);
+
   PlatformSP platform_sp(GetSP());
   if (platform_sp)
     return platform_sp->GetName().GetCString();

 }
 
 const char *SBPlatform::GetWorkingDirectory() {
+  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBPlatform, GetWorkingDirectory);
+
   PlatformSP platform_sp(GetSP());
   if (platform_sp)
     return platform_sp->GetWorkingDirectory().GetCString();

 }
 
 bool SBPlatform::SetWorkingDirectory(const char *path) {
+  LLDB_RECORD_METHOD(bool, SBPlatform, SetWorkingDirectory, (const char *),
+                     path);
+
   PlatformSP platform_sp(GetSP());
   if (platform_sp) {
     if (path)

 }
 
 SBError SBPlatform::ConnectRemote(SBPlatformConnectOptions &connect_options) {
+  LLDB_RECORD_METHOD(lldb::SBError, SBPlatform, ConnectRemote,
+                     (lldb::SBPlatformConnectOptions &), connect_options);
+
   SBError sb_error;
   PlatformSP platform_sp(GetSP());
   if (platform_sp && connect_options.GetURL()) {

   } else {
     sb_error.SetErrorString("invalid platform");
   }
-  return sb_error;
+  return LLDB_RECORD_RESULT(sb_error);
 }
 
 void SBPlatform::DisconnectRemote() {
+  LLDB_RECORD_METHOD_NO_ARGS(void, SBPlatform, DisconnectRemote);
+
   PlatformSP platform_sp(GetSP());
   if (platform_sp)
     platform_sp->DisconnectRemote();
 }
 
 bool SBPlatform::IsConnected() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBPlatform, IsConnected);
+
   PlatformSP platform_sp(GetSP());
   if (platform_sp)
     return platform_sp->IsConnected();

 }
 
 const char *SBPlatform::GetTriple() {
+  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBPlatform, GetTriple);
+
   PlatformSP platform_sp(GetSP());
   if (platform_sp) {
     ArchSpec arch(platform_sp->GetSystemArchitecture());

 }
 
 const char *SBPlatform::GetOSBuild() {
+  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBPlatform, GetOSBuild);
+
   PlatformSP platform_sp(GetSP());
   if (platform_sp) {
     std::string s;

 }
 
 const char *SBPlatform::GetOSDescription() {
+  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBPlatform, GetOSDescription);
+
   PlatformSP platform_sp(GetSP());
   if (platform_sp) {
     std::string s;

 }
 
 const char *SBPlatform::GetHostname() {
+  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBPlatform, GetHostname);
+
   PlatformSP platform_sp(GetSP());
   if (platform_sp)
     return platform_sp->GetHostname();

 }
 
 uint32_t SBPlatform::GetOSMajorVersion() {
+  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBPlatform, GetOSMajorVersion);
+
   llvm::VersionTuple version;
   if (PlatformSP platform_sp = GetSP())
     version = platform_sp->GetOSVersion();

 }
 
 uint32_t SBPlatform::GetOSMinorVersion() {
+  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBPlatform, GetOSMinorVersion);
+
   llvm::VersionTuple version;
   if (PlatformSP platform_sp = GetSP())
     version = platform_sp->GetOSVersion();

 }
 
 uint32_t SBPlatform::GetOSUpdateVersion() {
+  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBPlatform, GetOSUpdateVersion);
+
   llvm::VersionTuple version;
   if (PlatformSP platform_sp = GetSP())
     version = platform_sp->GetOSVersion();

 }
 
 SBError SBPlatform::Get(SBFileSpec &src, SBFileSpec &dst) {
+  LLDB_RECORD_METHOD(lldb::SBError, SBPlatform, Get,
+                     (lldb::SBFileSpec &, lldb::SBFileSpec &), src, dst);
+
   SBError sb_error;
   PlatformSP platform_sp(GetSP());
   if (platform_sp) {

   } else {
     sb_error.SetErrorString("invalid platform");
   }
-  return sb_error;
+  return LLDB_RECORD_RESULT(sb_error);
 }
 
 SBError SBPlatform::Put(SBFileSpec &src, SBFileSpec &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);
-    }
-
-    Status error;
-    error.SetErrorStringWithFormat("'src' argument doesn't exist: '%s'",
-                                   src.ref().GetPath().c_str());
-    return error;
-  });
+  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;
+          }
+
+          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;
+      }));
 }
 
 SBError SBPlatform::Install(SBFileSpec &src, SBFileSpec &dst) {
-  return ExecuteConnected([&](const lldb::PlatformSP &platform_sp) {
-    if (src.Exists())
-      return platform_sp->Install(src.ref(), dst.ref());
+  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());
 
         Status error;
         error.SetErrorStringWithFormat("'src' argument doesn't exist: '%s'",
                                        src.ref().GetPath().c_str());
         return error;
-  });
+      }));
 }
 
 SBError SBPlatform::Run(SBPlatformShellCommand &shell_command) {
-  return ExecuteConnected([&](const lldb::PlatformSP &platform_sp) {
+  LLDB_RECORD_METHOD(lldb::SBError, SBPlatform, Run,
+                     (lldb::SBPlatformShellCommand &), shell_command);
+  return LLDB_RECORD_RESULT(ExecuteConnected([&](const lldb::PlatformSP
+                                                     &platform_sp) {
     const char *command = shell_command.GetCommand();
     if (!command)
       return Status("invalid shell command (empty)");

                                         &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) {
-  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;
-  });
+  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;
+      }));
 }
 
 SBError SBPlatform::Kill(const lldb::pid_t pid) {
-  return ExecuteConnected([&](const lldb::PlatformSP &platform_sp) {
-    return platform_sp->KillProcess(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);
+      }));
 }
 
 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);
+
   SBError sb_error;
   PlatformSP platform_sp(GetSP());
   if (platform_sp) {

   } else {
     sb_error.SetErrorString("invalid platform");
   }
-  return sb_error;
+  return LLDB_RECORD_RESULT(sb_error);
 }
 
 uint32_t SBPlatform::GetFilePermissions(const char *path) {
+  LLDB_RECORD_METHOD(uint32_t, SBPlatform, GetFilePermissions, (const char *),
+                     path);
+
   PlatformSP platform_sp(GetSP());
   if (platform_sp) {
     uint32_t file_permissions = 0;

 
 SBError SBPlatform::SetFilePermissions(const char *path,
                                        uint32_t file_permissions) {
+  LLDB_RECORD_METHOD(lldb::SBError, SBPlatform, SetFilePermissions,
+                     (const char *, uint32_t), path, file_permissions);
+
   SBError sb_error;
   PlatformSP platform_sp(GetSP());
   if (platform_sp) {

   } else {
     sb_error.SetErrorString("invalid platform");
   }
-  return sb_error;
+  return LLDB_RECORD_RESULT(sb_error);
 }
 
 SBUnixSignals SBPlatform::GetUnixSignals() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBUnixSignals, SBPlatform,
+                                   GetUnixSignals);
+
   if (auto platform_sp = GetSP())
-    return SBUnixSignals{platform_sp};
+    return LLDB_RECORD_RESULT(SBUnixSignals{platform_sp});
 
-  return {};
+  return LLDB_RECORD_RESULT(SBUnixSignals());
 }

lldb/source/API/SBProcess.cpp

 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBProcess.h"
+#include "SBReproducerPrivate.h"
 
 #include <inttypes.h>
 

 using namespace lldb;
 using namespace lldb_private;
 
-SBProcess::SBProcess() : m_opaque_wp() {}
+SBProcess::SBProcess() : m_opaque_wp() {
+  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBProcess);
+}
 
 //----------------------------------------------------------------------
 // SBProcess constructor
 //----------------------------------------------------------------------
 
-SBProcess::SBProcess(const SBProcess &rhs) : m_opaque_wp(rhs.m_opaque_wp) {}
+SBProcess::SBProcess(const SBProcess &rhs) : m_opaque_wp(rhs.m_opaque_wp) {
+  LLDB_RECORD_CONSTRUCTOR(SBProcess, (const lldb::SBProcess &), rhs);
+}
 
 SBProcess::SBProcess(const lldb::ProcessSP &process_sp)
-    : m_opaque_wp(process_sp) {}
+    : m_opaque_wp(process_sp) {
+  LLDB_RECORD_CONSTRUCTOR(SBProcess, (const lldb::ProcessSP &), process_sp);
+}
 
 const SBProcess &SBProcess::operator=(const SBProcess &rhs) {
+  LLDB_RECORD_METHOD(const lldb::SBProcess &,
+                     SBProcess, operator=,(const lldb::SBProcess &), rhs);
+
   if (this != &rhs)
     m_opaque_wp = rhs.m_opaque_wp;
   return *this;

 SBProcess::~SBProcess() {}
 
 const char *SBProcess::GetBroadcasterClassName() {
+  LLDB_RECORD_STATIC_METHOD_NO_ARGS(const char *, SBProcess,
+                                    GetBroadcasterClassName);
+
   return Process::GetStaticBroadcasterClass().AsCString();
 }
 
 const char *SBProcess::GetPluginName() {
+  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBProcess, GetPluginName);
+
   ProcessSP process_sp(GetSP());
   if (process_sp) {
     return process_sp->GetPluginName().GetCString();

 }
 
 const char *SBProcess::GetShortPluginName() {
+  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBProcess, GetShortPluginName);
+
   ProcessSP process_sp(GetSP());
   if (process_sp) {
     return process_sp->GetPluginName().GetCString();

 
 void SBProcess::SetSP(const ProcessSP &process_sp) { m_opaque_wp = process_sp; }
 
-void SBProcess::Clear() { m_opaque_wp.reset(); }
+void SBProcess::Clear() {
+  LLDB_RECORD_METHOD_NO_ARGS(void, SBProcess, Clear);
+
+  m_opaque_wp.reset();
+}
 
 bool SBProcess::IsValid() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBProcess, IsValid);
+
   ProcessSP process_sp(m_opaque_wp.lock());
   return ((bool)process_sp && process_sp->IsValid());
 }

                              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,
+                     working_directory, launch_flags, stop_at_entry, error);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   if (log)
     log->Printf("SBProcess(%p)::RemoteLaunch (argv=%p, envp=%p, stdin=%s, "

 
 bool SBProcess::RemoteAttachToProcessWithID(lldb::pid_t pid,
                                             lldb::SBError &error) {
+  LLDB_RECORD_METHOD(bool, SBProcess, RemoteAttachToProcessWithID,
+                     (lldb::pid_t, lldb::SBError &), pid, error);
+
   ProcessSP process_sp(GetSP());
   if (process_sp) {
     std::lock_guard<std::recursive_mutex> guard(

 }
 
 uint32_t SBProcess::GetNumThreads() {
+  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBProcess, GetNumThreads);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   uint32_t num_threads = 0;

 }
 
 SBThread SBProcess::GetSelectedThread() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBThread, SBProcess,
+                                   GetSelectedThread);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   SBThread sb_thread;

                 static_cast<void *>(process_sp.get()),
                 static_cast<void *>(thread_sp.get()));
 
-  return sb_thread;
+  return LLDB_RECORD_RESULT(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);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   SBThread sb_thread;

                 static_cast<void *>(process_sp.get()), tid, context,
                 static_cast<void *>(thread_sp.get()));
 
-  return sb_thread;
+  return LLDB_RECORD_RESULT(sb_thread);
 }
 
 SBTarget SBProcess::GetTarget() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBTarget, SBProcess, GetTarget);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   SBTarget sb_target;

                 static_cast<void *>(process_sp.get()),
                 static_cast<void *>(target_sp.get()));
 
-  return sb_target;
+  return LLDB_RECORD_RESULT(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);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   size_t ret_val = 0;

 }
 
 size_t SBProcess::GetSTDOUT(char *dst, size_t dst_len) const {
+  LLDB_RECORD_METHOD_CONST(size_t, SBProcess, GetSTDOUT, (char *, size_t), dst,
+                           dst_len);
+
   size_t bytes_read = 0;
   ProcessSP process_sp(GetSP());
   if (process_sp) {

 }
 
 size_t SBProcess::GetSTDERR(char *dst, size_t dst_len) const {
+  LLDB_RECORD_METHOD_CONST(size_t, SBProcess, GetSTDERR, (char *, size_t), dst,
+                           dst_len);
+
   size_t bytes_read = 0;
   ProcessSP process_sp(GetSP());
   if (process_sp) {

 }
 
 size_t SBProcess::GetAsyncProfileData(char *dst, size_t dst_len) const {
+  LLDB_RECORD_METHOD_CONST(size_t, SBProcess, GetAsyncProfileData,
+                           (char *, size_t), dst, dst_len);
+
   size_t bytes_read = 0;
   ProcessSP process_sp(GetSP());
   if (process_sp) {

 
 lldb::SBTrace SBProcess::StartTrace(SBTraceOptions &options,
                                     lldb::SBError &error) {
+  LLDB_RECORD_METHOD(lldb::SBTrace, SBProcess, StartTrace,
+                     (lldb::SBTraceOptions &, lldb::SBError &), options, error);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   ProcessSP process_sp(GetSP());
   error.Clear();

     trace_instance.SetTraceUID(uid);
     LLDB_LOG(log, "SBProcess::returned uid - {0}", uid);
   }
-  return trace_instance;
+  return LLDB_RECORD_RESULT(trace_instance);
 }
 
 void SBProcess::ReportEventState(const SBEvent &event, FILE *out) const {
+  LLDB_RECORD_METHOD_CONST(void, SBProcess, ReportEventState,
+                           (const lldb::SBEvent &, FILE *), event, out);
+
   if (out == NULL)
     return;
 

 
 void SBProcess::AppendEventStateReport(const SBEvent &event,
                                        SBCommandReturnObject &result) {
+  LLDB_RECORD_METHOD(void, SBProcess, AppendEventStateReport,
+                     (const lldb::SBEvent &, lldb::SBCommandReturnObject &),
+                     event, result);
+
   ProcessSP process_sp(GetSP());
   if (process_sp) {
     const StateType event_state = SBProcess::GetStateFromEvent(event);

 }
 
 bool SBProcess::SetSelectedThread(const SBThread &thread) {
+  LLDB_RECORD_METHOD(bool, SBProcess, SetSelectedThread,
+                     (const lldb::SBThread &), thread);
+
   ProcessSP process_sp(GetSP());
   if (process_sp) {
     std::lock_guard<std::recursive_mutex> guard(

 }
 
 bool SBProcess::SetSelectedThreadByID(lldb::tid_t tid) {
+  LLDB_RECORD_METHOD(bool, SBProcess, SetSelectedThreadByID, (lldb::tid_t),
+                     tid);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   bool ret_val = false;

 }
 
 bool SBProcess::SetSelectedThreadByIndexID(uint32_t index_id) {
+  LLDB_RECORD_METHOD(bool, SBProcess, SetSelectedThreadByIndexID, (uint32_t),
+                     index_id);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   bool ret_val = false;

 }
 
 SBThread SBProcess::GetThreadAtIndex(size_t index) {
+  LLDB_RECORD_METHOD(lldb::SBThread, SBProcess, GetThreadAtIndex, (size_t),
+                     index);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   SBThread sb_thread;

                 static_cast<uint32_t>(index),
                 static_cast<void *>(thread_sp.get()));
 
-  return sb_thread;
+  return LLDB_RECORD_RESULT(sb_thread);
 }
 
 uint32_t SBProcess::GetNumQueues() {
+  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBProcess, GetNumQueues);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   uint32_t num_queues = 0;

 }
 
 SBQueue SBProcess::GetQueueAtIndex(size_t index) {
+  LLDB_RECORD_METHOD(lldb::SBQueue, SBProcess, GetQueueAtIndex, (size_t),
+                     index);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   SBQueue sb_queue;

                 static_cast<uint32_t>(index),
                 static_cast<void *>(queue_sp.get()));
 
-  return sb_queue;
+  return LLDB_RECORD_RESULT(sb_queue);
 }
 
 uint32_t SBProcess::GetStopID(bool include_expression_stops) {
+  LLDB_RECORD_METHOD(uint32_t, SBProcess, GetStopID, (bool),
+                     include_expression_stops);
+
   ProcessSP process_sp(GetSP());
   if (process_sp) {
     std::lock_guard<std::recursive_mutex> guard(

 }
 
 SBEvent SBProcess::GetStopEventForStopID(uint32_t stop_id) {
+  LLDB_RECORD_METHOD(lldb::SBEvent, SBProcess, GetStopEventForStopID,
+                     (uint32_t), stop_id);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   SBEvent sb_event;

                 static_cast<void *>(process_sp.get()), stop_id,
                 static_cast<void *>(event_sp.get()));
 
-  return sb_event;
+  return LLDB_RECORD_RESULT(sb_event);
 }
 
 StateType SBProcess::GetState() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::StateType, SBProcess, GetState);
 
   StateType ret_val = eStateInvalid;
   ProcessSP process_sp(GetSP());

 }
 
 int SBProcess::GetExitStatus() {
+  LLDB_RECORD_METHOD_NO_ARGS(int, SBProcess, GetExitStatus);
+
   int exit_status = 0;
   ProcessSP process_sp(GetSP());
   if (process_sp) {

 }
 
 const char *SBProcess::GetExitDescription() {
+  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBProcess, GetExitDescription);
+
   const char *exit_desc = NULL;
   ProcessSP process_sp(GetSP());
   if (process_sp) {

 }
 
 lldb::pid_t SBProcess::GetProcessID() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::pid_t, SBProcess, GetProcessID);
+
   lldb::pid_t ret_val = LLDB_INVALID_PROCESS_ID;
   ProcessSP process_sp(GetSP());
   if (process_sp)

 }
 
 uint32_t SBProcess::GetUniqueID() {
+  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBProcess, GetUniqueID);
+
   uint32_t ret_val = 0;
   ProcessSP process_sp(GetSP());
   if (process_sp)

 }
 
 ByteOrder SBProcess::GetByteOrder() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::ByteOrder, SBProcess, GetByteOrder);
+
   ByteOrder byteOrder = eByteOrderInvalid;
   ProcessSP process_sp(GetSP());
   if (process_sp)

 }
 
 uint32_t SBProcess::GetAddressByteSize() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBProcess, GetAddressByteSize);
+
   uint32_t size = 0;
   ProcessSP process_sp(GetSP());
   if (process_sp)

 }
 
 SBError SBProcess::Continue() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBProcess, Continue);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   SBError sb_error;

                 static_cast<void *>(sb_error.get()), sstr.GetData());
   }
 
-  return sb_error;
+  return LLDB_RECORD_RESULT(sb_error);
 }
 
 SBError SBProcess::Destroy() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBProcess, Destroy);
+
   SBError sb_error;
   ProcessSP process_sp(GetSP());
   if (process_sp) {

                 static_cast<void *>(sb_error.get()), sstr.GetData());
   }
 
-  return sb_error;
+  return LLDB_RECORD_RESULT(sb_error);
 }
 
 SBError SBProcess::Stop() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBProcess, Stop);
+
   SBError sb_error;
   ProcessSP process_sp(GetSP());
   if (process_sp) {

                 static_cast<void *>(sb_error.get()), sstr.GetData());
   }
 
-  return sb_error;
+  return LLDB_RECORD_RESULT(sb_error);
 }
 
 SBError SBProcess::Kill() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBProcess, Kill);
+
   SBError sb_error;
   ProcessSP process_sp(GetSP());
   if (process_sp) {

                 static_cast<void *>(sb_error.get()), sstr.GetData());
   }
 
-  return sb_error;
+  return LLDB_RECORD_RESULT(sb_error);
 }
 
 SBError SBProcess::Detach() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBProcess, Detach);
+
   // FIXME: This should come from a process default.
   bool keep_stopped = false;
-  return Detach(keep_stopped);
+  return LLDB_RECORD_RESULT(Detach(keep_stopped));
 }
 
 SBError SBProcess::Detach(bool keep_stopped) {
+  LLDB_RECORD_METHOD(lldb::SBError, SBProcess, Detach, (bool), keep_stopped);
+
   SBError sb_error;
   ProcessSP process_sp(GetSP());
   if (process_sp) {

   } else
     sb_error.SetErrorString("SBProcess is invalid");
 
-  return sb_error;
+  return LLDB_RECORD_RESULT(sb_error);
 }
 
 SBError SBProcess::Signal(int signo) {
+  LLDB_RECORD_METHOD(lldb::SBError, SBProcess, Signal, (int), signo);
+
   SBError sb_error;
   ProcessSP process_sp(GetSP());
   if (process_sp) {

                 static_cast<void *>(process_sp.get()), signo,
                 static_cast<void *>(sb_error.get()), sstr.GetData());
   }
-  return sb_error;
+  return LLDB_RECORD_RESULT(sb_error);
 }
 
 SBUnixSignals SBProcess::GetUnixSignals() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBUnixSignals, SBProcess, GetUnixSignals);
+
   if (auto process_sp = GetSP())
-    return SBUnixSignals{process_sp};
+    return LLDB_RECORD_RESULT(SBUnixSignals{process_sp});
 
-  return {};
+  return LLDB_RECORD_RESULT(SBUnixSignals{});
 }
 
 void SBProcess::SendAsyncInterrupt() {
+  LLDB_RECORD_METHOD_NO_ARGS(void, SBProcess, SendAsyncInterrupt);
+
   ProcessSP process_sp(GetSP());
   if (process_sp) {
     process_sp->SendAsyncInterrupt();

 }
 
 SBThread SBProcess::GetThreadByID(tid_t tid) {
+  LLDB_RECORD_METHOD(lldb::SBThread, SBProcess, GetThreadByID, (lldb::tid_t),
+                     tid);
+
   SBThread sb_thread;
   ThreadSP thread_sp;
   ProcessSP process_sp(GetSP());

                 static_cast<void *>(process_sp.get()), tid,
                 static_cast<void *>(thread_sp.get()));
 
-  return sb_thread;
+  return LLDB_RECORD_RESULT(sb_thread);
 }
 
 SBThread SBProcess::GetThreadByIndexID(uint32_t index_id) {
+  LLDB_RECORD_METHOD(lldb::SBThread, SBProcess, GetThreadByIndexID, (uint32_t),
+                     index_id);
+
   SBThread sb_thread;
   ThreadSP thread_sp;
   ProcessSP process_sp(GetSP());

                 static_cast<void *>(process_sp.get()), index_id,
                 static_cast<void *>(thread_sp.get()));
 
-  return sb_thread;
+  return LLDB_RECORD_RESULT(sb_thread);
 }
 
 StateType SBProcess::GetStateFromEvent(const SBEvent &event) {
+  LLDB_RECORD_STATIC_METHOD(lldb::StateType, SBProcess, GetStateFromEvent,
+                            (const lldb::SBEvent &), event);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   StateType ret_val = Process::ProcessEventData::GetStateFromEvent(event.get());

 }
 
 bool SBProcess::GetRestartedFromEvent(const SBEvent &event) {
+  LLDB_RECORD_STATIC_METHOD(bool, SBProcess, GetRestartedFromEvent,
+                            (const lldb::SBEvent &), event);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   bool ret_val = Process::ProcessEventData::GetRestartedFromEvent(event.get());

 }
 
 size_t SBProcess::GetNumRestartedReasonsFromEvent(const lldb::SBEvent &event) {
+  LLDB_RECORD_STATIC_METHOD(size_t, SBProcess, GetNumRestartedReasonsFromEvent,
+                            (const lldb::SBEvent &), event);
+
   return Process::ProcessEventData::GetNumRestartedReasons(event.get());
 }
 
 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);
+
   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);
+
   ProcessSP process_sp =
       Process::ProcessEventData::GetProcessFromEvent(event.get());
   if (!process_sp) {

     process_sp = EventDataStructuredData::GetProcessFromEvent(event.get());
   }
 
-  return SBProcess(process_sp);
+  return LLDB_RECORD_RESULT(SBProcess(process_sp));
 }
 
 bool SBProcess::GetInterruptedFromEvent(const SBEvent &event) {
+  LLDB_RECORD_STATIC_METHOD(bool, SBProcess, GetInterruptedFromEvent,
+                            (const lldb::SBEvent &), event);
+
   return Process::ProcessEventData::GetInterruptedFromEvent(event.get());
 }
 
 lldb::SBStructuredData
 SBProcess::GetStructuredDataFromEvent(const lldb::SBEvent &event) {
-  return SBStructuredData(event.GetSP());
+  LLDB_RECORD_STATIC_METHOD(lldb::SBStructuredData, SBProcess,
+                            GetStructuredDataFromEvent, (const lldb::SBEvent &),
+                            event);
+
+  return LLDB_RECORD_RESULT(SBStructuredData(event.GetSP()));
 }
 
 bool SBProcess::EventIsProcessEvent(const SBEvent &event) {
+  LLDB_RECORD_STATIC_METHOD(bool, SBProcess, EventIsProcessEvent,
+                            (const lldb::SBEvent &), 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);
+
   EventSP event_sp = event.GetSP();
   EventData *event_data = event_sp ? event_sp->GetData() : nullptr;
   return event_data && (event_data->GetFlavor() ==

 }
 
 SBBroadcaster SBProcess::GetBroadcaster() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBBroadcaster, SBProcess,
+                                   GetBroadcaster);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   ProcessSP process_sp(GetSP());

                 static_cast<void *>(process_sp.get()),
                 static_cast<void *>(broadcaster.get()));
 
-  return broadcaster;
+  return LLDB_RECORD_RESULT(broadcaster);
 }
 
 const char *SBProcess::GetBroadcasterClass() {
+  LLDB_RECORD_STATIC_METHOD_NO_ARGS(const char *, SBProcess,
+                                    GetBroadcasterClass);
+
   return Process::GetStaticBroadcasterClass().AsCString();
 }
 

 
 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);
+
   uint64_t value = 0;
   ProcessSP process_sp(GetSP());
   if (process_sp) {

 
 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::addr_t ptr = LLDB_INVALID_ADDRESS;
   ProcessSP process_sp(GetSP());
   if (process_sp) {

 }
 
 bool SBProcess::GetDescription(SBStream &description) {
+  LLDB_RECORD_METHOD(bool, SBProcess, GetDescription, (lldb::SBStream &),
+                     description);
+
   Stream &strm = description.ref();
 
   ProcessSP process_sp(GetSP());

 
 uint32_t
 SBProcess::GetNumSupportedHardwareWatchpoints(lldb::SBError &sb_error) const {
+  LLDB_RECORD_METHOD_CONST(uint32_t, SBProcess,
+                           GetNumSupportedHardwareWatchpoints,
+                           (lldb::SBError &), sb_error);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   uint32_t num = 0;

 
 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);
+
   return LoadImage(SBFileSpec(), sb_remote_image_spec, sb_error);
 }
 
 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);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   ProcessSP process_sp(GetSP());
   if (process_sp) {

 
 uint32_t SBProcess::LoadImageUsingPaths(const lldb::SBFileSpec &image_spec,
                                         SBStringList &paths,
-                                        lldb::SBFileSpec &loaded_path, 
+                                        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);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   ProcessSP process_sp(GetSP());
   if (process_sp) {

 }
 
 lldb::SBError SBProcess::UnloadImage(uint32_t image_token) {
+  LLDB_RECORD_METHOD(lldb::SBError, SBProcess, UnloadImage, (uint32_t),
+                     image_token);
+
   lldb::SBError sb_error;
   ProcessSP process_sp(GetSP());
   if (process_sp) {

     }
   } else
     sb_error.SetErrorString("invalid process");
-  return sb_error;
+  return LLDB_RECORD_RESULT(sb_error);
 }
 
 lldb::SBError SBProcess::SendEventData(const char *event_data) {
+  LLDB_RECORD_METHOD(lldb::SBError, SBProcess, SendEventData, (const char *),
+                     event_data);
+
   lldb::SBError sb_error;
   ProcessSP process_sp(GetSP());
   if (process_sp) {

     }
   } else
     sb_error.SetErrorString("invalid process");
-  return sb_error;
+  return LLDB_RECORD_RESULT(sb_error);
 }
 
 uint32_t SBProcess::GetNumExtendedBacktraceTypes() {
+  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBProcess, GetNumExtendedBacktraceTypes);
+
   ProcessSP process_sp(GetSP());
   if (process_sp && process_sp->GetSystemRuntime()) {
     SystemRuntime *runtime = process_sp->GetSystemRuntime();

 }
 
 const char *SBProcess::GetExtendedBacktraceTypeAtIndex(uint32_t idx) {
+  LLDB_RECORD_METHOD(const char *, SBProcess, GetExtendedBacktraceTypeAtIndex,
+                     (uint32_t), idx);
+
   ProcessSP process_sp(GetSP());
   if (process_sp && process_sp->GetSystemRuntime()) {
     SystemRuntime *runtime = process_sp->GetSystemRuntime();

 }
 
 SBThreadCollection SBProcess::GetHistoryThreads(addr_t addr) {
+  LLDB_RECORD_METHOD(lldb::SBThreadCollection, SBProcess, GetHistoryThreads,
+                     (lldb::addr_t), addr);
+
   ProcessSP process_sp(GetSP());
   SBThreadCollection threads;
   if (process_sp) {
     threads = SBThreadCollection(process_sp->GetHistoryThreads(addr));
   }
-  return threads;
+  return LLDB_RECORD_RESULT(threads);
 }
 
 bool SBProcess::IsInstrumentationRuntimePresent(
     InstrumentationRuntimeType type) {
+  LLDB_RECORD_METHOD(bool, SBProcess, IsInstrumentationRuntimePresent,
+                     (lldb::InstrumentationRuntimeType), type);
+
   ProcessSP process_sp(GetSP());
   if (!process_sp)
     return false;

 }
 
 lldb::SBError SBProcess::SaveCore(const char *file_name) {
+  LLDB_RECORD_METHOD(lldb::SBError, SBProcess, SaveCore, (const char *),
+                     file_name);
+
   lldb::SBError error;
   ProcessSP process_sp(GetSP());
   if (!process_sp) {
     error.SetErrorString("SBProcess is invalid");
-    return error;
+    return LLDB_RECORD_RESULT(error);
   }
 
   std::lock_guard<std::recursive_mutex> guard(

 
   if (process_sp->GetState() != eStateStopped) {
     error.SetErrorString("the process is not stopped");
-    return error;
+    return LLDB_RECORD_RESULT(error);
   }
 
   FileSpec core_file(file_name);
   error.ref() = PluginManager::SaveCore(process_sp, core_file);
-  return error;
+  return LLDB_RECORD_RESULT(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::SBError sb_error;
   ProcessSP process_sp(GetSP());
   if (process_sp) {

   } else {
     sb_error.SetErrorString("SBProcess is invalid");
   }
-  return sb_error;
+  return LLDB_RECORD_RESULT(sb_error);
 }
 
 lldb::SBMemoryRegionInfoList SBProcess::GetMemoryRegions() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBMemoryRegionInfoList, SBProcess,
+                             GetMemoryRegions);
+
   lldb::SBMemoryRegionInfoList sb_region_list;
 
   ProcessSP process_sp(GetSP());

           static_cast<void *>(process_sp.get()));
   }
 
-  return sb_region_list;
+  return LLDB_RECORD_RESULT(sb_region_list);
 }
 
 lldb::SBProcessInfo SBProcess::GetProcessInfo() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBProcessInfo, SBProcess, GetProcessInfo);
+
   lldb::SBProcessInfo sb_proc_info;
   ProcessSP process_sp(GetSP());
   ProcessInstanceInfo proc_info;
   if (process_sp && process_sp->GetProcessInfo(proc_info)) {
     sb_proc_info.SetProcessInfo(proc_info);
   }
-  return sb_proc_info;
+  return LLDB_RECORD_RESULT(sb_proc_info);
 }

lldb/source/API/SBProcessInfo.cpp

 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBProcessInfo.h"
+#include "SBReproducerPrivate.h"
 
 #include "lldb/API/SBFileSpec.h"
 #include "lldb/Target/Process.h"

 using namespace lldb;
 using namespace lldb_private;
 
-SBProcessInfo::SBProcessInfo() : m_opaque_up() {}
+SBProcessInfo::SBProcessInfo() : m_opaque_up() {
+  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBProcessInfo);
+}
 
 SBProcessInfo::SBProcessInfo(const SBProcessInfo &rhs) : m_opaque_up() {
+  LLDB_RECORD_CONSTRUCTOR(SBProcessInfo, (const lldb::SBProcessInfo &), rhs);
+
   if (rhs.IsValid()) {
     ref() = *rhs.m_opaque_up;
   }

 SBProcessInfo::~SBProcessInfo() {}
 
 SBProcessInfo &SBProcessInfo::operator=(const SBProcessInfo &rhs) {
+  LLDB_RECORD_METHOD(lldb::SBProcessInfo &,
+                     SBProcessInfo, operator=,(const lldb::SBProcessInfo &),
+                     rhs);
+
   if (this != &rhs) {
     if (rhs.IsValid())
       ref() = *rhs.m_opaque_up;

   ref() = proc_info_ref;
 }
 
-bool SBProcessInfo::IsValid() const { return m_opaque_up != nullptr; }
+bool SBProcessInfo::IsValid() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBProcessInfo, IsValid);
+
+  return m_opaque_up != nullptr;
+}
 
 const char *SBProcessInfo::GetName() {
+  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBProcessInfo, GetName);
+
   const char *name = nullptr;
   if (m_opaque_up) {
     name = m_opaque_up->GetName();

 }
 
 SBFileSpec SBProcessInfo::GetExecutableFile() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBFileSpec, SBProcessInfo,
+                             GetExecutableFile);
+
   SBFileSpec file_spec;
   if (m_opaque_up) {
     file_spec.SetFileSpec(m_opaque_up->GetExecutableFile());
   }
-  return file_spec;
+  return LLDB_RECORD_RESULT(file_spec);
 }
 
 lldb::pid_t SBProcessInfo::GetProcessID() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::pid_t, SBProcessInfo, GetProcessID);
+
   lldb::pid_t proc_id = LLDB_INVALID_PROCESS_ID;
   if (m_opaque_up) {
     proc_id = m_opaque_up->GetProcessID();

 }
 
 uint32_t SBProcessInfo::GetUserID() {
+  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBProcessInfo, GetUserID);
+
   uint32_t user_id = UINT32_MAX;
   if (m_opaque_up) {
     user_id = m_opaque_up->GetUserID();

 }
 
 uint32_t SBProcessInfo::GetGroupID() {
+  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBProcessInfo, GetGroupID);
+
   uint32_t group_id = UINT32_MAX;
   if (m_opaque_up) {
     group_id = m_opaque_up->GetGroupID();

 }
 
 bool SBProcessInfo::UserIDIsValid() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBProcessInfo, UserIDIsValid);
+
   bool is_valid = false;
   if (m_opaque_up) {
     is_valid = m_opaque_up->UserIDIsValid();

 }
 
 bool SBProcessInfo::GroupIDIsValid() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBProcessInfo, GroupIDIsValid);
+
   bool is_valid = false;
   if (m_opaque_up) {
     is_valid = m_opaque_up->GroupIDIsValid();

 }
 
 uint32_t SBProcessInfo::GetEffectiveUserID() {
+  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBProcessInfo, GetEffectiveUserID);
+
   uint32_t user_id = UINT32_MAX;
   if (m_opaque_up) {
     user_id = m_opaque_up->GetEffectiveUserID();

 }
 
 uint32_t SBProcessInfo::GetEffectiveGroupID() {
+  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBProcessInfo, GetEffectiveGroupID);
+
   uint32_t group_id = UINT32_MAX;
   if (m_opaque_up) {
     group_id = m_opaque_up->GetEffectiveGroupID();

 }
 
 bool SBProcessInfo::EffectiveUserIDIsValid() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBProcessInfo, EffectiveUserIDIsValid);
+
   bool is_valid = false;
   if (m_opaque_up) {
     is_valid = m_opaque_up->EffectiveUserIDIsValid();

 }
 
 bool SBProcessInfo::EffectiveGroupIDIsValid() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBProcessInfo, EffectiveGroupIDIsValid);
+
   bool is_valid = false;
   if (m_opaque_up) {
     is_valid = m_opaque_up->EffectiveGroupIDIsValid();

 }
 
 lldb::pid_t SBProcessInfo::GetParentProcessID() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::pid_t, SBProcessInfo, GetParentProcessID);
+
   lldb::pid_t proc_id = LLDB_INVALID_PROCESS_ID;
   if (m_opaque_up) {
     proc_id = m_opaque_up->GetParentProcessID();

lldb/source/API/SBQueue.cpp

 
 #include <inttypes.h>
 
+#include "SBReproducerPrivate.h"
 #include "lldb/API/SBQueue.h"
 
 #include "lldb/API/SBProcess.h"

 };
 }
 
-SBQueue::SBQueue() : m_opaque_sp(new QueueImpl()) {}
+SBQueue::SBQueue() : m_opaque_sp(new QueueImpl()) {
+  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBQueue);
+}
 
 SBQueue::SBQueue(const QueueSP &queue_sp)
-    : m_opaque_sp(new QueueImpl(queue_sp)) {}
+    : m_opaque_sp(new QueueImpl(queue_sp)) {
+  LLDB_RECORD_CONSTRUCTOR(SBQueue, (const lldb::QueueSP &), queue_sp);
+}
 
 SBQueue::SBQueue(const SBQueue &rhs) {
+  LLDB_RECORD_CONSTRUCTOR(SBQueue, (const lldb::SBQueue &), rhs);
+
   if (&rhs == this)
     return;
 

 }
 
 const lldb::SBQueue &SBQueue::operator=(const lldb::SBQueue &rhs) {
+  LLDB_RECORD_METHOD(const lldb::SBQueue &,
+                     SBQueue, operator=,(const lldb::SBQueue &), rhs);
+
   m_opaque_sp = rhs.m_opaque_sp;
   return *this;
 }

 SBQueue::~SBQueue() {}
 
 bool SBQueue::IsValid() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBQueue, IsValid);
+
   bool is_valid = m_opaque_sp->IsValid();
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   if (log)

 }
 
 void SBQueue::Clear() {
+  LLDB_RECORD_METHOD_NO_ARGS(void, SBQueue, Clear);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   if (log)
     log->Printf("SBQueue(0x%" PRIx64 ")::Clear()", m_opaque_sp->GetQueueID());

 }
 
 lldb::queue_id_t SBQueue::GetQueueID() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::queue_id_t, SBQueue, GetQueueID);
+
   lldb::queue_id_t qid = m_opaque_sp->GetQueueID();
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   if (log)

 }
 
 uint32_t SBQueue::GetIndexID() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBQueue, GetIndexID);
+
   uint32_t index_id = m_opaque_sp->GetIndexID();
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   if (log)

 }
 
 const char *SBQueue::GetName() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBQueue, GetName);
+
   const char *name = m_opaque_sp->GetName();
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   if (log)

 }
 
 uint32_t SBQueue::GetNumThreads() {
+  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBQueue, GetNumThreads);
+
   uint32_t numthreads = m_opaque_sp->GetNumThreads();
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   if (log)

 }
 
 SBThread SBQueue::GetThreadAtIndex(uint32_t idx) {
+  LLDB_RECORD_METHOD(lldb::SBThread, SBQueue, GetThreadAtIndex, (uint32_t),
+                     idx);
+
   SBThread th = m_opaque_sp->GetThreadAtIndex(idx);
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   if (log)
     log->Printf("SBQueue(0x%" PRIx64 ")::GetThreadAtIndex(%d)",
                 m_opaque_sp->GetQueueID(), idx);
-  return th;
+  return LLDB_RECORD_RESULT(th);
 }
 
 uint32_t SBQueue::GetNumPendingItems() {
+  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBQueue, GetNumPendingItems);
+
   uint32_t pending_items = m_opaque_sp->GetNumPendingItems();
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   if (log)

 }
 
 SBQueueItem SBQueue::GetPendingItemAtIndex(uint32_t idx) {
+  LLDB_RECORD_METHOD(lldb::SBQueueItem, SBQueue, GetPendingItemAtIndex,
+                     (uint32_t), idx);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   if (log)
     log->Printf("SBQueue(0x%" PRIx64 ")::GetPendingItemAtIndex(%d)",
                 m_opaque_sp->GetQueueID(), idx);
-  return m_opaque_sp->GetPendingItemAtIndex(idx);
+  return LLDB_RECORD_RESULT(m_opaque_sp->GetPendingItemAtIndex(idx));
 }
 
 uint32_t SBQueue::GetNumRunningItems() {
+  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBQueue, GetNumRunningItems);
+
   uint32_t running_items = m_opaque_sp->GetNumRunningItems();
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   if (log)

   return running_items;
 }
 
-SBProcess SBQueue::GetProcess() { return m_opaque_sp->GetProcess(); }
+SBProcess SBQueue::GetProcess() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBProcess, SBQueue, GetProcess);
 
-lldb::QueueKind SBQueue::GetKind() { return m_opaque_sp->GetKind(); }
+  return LLDB_RECORD_RESULT(m_opaque_sp->GetProcess());
+}
+
+lldb::QueueKind SBQueue::GetKind() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::QueueKind, SBQueue, GetKind);
+
+  return m_opaque_sp->GetKind();
+}

lldb/source/API/SBQueueItem.cpp

 
 #include "lldb/lldb-forward.h"
 
+#include "SBReproducerPrivate.h"
 #include "lldb/API/SBAddress.h"
 #include "lldb/API/SBQueueItem.h"
 #include "lldb/API/SBThread.h"

 //----------------------------------------------------------------------
 // Constructors
 //----------------------------------------------------------------------
-SBQueueItem::SBQueueItem() : m_queue_item_sp() {}
+SBQueueItem::SBQueueItem() : m_queue_item_sp() {
+  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBQueueItem);
+}
 
 SBQueueItem::SBQueueItem(const QueueItemSP &queue_item_sp)
-    : m_queue_item_sp(queue_item_sp) {}
+    : m_queue_item_sp(queue_item_sp) {
+  LLDB_RECORD_CONSTRUCTOR(SBQueueItem, (const lldb::QueueItemSP &),
+                          queue_item_sp);
+}
 
 //----------------------------------------------------------------------
 // Destructor

 SBQueueItem::~SBQueueItem() { m_queue_item_sp.reset(); }
 
 bool SBQueueItem::IsValid() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBQueueItem, IsValid);
+
   bool is_valid = m_queue_item_sp.get() != NULL;
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   if (log)

 }
 
 void SBQueueItem::Clear() {
+  LLDB_RECORD_METHOD_NO_ARGS(void, SBQueueItem, Clear);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   if (log)
     log->Printf("SBQueueItem(%p)::Clear()",

 }
 
 void SBQueueItem::SetQueueItem(const QueueItemSP &queue_item_sp) {
+  LLDB_RECORD_METHOD(void, SBQueueItem, SetQueueItem,
+                     (const lldb::QueueItemSP &), 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);
+
   QueueItemKind result = eQueueItemKindUnknown;
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   if (m_queue_item_sp) {

 }
 
 void SBQueueItem::SetKind(lldb::QueueItemKind kind) {
+  LLDB_RECORD_METHOD(void, SBQueueItem, SetKind, (lldb::QueueItemKind), kind);
+
   if (m_queue_item_sp) {
     m_queue_item_sp->SetKind(kind);
   }
 }
 
 SBAddress SBQueueItem::GetAddress() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBAddress, SBQueueItem, GetAddress);
+
   SBAddress result;
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   if (m_queue_item_sp) {

                 static_cast<void *>(m_queue_item_sp.get()),
                 static_cast<void *>(result.get()), sstr.GetData());
   }
-  return result;
+  return LLDB_RECORD_RESULT(result);
 }
 
 void SBQueueItem::SetAddress(SBAddress addr) {
+  LLDB_RECORD_METHOD(void, SBQueueItem, SetAddress, (lldb::SBAddress), addr);
+
   if (m_queue_item_sp) {
     m_queue_item_sp->SetAddress(addr.ref());
   }
 }
 
 SBThread SBQueueItem::GetExtendedBacktraceThread(const char *type) {
+  LLDB_RECORD_METHOD(lldb::SBThread, SBQueueItem, GetExtendedBacktraceThread,
+                     (const char *), type);
+
   SBThread result;
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   if (m_queue_item_sp) {

       }
     }
   }
-  return result;
+  return LLDB_RECORD_RESULT(result);
 }

lldb/source/API/SBReproducer.cpp

 
 #include "SBReproducerPrivate.h"
 
+#include "SBReproducerPrivate.h"
 #include "lldb/API/LLDB.h"
 #include "lldb/API/SBAddress.h"
 #include "lldb/API/SBAttachInfo.h"

 using namespace lldb_private;
 using namespace lldb_private::repro;
 
-SBRegistry::SBRegistry() {}
+static void SetInputFileHandleRedirect(SBDebugger *t, FILE *, bool) {
+  repro::Loader *loader = repro::Reproducer::Instance().GetLoader();
+  if (!loader)
+    return;
+
+  FileSpec fs = loader->GetFile<SBInfo>();
+  if (!fs)
+    return;
+
+  FILE *f = FileSystem::Instance().Fopen(fs.GetPath().c_str(), "r");
+  if (f == nullptr)
+    return;
+  t->SetInputFileHandle(f, true);
+}
+
+static void SetFileHandleRedirect(SBDebugger *, FILE *, bool) {
+  // Do nothing.
+}
+
+static bool GetDefaultArchitectureRedirect(char *arch_name,
+                                           size_t arch_name_len) {
+  // The function is writing to its argument. Without the redirect it would
+  // write into the replay buffer.
+  char buffer[arch_name_len];
+  return SBDebugger::GetDefaultArchitecture(buffer, arch_name_len);
+}
+
+SBRegistry::SBRegistry() {
+
+  // Custom implementation.
+  Register(&invoke<void (SBDebugger::*)(
+               FILE *, bool)>::method<&SBDebugger::SetInputFileHandle>::doit,
+           &SetInputFileHandleRedirect);
+  Register(&invoke<void (SBDebugger::*)(
+               FILE *, bool)>::method<&SBDebugger::SetErrorFileHandle>::doit,
+           &SetFileHandleRedirect);
+  Register(&invoke<void (SBDebugger::*)(
+               FILE *, bool)>::method<&SBDebugger::SetOutputFileHandle>::doit,
+           &SetFileHandleRedirect);
+  Register<bool(char *, size_t)>(static_cast<bool (*)(char *, size_t)>(
+                                     &SBDebugger::GetDefaultArchitecture),
+                                 &GetDefaultArchitectureRedirect);
+
+  {
+    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, IsValid, ());
+    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, ());
+  }
+  {
+    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 &));
+  }
+  {
+    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, 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));
+  }
+  {
+    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::break_id_t, SBBreakpoint, GetID, ());
+    LLDB_REGISTER_METHOD_CONST(bool, SBBreakpoint, IsValid, ());
+    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(void, SBBreakpoint, SetScriptCallbackFunction,
+                         (const char *));
+    LLDB_REGISTER_METHOD(lldb::SBError, SBBreakpoint, SetScriptCallbackBody,
+                         (const char *));
+    LLDB_REGISTER_METHOD(bool, SBBreakpoint, AddName, (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, ());
+    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, ());
+  }
+  {
+    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(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(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, ());
+  }
+  {
+    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(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(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));
+  }
+  {} {
+    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(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 &));
+  }
+  {
+    LLDB_REGISTER_CONSTRUCTOR(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,
+                               GetAddToHistory, ());
+    LLDB_REGISTER_METHOD(void, SBCommandInterpreterRunOptions, SetAddToHistory,
+                         (bool));
+    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(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,
+                         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_CONSTRUCTOR(SBCommand, ());
+    LLDB_REGISTER_METHOD(bool, SBCommand, IsValid, ());
+    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(uint32_t, SBCommand, GetFlags, ());
+    LLDB_REGISTER_METHOD(void, SBCommand, SetFlags, (uint32_t));
+  }
+  {
+    LLDB_REGISTER_CONSTRUCTOR(SBCommandReturnObject, ());
+    LLDB_REGISTER_CONSTRUCTOR(SBCommandReturnObject,
+                              (const lldb::SBCommandReturnObject &));
+    LLDB_REGISTER_CONSTRUCTOR(SBCommandReturnObject,
+                              (lldb_private::CommandReturnObject *));
+    LLDB_REGISTER_METHOD(lldb_private::CommandReturnObject *,
+                         SBCommandReturnObject, Release, ());
+    LLDB_REGISTER_METHOD(
+        const lldb::SBCommandReturnObject &,
+        SBCommandReturnObject, operator=,(const lldb::SBCommandReturnObject &));
+    LLDB_REGISTER_METHOD_CONST(bool, SBCommandReturnObject, IsValid, ());
+    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(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,
+                         (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 *));
+  }
+  {
+    LLDB_REGISTER_CONSTRUCTOR(SBCommunication, ());
+    LLDB_REGISTER_CONSTRUCTOR(SBCommunication, (const char *));
+    LLDB_REGISTER_METHOD_CONST(bool, SBCommunication, IsValid, ());
+    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, ());
+  }
+  {
+    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==,(const lldb::SBCompileUnit &));
+    LLDB_REGISTER_METHOD_CONST(
+        bool, SBCompileUnit, operator!=,(const lldb::SBCompileUnit &));
+    LLDB_REGISTER_METHOD(bool, SBCompileUnit, GetDescription,
+                         (lldb::SBStream &));
+  }
+  {
+    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(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));
+  }
+  {
+    LLDB_REGISTER_METHOD(void, SBInputReader, SetIsDone, (bool));
+    LLDB_REGISTER_METHOD_CONST(bool, SBInputReader, IsActive, ());
+    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(void, SBDebugger, Destroy,
+                                (lldb::SBDebugger &));
+    LLDB_REGISTER_STATIC_METHOD(void, SBDebugger, MemoryPressureDetected, ());
+    LLDB_REGISTER_METHOD_CONST(bool, SBDebugger, IsValid, ());
+    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(FILE *, SBDebugger, GetInputFileHandle, ());
+    LLDB_REGISTER_METHOD(FILE *, SBDebugger, GetOutputFileHandle, ());
+    LLDB_REGISTER_METHOD(FILE *, SBDebugger, GetErrorFileHandle, ());
+    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(lldb::SBSourceManager, SBDebugger, GetSourceManager,
+                         ());
+    LLDB_REGISTER_STATIC_METHOD(bool, SBDebugger, SetDefaultArchitecture,
+                                (const char *));
+    LLDB_REGISTER_METHOD(lldb::ScriptLanguage, SBDebugger, GetScriptingLanguage,
+                         (const char *));
+    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::SBTypeFilter, SBDebugger, GetFilterForType,
+                         (lldb::SBTypeNameSpecifier));
+    LLDB_REGISTER_METHOD(lldb::SBTypeSynthetic, SBDebugger, GetSyntheticForType,
+                         (lldb::SBTypeNameSpecifier));
+    LLDB_REGISTER_METHOD(bool, SBDebugger, EnableLog,
+                         (const char *, const char **));
+  }
+  {
+    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(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 &));
+  }
+  {
+    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(bool, SBError, GetDescription, (lldb::SBStream &));
+  }
+  {
+    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_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 &));
+  }
+  {
+    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, ());
+  }
+  {
+    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_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, IsValid, ());
+    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(uint32_t, SBFileSpec, GetPath, (char *, size_t));
+    LLDB_REGISTER_METHOD_CONST(bool, SBFileSpec, GetDescription,
+                               (lldb::SBStream &));
+    LLDB_REGISTER_METHOD(void, SBFileSpec, AppendPathComponent, (const char *));
+  }
+  {
+    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 &));
+  }
+  {
+    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(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, ());
+  }
+  {
+    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(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, ());
+  }
+  {
+    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 *));
+    LLDB_REGISTER_STATIC_METHOD(bool, SBHostOS, ThreadCancel,
+                                (lldb::thread_t, lldb::SBError *));
+    LLDB_REGISTER_STATIC_METHOD(bool, SBHostOS, ThreadDetach,
+                                (lldb::thread_t, lldb::SBError *));
+    LLDB_REGISTER_STATIC_METHOD(
+        bool, SBHostOS, ThreadJoin,
+        (lldb::thread_t, lldb::thread_result_t *, lldb::SBError *));
+  }
+  {
+    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(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(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 *));
+  }
+  {
+    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(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(bool, SBInstructionList, GetDescription,
+                         (lldb::SBStream &));
+    LLDB_REGISTER_METHOD(bool, SBInstructionList,
+                         DumpEmulationForAllInstructions, (const char *));
+  }
+  {
+    LLDB_REGISTER_STATIC_METHOD(lldb::LanguageType, SBLanguageRuntime,
+                                GetLanguageTypeFromString, (const char *));
+    LLDB_REGISTER_STATIC_METHOD(const char *, SBLanguageRuntime,
+                                GetNameForLanguageType, (lldb::LanguageType));
+  }
+  {
+    LLDB_REGISTER_CONSTRUCTOR(SBLaunchInfo, (const char **));
+    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_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(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 &));
+  }
+  {
+    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(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 &));
+  }
+  {
+    LLDB_REGISTER_CONSTRUCTOR(SBMemoryRegionInfo, ());
+    LLDB_REGISTER_CONSTRUCTOR(SBMemoryRegionInfo,
+                              (const lldb::SBMemoryRegionInfo &));
+    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_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, 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 &));
+  }
+  {
+    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(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_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(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 &));
+  }
+  {
+    LLDB_REGISTER_CONSTRUCTOR(SBPlatformConnectOptions, (const char *));
+    LLDB_REGISTER_CONSTRUCTOR(SBPlatformConnectOptions,
+                              (const lldb::SBPlatformConnectOptions &));
+    LLDB_REGISTER_METHOD(
+        void,
+        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 *));
+    LLDB_REGISTER_CONSTRUCTOR(SBPlatformShellCommand, (const char *));
+    LLDB_REGISTER_CONSTRUCTOR(SBPlatformShellCommand,
+                              (const lldb::SBPlatformShellCommand &));
+    LLDB_REGISTER_METHOD(void, SBPlatformShellCommand, Clear, ());
+    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, ());
+    LLDB_REGISTER_CONSTRUCTOR(SBPlatform, ());
+    LLDB_REGISTER_CONSTRUCTOR(SBPlatform, (const char *));
+    LLDB_REGISTER_METHOD_CONST(bool, SBPlatform, IsValid, ());
+    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_CONST(lldb::SBUnixSignals, SBPlatform, GetUnixSignals,
+                               ());
+  }
+  {
+    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(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(size_t, SBProcess, GetSTDOUT, (char *, size_t));
+    LLDB_REGISTER_METHOD_CONST(size_t, SBProcess, GetSTDERR, (char *, size_t));
+    LLDB_REGISTER_METHOD_CONST(size_t, SBProcess, GetAsyncProfileData,
+                               (char *, size_t));
+    LLDB_REGISTER_METHOD(lldb::SBTrace, SBProcess, StartTrace,
+                         (lldb::SBTraceOptions &, lldb::SBError &));
+    LLDB_REGISTER_METHOD_CONST(void, SBProcess, ReportEventState,
+                               (const lldb::SBEvent &, FILE *));
+    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_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_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 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_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(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, ());
+  }
+  {
+    LLDB_REGISTER_CONSTRUCTOR(SBQueueItem, ());
+    LLDB_REGISTER_CONSTRUCTOR(SBQueueItem, (const lldb::QueueItemSP &));
+    LLDB_REGISTER_METHOD_CONST(bool, SBQueueItem, IsValid, ());
+    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 *));
+  }
+  {
+    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 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 &));
+  }
+  {
+    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 &));
+  }
+  {
+    LLDB_REGISTER_CONSTRUCTOR(SBStream, ());
+    LLDB_REGISTER_METHOD_CONST(bool, SBStream, IsValid, ());
+    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, RedirectToFileHandle, (FILE *, bool));
+    LLDB_REGISTER_METHOD(void, SBStream, RedirectToFileDescriptor, (int, bool));
+    LLDB_REGISTER_METHOD(void, SBStream, Clear, ());
+  }
+  {
+    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(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, ());
+  }
+  {
+    LLDB_REGISTER_CONSTRUCTOR(SBStructuredData, ());
+    LLDB_REGISTER_CONSTRUCTOR(SBStructuredData,
+                              (const lldb::SBStructuredData &));
+    LLDB_REGISTER_CONSTRUCTOR(SBStructuredData, (const lldb::EventSP &));
+    LLDB_REGISTER_CONSTRUCTOR(SBStructuredData,
+                              (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_CONST(bool, SBStructuredData, IsValid, ());
+    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_METHOD_CONST(size_t, SBStructuredData, GetStringValue,
+                               (char *, size_t));
+  }
+  {
+    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(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, ());
+  }
+  {
+    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(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 &));
+  }
+  {
+    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(bool, SBSymbolContextList, GetDescription,
+                         (lldb::SBStream &));
+  }
+  {
+    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(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, 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(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(lldb::SBLaunchInfo, SBTarget, GetLaunchInfo, ());
+    LLDB_REGISTER_METHOD(void, SBTarget, SetLaunchInfo,
+                         (const lldb::SBLaunchInfo &));
+  }
+  {
+    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(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(size_t, SBThread, GetStopDescription,
+                         (char *, size_t));
+    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, 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_METHOD(lldb_private::Thread *, SBThread, operator->,());
+    LLDB_REGISTER_METHOD(lldb_private::Thread *, SBThread, get, ());
+  }
+  {
+    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(size_t, SBThreadCollection, GetSize, ());
+    LLDB_REGISTER_METHOD(lldb::SBThread, SBThreadCollection, GetThreadAtIndex,
+                         (size_t));
+  }
+  {
+    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_METHOD(const lldb::SBThreadPlan &,
+                         SBThreadPlan, operator=,(const lldb::SBThreadPlan &));
+    LLDB_REGISTER_METHOD(lldb_private::ThreadPlan *, SBThreadPlan, get, ());
+    LLDB_REGISTER_METHOD_CONST(bool, SBThreadPlan, IsValid, ());
+    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(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(void, SBTrace, StopTrace,
+                         (lldb::SBError &, lldb::tid_t));
+    LLDB_REGISTER_METHOD(void, SBTrace, GetTraceConfig,
+                         (lldb::SBTraceOptions &, lldb::SBError &));
+    LLDB_REGISTER_METHOD(lldb::user_id_t, SBTrace, GetTraceUID, ());
+    LLDB_REGISTER_CONSTRUCTOR(SBTrace, ());
+    LLDB_REGISTER_METHOD(bool, SBTrace, IsValid, ());
+  }
+  {
+    LLDB_REGISTER_CONSTRUCTOR(SBTraceOptions, ());
+    LLDB_REGISTER_METHOD_CONST(lldb::TraceType, SBTraceOptions, getType, ());
+    LLDB_REGISTER_METHOD_CONST(uint64_t, SBTraceOptions, getTraceBufferSize,
+                               ());
+    LLDB_REGISTER_METHOD(lldb::SBStructuredData, SBTraceOptions, getTraceParams,
+                         (lldb::SBError &));
+    LLDB_REGISTER_METHOD_CONST(uint64_t, SBTraceOptions, getMetaDataBufferSize,
+                               ());
+    LLDB_REGISTER_METHOD(void, SBTraceOptions, setTraceParams,
+                         (lldb::SBStructuredData &));
+    LLDB_REGISTER_METHOD(void, SBTraceOptions, setType, (lldb::TraceType));
+    LLDB_REGISTER_METHOD(void, SBTraceOptions, setTraceBufferSize, (uint64_t));
+    LLDB_REGISTER_METHOD(void, SBTraceOptions, setMetaDataBufferSize,
+                         (uint64_t));
+    LLDB_REGISTER_METHOD(bool, SBTraceOptions, IsValid, ());
+    LLDB_REGISTER_METHOD(void, SBTraceOptions, setThreadID, (lldb::tid_t));
+    LLDB_REGISTER_METHOD(lldb::tid_t, SBTraceOptions, getThreadID, ());
+  }
+  {
+    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(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(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::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(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(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 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 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));
+  }
+  {
+    LLDB_REGISTER_CONSTRUCTOR(SBTypeCategory, ());
+    LLDB_REGISTER_CONSTRUCTOR(SBTypeCategory, (const lldb::SBTypeCategory &));
+    LLDB_REGISTER_METHOD_CONST(bool, SBTypeCategory, IsValid, ());
+    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,
+                         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::SBTypeNameSpecifier, SBTypeCategory,
+                         GetTypeNameSpecifierForSyntheticAtIndex, (uint32_t));
+    LLDB_REGISTER_METHOD(lldb::SBTypeFilter, SBTypeCategory, GetFilterForType,
+                         (lldb::SBTypeNameSpecifier));
+    LLDB_REGISTER_METHOD(lldb::SBTypeFormat, SBTypeCategory, GetFormatForType,
+                         (lldb::SBTypeNameSpecifier));
+    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::SBTypeFormat, SBTypeCategory, GetFormatAtIndex,
+                         (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, AddTypeFormat,
+                         (lldb::SBTypeNameSpecifier, lldb::SBTypeFormat));
+    LLDB_REGISTER_METHOD(bool, SBTypeCategory, DeleteTypeFormat,
+                         (lldb::SBTypeNameSpecifier));
+    LLDB_REGISTER_METHOD(bool, SBTypeCategory, AddTypeSummary,
+                         (lldb::SBTypeNameSpecifier, lldb::SBTypeSummary));
+    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, AddTypeSynthetic,
+                         (lldb::SBTypeNameSpecifier, lldb::SBTypeSynthetic));
+    LLDB_REGISTER_METHOD(bool, SBTypeCategory, DeleteTypeSynthetic,
+                         (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 &));
+  }
+  {
+    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 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(
+        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));
+  }
+  {
+    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(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 &));
+  }
+  {
+    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(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 &));
+  }
+  {
+    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 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 &));
+  }
+  {
+    LLDB_REGISTER_CONSTRUCTOR(SBTypeSummaryOptions, ());
+    LLDB_REGISTER_CONSTRUCTOR(SBTypeSummaryOptions,
+                              (const lldb::SBTypeSummaryOptions &));
+    LLDB_REGISTER_METHOD(bool, SBTypeSummaryOptions, IsValid, ());
+    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 *));
+    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(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 &));
+  }
+  {
+    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(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 &));
+  }
+  {
+    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(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));
+  }
+  {
+    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(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(const char *, SBValue, GetTypeValidatorResult, ());
+    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::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, ());
+  }
+  {
+    LLDB_REGISTER_CONSTRUCTOR(SBValueList, ());
+    LLDB_REGISTER_CONSTRUCTOR(SBValueList, (const lldb::SBValueList &));
+    LLDB_REGISTER_METHOD_CONST(bool, SBValueList, IsValid, ());
+    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 *));
+  }
+  {
+    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, 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));
+  }
+  {
+    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(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 &));
+  }
+}
 
 const char *SBReproducer::Capture(const char *path) {
   static std::string error;

lldb/source/API/SBSection.cpp

 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBSection.h"
+#include "SBReproducerPrivate.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/API/SBTarget.h"
 #include "lldb/Core/Module.h"

 using namespace lldb;
 using namespace lldb_private;
 
-SBSection::SBSection() : m_opaque_wp() {}
+SBSection::SBSection() : m_opaque_wp() {
+  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBSection);
+}
 
-SBSection::SBSection(const SBSection &rhs) : m_opaque_wp(rhs.m_opaque_wp) {}
+SBSection::SBSection(const SBSection &rhs) : m_opaque_wp(rhs.m_opaque_wp) {
+  LLDB_RECORD_CONSTRUCTOR(SBSection, (const lldb::SBSection &), rhs);
+}
 
 SBSection::SBSection(const lldb::SectionSP &section_sp)
     : m_opaque_wp() // Don't init with section_sp otherwise this will throw if

 }
 
 const SBSection &SBSection::operator=(const SBSection &rhs) {
+  LLDB_RECORD_METHOD(const lldb::SBSection &,
+                     SBSection, operator=,(const lldb::SBSection &), rhs);
+
   m_opaque_wp = rhs.m_opaque_wp;
   return *this;
 }

 SBSection::~SBSection() {}
 
 bool SBSection::IsValid() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBSection, IsValid);
+
   SectionSP section_sp(GetSP());
   return section_sp && section_sp->GetModule().get() != NULL;
 }
 
 const char *SBSection::GetName() {
+  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBSection, GetName);
+
   SectionSP section_sp(GetSP());
   if (section_sp)
     return section_sp->GetName().GetCString();

 }
 
 lldb::SBSection SBSection::GetParent() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBSection, SBSection, GetParent);
+
   lldb::SBSection sb_section;
   SectionSP section_sp(GetSP());
   if (section_sp) {

     if (parent_section_sp)
       sb_section.SetSP(parent_section_sp);
   }
-  return sb_section;
+  return LLDB_RECORD_RESULT(sb_section);
 }
 
 lldb::SBSection SBSection::FindSubSection(const char *sect_name) {
+  LLDB_RECORD_METHOD(lldb::SBSection, SBSection, FindSubSection, (const char *),
+                     sect_name);
+
   lldb::SBSection sb_section;
   if (sect_name) {
     SectionSP section_sp(GetSP());

           section_sp->GetChildren().FindSectionByName(const_sect_name));
     }
   }
-  return sb_section;
+  return LLDB_RECORD_RESULT(sb_section);
 }
 
 size_t SBSection::GetNumSubSections() {
+  LLDB_RECORD_METHOD_NO_ARGS(size_t, SBSection, GetNumSubSections);
+
   SectionSP section_sp(GetSP());
   if (section_sp)
     return section_sp->GetChildren().GetSize();

 }
 
 lldb::SBSection SBSection::GetSubSectionAtIndex(size_t idx) {
+  LLDB_RECORD_METHOD(lldb::SBSection, SBSection, GetSubSectionAtIndex, (size_t),
+                     idx);
+
   lldb::SBSection sb_section;
   SectionSP section_sp(GetSP());
   if (section_sp)
     sb_section.SetSP(section_sp->GetChildren().GetSectionAtIndex(idx));
-  return sb_section;
+  return LLDB_RECORD_RESULT(sb_section);
 }
 
 lldb::SectionSP SBSection::GetSP() const { return m_opaque_wp.lock(); }

 }
 
 lldb::addr_t SBSection::GetFileAddress() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::addr_t, SBSection, GetFileAddress);
+
   lldb::addr_t file_addr = LLDB_INVALID_ADDRESS;
   SectionSP section_sp(GetSP());
   if (section_sp)

 }
 
 lldb::addr_t SBSection::GetLoadAddress(lldb::SBTarget &sb_target) {
+  LLDB_RECORD_METHOD(lldb::addr_t, SBSection, GetLoadAddress,
+                     (lldb::SBTarget &), sb_target);
+
   TargetSP target_sp(sb_target.GetSP());
   if (target_sp) {
     SectionSP section_sp(GetSP());

 }
 
 lldb::addr_t SBSection::GetByteSize() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::addr_t, SBSection, GetByteSize);
+
   SectionSP section_sp(GetSP());
   if (section_sp)
     return section_sp->GetByteSize();

 }
 
 uint64_t SBSection::GetFileOffset() {
+  LLDB_RECORD_METHOD_NO_ARGS(uint64_t, SBSection, GetFileOffset);
+
   SectionSP section_sp(GetSP());
   if (section_sp) {
     ModuleSP module_sp(section_sp->GetModule());

 }
 
 uint64_t SBSection::GetFileByteSize() {
+  LLDB_RECORD_METHOD_NO_ARGS(uint64_t, SBSection, GetFileByteSize);
+
   SectionSP section_sp(GetSP());
   if (section_sp)
     return section_sp->GetFileSize();
   return 0;
 }
 
-SBData SBSection::GetSectionData() { return GetSectionData(0, UINT64_MAX); }
+SBData SBSection::GetSectionData() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBData, SBSection, GetSectionData);
+
+  return LLDB_RECORD_RESULT(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);
+
   SBData sb_data;
   SectionSP section_sp(GetSP());
   if (section_sp) {

       }
     }
   }
-  return sb_data;
+  return LLDB_RECORD_RESULT(sb_data);
 }
 
 SectionType SBSection::GetSectionType() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SectionType, SBSection, GetSectionType);
+
   SectionSP section_sp(GetSP());
   if (section_sp.get())
     return section_sp->GetType();
   return eSectionTypeInvalid;
 }
 
-uint32_t
-SBSection::GetPermissions() const
-{
-    SectionSP section_sp(GetSP());
-    if (section_sp)
-        return section_sp->GetPermissions();
-    return 0;
+uint32_t SBSection::GetPermissions() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBSection, GetPermissions);
+
 }
 
 uint32_t SBSection::GetTargetByteSize() {
+  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBSection, GetTargetByteSize);
+
   SectionSP section_sp(GetSP());
   if (section_sp.get())
     return section_sp->GetTargetByteSize();

 }
 
 bool SBSection::operator==(const SBSection &rhs) {
+  LLDB_RECORD_METHOD(bool, SBSection, operator==,(const lldb::SBSection &),
+                     rhs);
+
   SectionSP lhs_section_sp(GetSP());
   SectionSP rhs_section_sp(rhs.GetSP());
   if (lhs_section_sp && rhs_section_sp)

 }
 
 bool SBSection::operator!=(const SBSection &rhs) {
+  LLDB_RECORD_METHOD(bool, SBSection, operator!=,(const lldb::SBSection &),
+                     rhs);
+
   SectionSP lhs_section_sp(GetSP());
   SectionSP rhs_section_sp(rhs.GetSP());
   return lhs_section_sp != rhs_section_sp;
 }
 
 bool SBSection::GetDescription(SBStream &description) {
+  LLDB_RECORD_METHOD(bool, SBSection, GetDescription, (lldb::SBStream &),
+                     description);
+
   Stream &strm = description.ref();
 
   SectionSP section_sp(GetSP());

lldb/source/API/SBSourceManager.cpp

 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBSourceManager.h"
+#include "SBReproducerPrivate.h"
 #include "lldb/API/SBDebugger.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/API/SBTarget.h"

 using namespace lldb_private;
 
 SBSourceManager::SBSourceManager(const SBDebugger &debugger) {
+  LLDB_RECORD_CONSTRUCTOR(SBSourceManager, (const lldb::SBDebugger &),
+                          debugger);
+
   m_opaque_up.reset(new SourceManagerImpl(debugger.get_sp()));
 }
 
 SBSourceManager::SBSourceManager(const SBTarget &target) {
+  LLDB_RECORD_CONSTRUCTOR(SBSourceManager, (const lldb::SBTarget &), target);
+
   m_opaque_up.reset(new SourceManagerImpl(target.GetSP()));
 }
 
 SBSourceManager::SBSourceManager(const SBSourceManager &rhs) {
+  LLDB_RECORD_CONSTRUCTOR(SBSourceManager, (const lldb::SBSourceManager &),
+                          rhs);
+
   if (&rhs == this)
     return;
 

 
 const lldb::SBSourceManager &SBSourceManager::
 operator=(const lldb::SBSourceManager &rhs) {
+  LLDB_RECORD_METHOD(const lldb::SBSourceManager &,
+                     SBSourceManager, operator=,(const lldb::SBSourceManager &),
+                     rhs);
+
   m_opaque_up.reset(new SourceManagerImpl(*(rhs.m_opaque_up.get())));
   return *this;
 }

 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,
+                     current_line_cstr, s);
+
   const uint32_t column = 0;
   return DisplaySourceLinesWithLineNumbersAndColumn(
       file.ref(), line, column, context_before, context_after,

     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);
+
   if (m_opaque_up == NULL)
     return 0;
 

lldb/source/API/SBStream.cpp

 
 #include "lldb/API/SBStream.h"
 
+#include "SBReproducerPrivate.h"
 #include "lldb/Core/StreamFile.h"
 #include "lldb/Host/FileSystem.h"
 #include "lldb/Utility/Status.h"

 using namespace lldb;
 using namespace lldb_private;
 
-SBStream::SBStream() : m_opaque_up(new StreamString()), m_is_file(false) {}
+SBStream::SBStream() : m_opaque_up(new StreamString()), m_is_file(false) {
+  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBStream);
+}
 
 SBStream::SBStream(SBStream &&rhs)
     : m_opaque_up(std::move(rhs.m_opaque_up)), m_is_file(rhs.m_is_file) {}
 
 SBStream::~SBStream() {}
 
-bool SBStream::IsValid() const { return (m_opaque_up != NULL); }
+bool SBStream::IsValid() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBStream, IsValid);
+
+  return (m_opaque_up != NULL);
+}
 
 // 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);
+
   if (m_is_file || m_opaque_up == NULL)
     return NULL;
 

 // 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);
+
   if (m_is_file || m_opaque_up == NULL)
     return 0;
 

 }
 
 void SBStream::RedirectToFile(const char *path, bool append) {
+  LLDB_RECORD_METHOD(void, SBStream, RedirectToFile, (const char *, bool), path,
+                     append);
+
   if (path == nullptr)
     return;
 

 }
 
 void SBStream::RedirectToFileHandle(FILE *fh, bool transfer_fh_ownership) {
+  LLDB_RECORD_METHOD(void, SBStream, RedirectToFileHandle, (FILE *, bool), fh,
+                     transfer_fh_ownership);
+
   if (fh == nullptr)
     return;
 

 }
 
 void SBStream::RedirectToFileDescriptor(int fd, bool transfer_fh_ownership) {
+  LLDB_RECORD_METHOD(void, SBStream, RedirectToFileDescriptor, (int, bool), fd,
+                     transfer_fh_ownership);
+
   std::string local_data;
   if (m_opaque_up) {
     // See if we have any locally backed data. If so, copy it so we can then

 }
 
 void SBStream::Clear() {
+  LLDB_RECORD_METHOD_NO_ARGS(void, SBStream, Clear);
+
   if (m_opaque_up) {
     // See if we have any locally backed data. If so, copy it so we can then
     // redirect it to the file so we don't lose the data

lldb/source/API/SBStringList.cpp

 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBStringList.h"
+#include "SBReproducerPrivate.h"
 
 #include "lldb/Utility/StringList.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
-SBStringList::SBStringList() : m_opaque_up() {}
+SBStringList::SBStringList() : m_opaque_up() {
+  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBStringList);
+}
 
 SBStringList::SBStringList(const lldb_private::StringList *lldb_strings_ptr)
     : m_opaque_up() {

 }
 
 SBStringList::SBStringList(const SBStringList &rhs) : m_opaque_up() {
+  LLDB_RECORD_CONSTRUCTOR(SBStringList, (const lldb::SBStringList &), rhs);
+
   if (rhs.IsValid())
     m_opaque_up.reset(new lldb_private::StringList(*rhs));
 }
 
 const SBStringList &SBStringList::operator=(const SBStringList &rhs) {
+  LLDB_RECORD_METHOD(const lldb::SBStringList &,
+                     SBStringList, operator=,(const lldb::SBStringList &), rhs);
+
   if (this != &rhs) {
     if (rhs.IsValid())
       m_opaque_up.reset(new lldb_private::StringList(*rhs));

   return *m_opaque_up;
 }
 
-bool SBStringList::IsValid() const { return (m_opaque_up != NULL); }
+bool SBStringList::IsValid() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBStringList, IsValid);
+
+  return (m_opaque_up != NULL);
+}
 
 void SBStringList::AppendString(const char *str) {
+  LLDB_RECORD_METHOD(void, SBStringList, AppendString, (const char *), str);
+
   if (str != NULL) {
     if (IsValid())
       m_opaque_up->AppendString(str);

 }
 
 void SBStringList::AppendList(const char **strv, int strc) {
+  LLDB_RECORD_METHOD(void, SBStringList, AppendList, (const char **, int), strv,
+                     strc);
+
   if ((strv != NULL) && (strc > 0)) {
     if (IsValid())
       m_opaque_up->AppendList(strv, strc);

 }
 
 void SBStringList::AppendList(const SBStringList &strings) {
+  LLDB_RECORD_METHOD(void, SBStringList, AppendList,
+                     (const lldb::SBStringList &), strings);
+
   if (strings.IsValid()) {
     if (!IsValid())
       m_opaque_up.reset(new lldb_private::StringList());

 }
 
 uint32_t SBStringList::GetSize() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBStringList, GetSize);
+
   if (IsValid()) {
     return m_opaque_up->GetSize();
   }

 }
 
 const char *SBStringList::GetStringAtIndex(size_t idx) {
+  LLDB_RECORD_METHOD(const char *, SBStringList, GetStringAtIndex, (size_t),
+                     idx);
+
   if (IsValid()) {
     return m_opaque_up->GetStringAtIndex(idx);
   }

 }
 
 const char *SBStringList::GetStringAtIndex(size_t idx) const {
+  LLDB_RECORD_METHOD_CONST(const char *, SBStringList, GetStringAtIndex,
+                           (size_t), idx);
+
   if (IsValid()) {
     return m_opaque_up->GetStringAtIndex(idx);
   }

 }
 
 void SBStringList::Clear() {
+  LLDB_RECORD_METHOD_NO_ARGS(void, SBStringList, Clear);
+
   if (IsValid()) {
     m_opaque_up->Clear();
   }

lldb/source/API/SBStructuredData.cpp

 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBStructuredData.h"
+#include "SBReproducerPrivate.h"
 
 #include "lldb/API/SBStream.h"
 #include "lldb/API/SBStringList.h"

 #pragma mark--
 #pragma mark SBStructuredData
 
-SBStructuredData::SBStructuredData() : m_impl_up(new StructuredDataImpl()) {}
+SBStructuredData::SBStructuredData() : m_impl_up(new StructuredDataImpl()) {
+  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBStructuredData);
+}
 
 SBStructuredData::SBStructuredData(const lldb::SBStructuredData &rhs)
-    : m_impl_up(new StructuredDataImpl(*rhs.m_impl_up.get())) {}
+    : m_impl_up(new StructuredDataImpl(*rhs.m_impl_up.get())) {
+  LLDB_RECORD_CONSTRUCTOR(SBStructuredData, (const lldb::SBStructuredData &),
+                          rhs);
+}
 
 SBStructuredData::SBStructuredData(const lldb::EventSP &event_sp)
-    : m_impl_up(new StructuredDataImpl(event_sp)) {}
+    : m_impl_up(new StructuredDataImpl(event_sp)) {
+  LLDB_RECORD_CONSTRUCTOR(SBStructuredData, (const lldb::EventSP &), event_sp);
+}
 
 SBStructuredData::SBStructuredData(lldb_private::StructuredDataImpl *impl)
-    : m_impl_up(impl) {}
+    : m_impl_up(impl) {
+  LLDB_RECORD_CONSTRUCTOR(SBStructuredData,
+                          (lldb_private::StructuredDataImpl *), impl);
+}
 
 SBStructuredData::~SBStructuredData() {}
 
 SBStructuredData &SBStructuredData::
 operator=(const lldb::SBStructuredData &rhs) {
+  LLDB_RECORD_METHOD(
+      lldb::SBStructuredData &,
+      SBStructuredData, operator=,(const lldb::SBStructuredData &), rhs);
+
   *m_impl_up = *rhs.m_impl_up;
   return *this;
 }
 
 lldb::SBError SBStructuredData::SetFromJSON(lldb::SBStream &stream) {
+  LLDB_RECORD_METHOD(lldb::SBError, SBStructuredData, SetFromJSON,
+                     (lldb::SBStream &), stream);
+
   lldb::SBError error;
   std::string json_str(stream.GetData());
 

 
   if (!json_obj || json_obj->GetType() != eStructuredDataTypeDictionary)
     error.SetErrorString("Invalid Syntax");
-  return error;
+  return LLDB_RECORD_RESULT(error);
 }
 
-bool SBStructuredData::IsValid() const { return m_impl_up->IsValid(); }
+bool SBStructuredData::IsValid() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBStructuredData, IsValid);
 
-void SBStructuredData::Clear() { m_impl_up->Clear(); }
+  return m_impl_up->IsValid();
+}
+
+void SBStructuredData::Clear() {
+  LLDB_RECORD_METHOD_NO_ARGS(void, SBStructuredData, Clear);
+
+  m_impl_up->Clear();
+}
 
 SBError SBStructuredData::GetAsJSON(lldb::SBStream &stream) const {
+  LLDB_RECORD_METHOD_CONST(lldb::SBError, SBStructuredData, GetAsJSON,
+                           (lldb::SBStream &), stream);
+
   SBError error;
   error.SetError(m_impl_up->GetAsJSON(stream.ref()));
-  return error;
+  return LLDB_RECORD_RESULT(error);
 }
 
 lldb::SBError SBStructuredData::GetDescription(lldb::SBStream &stream) const {
+  LLDB_RECORD_METHOD_CONST(lldb::SBError, SBStructuredData, GetDescription,
+                           (lldb::SBStream &), stream);
+
   Status error = m_impl_up->GetDescription(stream.ref());
   SBError sb_error;
   sb_error.SetError(error);
-  return sb_error;
+  return LLDB_RECORD_RESULT(sb_error);
 }
 
 StructuredDataType SBStructuredData::GetType() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::StructuredDataType, SBStructuredData,
+                                   GetType);
+
   return (m_impl_up ? m_impl_up->GetType() : eStructuredDataTypeInvalid);
 }
 
 size_t SBStructuredData::GetSize() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(size_t, SBStructuredData, GetSize);
+
   return (m_impl_up ? m_impl_up->GetSize() : 0);
 }
 
 bool SBStructuredData::GetKeys(lldb::SBStringList &keys) const {
+  LLDB_RECORD_METHOD_CONST(bool, SBStructuredData, GetKeys,
+                           (lldb::SBStringList &), keys);
+
   if (!m_impl_up)
     return false;
   

 }
 
 lldb::SBStructuredData SBStructuredData::GetValueForKey(const char *key) const {
+  LLDB_RECORD_METHOD_CONST(lldb::SBStructuredData, SBStructuredData,
+                           GetValueForKey, (const char *), key);
+
   if (!m_impl_up)
-    return SBStructuredData();
+    return LLDB_RECORD_RESULT(SBStructuredData());
 
   SBStructuredData result;
   result.m_impl_up->SetObjectSP(m_impl_up->GetValueForKey(key));
-  return result;
+  return LLDB_RECORD_RESULT(result);
 }
 
 lldb::SBStructuredData SBStructuredData::GetItemAtIndex(size_t idx) const {
+  LLDB_RECORD_METHOD_CONST(lldb::SBStructuredData, SBStructuredData,
+                           GetItemAtIndex, (size_t), idx);
+
   if (!m_impl_up)
-    return SBStructuredData();
+    return LLDB_RECORD_RESULT(SBStructuredData());
 
   SBStructuredData result;
   result.m_impl_up->SetObjectSP(m_impl_up->GetItemAtIndex(idx));
-  return result;
+  return LLDB_RECORD_RESULT(result);
 }
 
 uint64_t SBStructuredData::GetIntegerValue(uint64_t fail_value) const {
+  LLDB_RECORD_METHOD_CONST(uint64_t, SBStructuredData, GetIntegerValue,
+                           (uint64_t), fail_value);
+
   return (m_impl_up ? m_impl_up->GetIntegerValue(fail_value) : fail_value);
 }
 
 double SBStructuredData::GetFloatValue(double fail_value) const {
+  LLDB_RECORD_METHOD_CONST(double, SBStructuredData, GetFloatValue, (double),
+                           fail_value);
+
   return (m_impl_up ? m_impl_up->GetFloatValue(fail_value) : fail_value);
 }
 
 bool SBStructuredData::GetBooleanValue(bool fail_value) const {
+  LLDB_RECORD_METHOD_CONST(bool, SBStructuredData, GetBooleanValue, (bool),
+                           fail_value);
+
   return (m_impl_up ? m_impl_up->GetBooleanValue(fail_value) : fail_value);
 }
 
 size_t SBStructuredData::GetStringValue(char *dst, size_t dst_len) const {
+  LLDB_RECORD_METHOD_CONST(size_t, SBStructuredData, GetStringValue,
+                           (char *, size_t), dst, dst_len);
+
   return (m_impl_up ? m_impl_up->GetStringValue(dst, dst_len) : 0);
 }

lldb/source/API/SBSymbol.cpp

 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBSymbol.h"
+#include "SBReproducerPrivate.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/Core/Disassembler.h"
 #include "lldb/Core/Module.h"

 using namespace lldb;
 using namespace lldb_private;
 
-SBSymbol::SBSymbol() : m_opaque_ptr(NULL) {}
+SBSymbol::SBSymbol() : m_opaque_ptr(NULL) {
+  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBSymbol);
+}
 
 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) {}
+SBSymbol::SBSymbol(const lldb::SBSymbol &rhs) : m_opaque_ptr(rhs.m_opaque_ptr) {
+  LLDB_RECORD_CONSTRUCTOR(SBSymbol, (const lldb::SBSymbol &), rhs);
+}
 
 const SBSymbol &SBSymbol::operator=(const SBSymbol &rhs) {
+  LLDB_RECORD_METHOD(const lldb::SBSymbol &,
+                     SBSymbol, operator=,(const lldb::SBSymbol &), rhs);
+
   m_opaque_ptr = rhs.m_opaque_ptr;
   return *this;
 }

   m_opaque_ptr = lldb_object_ptr;
 }
 
-bool SBSymbol::IsValid() const { return m_opaque_ptr != NULL; }
+bool SBSymbol::IsValid() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBSymbol, IsValid);
+
+  return m_opaque_ptr != NULL;
+}
 
 const char *SBSymbol::GetName() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBSymbol, GetName);
+
   const char *name = NULL;
   if (m_opaque_ptr)
     name = m_opaque_ptr->GetName().AsCString();

 }
 
 const char *SBSymbol::GetDisplayName() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBSymbol, GetDisplayName);
+
   const char *name = NULL;
   if (m_opaque_ptr)
     name = m_opaque_ptr->GetMangled()

 }
 
 const char *SBSymbol::GetMangledName() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBSymbol, GetMangledName);
+
   const char *name = NULL;
   if (m_opaque_ptr)
     name = m_opaque_ptr->GetMangled().GetMangledName().AsCString();

 }
 
 bool SBSymbol::operator==(const SBSymbol &rhs) const {
+  LLDB_RECORD_METHOD_CONST(bool, SBSymbol, operator==,(const lldb::SBSymbol &),
+                           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);
+
   return m_opaque_ptr != rhs.m_opaque_ptr;
 }
 
 bool SBSymbol::GetDescription(SBStream &description) {
+  LLDB_RECORD_METHOD(bool, SBSymbol, GetDescription, (lldb::SBStream &),
+                     description);
+
   Stream &strm = description.ref();
 
   if (m_opaque_ptr) {

 }
 
 SBInstructionList SBSymbol::GetInstructions(SBTarget target) {
-  return GetInstructions(target, NULL);
+  LLDB_RECORD_METHOD(lldb::SBInstructionList, SBSymbol, GetInstructions,
+                     (lldb::SBTarget), target);
+
+  return LLDB_RECORD_RESULT(GetInstructions(target, NULL));
 }
 
 SBInstructionList SBSymbol::GetInstructions(SBTarget target,
                                             const char *flavor_string) {
+  LLDB_RECORD_METHOD(lldb::SBInstructionList, SBSymbol, GetInstructions,
+                     (lldb::SBTarget, const char *), target, flavor_string);
+
   SBInstructionList sb_instructions;
   if (m_opaque_ptr) {
     ExecutionContext exe_ctx;

       }
     }
   }
-  return sb_instructions;
+  return LLDB_RECORD_RESULT(sb_instructions);
 }
 
 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);
+
   SBAddress addr;
   if (m_opaque_ptr && m_opaque_ptr->ValueIsAddress()) {
     addr.SetAddress(&m_opaque_ptr->GetAddressRef());
   }
-  return addr;
+  return LLDB_RECORD_RESULT(addr);
 }
 
 SBAddress SBSymbol::GetEndAddress() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBAddress, SBSymbol, GetEndAddress);
+
   SBAddress addr;
   if (m_opaque_ptr && m_opaque_ptr->ValueIsAddress()) {
     lldb::addr_t range_size = m_opaque_ptr->GetByteSize();

       addr->Slide(m_opaque_ptr->GetByteSize());
     }
   }
-  return addr;
+  return LLDB_RECORD_RESULT(addr);
 }
 
 uint32_t SBSymbol::GetPrologueByteSize() {
+  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBSymbol, GetPrologueByteSize);
+
   if (m_opaque_ptr)
     return m_opaque_ptr->GetPrologueByteSize();
   return 0;
 }
 
 SymbolType SBSymbol::GetType() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SymbolType, SBSymbol, GetType);
+
   if (m_opaque_ptr)
     return m_opaque_ptr->GetType();
   return eSymbolTypeInvalid;
 }
 
 bool SBSymbol::IsExternal() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBSymbol, IsExternal);
+
   if (m_opaque_ptr)
     return m_opaque_ptr->IsExternal();
   return false;
 }
 
 bool SBSymbol::IsSynthetic() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBSymbol, IsSynthetic);
+
   if (m_opaque_ptr)
     return m_opaque_ptr->IsSynthetic();
   return false;

lldb/source/API/SBSymbolContext.cpp

 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBSymbolContext.h"
+#include "SBReproducerPrivate.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Symbol/Function.h"

 using namespace lldb;
 using namespace lldb_private;
 
-SBSymbolContext::SBSymbolContext() : m_opaque_up() {}
+SBSymbolContext::SBSymbolContext() : m_opaque_up() {
+  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBSymbolContext);
+}
 
 SBSymbolContext::SBSymbolContext(const SymbolContext *sc_ptr) : m_opaque_up() {
+  LLDB_RECORD_CONSTRUCTOR(SBSymbolContext,
+                          (const lldb_private::SymbolContext *), sc_ptr);
+
   if (sc_ptr)
     m_opaque_up.reset(new SymbolContext(*sc_ptr));
 }
 
 SBSymbolContext::SBSymbolContext(const SBSymbolContext &rhs) : m_opaque_up() {
+  LLDB_RECORD_CONSTRUCTOR(SBSymbolContext, (const lldb::SBSymbolContext &),
+                          rhs);
+
   if (rhs.IsValid()) {
     if (m_opaque_up)
       *m_opaque_up = *rhs.m_opaque_up;

 SBSymbolContext::~SBSymbolContext() {}
 
 const SBSymbolContext &SBSymbolContext::operator=(const SBSymbolContext &rhs) {
+  LLDB_RECORD_METHOD(const lldb::SBSymbolContext &,
+                     SBSymbolContext, operator=,(const lldb::SBSymbolContext &),
+                     rhs);
+
   if (this != &rhs) {
     if (rhs.IsValid())
       m_opaque_up.reset(new lldb_private::SymbolContext(*rhs.m_opaque_up));

   }
 }
 
-bool SBSymbolContext::IsValid() const { return m_opaque_up != NULL; }
+bool SBSymbolContext::IsValid() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBSymbolContext, IsValid);
+
+  return m_opaque_up != NULL;
+}
 
 SBModule SBSymbolContext::GetModule() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBModule, SBSymbolContext, GetModule);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   SBModule sb_module;

                 static_cast<void *>(module_sp.get()), sstr.GetData());
   }
 
-  return sb_module;
+  return LLDB_RECORD_RESULT(sb_module);
 }
 
 SBCompileUnit SBSymbolContext::GetCompileUnit() {
-  return SBCompileUnit(m_opaque_up ? m_opaque_up->comp_unit : NULL);
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBCompileUnit, SBSymbolContext,
+                             GetCompileUnit);
+
+  return LLDB_RECORD_RESULT(
+      SBCompileUnit(m_opaque_up ? m_opaque_up->comp_unit : NULL));
 }
 
 SBFunction SBSymbolContext::GetFunction() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBFunction, SBSymbolContext, GetFunction);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   Function *function = NULL;

                 static_cast<void *>(m_opaque_up.get()),
                 static_cast<void *>(function));
 
-  return sb_function;
+  return LLDB_RECORD_RESULT(sb_function);
 }
 
 SBBlock SBSymbolContext::GetBlock() {
-  return SBBlock(m_opaque_up ? m_opaque_up->block : NULL);
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBBlock, SBSymbolContext, GetBlock);
+
+  return LLDB_RECORD_RESULT(SBBlock(m_opaque_up ? m_opaque_up->block : NULL));
 }
 
 SBLineEntry SBSymbolContext::GetLineEntry() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBLineEntry, SBSymbolContext, GetLineEntry);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   SBLineEntry sb_line_entry;

                 static_cast<void *>(sb_line_entry.get()));
   }
 
-  return sb_line_entry;
+  return LLDB_RECORD_RESULT(sb_line_entry);
 }
 
 SBSymbol SBSymbolContext::GetSymbol() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBSymbol, SBSymbolContext, GetSymbol);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   Symbol *symbol = NULL;

                 static_cast<void *>(m_opaque_up.get()),
                 static_cast<void *>(symbol));
 
-  return sb_symbol;
+  return LLDB_RECORD_RESULT(sb_symbol);
 }
 
 void SBSymbolContext::SetModule(lldb::SBModule module) {
+  LLDB_RECORD_METHOD(void, SBSymbolContext, SetModule, (lldb::SBModule),
+                     module);
+
   ref().module_sp = module.GetSP();
 }
 
 void SBSymbolContext::SetCompileUnit(lldb::SBCompileUnit compile_unit) {
+  LLDB_RECORD_METHOD(void, SBSymbolContext, SetCompileUnit,
+                     (lldb::SBCompileUnit), compile_unit);
+
   ref().comp_unit = compile_unit.get();
 }
 
 void SBSymbolContext::SetFunction(lldb::SBFunction function) {
+  LLDB_RECORD_METHOD(void, SBSymbolContext, SetFunction, (lldb::SBFunction),
+                     function);
+
   ref().function = function.get();
 }
 
 void SBSymbolContext::SetBlock(lldb::SBBlock block) {
+  LLDB_RECORD_METHOD(void, SBSymbolContext, SetBlock, (lldb::SBBlock), block);
+
   ref().block = block.GetPtr();
 }
 
 void SBSymbolContext::SetLineEntry(lldb::SBLineEntry line_entry) {
+  LLDB_RECORD_METHOD(void, SBSymbolContext, SetLineEntry, (lldb::SBLineEntry),
+                     line_entry);
+
   if (line_entry.IsValid())
     ref().line_entry = line_entry.ref();
   else

 }
 
 void SBSymbolContext::SetSymbol(lldb::SBSymbol symbol) {
+  LLDB_RECORD_METHOD(void, SBSymbolContext, SetSymbol, (lldb::SBSymbol),
+                     symbol);
+
   ref().symbol = symbol.get();
 }
 

 }
 
 bool SBSymbolContext::GetDescription(SBStream &description) {
+  LLDB_RECORD_METHOD(bool, SBSymbolContext, GetDescription, (lldb::SBStream &),
+                     description);
+
   Stream &strm = description.ref();
 
   if (m_opaque_up) {

 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);
+
   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 sb_sc;
+      return LLDB_RECORD_RESULT(sb_sc);
   }
-  return SBSymbolContext();
+  return LLDB_RECORD_RESULT(SBSymbolContext());
 }

lldb/source/API/SBSymbolContextList.cpp

 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBSymbolContextList.h"
+#include "SBReproducerPrivate.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/Symbol/SymbolContext.h"
 

 using namespace lldb_private;
 
 SBSymbolContextList::SBSymbolContextList()
-    : m_opaque_up(new SymbolContextList()) {}
+    : m_opaque_up(new SymbolContextList()) {
+  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBSymbolContextList);
+}
 
 SBSymbolContextList::SBSymbolContextList(const SBSymbolContextList &rhs)
-    : m_opaque_up(new SymbolContextList(*rhs.m_opaque_up)) {}
+    : m_opaque_up(new SymbolContextList(*rhs.m_opaque_up)) {
+  LLDB_RECORD_CONSTRUCTOR(SBSymbolContextList,
+                          (const lldb::SBSymbolContextList &), rhs);
+}
 
 SBSymbolContextList::~SBSymbolContextList() {}
 
 const SBSymbolContextList &SBSymbolContextList::
 operator=(const SBSymbolContextList &rhs) {
+  LLDB_RECORD_METHOD(
+      const lldb::SBSymbolContextList &,
+      SBSymbolContextList, operator=,(const lldb::SBSymbolContextList &), rhs);
+
   if (this != &rhs) {
     *m_opaque_up = *rhs.m_opaque_up;
   }

 }
 
 uint32_t SBSymbolContextList::GetSize() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBSymbolContextList, GetSize);
+
   if (m_opaque_up)
     return m_opaque_up->GetSize();
   return 0;
 }
 
 SBSymbolContext SBSymbolContextList::GetContextAtIndex(uint32_t idx) {
+  LLDB_RECORD_METHOD(lldb::SBSymbolContext, SBSymbolContextList,
+                     GetContextAtIndex, (uint32_t), idx);
+
   SBSymbolContext sb_sc;
   if (m_opaque_up) {
     SymbolContext sc;

       sb_sc.SetSymbolContext(&sc);
     }
   }
-  return sb_sc;
+  return LLDB_RECORD_RESULT(sb_sc);
 }
 
 void SBSymbolContextList::Clear() {
+  LLDB_RECORD_METHOD_NO_ARGS(void, SBSymbolContextList, Clear);
+
   if (m_opaque_up)
     m_opaque_up->Clear();
 }
 
 void SBSymbolContextList::Append(SBSymbolContext &sc) {
+  LLDB_RECORD_METHOD(void, SBSymbolContextList, Append,
+                     (lldb::SBSymbolContext &), 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);
+
   if (sc_list.IsValid() && m_opaque_up.get())
     m_opaque_up->Append(*sc_list);
 }
 
-bool SBSymbolContextList::IsValid() const { return m_opaque_up != NULL; }
+bool SBSymbolContextList::IsValid() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBSymbolContextList, IsValid);
+
+  return m_opaque_up != NULL;
+}
 
 lldb_private::SymbolContextList *SBSymbolContextList::operator->() const {
   return m_opaque_up.get();

 }
 
 bool SBSymbolContextList::GetDescription(lldb::SBStream &description) {
+  LLDB_RECORD_METHOD(bool, SBSymbolContextList, GetDescription,
+                     (lldb::SBStream &), description);
+
   Stream &strm = description.ref();
   if (m_opaque_up)
     m_opaque_up->GetDescription(&strm, lldb::eDescriptionLevelFull, NULL);

lldb/source/API/SBTarget.cpp

 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBTarget.h"
+#include "SBReproducerPrivate.h"
 
 #include "lldb/lldb-public.h"
 

 //----------------------------------------------------------------------
 // SBTarget constructor
 //----------------------------------------------------------------------
-SBTarget::SBTarget() : m_opaque_sp() {}
+SBTarget::SBTarget() : m_opaque_sp() {
+  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTarget);
+}
 
-SBTarget::SBTarget(const SBTarget &rhs) : m_opaque_sp(rhs.m_opaque_sp) {}
+SBTarget::SBTarget(const SBTarget &rhs) : m_opaque_sp(rhs.m_opaque_sp) {
+  LLDB_RECORD_CONSTRUCTOR(SBTarget, (const lldb::SBTarget &), rhs);
+}
 
-SBTarget::SBTarget(const TargetSP &target_sp) : m_opaque_sp(target_sp) {}
+SBTarget::SBTarget(const TargetSP &target_sp) : m_opaque_sp(target_sp) {
+  LLDB_RECORD_CONSTRUCTOR(SBTarget, (const lldb::TargetSP &), target_sp);
+}
 
 const SBTarget &SBTarget::operator=(const SBTarget &rhs) {
+  LLDB_RECORD_METHOD(const lldb::SBTarget &,
+                     SBTarget, operator=,(const lldb::SBTarget &), rhs);
+
   if (this != &rhs)
     m_opaque_sp = rhs.m_opaque_sp;
   return *this;

 SBTarget::~SBTarget() {}
 
 bool SBTarget::EventIsTargetEvent(const SBEvent &event) {
+  LLDB_RECORD_STATIC_METHOD(bool, SBTarget, EventIsTargetEvent,
+                            (const lldb::SBEvent &), event);
+
   return Target::TargetEventData::GetEventDataFromEvent(event.get()) != NULL;
 }
 
 SBTarget SBTarget::GetTargetFromEvent(const SBEvent &event) {
-  return Target::TargetEventData::GetTargetFromEvent(event.get());
+  LLDB_RECORD_STATIC_METHOD(lldb::SBTarget, SBTarget, GetTargetFromEvent,
+                            (const lldb::SBEvent &), event);
+
+  return LLDB_RECORD_RESULT(
+      Target::TargetEventData::GetTargetFromEvent(event.get()));
 }
 
 uint32_t SBTarget::GetNumModulesFromEvent(const SBEvent &event) {
+  LLDB_RECORD_STATIC_METHOD(uint32_t, SBTarget, GetNumModulesFromEvent,
+                            (const lldb::SBEvent &), event);
+
   const ModuleList module_list =
       Target::TargetEventData::GetModuleListFromEvent(event.get());
   return module_list.GetSize();

 
 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);
+
   const ModuleList module_list =
       Target::TargetEventData::GetModuleListFromEvent(event.get());
-  return SBModule(module_list.GetModuleAtIndex(idx));
+  return LLDB_RECORD_RESULT(SBModule(module_list.GetModuleAtIndex(idx)));
 }
 
 const char *SBTarget::GetBroadcasterClassName() {
+  LLDB_RECORD_STATIC_METHOD_NO_ARGS(const char *, SBTarget,
+                                    GetBroadcasterClassName);
+
   return Target::GetStaticBroadcasterClass().AsCString();
 }
 
 bool SBTarget::IsValid() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTarget, IsValid);
+
   return m_opaque_sp.get() != NULL && m_opaque_sp->IsValid();
 }
 
 SBProcess SBTarget::GetProcess() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBProcess, SBTarget, GetProcess);
+
   SBProcess sb_process;
   ProcessSP process_sp;
   TargetSP target_sp(GetSP());

                 static_cast<void *>(target_sp.get()),
                 static_cast<void *>(process_sp.get()));
 
-  return sb_process;
+  return LLDB_RECORD_RESULT(sb_process);
 }
 
 SBPlatform SBTarget::GetPlatform() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBPlatform, SBTarget, GetPlatform);
+
   TargetSP target_sp(GetSP());
   if (!target_sp)
-    return SBPlatform();
+    return LLDB_RECORD_RESULT(SBPlatform());
 
   SBPlatform platform;
   platform.m_opaque_sp = target_sp->GetPlatform();
 
-  return platform;
+  return LLDB_RECORD_RESULT(platform);
 }
 
 SBDebugger SBTarget::GetDebugger() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBDebugger, SBTarget, GetDebugger);
+
   SBDebugger debugger;
   TargetSP target_sp(GetSP());
   if (target_sp)
     debugger.reset(target_sp->GetDebugger().shared_from_this());
-  return debugger;
+  return LLDB_RECORD_RESULT(debugger);
 }
 
 SBStructuredData SBTarget::GetStatistics() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBStructuredData, SBTarget, GetStatistics);
+
   SBStructuredData data;
   TargetSP target_sp(GetSP());
   if (!target_sp)
-    return data;
+    return LLDB_RECORD_RESULT(data);
 
   auto stats_up = llvm::make_unique<StructuredData::Dictionary>();
   int i = 0;

   }
 
   data.m_impl_up->SetObjectSP(std::move(stats_up));
-  return data;
+  return LLDB_RECORD_RESULT(data);
 }
 
 void SBTarget::SetCollectingStats(bool v) {
+  LLDB_RECORD_METHOD(void, SBTarget, SetCollectingStats, (bool), v);
+
   TargetSP target_sp(GetSP());
   if (!target_sp)
     return;

 }
 
 bool SBTarget::GetCollectingStats() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBTarget, GetCollectingStats);
+
   TargetSP target_sp(GetSP());
   if (!target_sp)
     return false;
   return target_sp->GetCollectingStats();
 }
 
-
 SBProcess SBTarget::LoadCore(const char *core_file) {
+  LLDB_RECORD_METHOD(lldb::SBProcess, SBTarget, LoadCore, (const char *),
+                     core_file);
+
   lldb::SBError error; // Ignored
-  return LoadCore(core_file, error);
+  return LLDB_RECORD_RESULT(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);
+
   SBProcess sb_process;
   TargetSP target_sp(GetSP());
   if (target_sp) {

   } else {
     error.SetErrorString("SBTarget is invalid");
   }
-  return sb_process;
+  return LLDB_RECORD_RESULT(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);
+
   char *stdin_path = NULL;
   char *stdout_path = NULL;
   char *stderr_path = NULL;

   bool stop_at_entry = false;
   SBError error;
   SBListener listener = GetDebugger().GetListener();
-  return Launch(listener, argv, envp, stdin_path, stdout_path, stderr_path,
-                working_directory, launch_flags, stop_at_entry, error);
+  return LLDB_RECORD_RESULT(Launch(listener, argv, envp, stdin_path,
+                                   stdout_path, stderr_path, working_directory,
+                                   launch_flags, stop_at_entry, error));
 }
 
 SBError SBTarget::Install() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBTarget, Install);
+
   SBError sb_error;
   TargetSP target_sp(GetSP());
   if (target_sp) {
     std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
     sb_error.ref() = target_sp->Install(NULL);
   }
-  return sb_error;
+  return LLDB_RECORD_RESULT(sb_error);
 }
 
 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);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   SBProcess sb_process;

           error.SetErrorString("process attach is in progress");
         else
           error.SetErrorString("a process is already being debugged");
-        return sb_process;
+        return LLDB_RECORD_RESULT(sb_process);
       }
     }
 

       if (listener.IsValid()) {
         error.SetErrorString("process is connected and already has a listener, "
                              "pass empty listener");
-        return sb_process;
+        return LLDB_RECORD_RESULT(sb_process);
       }
     }
 

                 static_cast<void *>(sb_process.GetSP().get()),
                 error.GetCString());
 
-  return sb_process;
+  return LLDB_RECORD_RESULT(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);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   SBProcess sb_process;

             error.SetErrorString("process attach is in progress");
           else
             error.SetErrorString("a process is already being debugged");
-          return sb_process;
+          return LLDB_RECORD_RESULT(sb_process);
         }
       }
     }

                 static_cast<void *>(target_sp.get()),
                 static_cast<void *>(sb_process.GetSP().get()));
 
-  return sb_process;
+  return LLDB_RECORD_RESULT(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);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   SBProcess sb_process;

                         static_cast<void *>(target_sp.get()),
                         error.GetCString());
           }
-          return sb_process;
+          return LLDB_RECORD_RESULT(sb_process);
         }
       }
     }

                 static_cast<void *>(target_sp.get()),
                 static_cast<void *>(sb_process.GetSP().get()));
 
-  return sb_process;
+  return LLDB_RECORD_RESULT(sb_process);
 }
 
 lldb::SBProcess SBTarget::AttachToProcessWithID(
     SBListener &listener,
     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);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   SBProcess sb_process;

     log->Printf("SBTarget(%p)::%s (...) => SBProcess(%p)",
                 static_cast<void *>(target_sp.get()), __FUNCTION__,
                 static_cast<void *>(sb_process.GetSP().get()));
-  return sb_process;
+  return LLDB_RECORD_RESULT(sb_process);
 }
 
 lldb::SBProcess SBTarget::AttachToProcessWithName(

     const char *name, // basename of process to attach to
     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);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   SBProcess sb_process;

     log->Printf("SBTarget(%p)::%s (...) => SBProcess(%p)",
                 static_cast<void *>(target_sp.get()), __FUNCTION__,
                 static_cast<void *>(sb_process.GetSP().get()));
-  return sb_process;
+  return LLDB_RECORD_RESULT(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);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   SBProcess sb_process;

     log->Printf("SBTarget(%p)::ConnectRemote (...) => SBProcess(%p)",
                 static_cast<void *>(target_sp.get()),
                 static_cast<void *>(process_sp.get()));
-  return sb_process;
+  return LLDB_RECORD_RESULT(sb_process);
 }
 
 SBFileSpec SBTarget::GetExecutable() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBFileSpec, SBTarget, GetExecutable);
 
   SBFileSpec exe_file_spec;
   TargetSP target_sp(GetSP());

                 static_cast<const void *>(exe_file_spec.get()));
   }
 
-  return exe_file_spec;
+  return LLDB_RECORD_RESULT(exe_file_spec);
 }
 
 bool SBTarget::operator==(const SBTarget &rhs) const {
+  LLDB_RECORD_METHOD_CONST(bool, SBTarget, operator==,(const lldb::SBTarget &),
+                           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);
+
   return m_opaque_sp.get() != rhs.m_opaque_sp.get();
 }
 

 }
 
 lldb::SBAddress SBTarget::ResolveLoadAddress(lldb::addr_t vm_addr) {
+  LLDB_RECORD_METHOD(lldb::SBAddress, SBTarget, ResolveLoadAddress,
+                     (lldb::addr_t), vm_addr);
+
   lldb::SBAddress sb_addr;
   Address &addr = sb_addr.ref();
   TargetSP target_sp(GetSP());
   if (target_sp) {
     std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
     if (target_sp->ResolveLoadAddress(vm_addr, addr))
-      return sb_addr;
+      return LLDB_RECORD_RESULT(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 sb_addr;
+  return LLDB_RECORD_RESULT(sb_addr);
 }
 
 lldb::SBAddress SBTarget::ResolveFileAddress(lldb::addr_t file_addr) {
+  LLDB_RECORD_METHOD(lldb::SBAddress, SBTarget, ResolveFileAddress,
+                     (lldb::addr_t), file_addr);
+
   lldb::SBAddress sb_addr;
   Address &addr = sb_addr.ref();
   TargetSP target_sp(GetSP());
   if (target_sp) {
     std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
     if (target_sp->ResolveFileAddress(file_addr, addr))
-      return sb_addr;
+      return LLDB_RECORD_RESULT(sb_addr);
   }
 
   addr.SetRawAddress(file_addr);
-  return sb_addr;
+  return LLDB_RECORD_RESULT(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::SBAddress sb_addr;
   Address &addr = sb_addr.ref();
   TargetSP target_sp(GetSP());
   if (target_sp) {
     std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
     if (target_sp->ResolveLoadAddress(vm_addr, addr))
-      return sb_addr;
+      return LLDB_RECORD_RESULT(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 sb_addr;
+  return LLDB_RECORD_RESULT(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);
+
   SBSymbolContext sc;
   SymbolContextItem scope = static_cast<SymbolContextItem>(resolve_scope);
   if (addr.IsValid()) {

       target_sp->GetImages().ResolveSymbolContextForAddress(addr.ref(), scope,
                                                             sc.ref());
   }
-  return sc;
+  return LLDB_RECORD_RESULT(sc);
 }
 
 size_t SBTarget::ReadMemory(const SBAddress addr, void *buf, size_t size,

 
 SBBreakpoint SBTarget::BreakpointCreateByLocation(const char *file,
                                                   uint32_t line) {
-  return SBBreakpoint(
-      BreakpointCreateByLocation(SBFileSpec(file, false), line));
+  LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByLocation,
+                     (const char *, uint32_t), file, line);
+
+  return LLDB_RECORD_RESULT(
+      SBBreakpoint(BreakpointCreateByLocation(SBFileSpec(file, false), line)));
 }
 
 SBBreakpoint
 SBTarget::BreakpointCreateByLocation(const SBFileSpec &sb_file_spec,
                                      uint32_t line) {
-  return BreakpointCreateByLocation(sb_file_spec, line, 0);
+  LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByLocation,
+                     (const lldb::SBFileSpec &, uint32_t), sb_file_spec, line);
+
+  return LLDB_RECORD_RESULT(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);
+
   SBFileSpecList empty_list;
-  return BreakpointCreateByLocation(sb_file_spec, line, offset, empty_list);
+  return LLDB_RECORD_RESULT(
+      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) {
-  return BreakpointCreateByLocation(sb_file_spec, line, 0, offset,
-                                    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);
+
+  return LLDB_RECORD_RESULT(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);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   SBBreakpoint sb_bp;

                 static_cast<void *>(sb_bp.GetSP().get()), sstr.GetData());
   }
 
-  return sb_bp;
+  return LLDB_RECORD_RESULT(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);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   SBBreakpoint sb_bp;

                 static_cast<void *>(target_sp.get()), symbol_name, module_name,
                 static_cast<void *>(sb_bp.GetSP().get()));
 
-  return sb_bp;
+  return LLDB_RECORD_RESULT(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::FunctionNameType name_type_mask = eFunctionNameTypeAuto;
-  return BreakpointCreateByName(symbol_name, name_type_mask,
-                                eLanguageTypeUnknown, module_list,
-                                comp_unit_list);
+  return LLDB_RECORD_RESULT(
+      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) {
-  return BreakpointCreateByName(symbol_name, name_type_mask,
-                                eLanguageTypeUnknown, module_list,
-                                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);
+
+  return LLDB_RECORD_RESULT(
+      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);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   SBBreakpoint sb_bp;

                 static_cast<void *>(target_sp.get()), symbol_name,
                 name_type_mask, static_cast<void *>(sb_bp.GetSP().get()));
 
-  return sb_bp;
+  return LLDB_RECORD_RESULT(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) {
-  return BreakpointCreateByNames(symbol_names, num_names, name_type_mask,
-                                 eLanguageTypeUnknown, module_list,
-                                 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);
+
+  return LLDB_RECORD_RESULT(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) {
-  return BreakpointCreateByNames(symbol_names, num_names, name_type_mask,
-                                 eLanguageTypeUnknown, 0, module_list,
-                                 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);
+
+  return LLDB_RECORD_RESULT(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);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   SBBreakpoint sb_bp;

                 static_cast<void *>(sb_bp.GetSP().get()));
   }
 
-  return sb_bp;
+  return LLDB_RECORD_RESULT(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);
+
   SBFileSpecList module_spec_list;
   SBFileSpecList comp_unit_list;
   if (module_name && module_name[0]) {
     module_spec_list.Append(FileSpec(module_name));
   }
-  return BreakpointCreateByRegex(symbol_name_regex, eLanguageTypeUnknown,
-                                 module_spec_list, comp_unit_list);
+  return LLDB_RECORD_RESULT(
+      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) {
-  return BreakpointCreateByRegex(symbol_name_regex, eLanguageTypeUnknown,
-                                 module_list, 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);
+
+  return LLDB_RECORD_RESULT(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);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   SBBreakpoint sb_bp;

                 static_cast<void *>(target_sp.get()), symbol_name_regex,
                 static_cast<void *>(sb_bp.GetSP().get()));
 
-  return sb_bp;
+  return LLDB_RECORD_RESULT(sb_bp);
 }
 
 SBBreakpoint SBTarget::BreakpointCreateByAddress(addr_t address) {
+  LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByAddress,
+                     (lldb::addr_t), address);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   SBBreakpoint sb_bp;

                 static_cast<uint64_t>(address),
                 static_cast<void *>(sb_bp.GetSP().get()));
 
-  return sb_bp;
+  return LLDB_RECORD_RESULT(sb_bp);
 }
 
 SBBreakpoint SBTarget::BreakpointCreateBySBAddress(SBAddress &sb_address) {
+  LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateBySBAddress,
+                     (lldb::SBAddress &), sb_address);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   SBBreakpoint sb_bp;

       log->Printf("SBTarget(%p)::BreakpointCreateBySBAddress called with "
                   "invalid address",
                   static_cast<void *>(target_sp.get()));
-    return sb_bp;
+    return LLDB_RECORD_RESULT(sb_bp);
   }
 
   if (target_sp) {

                 static_cast<void *>(sb_bp.GetSP().get()));
   }
 
-  return sb_bp;
+  return LLDB_RECORD_RESULT(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);
+
   SBFileSpecList module_spec_list;
 
   if (module_name && module_name[0]) {

     source_file_list.Append(source_file);
   }
 
-  return BreakpointCreateBySourceRegex(source_regex, module_spec_list,
-                                       source_file_list);
+  return LLDB_RECORD_RESULT(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) {
-  return BreakpointCreateBySourceRegex(source_regex, module_list,
-                                       source_file_list, SBStringList());
+  LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget,
+                     BreakpointCreateBySourceRegex,
+                     (const char *, const lldb::SBFileSpecList &,
+                      const lldb::SBFileSpecList &),
+                     source_regex, module_list, source_file_list);
+
+  return LLDB_RECORD_RESULT(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);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   SBBreakpoint sb_bp;

                 static_cast<void *>(target_sp.get()), source_regex,
                 static_cast<void *>(sb_bp.GetSP().get()));
 
-  return sb_bp;
+  return LLDB_RECORD_RESULT(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);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   SBBreakpoint sb_bp;

                 catch_bp ? "on" : "off", throw_bp ? "on" : "off",
                 static_cast<void *>(sb_bp.GetSP().get()));
 
-  return sb_bp;
+  return LLDB_RECORD_RESULT(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::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);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   SBBreakpoint sb_bp;

                 class_name,
                 static_cast<void *>(sb_bp.GetSP().get()));
 
-  return sb_bp;
+  return LLDB_RECORD_RESULT(sb_bp);
 }
 
-
 uint32_t SBTarget::GetNumBreakpoints() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBTarget, GetNumBreakpoints);
+
   TargetSP target_sp(GetSP());
   if (target_sp) {
     // The breakpoint list is thread safe, no need to lock

 }
 
 SBBreakpoint SBTarget::GetBreakpointAtIndex(uint32_t idx) const {
+  LLDB_RECORD_METHOD_CONST(lldb::SBBreakpoint, SBTarget, GetBreakpointAtIndex,
+                           (uint32_t), idx);
+
   SBBreakpoint sb_breakpoint;
   TargetSP target_sp(GetSP());
   if (target_sp) {
     // The breakpoint list is thread safe, no need to lock
     sb_breakpoint = target_sp->GetBreakpointList().GetBreakpointAtIndex(idx);
   }
-  return sb_breakpoint;
+  return LLDB_RECORD_RESULT(sb_breakpoint);
 }
 
 bool SBTarget::BreakpointDelete(break_id_t bp_id) {
+  LLDB_RECORD_METHOD(bool, SBTarget, BreakpointDelete, (lldb::break_id_t),
+                     bp_id);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   bool result = false;

 }
 
 SBBreakpoint SBTarget::FindBreakpointByID(break_id_t bp_id) {
+  LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, FindBreakpointByID,
+                     (lldb::break_id_t), bp_id);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   SBBreakpoint sb_breakpoint;

         static_cast<void *>(target_sp.get()), static_cast<uint32_t>(bp_id),
         static_cast<void *>(sb_breakpoint.GetSP().get()));
 
-  return sb_breakpoint;
+  return LLDB_RECORD_RESULT(sb_breakpoint);
 }
 
 bool SBTarget::FindBreakpointsByName(const char *name,
                                      SBBreakpointList &bkpts) {
+  LLDB_RECORD_METHOD(bool, SBTarget, FindBreakpointsByName,
+                     (const char *, lldb::SBBreakpointList &), name, bkpts);
+
   TargetSP target_sp(GetSP());
   if (target_sp) {
     std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());

   return true;
 }
 
-void SBTarget::GetBreakpointNames(SBStringList &names)
-{
+void SBTarget::GetBreakpointNames(SBStringList &names) {
+  LLDB_RECORD_METHOD(void, SBTarget, GetBreakpointNames, (lldb::SBStringList &),
+                     names);
+
   names.Clear();
 
   TargetSP target_sp(GetSP());

   }
 }
 
-void SBTarget::DeleteBreakpointName(const char *name)
-{
+void SBTarget::DeleteBreakpointName(const char *name) {
+  LLDB_RECORD_METHOD(void, SBTarget, DeleteBreakpointName, (const char *),
+                     name);
+
   TargetSP target_sp(GetSP());
   if (target_sp) {
     std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());

 }
 
 bool SBTarget::EnableAllBreakpoints() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBTarget, EnableAllBreakpoints);
+
   TargetSP target_sp(GetSP());
   if (target_sp) {
     std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());

 }
 
 bool SBTarget::DisableAllBreakpoints() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBTarget, DisableAllBreakpoints);
+
   TargetSP target_sp(GetSP());
   if (target_sp) {
     std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());

 }
 
 bool SBTarget::DeleteAllBreakpoints() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBTarget, DeleteAllBreakpoints);
+
   TargetSP target_sp(GetSP());
   if (target_sp) {
     std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());

 
 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);
+
   SBStringList empty_name_list;
-  return BreakpointsCreateFromFile(source_file, empty_name_list, new_bps);
+  return LLDB_RECORD_RESULT(
+      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);
+
   SBError sberr;
   TargetSP target_sp(GetSP());
   if (!target_sp) {
     sberr.SetErrorString(
         "BreakpointCreateFromFile called with invalid target.");
-    return sberr;
+    return LLDB_RECORD_RESULT(sberr);
   }
   std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
 

   sberr.ref() = target_sp->CreateBreakpointsFromFile(source_file.ref(),
                                                      name_vector, bp_ids);
   if (sberr.Fail())
-    return sberr;
+    return LLDB_RECORD_RESULT(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 sberr;
+  return LLDB_RECORD_RESULT(sberr);
 }
 
 lldb::SBError SBTarget::BreakpointsWriteToFile(SBFileSpec &dest_file) {
+  LLDB_RECORD_METHOD(lldb::SBError, SBTarget, BreakpointsWriteToFile,
+                     (lldb::SBFileSpec &), dest_file);
+
   SBError sberr;
   TargetSP target_sp(GetSP());
   if (!target_sp) {
     sberr.SetErrorString("BreakpointWriteToFile called with invalid target.");
-    return sberr;
+    return LLDB_RECORD_RESULT(sberr);
   }
   SBBreakpointList bkpt_list(*this);
-  return BreakpointsWriteToFile(dest_file, bkpt_list);
+  return LLDB_RECORD_RESULT(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);
+
   SBError sberr;
   TargetSP target_sp(GetSP());
   if (!target_sp) {
     sberr.SetErrorString("BreakpointWriteToFile called with invalid target.");
-    return sberr;
+    return LLDB_RECORD_RESULT(sberr);
   }
 
   std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());

   bkpt_list.CopyToBreakpointIDList(bp_id_list);
   sberr.ref() = target_sp->SerializeBreakpointsToFile(dest_file.ref(),
                                                       bp_id_list, append);
-  return sberr;
+  return LLDB_RECORD_RESULT(sberr);
 }
 
 uint32_t SBTarget::GetNumWatchpoints() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBTarget, GetNumWatchpoints);
+
   TargetSP target_sp(GetSP());
   if (target_sp) {
     // The watchpoint list is thread safe, no need to lock

 }
 
 SBWatchpoint SBTarget::GetWatchpointAtIndex(uint32_t idx) const {
+  LLDB_RECORD_METHOD_CONST(lldb::SBWatchpoint, SBTarget, GetWatchpointAtIndex,
+                           (uint32_t), idx);
+
   SBWatchpoint sb_watchpoint;
   TargetSP target_sp(GetSP());
   if (target_sp) {
     // The watchpoint list is thread safe, no need to lock
     sb_watchpoint.SetSP(target_sp->GetWatchpointList().GetByIndex(idx));
   }
-  return sb_watchpoint;
+  return LLDB_RECORD_RESULT(sb_watchpoint);
 }
 
 bool SBTarget::DeleteWatchpoint(watch_id_t wp_id) {
+  LLDB_RECORD_METHOD(bool, SBTarget, DeleteWatchpoint, (lldb::watch_id_t),
+                     wp_id);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   bool result = false;

 }
 
 SBWatchpoint SBTarget::FindWatchpointByID(lldb::watch_id_t wp_id) {
+  LLDB_RECORD_METHOD(lldb::SBWatchpoint, SBTarget, FindWatchpointByID,
+                     (lldb::watch_id_t), wp_id);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   SBWatchpoint sb_watchpoint;

         static_cast<void *>(target_sp.get()), static_cast<uint32_t>(wp_id),
         static_cast<void *>(watchpoint_sp.get()));
 
-  return sb_watchpoint;
+  return LLDB_RECORD_RESULT(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);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   SBWatchpoint sb_watchpoint;

     if (watch_type == 0) {
       error.SetErrorString(
           "Can't create a watchpoint that is neither read nor write.");
-      return sb_watchpoint;
+      return LLDB_RECORD_RESULT(sb_watchpoint);
     }
 
     // Target::CreateWatchpoint() is thread safe.

                 static_cast<uint32_t>(size),
                 static_cast<void *>(watchpoint_sp.get()));
 
-  return sb_watchpoint;
+  return LLDB_RECORD_RESULT(sb_watchpoint);
 }
 
 bool SBTarget::EnableAllWatchpoints() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBTarget, EnableAllWatchpoints);
+
   TargetSP target_sp(GetSP());
   if (target_sp) {
     std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());

 }
 
 bool SBTarget::DisableAllWatchpoints() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBTarget, DisableAllWatchpoints);
+
   TargetSP target_sp(GetSP());
   if (target_sp) {
     std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());

 
 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);
+
   SBValue sb_value;
   lldb::ValueObjectSP new_value_sp;
   if (IsValid() && name && *name && addr.IsValid() && type.IsValid()) {

       log->Printf("SBTarget(%p)::CreateValueFromAddress => NULL",
                   static_cast<void *>(m_opaque_sp.get()));
   }
-  return sb_value;
+  return LLDB_RECORD_RESULT(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);
+
   SBValue sb_value;
   lldb::ValueObjectSP new_value_sp;
   if (IsValid() && name && *name && data.IsValid() && type.IsValid()) {

       log->Printf("SBTarget(%p)::CreateValueFromData => NULL",
                   static_cast<void *>(m_opaque_sp.get()));
   }
-  return sb_value;
+  return LLDB_RECORD_RESULT(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);
+
   SBValue sb_value;
   lldb::ValueObjectSP new_value_sp;
   if (IsValid() && name && *name && expr && *expr) {

       log->Printf("SBTarget(%p)::CreateValueFromExpression => NULL",
                   static_cast<void *>(m_opaque_sp.get()));
   }
-  return sb_value;
+  return LLDB_RECORD_RESULT(sb_value);
 }
 
 bool SBTarget::DeleteAllWatchpoints() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBTarget, DeleteAllWatchpoints);
+
   TargetSP target_sp(GetSP());
   if (target_sp) {
     std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());

 
 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);
+
   TargetSP target_sp(GetSP());
   if (!target_sp)
     return error.SetErrorString("invalid target");

 
 lldb::SBModule SBTarget::AddModule(const char *path, const char *triple,
                                    const char *uuid_cstr) {
-  return AddModule(path, triple, uuid_cstr, NULL);
+  LLDB_RECORD_METHOD(lldb::SBModule, SBTarget, AddModule,
+                     (const char *, const char *, const char *), path, triple,
+                     uuid_cstr);
+
+  return LLDB_RECORD_RESULT(AddModule(path, triple, uuid_cstr, NULL));
 }
 
 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::SBModule sb_module;
   TargetSP target_sp(GetSP());
   if (target_sp) {

 
     sb_module.SetSP(target_sp->GetSharedModule(module_spec));
   }
-  return sb_module;
+  return LLDB_RECORD_RESULT(sb_module);
 }
 
 lldb::SBModule SBTarget::AddModule(const SBModuleSpec &module_spec) {
+  LLDB_RECORD_METHOD(lldb::SBModule, SBTarget, AddModule,
+                     (const lldb::SBModuleSpec &), module_spec);
+
   lldb::SBModule sb_module;
   TargetSP target_sp(GetSP());
   if (target_sp)
     sb_module.SetSP(target_sp->GetSharedModule(*module_spec.m_opaque_up));
-  return sb_module;
+  return LLDB_RECORD_RESULT(sb_module);
 }
 
 bool SBTarget::AddModule(lldb::SBModule &module) {
+  LLDB_RECORD_METHOD(bool, SBTarget, AddModule, (lldb::SBModule &), module);
+
   TargetSP target_sp(GetSP());
   if (target_sp) {
     target_sp->GetImages().AppendIfNeeded(module.GetSP());

 }
 
 uint32_t SBTarget::GetNumModules() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBTarget, GetNumModules);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   uint32_t num = 0;

 }
 
 void SBTarget::Clear() {
+  LLDB_RECORD_METHOD_NO_ARGS(void, SBTarget, Clear);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   if (log)

 }
 
 SBModule SBTarget::FindModule(const SBFileSpec &sb_file_spec) {
+  LLDB_RECORD_METHOD(lldb::SBModule, SBTarget, FindModule,
+                     (const lldb::SBFileSpec &), sb_file_spec);
+
   SBModule sb_module;
   TargetSP target_sp(GetSP());
   if (target_sp && sb_file_spec.IsValid()) {

     // The module list is thread safe, no need to lock
     sb_module.SetSP(target_sp->GetImages().FindFirstModule(module_spec));
   }
-  return sb_module;
+  return LLDB_RECORD_RESULT(sb_module);
 }
 
-SBSymbolContextList
-SBTarget::FindCompileUnits(const SBFileSpec &sb_file_spec) {
+SBSymbolContextList SBTarget::FindCompileUnits(const SBFileSpec &sb_file_spec) {
+  LLDB_RECORD_METHOD(lldb::SBSymbolContextList, SBTarget, FindCompileUnits,
+                     (const lldb::SBFileSpec &), 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,
                                             append, *sb_sc_list);
   }
-  return sb_sc_list;
+  return LLDB_RECORD_RESULT(sb_sc_list);
 }
 
 lldb::ByteOrder SBTarget::GetByteOrder() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::ByteOrder, SBTarget, GetByteOrder);
+
   TargetSP target_sp(GetSP());
   if (target_sp)
     return target_sp->GetArchitecture().GetByteOrder();

 }
 
 const char *SBTarget::GetTriple() {
+  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTarget, GetTriple);
+
   TargetSP target_sp(GetSP());
   if (target_sp) {
     std::string triple(target_sp->GetArchitecture().GetTriple().str());

 }
 
 uint32_t SBTarget::GetDataByteSize() {
+  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTarget, GetDataByteSize);
+
   TargetSP target_sp(GetSP());
   if (target_sp) {
     return target_sp->GetArchitecture().GetDataByteSize();

 }
 
 uint32_t SBTarget::GetCodeByteSize() {
+  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTarget, GetCodeByteSize);
+
   TargetSP target_sp(GetSP());
   if (target_sp) {
     return target_sp->GetArchitecture().GetCodeByteSize();

 }
 
 uint32_t SBTarget::GetAddressByteSize() {
+  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTarget, GetAddressByteSize);
+
   TargetSP target_sp(GetSP());
   if (target_sp)
     return target_sp->GetArchitecture().GetAddressByteSize();

 }
 
 SBModule SBTarget::GetModuleAtIndex(uint32_t idx) {
+  LLDB_RECORD_METHOD(lldb::SBModule, SBTarget, GetModuleAtIndex, (uint32_t),
+                     idx);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   SBModule sb_module;

                 static_cast<void *>(target_sp.get()), idx,
                 static_cast<void *>(module_sp.get()));
 
-  return sb_module;
+  return LLDB_RECORD_RESULT(sb_module);
 }
 
 bool SBTarget::RemoveModule(lldb::SBModule module) {
+  LLDB_RECORD_METHOD(bool, SBTarget, RemoveModule, (lldb::SBModule), module);
+
   TargetSP target_sp(GetSP());
   if (target_sp)
     return target_sp->GetImages().Remove(module.GetSP());

 }
 
 SBBroadcaster SBTarget::GetBroadcaster() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBBroadcaster, SBTarget,
+                                   GetBroadcaster);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   TargetSP target_sp(GetSP());

                 static_cast<void *>(target_sp.get()),
                 static_cast<void *>(broadcaster.get()));
 
-  return broadcaster;
+  return LLDB_RECORD_RESULT(broadcaster);
 }
 
 bool SBTarget::GetDescription(SBStream &description,
                               lldb::DescriptionLevel description_level) {
+  LLDB_RECORD_METHOD(bool, SBTarget, GetDescription,
+                     (lldb::SBStream &, lldb::DescriptionLevel), description,
+                     description_level);
+
   Stream &strm = description.ref();
 
   TargetSP target_sp(GetSP());

 
 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::SBSymbolContextList sb_sc_list;
   if (!name | !name[0])
-    return sb_sc_list;
+    return LLDB_RECORD_RESULT(sb_sc_list);
 
   TargetSP target_sp(GetSP());
   if (!target_sp)
-    return sb_sc_list;
+    return LLDB_RECORD_RESULT(sb_sc_list);
 
   const bool symbols_ok = true;
   const bool inlines_ok = true;

   FunctionNameType mask = static_cast<FunctionNameType>(name_type_mask);
   target_sp->GetImages().FindFunctions(ConstString(name), mask, symbols_ok,
                                        inlines_ok, append, *sb_sc_list);
-  return sb_sc_list;
+  return LLDB_RECORD_RESULT(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::SBSymbolContextList sb_sc_list;
   if (name && name[0]) {
     llvm::StringRef name_ref(name);

       }
     }
   }
-  return sb_sc_list;
+  return LLDB_RECORD_RESULT(sb_sc_list);
 }
 
 lldb::SBType SBTarget::FindFirstType(const char *typename_cstr) {
+  LLDB_RECORD_METHOD(lldb::SBType, SBTarget, FindFirstType, (const char *),
+                     typename_cstr);
+
   TargetSP target_sp(GetSP());
   if (typename_cstr && typename_cstr[0] && target_sp) {
     ConstString const_typename(typename_cstr);

         TypeSP type_sp(
             module_sp->FindFirstType(sc, const_typename, exact_match));
         if (type_sp)
-          return SBType(type_sp);
+          return LLDB_RECORD_RESULT(SBType(type_sp));
       }
     }
 

 
           if (objc_decl_vendor->FindDecls(const_typename, true, 1, decls) > 0) {
             if (CompilerType type = ClangASTContext::GetTypeForDecl(decls[0])) {
-              return SBType(type);
+              return LLDB_RECORD_RESULT(SBType(type));
             }
           }
         }

     // No matches, search for basic typename matches
     ClangASTContext *clang_ast = target_sp->GetScratchClangASTContext();
     if (clang_ast)
-      return SBType(ClangASTContext::GetBasicType(clang_ast->getASTContext(),
-                                                  const_typename));
+      return LLDB_RECORD_RESULT(SBType(ClangASTContext::GetBasicType(
+          clang_ast->getASTContext(), const_typename)));
   }
-  return SBType();
+  return LLDB_RECORD_RESULT(SBType());
 }
 
 SBType SBTarget::GetBasicType(lldb::BasicType type) {
+  LLDB_RECORD_METHOD(lldb::SBType, SBTarget, GetBasicType, (lldb::BasicType),
+                     type);
+
   TargetSP target_sp(GetSP());
   if (target_sp) {
     ClangASTContext *clang_ast = target_sp->GetScratchClangASTContext();
     if (clang_ast)
-      return SBType(
-          ClangASTContext::GetBasicType(clang_ast->getASTContext(), type));
+      return LLDB_RECORD_RESULT(SBType(
+          ClangASTContext::GetBasicType(clang_ast->getASTContext(), type)));
   }
-  return SBType();
+  return LLDB_RECORD_RESULT(SBType());
 }
 
 lldb::SBTypeList SBTarget::FindTypes(const char *typename_cstr) {
+  LLDB_RECORD_METHOD(lldb::SBTypeList, SBTarget, FindTypes, (const char *),
+                     typename_cstr);
+
   SBTypeList sb_type_list;
   TargetSP target_sp(GetSP());
   if (typename_cstr && typename_cstr[0] && target_sp) {

             clang_ast->getASTContext(), const_typename)));
     }
   }
-  return sb_type_list;
+  return LLDB_RECORD_RESULT(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);
+
   SBValueList sb_value_list;
 
   TargetSP target_sp(GetSP());

     }
   }
 
-  return sb_value_list;
+  return LLDB_RECORD_RESULT(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);
+
   SBValueList sb_value_list;
 
   TargetSP target_sp(GetSP());

     }
   }
 
-  return sb_value_list;
+  return LLDB_RECORD_RESULT(sb_value_list);
 }
 
 lldb::SBValue SBTarget::FindFirstGlobalVariable(const char *name) {
+  LLDB_RECORD_METHOD(lldb::SBValue, SBTarget, FindFirstGlobalVariable,
+                     (const char *), name);
+
   SBValueList sb_value_list(FindGlobalVariables(name, 1));
   if (sb_value_list.IsValid() && sb_value_list.GetSize() > 0)
-    return sb_value_list.GetValueAtIndex(0);
-  return SBValue();
+    return LLDB_RECORD_RESULT(sb_value_list.GetValueAtIndex(0));
+  return LLDB_RECORD_RESULT(SBValue());
 }
 
 SBSourceManager SBTarget::GetSourceManager() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBSourceManager, SBTarget, GetSourceManager);
+
   SBSourceManager source_manager(*this);
-  return source_manager;
+  return LLDB_RECORD_RESULT(source_manager);
 }
 
 lldb::SBInstructionList SBTarget::ReadInstructions(lldb::SBAddress base_addr,
                                                    uint32_t count) {
-  return ReadInstructions(base_addr, count, NULL);
+  LLDB_RECORD_METHOD(lldb::SBInstructionList, SBTarget, ReadInstructions,
+                     (lldb::SBAddress, uint32_t), base_addr, count);
+
+  return LLDB_RECORD_RESULT(ReadInstructions(base_addr, count, NULL));
 }
 
 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);
+
   SBInstructionList sb_instructions;
 
   TargetSP target_sp(GetSP());

     }
   }
 
-  return sb_instructions;
+  return LLDB_RECORD_RESULT(sb_instructions);
 }
 
 lldb::SBInstructionList SBTarget::GetInstructions(lldb::SBAddress base_addr,

 
 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);
+
   SBError sb_error;
   TargetSP target_sp(GetSP());
   if (target_sp) {

   } else {
     sb_error.SetErrorString("invalid target");
   }
-  return sb_error;
+  return LLDB_RECORD_RESULT(sb_error);
 }
 
 SBError SBTarget::ClearSectionLoadAddress(lldb::SBSection section) {
+  LLDB_RECORD_METHOD(lldb::SBError, SBTarget, ClearSectionLoadAddress,
+                     (lldb::SBSection), section);
+
   SBError sb_error;
 
   TargetSP target_sp(GetSP());

   } else {
     sb_error.SetErrorStringWithFormat("invalid target");
   }
-  return sb_error;
+  return LLDB_RECORD_RESULT(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);
+
   SBError sb_error;
 
   TargetSP target_sp(GetSP());

   } else {
     sb_error.SetErrorStringWithFormat("invalid target");
   }
-  return sb_error;
+  return LLDB_RECORD_RESULT(sb_error);
 }
 
 SBError SBTarget::ClearModuleLoadAddress(lldb::SBModule module) {
+  LLDB_RECORD_METHOD(lldb::SBError, SBTarget, ClearModuleLoadAddress,
+                     (lldb::SBModule), module);
+
   SBError sb_error;
 
   char path[PATH_MAX];

   } else {
     sb_error.SetErrorStringWithFormat("invalid target");
   }
-  return sb_error;
+  return LLDB_RECORD_RESULT(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);
+
   SBSymbolContextList sb_sc_list;
   if (name && name[0]) {
     TargetSP target_sp(GetSP());

           ConstString(name), symbol_type, *sb_sc_list, append);
     }
   }
-  return sb_sc_list;
+  return LLDB_RECORD_RESULT(sb_sc_list);
 }
 
 lldb::SBValue SBTarget::EvaluateExpression(const char *expr) {
+  LLDB_RECORD_METHOD(lldb::SBValue, SBTarget, EvaluateExpression,
+                     (const char *), expr);
+
   TargetSP target_sp(GetSP());
   if (!target_sp)
-    return SBValue();
+    return LLDB_RECORD_RESULT(SBValue());
 
   SBExpressionOptions options;
   lldb::DynamicValueType fetch_dynamic_value =
       target_sp->GetPreferDynamicValue();
   options.SetFetchDynamicValue(fetch_dynamic_value);
   options.SetUnwindOnError(true);
-  return EvaluateExpression(expr, options);
+  return LLDB_RECORD_RESULT(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);
+
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 #if !defined(LLDB_DISABLE_PYTHON)
   Log *expr_log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));

       if (log)
         log->Printf(
             "SBTarget::EvaluateExpression called with an empty expression");
-      return expr_result;
+      return LLDB_RECORD_RESULT(expr_result);
     }
 
     std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());

                 static_cast<void *>(expr_value_sp.get()), exe_results);
 #endif
 
-  return expr_result;
+  return LLDB_RECORD_RESULT(expr_result);
 }
 
 lldb::addr_t SBTarget::GetStackRedZoneSize() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::addr_t, SBTarget, GetStackRedZoneSize);
+
   TargetSP target_sp(GetSP());
   if (target_sp) {
     ABISP abi_sp;

 }
 
 lldb::SBLaunchInfo SBTarget::GetLaunchInfo() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBLaunchInfo, SBTarget, GetLaunchInfo);
+
   lldb::SBLaunchInfo launch_info(NULL);
   TargetSP target_sp(GetSP());
   if (target_sp)
     launch_info.set_ref(m_opaque_sp->GetProcessLaunchInfo());
-  return launch_info;
+  return LLDB_RECORD_RESULT(launch_info);
 }
 
 void SBTarget::SetLaunchInfo(const lldb::SBLaunchInfo &launch_info) {
+  LLDB_RECORD_METHOD(void, SBTarget, SetLaunchInfo,
+                     (const lldb::SBLaunchInfo &), launch_info);
+
   TargetSP target_sp(GetSP());
   if (target_sp)
     m_opaque_sp->SetProcessLaunchInfo(launch_info.ref());

lldb/source/API/SBThread.cpp

 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBThread.h"
+#include "SBReproducerPrivate.h"
 
 #include "lldb/API/SBFileSpec.h"
 #include "lldb/API/SBStream.h"

 using namespace lldb_private;
 
 const char *SBThread::GetBroadcasterClassName() {
+  LLDB_RECORD_STATIC_METHOD_NO_ARGS(const char *, SBThread,
+                                    GetBroadcasterClassName);
+
   return Thread::GetStaticBroadcasterClass().AsCString();
 }
 
 //----------------------------------------------------------------------
 // Constructors
 //----------------------------------------------------------------------
-SBThread::SBThread() : m_opaque_sp(new ExecutionContextRef()) {}
+SBThread::SBThread() : m_opaque_sp(new ExecutionContextRef()) {
+  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBThread);
+}
 
 SBThread::SBThread(const ThreadSP &lldb_object_sp)
-    : m_opaque_sp(new ExecutionContextRef(lldb_object_sp)) {}
+    : m_opaque_sp(new ExecutionContextRef(lldb_object_sp)) {
+  LLDB_RECORD_CONSTRUCTOR(SBThread, (const lldb::ThreadSP &), lldb_object_sp);
+}
 
 SBThread::SBThread(const SBThread &rhs)
-    : m_opaque_sp(new ExecutionContextRef(*rhs.m_opaque_sp)) {}
+    : m_opaque_sp(new ExecutionContextRef(*rhs.m_opaque_sp)) {
+  LLDB_RECORD_CONSTRUCTOR(SBThread, (const lldb::SBThread &), rhs);
+}
 
 //----------------------------------------------------------------------
 // Assignment operator
 //----------------------------------------------------------------------
 
 const lldb::SBThread &SBThread::operator=(const SBThread &rhs) {
+  LLDB_RECORD_METHOD(const lldb::SBThread &,
+                     SBThread, operator=,(const lldb::SBThread &), rhs);
+
   if (this != &rhs)
     *m_opaque_sp = *rhs.m_opaque_sp;
   return *this;

 SBThread::~SBThread() {}
 
 lldb::SBQueue SBThread::GetQueue() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBQueue, SBThread, GetQueue);
+
   SBQueue sb_queue;
   QueueSP queue_sp;
   std::unique_lock<std::recursive_mutex> lock;

                 static_cast<void *>(exe_ctx.GetThreadPtr()),
                 static_cast<void *>(queue_sp.get()));
 
-  return sb_queue;
+  return LLDB_RECORD_RESULT(sb_queue);
 }
 
 bool SBThread::IsValid() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBThread, IsValid);
+
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 

   return false;
 }
 
-void SBThread::Clear() { m_opaque_sp->Clear(); }
+void SBThread::Clear() {
+  LLDB_RECORD_METHOD_NO_ARGS(void, SBThread, Clear);
+
+  m_opaque_sp->Clear();
+}
 
 StopReason SBThread::GetStopReason() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::StopReason, SBThread, GetStopReason);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   StopReason reason = eStopReasonInvalid;

 }
 
 size_t SBThread::GetStopReasonDataCount() {
+  LLDB_RECORD_METHOD_NO_ARGS(size_t, SBThread, GetStopReasonDataCount);
+
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 

 }
 
 uint64_t SBThread::GetStopReasonDataAtIndex(uint32_t idx) {
+  LLDB_RECORD_METHOD(uint64_t, SBThread, GetStopReasonDataAtIndex, (uint32_t),
+                     idx);
+
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 

 }
 
 bool SBThread::GetStopReasonExtendedInfoAsJSON(lldb::SBStream &stream) {
+  LLDB_RECORD_METHOD(bool, SBThread, GetStopReasonExtendedInfoAsJSON,
+                     (lldb::SBStream &), stream);
+
   Stream &strm = stream.ref();
 
   std::unique_lock<std::recursive_mutex> lock;

 
 SBThreadCollection
 SBThread::GetStopReasonExtendedBacktraces(InstrumentationRuntimeType type) {
+  LLDB_RECORD_METHOD(lldb::SBThreadCollection, SBThread,
+                     GetStopReasonExtendedBacktraces,
+                     (lldb::InstrumentationRuntimeType), type);
+
   ThreadCollectionSP threads;
   threads = std::make_shared<ThreadCollection>();
 

   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
   if (!exe_ctx.HasThreadScope())
-    return threads;
+    return LLDB_RECORD_RESULT(threads);
 
   ProcessSP process_sp = exe_ctx.GetProcessSP();
 
   StopInfoSP stop_info = exe_ctx.GetThreadPtr()->GetStopInfo();
   StructuredData::ObjectSP info = stop_info->GetExtendedInfo();
   if (!info)
-    return threads;
+    return LLDB_RECORD_RESULT(threads);
 
-  return process_sp->GetInstrumentationRuntime(type)
-      ->GetBacktracesFromExtendedStopInfo(info);
+  return LLDB_RECORD_RESULT(process_sp->GetInstrumentationRuntime(type)
+                                ->GetBacktracesFromExtendedStopInfo(info));
 }
 
 size_t SBThread::GetStopDescription(char *dst, size_t dst_len) {
+  LLDB_RECORD_METHOD(size_t, SBThread, GetStopDescription, (char *, size_t),
+                     dst, dst_len);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   std::unique_lock<std::recursive_mutex> lock;

 }
 
 SBValue SBThread::GetStopReturnValue() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBValue, SBThread, GetStopReturnValue);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   ValueObjectSP return_valobj_sp;
   std::unique_lock<std::recursive_mutex> lock;

                 return_valobj_sp.get() ? return_valobj_sp->GetValueAsCString()
                                        : "<no return value>");
 
-  return SBValue(return_valobj_sp);
+  return LLDB_RECORD_RESULT(SBValue(return_valobj_sp));
 }
 
 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);
+
   ThreadSP thread_sp(m_opaque_sp->GetThreadSP());
   if (thread_sp)
     return thread_sp->GetID();

 }
 
 uint32_t SBThread::GetIndexID() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBThread, GetIndexID);
+
   ThreadSP thread_sp(m_opaque_sp->GetThreadSP());
   if (thread_sp)
     return thread_sp->GetIndexID();

 }
 
 const char *SBThread::GetName() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBThread, GetName);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   const char *name = NULL;
   std::unique_lock<std::recursive_mutex> lock;

 }
 
 const char *SBThread::GetQueueName() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBThread, GetQueueName);
+
   const char *name = NULL;
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);

 }
 
 lldb::queue_id_t SBThread::GetQueueID() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::queue_id_t, SBThread, GetQueueID);
+
   queue_id_t id = LLDB_INVALID_QUEUE_ID;
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);

 }
 
 bool SBThread::GetInfoItemByPathAsString(const char *path, SBStream &strm) {
+  LLDB_RECORD_METHOD(bool, SBThread, GetInfoItemByPathAsString,
+                     (const char *, lldb::SBStream &), path, strm);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   bool success = false;
   std::unique_lock<std::recursive_mutex> lock;

 }
 
 void SBThread::StepOver(lldb::RunMode stop_other_threads) {
+  LLDB_RECORD_METHOD(void, SBThread, StepOver, (lldb::RunMode),
+                     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);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   std::unique_lock<std::recursive_mutex> lock;

 }
 
 void SBThread::StepInto(lldb::RunMode stop_other_threads) {
+  LLDB_RECORD_METHOD(void, SBThread, StepInto, (lldb::RunMode),
+                     stop_other_threads);
+
   StepInto(NULL, 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);
+
   SBError error; // Ignored
   StepInto(target_name, LLDB_INVALID_LINE_NUMBER, error, stop_other_threads);
 }
 
 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);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   std::unique_lock<std::recursive_mutex> lock;

 }
 
 void SBThread::StepOut() {
+  LLDB_RECORD_METHOD_NO_ARGS(void, SBThread, StepOut);
+
   SBError error; // Ignored
   StepOut(error);
 }
 
 void SBThread::StepOut(SBError &error) {
+  LLDB_RECORD_METHOD(void, SBThread, StepOut, (lldb::SBError &), error);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   std::unique_lock<std::recursive_mutex> lock;

 }
 
 void SBThread::StepOutOfFrame(SBFrame &sb_frame) {
+  LLDB_RECORD_METHOD(void, SBThread, StepOutOfFrame, (lldb::SBFrame &),
+                     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);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   std::unique_lock<std::recursive_mutex> lock;

 }
 
 void SBThread::StepInstruction(bool step_over) {
+  LLDB_RECORD_METHOD(void, SBThread, StepInstruction, (bool), 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);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   std::unique_lock<std::recursive_mutex> lock;

 }
 
 void SBThread::RunToAddress(lldb::addr_t addr) {
+  LLDB_RECORD_METHOD(void, SBThread, RunToAddress, (lldb::addr_t), 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);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   std::unique_lock<std::recursive_mutex> lock;

 
 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);
+
   SBError sb_error;
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   char path[PATH_MAX];

 
     if (line == 0) {
       sb_error.SetErrorString("invalid line argument");
-      return sb_error;
+      return LLDB_RECORD_RESULT(sb_error);
     }
 
     if (!frame_sp) {

     SymbolContext frame_sc;
     if (!frame_sp) {
       sb_error.SetErrorString("no valid frames in thread to step");
-      return sb_error;
+      return LLDB_RECORD_RESULT(sb_error);
     }
 
     // If we have a frame, get its line

     if (frame_sc.comp_unit == NULL) {
       sb_error.SetErrorStringWithFormat(
           "frame %u doesn't have debug information", frame_sp->GetFrameIndex());
-      return sb_error;
+      return LLDB_RECORD_RESULT(sb_error);
     }
 
     FileSpec step_file_spec;

         step_file_spec = frame_sc.line_entry.file;
       else {
         sb_error.SetErrorString("invalid file argument or no file for frame");
-        return sb_error;
+        return LLDB_RECORD_RESULT(sb_error);
       }
     }
 

   } else {
     sb_error.SetErrorString("this SBThread object is invalid");
   }
-  return sb_error;
+  return LLDB_RECORD_RESULT(sb_error);
 }
 
 SBError SBThread::StepUsingScriptedThreadPlan(const char *script_class_name) {
-  return StepUsingScriptedThreadPlan(script_class_name, true);
+  LLDB_RECORD_METHOD(lldb::SBError, SBThread, StepUsingScriptedThreadPlan,
+                     (const char *), script_class_name);
+
+  return LLDB_RECORD_RESULT(
+      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);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   SBError error;
 

 
   if (!exe_ctx.HasThreadScope()) {
     error.SetErrorString("this SBThread object is invalid");
-    return error;
+    return LLDB_RECORD_RESULT(error);
   }
 
   Thread *thread = exe_ctx.GetThreadPtr();

 
   if (new_plan_status.Fail()) {
     error.SetErrorString(new_plan_status.AsCString());
-    return error;
+    return LLDB_RECORD_RESULT(error);
   }
 
   if (!resume_immediately)
-    return error;
+    return LLDB_RECORD_RESULT(error);
 
   if (new_plan_status.Success())
     error = ResumeNewPlan(exe_ctx, new_plan_sp.get());
   else
     error.SetErrorString(new_plan_status.AsCString());
 
-  return error;
+  return LLDB_RECORD_RESULT(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);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   SBError sb_error;
 

 
   if (!exe_ctx.HasThreadScope()) {
     sb_error.SetErrorString("this SBThread object is invalid");
-    return sb_error;
+    return LLDB_RECORD_RESULT(sb_error);
   }
 
   Thread *thread = exe_ctx.GetThreadPtr();
 
   Status err = thread->JumpToLine(file_spec.get(), line, true);
   sb_error.SetError(err);
-  return sb_error;
+  return LLDB_RECORD_RESULT(sb_error);
 }
 
 SBError SBThread::ReturnFromFrame(SBFrame &frame, SBValue &return_value) {
+  LLDB_RECORD_METHOD(lldb::SBError, SBThread, ReturnFromFrame,
+                     (lldb::SBFrame &, lldb::SBValue &), frame, return_value);
+
   SBError sb_error;
 
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));

         thread->ReturnFromFrame(frame.GetFrameSP(), return_value.GetSP()));
   }
 
-  return sb_error;
+  return LLDB_RECORD_RESULT(sb_error);
 }
 
 SBError SBThread::UnwindInnermostExpression() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBThread,
+                             UnwindInnermostExpression);
+
   SBError sb_error;
 
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));

       thread->SetSelectedFrameByIndex(0, false);
   }
 
-  return sb_error;
+  return LLDB_RECORD_RESULT(sb_error);
 }
 
 bool SBThread::Suspend() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBThread, Suspend);
+
   SBError error; // Ignored
   return Suspend(error);
 }
 
 bool SBThread::Suspend(SBError &error) {
+  LLDB_RECORD_METHOD(bool, SBThread, Suspend, (lldb::SBError &), error);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);

 }
 
 bool SBThread::Resume() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBThread, Resume);
+
   SBError error; // Ignored
   return Resume(error);
 }
 
 bool SBThread::Resume(SBError &error) {
+  LLDB_RECORD_METHOD(bool, SBThread, Resume, (lldb::SBError &), error);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);

 }
 
 bool SBThread::IsSuspended() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBThread, IsSuspended);
+
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 

 }
 
 bool SBThread::IsStopped() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBThread, IsStopped);
+
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 

 }
 
 SBProcess SBThread::GetProcess() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBProcess, SBThread, GetProcess);
+
   SBProcess sb_process;
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);

                 frame_desc_strm.GetData());
   }
 
-  return sb_process;
+  return LLDB_RECORD_RESULT(sb_process);
 }
 
 uint32_t SBThread::GetNumFrames() {
+  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBThread, GetNumFrames);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   uint32_t num_frames = 0;

 }
 
 SBFrame SBThread::GetFrameAtIndex(uint32_t idx) {
+  LLDB_RECORD_METHOD(lldb::SBFrame, SBThread, GetFrameAtIndex, (uint32_t), idx);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   SBFrame sb_frame;

                 static_cast<void *>(frame_sp.get()), frame_desc_strm.GetData());
   }
 
-  return sb_frame;
+  return LLDB_RECORD_RESULT(sb_frame);
 }
 
 lldb::SBFrame SBThread::GetSelectedFrame() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBFrame, SBThread, GetSelectedFrame);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   SBFrame sb_frame;

                 static_cast<void *>(frame_sp.get()), frame_desc_strm.GetData());
   }
 
-  return sb_frame;
+  return LLDB_RECORD_RESULT(sb_frame);
 }
 
 lldb::SBFrame SBThread::SetSelectedFrame(uint32_t idx) {
+  LLDB_RECORD_METHOD(lldb::SBFrame, SBThread, SetSelectedFrame, (uint32_t),
+                     idx);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   SBFrame sb_frame;

                 static_cast<void *>(exe_ctx.GetThreadPtr()), idx,
                 static_cast<void *>(frame_sp.get()), frame_desc_strm.GetData());
   }
-  return sb_frame;
+  return LLDB_RECORD_RESULT(sb_frame);
 }
 
 bool SBThread::EventIsThreadEvent(const SBEvent &event) {
+  LLDB_RECORD_STATIC_METHOD(bool, SBThread, EventIsThreadEvent,
+                            (const lldb::SBEvent &), event);
+
   return Thread::ThreadEventData::GetEventDataFromEvent(event.get()) != NULL;
 }
 
 SBFrame SBThread::GetStackFrameFromEvent(const SBEvent &event) {
-  return Thread::ThreadEventData::GetStackFrameFromEvent(event.get());
+  LLDB_RECORD_STATIC_METHOD(lldb::SBFrame, SBThread, GetStackFrameFromEvent,
+                            (const lldb::SBEvent &), event);
+
+  return LLDB_RECORD_RESULT(
+      Thread::ThreadEventData::GetStackFrameFromEvent(event.get()));
 }
 
 SBThread SBThread::GetThreadFromEvent(const SBEvent &event) {
-  return Thread::ThreadEventData::GetThreadFromEvent(event.get());
+  LLDB_RECORD_STATIC_METHOD(lldb::SBThread, SBThread, GetThreadFromEvent,
+                            (const lldb::SBEvent &), event);
+
+  return LLDB_RECORD_RESULT(
+      Thread::ThreadEventData::GetThreadFromEvent(event.get()));
 }
 
 bool SBThread::operator==(const SBThread &rhs) const {
+  LLDB_RECORD_METHOD_CONST(bool, SBThread, operator==,(const lldb::SBThread &),
+                           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);
+
   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);
+
   Stream &strm = status.ref();
 
   std::unique_lock<std::recursive_mutex> lock;

 }
 
 bool SBThread::GetDescription(SBStream &description) const {
-    return GetDescription(description, false);
+  LLDB_RECORD_METHOD_CONST(bool, SBThread, GetDescription, (lldb::SBStream &),
+                           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);
+
   Stream &strm = description.ref();
 
   std::unique_lock<std::recursive_mutex> lock;

 }
 
 SBThread SBThread::GetExtendedBacktraceThread(const char *type) {
+  LLDB_RECORD_METHOD(lldb::SBThread, SBThread, GetExtendedBacktraceThread,
+                     (const char *), type);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);

     log->Printf("SBThread(%p)::GetExtendedBacktraceThread() is not returning a "
                 "Valid thread",
                 static_cast<void *>(exe_ctx.GetThreadPtr()));
-  return sb_origin_thread;
+  return LLDB_RECORD_RESULT(sb_origin_thread);
 }
 
 uint32_t SBThread::GetExtendedBacktraceOriginatingIndexID() {
+  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBThread,
+                             GetExtendedBacktraceOriginatingIndexID);
+
   ThreadSP thread_sp(m_opaque_sp->GetThreadSP());
   if (thread_sp)
     return thread_sp->GetExtendedBacktraceOriginatingIndexID();

 }
 
 SBValue SBThread::GetCurrentException() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBValue, SBThread, GetCurrentException);
+
   ThreadSP thread_sp(m_opaque_sp->GetThreadSP());
-  if (!thread_sp) return SBValue();
+  if (!thread_sp)
+    return LLDB_RECORD_RESULT(SBValue());
 
-  return SBValue(thread_sp->GetCurrentException());
+  return LLDB_RECORD_RESULT(SBValue(thread_sp->GetCurrentException()));
 }
 
 SBThread SBThread::GetCurrentExceptionBacktrace() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBThread, SBThread,
+                             GetCurrentExceptionBacktrace);
+
   ThreadSP thread_sp(m_opaque_sp->GetThreadSP());
-  if (!thread_sp) return SBThread();
+  if (!thread_sp)
+    return LLDB_RECORD_RESULT(SBThread());
 
-  return SBThread(thread_sp->GetCurrentExceptionBacktrace());
+  return LLDB_RECORD_RESULT(
+      SBThread(thread_sp->GetCurrentExceptionBacktrace()));
 }
 
 bool SBThread::SafeToCallFunctions() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBThread, SafeToCallFunctions);
+
   ThreadSP thread_sp(m_opaque_sp->GetThreadSP());
   if (thread_sp)
     return thread_sp->SafeToCallFunctions();

 }
 
 lldb_private::Thread *SBThread::operator->() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb_private::Thread *, SBThread, operator->);
+
   ThreadSP thread_sp(m_opaque_sp->GetThreadSP());
   if (thread_sp)
     return thread_sp.get();

 }
 
 lldb_private::Thread *SBThread::get() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb_private::Thread *, SBThread, get);
+
   ThreadSP thread_sp(m_opaque_sp->GetThreadSP());
   if (thread_sp)
     return thread_sp.get();

lldb/source/API/SBThreadCollection.cpp

 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBThreadCollection.h"
+#include "SBReproducerPrivate.h"
 #include "lldb/API/SBThread.h"
 #include "lldb/Target/ThreadList.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
-SBThreadCollection::SBThreadCollection() : m_opaque_sp() {}
+SBThreadCollection::SBThreadCollection() : m_opaque_sp() {
+  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBThreadCollection);
+}
 
 SBThreadCollection::SBThreadCollection(const SBThreadCollection &rhs)
-    : m_opaque_sp(rhs.m_opaque_sp) {}
+    : m_opaque_sp(rhs.m_opaque_sp) {
+  LLDB_RECORD_CONSTRUCTOR(SBThreadCollection,
+                          (const lldb::SBThreadCollection &), rhs);
+}
 
 const SBThreadCollection &SBThreadCollection::
 operator=(const SBThreadCollection &rhs) {
+  LLDB_RECORD_METHOD(
+      const lldb::SBThreadCollection &,
+      SBThreadCollection, operator=,(const lldb::SBThreadCollection &), rhs);
+
   if (this != &rhs)
     m_opaque_sp = rhs.m_opaque_sp;
   return *this;

   return m_opaque_sp;
 }
 
-bool SBThreadCollection::IsValid() const { return m_opaque_sp.get() != NULL; }
+bool SBThreadCollection::IsValid() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBThreadCollection, IsValid);
+
+  return m_opaque_sp.get() != NULL;
+}
 
 size_t SBThreadCollection::GetSize() {
+  LLDB_RECORD_METHOD_NO_ARGS(size_t, SBThreadCollection, GetSize);
+
   if (m_opaque_sp)
     return m_opaque_sp->GetSize();
   return 0;
 }
 
 SBThread SBThreadCollection::GetThreadAtIndex(size_t idx) {
+  LLDB_RECORD_METHOD(lldb::SBThread, SBThreadCollection, GetThreadAtIndex,
+                     (size_t), idx);
+
   SBThread thread;
   if (m_opaque_sp && idx < m_opaque_sp->GetSize())
     thread = m_opaque_sp->GetThreadAtIndex(idx);
-  return thread;
+  return LLDB_RECORD_RESULT(thread);
 }

lldb/source/API/SBThreadPlan.cpp

 //
 //===----------------------------------------------------------------------===//
 
+#include "SBReproducerPrivate.h"
 #include "lldb/API/SBThread.h"
 
 #include "lldb/API/SBFileSpec.h"

 //----------------------------------------------------------------------
 // Constructors
 //----------------------------------------------------------------------
-SBThreadPlan::SBThreadPlan() {}
+SBThreadPlan::SBThreadPlan() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBThreadPlan); }
 
 SBThreadPlan::SBThreadPlan(const ThreadPlanSP &lldb_object_sp)
-    : m_opaque_sp(lldb_object_sp) {}
+    : m_opaque_sp(lldb_object_sp) {
+  LLDB_RECORD_CONSTRUCTOR(SBThreadPlan, (const lldb::ThreadPlanSP &),
+                          lldb_object_sp);
+}
 
 SBThreadPlan::SBThreadPlan(const SBThreadPlan &rhs)
-    : m_opaque_sp(rhs.m_opaque_sp) {}
+    : m_opaque_sp(rhs.m_opaque_sp) {
+  LLDB_RECORD_CONSTRUCTOR(SBThreadPlan, (const lldb::SBThreadPlan &), rhs);
+}
 
 SBThreadPlan::SBThreadPlan(lldb::SBThread &sb_thread, const char *class_name) {
+  LLDB_RECORD_CONSTRUCTOR(SBThreadPlan, (lldb::SBThread &, const char *),
+                          sb_thread, class_name);
+
   Thread *thread = sb_thread.get();
   if (thread)
     m_opaque_sp = std::make_shared<ThreadPlanPython>(*thread, class_name);

 //----------------------------------------------------------------------
 
 const lldb::SBThreadPlan &SBThreadPlan::operator=(const SBThreadPlan &rhs) {
+  LLDB_RECORD_METHOD(const lldb::SBThreadPlan &,
+                     SBThreadPlan, operator=,(const lldb::SBThreadPlan &), rhs);
+
   if (this != &rhs)
     m_opaque_sp = rhs.m_opaque_sp;
   return *this;

 //----------------------------------------------------------------------
 SBThreadPlan::~SBThreadPlan() {}
 
-lldb_private::ThreadPlan *SBThreadPlan::get() { return m_opaque_sp.get(); }
+lldb_private::ThreadPlan *SBThreadPlan::get() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb_private::ThreadPlan *, SBThreadPlan, get);
+
+  return m_opaque_sp.get();
+}
+
+bool SBThreadPlan::IsValid() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBThreadPlan, IsValid);
+
+  return m_opaque_sp.get() != NULL;
+}
+
+void SBThreadPlan::Clear() {
+  LLDB_RECORD_METHOD_NO_ARGS(void, SBThreadPlan, Clear);
+
+  m_opaque_sp.reset();
+}
 
-bool SBThreadPlan::IsValid() const { return m_opaque_sp.get() != NULL; }
+lldb::StopReason SBThreadPlan::GetStopReason() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::StopReason, SBThreadPlan, GetStopReason);
 
-void SBThreadPlan::Clear() { m_opaque_sp.reset(); }
+  return eStopReasonNone;
+}
+
+size_t SBThreadPlan::GetStopReasonDataCount() {
+  LLDB_RECORD_METHOD_NO_ARGS(size_t, SBThreadPlan, GetStopReasonDataCount);
 
-lldb::StopReason SBThreadPlan::GetStopReason() { return eStopReasonNone; }
+  return 0;
+}
 
-size_t SBThreadPlan::GetStopReasonDataCount() { return 0; }
+uint64_t SBThreadPlan::GetStopReasonDataAtIndex(uint32_t idx) {
+  LLDB_RECORD_METHOD(uint64_t, SBThreadPlan, GetStopReasonDataAtIndex,
+                     (uint32_t), idx);
 
-uint64_t SBThreadPlan::GetStopReasonDataAtIndex(uint32_t idx) { return 0; }
+  return 0;
+}
 
 SBThread SBThreadPlan::GetThread() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBThread, SBThreadPlan, GetThread);
+
   if (m_opaque_sp) {
-    return SBThread(m_opaque_sp->GetThread().shared_from_this());
+    return LLDB_RECORD_RESULT(
+        SBThread(m_opaque_sp->GetThread().shared_from_this()));
   } else
-    return SBThread();
+    return LLDB_RECORD_RESULT(SBThread());
 }
 
 bool SBThreadPlan::GetDescription(lldb::SBStream &description) const {
+  LLDB_RECORD_METHOD_CONST(bool, SBThreadPlan, GetDescription,
+                           (lldb::SBStream &), description);
+
   if (m_opaque_sp) {
     m_opaque_sp->GetDescription(description.get(), eDescriptionLevelFull);
   } else {

 }
 
 void SBThreadPlan::SetPlanComplete(bool success) {
+  LLDB_RECORD_METHOD(void, SBThreadPlan, SetPlanComplete, (bool), success);
+
   if (m_opaque_sp)
     m_opaque_sp->SetPlanComplete(success);
 }
 
 bool SBThreadPlan::IsPlanComplete() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBThreadPlan, IsPlanComplete);
+
   if (m_opaque_sp)
     return m_opaque_sp->IsPlanComplete();
   else

 }
 
 bool SBThreadPlan::IsPlanStale() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBThreadPlan, IsPlanStale);
+
   if (m_opaque_sp)
     return m_opaque_sp->IsPlanStale();
   else

 }
 
 bool SBThreadPlan::IsValid() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBThreadPlan, IsValid);
+
   if (m_opaque_sp)
     return m_opaque_sp->ValidatePlan(nullptr);
   else

 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);
+
   SBError error;
-  return QueueThreadPlanForStepOverRange(sb_start_address, size, error);
+  return LLDB_RECORD_RESULT(
+      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);
+
   if (m_opaque_sp) {
     Address *start_address = sb_start_address.get();
     if (!start_address) {
-      return SBThreadPlan();
+      return LLDB_RECORD_RESULT(SBThreadPlan());
     }
 
     AddressRange range(*start_address, size);

     if (plan_status.Fail())
       error.SetErrorString(plan_status.AsCString());
 
-    return plan;
+    return LLDB_RECORD_RESULT(plan);
   } else {
-    return SBThreadPlan();
+    return LLDB_RECORD_RESULT(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);
+
   SBError error;
-  return QueueThreadPlanForStepInRange(sb_start_address, size, error);
+  return LLDB_RECORD_RESULT(
+      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);
+
   if (m_opaque_sp) {
     Address *start_address = sb_start_address.get();
     if (!start_address) {
-      return SBThreadPlan();
+      return LLDB_RECORD_RESULT(SBThreadPlan());
     }
 
     AddressRange range(*start_address, size);

     if (plan_status.Fail())
       error.SetErrorString(plan_status.AsCString());
 
-    return plan;
+    return LLDB_RECORD_RESULT(plan);
   } else {
-    return SBThreadPlan();
+    return LLDB_RECORD_RESULT(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);
+
   SBError error;
-  return QueueThreadPlanForStepOut(frame_idx_to_step_to, first_insn, error);
+  return LLDB_RECORD_RESULT(
+      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);
+
   if (m_opaque_sp) {
     SymbolContext sc;
     sc = m_opaque_sp->GetThread().GetStackFrameAtIndex(0)->GetSymbolContext(

     if (plan_status.Fail())
       error.SetErrorString(plan_status.AsCString());
 
-    return plan;
+    return LLDB_RECORD_RESULT(plan);
   } else {
-    return SBThreadPlan();
+    return LLDB_RECORD_RESULT(SBThreadPlan());
   }
 }
 
 SBThreadPlan
 SBThreadPlan::QueueThreadPlanForRunToAddress(SBAddress sb_address) {
+  LLDB_RECORD_METHOD(lldb::SBThreadPlan, SBThreadPlan,
+                     QueueThreadPlanForRunToAddress, (lldb::SBAddress),
+                     sb_address);
+
   SBError error;
-  return QueueThreadPlanForRunToAddress(sb_address, error);
+  return LLDB_RECORD_RESULT(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);
+
   if (m_opaque_sp) {
     Address *address = sb_address.get();
     if (!address)
-      return SBThreadPlan();
+      return LLDB_RECORD_RESULT(SBThreadPlan());
 
     Status plan_status;
     SBThreadPlan plan =

     if (plan_status.Fail())
       error.SetErrorString(plan_status.AsCString());
 
-    return plan;
+    return LLDB_RECORD_RESULT(plan);
   } else {
-    return SBThreadPlan();
+    return LLDB_RECORD_RESULT(SBThreadPlan());
   }
 }
 
 SBThreadPlan
 SBThreadPlan::QueueThreadPlanForStepScripted(const char *script_class_name) {
+  LLDB_RECORD_METHOD(lldb::SBThreadPlan, SBThreadPlan,
+                     QueueThreadPlanForStepScripted, (const char *),
+                     script_class_name);
+
   SBError error;
-  return QueueThreadPlanForStepScripted(script_class_name, error);
+  return LLDB_RECORD_RESULT(
+      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);
+
   if (m_opaque_sp) {
     Status plan_status;
     SBThreadPlan plan =

     if (plan_status.Fail())
       error.SetErrorString(plan_status.AsCString());
 
-    return plan;
+    return LLDB_RECORD_RESULT(plan);
   } else {
-    return SBThreadPlan();
+    return LLDB_RECORD_RESULT(SBThreadPlan());
   }
 }

lldb/source/API/SBTrace.cpp

 //
 //===----------------------------------------------------------------------===//
 
+#include "SBReproducerPrivate.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Utility/Log.h"
 

 }
 
 void SBTrace::StopTrace(SBError &error, lldb::tid_t thread_id) {
+  LLDB_RECORD_METHOD(void, SBTrace, StopTrace, (lldb::SBError &, lldb::tid_t),
+                     error, thread_id);
+
   ProcessSP process_sp(GetSP());
   error.Clear();
 

 }
 
 void SBTrace::GetTraceConfig(SBTraceOptions &options, SBError &error) {
+  LLDB_RECORD_METHOD(void, SBTrace, GetTraceConfig,
+                     (lldb::SBTraceOptions &, lldb::SBError &), options, error);
+
   ProcessSP process_sp(GetSP());
   error.Clear();
 

 }
 
 lldb::user_id_t SBTrace::GetTraceUID() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::user_id_t, SBTrace, GetTraceUID);
+
   if (m_trace_impl_sp)
     return m_trace_impl_sp->uid;
   return LLDB_INVALID_UID;

 }
 
 SBTrace::SBTrace() {
+  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTrace);
+
   m_trace_impl_sp = std::make_shared<TraceImpl>();
   if (m_trace_impl_sp)
     m_trace_impl_sp->uid = LLDB_INVALID_UID;

 void SBTrace::SetSP(const ProcessSP &process_sp) { m_opaque_wp = process_sp; }
 
 bool SBTrace::IsValid() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBTrace, IsValid);
+
   if (!m_trace_impl_sp)
     return false;
   if (!GetSP())

lldb/source/API/SBTraceOptions.cpp

 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBTraceOptions.h"
+#include "SBReproducerPrivate.h"
 #include "lldb/API/SBError.h"
 #include "lldb/API/SBStructuredData.h"
 #include "lldb/Core/StructuredDataImpl.h"

 using namespace lldb_private;
 
 SBTraceOptions::SBTraceOptions() {
+  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTraceOptions);
+
   m_traceoptions_sp = std::make_shared<TraceOptions>();
 }
 
 lldb::TraceType SBTraceOptions::getType() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::TraceType, SBTraceOptions, getType);
+
   if (m_traceoptions_sp)
     return m_traceoptions_sp->getType();
   return lldb::TraceType::eTraceTypeNone;
 }
 
 uint64_t SBTraceOptions::getTraceBufferSize() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(uint64_t, SBTraceOptions,
+                                   getTraceBufferSize);
+
   if (m_traceoptions_sp)
     return m_traceoptions_sp->getTraceBufferSize();
   return 0;
 }
 
 lldb::SBStructuredData SBTraceOptions::getTraceParams(lldb::SBError &error) {
+  LLDB_RECORD_METHOD(lldb::SBStructuredData, SBTraceOptions, getTraceParams,
+                     (lldb::SBError &), error);
+
   error.Clear();
   const lldb_private::StructuredData::DictionarySP dict_obj =
       m_traceoptions_sp->getTraceParams();

     structData.m_impl_up->SetObjectSP(dict_obj->shared_from_this());
   else
     error.SetErrorString("Empty trace params");
-  return structData;
+  return LLDB_RECORD_RESULT(structData);
 }
 
 uint64_t SBTraceOptions::getMetaDataBufferSize() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(uint64_t, SBTraceOptions,
+                                   getMetaDataBufferSize);
+
   if (m_traceoptions_sp)
     return m_traceoptions_sp->getTraceBufferSize();
   return 0;
 }
 
 void SBTraceOptions::setTraceParams(lldb::SBStructuredData &params) {
+  LLDB_RECORD_METHOD(void, SBTraceOptions, setTraceParams,
+                     (lldb::SBStructuredData &), params);
+
   if (m_traceoptions_sp && params.m_impl_up) {
     StructuredData::ObjectSP obj_sp = params.m_impl_up->GetObjectSP();
     if (obj_sp && obj_sp->GetAsDictionary() != nullptr)

 }
 
 void SBTraceOptions::setType(lldb::TraceType type) {
+  LLDB_RECORD_METHOD(void, SBTraceOptions, setType, (lldb::TraceType), type);
+
   if (m_traceoptions_sp)
     m_traceoptions_sp->setType(type);
 }
 
 void SBTraceOptions::setTraceBufferSize(uint64_t size) {
+  LLDB_RECORD_METHOD(void, SBTraceOptions, setTraceBufferSize, (uint64_t),
+                     size);
+
   if (m_traceoptions_sp)
     m_traceoptions_sp->setTraceBufferSize(size);
 }
 
 void SBTraceOptions::setMetaDataBufferSize(uint64_t size) {
+  LLDB_RECORD_METHOD(void, SBTraceOptions, setMetaDataBufferSize, (uint64_t),
+                     size);
+
   if (m_traceoptions_sp)
     m_traceoptions_sp->setMetaDataBufferSize(size);
 }
 
 bool SBTraceOptions::IsValid() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBTraceOptions, IsValid);
+
   if (m_traceoptions_sp)
     return true;
   return false;
 }
 
 void SBTraceOptions::setThreadID(lldb::tid_t thread_id) {
+  LLDB_RECORD_METHOD(void, SBTraceOptions, setThreadID, (lldb::tid_t),
+                     thread_id);
+
   if (m_traceoptions_sp)
     m_traceoptions_sp->setThreadID(thread_id);
 }
 
 lldb::tid_t SBTraceOptions::getThreadID() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::tid_t, SBTraceOptions, getThreadID);
+
   if (m_traceoptions_sp)
     return m_traceoptions_sp->getThreadID();
   return LLDB_INVALID_THREAD_ID;

lldb/source/API/SBType.cpp

 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBType.h"
+#include "SBReproducerPrivate.h"
 #include "lldb/API/SBDefines.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/API/SBTypeEnumMember.h"

 using namespace lldb;
 using namespace lldb_private;
 
-SBType::SBType() : m_opaque_sp() {}
+SBType::SBType() : m_opaque_sp() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBType); }
 
 SBType::SBType(const CompilerType &type)
     : m_opaque_sp(new TypeImpl(

     : m_opaque_sp(type_impl_sp) {}
 
 SBType::SBType(const SBType &rhs) : m_opaque_sp() {
+  LLDB_RECORD_CONSTRUCTOR(SBType, (const lldb::SBType &), rhs);
+
   if (this != &rhs) {
     m_opaque_sp = rhs.m_opaque_sp;
   }

 //{}
 //
 bool SBType::operator==(SBType &rhs) {
+  LLDB_RECORD_METHOD(bool, SBType, operator==,(lldb::SBType &), rhs);
+
   if (!IsValid())
     return !rhs.IsValid();
 

 }
 
 bool SBType::operator!=(SBType &rhs) {
+  LLDB_RECORD_METHOD(bool, SBType, operator!=,(lldb::SBType &), rhs);
+
   if (!IsValid())
     return rhs.IsValid();
 

 }
 
 SBType &SBType::operator=(const SBType &rhs) {
+  LLDB_RECORD_METHOD(lldb::SBType &, SBType, operator=,(const lldb::SBType &),
+                     rhs);
+
   if (this != &rhs) {
     m_opaque_sp = rhs.m_opaque_sp;
   }

 }
 
 bool SBType::IsValid() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBType, IsValid);
+
   if (m_opaque_sp.get() == NULL)
     return false;
 

 }
 
 uint64_t SBType::GetByteSize() {
+  LLDB_RECORD_METHOD_NO_ARGS(uint64_t, SBType, GetByteSize);
+
   if (IsValid())
     if (llvm::Optional<uint64_t> size =
             m_opaque_sp->GetCompilerType(false).GetByteSize(nullptr))

 }
 
 bool SBType::IsPointerType() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBType, IsPointerType);
+
   if (!IsValid())
     return false;
   return m_opaque_sp->GetCompilerType(true).IsPointerType();
 }
 
 bool SBType::IsArrayType() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBType, IsArrayType);
+
   if (!IsValid())
     return false;
   return m_opaque_sp->GetCompilerType(true).IsArrayType(nullptr, nullptr,

 }
 
 bool SBType::IsVectorType() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBType, IsVectorType);
+
   if (!IsValid())
     return false;
   return m_opaque_sp->GetCompilerType(true).IsVectorType(nullptr, nullptr);
 }
 
 bool SBType::IsReferenceType() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBType, IsReferenceType);
+
   if (!IsValid())
     return false;
   return m_opaque_sp->GetCompilerType(true).IsReferenceType();
 }
 
 SBType SBType::GetPointerType() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBType, GetPointerType);
+
   if (!IsValid())
-    return SBType();
+    return LLDB_RECORD_RESULT(SBType());
 
-  return SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetPointerType())));
+  return LLDB_RECORD_RESULT(
+      SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetPointerType()))));
 }
 
 SBType SBType::GetPointeeType() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBType, GetPointeeType);
+
   if (!IsValid())
-    return SBType();
-  return SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetPointeeType())));
+    return LLDB_RECORD_RESULT(SBType());
+  return LLDB_RECORD_RESULT(
+      SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetPointeeType()))));
 }
 
 SBType SBType::GetReferenceType() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBType, GetReferenceType);
+
   if (!IsValid())
-    return SBType();
-  return SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetReferenceType())));
+    return LLDB_RECORD_RESULT(SBType());
+  return LLDB_RECORD_RESULT(
+      SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetReferenceType()))));
 }
 
 SBType SBType::GetTypedefedType() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBType, GetTypedefedType);
+
   if (!IsValid())
-    return SBType();
-  return SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetTypedefedType())));
+    return LLDB_RECORD_RESULT(SBType());
+  return LLDB_RECORD_RESULT(
+      SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetTypedefedType()))));
 }
 
 SBType SBType::GetDereferencedType() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBType, GetDereferencedType);
+
   if (!IsValid())
-    return SBType();
-  return SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetDereferencedType())));
+    return LLDB_RECORD_RESULT(SBType());
+  return LLDB_RECORD_RESULT(
+      SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetDereferencedType()))));
 }
 
 SBType SBType::GetArrayElementType() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBType, GetArrayElementType);
+
   if (!IsValid())
-    return SBType();
-  return SBType(TypeImplSP(
-      new TypeImpl(m_opaque_sp->GetCompilerType(true).GetArrayElementType())));
+    return LLDB_RECORD_RESULT(SBType());
+  return LLDB_RECORD_RESULT(SBType(TypeImplSP(
+      new TypeImpl(m_opaque_sp->GetCompilerType(true).GetArrayElementType()))));
 }
 
 SBType SBType::GetArrayType(uint64_t size) {
+  LLDB_RECORD_METHOD(lldb::SBType, SBType, GetArrayType, (uint64_t), size);
+
   if (!IsValid())
-    return SBType();
-  return SBType(TypeImplSP(
-      new TypeImpl(m_opaque_sp->GetCompilerType(true).GetArrayType(size))));
+    return LLDB_RECORD_RESULT(SBType());
+  return LLDB_RECORD_RESULT(SBType(TypeImplSP(
+      new TypeImpl(m_opaque_sp->GetCompilerType(true).GetArrayType(size)))));
 }
 
 SBType SBType::GetVectorElementType() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBType, GetVectorElementType);
+
   SBType type_sb;
   if (IsValid()) {
     CompilerType vector_element_type;

                                                         nullptr))
       type_sb.SetSP(TypeImplSP(new TypeImpl(vector_element_type)));
   }
-  return type_sb;
+  return LLDB_RECORD_RESULT(type_sb);
 }
 
 bool SBType::IsFunctionType() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBType, IsFunctionType);
+
   if (!IsValid())
     return false;
   return m_opaque_sp->GetCompilerType(true).IsFunctionType();
 }
 
 bool SBType::IsPolymorphicClass() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBType, IsPolymorphicClass);
+
   if (!IsValid())
     return false;
   return m_opaque_sp->GetCompilerType(true).IsPolymorphicClass();
 }
 
 bool SBType::IsTypedefType() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBType, IsTypedefType);
+
   if (!IsValid())
     return false;
   return m_opaque_sp->GetCompilerType(true).IsTypedefType();
 }
 
 bool SBType::IsAnonymousType() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBType, IsAnonymousType);
+
   if (!IsValid())
     return false;
   return m_opaque_sp->GetCompilerType(true).IsAnonymousType();
 }
 
 lldb::SBType SBType::GetFunctionReturnType() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBType, GetFunctionReturnType);
+
   if (IsValid()) {
     CompilerType return_type(
         m_opaque_sp->GetCompilerType(true).GetFunctionReturnType());
     if (return_type.IsValid())
-      return SBType(return_type);
+      return LLDB_RECORD_RESULT(SBType(return_type));
   }
-  return lldb::SBType();
+  return LLDB_RECORD_RESULT(lldb::SBType());
 }
 
 lldb::SBTypeList SBType::GetFunctionArgumentTypes() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTypeList, SBType,
+                             GetFunctionArgumentTypes);
+
   SBTypeList sb_type_list;
   if (IsValid()) {
     CompilerType func_type(m_opaque_sp->GetCompilerType(true));

       sb_type_list.Append(SBType(func_type.GetFunctionArgumentAtIndex(i)));
     }
   }
-  return sb_type_list;
+  return LLDB_RECORD_RESULT(sb_type_list);
 }
 
 uint32_t SBType::GetNumberOfMemberFunctions() {
+  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBType, GetNumberOfMemberFunctions);
+
   if (IsValid()) {
     return m_opaque_sp->GetCompilerType(true).GetNumMemberFunctions();
   }

 }
 
 lldb::SBTypeMemberFunction SBType::GetMemberFunctionAtIndex(uint32_t idx) {
+  LLDB_RECORD_METHOD(lldb::SBTypeMemberFunction, SBType,
+                     GetMemberFunctionAtIndex, (uint32_t), idx);
+
   SBTypeMemberFunction sb_func_type;
   if (IsValid())
     sb_func_type.reset(new TypeMemberFunctionImpl(
         m_opaque_sp->GetCompilerType(true).GetMemberFunctionAtIndex(idx)));
-  return sb_func_type;
+  return LLDB_RECORD_RESULT(sb_func_type);
 }
 
 lldb::SBType SBType::GetUnqualifiedType() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBType, GetUnqualifiedType);
+
   if (!IsValid())
-    return SBType();
-  return SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetUnqualifiedType())));
+    return LLDB_RECORD_RESULT(SBType());
+  return LLDB_RECORD_RESULT(
+      SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetUnqualifiedType()))));
 }
 
 lldb::SBType SBType::GetCanonicalType() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBType, GetCanonicalType);
+
   if (IsValid())
-    return SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetCanonicalType())));
-  return SBType();
+    return LLDB_RECORD_RESULT(
+        SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetCanonicalType()))));
+  return LLDB_RECORD_RESULT(SBType());
 }
 
 lldb::BasicType SBType::GetBasicType() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::BasicType, SBType, GetBasicType);
+
   if (IsValid())
     return m_opaque_sp->GetCompilerType(false).GetBasicTypeEnumeration();
   return eBasicTypeInvalid;
 }
 
 SBType SBType::GetBasicType(lldb::BasicType basic_type) {
+  LLDB_RECORD_METHOD(lldb::SBType, SBType, GetBasicType, (lldb::BasicType),
+                     basic_type);
+
   if (IsValid() && m_opaque_sp->IsValid())
-    return SBType(
-        m_opaque_sp->GetTypeSystem(false)->GetBasicTypeFromAST(basic_type));
-  return SBType();
+    return LLDB_RECORD_RESULT(SBType(
+        m_opaque_sp->GetTypeSystem(false)->GetBasicTypeFromAST(basic_type)));
+  return LLDB_RECORD_RESULT(SBType());
 }
 
 uint32_t SBType::GetNumberOfDirectBaseClasses() {
+  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBType, GetNumberOfDirectBaseClasses);
+
   if (IsValid())
     return m_opaque_sp->GetCompilerType(true).GetNumDirectBaseClasses();
   return 0;
 }
 
 uint32_t SBType::GetNumberOfVirtualBaseClasses() {
+  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBType, GetNumberOfVirtualBaseClasses);
+
   if (IsValid())
     return m_opaque_sp->GetCompilerType(true).GetNumVirtualBaseClasses();
   return 0;
 }
 
 uint32_t SBType::GetNumberOfFields() {
+  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBType, GetNumberOfFields);
+
   if (IsValid())
     return m_opaque_sp->GetCompilerType(true).GetNumFields();
   return 0;

 
 bool SBType::GetDescription(SBStream &description,
                             lldb::DescriptionLevel description_level) {
+  LLDB_RECORD_METHOD(bool, SBType, GetDescription,
+                     (lldb::SBStream &, lldb::DescriptionLevel), description,
+                     description_level);
+
   Stream &strm = description.ref();
 
   if (m_opaque_sp) {

 }
 
 SBTypeMember SBType::GetDirectBaseClassAtIndex(uint32_t idx) {
+  LLDB_RECORD_METHOD(lldb::SBTypeMember, SBType, GetDirectBaseClassAtIndex,
+                     (uint32_t), idx);
+
   SBTypeMember sb_type_member;
   if (IsValid()) {
     uint32_t bit_offset = 0;

       sb_type_member.reset(new TypeMemberImpl(
           TypeImplSP(new TypeImpl(base_class_type)), bit_offset));
   }
-  return sb_type_member;
+  return LLDB_RECORD_RESULT(sb_type_member);
 }
 
 SBTypeMember SBType::GetVirtualBaseClassAtIndex(uint32_t idx) {
+  LLDB_RECORD_METHOD(lldb::SBTypeMember, SBType, GetVirtualBaseClassAtIndex,
+                     (uint32_t), idx);
+
   SBTypeMember sb_type_member;
   if (IsValid()) {
     uint32_t bit_offset = 0;

       sb_type_member.reset(new TypeMemberImpl(
           TypeImplSP(new TypeImpl(base_class_type)), bit_offset));
   }
-  return sb_type_member;
+  return LLDB_RECORD_RESULT(sb_type_member);
 }
 
 SBTypeEnumMemberList SBType::GetEnumMembers() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTypeEnumMemberList, SBType,
+                             GetEnumMembers);
+
   SBTypeEnumMemberList sb_enum_member_list;
   if (IsValid()) {
     CompilerType this_type(m_opaque_sp->GetCompilerType(true));

       });
     }
   }
-  return sb_enum_member_list;
+  return LLDB_RECORD_RESULT(sb_enum_member_list);
 }
 
 SBTypeMember SBType::GetFieldAtIndex(uint32_t idx) {
+  LLDB_RECORD_METHOD(lldb::SBTypeMember, SBType, GetFieldAtIndex, (uint32_t),
+                     idx);
+
   SBTypeMember sb_type_member;
   if (IsValid()) {
     CompilerType this_type(m_opaque_sp->GetCompilerType(false));

       }
     }
   }
-  return sb_type_member;
+  return LLDB_RECORD_RESULT(sb_type_member);
 }
 
 bool SBType::IsTypeComplete() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBType, IsTypeComplete);
+
   if (!IsValid())
     return false;
   return m_opaque_sp->GetCompilerType(false).IsCompleteType();
 }
 
 uint32_t SBType::GetTypeFlags() {
+  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBType, GetTypeFlags);
+
   if (!IsValid())
     return 0;
   return m_opaque_sp->GetCompilerType(true).GetTypeInfo();
 }
 
 const char *SBType::GetName() {
+  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBType, GetName);
+
   if (!IsValid())
     return "";
   return m_opaque_sp->GetName().GetCString();
 }
 
 const char *SBType::GetDisplayTypeName() {
+  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBType, GetDisplayTypeName);
+
   if (!IsValid())
     return "";
   return m_opaque_sp->GetDisplayTypeName().GetCString();
 }
 
 lldb::TypeClass SBType::GetTypeClass() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::TypeClass, SBType, GetTypeClass);
+
   if (IsValid())
     return m_opaque_sp->GetCompilerType(true).GetTypeClass();
   return lldb::eTypeClassInvalid;
 }
 
 uint32_t SBType::GetNumberOfTemplateArguments() {
+  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBType, GetNumberOfTemplateArguments);
+
   if (IsValid())
     return m_opaque_sp->GetCompilerType(false).GetNumTemplateArguments();
   return 0;
 }
 
 lldb::SBType SBType::GetTemplateArgumentType(uint32_t idx) {
+  LLDB_RECORD_METHOD(lldb::SBType, SBType, GetTemplateArgumentType, (uint32_t),
+                     idx);
+
   if (!IsValid())
-    return SBType();
+    return LLDB_RECORD_RESULT(SBType());
 
   CompilerType type;
   switch(GetTemplateArgumentKind(idx)) {

       break;
   }
   if (type.IsValid())
-    return SBType(type);
-  return SBType();
+    return LLDB_RECORD_RESULT(SBType(type));
+  return LLDB_RECORD_RESULT(SBType());
 }
 
 lldb::TemplateArgumentKind SBType::GetTemplateArgumentKind(uint32_t idx) {
+  LLDB_RECORD_METHOD(lldb::TemplateArgumentKind, SBType,
+                     GetTemplateArgumentKind, (uint32_t), idx);
+
   if (IsValid())
     return m_opaque_sp->GetCompilerType(false).GetTemplateArgumentKind(idx);
   return eTemplateArgumentKindNull;
 }
 
-SBTypeList::SBTypeList() : m_opaque_up(new TypeListImpl()) {}
+SBTypeList::SBTypeList() : m_opaque_up(new TypeListImpl()) {
+  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTypeList);
+}
 
 SBTypeList::SBTypeList(const SBTypeList &rhs)
     : m_opaque_up(new TypeListImpl()) {
+  LLDB_RECORD_CONSTRUCTOR(SBTypeList, (const lldb::SBTypeList &), rhs);
+
   for (uint32_t i = 0, rhs_size = const_cast<SBTypeList &>(rhs).GetSize();
        i < rhs_size; i++)
     Append(const_cast<SBTypeList &>(rhs).GetTypeAtIndex(i));
 }
 
-bool SBTypeList::IsValid() { return (m_opaque_up != NULL); }
+bool SBTypeList::IsValid() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBTypeList, IsValid);
+
+  return (m_opaque_up != NULL);
+}
 
 SBTypeList &SBTypeList::operator=(const SBTypeList &rhs) {
+  LLDB_RECORD_METHOD(lldb::SBTypeList &,
+                     SBTypeList, operator=,(const lldb::SBTypeList &), rhs);
+
   if (this != &rhs) {
     m_opaque_up.reset(new TypeListImpl());
     for (uint32_t i = 0, rhs_size = const_cast<SBTypeList &>(rhs).GetSize();

 }
 
 void SBTypeList::Append(SBType type) {
+  LLDB_RECORD_METHOD(void, SBTypeList, Append, (lldb::SBType), 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);
+
   if (m_opaque_up)
-    return SBType(m_opaque_up->GetTypeAtIndex(index));
-  return SBType();
+    return LLDB_RECORD_RESULT(SBType(m_opaque_up->GetTypeAtIndex(index)));
+  return LLDB_RECORD_RESULT(SBType());
 }
 
-uint32_t SBTypeList::GetSize() { return m_opaque_up->GetSize(); }
+uint32_t SBTypeList::GetSize() {
+  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeList, GetSize);
+
+  return m_opaque_up->GetSize();
+}
 
 SBTypeList::~SBTypeList() {}
 
-SBTypeMember::SBTypeMember() : m_opaque_up() {}
+SBTypeMember::SBTypeMember() : m_opaque_up() {
+  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTypeMember);
+}
 
 SBTypeMember::~SBTypeMember() {}
 
 SBTypeMember::SBTypeMember(const SBTypeMember &rhs) : m_opaque_up() {
+  LLDB_RECORD_CONSTRUCTOR(SBTypeMember, (const lldb::SBTypeMember &), rhs);
+
   if (this != &rhs) {
     if (rhs.IsValid())
       m_opaque_up.reset(new TypeMemberImpl(rhs.ref()));

 }
 
 lldb::SBTypeMember &SBTypeMember::operator=(const lldb::SBTypeMember &rhs) {
+  LLDB_RECORD_METHOD(lldb::SBTypeMember &,
+                     SBTypeMember, operator=,(const lldb::SBTypeMember &), rhs);
+
   if (this != &rhs) {
     if (rhs.IsValid())
       m_opaque_up.reset(new TypeMemberImpl(rhs.ref()));

   return *this;
 }
 
-bool SBTypeMember::IsValid() const { return m_opaque_up.get(); }
+bool SBTypeMember::IsValid() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeMember, IsValid);
+
+  return m_opaque_up.get();
+}
 
 const char *SBTypeMember::GetName() {
+  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTypeMember, GetName);
+
   if (m_opaque_up)
     return m_opaque_up->GetName().GetCString();
   return NULL;
 }
 
 SBType SBTypeMember::GetType() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBTypeMember, GetType);
+
   SBType sb_type;
   if (m_opaque_up) {
     sb_type.SetSP(m_opaque_up->GetTypeImpl());
   }
-  return sb_type;
+  return LLDB_RECORD_RESULT(sb_type);
 }
 
 uint64_t SBTypeMember::GetOffsetInBytes() {
+  LLDB_RECORD_METHOD_NO_ARGS(uint64_t, SBTypeMember, GetOffsetInBytes);
+
   if (m_opaque_up)
     return m_opaque_up->GetBitOffset() / 8u;
   return 0;
 }
 
 uint64_t SBTypeMember::GetOffsetInBits() {
+  LLDB_RECORD_METHOD_NO_ARGS(uint64_t, SBTypeMember, GetOffsetInBits);
+
   if (m_opaque_up)
     return m_opaque_up->GetBitOffset();
   return 0;
 }
 
 bool SBTypeMember::IsBitfield() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBTypeMember, IsBitfield);
+
   if (m_opaque_up)
     return m_opaque_up->GetIsBitfield();
   return false;
 }
 
 uint32_t SBTypeMember::GetBitfieldSizeInBits() {
+  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeMember, GetBitfieldSizeInBits);
+
   if (m_opaque_up)
     return m_opaque_up->GetBitfieldBitSize();
   return 0;

 
 bool SBTypeMember::GetDescription(lldb::SBStream &description,
                                   lldb::DescriptionLevel description_level) {
+  LLDB_RECORD_METHOD(bool, SBTypeMember, GetDescription,
+                     (lldb::SBStream &, lldb::DescriptionLevel), description,
+                     description_level);
+
   Stream &strm = description.ref();
 
   if (m_opaque_up) {

 
 const TypeMemberImpl &SBTypeMember::ref() const { return *m_opaque_up; }
 
-SBTypeMemberFunction::SBTypeMemberFunction() : m_opaque_sp() {}
+SBTypeMemberFunction::SBTypeMemberFunction() : m_opaque_sp() {
+  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTypeMemberFunction);
+}
 
 SBTypeMemberFunction::~SBTypeMemberFunction() {}
 
 SBTypeMemberFunction::SBTypeMemberFunction(const SBTypeMemberFunction &rhs)
-    : m_opaque_sp(rhs.m_opaque_sp) {}
+    : m_opaque_sp(rhs.m_opaque_sp) {
+  LLDB_RECORD_CONSTRUCTOR(SBTypeMemberFunction,
+                          (const lldb::SBTypeMemberFunction &), rhs);
+}
 
 lldb::SBTypeMemberFunction &SBTypeMemberFunction::
 operator=(const lldb::SBTypeMemberFunction &rhs) {
+  LLDB_RECORD_METHOD(
+      lldb::SBTypeMemberFunction &,
+      SBTypeMemberFunction, operator=,(const lldb::SBTypeMemberFunction &),
+      rhs);
+
   if (this != &rhs)
     m_opaque_sp = rhs.m_opaque_sp;
   return *this;
 }
 
-bool SBTypeMemberFunction::IsValid() const { return m_opaque_sp.get(); }
+bool SBTypeMemberFunction::IsValid() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeMemberFunction, IsValid);
+
+  return m_opaque_sp.get();
+}
 
 const char *SBTypeMemberFunction::GetName() {
+  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTypeMemberFunction, GetName);
+
   if (m_opaque_sp)
     return m_opaque_sp->GetName().GetCString();
   return NULL;
 }
 
 const char *SBTypeMemberFunction::GetDemangledName() {
+  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTypeMemberFunction,
+                             GetDemangledName);
+
   if (m_opaque_sp) {
     ConstString mangled_str = m_opaque_sp->GetMangledName();
     if (mangled_str) {

 }
 
 const char *SBTypeMemberFunction::GetMangledName() {
+  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTypeMemberFunction,
+                             GetMangledName);
+
   if (m_opaque_sp)
     return m_opaque_sp->GetMangledName().GetCString();
   return NULL;
 }
 
 SBType SBTypeMemberFunction::GetType() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBTypeMemberFunction, GetType);
+
   SBType sb_type;
   if (m_opaque_sp) {
     sb_type.SetSP(lldb::TypeImplSP(new TypeImpl(m_opaque_sp->GetType())));
   }
-  return sb_type;
+  return LLDB_RECORD_RESULT(sb_type);
 }
 
 lldb::SBType SBTypeMemberFunction::GetReturnType() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBTypeMemberFunction, GetReturnType);
+
   SBType sb_type;
   if (m_opaque_sp) {
     sb_type.SetSP(lldb::TypeImplSP(new TypeImpl(m_opaque_sp->GetReturnType())));
   }
-  return sb_type;
+  return LLDB_RECORD_RESULT(sb_type);
 }
 
 uint32_t SBTypeMemberFunction::GetNumberOfArguments() {
+  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeMemberFunction,
+                             GetNumberOfArguments);
+
   if (m_opaque_sp)
     return m_opaque_sp->GetNumArguments();
   return 0;
 }
 
 lldb::SBType SBTypeMemberFunction::GetArgumentTypeAtIndex(uint32_t i) {
+  LLDB_RECORD_METHOD(lldb::SBType, SBTypeMemberFunction, GetArgumentTypeAtIndex,
+                     (uint32_t), i);
+
   SBType sb_type;
   if (m_opaque_sp) {
     sb_type.SetSP(
         lldb::TypeImplSP(new TypeImpl(m_opaque_sp->GetArgumentAtIndex(i))));
   }
-  return sb_type;
+  return LLDB_RECORD_RESULT(sb_type);
 }
 
 lldb::MemberFunctionKind SBTypeMemberFunction::GetKind() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::MemberFunctionKind, SBTypeMemberFunction,
+                             GetKind);
+
   if (m_opaque_sp)
     return m_opaque_sp->GetKind();
   return lldb::eMemberFunctionKindUnknown;

 
 bool SBTypeMemberFunction::GetDescription(
     lldb::SBStream &description, lldb::DescriptionLevel description_level) {
+  LLDB_RECORD_METHOD(bool, SBTypeMemberFunction, GetDescription,
+                     (lldb::SBStream &, lldb::DescriptionLevel), description,
+                     description_level);
+
   Stream &strm = description.ref();
 
   if (m_opaque_sp)

lldb/source/API/SBTypeCategory.cpp

 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBTypeCategory.h"
+#include "SBReproducerPrivate.h"
 
 #include "lldb/API/SBStream.h"
 #include "lldb/API/SBTypeFilter.h"

 
 typedef std::pair<lldb::TypeCategoryImplSP, user_id_t> ImplType;
 
-SBTypeCategory::SBTypeCategory() : m_opaque_sp() {}
+SBTypeCategory::SBTypeCategory() : m_opaque_sp() {
+  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTypeCategory);
+}
 
 SBTypeCategory::SBTypeCategory(const char *name) : m_opaque_sp() {
   DataVisualization::Categories::GetCategory(ConstString(name), m_opaque_sp);
 }
 
 SBTypeCategory::SBTypeCategory(const lldb::SBTypeCategory &rhs)
-    : m_opaque_sp(rhs.m_opaque_sp) {}
+    : m_opaque_sp(rhs.m_opaque_sp) {
+  LLDB_RECORD_CONSTRUCTOR(SBTypeCategory, (const lldb::SBTypeCategory &), rhs);
+}
 
 SBTypeCategory::~SBTypeCategory() {}
 
-bool SBTypeCategory::IsValid() const { return (m_opaque_sp.get() != NULL); }
+bool SBTypeCategory::IsValid() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeCategory, IsValid);
+
+  return (m_opaque_sp.get() != NULL);
+}
 
 bool SBTypeCategory::GetEnabled() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBTypeCategory, GetEnabled);
+
   if (!IsValid())
     return false;
   return m_opaque_sp->IsEnabled();
 }
 
 void SBTypeCategory::SetEnabled(bool enabled) {
+  LLDB_RECORD_METHOD(void, SBTypeCategory, SetEnabled, (bool), enabled);
+
   if (!IsValid())
     return;
   if (enabled)

 }
 
 const char *SBTypeCategory::GetName() {
+  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTypeCategory, GetName);
+
   if (!IsValid())
     return NULL;
   return m_opaque_sp->GetName();
 }
 
 lldb::LanguageType SBTypeCategory::GetLanguageAtIndex(uint32_t idx) {
+  LLDB_RECORD_METHOD(lldb::LanguageType, SBTypeCategory, GetLanguageAtIndex,
+                     (uint32_t), idx);
+
   if (IsValid())
     return m_opaque_sp->GetLanguageAtIndex(idx);
   return lldb::eLanguageTypeUnknown;
 }
 
 uint32_t SBTypeCategory::GetNumLanguages() {
+  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeCategory, GetNumLanguages);
+
   if (IsValid())
     return m_opaque_sp->GetNumLanguages();
   return 0;
 }
 
 void SBTypeCategory::AddLanguage(lldb::LanguageType language) {
+  LLDB_RECORD_METHOD(void, SBTypeCategory, AddLanguage, (lldb::LanguageType),
+                     language);
+
   if (IsValid())
     m_opaque_sp->AddLanguage(language);
 }
 
 uint32_t SBTypeCategory::GetNumFormats() {
+  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeCategory, GetNumFormats);
+
   if (!IsValid())
     return 0;
 

 }
 
 uint32_t SBTypeCategory::GetNumSummaries() {
+  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeCategory, GetNumSummaries);
+
   if (!IsValid())
     return 0;
   return m_opaque_sp->GetTypeSummariesContainer()->GetCount() +

 }
 
 uint32_t SBTypeCategory::GetNumFilters() {
+  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeCategory, GetNumFilters);
+
   if (!IsValid())
     return 0;
   return m_opaque_sp->GetTypeFiltersContainer()->GetCount() +

 
 #ifndef LLDB_DISABLE_PYTHON
 uint32_t SBTypeCategory::GetNumSynthetics() {
+  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeCategory, GetNumSynthetics);
+
   if (!IsValid())
     return 0;
   return m_opaque_sp->GetTypeSyntheticsContainer()->GetCount() +

 
 lldb::SBTypeNameSpecifier
 SBTypeCategory::GetTypeNameSpecifierForFilterAtIndex(uint32_t index) {
+  LLDB_RECORD_METHOD(lldb::SBTypeNameSpecifier, SBTypeCategory,
+                     GetTypeNameSpecifierForFilterAtIndex, (uint32_t), index);
+
   if (!IsValid())
-    return SBTypeNameSpecifier();
-  return SBTypeNameSpecifier(
-      m_opaque_sp->GetTypeNameSpecifierForFilterAtIndex(index));
+    return LLDB_RECORD_RESULT(SBTypeNameSpecifier());
+  return LLDB_RECORD_RESULT(SBTypeNameSpecifier(
+      m_opaque_sp->GetTypeNameSpecifierForFilterAtIndex(index)));
 }
 
 lldb::SBTypeNameSpecifier
 SBTypeCategory::GetTypeNameSpecifierForFormatAtIndex(uint32_t index) {
+  LLDB_RECORD_METHOD(lldb::SBTypeNameSpecifier, SBTypeCategory,
+                     GetTypeNameSpecifierForFormatAtIndex, (uint32_t), index);
+
   if (!IsValid())
-    return SBTypeNameSpecifier();
-  return SBTypeNameSpecifier(
-      m_opaque_sp->GetTypeNameSpecifierForFormatAtIndex(index));
+    return LLDB_RECORD_RESULT(SBTypeNameSpecifier());
+  return LLDB_RECORD_RESULT(SBTypeNameSpecifier(
+      m_opaque_sp->GetTypeNameSpecifierForFormatAtIndex(index)));
 }
 
 lldb::SBTypeNameSpecifier
 SBTypeCategory::GetTypeNameSpecifierForSummaryAtIndex(uint32_t index) {
+  LLDB_RECORD_METHOD(lldb::SBTypeNameSpecifier, SBTypeCategory,
+                     GetTypeNameSpecifierForSummaryAtIndex, (uint32_t), index);
+
   if (!IsValid())
-    return SBTypeNameSpecifier();
-  return SBTypeNameSpecifier(
-      m_opaque_sp->GetTypeNameSpecifierForSummaryAtIndex(index));
+    return LLDB_RECORD_RESULT(SBTypeNameSpecifier());
+  return LLDB_RECORD_RESULT(SBTypeNameSpecifier(
+      m_opaque_sp->GetTypeNameSpecifierForSummaryAtIndex(index)));
 }
 
 #ifndef LLDB_DISABLE_PYTHON
 lldb::SBTypeNameSpecifier
 SBTypeCategory::GetTypeNameSpecifierForSyntheticAtIndex(uint32_t index) {
+  LLDB_RECORD_METHOD(lldb::SBTypeNameSpecifier, SBTypeCategory,
+                     GetTypeNameSpecifierForSyntheticAtIndex, (uint32_t),
+                     index);
+
   if (!IsValid())
-    return SBTypeNameSpecifier();
-  return SBTypeNameSpecifier(
-      m_opaque_sp->GetTypeNameSpecifierForSyntheticAtIndex(index));
+    return LLDB_RECORD_RESULT(SBTypeNameSpecifier());
+  return LLDB_RECORD_RESULT(SBTypeNameSpecifier(
+      m_opaque_sp->GetTypeNameSpecifierForSyntheticAtIndex(index)));
 }
 #endif
 
 SBTypeFilter SBTypeCategory::GetFilterForType(SBTypeNameSpecifier spec) {
+  LLDB_RECORD_METHOD(lldb::SBTypeFilter, SBTypeCategory, GetFilterForType,
+                     (lldb::SBTypeNameSpecifier), spec);
+
   if (!IsValid())
-    return SBTypeFilter();
+    return LLDB_RECORD_RESULT(SBTypeFilter());
 
   if (!spec.IsValid())
-    return SBTypeFilter();
+    return LLDB_RECORD_RESULT(SBTypeFilter());
 
   lldb::TypeFilterImplSP children_sp;
 

         ConstString(spec.GetName()), children_sp);
 
   if (!children_sp)
-    return lldb::SBTypeFilter();
+    return LLDB_RECORD_RESULT(lldb::SBTypeFilter());
 
   TypeFilterImplSP filter_sp =
       std::static_pointer_cast<TypeFilterImpl>(children_sp);
 
-  return lldb::SBTypeFilter(filter_sp);
+  return LLDB_RECORD_RESULT(lldb::SBTypeFilter(filter_sp));
 }
 SBTypeFormat SBTypeCategory::GetFormatForType(SBTypeNameSpecifier spec) {
+  LLDB_RECORD_METHOD(lldb::SBTypeFormat, SBTypeCategory, GetFormatForType,
+                     (lldb::SBTypeNameSpecifier), spec);
+
   if (!IsValid())
-    return SBTypeFormat();
+    return LLDB_RECORD_RESULT(SBTypeFormat());
 
   if (!spec.IsValid())
-    return SBTypeFormat();
+    return LLDB_RECORD_RESULT(SBTypeFormat());
 
   lldb::TypeFormatImplSP format_sp;
 

         ConstString(spec.GetName()), format_sp);
 
   if (!format_sp)
-    return lldb::SBTypeFormat();
+    return LLDB_RECORD_RESULT(lldb::SBTypeFormat());
 
-  return lldb::SBTypeFormat(format_sp);
+  return LLDB_RECORD_RESULT(lldb::SBTypeFormat(format_sp));
 }
 
 #ifndef LLDB_DISABLE_PYTHON
 SBTypeSummary SBTypeCategory::GetSummaryForType(SBTypeNameSpecifier spec) {
+  LLDB_RECORD_METHOD(lldb::SBTypeSummary, SBTypeCategory, GetSummaryForType,
+                     (lldb::SBTypeNameSpecifier), spec);
+
   if (!IsValid())
-    return SBTypeSummary();
+    return LLDB_RECORD_RESULT(SBTypeSummary());
 
   if (!spec.IsValid())
-    return SBTypeSummary();
+    return LLDB_RECORD_RESULT(SBTypeSummary());
 
   lldb::TypeSummaryImplSP summary_sp;
 

         ConstString(spec.GetName()), summary_sp);
 
   if (!summary_sp)
-    return lldb::SBTypeSummary();
+    return LLDB_RECORD_RESULT(lldb::SBTypeSummary());
 
-  return lldb::SBTypeSummary(summary_sp);
+  return LLDB_RECORD_RESULT(lldb::SBTypeSummary(summary_sp));
 }
 #endif // LLDB_DISABLE_PYTHON
 
 #ifndef LLDB_DISABLE_PYTHON
 SBTypeSynthetic SBTypeCategory::GetSyntheticForType(SBTypeNameSpecifier spec) {
+  LLDB_RECORD_METHOD(lldb::SBTypeSynthetic, SBTypeCategory, GetSyntheticForType,
+                     (lldb::SBTypeNameSpecifier), spec);
+
   if (!IsValid())
-    return SBTypeSynthetic();
+    return LLDB_RECORD_RESULT(SBTypeSynthetic());
 
   if (!spec.IsValid())
-    return SBTypeSynthetic();
+    return LLDB_RECORD_RESULT(SBTypeSynthetic());
 
   lldb::SyntheticChildrenSP children_sp;
 

         ConstString(spec.GetName()), children_sp);
 
   if (!children_sp)
-    return lldb::SBTypeSynthetic();
+    return LLDB_RECORD_RESULT(lldb::SBTypeSynthetic());
 
   ScriptedSyntheticChildrenSP synth_sp =
       std::static_pointer_cast<ScriptedSyntheticChildren>(children_sp);
 
-  return lldb::SBTypeSynthetic(synth_sp);
+  return LLDB_RECORD_RESULT(lldb::SBTypeSynthetic(synth_sp));
 }
 #endif
 
 #ifndef LLDB_DISABLE_PYTHON
 SBTypeFilter SBTypeCategory::GetFilterAtIndex(uint32_t index) {
+  LLDB_RECORD_METHOD(lldb::SBTypeFilter, SBTypeCategory, GetFilterAtIndex,
+                     (uint32_t), index);
+
   if (!IsValid())
-    return SBTypeFilter();
+    return LLDB_RECORD_RESULT(SBTypeFilter());
   lldb::SyntheticChildrenSP children_sp =
       m_opaque_sp->GetSyntheticAtIndex((index));
 
   if (!children_sp.get())
-    return lldb::SBTypeFilter();
+    return LLDB_RECORD_RESULT(lldb::SBTypeFilter());
 
   TypeFilterImplSP filter_sp =
       std::static_pointer_cast<TypeFilterImpl>(children_sp);
 
-  return lldb::SBTypeFilter(filter_sp);
+  return LLDB_RECORD_RESULT(lldb::SBTypeFilter(filter_sp));
 }
 #endif
 
 SBTypeFormat SBTypeCategory::GetFormatAtIndex(uint32_t index) {
+  LLDB_RECORD_METHOD(lldb::SBTypeFormat, SBTypeCategory, GetFormatAtIndex,
+                     (uint32_t), index);
+
   if (!IsValid())
-    return SBTypeFormat();
-  return SBTypeFormat(m_opaque_sp->GetFormatAtIndex((index)));
+    return LLDB_RECORD_RESULT(SBTypeFormat());
+  return LLDB_RECORD_RESULT(
+      SBTypeFormat(m_opaque_sp->GetFormatAtIndex((index))));
 }
 
 #ifndef LLDB_DISABLE_PYTHON
 SBTypeSummary SBTypeCategory::GetSummaryAtIndex(uint32_t index) {
+  LLDB_RECORD_METHOD(lldb::SBTypeSummary, SBTypeCategory, GetSummaryAtIndex,
+                     (uint32_t), index);
+
   if (!IsValid())
-    return SBTypeSummary();
-  return SBTypeSummary(m_opaque_sp->GetSummaryAtIndex((index)));
+    return LLDB_RECORD_RESULT(SBTypeSummary());
+  return LLDB_RECORD_RESULT(
+      SBTypeSummary(m_opaque_sp->GetSummaryAtIndex((index))));
 }
 #endif
 
 #ifndef LLDB_DISABLE_PYTHON
 SBTypeSynthetic SBTypeCategory::GetSyntheticAtIndex(uint32_t index) {
+  LLDB_RECORD_METHOD(lldb::SBTypeSynthetic, SBTypeCategory, GetSyntheticAtIndex,
+                     (uint32_t), index);
+
   if (!IsValid())
-    return SBTypeSynthetic();
+    return LLDB_RECORD_RESULT(SBTypeSynthetic());
   lldb::SyntheticChildrenSP children_sp =
       m_opaque_sp->GetSyntheticAtIndex((index));
 
   if (!children_sp.get())
-    return lldb::SBTypeSynthetic();
+    return LLDB_RECORD_RESULT(lldb::SBTypeSynthetic());
 
   ScriptedSyntheticChildrenSP synth_sp =
       std::static_pointer_cast<ScriptedSyntheticChildren>(children_sp);
 
-  return lldb::SBTypeSynthetic(synth_sp);
+  return LLDB_RECORD_RESULT(lldb::SBTypeSynthetic(synth_sp));
 }
 #endif
 
 bool SBTypeCategory::AddTypeFormat(SBTypeNameSpecifier type_name,
                                    SBTypeFormat format) {
+  LLDB_RECORD_METHOD(bool, SBTypeCategory, AddTypeFormat,
+                     (lldb::SBTypeNameSpecifier, lldb::SBTypeFormat), type_name,
+                     format);
+
   if (!IsValid())
     return false;
 

 }
 
 bool SBTypeCategory::DeleteTypeFormat(SBTypeNameSpecifier type_name) {
+  LLDB_RECORD_METHOD(bool, SBTypeCategory, DeleteTypeFormat,
+                     (lldb::SBTypeNameSpecifier), type_name);
+
   if (!IsValid())
     return false;
 

 #ifndef LLDB_DISABLE_PYTHON
 bool SBTypeCategory::AddTypeSummary(SBTypeNameSpecifier type_name,
                                     SBTypeSummary summary) {
+  LLDB_RECORD_METHOD(bool, SBTypeCategory, AddTypeSummary,
+                     (lldb::SBTypeNameSpecifier, lldb::SBTypeSummary),
+                     type_name, summary);
+
   if (!IsValid())
     return false;
 

 #endif
 
 bool SBTypeCategory::DeleteTypeSummary(SBTypeNameSpecifier type_name) {
+  LLDB_RECORD_METHOD(bool, SBTypeCategory, DeleteTypeSummary,
+                     (lldb::SBTypeNameSpecifier), type_name);
+
   if (!IsValid())
     return false;
 

 
 bool SBTypeCategory::AddTypeFilter(SBTypeNameSpecifier type_name,
                                    SBTypeFilter filter) {
+  LLDB_RECORD_METHOD(bool, SBTypeCategory, AddTypeFilter,
+                     (lldb::SBTypeNameSpecifier, lldb::SBTypeFilter), type_name,
+                     filter);
+
   if (!IsValid())
     return false;
 

 }
 
 bool SBTypeCategory::DeleteTypeFilter(SBTypeNameSpecifier type_name) {
+  LLDB_RECORD_METHOD(bool, SBTypeCategory, DeleteTypeFilter,
+                     (lldb::SBTypeNameSpecifier), type_name);
+
   if (!IsValid())
     return false;
 

 #ifndef LLDB_DISABLE_PYTHON
 bool SBTypeCategory::AddTypeSynthetic(SBTypeNameSpecifier type_name,
                                       SBTypeSynthetic synth) {
+  LLDB_RECORD_METHOD(bool, SBTypeCategory, AddTypeSynthetic,
+                     (lldb::SBTypeNameSpecifier, lldb::SBTypeSynthetic),
+                     type_name, synth);
+
   if (!IsValid())
     return false;
 

 }
 
 bool SBTypeCategory::DeleteTypeSynthetic(SBTypeNameSpecifier type_name) {
+  LLDB_RECORD_METHOD(bool, SBTypeCategory, DeleteTypeSynthetic,
+                     (lldb::SBTypeNameSpecifier), type_name);
+
   if (!IsValid())
     return false;
 

 
 bool SBTypeCategory::GetDescription(lldb::SBStream &description,
                                     lldb::DescriptionLevel description_level) {
+  LLDB_RECORD_METHOD(bool, SBTypeCategory, GetDescription,
+                     (lldb::SBStream &, lldb::DescriptionLevel), description,
+                     description_level);
+
   if (!IsValid())
     return false;
   description.Printf("Category name: %s\n", GetName());

 
 lldb::SBTypeCategory &SBTypeCategory::
 operator=(const lldb::SBTypeCategory &rhs) {
+  LLDB_RECORD_METHOD(lldb::SBTypeCategory &,
+                     SBTypeCategory, operator=,(const lldb::SBTypeCategory &),
+                     rhs);
+
   if (this != &rhs) {
     m_opaque_sp = rhs.m_opaque_sp;
   }

 }
 
 bool SBTypeCategory::operator==(lldb::SBTypeCategory &rhs) {
+  LLDB_RECORD_METHOD(bool, SBTypeCategory, operator==,(lldb::SBTypeCategory &),
+                     rhs);
+
   if (!IsValid())
     return !rhs.IsValid();
 

 }
 
 bool SBTypeCategory::operator!=(lldb::SBTypeCategory &rhs) {
+  LLDB_RECORD_METHOD(bool, SBTypeCategory, operator!=,(lldb::SBTypeCategory &),
+                     rhs);
+
   if (!IsValid())
     return rhs.IsValid();
 

lldb/source/API/SBTypeEnumMember.cpp

 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBTypeEnumMember.h"
+#include "SBReproducerPrivate.h"
 #include "lldb/API/SBDefines.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/API/SBType.h"

 using namespace lldb;
 using namespace lldb_private;
 
-SBTypeEnumMember::SBTypeEnumMember() : m_opaque_sp() {}
+SBTypeEnumMember::SBTypeEnumMember() : m_opaque_sp() {
+  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTypeEnumMember);
+}
 
 SBTypeEnumMember::~SBTypeEnumMember() {}
 SBTypeEnumMember::SBTypeEnumMember(

 
 SBTypeEnumMember::SBTypeEnumMember(const SBTypeEnumMember &rhs)
     : m_opaque_sp() {
+  LLDB_RECORD_CONSTRUCTOR(SBTypeEnumMember, (const lldb::SBTypeEnumMember &),
+                          rhs);
+
   if (this != &rhs) {
     if (rhs.IsValid())
       m_opaque_sp = std::make_shared<TypeEnumMemberImpl>(rhs.ref());

 }
 
 SBTypeEnumMember &SBTypeEnumMember::operator=(const SBTypeEnumMember &rhs) {
+  LLDB_RECORD_METHOD(
+      lldb::SBTypeEnumMember &,
+      SBTypeEnumMember, operator=,(const lldb::SBTypeEnumMember &), rhs);
+
   if (this != &rhs) {
     if (rhs.IsValid())
       m_opaque_sp = std::make_shared<TypeEnumMemberImpl>(rhs.ref());

   return *this;
 }
 
-bool SBTypeEnumMember::IsValid() const { return m_opaque_sp.get(); }
+bool SBTypeEnumMember::IsValid() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeEnumMember, IsValid);
+
+  return m_opaque_sp.get();
+}
 
 const char *SBTypeEnumMember::GetName() {
+  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTypeEnumMember, GetName);
+
   if (m_opaque_sp.get())
     return m_opaque_sp->GetName().GetCString();
   return NULL;
 }
 
 int64_t SBTypeEnumMember::GetValueAsSigned() {
+  LLDB_RECORD_METHOD_NO_ARGS(int64_t, SBTypeEnumMember, GetValueAsSigned);
+
   if (m_opaque_sp.get())
     return m_opaque_sp->GetValueAsSigned();
   return 0;
 }
 
 uint64_t SBTypeEnumMember::GetValueAsUnsigned() {
+  LLDB_RECORD_METHOD_NO_ARGS(uint64_t, SBTypeEnumMember, GetValueAsUnsigned);
+
   if (m_opaque_sp.get())
     return m_opaque_sp->GetValueAsUnsigned();
   return 0;
 }
 
 SBType SBTypeEnumMember::GetType() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBTypeEnumMember, GetType);
+
   SBType sb_type;
   if (m_opaque_sp.get()) {
     sb_type.SetSP(m_opaque_sp->GetIntegerType());
   }
-  return sb_type;
+  return LLDB_RECORD_RESULT(sb_type);
 }
 
 void SBTypeEnumMember::reset(TypeEnumMemberImpl *type_member_impl) {

 }
 
 SBTypeEnumMemberList::SBTypeEnumMemberList()
-    : m_opaque_up(new TypeEnumMemberListImpl()) {}
+    : m_opaque_up(new TypeEnumMemberListImpl()) {
+  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTypeEnumMemberList);
+}
 
 SBTypeEnumMemberList::SBTypeEnumMemberList(const SBTypeEnumMemberList &rhs)
     : m_opaque_up(new TypeEnumMemberListImpl()) {
+  LLDB_RECORD_CONSTRUCTOR(SBTypeEnumMemberList,
+                          (const lldb::SBTypeEnumMemberList &), rhs);
+
   for (uint32_t i = 0,
                 rhs_size = const_cast<SBTypeEnumMemberList &>(rhs).GetSize();
        i < rhs_size; i++)
     Append(const_cast<SBTypeEnumMemberList &>(rhs).GetTypeEnumMemberAtIndex(i));
 }
 
-bool SBTypeEnumMemberList::IsValid() { return (m_opaque_up != NULL); }
+bool SBTypeEnumMemberList::IsValid() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBTypeEnumMemberList, IsValid);
+
+  return (m_opaque_up != NULL);
+}
 
 SBTypeEnumMemberList &SBTypeEnumMemberList::
 operator=(const SBTypeEnumMemberList &rhs) {
+  LLDB_RECORD_METHOD(
+      lldb::SBTypeEnumMemberList &,
+      SBTypeEnumMemberList, operator=,(const lldb::SBTypeEnumMemberList &),
+      rhs);
+
   if (this != &rhs) {
     m_opaque_up.reset(new TypeEnumMemberListImpl());
     for (uint32_t i = 0,

 }
 
 void SBTypeEnumMemberList::Append(SBTypeEnumMember enum_member) {
+  LLDB_RECORD_METHOD(void, SBTypeEnumMemberList, Append,
+                     (lldb::SBTypeEnumMember), enum_member);
+
   if (enum_member.IsValid())
     m_opaque_up->Append(enum_member.m_opaque_sp);
 }
 
 SBTypeEnumMember
 SBTypeEnumMemberList::GetTypeEnumMemberAtIndex(uint32_t index) {
+  LLDB_RECORD_METHOD(lldb::SBTypeEnumMember, SBTypeEnumMemberList,
+                     GetTypeEnumMemberAtIndex, (uint32_t), index);
+
   if (m_opaque_up)
-    return SBTypeEnumMember(m_opaque_up->GetTypeEnumMemberAtIndex(index));
-  return SBTypeEnumMember();
+    return LLDB_RECORD_RESULT(
+        SBTypeEnumMember(m_opaque_up->GetTypeEnumMemberAtIndex(index)));
+  return LLDB_RECORD_RESULT(SBTypeEnumMember());
 }
 
-uint32_t SBTypeEnumMemberList::GetSize() { return m_opaque_up->GetSize(); }
+uint32_t SBTypeEnumMemberList::GetSize() {
+  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeEnumMemberList, GetSize);
+
+  return m_opaque_up->GetSize();
+}
 
 SBTypeEnumMemberList::~SBTypeEnumMemberList() {}
 
 bool SBTypeEnumMember::GetDescription(
     lldb::SBStream &description, lldb::DescriptionLevel description_level) {
+  LLDB_RECORD_METHOD(bool, SBTypeEnumMember, GetDescription,
+                     (lldb::SBStream &, lldb::DescriptionLevel), description,
+                     description_level);
+
   Stream &strm = description.ref();
 
   if (m_opaque_sp.get()) {

lldb/source/API/SBTypeFilter.cpp

 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBTypeFilter.h"
+#include "SBReproducerPrivate.h"
 
 #include "lldb/API/SBStream.h"
 

 using namespace lldb;
 using namespace lldb_private;
 
-SBTypeFilter::SBTypeFilter() : m_opaque_sp() {}
+SBTypeFilter::SBTypeFilter() : m_opaque_sp() {
+  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTypeFilter);
+}
 
 SBTypeFilter::SBTypeFilter(uint32_t options)
-    : m_opaque_sp(TypeFilterImplSP(new TypeFilterImpl(options))) {}
+    : m_opaque_sp(TypeFilterImplSP(new TypeFilterImpl(options))) {
+  LLDB_RECORD_CONSTRUCTOR(SBTypeFilter, (uint32_t), options);
+}
 
 SBTypeFilter::SBTypeFilter(const lldb::SBTypeFilter &rhs)
-    : m_opaque_sp(rhs.m_opaque_sp) {}
+    : m_opaque_sp(rhs.m_opaque_sp) {
+  LLDB_RECORD_CONSTRUCTOR(SBTypeFilter, (const lldb::SBTypeFilter &), rhs);
+}
 
 SBTypeFilter::~SBTypeFilter() {}
 
-bool SBTypeFilter::IsValid() const { return m_opaque_sp.get() != NULL; }
+bool SBTypeFilter::IsValid() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeFilter, IsValid);
+
+  return m_opaque_sp.get() != NULL;
+}
 
 uint32_t SBTypeFilter::GetOptions() {
+  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeFilter, GetOptions);
+
   if (IsValid())
     return m_opaque_sp->GetOptions();
   return 0;
 }
 
 void SBTypeFilter::SetOptions(uint32_t value) {
+  LLDB_RECORD_METHOD(void, SBTypeFilter, SetOptions, (uint32_t), value);
+
   if (CopyOnWrite_Impl())
     m_opaque_sp->SetOptions(value);
 }
 
 bool SBTypeFilter::GetDescription(lldb::SBStream &description,
                                   lldb::DescriptionLevel description_level) {
+  LLDB_RECORD_METHOD(bool, SBTypeFilter, GetDescription,
+                     (lldb::SBStream &, lldb::DescriptionLevel), description,
+                     description_level);
+
   if (!IsValid())
     return false;
   else {

 }
 
 void SBTypeFilter::Clear() {
+  LLDB_RECORD_METHOD_NO_ARGS(void, SBTypeFilter, Clear);
+
   if (CopyOnWrite_Impl())
     m_opaque_sp->Clear();
 }
 
 uint32_t SBTypeFilter::GetNumberOfExpressionPaths() {
+  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeFilter,
+                             GetNumberOfExpressionPaths);
+
   if (IsValid())
     return m_opaque_sp->GetCount();
   return 0;
 }
 
 const char *SBTypeFilter::GetExpressionPathAtIndex(uint32_t i) {
+  LLDB_RECORD_METHOD(const char *, SBTypeFilter, GetExpressionPathAtIndex,
+                     (uint32_t), i);
+
   if (IsValid()) {
     const char *item = m_opaque_sp->GetExpressionPathAtIndex(i);
     if (item && *item == '.')

 }
 
 bool SBTypeFilter::ReplaceExpressionPathAtIndex(uint32_t i, const char *item) {
+  LLDB_RECORD_METHOD(bool, SBTypeFilter, ReplaceExpressionPathAtIndex,
+                     (uint32_t, const char *), i, item);
+
   if (CopyOnWrite_Impl())
     return m_opaque_sp->SetExpressionPathAtIndex(i, item);
   else

 }
 
 void SBTypeFilter::AppendExpressionPath(const char *item) {
+  LLDB_RECORD_METHOD(void, SBTypeFilter, AppendExpressionPath, (const char *),
+                     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);
+
   if (this != &rhs) {
     m_opaque_sp = rhs.m_opaque_sp;
   }

 }
 
 bool SBTypeFilter::operator==(lldb::SBTypeFilter &rhs) {
+  LLDB_RECORD_METHOD(bool, SBTypeFilter, operator==,(lldb::SBTypeFilter &),
+                     rhs);
+
   if (!IsValid())
     return !rhs.IsValid();
 

 }
 
 bool SBTypeFilter::IsEqualTo(lldb::SBTypeFilter &rhs) {
+  LLDB_RECORD_METHOD(bool, SBTypeFilter, IsEqualTo, (lldb::SBTypeFilter &),
+                     rhs);
+
   if (!IsValid())
     return !rhs.IsValid();
 

 }
 
 bool SBTypeFilter::operator!=(lldb::SBTypeFilter &rhs) {
+  LLDB_RECORD_METHOD(bool, SBTypeFilter, operator!=,(lldb::SBTypeFilter &),
+                     rhs);
+
   if (!IsValid())
     return !rhs.IsValid();
 

lldb/source/API/SBTypeFormat.cpp

 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBTypeFormat.h"
+#include "SBReproducerPrivate.h"
 
 #include "lldb/API/SBStream.h"
 

 using namespace lldb;
 using namespace lldb_private;
 
-SBTypeFormat::SBTypeFormat() : m_opaque_sp() {}
+SBTypeFormat::SBTypeFormat() : m_opaque_sp() {
+  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTypeFormat);
+}
 
 SBTypeFormat::SBTypeFormat(lldb::Format format, uint32_t options)
     : m_opaque_sp(
-          TypeFormatImplSP(new TypeFormatImpl_Format(format, options))) {}
+          TypeFormatImplSP(new TypeFormatImpl_Format(format, options))) {
+  LLDB_RECORD_CONSTRUCTOR(SBTypeFormat, (lldb::Format, uint32_t), format,
+                          options);
+}
 
 SBTypeFormat::SBTypeFormat(const char *type, uint32_t options)
     : m_opaque_sp(TypeFormatImplSP(new TypeFormatImpl_EnumType(
-          ConstString(type ? type : ""), options))) {}
+          ConstString(type ? type : ""), options))) {
+  LLDB_RECORD_CONSTRUCTOR(SBTypeFormat, (const char *, uint32_t), type,
+                          options);
+}
 
 SBTypeFormat::SBTypeFormat(const lldb::SBTypeFormat &rhs)
-    : m_opaque_sp(rhs.m_opaque_sp) {}
+    : m_opaque_sp(rhs.m_opaque_sp) {
+  LLDB_RECORD_CONSTRUCTOR(SBTypeFormat, (const lldb::SBTypeFormat &), rhs);
+}
 
 SBTypeFormat::~SBTypeFormat() {}
 
-bool SBTypeFormat::IsValid() const { return m_opaque_sp.get() != NULL; }
+bool SBTypeFormat::IsValid() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeFormat, IsValid);
+
+  return m_opaque_sp.get() != NULL;
+}
 
 lldb::Format SBTypeFormat::GetFormat() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::Format, SBTypeFormat, GetFormat);
+
   if (IsValid() && m_opaque_sp->GetType() == TypeFormatImpl::Type::eTypeFormat)
     return ((TypeFormatImpl_Format *)m_opaque_sp.get())->GetFormat();
   return lldb::eFormatInvalid;
 }
 
 const char *SBTypeFormat::GetTypeName() {
+  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTypeFormat, GetTypeName);
+
   if (IsValid() && m_opaque_sp->GetType() == TypeFormatImpl::Type::eTypeEnum)
     return ((TypeFormatImpl_EnumType *)m_opaque_sp.get())
         ->GetTypeName()

 }
 
 uint32_t SBTypeFormat::GetOptions() {
+  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeFormat, GetOptions);
+
   if (IsValid())
     return m_opaque_sp->GetOptions();
   return 0;
 }
 
 void SBTypeFormat::SetFormat(lldb::Format fmt) {
+  LLDB_RECORD_METHOD(void, SBTypeFormat, SetFormat, (lldb::Format), 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);
+
   if (CopyOnWrite_Impl(Type::eTypeEnum))
     ((TypeFormatImpl_EnumType *)m_opaque_sp.get())
         ->SetTypeName(ConstString(type ? type : ""));
 }
 
 void SBTypeFormat::SetOptions(uint32_t value) {
+  LLDB_RECORD_METHOD(void, SBTypeFormat, SetOptions, (uint32_t), value);
+
   if (CopyOnWrite_Impl(Type::eTypeKeepSame))
     m_opaque_sp->SetOptions(value);
 }
 
 bool SBTypeFormat::GetDescription(lldb::SBStream &description,
                                   lldb::DescriptionLevel description_level) {
+  LLDB_RECORD_METHOD(bool, SBTypeFormat, GetDescription,
+                     (lldb::SBStream &, lldb::DescriptionLevel), description,
+                     description_level);
+
   if (!IsValid())
     return false;
   else {

 }
 
 lldb::SBTypeFormat &SBTypeFormat::operator=(const lldb::SBTypeFormat &rhs) {
+  LLDB_RECORD_METHOD(lldb::SBTypeFormat &,
+                     SBTypeFormat, operator=,(const lldb::SBTypeFormat &), rhs);
+
   if (this != &rhs) {
     m_opaque_sp = rhs.m_opaque_sp;
   }

 }
 
 bool SBTypeFormat::operator==(lldb::SBTypeFormat &rhs) {
+  LLDB_RECORD_METHOD(bool, SBTypeFormat, operator==,(lldb::SBTypeFormat &),
+                     rhs);
+
   if (!IsValid())
     return !rhs.IsValid();
   return m_opaque_sp == rhs.m_opaque_sp;
 }
 
 bool SBTypeFormat::IsEqualTo(lldb::SBTypeFormat &rhs) {
+  LLDB_RECORD_METHOD(bool, SBTypeFormat, IsEqualTo, (lldb::SBTypeFormat &),
+                     rhs);
+
   if (!IsValid())
     return !rhs.IsValid();
 

 }
 
 bool SBTypeFormat::operator!=(lldb::SBTypeFormat &rhs) {
+  LLDB_RECORD_METHOD(bool, SBTypeFormat, operator!=,(lldb::SBTypeFormat &),
+                     rhs);
+
   if (!IsValid())
     return !rhs.IsValid();
   return m_opaque_sp != rhs.m_opaque_sp;

lldb/source/API/SBTypeNameSpecifier.cpp

 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBTypeNameSpecifier.h"
+#include "SBReproducerPrivate.h"
 
 #include "lldb/API/SBStream.h"
 #include "lldb/API/SBType.h"

 using namespace lldb;
 using namespace lldb_private;
 
-SBTypeNameSpecifier::SBTypeNameSpecifier() : m_opaque_sp() {}
+SBTypeNameSpecifier::SBTypeNameSpecifier() : m_opaque_sp() {
+  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTypeNameSpecifier);
+}
 
 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);
+
   if (name == NULL || (*name) == 0)
     m_opaque_sp.reset();
 }
 
 SBTypeNameSpecifier::SBTypeNameSpecifier(SBType type) : m_opaque_sp() {
+  LLDB_RECORD_CONSTRUCTOR(SBTypeNameSpecifier, (lldb::SBType), type);
+
   if (type.IsValid())
     m_opaque_sp = TypeNameSpecifierImplSP(
         new TypeNameSpecifierImpl(type.m_opaque_sp->GetCompilerType(true)));
 }
 
 SBTypeNameSpecifier::SBTypeNameSpecifier(const lldb::SBTypeNameSpecifier &rhs)
-    : m_opaque_sp(rhs.m_opaque_sp) {}
+    : m_opaque_sp(rhs.m_opaque_sp) {
+  LLDB_RECORD_CONSTRUCTOR(SBTypeNameSpecifier,
+                          (const lldb::SBTypeNameSpecifier &), rhs);
+}
 
 SBTypeNameSpecifier::~SBTypeNameSpecifier() {}
 
-bool SBTypeNameSpecifier::IsValid() const { return m_opaque_sp.get() != NULL; }
+bool SBTypeNameSpecifier::IsValid() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeNameSpecifier, IsValid);
+
+  return m_opaque_sp.get() != NULL;
+}
 
 const char *SBTypeNameSpecifier::GetName() {
+  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTypeNameSpecifier, GetName);
+
   if (!IsValid())
     return NULL;
 

 }
 
 SBType SBTypeNameSpecifier::GetType() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBTypeNameSpecifier, GetType);
+
   if (!IsValid())
-    return SBType();
+    return LLDB_RECORD_RESULT(SBType());
   lldb_private::CompilerType c_type = m_opaque_sp->GetCompilerType();
   if (c_type.IsValid())
-    return SBType(c_type);
-  return SBType();
+    return LLDB_RECORD_RESULT(SBType(c_type));
+  return LLDB_RECORD_RESULT(SBType());
 }
 
 bool SBTypeNameSpecifier::IsRegex() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBTypeNameSpecifier, IsRegex);
+
   if (!IsValid())
     return false;
 

 
 bool SBTypeNameSpecifier::GetDescription(
     lldb::SBStream &description, lldb::DescriptionLevel description_level) {
+  LLDB_RECORD_METHOD(bool, SBTypeNameSpecifier, GetDescription,
+                     (lldb::SBStream &, lldb::DescriptionLevel), description,
+                     description_level);
+
   if (!IsValid())
     return false;
   description.Printf("SBTypeNameSpecifier(%s,%s)", GetName(),

 
 lldb::SBTypeNameSpecifier &SBTypeNameSpecifier::
 operator=(const lldb::SBTypeNameSpecifier &rhs) {
+  LLDB_RECORD_METHOD(
+      lldb::SBTypeNameSpecifier &,
+      SBTypeNameSpecifier, operator=,(const lldb::SBTypeNameSpecifier &), rhs);
+
   if (this != &rhs) {
     m_opaque_sp = rhs.m_opaque_sp;
   }

 }
 
 bool SBTypeNameSpecifier::operator==(lldb::SBTypeNameSpecifier &rhs) {
+  LLDB_RECORD_METHOD(
+      bool, SBTypeNameSpecifier, operator==,(lldb::SBTypeNameSpecifier &), rhs);
+
   if (!IsValid())
     return !rhs.IsValid();
   return m_opaque_sp == rhs.m_opaque_sp;
 }
 
 bool SBTypeNameSpecifier::IsEqualTo(lldb::SBTypeNameSpecifier &rhs) {
+  LLDB_RECORD_METHOD(bool, SBTypeNameSpecifier, IsEqualTo,
+                     (lldb::SBTypeNameSpecifier &), rhs);
+
   if (!IsValid())
     return !rhs.IsValid();
 

 }
 
 bool SBTypeNameSpecifier::operator!=(lldb::SBTypeNameSpecifier &rhs) {
+  LLDB_RECORD_METHOD(
+      bool, SBTypeNameSpecifier, operator!=,(lldb::SBTypeNameSpecifier &), rhs);
+
   if (!IsValid())
     return !rhs.IsValid();
   return m_opaque_sp != rhs.m_opaque_sp;

lldb/source/API/SBTypeSummary.cpp

 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBTypeSummary.h"
+#include "SBReproducerPrivate.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/API/SBValue.h"
 #include "lldb/DataFormatters/DataVisualization.h"

 using namespace lldb_private;
 
 SBTypeSummaryOptions::SBTypeSummaryOptions() {
+  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTypeSummaryOptions);
+
   m_opaque_up.reset(new TypeSummaryOptions());
 }
 
 SBTypeSummaryOptions::SBTypeSummaryOptions(
     const lldb::SBTypeSummaryOptions &rhs) {
+  LLDB_RECORD_CONSTRUCTOR(SBTypeSummaryOptions,
+                          (const lldb::SBTypeSummaryOptions &), rhs);
+
   if (rhs.m_opaque_up)
     m_opaque_up.reset(new TypeSummaryOptions(*rhs.m_opaque_up));
   else

 
 SBTypeSummaryOptions::~SBTypeSummaryOptions() {}
 
-bool SBTypeSummaryOptions::IsValid() { return m_opaque_up.get(); }
+bool SBTypeSummaryOptions::IsValid() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBTypeSummaryOptions, IsValid);
+
+  return m_opaque_up.get();
+}
 
 lldb::LanguageType SBTypeSummaryOptions::GetLanguage() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::LanguageType, SBTypeSummaryOptions,
+                             GetLanguage);
+
   if (IsValid())
     return m_opaque_up->GetLanguage();
   return lldb::eLanguageTypeUnknown;
 }
 
 lldb::TypeSummaryCapping SBTypeSummaryOptions::GetCapping() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::TypeSummaryCapping, SBTypeSummaryOptions,
+                             GetCapping);
+
   if (IsValid())
     return m_opaque_up->GetCapping();
   return eTypeSummaryCapped;
 }
 
 void SBTypeSummaryOptions::SetLanguage(lldb::LanguageType l) {
+  LLDB_RECORD_METHOD(void, SBTypeSummaryOptions, SetLanguage,
+                     (lldb::LanguageType), l);
+
   if (IsValid())
     m_opaque_up->SetLanguage(l);
 }
 
 void SBTypeSummaryOptions::SetCapping(lldb::TypeSummaryCapping c) {
+  LLDB_RECORD_METHOD(void, SBTypeSummaryOptions, SetCapping,
+                     (lldb::TypeSummaryCapping), c);
+
   if (IsValid())
     m_opaque_up->SetCapping(c);
 }

 
 SBTypeSummaryOptions::SBTypeSummaryOptions(
     const lldb_private::TypeSummaryOptions *lldb_object_ptr) {
+  LLDB_RECORD_CONSTRUCTOR(SBTypeSummaryOptions,
+                          (const lldb_private::TypeSummaryOptions *),
+                          lldb_object_ptr);
+
   SetOptions(lldb_object_ptr);
 }
 

     m_opaque_up.reset(new TypeSummaryOptions());
 }
 
-SBTypeSummary::SBTypeSummary() : m_opaque_sp() {}
+SBTypeSummary::SBTypeSummary() : m_opaque_sp() {
+  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTypeSummary);
+}
 
 SBTypeSummary SBTypeSummary::CreateWithSummaryString(const char *data,
                                                      uint32_t options) {
+  LLDB_RECORD_STATIC_METHOD(lldb::SBTypeSummary, SBTypeSummary,
+                            CreateWithSummaryString, (const char *, uint32_t),
+                            data, options);
+
   if (!data || data[0] == 0)
-    return SBTypeSummary();
+    return LLDB_RECORD_RESULT(SBTypeSummary());
 
-  return SBTypeSummary(
-      TypeSummaryImplSP(new StringSummaryFormat(options, data)));
+  return LLDB_RECORD_RESULT(
+      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);
+
   if (!data || data[0] == 0)
-    return SBTypeSummary();
+    return LLDB_RECORD_RESULT(SBTypeSummary());
 
-  return SBTypeSummary(
-      TypeSummaryImplSP(new ScriptSummaryFormat(options, data)));
+  return LLDB_RECORD_RESULT(
+      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);
+
   if (!data || data[0] == 0)
-    return SBTypeSummary();
+    return LLDB_RECORD_RESULT(SBTypeSummary());
 
-  return SBTypeSummary(
-      TypeSummaryImplSP(new ScriptSummaryFormat(options, "", data)));
+  return LLDB_RECORD_RESULT(SBTypeSummary(
+      TypeSummaryImplSP(new ScriptSummaryFormat(options, "", data))));
 }
 
 SBTypeSummary SBTypeSummary::CreateWithCallback(FormatCallback cb,

 }
 
 SBTypeSummary::SBTypeSummary(const lldb::SBTypeSummary &rhs)
-    : m_opaque_sp(rhs.m_opaque_sp) {}
+    : m_opaque_sp(rhs.m_opaque_sp) {
+  LLDB_RECORD_CONSTRUCTOR(SBTypeSummary, (const lldb::SBTypeSummary &), rhs);
+}
 
 SBTypeSummary::~SBTypeSummary() {}
 
-bool SBTypeSummary::IsValid() const { return m_opaque_sp.get() != NULL; }
+bool SBTypeSummary::IsValid() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeSummary, IsValid);
+
+  return m_opaque_sp.get() != NULL;
+}
 
 bool SBTypeSummary::IsFunctionCode() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBTypeSummary, IsFunctionCode);
+
   if (!IsValid())
     return false;
   if (ScriptSummaryFormat *script_summary_ptr =

 }
 
 bool SBTypeSummary::IsFunctionName() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBTypeSummary, IsFunctionName);
+
   if (!IsValid())
     return false;
   if (ScriptSummaryFormat *script_summary_ptr =

 }
 
 bool SBTypeSummary::IsSummaryString() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBTypeSummary, IsSummaryString);
+
   if (!IsValid())
     return false;
 

 }
 
 const char *SBTypeSummary::GetData() {
+  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTypeSummary, GetData);
+
   if (!IsValid())
     return NULL;
   if (ScriptSummaryFormat *script_summary_ptr =

 }
 
 uint32_t SBTypeSummary::GetOptions() {
+  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeSummary, GetOptions);
+
   if (!IsValid())
     return lldb::eTypeOptionNone;
   return m_opaque_sp->GetOptions();
 }
 
 void SBTypeSummary::SetOptions(uint32_t value) {
+  LLDB_RECORD_METHOD(void, SBTypeSummary, SetOptions, (uint32_t), value);
+
   if (!CopyOnWrite_Impl())
     return;
   m_opaque_sp->SetOptions(value);
 }
 
 void SBTypeSummary::SetSummaryString(const char *data) {
+  LLDB_RECORD_METHOD(void, SBTypeSummary, SetSummaryString, (const char *),
+                     data);
+
   if (!IsValid())
     return;
   if (!llvm::isa<StringSummaryFormat>(m_opaque_sp.get()))

 }
 
 void SBTypeSummary::SetFunctionName(const char *data) {
+  LLDB_RECORD_METHOD(void, SBTypeSummary, SetFunctionName, (const char *),
+                     data);
+
   if (!IsValid())
     return;
   if (!llvm::isa<ScriptSummaryFormat>(m_opaque_sp.get()))

 }
 
 void SBTypeSummary::SetFunctionCode(const char *data) {
+  LLDB_RECORD_METHOD(void, SBTypeSummary, SetFunctionCode, (const char *),
+                     data);
+
   if (!IsValid())
     return;
   if (!llvm::isa<ScriptSummaryFormat>(m_opaque_sp.get()))

 
 bool SBTypeSummary::GetDescription(lldb::SBStream &description,
                                    lldb::DescriptionLevel description_level) {
+  LLDB_RECORD_METHOD(bool, SBTypeSummary, GetDescription,
+                     (lldb::SBStream &, lldb::DescriptionLevel), description,
+                     description_level);
+
   if (!CopyOnWrite_Impl())
     return false;
   else {

 }
 
 bool SBTypeSummary::DoesPrintValue(lldb::SBValue value) {
+  LLDB_RECORD_METHOD(bool, SBTypeSummary, DoesPrintValue, (lldb::SBValue),
+                     value);
+
   if (!IsValid())
     return false;
   lldb::ValueObjectSP value_sp = value.GetSP();

 }
 
 lldb::SBTypeSummary &SBTypeSummary::operator=(const lldb::SBTypeSummary &rhs) {
+  LLDB_RECORD_METHOD(lldb::SBTypeSummary &,
+                     SBTypeSummary, operator=,(const lldb::SBTypeSummary &),
+                     rhs);
+
   if (this != &rhs) {
     m_opaque_sp = rhs.m_opaque_sp;
   }

 }
 
 bool SBTypeSummary::operator==(lldb::SBTypeSummary &rhs) {
+  LLDB_RECORD_METHOD(bool, SBTypeSummary, operator==,(lldb::SBTypeSummary &),
+                     rhs);
+
   if (!IsValid())
     return !rhs.IsValid();
   return m_opaque_sp == rhs.m_opaque_sp;
 }
 
 bool SBTypeSummary::IsEqualTo(lldb::SBTypeSummary &rhs) {
+  LLDB_RECORD_METHOD(bool, SBTypeSummary, IsEqualTo, (lldb::SBTypeSummary &),
+                     rhs);
+
   if (IsValid()) {
     // valid and invalid are different
     if (!rhs.IsValid())

 }
 
 bool SBTypeSummary::operator!=(lldb::SBTypeSummary &rhs) {
+  LLDB_RECORD_METHOD(bool, SBTypeSummary, operator!=,(lldb::SBTypeSummary &),
+                     rhs);
+
   if (!IsValid())
     return !rhs.IsValid();
   return m_opaque_sp != rhs.m_opaque_sp;

lldb/source/API/SBTypeSynthetic.cpp

 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBTypeSynthetic.h"
+#include "SBReproducerPrivate.h"
 
 #include "lldb/API/SBStream.h"
 

 
 #ifndef LLDB_DISABLE_PYTHON
 
-SBTypeSynthetic::SBTypeSynthetic() : m_opaque_sp() {}
+SBTypeSynthetic::SBTypeSynthetic() : m_opaque_sp() {
+  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTypeSynthetic);
+}
 
 SBTypeSynthetic SBTypeSynthetic::CreateWithClassName(const char *data,
                                                      uint32_t options) {
+  LLDB_RECORD_STATIC_METHOD(lldb::SBTypeSynthetic, SBTypeSynthetic,
+                            CreateWithClassName, (const char *, uint32_t), data,
+                            options);
+
   if (!data || data[0] == 0)
-    return SBTypeSynthetic();
-  return SBTypeSynthetic(ScriptedSyntheticChildrenSP(
-      new ScriptedSyntheticChildren(options, data, "")));
+    return LLDB_RECORD_RESULT(SBTypeSynthetic());
+  return LLDB_RECORD_RESULT(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);
+
   if (!data || data[0] == 0)
-    return SBTypeSynthetic();
-  return SBTypeSynthetic(ScriptedSyntheticChildrenSP(
-      new ScriptedSyntheticChildren(options, "", data)));
+    return LLDB_RECORD_RESULT(SBTypeSynthetic());
+  return LLDB_RECORD_RESULT(SBTypeSynthetic(ScriptedSyntheticChildrenSP(
+      new ScriptedSyntheticChildren(options, "", data))));
 }
 
 SBTypeSynthetic::SBTypeSynthetic(const lldb::SBTypeSynthetic &rhs)
-    : m_opaque_sp(rhs.m_opaque_sp) {}
+    : m_opaque_sp(rhs.m_opaque_sp) {
+  LLDB_RECORD_CONSTRUCTOR(SBTypeSynthetic, (const lldb::SBTypeSynthetic &),
+                          rhs);
+}
 
 SBTypeSynthetic::~SBTypeSynthetic() {}
 
-bool SBTypeSynthetic::IsValid() const { return m_opaque_sp.get() != NULL; }
+bool SBTypeSynthetic::IsValid() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeSynthetic, IsValid);
+
+  return m_opaque_sp.get() != NULL;
+}
 
 bool SBTypeSynthetic::IsClassCode() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBTypeSynthetic, IsClassCode);
+
   if (!IsValid())
     return false;
   const char *code = m_opaque_sp->GetPythonCode();

 }
 
 bool SBTypeSynthetic::IsClassName() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBTypeSynthetic, IsClassName);
+
   if (!IsValid())
     return false;
   return !IsClassCode();
 }
 
 const char *SBTypeSynthetic::GetData() {
+  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTypeSynthetic, GetData);
+
   if (!IsValid())
     return NULL;
   if (IsClassCode())

 }
 
 void SBTypeSynthetic::SetClassName(const char *data) {
+  LLDB_RECORD_METHOD(void, SBTypeSynthetic, SetClassName, (const char *), 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);
+
   if (IsValid() && data && *data)
     m_opaque_sp->SetPythonCode(data);
 }
 
 uint32_t SBTypeSynthetic::GetOptions() {
+  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeSynthetic, GetOptions);
+
   if (!IsValid())
     return lldb::eTypeOptionNone;
   return m_opaque_sp->GetOptions();
 }
 
 void SBTypeSynthetic::SetOptions(uint32_t value) {
+  LLDB_RECORD_METHOD(void, SBTypeSynthetic, SetOptions, (uint32_t), value);
+
   if (!CopyOnWrite_Impl())
     return;
   m_opaque_sp->SetOptions(value);

 
 bool SBTypeSynthetic::GetDescription(lldb::SBStream &description,
                                      lldb::DescriptionLevel description_level) {
+  LLDB_RECORD_METHOD(bool, SBTypeSynthetic, GetDescription,
+                     (lldb::SBStream &, lldb::DescriptionLevel), description,
+                     description_level);
+
   if (m_opaque_sp) {
     description.Printf("%s\n", m_opaque_sp->GetDescription().c_str());
     return true;

 
 lldb::SBTypeSynthetic &SBTypeSynthetic::
 operator=(const lldb::SBTypeSynthetic &rhs) {
+  LLDB_RECORD_METHOD(lldb::SBTypeSynthetic &,
+                     SBTypeSynthetic, operator=,(const lldb::SBTypeSynthetic &),
+                     rhs);
+
   if (this != &rhs) {
     m_opaque_sp = rhs.m_opaque_sp;
   }

 }
 
 bool SBTypeSynthetic::operator==(lldb::SBTypeSynthetic &rhs) {
+  LLDB_RECORD_METHOD(
+      bool, SBTypeSynthetic, operator==,(lldb::SBTypeSynthetic &), rhs);
+
   if (!IsValid())
     return !rhs.IsValid();
   return m_opaque_sp == rhs.m_opaque_sp;
 }
 
 bool SBTypeSynthetic::IsEqualTo(lldb::SBTypeSynthetic &rhs) {
+  LLDB_RECORD_METHOD(bool, SBTypeSynthetic, IsEqualTo,
+                     (lldb::SBTypeSynthetic &), rhs);
+
   if (!IsValid())
     return !rhs.IsValid();
 

 }
 
 bool SBTypeSynthetic::operator!=(lldb::SBTypeSynthetic &rhs) {
+  LLDB_RECORD_METHOD(
+      bool, SBTypeSynthetic, operator!=,(lldb::SBTypeSynthetic &), rhs);
+
   if (!IsValid())
     return !rhs.IsValid();
   return m_opaque_sp != rhs.m_opaque_sp;

lldb/source/API/SBUnixSignals.cpp

 //
 //===----------------------------------------------------------------------===//
 
+#include "SBReproducerPrivate.h"
 #include "lldb/Target/Platform.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/UnixSignals.h"

 using namespace lldb;
 using namespace lldb_private;
 
-SBUnixSignals::SBUnixSignals() {}
+SBUnixSignals::SBUnixSignals() {
+  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBUnixSignals);
+}
 
 SBUnixSignals::SBUnixSignals(const SBUnixSignals &rhs)
-    : m_opaque_wp(rhs.m_opaque_wp) {}
+    : m_opaque_wp(rhs.m_opaque_wp) {
+  LLDB_RECORD_CONSTRUCTOR(SBUnixSignals, (const lldb::SBUnixSignals &), rhs);
+}
 
 SBUnixSignals::SBUnixSignals(ProcessSP &process_sp)
     : m_opaque_wp(process_sp ? process_sp->GetUnixSignals() : nullptr) {}

     : 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);
+
   if (this != &rhs)
     m_opaque_wp = rhs.m_opaque_wp;
   return *this;

   m_opaque_wp = signals_sp;
 }
 
-void SBUnixSignals::Clear() { m_opaque_wp.reset(); }
+void SBUnixSignals::Clear() {
+  LLDB_RECORD_METHOD_NO_ARGS(void, SBUnixSignals, Clear);
+
+  m_opaque_wp.reset();
+}
 
-bool SBUnixSignals::IsValid() const { return static_cast<bool>(GetSP()); }
+bool SBUnixSignals::IsValid() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBUnixSignals, IsValid);
+
+  return static_cast<bool>(GetSP());
+}
 
 const char *SBUnixSignals::GetSignalAsCString(int32_t signo) const {
+  LLDB_RECORD_METHOD_CONST(const char *, SBUnixSignals, GetSignalAsCString,
+                           (int32_t), signo);
+
   if (auto signals_sp = GetSP())
     return signals_sp->GetSignalAsCString(signo);
 

 }
 
 int32_t SBUnixSignals::GetSignalNumberFromName(const char *name) const {
+  LLDB_RECORD_METHOD_CONST(int32_t, SBUnixSignals, GetSignalNumberFromName,
+                           (const char *), name);
+
   if (auto signals_sp = GetSP())
     return signals_sp->GetSignalNumberFromName(name);
 

 }
 
 bool SBUnixSignals::GetShouldSuppress(int32_t signo) const {
+  LLDB_RECORD_METHOD_CONST(bool, SBUnixSignals, GetShouldSuppress, (int32_t),
+                           signo);
+
   if (auto signals_sp = GetSP())
     return signals_sp->GetShouldSuppress(signo);
 

 }
 
 bool SBUnixSignals::SetShouldSuppress(int32_t signo, bool value) {
+  LLDB_RECORD_METHOD(bool, SBUnixSignals, SetShouldSuppress, (int32_t, bool),
+                     signo, value);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   auto signals_sp = GetSP();
 

 }
 
 bool SBUnixSignals::GetShouldStop(int32_t signo) const {
+  LLDB_RECORD_METHOD_CONST(bool, SBUnixSignals, GetShouldStop, (int32_t),
+                           signo);
+
   if (auto signals_sp = GetSP())
     return signals_sp->GetShouldStop(signo);
 

 }
 
 bool SBUnixSignals::SetShouldStop(int32_t signo, bool value) {
+  LLDB_RECORD_METHOD(bool, SBUnixSignals, SetShouldStop, (int32_t, bool), signo,
+                     value);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   auto signals_sp = GetSP();
 

 }
 
 bool SBUnixSignals::GetShouldNotify(int32_t signo) const {
+  LLDB_RECORD_METHOD_CONST(bool, SBUnixSignals, GetShouldNotify, (int32_t),
+                           signo);
+
   if (auto signals_sp = GetSP())
     return signals_sp->GetShouldNotify(signo);
 

 }
 
 bool SBUnixSignals::SetShouldNotify(int32_t signo, bool value) {
+  LLDB_RECORD_METHOD(bool, SBUnixSignals, SetShouldNotify, (int32_t, bool),
+                     signo, value);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   auto signals_sp = GetSP();
 

 }
 
 int32_t SBUnixSignals::GetNumSignals() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(int32_t, SBUnixSignals, GetNumSignals);
+
   if (auto signals_sp = GetSP())
     return signals_sp->GetNumSignals();
 

 }
 
 int32_t SBUnixSignals::GetSignalAtIndex(int32_t index) const {
+  LLDB_RECORD_METHOD_CONST(int32_t, SBUnixSignals, GetSignalAtIndex, (int32_t),
+                           index);
+
   if (auto signals_sp = GetSP())
     return signals_sp->GetSignalAtIndex(index);
 

lldb/source/API/SBValue.cpp

 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBValue.h"
+#include "SBReproducerPrivate.h"
 
 #include "lldb/API/SBDeclaration.h"
 #include "lldb/API/SBStream.h"

   Status m_lock_error;
 };
 
-SBValue::SBValue() : m_opaque_sp() {}
+SBValue::SBValue() : m_opaque_sp() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBValue); }
 
-SBValue::SBValue(const lldb::ValueObjectSP &value_sp) { SetSP(value_sp); }
+SBValue::SBValue(const lldb::ValueObjectSP &value_sp) {
+  LLDB_RECORD_CONSTRUCTOR(SBValue, (const lldb::ValueObjectSP &), value_sp);
 
-SBValue::SBValue(const SBValue &rhs) { SetSP(rhs.m_opaque_sp); }
+  SetSP(value_sp);
+}
+
+SBValue::SBValue(const SBValue &rhs) {
+  LLDB_RECORD_CONSTRUCTOR(SBValue, (const lldb::SBValue &), rhs);
+
+  SetSP(rhs.m_opaque_sp);
+}
 
 SBValue &SBValue::operator=(const SBValue &rhs) {
+  LLDB_RECORD_METHOD(lldb::SBValue &,
+                     SBValue, operator=,(const lldb::SBValue &), rhs);
+
   if (this != &rhs) {
     SetSP(rhs.m_opaque_sp);
   }

 SBValue::~SBValue() {}
 
 bool SBValue::IsValid() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBValue, IsValid);
+
   // 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
   // (m_opaque_sp)" code in this file.

          m_opaque_sp->GetRootSP().get() != NULL;
 }
 
-void SBValue::Clear() { m_opaque_sp.reset(); }
+void SBValue::Clear() {
+  LLDB_RECORD_METHOD_NO_ARGS(void, SBValue, Clear);
+
+  m_opaque_sp.reset();
+}
 
 SBError SBValue::GetError() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBValue, GetError);
+
   SBError sb_error;
 
   ValueLocker locker;

     sb_error.SetErrorStringWithFormat("error: %s",
                                       locker.GetError().AsCString());
 
-  return sb_error;
+  return LLDB_RECORD_RESULT(sb_error);
 }
 
 user_id_t SBValue::GetID() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::user_id_t, SBValue, GetID);
+
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));
   if (value_sp)

 }
 
 const char *SBValue::GetName() {
+  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBValue, GetName);
+
   const char *name = NULL;
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));

 }
 
 const char *SBValue::GetTypeName() {
+  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBValue, GetTypeName);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   const char *name = NULL;
   ValueLocker locker;

 }
 
 const char *SBValue::GetDisplayTypeName() {
+  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBValue, GetDisplayTypeName);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   const char *name = NULL;
   ValueLocker locker;

 }
 
 size_t SBValue::GetByteSize() {
+  LLDB_RECORD_METHOD_NO_ARGS(size_t, SBValue, GetByteSize);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   size_t result = 0;
 

 }
 
 bool SBValue::IsInScope() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBValue, IsInScope);
+
   bool result = false;
 
   ValueLocker locker;

 }
 
 const char *SBValue::GetValue() {
+  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBValue, GetValue);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   const char *cstr = NULL;

 }
 
 ValueType SBValue::GetValueType() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::ValueType, SBValue, GetValueType);
+
   ValueType result = eValueTypeInvalid;
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));

 }
 
 const char *SBValue::GetObjectDescription() {
+  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBValue, GetObjectDescription);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   const char *cstr = NULL;
   ValueLocker locker;

 }
 
 const char *SBValue::GetTypeValidatorResult() {
+  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBValue, GetTypeValidatorResult);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   const char *cstr = NULL;
   ValueLocker locker;

 }
 
 SBType SBValue::GetType() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBValue, GetType);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   SBType sb_type;
   ValueLocker locker;

       log->Printf("SBValue(%p)::GetType => NULL",
                   static_cast<void *>(value_sp.get()));
   }
-  return sb_type;
+  return LLDB_RECORD_RESULT(sb_type);
 }
 
 bool SBValue::GetValueDidChange() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBValue, GetValueDidChange);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   bool result = false;
   ValueLocker locker;

 }
 
 const char *SBValue::GetSummary() {
+  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBValue, GetSummary);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   const char *cstr = NULL;
   ValueLocker locker;

 
 const char *SBValue::GetSummary(lldb::SBStream &stream,
                                 lldb::SBTypeSummaryOptions &options) {
+  LLDB_RECORD_METHOD(const char *, SBValue, GetSummary,
+                     (lldb::SBStream &, lldb::SBTypeSummaryOptions &), stream,
+                     options);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));

 }
 
 const char *SBValue::GetLocation() {
+  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBValue, GetLocation);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   const char *cstr = NULL;
   ValueLocker locker;

 
 // 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::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);
+
   bool success = false;
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));

 }
 
 lldb::SBTypeFormat SBValue::GetTypeFormat() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTypeFormat, SBValue, GetTypeFormat);
+
   lldb::SBTypeFormat format;
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));

         format.SetSP(format_sp);
     }
   }
-  return format;
+  return LLDB_RECORD_RESULT(format);
 }
 
 lldb::SBTypeSummary SBValue::GetTypeSummary() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTypeSummary, SBValue, GetTypeSummary);
+
   lldb::SBTypeSummary summary;
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));

         summary.SetSP(summary_sp);
     }
   }
-  return summary;
+  return LLDB_RECORD_RESULT(summary);
 }
 
 lldb::SBTypeFilter SBValue::GetTypeFilter() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTypeFilter, SBValue, GetTypeFilter);
+
   lldb::SBTypeFilter filter;
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));

       }
     }
   }
-  return filter;
+  return LLDB_RECORD_RESULT(filter);
 }
 
 #ifndef LLDB_DISABLE_PYTHON
 lldb::SBTypeSynthetic SBValue::GetTypeSynthetic() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTypeSynthetic, SBValue, GetTypeSynthetic);
+
   lldb::SBTypeSynthetic synthetic;
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));

       }
     }
   }
-  return synthetic;
+  return LLDB_RECORD_RESULT(synthetic);
 }
 #endif
 
 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::SBValue sb_value;
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));

       log->Printf("SBValue(%p)::CreateChildAtOffset => NULL",
                   static_cast<void *>(value_sp.get()));
   }
-  return sb_value;
+  return LLDB_RECORD_RESULT(sb_value);
 }
 
 lldb::SBValue SBValue::Cast(SBType type) {
+  LLDB_RECORD_METHOD(lldb::SBValue, SBValue, Cast, (lldb::SBType), type);
+
   lldb::SBValue sb_value;
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));

   if (value_sp && type_sp)
     sb_value.SetSP(value_sp->Cast(type_sp->GetCompilerType(false)),
                    GetPreferDynamicValue(), GetPreferSyntheticValue());
-  return sb_value;
+  return LLDB_RECORD_RESULT(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);
+
   SBExpressionOptions options;
   options.ref().SetKeepInMemory(true);
-  return CreateValueFromExpression(name, expression, options);
+  return LLDB_RECORD_RESULT(
+      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);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   lldb::SBValue sb_value;
   ValueLocker locker;

                   "expression=\"%s\") => NULL",
                   static_cast<void *>(value_sp.get()), name, expression);
   }
-  return sb_value;
+  return LLDB_RECORD_RESULT(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::SBValue sb_value;
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));

       log->Printf("SBValue(%p)::CreateValueFromAddress => NULL",
                   static_cast<void *>(value_sp.get()));
   }
-  return sb_value;
+  return LLDB_RECORD_RESULT(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::SBValue sb_value;
   lldb::ValueObjectSP new_value_sp;
   ValueLocker locker;

       log->Printf("SBValue(%p)::CreateValueFromData => NULL",
                   static_cast<void *>(value_sp.get()));
   }
-  return sb_value;
+  return LLDB_RECORD_RESULT(sb_value);
 }
 
 SBValue SBValue::GetChildAtIndex(uint32_t idx) {
+  LLDB_RECORD_METHOD(lldb::SBValue, SBValue, GetChildAtIndex, (uint32_t), idx);
+
   const bool can_create_synthetic = false;
   lldb::DynamicValueType use_dynamic = eNoDynamicValues;
   TargetSP target_sp;

   if (target_sp)
     use_dynamic = target_sp->GetPreferDynamicValue();
 
-  return GetChildAtIndex(idx, use_dynamic, can_create_synthetic);
+  return LLDB_RECORD_RESULT(
+      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::ValueObjectSP child_sp;
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 

                 static_cast<void *>(value_sp.get()), idx,
                 static_cast<void *>(value_sp.get()));
 
-  return sb_value;
+  return LLDB_RECORD_RESULT(sb_value);
 }
 
 uint32_t SBValue::GetIndexOfChildWithName(const char *name) {
+  LLDB_RECORD_METHOD(uint32_t, SBValue, GetIndexOfChildWithName, (const char *),
+                     name);
+
   uint32_t idx = UINT32_MAX;
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));

 }
 
 SBValue SBValue::GetChildMemberWithName(const char *name) {
+  LLDB_RECORD_METHOD(lldb::SBValue, SBValue, GetChildMemberWithName,
+                     (const char *), name);
+
   lldb::DynamicValueType use_dynamic_value = eNoDynamicValues;
   TargetSP target_sp;
   if (m_opaque_sp)

 
   if (target_sp)
     use_dynamic_value = target_sp->GetPreferDynamicValue();
-  return GetChildMemberWithName(name, use_dynamic_value);
+  return LLDB_RECORD_RESULT(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::ValueObjectSP child_sp;
   const ConstString str_name(name);
 

         static_cast<void *>(value_sp.get()), name,
         static_cast<void *>(value_sp.get()));
 
-  return sb_value;
+  return LLDB_RECORD_RESULT(sb_value);
 }
 
 lldb::SBValue SBValue::GetDynamicValue(lldb::DynamicValueType use_dynamic) {
+  LLDB_RECORD_METHOD(lldb::SBValue, SBValue, GetDynamicValue,
+                     (lldb::DynamicValueType), use_dynamic);
+
   SBValue value_sb;
   if (IsValid()) {
     ValueImplSP proxy_sp(new ValueImpl(m_opaque_sp->GetRootSP(), use_dynamic,
                                        m_opaque_sp->GetUseSynthetic()));
     value_sb.SetSP(proxy_sp);
   }
-  return value_sb;
+  return LLDB_RECORD_RESULT(value_sb);
 }
 
 lldb::SBValue SBValue::GetStaticValue() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBValue, SBValue, GetStaticValue);
+
   SBValue value_sb;
   if (IsValid()) {
     ValueImplSP proxy_sp(new ValueImpl(m_opaque_sp->GetRootSP(),

                                        m_opaque_sp->GetUseSynthetic()));
     value_sb.SetSP(proxy_sp);
   }
-  return value_sb;
+  return LLDB_RECORD_RESULT(value_sb);
 }
 
 lldb::SBValue SBValue::GetNonSyntheticValue() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBValue, SBValue, GetNonSyntheticValue);
+
   SBValue value_sb;
   if (IsValid()) {
     ValueImplSP proxy_sp(new ValueImpl(m_opaque_sp->GetRootSP(),
                                        m_opaque_sp->GetUseDynamic(), false));
     value_sb.SetSP(proxy_sp);
   }
-  return value_sb;
+  return LLDB_RECORD_RESULT(value_sb);
 }
 
 lldb::DynamicValueType SBValue::GetPreferDynamicValue() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::DynamicValueType, SBValue,
+                             GetPreferDynamicValue);
+
   if (!IsValid())
     return eNoDynamicValues;
   return m_opaque_sp->GetUseDynamic();
 }
 
 void SBValue::SetPreferDynamicValue(lldb::DynamicValueType use_dynamic) {
+  LLDB_RECORD_METHOD(void, SBValue, SetPreferDynamicValue,
+                     (lldb::DynamicValueType), use_dynamic);
+
   if (IsValid())
     return m_opaque_sp->SetUseDynamic(use_dynamic);
 }
 
 bool SBValue::GetPreferSyntheticValue() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBValue, GetPreferSyntheticValue);
+
   if (!IsValid())
     return false;
   return m_opaque_sp->GetUseSynthetic();
 }
 
 void SBValue::SetPreferSyntheticValue(bool use_synthetic) {
+  LLDB_RECORD_METHOD(void, SBValue, SetPreferSyntheticValue, (bool),
+                     use_synthetic);
+
   if (IsValid())
     return m_opaque_sp->SetUseSynthetic(use_synthetic);
 }
 
 bool SBValue::IsDynamic() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBValue, IsDynamic);
+
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));
   if (value_sp)

 }
 
 bool SBValue::IsSynthetic() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBValue, IsSynthetic);
+
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));
   if (value_sp)

 }
 
 bool SBValue::IsSyntheticChildrenGenerated() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBValue, IsSyntheticChildrenGenerated);
+
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));
   if (value_sp)

 }
 
 void SBValue::SetSyntheticChildrenGenerated(bool is) {
+  LLDB_RECORD_METHOD(void, SBValue, SetSyntheticChildrenGenerated, (bool), is);
+
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));
   if (value_sp)

 }
 
 lldb::SBValue SBValue::GetValueForExpressionPath(const char *expr_path) {
+  LLDB_RECORD_METHOD(lldb::SBValue, SBValue, GetValueForExpressionPath,
+                     (const char *), expr_path);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   lldb::ValueObjectSP child_sp;
   ValueLocker locker;

                 static_cast<void *>(value_sp.get()), expr_path,
                 static_cast<void *>(value_sp.get()));
 
-  return sb_value;
+  return LLDB_RECORD_RESULT(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);
+
   error.Clear();
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));

 }
 
 uint64_t SBValue::GetValueAsUnsigned(SBError &error, uint64_t fail_value) {
+  LLDB_RECORD_METHOD(uint64_t, SBValue, GetValueAsUnsigned,
+                     (lldb::SBError &, uint64_t), error, fail_value);
+
   error.Clear();
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));

 }
 
 int64_t SBValue::GetValueAsSigned(int64_t fail_value) {
+  LLDB_RECORD_METHOD(int64_t, SBValue, GetValueAsSigned, (int64_t), fail_value);
+
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));
   if (value_sp) {

 }
 
 uint64_t SBValue::GetValueAsUnsigned(uint64_t fail_value) {
+  LLDB_RECORD_METHOD(uint64_t, SBValue, GetValueAsUnsigned, (uint64_t),
+                     fail_value);
+
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));
   if (value_sp) {

 }
 
 bool SBValue::MightHaveChildren() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBValue, MightHaveChildren);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   bool has_children = false;
   ValueLocker locker;

 }
 
 bool SBValue::IsRuntimeSupportValue() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBValue, IsRuntimeSupportValue);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   bool is_support = false;
   ValueLocker locker;

   return is_support;
 }
 
-uint32_t SBValue::GetNumChildren() { return GetNumChildren(UINT32_MAX); }
+uint32_t SBValue::GetNumChildren() {
+  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBValue, GetNumChildren);
+
+  return GetNumChildren(UINT32_MAX);
+}
 
 uint32_t SBValue::GetNumChildren(uint32_t max) {
+  LLDB_RECORD_METHOD(uint32_t, SBValue, GetNumChildren, (uint32_t), max);
+
   uint32_t num_children = 0;
 
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));

 }
 
 SBValue SBValue::Dereference() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBValue, SBValue, Dereference);
+
   SBValue sb_value;
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));

                 static_cast<void *>(value_sp.get()),
                 static_cast<void *>(value_sp.get()));
 
-  return sb_value;
+  return LLDB_RECORD_RESULT(sb_value);
 }
 
 // Deprecated - please use GetType().IsPointerType() instead.
-bool SBValue::TypeIsPointerType() { return GetType().IsPointerType(); }
+bool SBValue::TypeIsPointerType() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBValue, TypeIsPointerType);
+
+  return GetType().IsPointerType();
+}
 
 void *SBValue::GetOpaqueType() {
+  LLDB_RECORD_METHOD_NO_ARGS(void *, SBValue, GetOpaqueType);
+
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));
   if (value_sp)

 }
 
 lldb::SBTarget SBValue::GetTarget() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTarget, SBValue, GetTarget);
+
   SBTarget sb_target;
   TargetSP target_sp;
   if (m_opaque_sp) {

                   static_cast<void *>(m_opaque_sp.get()),
                   static_cast<void *>(target_sp.get()));
   }
-  return sb_target;
+  return LLDB_RECORD_RESULT(sb_target);
 }
 
 lldb::SBProcess SBValue::GetProcess() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBProcess, SBValue, GetProcess);
+
   SBProcess sb_process;
   ProcessSP process_sp;
   if (m_opaque_sp) {

                   static_cast<void *>(m_opaque_sp.get()),
                   static_cast<void *>(process_sp.get()));
   }
-  return sb_process;
+  return LLDB_RECORD_RESULT(sb_process);
 }
 
 lldb::SBThread SBValue::GetThread() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBThread, SBValue, GetThread);
+
   SBThread sb_thread;
   ThreadSP thread_sp;
   if (m_opaque_sp) {

                   static_cast<void *>(m_opaque_sp.get()),
                   static_cast<void *>(thread_sp.get()));
   }
-  return sb_thread;
+  return LLDB_RECORD_RESULT(sb_thread);
 }
 
 lldb::SBFrame SBValue::GetFrame() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBFrame, SBValue, GetFrame);
+
   SBFrame sb_frame;
   StackFrameSP frame_sp;
   if (m_opaque_sp) {

                   static_cast<void *>(m_opaque_sp.get()),
                   static_cast<void *>(frame_sp.get()));
   }
-  return sb_frame;
+  return LLDB_RECORD_RESULT(sb_frame);
 }
 
 lldb::ValueObjectSP SBValue::GetSP(ValueLocker &locker) const {

 }
 
 lldb::ValueObjectSP SBValue::GetSP() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::ValueObjectSP, SBValue, GetSP);
+
   ValueLocker locker;
-  return GetSP(locker);
+  return LLDB_RECORD_RESULT(GetSP(locker));
 }
 
 void SBValue::SetSP(ValueImplSP impl_sp) { m_opaque_sp = impl_sp; }

 }
 
 bool SBValue::GetExpressionPath(SBStream &description) {
+  LLDB_RECORD_METHOD(bool, SBValue, GetExpressionPath, (lldb::SBStream &),
+                     description);
+
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));
   if (value_sp) {

 
 bool SBValue::GetExpressionPath(SBStream &description,
                                 bool qualify_cxx_base_classes) {
+  LLDB_RECORD_METHOD(bool, SBValue, GetExpressionPath, (lldb::SBStream &, bool),
+                     description, qualify_cxx_base_classes);
+
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));
   if (value_sp) {

   return false;
 }
 
-lldb::SBValue SBValue::EvaluateExpression(const char* expr) const {
+lldb::SBValue SBValue::EvaluateExpression(const char *expr) const {
+  LLDB_RECORD_METHOD_CONST(lldb::SBValue, SBValue, EvaluateExpression,
+                           (const char *), expr);
+
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));
   if (!value_sp)
-    return SBValue();
+    return LLDB_RECORD_RESULT(SBValue());
 
   lldb::TargetSP target_sp = value_sp->GetTargetSP();
   if (!target_sp)
-    return SBValue();
+    return LLDB_RECORD_RESULT(SBValue());
 
   lldb::SBExpressionOptions options;
   options.SetFetchDynamicValue(target_sp->GetPreferDynamicValue());
   options.SetUnwindOnError(true);
   options.SetIgnoreBreakpoints(true);
 
-  return EvaluateExpression(expr, options, nullptr);
+  return LLDB_RECORD_RESULT(EvaluateExpression(expr, options, nullptr));
 }
 
 lldb::SBValue
 SBValue::EvaluateExpression(const char *expr,
                             const SBExpressionOptions &options) const {
-  return EvaluateExpression(expr, options, nullptr);
+  LLDB_RECORD_METHOD_CONST(lldb::SBValue, SBValue, EvaluateExpression,
+                           (const char *, const lldb::SBExpressionOptions &),
+                           expr, options);
+
+  return LLDB_RECORD_RESULT(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);
+
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   if (!expr || expr[0] == '\0') {
     LLDB_LOG(log,
              "SBValue::EvaluateExpression called with an empty expression");
-    return SBValue();
+    return LLDB_RECORD_RESULT(SBValue());
   }
 
   LLDB_LOG(log, "SBValue()::EvaluateExpression (expr=\"{0}\")...", expr);

   if (!value_sp) {
     LLDB_LOG(log, "SBValue::EvaluateExpression () => error: could not "
                   "reconstruct value object for this SBValue");
-    return SBValue();
+    return LLDB_RECORD_RESULT(SBValue());
   }
 
   lldb::TargetSP target_sp = value_sp->GetTargetSP();

     LLDB_LOG(
         log,
         "SBValue::EvaluateExpression () => error: could not retrieve target");
-    return SBValue();
+    return LLDB_RECORD_RESULT(SBValue());
   }
 
   std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());

   if (!frame) {
     LLDB_LOG(log, "SBValue::EvaluateExpression () => error: could not retrieve "
                   "current stack frame");
-    return SBValue();
+    return LLDB_RECORD_RESULT(SBValue());
   }
 
   ValueObjectSP res_val_sp;

 
   SBValue result;
   result.SetSP(res_val_sp, options.GetFetchDynamicValue());
-  return result;
+  return LLDB_RECORD_RESULT(result);
 }
 
 bool SBValue::GetDescription(SBStream &description) {
+  LLDB_RECORD_METHOD(bool, SBValue, GetDescription, (lldb::SBStream &),
+                     description);
+
   Stream &strm = description.ref();
 
   ValueLocker locker;

 }
 
 lldb::Format SBValue::GetFormat() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::Format, SBValue, GetFormat);
+
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));
   if (value_sp)

 }
 
 void SBValue::SetFormat(lldb::Format format) {
+  LLDB_RECORD_METHOD(void, SBValue, SetFormat, (lldb::Format), format);
+
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));
   if (value_sp)

 }
 
 lldb::SBValue SBValue::AddressOf() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBValue, SBValue, AddressOf);
+
   SBValue sb_value;
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));

                 static_cast<void *>(value_sp.get()),
                 static_cast<void *>(value_sp.get()));
 
-  return sb_value;
+  return LLDB_RECORD_RESULT(sb_value);
 }
 
 lldb::addr_t SBValue::GetLoadAddress() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::addr_t, SBValue, GetLoadAddress);
+
   lldb::addr_t value = LLDB_INVALID_ADDRESS;
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));

 }
 
 lldb::SBAddress SBValue::GetAddress() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBAddress, SBValue, GetAddress);
+
   Address addr;
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));

                 (addr.GetSection() ? addr.GetSection()->GetName().GetCString()
                                    : "NULL"),
                 addr.GetOffset());
-  return SBAddress(new Address(addr));
+  return LLDB_RECORD_RESULT(SBAddress(new Address(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);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   lldb::SBData sb_data;
   ValueLocker locker;

                 static_cast<void *>(value_sp.get()), item_idx, item_count,
                 static_cast<void *>(sb_data.get()));
 
-  return sb_data;
+  return LLDB_RECORD_RESULT(sb_data);
 }
 
 lldb::SBData SBValue::GetData() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBData, SBValue, GetData);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   lldb::SBData sb_data;
   ValueLocker locker;

                 static_cast<void *>(value_sp.get()),
                 static_cast<void *>(sb_data.get()));
 
-  return sb_data;
+  return LLDB_RECORD_RESULT(sb_data);
 }
 
 bool SBValue::SetData(lldb::SBData &data, SBError &error) {
+  LLDB_RECORD_METHOD(bool, SBValue, SetData, (lldb::SBData &, lldb::SBError &),
+                     data, error);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));

 }
 
 lldb::SBDeclaration SBValue::GetDeclaration() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBDeclaration, SBValue, GetDeclaration);
+
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));
   SBDeclaration decl_sb;

     if (value_sp->GetDeclaration(decl))
       decl_sb.SetDeclaration(decl);
   }
-  return decl_sb;
+  return LLDB_RECORD_RESULT(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);
+
   SBWatchpoint sb_watchpoint;
 
   // If the SBValue is not valid, there's no point in even trying to watch it.

   if (value_sp && target_sp) {
     // Read and Write cannot both be false.
     if (!read && !write)
-      return sb_watchpoint;
+      return LLDB_RECORD_RESULT(sb_watchpoint);
 
     // If the value is not in scope, don't try and watch and invalid value
     if (!IsInScope())
-      return sb_watchpoint;
+      return LLDB_RECORD_RESULT(sb_watchpoint);
 
     addr_t addr = GetLoadAddress();
     if (addr == LLDB_INVALID_ADDRESS)
-      return sb_watchpoint;
+      return LLDB_RECORD_RESULT(sb_watchpoint);
     size_t byte_size = GetByteSize();
     if (byte_size == 0)
-      return sb_watchpoint;
+      return LLDB_RECORD_RESULT(sb_watchpoint);
 
     uint32_t watch_type = 0;
     if (read)

     error.SetErrorString("could not set watchpoint, a target is required");
   }
 
-  return sb_watchpoint;
+  return LLDB_RECORD_RESULT(sb_watchpoint);
 }
 
 // FIXME: Remove this method impl (as well as the decl in .h) once it is no

 // 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);
+
   SBError error;
-  return Watch(resolve_location, read, write, error);
+  return LLDB_RECORD_RESULT(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);
+
   SBWatchpoint sb_watchpoint;
   if (IsInScope() && GetType().IsPointerType())
     sb_watchpoint = Dereference().Watch(resolve_location, read, write, error);
-  return sb_watchpoint;
+  return LLDB_RECORD_RESULT(sb_watchpoint);
 }
 
 lldb::SBValue SBValue::Persist() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBValue, SBValue, Persist);
+
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));
   SBValue persisted_sb;
   if (value_sp) {
     persisted_sb.SetSP(value_sp->Persist());
   }
-  return persisted_sb;
+  return LLDB_RECORD_RESULT(persisted_sb);
 }

lldb/source/API/SBValueList.cpp

 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBValueList.h"
+#include "SBReproducerPrivate.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/API/SBValue.h"
 #include "lldb/Core/ValueObjectList.h"

   std::vector<lldb::SBValue> m_values;
 };
 
-SBValueList::SBValueList() : m_opaque_up() {}
+SBValueList::SBValueList() : m_opaque_up() {
+  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBValueList);
+}
 
 SBValueList::SBValueList(const SBValueList &rhs) : m_opaque_up() {
+  LLDB_RECORD_CONSTRUCTOR(SBValueList, (const lldb::SBValueList &), rhs);
+
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   if (rhs.IsValid())

 
 SBValueList::~SBValueList() {}
 
-bool SBValueList::IsValid() const { return (m_opaque_up != NULL); }
+bool SBValueList::IsValid() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBValueList, IsValid);
+
+  return (m_opaque_up != NULL);
+}
 
-void SBValueList::Clear() { m_opaque_up.reset(); }
+void SBValueList::Clear() {
+  LLDB_RECORD_METHOD_NO_ARGS(void, SBValueList, Clear);
+
+  m_opaque_up.reset();
+}
 
 const SBValueList &SBValueList::operator=(const SBValueList &rhs) {
+  LLDB_RECORD_METHOD(const lldb::SBValueList &,
+                     SBValueList, operator=,(const lldb::SBValueList &), rhs);
+
   if (this != &rhs) {
     if (rhs.IsValid())
       m_opaque_up.reset(new ValueListImpl(*rhs));

 const ValueListImpl &SBValueList::operator*() const { return *m_opaque_up; }
 
 void SBValueList::Append(const SBValue &val_obj) {
+  LLDB_RECORD_METHOD(void, SBValueList, Append, (const lldb::SBValue &),
+                     val_obj);
+
   CreateIfNeeded();
   m_opaque_up->Append(val_obj);
 }

 }
 
 void SBValueList::Append(const lldb::SBValueList &value_list) {
+  LLDB_RECORD_METHOD(void, SBValueList, Append, (const lldb::SBValueList &),
+                     value_list);
+
   if (value_list.IsValid()) {
     CreateIfNeeded();
     m_opaque_up->Append(*value_list);

 }
 
 SBValue SBValueList::GetValueAtIndex(uint32_t idx) const {
+  LLDB_RECORD_METHOD_CONST(lldb::SBValue, SBValueList, GetValueAtIndex,
+                           (uint32_t), idx);
+
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   // if (log)

                 static_cast<void *>(sb_value.GetSP().get()), sstr.GetData());
   }
 
-  return sb_value;
+  return LLDB_RECORD_RESULT(sb_value);
 }
 
 uint32_t SBValueList::GetSize() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBValueList, GetSize);
+
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   // if (log)

 }
 
 SBValue SBValueList::FindValueObjectByUID(lldb::user_id_t uid) {
+  LLDB_RECORD_METHOD(lldb::SBValue, SBValueList, FindValueObjectByUID,
+                     (lldb::user_id_t), uid);
+
   SBValue sb_value;
   if (m_opaque_up)
     sb_value = m_opaque_up->FindValueByUID(uid);
-  return sb_value;
+  return LLDB_RECORD_RESULT(sb_value);
 }
 
 SBValue SBValueList::GetFirstValueByName(const char *name) const {
+  LLDB_RECORD_METHOD_CONST(lldb::SBValue, SBValueList, GetFirstValueByName,
+                           (const char *), name);
+
   SBValue sb_value;
   if (m_opaque_up)
     sb_value = m_opaque_up->GetFirstValueByName(name);
-  return sb_value;
+  return LLDB_RECORD_RESULT(sb_value);
 }
 
 void *SBValueList::opaque_ptr() { return m_opaque_up.get(); }

lldb/source/API/SBVariablesOptions.cpp

 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBVariablesOptions.h"
+#include "SBReproducerPrivate.h"
 #include "lldb/API/SBTarget.h"
 #include "lldb/Target/Target.h"
 

 };
 
 SBVariablesOptions::SBVariablesOptions()
-    : m_opaque_up(new VariablesOptionsImpl()) {}
+    : m_opaque_up(new VariablesOptionsImpl()) {
+  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBVariablesOptions);
+}
 
 SBVariablesOptions::SBVariablesOptions(const SBVariablesOptions &options)
-    : m_opaque_up(new VariablesOptionsImpl(options.ref())) {}
+    : m_opaque_up(new VariablesOptionsImpl(options.ref())) {
+  LLDB_RECORD_CONSTRUCTOR(SBVariablesOptions,
+                          (const lldb::SBVariablesOptions &), options);
+}
 
 SBVariablesOptions &SBVariablesOptions::
 operator=(const SBVariablesOptions &options) {
+  LLDB_RECORD_METHOD(
+      lldb::SBVariablesOptions &,
+      SBVariablesOptions, operator=,(const lldb::SBVariablesOptions &),
+      options);
+
   m_opaque_up.reset(new VariablesOptionsImpl(options.ref()));
   return *this;
 }
 
 SBVariablesOptions::~SBVariablesOptions() = default;
 
-bool SBVariablesOptions::IsValid() const { return m_opaque_up != nullptr; }
+bool SBVariablesOptions::IsValid() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBVariablesOptions, IsValid);
+
+  return m_opaque_up != nullptr;
+}
 
 bool SBVariablesOptions::GetIncludeArguments() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBVariablesOptions,
+                                   GetIncludeArguments);
+
   return m_opaque_up->GetIncludeArguments();
 }
 
 void SBVariablesOptions::SetIncludeArguments(bool arguments) {
+  LLDB_RECORD_METHOD(void, SBVariablesOptions, SetIncludeArguments, (bool),
+                     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);
+
   return m_opaque_up->GetIncludeRecognizedArguments(target.GetSP());
 }
 
 void SBVariablesOptions::SetIncludeRecognizedArguments(bool arguments) {
+  LLDB_RECORD_METHOD(void, SBVariablesOptions, SetIncludeRecognizedArguments,
+                     (bool), arguments);
+
   m_opaque_up->SetIncludeRecognizedArguments(arguments);
 }
 
 bool SBVariablesOptions::GetIncludeLocals() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBVariablesOptions, GetIncludeLocals);
+
   return m_opaque_up->GetIncludeLocals();
 }
 
 void SBVariablesOptions::SetIncludeLocals(bool locals) {
+  LLDB_RECORD_METHOD(void, SBVariablesOptions, SetIncludeLocals, (bool),
+                     locals);
+
   m_opaque_up->SetIncludeLocals(locals);
 }
 
 bool SBVariablesOptions::GetIncludeStatics() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBVariablesOptions, GetIncludeStatics);
+
   return m_opaque_up->GetIncludeStatics();
 }
 
 void SBVariablesOptions::SetIncludeStatics(bool statics) {
+  LLDB_RECORD_METHOD(void, SBVariablesOptions, SetIncludeStatics, (bool),
+                     statics);
+
   m_opaque_up->SetIncludeStatics(statics);
 }
 
 bool SBVariablesOptions::GetInScopeOnly() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBVariablesOptions, GetInScopeOnly);
+
   return m_opaque_up->GetInScopeOnly();
 }
 
 void SBVariablesOptions::SetInScopeOnly(bool in_scope_only) {
+  LLDB_RECORD_METHOD(void, SBVariablesOptions, SetInScopeOnly, (bool),
+                     in_scope_only);
+
   m_opaque_up->SetInScopeOnly(in_scope_only);
 }
 
 bool SBVariablesOptions::GetIncludeRuntimeSupportValues() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBVariablesOptions,
+                                   GetIncludeRuntimeSupportValues);
+
   return m_opaque_up->GetIncludeRuntimeSupportValues();
 }
 
 void SBVariablesOptions::SetIncludeRuntimeSupportValues(
     bool runtime_support_values) {
+  LLDB_RECORD_METHOD(void, SBVariablesOptions, SetIncludeRuntimeSupportValues,
+                     (bool), 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);
+
   return m_opaque_up->GetUseDynamic();
 }
 
 void SBVariablesOptions::SetUseDynamic(lldb::DynamicValueType dynamic) {
+  LLDB_RECORD_METHOD(void, SBVariablesOptions, SetUseDynamic,
+                     (lldb::DynamicValueType), dynamic);
+
   m_opaque_up->SetUseDynamic(dynamic);
 }
 

lldb/source/API/SBWatchpoint.cpp

 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBWatchpoint.h"
+#include "SBReproducerPrivate.h"
 #include "lldb/API/SBAddress.h"
 #include "lldb/API/SBDebugger.h"
 #include "lldb/API/SBDefines.h"

 using namespace lldb;
 using namespace lldb_private;
 
-SBWatchpoint::SBWatchpoint() {}
+SBWatchpoint::SBWatchpoint() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBWatchpoint); }
 
 SBWatchpoint::SBWatchpoint(const lldb::WatchpointSP &wp_sp)
     : m_opaque_wp(wp_sp) {
+  LLDB_RECORD_CONSTRUCTOR(SBWatchpoint, (const lldb::WatchpointSP &), wp_sp);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   if (log) {

 }
 
 SBWatchpoint::SBWatchpoint(const SBWatchpoint &rhs)
-    : m_opaque_wp(rhs.m_opaque_wp) {}
+    : m_opaque_wp(rhs.m_opaque_wp) {
+  LLDB_RECORD_CONSTRUCTOR(SBWatchpoint, (const lldb::SBWatchpoint &), rhs);
+}
 
 const SBWatchpoint &SBWatchpoint::operator=(const SBWatchpoint &rhs) {
+  LLDB_RECORD_METHOD(const lldb::SBWatchpoint &,
+                     SBWatchpoint, operator=,(const lldb::SBWatchpoint &), rhs);
+
   m_opaque_wp = rhs.m_opaque_wp;
   return *this;
 }

 SBWatchpoint::~SBWatchpoint() {}
 
 watch_id_t SBWatchpoint::GetID() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::watch_id_t, SBWatchpoint, GetID);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   watch_id_t watch_id = LLDB_INVALID_WATCH_ID;

   return watch_id;
 }
 
-bool SBWatchpoint::IsValid() const { return bool(m_opaque_wp.lock()); }
+bool SBWatchpoint::IsValid() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBWatchpoint, IsValid);
+
+  return bool(m_opaque_wp.lock());
+}
 
 SBError SBWatchpoint::GetError() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBWatchpoint, GetError);
+
   SBError sb_error;
   lldb::WatchpointSP watchpoint_sp(GetSP());
   if (watchpoint_sp) {
     sb_error.SetError(watchpoint_sp->GetError());
   }
-  return sb_error;
+  return LLDB_RECORD_RESULT(sb_error);
 }
 
 int32_t SBWatchpoint::GetHardwareIndex() {
+  LLDB_RECORD_METHOD_NO_ARGS(int32_t, SBWatchpoint, GetHardwareIndex);
+
   int32_t hw_index = -1;
 
   lldb::WatchpointSP watchpoint_sp(GetSP());

 }
 
 addr_t SBWatchpoint::GetWatchAddress() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::addr_t, SBWatchpoint, GetWatchAddress);
+
   addr_t ret_addr = LLDB_INVALID_ADDRESS;
 
   lldb::WatchpointSP watchpoint_sp(GetSP());

 }
 
 size_t SBWatchpoint::GetWatchSize() {
+  LLDB_RECORD_METHOD_NO_ARGS(size_t, SBWatchpoint, GetWatchSize);
+
   size_t watch_size = 0;
 
   lldb::WatchpointSP watchpoint_sp(GetSP());

 }
 
 void SBWatchpoint::SetEnabled(bool enabled) {
+  LLDB_RECORD_METHOD(void, SBWatchpoint, SetEnabled, (bool), enabled);
+
   lldb::WatchpointSP watchpoint_sp(GetSP());
   if (watchpoint_sp) {
     Target &target = watchpoint_sp->GetTarget();

 }
 
 bool SBWatchpoint::IsEnabled() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBWatchpoint, IsEnabled);
+
   lldb::WatchpointSP watchpoint_sp(GetSP());
   if (watchpoint_sp) {
     std::lock_guard<std::recursive_mutex> guard(

 }
 
 uint32_t SBWatchpoint::GetHitCount() {
+  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBWatchpoint, GetHitCount);
+
   uint32_t count = 0;
   lldb::WatchpointSP watchpoint_sp(GetSP());
   if (watchpoint_sp) {

 }
 
 uint32_t SBWatchpoint::GetIgnoreCount() {
+  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBWatchpoint, GetIgnoreCount);
+
   lldb::WatchpointSP watchpoint_sp(GetSP());
   if (watchpoint_sp) {
     std::lock_guard<std::recursive_mutex> guard(

 }
 
 void SBWatchpoint::SetIgnoreCount(uint32_t n) {
+  LLDB_RECORD_METHOD(void, SBWatchpoint, SetIgnoreCount, (uint32_t), n);
+
   lldb::WatchpointSP watchpoint_sp(GetSP());
   if (watchpoint_sp) {
     std::lock_guard<std::recursive_mutex> guard(

 }
 
 const char *SBWatchpoint::GetCondition() {
+  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBWatchpoint, GetCondition);
+
   lldb::WatchpointSP watchpoint_sp(GetSP());
   if (watchpoint_sp) {
     std::lock_guard<std::recursive_mutex> guard(

 }
 
 void SBWatchpoint::SetCondition(const char *condition) {
+  LLDB_RECORD_METHOD(void, SBWatchpoint, SetCondition, (const char *),
+                     condition);
+
   lldb::WatchpointSP watchpoint_sp(GetSP());
   if (watchpoint_sp) {
     std::lock_guard<std::recursive_mutex> guard(

 
 bool SBWatchpoint::GetDescription(SBStream &description,
                                   DescriptionLevel level) {
+  LLDB_RECORD_METHOD(bool, SBWatchpoint, GetDescription,
+                     (lldb::SBStream &, lldb::DescriptionLevel), description,
+                     level);
+
   Stream &strm = description.ref();
 
   lldb::WatchpointSP watchpoint_sp(GetSP());

   return true;
 }
 
-void SBWatchpoint::Clear() { m_opaque_wp.reset(); }
+void SBWatchpoint::Clear() {
+  LLDB_RECORD_METHOD_NO_ARGS(void, SBWatchpoint, Clear);
 
-lldb::WatchpointSP SBWatchpoint::GetSP() const { return m_opaque_wp.lock(); }
+  m_opaque_wp.reset();
+}
+
+lldb::WatchpointSP SBWatchpoint::GetSP() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::WatchpointSP, SBWatchpoint, GetSP);
 
-void SBWatchpoint::SetSP(const lldb::WatchpointSP &sp) { m_opaque_wp = sp; }
+  return LLDB_RECORD_RESULT(m_opaque_wp.lock());
+}
+
+void SBWatchpoint::SetSP(const lldb::WatchpointSP &sp) {
+  LLDB_RECORD_METHOD(void, SBWatchpoint, SetSP, (const lldb::WatchpointSP &),
+                     sp);
+
+  m_opaque_wp = sp;
+}
 
 bool SBWatchpoint::EventIsWatchpointEvent(const lldb::SBEvent &event) {
+  LLDB_RECORD_STATIC_METHOD(bool, SBWatchpoint, EventIsWatchpointEvent,
+                            (const lldb::SBEvent &), event);
+
   return Watchpoint::WatchpointEventData::GetEventDataFromEvent(event.get()) !=
          NULL;
 }
 
 WatchpointEventType
 SBWatchpoint::GetWatchpointEventTypeFromEvent(const SBEvent &event) {
+  LLDB_RECORD_STATIC_METHOD(lldb::WatchpointEventType, SBWatchpoint,
+                            GetWatchpointEventTypeFromEvent,
+                            (const lldb::SBEvent &), event);
+
   if (event.IsValid())
     return Watchpoint::WatchpointEventData::GetWatchpointEventTypeFromEvent(
         event.GetSP());

 }
 
 SBWatchpoint SBWatchpoint::GetWatchpointFromEvent(const lldb::SBEvent &event) {
+  LLDB_RECORD_STATIC_METHOD(lldb::SBWatchpoint, SBWatchpoint,
+                            GetWatchpointFromEvent, (const lldb::SBEvent &),
+                            event);
+
   SBWatchpoint sb_watchpoint;
   if (event.IsValid())
     sb_watchpoint =
         Watchpoint::WatchpointEventData::GetWatchpointFromEvent(event.GetSP());
-  return sb_watchpoint;
+  return LLDB_RECORD_RESULT(sb_watchpoint);
 }