[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

 //===-- SBAddress.cpp -------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBAddress.h"
+#include "SBReproducerPrivate.h"
 #include "lldb/API/SBProcess.h"
 #include "lldb/API/SBSection.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/Core/Address.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Symbol/LineEntry.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/StreamString.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()) {
   if (lldb_object_ptr)
     ref() = *lldb_object_ptr;
 }
 
 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();
     else
       m_opaque_up.reset(new Address());
   }
   return *this;
 }
 
 bool lldb::operator==(const SBAddress &lhs, const SBAddress &rhs) {
   if (lhs.IsValid() && rhs.IsValid())
     return lhs.ref() == rhs.ref();
   return false;
 }
 
 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);
 }
 
 void SBAddress::SetAddress(const Address *lldb_object_ptr) {
   if (lldb_object_ptr)
     ref() = *lldb_object_ptr;
   else
     m_opaque_up.reset(new Address());
 }
 
 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
     return LLDB_INVALID_ADDRESS;
 }
 
 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;
   TargetSP target_sp(target.GetSP());
   if (target_sp) {
     if (m_opaque_up->IsValid()) {
       std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
       addr = m_opaque_up->GetLoadAddress(target_sp.get());
else
       log->Printf("SBAddress::GetLoadAddress (SBTarget(%p)) => 0x%" PRIx64,
                   static_cast<void *>(target_sp.get()), addr);
   }
 
   return addr;
 }
 
 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())
     *this = target.ResolveLoadAddress(load_addr);
   else
     m_opaque_up->Clear();
 
   // Check if we weren't were able to resolve a section offset address. If we
   // weren't it is ok, the load address might be a location on the stack or
   // heap, so we should just have an address with no section and a valid offset
   if (!m_opaque_up->IsValid())
     m_opaque_up->SetOffset(load_addr);
 }
 
 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) {
       m_opaque_up->SetOffset(addr_offset + offset);
       return true;
     }
   }
   return false;
 }
 
 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;
 }
 
 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::operator->() { return m_opaque_up.get(); }
 
 const Address *SBAddress::operator->() const { return m_opaque_up.get(); }
const Address &SBAddress::ref() const {
   // this function. In case you didn't we will assert and die to let you know.
   assert(m_opaque_up.get());
   return *m_opaque_up;
 }
 
 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();
   if (m_opaque_up->IsValid()) {
     m_opaque_up->Dump(&strm, NULL, Address::DumpStyleResolvedDescription,
                       Address::DumpStyleModuleWithFileAddress, 4);
     StreamString sstrm;
     //        m_opaque_up->Dump (&sstrm, NULL,
     //        Address::DumpStyleResolvedDescription, Address::DumpStyleInvalid,
     //        4);
     //        if (sstrm.GetData())
     //            strm.Printf (" (%s)", sstrm.GetData());
   } else
     strm.PutCString("No value");
 
   return true;
 }
 
 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;
 }
 
 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;
 }
 
 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;
 }
 
 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;
 }
 
 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;
 }
 
 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;
 }
 
 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;
 }

lldb/source/API/SBAttachInfo.cpp

 //===-- SBAttachInfo.cpp ----------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBAttachInfo.h"
 
+#include "SBReproducerPrivate.h"
 #include "lldb/API/SBFileSpec.h"
 #include "lldb/API/SBListener.h"
 #include "lldb/Target/Process.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);
   m_opaque_sp->SetAsync(async);
 }
 
 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;
 }
 
 SBAttachInfo::~SBAttachInfo() {}
 
 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
     m_opaque_sp->GetExecutableFile().Clear();
 }
 
 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
     m_opaque_sp->GetExecutableFile().Clear();
 }
 
 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);
+  return m_opaque_sp->GetUserID();
+}
 
-uint32_t SBAttachInfo::GetGroupID() { return m_opaque_sp->GetGroupID(); }
+uint32_t SBAttachInfo::GetGroupID() {
+  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBAttachInfo, GetGroupID);
+  return m_opaque_sp->GetGroupID();
+}
 
-bool SBAttachInfo::UserIDIsValid() { return m_opaque_sp->UserIDIsValid(); }
+bool SBAttachInfo::UserIDIsValid() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBAttachInfo, UserIDIsValid);
+  return m_opaque_sp->UserIDIsValid();
+}
 
-bool SBAttachInfo::GroupIDIsValid() { return m_opaque_sp->GroupIDIsValid(); }
+bool SBAttachInfo::GroupIDIsValid() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBAttachInfo, GroupIDIsValid);
+  return m_opaque_sp->GroupIDIsValid();
+}
 
-void SBAttachInfo::SetUserID(uint32_t uid) { m_opaque_sp->SetUserID(uid); }
+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) { m_opaque_sp->SetGroupID(gid); }
+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() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBListener, SBAttachInfo, GetListener);
+
   return 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

 //===-- SBBlock.cpp ---------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
+#include "SBReproducerPrivate.h"
+
 #include "lldb/API/SBBlock.h"
 #include "lldb/API/SBAddress.h"
 #include "lldb/API/SBFileSpec.h"
 #include "lldb/API/SBFrame.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/API/SBValue.h"
 #include "lldb/Core/AddressRange.h"
 #include "lldb/Core/ValueObjectVariable.h"
 #include "lldb/Symbol/Block.h"
 #include "lldb/Symbol/Function.h"
 #include "lldb/Symbol/SymbolContext.h"
 #include "lldb/Symbol/VariableList.h"
 #include "lldb/Target/StackFrame.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/Log.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();
     if (inlined_info) {
       Function *function = m_opaque_ptr->CalculateSymbolContextFunction();
       LanguageType language;
       if (function)
         language = function->GetLanguage();
       else
         language = lldb::eLanguageTypeUnknown;
       return inlined_info->GetName(language).AsCString(NULL);
     }
   }
   return NULL;
 }
 
 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 =
         m_opaque_ptr->GetInlinedFunctionInfo();
     if (inlined_info)
       sb_file.SetFileSpec(inlined_info->GetCallSite().GetFile());
   }
   return 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();
     if (inlined_info)
       return inlined_info->GetCallSite().GetLine();
   }
   return 0;
 }
 
 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();
     if (inlined_info)
       return inlined_info->GetCallSite().GetColumn();
   }
   return 0;
 }
 
 void SBBlock::AppendVariables(bool can_create, bool get_parent_variables,
                               lldb_private::VariableList *var_list) {
   if (IsValid()) {
     bool show_inline = true;
     m_opaque_ptr->AppendVariables(can_create, get_parent_variables, show_inline,
                                   [](Variable *) { return true; }, var_list);
   }
 }
 
 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;
 }
 
 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;
 }
 
 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;
 }
 
 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;
 }
 
 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) {
     lldb::user_id_t id = m_opaque_ptr->GetID();
     strm.Printf("Block: {id: %" PRIu64 "} ", id);
     if (IsInlined()) {
       strm.Printf(" (inlined, '%s') ", GetInlinedName());
     }
     lldb_private::SymbolContext sc;
     m_opaque_ptr->CalculateSymbolContext(&sc);
     if (sc.function) {
       m_opaque_ptr->DumpAddressRanges(
           &strm,
           sc.function->GetAddressRange().GetBaseAddress().GetFileAddress());
     }
   } else
     strm.PutCString("No value");
 
   return true;
 }
 
 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;
     if (m_opaque_ptr->GetRangeAtIndex(idx, range)) {
       sb_addr.ref() = range.GetBaseAddress();
     }
   }
   return 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;
     if (m_opaque_ptr->GetRangeAtIndex(idx, range)) {
       sb_addr.ref() = range.GetBaseAddress();
       sb_addr.ref().Slide(range.GetByteSize());
     }
   }
   return 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());
   }
 
   return UINT32_MAX;
 }
 
 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) {
     StackFrameSP frame_sp(frame.GetFrameSP());
     VariableListSP variable_list_sp(block->GetBlockVariableList(true));
 
     if (variable_list_sp) {
       const size_t num_variables = variable_list_sp->GetSize();
if (variable_list_sp) {
       }
     }
   }
   return value_list;
 }
 
 lldb::SBValueList SBBlock::GetVariables(lldb::SBTarget &target, bool arguments,
                                         bool locals, bool statics) {
+  LLDB_RECORD_METHOD(lldb::SBValueList, SBBlock, GetVariables,
+                     (lldb::SBTarget &, bool, bool, bool), target, arguments,
+                     locals, statics);
+
   Block *block = GetPtr();
 
   SBValueList value_list;
   if (block) {
     TargetSP target_sp(target.GetSP());
 
     VariableListSP variable_list_sp(block->GetBlockVariableList(true));
 

lldb/source/API/SBBreakpoint.cpp

 //===-- SBBreakpoint.cpp ----------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
+#include "SBReproducerPrivate.h"
+
 #include "lldb/API/SBBreakpoint.h"
 #include "lldb/API/SBBreakpointLocation.h"
 #include "lldb/API/SBDebugger.h"
 #include "lldb/API/SBEvent.h"
 #include "lldb/API/SBProcess.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/API/SBStringList.h"
 #include "lldb/API/SBThread.h"

 
 #include "lldb/lldb-enumerations.h"
 
 #include "llvm/ADT/STLExtras.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;
   BreakpointSP bkpt_sp = GetSP();
   if (bkpt_sp)
     break_id = bkpt_sp->GetID();
 
   LLDB_LOG(log, "breakpoint = {0}, id = {1}", bkpt_sp.get(), break_id);
   return break_id;
 }
 
 bool SBBreakpoint::IsValid() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBreakpoint, IsValid);
+
   BreakpointSP bkpt_sp = GetSP();
   if (!bkpt_sp)
     return false;
   else if (bkpt_sp->GetTarget().GetBreakpointByID(bkpt_sp->GetID()))
     return true;
   else
     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(
         bkpt_sp->GetTarget().GetAPIMutex());
     bkpt_sp->ClearAllBreakpointSites();
   }
 }
 
 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();
   if (bkpt_sp) {
     if (vm_addr != LLDB_INVALID_ADDRESS) {
       std::lock_guard<std::recursive_mutex> guard(
           bkpt_sp->GetTarget().GetAPIMutex());
       Address address;
       Target &target = bkpt_sp->GetTarget();
       if (!target.GetSectionLoadList().ResolveLoadAddress(vm_addr, address)) {
         address.SetRawAddress(vm_addr);
       }
       sb_bp_location.SetLocation(bkpt_sp->FindLocationByAddress(address));
     }
   }
   return sb_bp_location;
 }
 
 break_id_t SBBreakpoint::FindLocationIDByAddress(addr_t vm_addr) {
+  LLDB_RECORD_METHOD(lldb::break_id_t, SBBreakpoint, FindLocationIDByAddress,
+                     (lldb::addr_t), vm_addr);
+
   break_id_t break_id = LLDB_INVALID_BREAK_ID;
   BreakpointSP bkpt_sp = GetSP();
 
   if (bkpt_sp && vm_addr != LLDB_INVALID_ADDRESS) {
     std::lock_guard<std::recursive_mutex> guard(
         bkpt_sp->GetTarget().GetAPIMutex());
     Address address;
     Target &target = bkpt_sp->GetTarget();
     if (!target.GetSectionLoadList().ResolveLoadAddress(vm_addr, address)) {
       address.SetRawAddress(vm_addr);
     }
     break_id = bkpt_sp->FindLocationIDByAddress(address);
   }
 
   return break_id;
 }
 
 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();
 
   if (bkpt_sp) {
     std::lock_guard<std::recursive_mutex> guard(
         bkpt_sp->GetTarget().GetAPIMutex());
     sb_bp_location.SetLocation(bkpt_sp->FindLocationByID(bp_loc_id));
   }
 
   return 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();
 
   if (bkpt_sp) {
     std::lock_guard<std::recursive_mutex> guard(
         bkpt_sp->GetTarget().GetAPIMutex());
     sb_bp_location.SetLocation(bkpt_sp->GetLocationAtIndex(index));
   }
 
   return 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();
 
   LLDB_LOG(log, "breakpoint = {0}, enable = {1}", bkpt_sp.get(), enable);
 
   if (bkpt_sp) {
     std::lock_guard<std::recursive_mutex> guard(
         bkpt_sp->GetTarget().GetAPIMutex());
     bkpt_sp->SetEnabled(enable);
   }
 }
 
 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(
         bkpt_sp->GetTarget().GetAPIMutex());
     return bkpt_sp->IsEnabled();
   } else
     return false;
 }
 
 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();
 
   LLDB_LOG(log, "breakpoint = {0}, one_shot = {1}", bkpt_sp.get(), one_shot);
 
   if (bkpt_sp) {
     std::lock_guard<std::recursive_mutex> guard(
         bkpt_sp->GetTarget().GetAPIMutex());
     bkpt_sp->SetOneShot(one_shot);
   }
 }
 
 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(
         bkpt_sp->GetTarget().GetAPIMutex());
     return bkpt_sp->IsOneShot();
   } else
     return false;
 }
 
 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(
         bkpt_sp->GetTarget().GetAPIMutex());
     return bkpt_sp->IsInternal();
   } else
     return false;
 }
 
 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();
 
   LLDB_LOG(log, "breakpoint = {0}, count = {1}", bkpt_sp.get(), count);
 
   if (bkpt_sp) {
     std::lock_guard<std::recursive_mutex> guard(
         bkpt_sp->GetTarget().GetAPIMutex());
     bkpt_sp->SetIgnoreCount(count);
   }
 }
 
 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(
         bkpt_sp->GetTarget().GetAPIMutex());
     bkpt_sp->SetCondition(condition);
   }
 }
 
 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(
         bkpt_sp->GetTarget().GetAPIMutex());
     return bkpt_sp->GetConditionText();
   }
   return nullptr;
 }
 
 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(
         bkpt_sp->GetTarget().GetAPIMutex());
     bkpt_sp->SetAutoContinue(auto_continue);
   }
 }
 
 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(
         bkpt_sp->GetTarget().GetAPIMutex());
     return bkpt_sp->IsAutoContinue();
   }
   return false;
 }
 
 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) {
     std::lock_guard<std::recursive_mutex> guard(
         bkpt_sp->GetTarget().GetAPIMutex());
     count = bkpt_sp->GetHitCount();
   }
 
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   LLDB_LOG(log, "breakpoint = {0}, count = {1}", bkpt_sp.get(), count);
 
   return count;
 }
 
 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) {
     std::lock_guard<std::recursive_mutex> guard(
         bkpt_sp->GetTarget().GetAPIMutex());
     count = bkpt_sp->GetIgnoreCount();
   }
 
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   LLDB_LOG(log, "breakpoint = {0}, count = {1}", bkpt_sp.get(), count);
 
   return count;
 }
 
 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(
         bkpt_sp->GetTarget().GetAPIMutex());
     bkpt_sp->SetThreadID(tid);
   }
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   LLDB_LOG(log, "breakpoint = {0}, tid = {1:x}", bkpt_sp.get(), tid);
 }
 
 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) {
     std::lock_guard<std::recursive_mutex> guard(
         bkpt_sp->GetTarget().GetAPIMutex());
     tid = bkpt_sp->GetThreadID();
   }
 
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   LLDB_LOG(log, "breakpoint = {0}, tid = {1:x}", bkpt_sp.get(), tid);
   return tid;
 }
 
 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);
   if (bkpt_sp) {
     std::lock_guard<std::recursive_mutex> guard(
         bkpt_sp->GetTarget().GetAPIMutex());
     bkpt_sp->GetOptions()->GetThreadSpec()->SetIndex(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) {
     std::lock_guard<std::recursive_mutex> guard(
         bkpt_sp->GetTarget().GetAPIMutex());
     const ThreadSpec *thread_spec =
         bkpt_sp->GetOptions()->GetThreadSpecNoCreate();
     if (thread_spec != nullptr)
       thread_idx = thread_spec->GetIndex();
   }
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   LLDB_LOG(log, "breakpoint = {0}, index = {1}", bkpt_sp.get(), thread_idx);
 
   return thread_idx;
 }
 
 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);
 
   if (bkpt_sp) {
     std::lock_guard<std::recursive_mutex> guard(
         bkpt_sp->GetTarget().GetAPIMutex());
     bkpt_sp->GetOptions()->GetThreadSpec()->SetName(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) {
     std::lock_guard<std::recursive_mutex> guard(
         bkpt_sp->GetTarget().GetAPIMutex());
     const ThreadSpec *thread_spec =
         bkpt_sp->GetOptions()->GetThreadSpecNoCreate();
     if (thread_spec != nullptr)
       name = thread_spec->GetName();
   }
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   LLDB_LOG(log, "breakpoint = {0}, name = {1}", bkpt_sp.get(), name);
 
   return name;
 }
 
 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(),
            queue_name);
   if (bkpt_sp) {
     std::lock_guard<std::recursive_mutex> guard(
         bkpt_sp->GetTarget().GetAPIMutex());
     bkpt_sp->GetOptions()->GetThreadSpec()->SetQueueName(queue_name);
   }
 }
 
 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) {
     std::lock_guard<std::recursive_mutex> guard(
         bkpt_sp->GetTarget().GetAPIMutex());
     const ThreadSpec *thread_spec =
         bkpt_sp->GetOptions()->GetThreadSpecNoCreate();
     if (thread_spec)
       name = thread_spec->GetQueueName();
   }
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   LLDB_LOG(log, "breakpoint = {0}, name = {1}", bkpt_sp.get(), name);
 
   return name;
 }
 
 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) {
     std::lock_guard<std::recursive_mutex> guard(
         bkpt_sp->GetTarget().GetAPIMutex());
     num_resolved = bkpt_sp->GetNumResolvedLocations();
   }
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   LLDB_LOG(log, "breakpoint = {0}, num_resolved = {1}", bkpt_sp.get(),
            num_resolved);
   return num_resolved;
 }
 
 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) {
     std::lock_guard<std::recursive_mutex> guard(
         bkpt_sp->GetTarget().GetAPIMutex());
     num_locs = bkpt_sp->GetNumLocations();
   }
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   LLDB_LOG(log, "breakpoint = {0}, num_locs = {1}", bkpt_sp.get(), num_locs);
   return num_locs;
 }
 
 void SBBreakpoint::SetCommandLineCommands(SBStringList &commands) {
+  LLDB_RECORD_METHOD(void, SBBreakpoint, SetCommandLineCommands,
+                     (lldb::SBStringList &), commands);
+
   BreakpointSP bkpt_sp = GetSP();
   if (!bkpt_sp)
     return;
   if (commands.GetSize() == 0)
     return;
 
   std::lock_guard<std::recursive_mutex> guard(
       bkpt_sp->GetTarget().GetAPIMutex());
   std::unique_ptr<BreakpointOptions::CommandData> cmd_data_up(
       new BreakpointOptions::CommandData(*commands, eScriptLanguageNone));
 
   bkpt_sp->GetOptions()->SetCommandDataCallback(cmd_data_up);
 }
 
 bool SBBreakpoint::GetCommandLineCommands(SBStringList &commands) {
+  LLDB_RECORD_METHOD(bool, SBBreakpoint, GetCommandLineCommands,
+                     (lldb::SBStringList &), commands);
+
   BreakpointSP bkpt_sp = GetSP();
   if (!bkpt_sp)
     return false;
   StringList command_list;
   bool has_commands =
       bkpt_sp->GetOptions()->GetCommandLineCallbacks(command_list);
   if (has_commands)
     commands.AppendList(command_list);
   return has_commands;
 }
 
 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(
         bkpt_sp->GetTarget().GetAPIMutex());
     s.Printf("SBBreakpoint: id = %i, ", bkpt_sp->GetID());
     bkpt_sp->GetResolverDescription(s.get());
     bkpt_sp->GetFilterDescription(s.get());
     if (include_locations) {
       const size_t num_locations = bkpt_sp->GetNumLocations();
       s.Printf(", locations = %" PRIu64, (uint64_t)num_locations);
     }
     return true;
   }
   s.Printf("No value");
   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);
+
+  else {
 }
 
-
 void SBBreakpoint
   ::SetCallback(SBBreakpointHitCallback callback,
   void *baton) {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   BreakpointSP bkpt_sp = GetSP();
   LLDB_LOG(log, "breakpoint = {0}, callback = {1}, baton = {2}", bkpt_sp.get(),
            callback, baton);
 
   if (bkpt_sp) {
     std::lock_guard<std::recursive_mutex> guard(
         bkpt_sp->GetTarget().GetAPIMutex());
     BatonSP baton_sp(new SBBreakpointCallbackBaton(callback, baton));
     bkpt_sp->SetCallback(SBBreakpointCallbackBaton
       ::PrivateBreakpointHitCallback, baton_sp,
                          false);
   }
 }
 
 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(),
            callback_function_name);
 
   if (bkpt_sp) {
     std::lock_guard<std::recursive_mutex> guard(
         bkpt_sp->GetTarget().GetAPIMutex());
     BreakpointOptions *bp_options = bkpt_sp->GetOptions();
     bkpt_sp->GetTarget()
         .GetDebugger()
         .GetCommandInterpreter()
         .GetScriptInterpreter()
         ->SetBreakpointCommandCallbackFunction(bp_options,
                                                callback_function_name);
   }
 }
 
 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(),
            callback_body_text);
 
   SBError sb_error;
   if (bkpt_sp) {
     std::lock_guard<std::recursive_mutex> guard(
         bkpt_sp->GetTarget().GetAPIMutex());
     BreakpointOptions *bp_options = bkpt_sp->GetOptions();
     Status error =
         bkpt_sp->GetTarget()
             .GetDebugger()
             .GetCommandInterpreter()
             .GetScriptInterpreter()
             ->SetBreakpointCommandCallback(bp_options, callback_body_text);
     sb_error.SetError(error);
   } 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);
 
   if (bkpt_sp) {
     std::lock_guard<std::recursive_mutex> guard(
         bkpt_sp->GetTarget().GetAPIMutex());
     Status error; // Think I'm just going to swallow the error here, it's
                   // probably more annoying to have to provide it.
     bkpt_sp->GetTarget().AddNameToBreakpoint(bkpt_sp, new_name, error);
     if (error.Fail())
     {
       if (log)
-        log->Printf("Failed to add name: '%s' to breakpoint: %s", 
-            new_name, error.AsCString());
+        log->Printf("Failed to add name: '%s' to breakpoint: %s", new_name,
+                    error.AsCString());
       return false;
     }
   }
 
   return true;
 }
 
 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);
 
   if (bkpt_sp) {
     std::lock_guard<std::recursive_mutex> guard(
         bkpt_sp->GetTarget().GetAPIMutex());
-    bkpt_sp->GetTarget().RemoveNameFromBreakpoint(bkpt_sp, 
+    bkpt_sp->GetTarget().RemoveNameFromBreakpoint(bkpt_sp,
                                                   ConstString(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);
 
   if (bkpt_sp) {
     std::lock_guard<std::recursive_mutex> guard(
         bkpt_sp->GetTarget().GetAPIMutex());
     return bkpt_sp->MatchesName(name);
   }
 
   return false;
 }
 
 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());
 
   if (bkpt_sp) {
     std::lock_guard<std::recursive_mutex> guard(
         bkpt_sp->GetTarget().GetAPIMutex());
     std::vector<std::string> names_vec;
     bkpt_sp->GetNames(names_vec);
     for (std::string name : names_vec) {
       names.AppendString(name.c_str());
     }
   }
 }
 
 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());
   return eBreakpointEventTypeInvalidType;
 }
 
 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();
 }
 
 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;
 }
 
 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 =
         (Breakpoint::BreakpointEventData::GetNumBreakpointLocationsFromEvent(
             event.GetSP()));
   return 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();
   return false;
 }
 
 BreakpointSP SBBreakpoint::GetSP() const { return m_opaque_wp.lock(); }
 
 // This is simple collection of breakpoint id's and their target.
 class SBBreakpointListImpl {
 public:
   SBBreakpointListImpl(lldb::TargetSP target_sp) : m_target_wp() {
+    LLDB_RECORD_CONSTRUCTOR(SBBreakpointListImpl, (lldb::TargetSP), target_sp);
+
     if (target_sp && target_sp->IsValid())
       m_target_wp = target_sp;
   }
 
   ~SBBreakpointListImpl() = default;
 
   size_t GetSize() { return m_break_ids.size(); }
 
public:
   TargetSP GetTarget() { return m_target_wp.lock(); }
 
 private:
   std::vector<lldb::break_id_t> m_break_ids;
   TargetWP m_target_wp;
 };
 
 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
     return m_opaque_sp->GetSize();
 }
 
 SBBreakpoint SBBreakpointList::GetBreakpointAtIndex(size_t idx) {
+  LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBBreakpointList, GetBreakpointAtIndex,
+                     (size_t), idx);
+
   if (!m_opaque_sp)
     return SBBreakpoint();
 
   BreakpointSP bkpt_sp = m_opaque_sp->GetBreakpointAtIndex(idx);
   return 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();
   BreakpointSP bkpt_sp = m_opaque_sp->FindBreakpointByID(id);
   return 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)
     return;
   m_opaque_sp->Append(sb_bkpt.m_opaque_wp.lock());
 }
 
 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)
     return false;
   return m_opaque_sp->AppendIfUnique(sb_bkpt.GetSP());
 }
 
 void SBBreakpointList::Clear() {
+  LLDB_RECORD_METHOD_NO_ARGS(void, SBBreakpointList, Clear);
+
   if (m_opaque_sp)
     m_opaque_sp->Clear();
 }
 
 void SBBreakpointList::CopyToBreakpointIDList(
     lldb_private::BreakpointIDList &bp_id_list) {
   if (m_opaque_sp)
     m_opaque_sp->CopyToBreakpointIDList(bp_id_list);
 }

lldb/source/API/SBBreakpointLocation.cpp

 //===-- SBBreakpointLocation.cpp --------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
+#include "SBReproducerPrivate.h"
+
 #include "lldb/API/SBBreakpointLocation.h"
 #include "lldb/API/SBAddress.h"
 #include "lldb/API/SBDebugger.h"
 #include "lldb/API/SBDefines.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/API/SBStringList.h"
 
 #include "lldb/Breakpoint/Breakpoint.h"
 #include "lldb/Breakpoint/BreakpointLocation.h"
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/StreamFile.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Interpreter/ScriptInterpreter.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/ThreadSpec.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/Stream.h"
 #include "lldb/lldb-defines.h"
 #include "lldb/lldb-types.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) {
     SBStream sstr;
     GetDescription(sstr, lldb::eDescriptionLevelBrief);
     LLDB_LOG(log, "location = {0} ({1})", break_loc_sp.get(), sstr.GetData());
   }
 }
 
 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;
 }
 
 SBBreakpointLocation::~SBBreakpointLocation() {}
 
 BreakpointLocationSP SBBreakpointLocation::GetSP() const {
   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();
 }
 
 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();
 
   if (loc_sp) {
     std::lock_guard<std::recursive_mutex> guard(
         loc_sp->GetTarget().GetAPIMutex());
     ret_addr = loc_sp->GetLoadAddress();
   }
 
   return ret_addr;
 }
 
 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(
         loc_sp->GetTarget().GetAPIMutex());
     loc_sp->SetEnabled(enabled);
   }
 }
 
 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(
         loc_sp->GetTarget().GetAPIMutex());
     return loc_sp->IsEnabled();
   } else
     return false;
 }
 
 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(
         loc_sp->GetTarget().GetAPIMutex());
     return loc_sp->GetHitCount();
   } else
     return 0;
 }
 
 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(
         loc_sp->GetTarget().GetAPIMutex());
     return loc_sp->GetIgnoreCount();
   } else
     return 0;
 }
 
 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(
         loc_sp->GetTarget().GetAPIMutex());
     loc_sp->SetIgnoreCount(n);
   }
 }
 
 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(
         loc_sp->GetTarget().GetAPIMutex());
     loc_sp->SetCondition(condition);
   }
 }
 
 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(
         loc_sp->GetTarget().GetAPIMutex());
     return loc_sp->GetConditionText();
   }
   return NULL;
 }
 
 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(
         loc_sp->GetTarget().GetAPIMutex());
     loc_sp->SetAutoContinue(auto_continue);
   }
 }
 
 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(
         loc_sp->GetTarget().GetAPIMutex());
     return loc_sp->IsAutoContinue();
   }
   return false;
 }
 
 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(),
            callback_function_name);
 
   if (loc_sp) {
     std::lock_guard<std::recursive_mutex> guard(
         loc_sp->GetTarget().GetAPIMutex());
     BreakpointOptions *bp_options = loc_sp->GetLocationOptions();
     loc_sp->GetBreakpoint()
         .GetTarget()
         .GetDebugger()
         .GetCommandInterpreter()
         .GetScriptInterpreter()
         ->SetBreakpointCommandCallbackFunction(bp_options,
                                                callback_function_name);
   }
 }
 
 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(),
            callback_body_text);
 
   SBError sb_error;
   if (loc_sp) {
     std::lock_guard<std::recursive_mutex> guard(
         loc_sp->GetTarget().GetAPIMutex());
     BreakpointOptions *bp_options = loc_sp->GetLocationOptions();
     Status error =
         loc_sp->GetBreakpoint()
             .GetTarget()
             .GetDebugger()
             .GetCommandInterpreter()
             .GetScriptInterpreter()
             ->SetBreakpointCommandCallback(bp_options, callback_body_text);
     sb_error.SetError(error);
   } 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;
   if (commands.GetSize() == 0)
     return;
 
   std::lock_guard<std::recursive_mutex> guard(
       loc_sp->GetTarget().GetAPIMutex());
   std::unique_ptr<BreakpointOptions::CommandData> cmd_data_up(
       new BreakpointOptions::CommandData(*commands, eScriptLanguageNone));
 
   loc_sp->GetLocationOptions()->SetCommandDataCallback(cmd_data_up);
 }
 
 bool SBBreakpointLocation::GetCommandLineCommands(SBStringList &commands) {
+  LLDB_RECORD_METHOD(bool, SBBreakpointLocation, GetCommandLineCommands,
+                     (lldb::SBStringList &), commands);
+
   BreakpointLocationSP loc_sp = GetSP();
   if (!loc_sp)
     return false;
   StringList command_list;
   bool has_commands =
       loc_sp->GetLocationOptions()->GetCommandLineCallbacks(command_list);
   if (has_commands)
     commands.AppendList(command_list);
   return has_commands;
 }
 
 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(
         loc_sp->GetTarget().GetAPIMutex());
     loc_sp->SetThreadID(thread_id);
   }
 }
 
 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) {
     std::lock_guard<std::recursive_mutex> guard(
         loc_sp->GetTarget().GetAPIMutex());
     return loc_sp->GetThreadID();
   }
   return tid;
 }
 
 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(
         loc_sp->GetTarget().GetAPIMutex());
     loc_sp->SetThreadIndex(index);
   }
 }
 
 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) {
     std::lock_guard<std::recursive_mutex> guard(
         loc_sp->GetTarget().GetAPIMutex());
     return loc_sp->GetThreadIndex();
   }
   return thread_idx;
 }
 
 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(
         loc_sp->GetTarget().GetAPIMutex());
     loc_sp->SetThreadName(thread_name);
   }
 }
 
 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(
         loc_sp->GetTarget().GetAPIMutex());
     return loc_sp->GetThreadName();
   }
   return NULL;
 }
 
 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(
         loc_sp->GetTarget().GetAPIMutex());
     loc_sp->SetQueueName(queue_name);
   }
 }
 
 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(
         loc_sp->GetTarget().GetAPIMutex());
     loc_sp->GetQueueName();
   }
   return NULL;
 }
 
 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(
         loc_sp->GetTarget().GetAPIMutex());
     return loc_sp->IsResolved();
   }
   return false;
 }
 
 void SBBreakpointLocation::SetLocation(
     const lldb::BreakpointLocationSP &break_loc_sp) {
   // Uninstall the callbacks?
   m_opaque_wp = break_loc_sp;
 }
 
 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();
 
   if (loc_sp) {
     std::lock_guard<std::recursive_mutex> guard(
         loc_sp->GetTarget().GetAPIMutex());
     loc_sp->GetDescription(&strm, level);
     strm.EOL();
   } else
     strm.PutCString("No value");
 
   return true;
 }
 
 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(
         loc_sp->GetTarget().GetAPIMutex());
     return loc_sp->GetID();
   } else
     return LLDB_INVALID_BREAK_ID;
 }
 
 SBBreakpoint SBBreakpointLocation::GetBreakpoint() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBBreakpoint, SBBreakpointLocation,
+                             GetBreakpoint);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   BreakpointLocationSP loc_sp = GetSP();
 
   SBBreakpoint sb_bp;
   if (loc_sp) {
     std::lock_guard<std::recursive_mutex> guard(
         loc_sp->GetTarget().GetAPIMutex());
     sb_bp = loc_sp->GetBreakpoint().shared_from_this();

lldb/source/API/SBBreakpointName.cpp

 //===-- SBBreakpointName.cpp ----------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
+#include "SBReproducerPrivate.h"
+
 #include "lldb/API/SBBreakpointName.h"
 #include "lldb/API/SBDebugger.h"
 #include "lldb/API/SBError.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/API/SBStringList.h"
 #include "lldb/API/SBTarget.h"
 
 #include "lldb/Breakpoint/BreakpointName.h"

 using namespace lldb;
 using namespace lldb_private;
 
 namespace lldb
 {
 class SBBreakpointNameImpl {
 public:
   SBBreakpointNameImpl(TargetSP target_sp, const char *name) {
+
     if (!name || name[0] == '\0')
       return;
     m_name.assign(name);
     
     if (!target_sp)
       return;
     
     m_target_wp = target_sp;
   }
 
   SBBreakpointNameImpl(SBTarget &sb_target, const char *name);
   bool operator==(const SBBreakpointNameImpl &rhs);
   bool operator!=(const SBBreakpointNameImpl &rhs);
 
   // For now we take a simple approach and only keep the name, and relook up
   // the location when we need it.
   
   TargetSP GetTarget() const {
+
     return m_target_wp.lock();
   }
   
   const char *GetName() const {
+
     return m_name.c_str();
   }
   
   bool IsValid() const {
+
     return !m_name.empty() && m_target_wp.lock();
   }
 
   lldb_private::BreakpointName *GetBreakpointName() const;
 
 private:
   TargetWP m_target_wp;
   std::string m_name;
 };
 
 SBBreakpointNameImpl::SBBreakpointNameImpl(SBTarget &sb_target,
                                            const char *name) {
+  LLDB_RECORD_CONSTRUCTOR(SBBreakpointNameImpl,
+                          (lldb::SBTarget &, const char *), sb_target, name);
+  LLDB_RECORD_CONSTRUCTOR(SBBreakpointNameImpl,
+                          (lldb::SBTarget &, const char *), sb_target, name);
+
   if (!name || name[0] == '\0')
     return;
   m_name.assign(name);
 
   if (!sb_target.IsValid())
     return;
 
   TargetSP target_sp = sb_target.GetSP();
lldb_private::BreakpointName *SBBreakpointNameImpl::GetBreakpointName() const {
   if (!target_sp)
     return nullptr;
   Status error;
   return target_sp->FindBreakpointName(ConstString(m_name), true, error);
 }
 
 } // 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();
   if (!bp_name)
     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;
   }
   BreakpointSP bkpt_sp = sb_bkpt.GetSP();
   Target &target = bkpt_sp->GetTarget();
 
   m_impl_up.reset(new SBBreakpointNameImpl(target.shared_from_this(), name));
   
   // Call FindBreakpointName here to make sure the name is valid, reset if not:
   BreakpointName *bp_name = GetBreakpointName();
   if (!bp_name) {
     m_impl_up.reset();
     return;
   }
   
   // Now copy over the breakpoint's options:
   target.ConfigureBreakpointName(*bp_name, *bkpt_sp->GetOptions(),
                                  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
     m_impl_up.reset(new SBBreakpointNameImpl(rhs.m_impl_up->GetTarget(),
                                              rhs.m_impl_up->GetName()));
 }
 
 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;
   }
   
   m_impl_up.reset(new SBBreakpointNameImpl(rhs.m_impl_up->GetTarget(),
                                            rhs.m_impl_up->GetName()));
   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();
   if (!bp_name)
     return;
  
   LLDB_LOG(log, "Name: {0} enabled: {1}\n", bp_name->GetName(), enable);
   std::lock_guard<std::recursive_mutex> guard(
void SBBreakpointName::UpdateName(BreakpointName &bp_name) {
   TargetSP target_sp = m_impl_up->GetTarget();
   if (!target_sp)
     return;
   target_sp->ApplyNameToBreakpoints(bp_name);
 
 }
 
 bool SBBreakpointName::IsEnabled() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBBreakpointName, IsEnabled);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   
   BreakpointName *bp_name = GetBreakpointName();
   if (!bp_name)
     return false;
  
   LLDB_LOG(log, "Name: {0}\n", bp_name->GetName());
   std::lock_guard<std::recursive_mutex> guard(
         m_impl_up->GetTarget()->GetAPIMutex());
 
   return bp_name->GetOptions().IsEnabled();
 }
 
 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();
   if (!bp_name)
     return;
  
   LLDB_LOG(log, "Name: {0} one_shot: {1}\n", bp_name->GetName(), one_shot);
   std::lock_guard<std::recursive_mutex> guard(
         m_impl_up->GetTarget()->GetAPIMutex());
 
   bp_name->GetOptions().SetOneShot(one_shot);
   UpdateName(*bp_name);
 }
 
 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();
   if (!bp_name)
     return false;
  
   LLDB_LOG(log, "Name: {0}\n", bp_name->GetName());
   std::lock_guard<std::recursive_mutex> guard(
         m_impl_up->GetTarget()->GetAPIMutex());
 
   return bp_name->GetOptions().IsOneShot();
 }
 
 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();
   if (!bp_name)
     return;
  
   LLDB_LOG(log, "Name: {0} one_shot: {1}\n", bp_name->GetName(), count);
   std::lock_guard<std::recursive_mutex> guard(
         m_impl_up->GetTarget()->GetAPIMutex());
 
   bp_name->GetOptions().SetIgnoreCount(count);
   UpdateName(*bp_name);
 }
 
 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();
   if (!bp_name)
     return false;
  
   LLDB_LOG(log, "Name: {0}\n", bp_name->GetName());
   std::lock_guard<std::recursive_mutex> guard(
         m_impl_up->GetTarget()->GetAPIMutex());
 
   return bp_name->GetOptions().GetIgnoreCount();
 }
 
 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();
   if (!bp_name)
     return;
  
   LLDB_LOG(log, "Name: {0} one_shot: {1}\n", bp_name->GetName(),
           condition ? condition : "<NULL>");
   
   std::lock_guard<std::recursive_mutex> guard(
         m_impl_up->GetTarget()->GetAPIMutex());
 
   bp_name->GetOptions().SetCondition(condition);
   UpdateName(*bp_name);
 }
 
 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();
   if (!bp_name)
     return nullptr;
  
   LLDB_LOG(log, "Name: {0}\n", bp_name->GetName());
   std::lock_guard<std::recursive_mutex> guard(
         m_impl_up->GetTarget()->GetAPIMutex());
 
   return bp_name->GetOptions().GetConditionText();
 }
 
 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();
   if (!bp_name)
     return;
  
   LLDB_LOG(log, "Name: {0} auto-continue: {1}\n", bp_name->GetName(), auto_continue);
   
   std::lock_guard<std::recursive_mutex> guard(
         m_impl_up->GetTarget()->GetAPIMutex());
 
   bp_name->GetOptions().SetAutoContinue(auto_continue);
   UpdateName(*bp_name);
 }
 
 bool SBBreakpointName::GetAutoContinue() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBBreakpointName, GetAutoContinue);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   
   BreakpointName *bp_name = GetBreakpointName();
   if (!bp_name)
     return false;
  
   LLDB_LOG(log, "Name: {0}\n", bp_name->GetName());
   std::lock_guard<std::recursive_mutex> guard(
         m_impl_up->GetTarget()->GetAPIMutex());
 
   return bp_name->GetOptions().IsAutoContinue();
 }
 
 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();
   if (!bp_name)
     return;
  
   LLDB_LOG(log, "Name: {0} tid: {1:x}\n", bp_name->GetName(), tid);
   
   std::lock_guard<std::recursive_mutex> guard(
         m_impl_up->GetTarget()->GetAPIMutex());
 
   bp_name->GetOptions().SetThreadID(tid);
   UpdateName(*bp_name);
 }
 
 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();
   if (!bp_name)
     return LLDB_INVALID_THREAD_ID;
  
   LLDB_LOG(log, "Name: {0}\n", bp_name->GetName());
   std::lock_guard<std::recursive_mutex> guard(
         m_impl_up->GetTarget()->GetAPIMutex());
 
   return bp_name->GetOptions().GetThreadSpec()->GetTID();
 }
 
 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();
   if (!bp_name)
     return;
  
   LLDB_LOG(log, "Name: {0} thread index: {1}\n", bp_name->GetName(), index);
   
   std::lock_guard<std::recursive_mutex> guard(
         m_impl_up->GetTarget()->GetAPIMutex());
 
   bp_name->GetOptions().GetThreadSpec()->SetIndex(index);
   UpdateName(*bp_name);
 }
 
 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();
   if (!bp_name)
     return LLDB_INVALID_THREAD_ID;
  
   LLDB_LOG(log, "Name: {0}\n", bp_name->GetName());
   std::lock_guard<std::recursive_mutex> guard(
         m_impl_up->GetTarget()->GetAPIMutex());
 
   return bp_name->GetOptions().GetThreadSpec()->GetIndex();
 }
 
 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();
   if (!bp_name)
     return;
  
   LLDB_LOG(log, "Name: {0} thread name: {1}\n", bp_name->GetName(), thread_name);
   
   std::lock_guard<std::recursive_mutex> guard(
         m_impl_up->GetTarget()->GetAPIMutex());
 
   bp_name->GetOptions().GetThreadSpec()->SetName(thread_name);
   UpdateName(*bp_name);
 }
 
 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();
   if (!bp_name)
     return nullptr;
  
   LLDB_LOG(log, "Name: {0}\n", bp_name->GetName());
   std::lock_guard<std::recursive_mutex> guard(
         m_impl_up->GetTarget()->GetAPIMutex());
 
   return bp_name->GetOptions().GetThreadSpec()->GetName();
 }
 
 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();
   if (!bp_name)
     return;
  
   LLDB_LOG(log, "Name: {0} queue name: {1}\n", bp_name->GetName(), queue_name);
   
   std::lock_guard<std::recursive_mutex> guard(
         m_impl_up->GetTarget()->GetAPIMutex());
 
   bp_name->GetOptions().GetThreadSpec()->SetQueueName(queue_name);
   UpdateName(*bp_name);
 }
 
 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();
   if (!bp_name)
     return nullptr;
  
   LLDB_LOG(log, "Name: {0}\n", bp_name->GetName());
   std::lock_guard<std::recursive_mutex> guard(
         m_impl_up->GetTarget()->GetAPIMutex());
 
   return bp_name->GetOptions().GetThreadSpec()->GetQueueName();
 }
 
 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)
     return;
   if (commands.GetSize() == 0)
     return;
 
   LLDB_LOG(log, "Name: {0} commands\n", bp_name->GetName());
 
   std::lock_guard<std::recursive_mutex> guard(
         m_impl_up->GetTarget()->GetAPIMutex());
   std::unique_ptr<BreakpointOptions::CommandData> cmd_data_up(
       new BreakpointOptions::CommandData(*commands, eScriptLanguageNone));
 
   bp_name->GetOptions().SetCommandDataCallback(cmd_data_up);
   UpdateName(*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();
   if (!bp_name)
     return false;
  
   LLDB_LOG(log, "Name: {0}\n", bp_name->GetName());
   StringList command_list;
   bool has_commands =
       bp_name->GetOptions().GetCommandLineCallbacks(command_list);
   if (has_commands)
     commands.AppendList(command_list);
   return has_commands;
 }
 
 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();
   if (!bp_name)
     return "";
  
   LLDB_LOG(log, "Help: {0}\n", bp_name->GetHelp());
   return bp_name->GetHelp();
 }
 
 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)
     return;
 
   LLDB_LOG(log, "Name: {0} help: {1}\n", bp_name->GetName(), help_string);
 
   std::lock_guard<std::recursive_mutex> guard(
         m_impl_up->GetTarget()->GetAPIMutex());
   bp_name->SetHelp(help_string);
 }
 
 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();
   if (!bp_name)
   {
     s.Printf("No value");
     return false;
   }
bp_name->GetOptions().SetCallback(SBBreakpointCallbackBaton
                                        ::PrivateBreakpointHitCallback,
                                     baton_sp,
                                     false);
   UpdateName(*bp_name);
 }
 
 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();
   if (!bp_name)
     return;
  
   LLDB_LOG(log, "Name: {0} callback: {1}\n", bp_name->GetName(),
            callback_function_name);
   
   std::lock_guard<std::recursive_mutex> guard(
         m_impl_up->GetTarget()->GetAPIMutex());
 
   BreakpointOptions &bp_options = bp_name->GetOptions();
   m_impl_up->GetTarget()
       ->GetDebugger()
       .GetCommandInterpreter()
       .GetScriptInterpreter()
       ->SetBreakpointCommandCallbackFunction(&bp_options,
                                              callback_function_name);
   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);
   
   std::lock_guard<std::recursive_mutex> guard(
         m_impl_up->GetTarget()->GetAPIMutex());
 
   BreakpointOptions &bp_options = bp_name->GetOptions();
   Status error =
       m_impl_up->GetTarget()
           ->GetDebugger()
           .GetCommandInterpreter()
           .GetScriptInterpreter()
           ->SetBreakpointCommandCallback(&bp_options, callback_body_text);
   sb_error.SetError(error);
   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();
   if (!bp_name)
     return;
   if (log)
     log->Printf("Setting allow list to %u for %s.", value, 
                 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();
   if (!bp_name)
     return;
   if (log)
     log->Printf("Setting allow delete to %u for %s.", value, 
                 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();
   if (!bp_name)
     return;
   if (log)
     log->Printf("Setting allow disable to %u for %s.", value, 
                 bp_name->GetName().AsCString());

lldb/source/API/SBBreakpointOptionCommon.cpp

 //===-- SBBreakpointName.cpp ----------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
+#include "SBReproducerPrivate.h"
+
 #include "lldb/API/SBBreakpointName.h"
 #include "lldb/API/SBBreakpointLocation.h"
 #include "lldb/API/SBDebugger.h"
 #include "lldb/API/SBEvent.h"
 #include "lldb/API/SBProcess.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/API/SBStringList.h"
 #include "lldb/API/SBThread.h"

lldb/source/API/SBBroadcaster.cpp

 //===-- SBBroadcaster.cpp ---------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
+#include "SBReproducerPrivate.h"
+
 #include "lldb/Utility/Broadcaster.h"
 #include "lldb/Utility/Log.h"
 
 #include "lldb/API/SBBroadcaster.h"
 #include "lldb/API/SBEvent.h"
 #include "lldb/API/SBListener.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(lldb_private::Broadcaster *broadcaster, bool owns)
     : m_opaque_sp(owns ? broadcaster : NULL), m_opaque_ptr(broadcaster) {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   LLDB_LOGV(log, "(broadcaster={0}, owns={1}) => SBBroadcaster({2})",
             broadcaster, owns, 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;
   }
   return *this;
 }
 
 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)
     log->Printf("SBBroadcaster(%p)::BroadcastEventByType (event_type=0x%8.8x, "
                 "unique=%i)",
                 static_cast<void *>(m_opaque_ptr), event_type, unique);
 
   if (m_opaque_ptr == NULL)
     return;
 
   if (unique)
     m_opaque_ptr->BroadcastEventIfUnique(event_type);
   else
     m_opaque_ptr->BroadcastEvent(event_type);
 }
 
 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)
     log->Printf(
         "SBBroadcaster(%p)::BroadcastEventByType (SBEvent(%p), unique=%i)",
         static_cast<void *>(m_opaque_ptr), static_cast<void *>(event.get()),
         unique);
 
   if (m_opaque_ptr == NULL)
     return;
 
   EventSP event_sp = event.GetSP();
   if (unique)
     m_opaque_ptr->BroadcastEventIfUnique(event_sp);
   else
     m_opaque_ptr->BroadcastEvent(event_sp);
 }
 
 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 "
                 "(SBListener(%p), event_mask=0x%8.8x)",
                 static_cast<void *>(m_opaque_ptr),
                 static_cast<void *>(listener.get()), requested_events);
   if (m_opaque_ptr)
     m_opaque_ptr->AddInitialEventsToListener(listener.m_opaque_sp,
                                              requested_events);
 }
 
 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;
 }
 
 Broadcaster *SBBroadcaster::get() const { return m_opaque_ptr; }
 
 void SBBroadcaster::reset(Broadcaster *broadcaster, bool owns) {
   if (owns)
     m_opaque_sp.reset(broadcaster);
   else
     m_opaque_sp.reset();
   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

 //===-- SBCommandInterpreter.cpp --------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
+#include "SBReproducerPrivate.h"
 #include "lldb/lldb-types.h"
 
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Interpreter/CommandObjectMultiword.h"
 #include "lldb/Interpreter/CommandReturnObject.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/Listener.h"
 
 #include "lldb/API/SBBroadcaster.h"
 #include "lldb/API/SBCommandInterpreter.h"
 #include "lldb/API/SBCommandReturnObject.h"
 #include "lldb/API/SBEvent.h"
 #include "lldb/API/SBExecutionContext.h"
 #include "lldb/API/SBListener.h"
 #include "lldb/API/SBProcess.h"
+#include "lldb/API/SBReproducer.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/API/SBStringList.h"
 #include "lldb/API/SBTarget.h"
 
 #include <memory>
 
 using namespace lldb;
 using namespace lldb_private;
 
 SBCommandInterpreterRunOptions::SBCommandInterpreterRunOptions() {
+  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBCommandInterpreterRunOptions);
+
   m_opaque_up.reset(new CommandInterpreterRunOptions());
+  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBCommandInterpreterRunOptions);
 }
 
 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);
 }
 
 lldb_private::CommandInterpreterRunOptions *
 SBCommandInterpreterRunOptions::get() const {
   return m_opaque_up.get();
 }
 
 lldb_private::CommandInterpreterRunOptions &
 SBCommandInterpreterRunOptions::ref() const {
   return *m_opaque_up;
 }
 
 class CommandPluginInterfaceImplementation : public CommandObjectParsed {
 public:
   CommandPluginInterfaceImplementation(CommandInterpreter &interpreter,
                                        const char *name,
                                        lldb::SBCommandPluginInterface *backend,
                                        const char *help = nullptr,
                                        const char *syntax = nullptr,
                                        uint32_t flags = 0)
       : CommandObjectParsed(interpreter, name, help, syntax, flags),
-        m_backend(backend) {}
+        m_backend(backend) {
+    LLDB_RECORD_CONSTRUCTOR(CommandPluginInterfaceImplementation,
+                            (lldb_private::CommandInterpreter &, const char *,
+                             lldb::SBCommandPluginInterface *, const char *,
+                             const char *, uint32_t),
+                            interpreter, name, backend, help, syntax, flags);
+  }
 
-  bool IsRemovable() const override { return true; }
+  bool IsRemovable() const override {
+    LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, CommandPluginInterfaceImplementation,
+                                     IsRemovable);
+    return true;
+  }
 
 protected:
   bool DoExecute(Args &command, CommandReturnObject &result) override {
     SBCommandReturnObject sb_return(&result);
     SBCommandInterpreter sb_interpreter(&m_interpreter);
     SBDebugger debugger_sb(m_interpreter.GetDebugger().shared_from_this());
     bool ret = m_backend->DoExecute(
         debugger_sb, (char **)command.GetArgumentVector(), sb_return);
     sb_return.Release();
     return ret;
   }
   std::shared_ptr<lldb::SBCommandPluginInterface> m_backend;
 };
 
 SBCommandInterpreter::SBCommandInterpreter(CommandInterpreter *interpreter)
     : m_opaque_ptr(interpreter) {
+  LLDB_RECORD_CONSTRUCTOR(SBCommandInterpreter, (CommandInterpreter *),
+                          interpreter);
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   if (log)
     log->Printf("SBCommandInterpreter::SBCommandInterpreter (interpreter=%p)"
                 " => SBCommandInterpreter(%p)",
                 static_cast<void *>(interpreter),
                 static_cast<void *>(m_opaque_ptr));
 }
 
 SBCommandInterpreter::SBCommandInterpreter(const SBCommandInterpreter &rhs)
-    : m_opaque_ptr(rhs.m_opaque_ptr) {}
+    : m_opaque_ptr(rhs.m_opaque_ptr) {
+  LLDB_RECORD_CONSTRUCTOR(SBCommandInterpreter, (const 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)
                     .GetCString()
               : nullptr);
 }
 
 lldb::ReturnStatus
 SBCommandInterpreter::HandleCommand(const char *command_line,
                                     SBCommandReturnObject &result,
                                     bool add_to_history) {
+  LLDB_RECORD_METHOD(lldb::ReturnStatus, SBCommandInterpreter, HandleCommand,
+                     (const char *, lldb::SBCommandReturnObject &, bool),
+                     command_line, result, add_to_history);
+
   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)
     log->Printf("SBCommandInterpreter(%p)::HandleCommand (command=\"%s\", "
                 "SBCommandReturnObject(%p), add_to_history=%i)",
                 static_cast<void *>(m_opaque_ptr), command_line,
                 static_cast<void *>(result.get()), add_to_history);
 
lldb::ReturnStatus SBCommandInterpreter::HandleCommand(
 
   return result.GetStatus();
 }
 
 void SBCommandInterpreter::HandleCommandsFromFile(
     lldb::SBFileSpec &file, lldb::SBExecutionContext &override_context,
     lldb::SBCommandInterpreterRunOptions &options,
     lldb::SBCommandReturnObject result) {
+  LLDB_RECORD_METHOD(void, SBCommandInterpreter, HandleCommandsFromFile,
+                     (lldb::SBFileSpec &, lldb::SBExecutionContext &,
+                      lldb::SBCommandInterpreterRunOptions &,
+                      lldb::SBCommandReturnObject),
+                     file, override_context, options, result);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   if (log) {
     SBStream s;
     file.GetDescription(s);
     log->Printf("SBCommandInterpreter(%p)::HandleCommandsFromFile "
                 "(file=\"%s\", SBCommandReturnObject(%p))",
                 static_cast<void *>(m_opaque_ptr), s.GetData(),
void SBCommandInterpreter::HandleCommandsFromFile(
 
   m_opaque_ptr->HandleCommandsFromFile(tmp_spec, ctx_ptr, options.ref(),
                                        result.ref());
 }
 
 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,
       matches, dummy_descriptions);
 }
 
 int SBCommandInterpreter::HandleCompletionWithDescriptions(
     const char *current_line, const char *cursor, const char *last_char,
     int match_start_point, int max_return_elements, SBStringList &matches,
     SBStringList &descriptions) {
+  LLDB_RECORD_METHOD(int, SBCommandInterpreter,
+                     HandleCompletionWithDescriptions,
+                     (const char *, const char *, const char *, int, int,
+                      lldb::SBStringList &, lldb::SBStringList &),
+                     current_line, cursor, last_char, match_start_point,
+                     max_return_elements, matches, descriptions);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   int num_completions = 0;
 
   // Sanity check the arguments that are passed in: cursor & last_char have to
   // be within the current_line.
   if (current_line == nullptr || cursor == nullptr || last_char == nullptr)
     return 0;
 
int SBCommandInterpreter::HandleCompletionWithDescriptions(
 
   return num_completions;
 }
 
 int SBCommandInterpreter::HandleCompletionWithDescriptions(
     const char *current_line, uint32_t cursor_pos, int match_start_point,
     int max_return_elements, SBStringList &matches,
     SBStringList &descriptions) {
+  LLDB_RECORD_METHOD(int, SBCommandInterpreter,
+                     HandleCompletionWithDescriptions,
+                     (const char *, uint32_t, int, int, lldb::SBStringList &,
+                      lldb::SBStringList &),
+                     current_line, cursor_pos, match_start_point,
+                     max_return_elements, matches, descriptions);
+
   const char *cursor = current_line + cursor_pos;
   const char *last_char = current_line + strlen(current_line);
   return HandleCompletionWithDescriptions(
       current_line, cursor, last_char, match_start_point, max_return_elements,
       matches, descriptions);
 }
 
 int SBCommandInterpreter::HandleCompletion(const char *current_line,
                                            uint32_t cursor_pos,
                                            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,
                           max_return_elements, matches);
 }
 
 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()) {
     TargetSP target_sp(m_opaque_ptr->GetDebugger().GetSelectedTarget());
     if (target_sp) {
       std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
       process_sp = target_sp->GetProcessSP();
       sb_process.SetSP(process_sp);
     }
   }
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   if (log)
     log->Printf("SBCommandInterpreter(%p)::GetProcess () => SBProcess(%p)",
                 static_cast<void *>(m_opaque_ptr),
                 static_cast<void *>(process_sp.get()));
 
   return 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());
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   if (log)
     log->Printf("SBCommandInterpreter(%p)::GetDebugger () => SBDebugger(%p)",
                 static_cast<void *>(m_opaque_ptr),
                 static_cast<void *>(sb_debugger.get()));
 
   return 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);
   return 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());
   } else {
     result->AppendError(
         "SBCommandInterpreter or the command line is not valid");
     result->SetStatus(eReturnStatusFailed);
   }
 }
 
 CommandInterpreter *SBCommandInterpreter::get() { return m_opaque_ptr; }
 
 CommandInterpreter &SBCommandInterpreter::ref() {
   assert(m_opaque_ptr);
   return *m_opaque_ptr;
 }
 
 void SBCommandInterpreter::reset(
     lldb_private::CommandInterpreter *interpreter) {
   m_opaque_ptr = interpreter;
 }
 
 void SBCommandInterpreter::SourceInitFileInHomeDirectory(
     SBCommandReturnObject &result) {
+  LLDB_RECORD_METHOD(void, SBCommandInterpreter, SourceInitFileInHomeDirectory,
+                     (SBCommandReturnObject &), result);
   result.Clear();
   if (IsValid()) {
     TargetSP target_sp(m_opaque_ptr->GetDebugger().GetSelectedTarget());
     std::unique_lock<std::recursive_mutex> lock;
     if (target_sp)
       lock = std::unique_lock<std::recursive_mutex>(target_sp->GetAPIMutex());
     m_opaque_ptr->SourceInitFile(false, result.ref());
   } else {
     result->AppendError("SBCommandInterpreter is not valid");
     result->SetStatus(eReturnStatusFailed);
   }
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   if (log)
     log->Printf("SBCommandInterpreter(%p)::SourceInitFileInHomeDirectory "
                 "(&SBCommandReturnObject(%p))",
                 static_cast<void *>(m_opaque_ptr),
                 static_cast<void *>(result.get()));
 }
 
 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());
     std::unique_lock<std::recursive_mutex> lock;
     if (target_sp)
       lock = std::unique_lock<std::recursive_mutex>(target_sp->GetAPIMutex());
     m_opaque_ptr->SourceInitFile(true, result.ref());
   } else {
     result->AppendError("SBCommandInterpreter is not valid");
     result->SetStatus(eReturnStatusFailed);
   }
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   if (log)
     log->Printf(
         "SBCommandInterpreter(%p)::SourceInitFileInCurrentWorkingDirectory "
         "(&SBCommandReturnObject(%p))",
         static_cast<void *>(m_opaque_ptr), static_cast<void *>(result.get()));
 }
 
 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);
 
   if (log)
     log->Printf(
         "SBCommandInterpreter(%p)::GetBroadcaster() => SBBroadcaster(%p)",
         static_cast<void *>(m_opaque_ptr),
         static_cast<void *>(broadcaster.get()));
 
   return 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();
 }
 
 bool SBCommandInterpreter::SetCommandOverrideCallback(
     const char *command_name, lldb::CommandOverrideCallback callback,
     void *baton) {
   if (command_name && command_name[0] && IsValid()) {
     llvm::StringRef command_name_str = command_name;
     CommandObject *cmd_obj =
         m_opaque_ptr->GetCommandObjectForCommand(command_name_str);
     if (cmd_obj) {
       assert(command_name_str.empty());
       cmd_obj->SetOverrideCallback(callback, baton);
       return true;
     }
   }
   return false;
 }
 
 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();
 }
 
 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();
 }
 
 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();
 }
 
-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();
   if (!m_opaque_sp->IsMultiwordObject())
     return lldb::SBCommand();
   CommandObjectMultiword *new_command = new CommandObjectMultiword(
       m_opaque_sp->GetCommandInterpreter(), name, help);
   new_command->SetRemovable(true);
   lldb::CommandObjectSP new_command_sp(new_command);
   if (new_command_sp && m_opaque_sp->LoadSubCommand(name, new_command_sp))
     return lldb::SBCommand(new_command_sp);
   return lldb::SBCommand();
 }
 
 lldb::SBCommand SBCommand::AddCommand(const char *name,
                                       lldb::SBCommandPluginInterface *impl,
                                       const char *help) {
+  LLDB_RECORD_METHOD(
+      lldb::SBCommand, SBCommand, AddCommand,
+      (const char *, lldb::SBCommandPluginInterface *, const char *), name,
+      impl, help);
+
   if (!IsValid())
     return lldb::SBCommand();
   if (!m_opaque_sp->IsMultiwordObject())
     return 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();
 }
 
 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();
   if (!m_opaque_sp->IsMultiwordObject())
     return 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();
 }
 
 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

 //===-- SBCommandReturnObject.cpp -------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBCommandReturnObject.h"
+#include "SBReproducerPrivate.h"
 #include "lldb/API/SBError.h"
 #include "lldb/API/SBStream.h"
 
 #include "lldb/Interpreter/CommandReturnObject.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/Status.h"
 
 using namespace lldb;
 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));
     else
       m_opaque_up.reset();
   }
   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) {
     llvm::StringRef output = m_opaque_up->GetOutputData();
     ConstString result(output.empty() ? llvm::StringRef("") : output);
 
     if (log)
       log->Printf("SBCommandReturnObject(%p)::GetOutput () => \"%s\"",
                   static_cast<void *>(m_opaque_up.get()), result.AsCString());
 
     return result.AsCString();
   }
 
   if (log)
     log->Printf("SBCommandReturnObject(%p)::GetOutput () => nullptr",
                 static_cast<void *>(m_opaque_up.get()));
 
   return nullptr;
 }
 
 const char *SBCommandReturnObject::GetError() {
+  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBCommandReturnObject, GetError);
+
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   if (m_opaque_up) {
     llvm::StringRef output = m_opaque_up->GetErrorData();
     ConstString result(output.empty() ? llvm::StringRef("") : output);
     if (log)
       log->Printf("SBCommandReturnObject(%p)::GetError () => \"%s\"",
                   static_cast<void *>(m_opaque_up.get()), result.AsCString());
 
     return result.AsCString();
   }
 
   if (log)
     log->Printf("SBCommandReturnObject(%p)::GetError () => nullptr",
                 static_cast<void *>(m_opaque_up.get()));
 
   return nullptr;
 }
 
 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)
       return ::fprintf(fh, "%s", GetOutput());
   }
   return 0;
 }
 
 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)
       return ::fprintf(fh, "%s", GetError());
   }
   return 0;
 }
 
 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);
 }
 
 CommandReturnObject *SBCommandReturnObject::operator->() const {
   return m_opaque_up.get();
 }
 

 }
 
 void SBCommandReturnObject::SetLLDBObjectPtr(CommandReturnObject *ptr) {
   if (m_opaque_up)
     m_opaque_up.reset(ptr);
 }
 
 bool SBCommandReturnObject::GetDescription(SBStream &description) {
+  LLDB_RECORD_METHOD(bool, SBCommandReturnObject, GetDescription,
+                     (lldb::SBStream &), description);
+
   Stream &strm = description.ref();
 
   if (m_opaque_up) {
     description.Printf("Error:  ");
     lldb::ReturnStatus status = m_opaque_up->GetStatus();
     if (status == lldb::eReturnStatusStarted)
       strm.PutCString("Started");
     else if (status == lldb::eReturnStatusInvalid)
if (GetErrorSize() > 0)
       strm.Printf("\nError Message:\n%s", GetError());
   } else
     strm.PutCString("No value");
 
   return true;
 }
 
 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;
     } else if (len > 0) {
       std::string buffer(string, len);
       m_opaque_up->AppendMessage(buffer.c_str());
     } else
       m_opaque_up->AppendMessage(string);
   }
 }
 
 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 ||
       m_opaque_up->GetImmediateOutputStream().get() == nullptr)
     return GetOutput();
   return nullptr;
 }
 
 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 ||
       m_opaque_up->GetImmediateErrorStream().get() == nullptr)
     return GetError();
   return nullptr;
 }
 
 size_t SBCommandReturnObject::Printf(const char *format, ...) {
   if (m_opaque_up) {
     va_list args;
     va_start(args, format);
     size_t result = m_opaque_up->GetOutputStream().PrintfVarArg(format, args);
     va_end(args);
     return result;
   }
   return 0;
 }
 
 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);
     else if (fallback_error_cstr)
       m_opaque_up->SetError(Status(), 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

 //===-- SBCommunication.cpp -------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
+#include "SBReproducerPrivate.h"
+
 #include "lldb/API/SBCommunication.h"
 #include "lldb/API/SBBroadcaster.h"
 #include "lldb/Core/Communication.h"
 #include "lldb/Host/ConnectionFileDescriptor.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Utility/Log.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)
     log->Printf("SBCommunication::SBCommunication (broadcaster_name=\"%s\") => "
                 "SBCommunication(%p)",
                 broadcaster_name, static_cast<void *>(m_opaque));
 }
 
 SBCommunication::~SBCommunication() {
   if (m_opaque && m_opaque_owned)
     delete m_opaque;
   m_opaque = NULL;
   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());
     return m_opaque->Connect(url, NULL);
   }
   return eConnectionStatusNoConnection;
 }
 
 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;
   if (m_opaque) {
     if (m_opaque->HasConnection()) {
       if (m_opaque->IsConnected())
         m_opaque->Disconnect();
     }
log->Printf(
         "SBCommunication(%p)::AdoptFileDescriptor (fd=%d, ownd_fd=%i) => %s",
         static_cast<void *>(m_opaque), fd, owns_fd,
         Communication::ConnectionStatusAsCString(status));
 
   return status;
 }
 
 ConnectionStatus SBCommunication::Disconnect() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::ConnectionStatus, SBCommunication,
+                             Disconnect);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   ConnectionStatus status = eConnectionStatusNoConnection;
   if (m_opaque)
     status = m_opaque->Disconnect();
 
   if (log)
     log->Printf("SBCommunication(%p)::Disconnect () => %s",
                 static_cast<void *>(m_opaque),
                 Communication::ConnectionStatusAsCString(status));
 
   return status;
 }
 
 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)
     result = m_opaque->IsConnected();
 
   if (log)
     log->Printf("SBCommunication(%p)::IsConnected () => %i",
                 static_cast<void *>(m_opaque), result);
log->Printf("SBCommunication(%p)::Write (src=%p, src_len=%" PRIu64
                 static_cast<uint64_t>(src_len),
                 Communication::ConnectionStatusAsCString(status),
                 static_cast<uint64_t>(bytes_written));
 
   return 0;
 }
 
 bool SBCommunication::ReadThreadStart() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommunication, ReadThreadStart);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   bool success = false;
   if (m_opaque)
     success = m_opaque->StartReadThread();
 
   if (log)
     log->Printf("SBCommunication(%p)::ReadThreadStart () => %i",
                 static_cast<void *>(m_opaque), success);
 
   return success;
 }
 
 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 ()...",
                 static_cast<void *>(m_opaque));
 
   bool success = false;
   if (m_opaque)
     success = m_opaque->StopReadThread();
 
   if (log)
     log->Printf("SBCommunication(%p)::ReadThreadStop () => %i",
                 static_cast<void *>(m_opaque), success);
 
   return success;
 }
 
 bool SBCommunication::ReadThreadIsRunning() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommunication, ReadThreadIsRunning);
+
   bool result = false;
   if (m_opaque)
     result = m_opaque->ReadThreadIsRunning();
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   if (log)
     log->Printf("SBCommunication(%p)::ReadThreadIsRunning () => %i",
                 static_cast<void *>(m_opaque), result);
   return result;
log->Printf("SBCommunication(%p)::SetReadThreadBytesReceivedCallback "
                 static_cast<void *>(m_opaque),
                 reinterpret_cast<void *>(reinterpret_cast<intptr_t>(callback)),
                 static_cast<void *>(callback_baton), result);
 
   return result;
 }
 
 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));
 
   if (log)
     log->Printf("SBCommunication(%p)::GetBroadcaster () => SBBroadcaster (%p)",
                 static_cast<void *>(m_opaque),
                 static_cast<void *>(broadcaster.get()));
 
   return broadcaster;
 }
 
 const char *SBCommunication::GetBroadcasterClass() {
+  LLDB_RECORD_STATIC_METHOD_NO_ARGS(const char *, SBCommunication,
+                                    GetBroadcasterClass);
+
   return Communication::GetStaticBroadcasterClass().AsCString();
 }
 
 //
 // void
 // SBCommunication::CreateIfNeeded ()
 //{
 //    if (m_opaque == NULL)

lldb/source/API/SBCompileUnit.cpp

 //===-- SBCompileUnit.cpp ---------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
+#include "SBReproducerPrivate.h"
+
 #include "lldb/API/SBCompileUnit.h"
 #include "lldb/API/SBLineEntry.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Symbol/CompileUnit.h"
 #include "lldb/Symbol/LineEntry.h"
 #include "lldb/Symbol/LineTable.h"
 #include "lldb/Symbol/SymbolVendor.h"
 #include "lldb/Symbol/Type.h"
 #include "lldb/Utility/Log.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;
 }
 
 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)
       return line_table->GetSize();
   }
   return 0;
 }
 
 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;
   if (m_opaque_ptr) {
     LineTable *line_table = m_opaque_ptr->GetLineTable();
     if (line_table) {
       LineEntry line_entry;
       if (line_table->GetLineEntryAtIndex(idx, line_entry))
log->Printf("SBCompileUnit(%p)::GetLineEntryAtIndex (idx=%u) => "
                 static_cast<void *>(sb_line_entry.get()), sstr.GetData());
   }
 
   return sb_line_entry;
 }
 
 uint32_t SBCompileUnit::FindLineEntryIndex(uint32_t start_idx, uint32_t line,
                                            SBFileSpec *inline_file_spec) const {
+  LLDB_RECORD_METHOD_CONST(uint32_t, SBCompileUnit, FindLineEntryIndex,
+                           (uint32_t, uint32_t, lldb::SBFileSpec *), start_idx,
+                           line, inline_file_spec);
+
   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;
   if (m_opaque_ptr) {
     FileSpec file_spec;
     if (inline_file_spec && inline_file_spec->IsValid())
       file_spec = inline_file_spec->ref();
     else
if (index == UINT32_MAX) {
                   index);
     }
   }
 
   return index;
 }
 
 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();
   }
   return 0;
 }
 
 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;
 
   ModuleSP module_sp(m_opaque_ptr->GetModule());
   if (!module_sp)
     return sb_type_list;
 
   SymbolVendor *vendor = module_sp->GetSymbolVendor();
   if (!vendor)
     return 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;
 }
 
 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;
   if (m_opaque_ptr) {
     FileSpecList &support_files = m_opaque_ptr->GetSupportFiles();
     FileSpec file_spec = support_files.GetFileSpecAtIndex(idx);
     sb_file_spec.SetFileSpec(file_spec);
   }
 
   if (log) {
     SBStream sstr;
     sb_file_spec.GetDescription(sstr);
     log->Printf("SBCompileUnit(%p)::GetGetFileSpecAtIndex (idx=%u) => "
                 "SBFileSpec(%p): '%s'",
                 static_cast<void *>(m_opaque_ptr), idx,
                 static_cast<const void *>(sb_file_spec.get()), sstr.GetData());
   }
 
   return sb_file_spec;
 }
 
 uint32_t SBCompileUnit::FindSupportFileIndex(uint32_t start_idx,
                                              const SBFileSpec &sb_file,
                                              bool full) {
+  LLDB_RECORD_METHOD(uint32_t, SBCompileUnit, FindSupportFileIndex,
+                     (uint32_t, const lldb::SBFileSpec &, bool), start_idx,
+                     sb_file, full);
+
   if (m_opaque_ptr) {
     FileSpecList &support_files = m_opaque_ptr->GetSupportFiles();
     return support_files.FindFileIndex(start_idx, sb_file.ref(), full);
   }
   return 0;
 }
 
 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;
 }
 
 const lldb_private::CompileUnit *SBCompileUnit::operator->() const {
   return m_opaque_ptr;
 }
 
 const lldb_private::CompileUnit &SBCompileUnit::operator*() const {
   return *m_opaque_ptr;
 }
 
 lldb_private::CompileUnit *SBCompileUnit::get() { return m_opaque_ptr; }
 
 void SBCompileUnit::reset(lldb_private::CompileUnit *lldb_object_ptr) {
   m_opaque_ptr = lldb_object_ptr;
 }
 
 bool SBCompileUnit::GetDescription(SBStream &description) {
+  LLDB_RECORD_METHOD(bool, SBCompileUnit, GetDescription, (lldb::SBStream &),
+                     description);
+
   Stream &strm = description.ref();
 
   if (m_opaque_ptr) {
     m_opaque_ptr->Dump(&strm, false);
   } else
     strm.PutCString("No value");
 
   return true;
 }

lldb/source/API/SBData.cpp

 //===-- SBData.cpp ----------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
+#include "SBReproducerPrivate.h"
+
 #include "lldb/API/SBData.h"
 #include "lldb/API/SBError.h"
 #include "lldb/API/SBStream.h"
 
 #include "lldb/Core/DumpDataExtractor.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/DataExtractor.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/Stream.h"
 
 #include <cinttypes>
 #include <memory>
 
 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;
 }
 
 SBData::~SBData() {}
 
 void SBData::SetOpaque(const lldb::DataExtractorSP &data_sp) {
   m_opaque_sp = data_sp;
 }
 
 lldb_private::DataExtractor *SBData::get() const { return m_opaque_sp.get(); }
 
 lldb_private::DataExtractor *SBData::operator->() const {
   return m_opaque_sp.operator->();
 }
 
 lldb::DataExtractorSP &SBData::operator*() { return m_opaque_sp; }
 
 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())
     value = m_opaque_sp->GetAddressByteSize();
   if (log)
     log->Printf("SBData::GetAddressByteSize () => "
                 "(%i)",
                 value);
   return value;
 }
 
 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);
   if (log)
     log->Printf("SBData::SetAddressByteSize (%i)", 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())
     value = m_opaque_sp->GetByteSize();
   if (log)
     log->Printf("SBData::GetByteSize () => "
                 "( %" PRIu64 " )",
                 (uint64_t)value);
   return value;
 }
 
 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())
     value = m_opaque_sp->GetByteOrder();
   if (log)
     log->Printf("SBData::GetByteOrder () => "
                 "(%i)",
                 value);
   return value;
 }
 
 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);
   if (log)
     log->Printf("SBData::GetByteOrder (%i)", 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()) {
     error.SetErrorString("no value to read from");
   } else {
     uint32_t old_offset = offset;
     value = m_opaque_sp->GetFloat(&offset);
     if (offset == old_offset)
       error.SetErrorString("unable to read data");
   }
   if (log)
     log->Printf("SBData::GetFloat (error=%p,offset=%" PRIu64 ") => (%f)",
                 static_cast<void *>(error.get()), offset, value);
   return value;
 }
 
 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()) {
     error.SetErrorString("no value to read from");
   } else {
     uint32_t old_offset = offset;
     value = m_opaque_sp->GetDouble(&offset);
     if (offset == old_offset)
       error.SetErrorString("unable to read data");
   }
   if (log)
     log->Printf("SBData::GetDouble (error=%p,offset=%" PRIu64 ") => "
                 "(%f)",
                 static_cast<void *>(error.get()), offset, value);
   return value;
 }
 
 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()) {
     error.SetErrorString("no value to read from");
   } else {
     uint32_t old_offset = offset;
     value = m_opaque_sp->GetLongDouble(&offset);
     if (offset == old_offset)
       error.SetErrorString("unable to read data");
   }
   if (log)
     log->Printf("SBData::GetLongDouble (error=%p,offset=%" PRIu64 ") => "
                 "(%Lf)",
                 static_cast<void *>(error.get()), offset, value);
   return value;
 }
 
 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()) {
     error.SetErrorString("no value to read from");
   } else {
     uint32_t old_offset = offset;
     value = m_opaque_sp->GetAddress(&offset);
     if (offset == old_offset)
       error.SetErrorString("unable to read data");
   }
   if (log)
     log->Printf("SBData::GetAddress (error=%p,offset=%" PRIu64 ") => "
                 "(%p)",
                 static_cast<void *>(error.get()), offset,
                 reinterpret_cast<void *>(value));
   return value;
 }
 
 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()) {
     error.SetErrorString("no value to read from");
   } else {
     uint32_t old_offset = offset;
     value = m_opaque_sp->GetU8(&offset);
     if (offset == old_offset)
       error.SetErrorString("unable to read data");
   }
   if (log)
     log->Printf("SBData::GetUnsignedInt8 (error=%p,offset=%" PRIu64 ") => "
                 "(%c)",
                 static_cast<void *>(error.get()), offset, value);
   return value;
 }
 
 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()) {
     error.SetErrorString("no value to read from");
   } else {
     uint32_t old_offset = offset;
     value = m_opaque_sp->GetU16(&offset);
     if (offset == old_offset)
       error.SetErrorString("unable to read data");
   }
   if (log)
     log->Printf("SBData::GetUnsignedInt16 (error=%p,offset=%" PRIu64 ") => "
                 "(%hd)",
                 static_cast<void *>(error.get()), offset, value);
   return value;
 }
 
 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()) {
     error.SetErrorString("no value to read from");
   } else {
     uint32_t old_offset = offset;
     value = m_opaque_sp->GetU32(&offset);
     if (offset == old_offset)
       error.SetErrorString("unable to read data");
   }
   if (log)
     log->Printf("SBData::GetUnsignedInt32 (error=%p,offset=%" PRIu64 ") => "
                 "(%d)",
                 static_cast<void *>(error.get()), offset, value);
   return value;
 }
 
 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()) {
     error.SetErrorString("no value to read from");
   } else {
     uint32_t old_offset = offset;
     value = m_opaque_sp->GetU64(&offset);
     if (offset == old_offset)
       error.SetErrorString("unable to read data");
   }
   if (log)
     log->Printf("SBData::GetUnsignedInt64 (error=%p,offset=%" PRIu64 ") => "
                 "(%" PRId64 ")",
                 static_cast<void *>(error.get()), offset, value);
   return value;
 }
 
 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()) {
     error.SetErrorString("no value to read from");
   } else {
     uint32_t old_offset = offset;
     value = (int8_t)m_opaque_sp->GetMaxS64(&offset, 1);
     if (offset == old_offset)
       error.SetErrorString("unable to read data");
   }
   if (log)
     log->Printf("SBData::GetSignedInt8 (error=%p,offset=%" PRIu64 ") => "
                 "(%c)",
                 static_cast<void *>(error.get()), offset, value);
   return value;
 }
 
 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()) {
     error.SetErrorString("no value to read from");
   } else {
     uint32_t old_offset = offset;
     value = (int16_t)m_opaque_sp->GetMaxS64(&offset, 2);
     if (offset == old_offset)
       error.SetErrorString("unable to read data");
   }
   if (log)
     log->Printf("SBData::GetSignedInt16 (error=%p,offset=%" PRIu64 ") => "
                 "(%hd)",
                 static_cast<void *>(error.get()), offset, value);
   return value;
 }
 
 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()) {
     error.SetErrorString("no value to read from");
   } else {
     uint32_t old_offset = offset;
     value = (int32_t)m_opaque_sp->GetMaxS64(&offset, 4);
     if (offset == old_offset)
       error.SetErrorString("unable to read data");
   }
   if (log)
     log->Printf("SBData::GetSignedInt32 (error=%p,offset=%" PRIu64 ") => "
                 "(%d)",
                 static_cast<void *>(error.get()), offset, value);
   return value;
 }
 
 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()) {
     error.SetErrorString("no value to read from");
   } else {
     uint32_t old_offset = offset;
     value = (int64_t)m_opaque_sp->GetMaxS64(&offset, 8);
     if (offset == old_offset)
       error.SetErrorString("unable to read data");
   }
   if (log)
     log->Printf("SBData::GetSignedInt64 (error=%p,offset=%" PRIu64 ") => "
                 "(%" PRId64 ")",
                 static_cast<void *>(error.get()), offset, value);
   return value;
 }
 
 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()) {
     error.SetErrorString("no value to read from");
   } else {
     uint32_t old_offset = offset;
     value = m_opaque_sp->GetCStr(&offset);
     if (offset == old_offset || (value == NULL))
       error.SetErrorString("unable to read data");
   }
   if (log)
     log->Printf("SBData::GetString (error=%p,offset=%" PRIu64 ") => (%p)",
                 static_cast<void *>(error.get()), offset,
                 static_cast<const void *>(value));
   return value;
 }
 
 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) {
     DumpDataExtractor(*m_opaque_sp, &strm, 0, lldb::eFormatBytesWithASCII, 1,
                       m_opaque_sp->GetByteSize(), 16, base_addr, 0, 0);
   } else
     strm.PutCString("No value");
 
log->Printf("SBData::SetData (error=%p,buf=%p,size=%" PRIu64
                 ",endian=%d,addr_size=%c) => "
                 "(%p)",
                 static_cast<void *>(error.get()),
                 static_cast<const void *>(buf), static_cast<uint64_t>(size),
                 endian, addr_size, static_cast<void *>(m_opaque_sp.get()));
 }
 
 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())
     value = m_opaque_sp.get()->Append(*rhs.m_opaque_sp);
   if (log)
     log->Printf("SBData::Append (rhs=%p) => (%s)",
                 static_cast<void *>(rhs.get()), value ? "true" : "false");
   return value;
 }
 
 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();
 
   uint32_t data_len = strlen(data);
 
   lldb::DataBufferSP buffer_sp(new DataBufferHeap(data, data_len));
   lldb::DataExtractorSP data_sp(
       new DataExtractor(buffer_sp, endian, addr_byte_size));
 
   SBData ret(data_sp);
 
   return ret;
 }
 
 lldb::SBData SBData::CreateDataFromUInt64Array(lldb::ByteOrder endian,
                                                uint32_t addr_byte_size,
                                                uint64_t *array,
                                                size_t array_len) {
+  LLDB_RECORD_STATIC_METHOD(lldb::SBData, SBData, CreateDataFromUInt64Array,
+                            (lldb::ByteOrder, uint32_t, uint64_t *, size_t),
+                            endian, addr_byte_size, array, array_len);
+
   if (!array || array_len == 0)
     return SBData();
 
   size_t data_len = array_len * sizeof(uint64_t);
 
   lldb::DataBufferSP buffer_sp(new DataBufferHeap(array, data_len));
   lldb::DataExtractorSP data_sp(
       new DataExtractor(buffer_sp, endian, addr_byte_size));
 
   SBData ret(data_sp);
 
   return ret;
 }
 
 lldb::SBData SBData::CreateDataFromUInt32Array(lldb::ByteOrder endian,
                                                uint32_t addr_byte_size,
                                                uint32_t *array,
                                                size_t array_len) {
+  LLDB_RECORD_STATIC_METHOD(lldb::SBData, SBData, CreateDataFromUInt32Array,
+                            (lldb::ByteOrder, uint32_t, uint32_t *, size_t),
+                            endian, addr_byte_size, array, array_len);
+
   if (!array || array_len == 0)
     return SBData();
 
   size_t data_len = array_len * sizeof(uint32_t);
 
   lldb::DataBufferSP buffer_sp(new DataBufferHeap(array, data_len));
   lldb::DataExtractorSP data_sp(
       new DataExtractor(buffer_sp, endian, addr_byte_size));
 
   SBData ret(data_sp);
 
   return ret;
 }
 
 lldb::SBData SBData::CreateDataFromSInt64Array(lldb::ByteOrder endian,
                                                uint32_t addr_byte_size,
                                                int64_t *array,
                                                size_t array_len) {
+  LLDB_RECORD_STATIC_METHOD(lldb::SBData, SBData, CreateDataFromSInt64Array,
+                            (lldb::ByteOrder, uint32_t, int64_t *, size_t),
+                            endian, addr_byte_size, array, array_len);
+
   if (!array || array_len == 0)
     return SBData();
 
   size_t data_len = array_len * sizeof(int64_t);
 
   lldb::DataBufferSP buffer_sp(new DataBufferHeap(array, data_len));
   lldb::DataExtractorSP data_sp(
       new DataExtractor(buffer_sp, endian, addr_byte_size));
 
   SBData ret(data_sp);
 
   return ret;
 }
 
 lldb::SBData SBData::CreateDataFromSInt32Array(lldb::ByteOrder endian,
                                                uint32_t addr_byte_size,
                                                int32_t *array,
                                                size_t array_len) {
+  LLDB_RECORD_STATIC_METHOD(lldb::SBData, SBData, CreateDataFromSInt32Array,
+                            (lldb::ByteOrder, uint32_t, int32_t *, size_t),
+                            endian, addr_byte_size, array, array_len);
+
   if (!array || array_len == 0)
     return SBData();
 
   size_t data_len = array_len * sizeof(int32_t);
 
   lldb::DataBufferSP buffer_sp(new DataBufferHeap(array, data_len));
   lldb::DataExtractorSP data_sp(
       new DataExtractor(buffer_sp, endian, addr_byte_size));
 
   SBData ret(data_sp);
 
   return ret;
 }
 
 lldb::SBData SBData::CreateDataFromDoubleArray(lldb::ByteOrder endian,
                                                uint32_t addr_byte_size,
                                                double *array,
                                                size_t array_len) {
+  LLDB_RECORD_STATIC_METHOD(lldb::SBData, SBData, CreateDataFromDoubleArray,
+                            (lldb::ByteOrder, uint32_t, double *, size_t),
+                            endian, addr_byte_size, array, array_len);
+
   if (!array || array_len == 0)
     return SBData();
 
   size_t data_len = array_len * sizeof(double);
 
   lldb::DataBufferSP buffer_sp(new DataBufferHeap(array, data_len));
   lldb::DataExtractorSP data_sp(
       new DataExtractor(buffer_sp, endian, addr_byte_size));
 
   SBData ret(data_sp);
 
   return 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) {
     if (log)
       log->Printf("SBData::SetDataFromCString (data=%p) => false",
                   static_cast<const void *>(data));
     return false;
   }
bool SBData::SetDataFromCString(const char *data) {
   if (log)
     log->Printf("SBData::SetDataFromCString (data=%p) => true",
                 static_cast<const void *>(data));
 
   return true;
 }
 
 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) {
     if (log)
       log->Printf(
           "SBData::SetDataFromUInt64Array (array=%p, array_len = %" PRIu64
           ") => "
           "false",
log->Printf("SBData::SetDataFromUInt64Array (array=%p, array_len = %" PRIu64
                 ") => "
                 "true",
                 static_cast<void *>(array), static_cast<uint64_t>(array_len));
 
   return true;
 }
 
 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) {
     if (log)
       log->Printf(
           "SBData::SetDataFromUInt32Array (array=%p, array_len = %" PRIu64
           ") => "
           "false",
log->Printf("SBData::SetDataFromUInt32Array (array=%p, array_len = %" PRIu64
                 ") => "
                 "true",
                 static_cast<void *>(array), static_cast<uint64_t>(array_len));
 
   return true;
 }
 
 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) {
     if (log)
       log->Printf(
           "SBData::SetDataFromSInt64Array (array=%p, array_len = %" PRIu64
           ") => "
           "false",
log->Printf("SBData::SetDataFromSInt64Array (array=%p, array_len = %" PRIu64
                 ") => "
                 "true",
                 static_cast<void *>(array), static_cast<uint64_t>(array_len));
 
   return true;
 }
 
 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) {
     if (log)
       log->Printf(
           "SBData::SetDataFromSInt32Array (array=%p, array_len = %" PRIu64
           ") => "
           "false",
log->Printf("SBData::SetDataFromSInt32Array (array=%p, array_len = %" PRIu64
                 ") => "
                 "true",
                 static_cast<void *>(array), static_cast<uint64_t>(array_len));
 
   return true;
 }
 
 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) {
     if (log)
       log->Printf(
           "SBData::SetDataFromDoubleArray (array=%p, array_len = %" PRIu64
           ") => "
           "false",

lldb/source/API/SBDebugger.cpp

 //===-- SBDebugger.cpp ------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-
+#include "SBReproducerPrivate.h"
 #include "SystemInitializerFull.h"
 
 #include "lldb/API/SBDebugger.h"
 
 #include "lldb/lldb-private.h"
 
 #include "lldb/API/SBBroadcaster.h"
 #include "lldb/API/SBCommandInterpreter.h"

 SBError SBInputReader::Initialize(
     lldb::SBDebugger &sb_debugger,
     unsigned long (*)(void *, lldb::SBInputReader *, lldb::InputReaderAction,
                       char const *, unsigned long),
     void *, lldb::InputReaderGranularity, char const *, char const *, bool) {
   return SBError();
 }
 
-void SBInputReader::SetIsDone(bool) {}
+void SBInputReader::SetIsDone(bool b) {
+  LLDB_RECORD_METHOD(void, SBInputReader, SetIsDone, (bool), b);
+}
 
-bool SBInputReader::IsActive() const { return false; }
+bool SBInputReader::IsActive() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBInputReader, IsActive);
+  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 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 SBDebugger &), rhs);
+}
 
-SBDebugger::~SBDebugger() = default;
+SBDebugger::~SBDebugger() {}
 
 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;
   }
   return *this;
 }
 
 void SBDebugger::Initialize() {
+  LLDB_RECORD_STATIC_METHOD_NO_ARGS(void, SBDebugger, Initialize);
+
   SBInitializerOptions options;
   SBDebugger::Initialize(options);
 }
 
 lldb::SBError SBDebugger::Initialize(SBInitializerOptions &options) {
+  LLDB_RECORD_STATIC_METHOD(lldb::SBError, SBDebugger, Initialize,
+                            (lldb::SBInitializerOptions &), options);
+
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   if (log)
     log->Printf("SBDebugger::Initialize ()");
 
   SBError error;
   if (auto e = g_debugger_lifetime->Initialize(
           llvm::make_unique<SystemInitializerFull>(), *options.m_opaque_up,
           LoadPlugin)) {
     error.SetError(Status(std::move(e)));
   }
   return 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)
     log->Printf("SBDebugger(%p)::Clear ()",
                 static_cast<void *>(m_opaque_sp.get()));
 
   if (m_opaque_sp)
     m_opaque_sp->ClearIOHandlers();
 
   m_opaque_sp.reset();
 }
 
 SBDebugger SBDebugger::Create() {
-  return SBDebugger::Create(false, nullptr, nullptr);
+  LLDB_RECORD_STATIC_METHOD_NO_ARGS(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(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,
                               lldb::LogOutputCallback callback, void *baton)
 
 {
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
SBDebugger SBDebugger::Create(bool source_init_files,
   } else {
     interp.get()->SkipLLDBInitFiles(true);
     interp.get()->SkipAppInitFiles(true);
   }
   return debugger;
 }
 
 void SBDebugger::Destroy(SBDebugger &debugger) {
+  LLDB_RECORD_STATIC_METHOD(void, SBDebugger, Destroy, (lldb::SBDebugger &),
+                            debugger);
+
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   if (log) {
     SBStream sstr;
     debugger.GetDescription(sstr);
     log->Printf("SBDebugger::Destroy () => SBDebugger(%p): %s",
                 static_cast<void *>(debugger.m_opaque_sp.get()),
                 sstr.GetData());
   }
 
   Debugger::Destroy(debugger.m_opaque_sp);
 
   if (debugger.m_opaque_sp.get() != nullptr)
     debugger.m_opaque_sp.reset();
 }
 
 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
   // deadlocks.
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   const bool mandatory = false;
   if (log) {
     log->Printf("SBDebugger::MemoryPressureDetected (), mandatory = %d",
                 mandatory);
   }
 
   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);
 }
 
 // Shouldn't really be settable after initialization as this could cause lots
 // of problems; don't want users trying to switch modes in the middle of a
 // debugging session.
 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)
     log->Printf(
         "SBDebugger(%p)::SetInputFileHandle (fh=%p, transfer_ownership=%i)",
         static_cast<void *>(m_opaque_sp.get()), static_cast<void *>(fh),
         transfer_ownership);
 
   if (m_opaque_sp)
     m_opaque_sp->SetInputFileHandle(fh, transfer_ownership);
 }
 
 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)
     log->Printf(
         "SBDebugger(%p)::SetOutputFileHandle (fh=%p, transfer_ownership=%i)",
         static_cast<void *>(m_opaque_sp.get()), static_cast<void *>(fh),
         transfer_ownership);
 
   if (m_opaque_sp)
     m_opaque_sp->SetOutputFileHandle(fh, transfer_ownership);
 }
 
 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)
     log->Printf(
         "SBDebugger(%p)::SetErrorFileHandle (fh=%p, transfer_ownership=%i)",
         static_cast<void *>(m_opaque_sp.get()), static_cast<void *>(fh),
         transfer_ownership);
 
   if (m_opaque_sp)
     m_opaque_sp->SetErrorFileHandle(fh, transfer_ownership);
 }
 
 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)
       return stream_file_sp->GetFile().GetStream();
   }
   return nullptr;
 }
 
 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)
       return stream_file_sp->GetFile().GetStream();
   }
   return nullptr;
 }
 
 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)
       return stream_file_sp->GetFile().GetStream();
   }
   return nullptr;
 }
 
 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(SBCommandInterpreter, SBDebugger,
+                             GetCommandInterpreter);
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   SBCommandInterpreter sb_interpreter;
   if (m_opaque_sp)
     sb_interpreter.reset(&m_opaque_sp->GetCommandInterpreter());
 
   if (log)
     log->Printf(
         "SBDebugger(%p)::GetCommandInterpreter () => SBCommandInterpreter(%p)",
         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;
     if (target_sp)
       lock = std::unique_lock<std::recursive_mutex>(target_sp->GetAPIMutex());
 
     SBCommandInterpreter sb_interpreter(GetCommandInterpreter());
     SBCommandReturnObject result;
if (!m_opaque_sp->GetAsyncExecution()) {
                              GetErrorFileHandle());
         }
       }
     }
   }
 }
 
 SBListener SBDebugger::GetListener() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBListener, SBDebugger, GetListener);
+
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   SBListener sb_listener;
   if (m_opaque_sp)
     sb_listener.reset(m_opaque_sp->GetListener());
 
   if (log)
     log->Printf("SBDebugger(%p)::GetListener () => SBListener(%p)",
                 static_cast<void *>(m_opaque_sp.get()),
                 static_cast<void *>(sb_listener.get()));
 
   return 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;
 
   TargetSP target_sp(process.GetTarget().GetSP());
   if (!target_sp)
     return;
 
   const uint32_t event_type = event.GetType();
if (event_type & Process::eBroadcastBitStateChanged) {
 
     bool is_stopped = StateIsStoppedState(event_state);
     if (!is_stopped)
       process.ReportEventState(event, out);
   }
 }
 
 SBSourceManager SBDebugger::GetSourceManager() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBSourceManager, SBDebugger,
+                             GetSourceManager);
+
   SBSourceManager sb_source_manager(*this);
   return 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, arch_name_len);
+
   if (arch_name && arch_name_len) {
     ArchSpec default_arch = Target::GetDefaultArchitecture();
 
     if (default_arch.IsValid()) {
       const std::string &triple_str = default_arch.GetTriple().str();
       if (!triple_str.empty())
         ::snprintf(arch_name, arch_name_len, "%s", triple_str.c_str());
       else
         ::snprintf(arch_name, arch_name_len, "%s",
                    default_arch.GetArchitectureName());
       return true;
     }
   }
   if (arch_name && arch_name_len)
     arch_name[0] = '\0';
   return false;
 }
 
 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()) {
       Target::SetDefaultArchitecture(arch);
       return true;
     }
   }
   return false;
 }
 
 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);
 }
 
 static void AddBoolConfigEntry(StructuredData::Dictionary &dict,
                                llvm::StringRef name, bool value,
                                llvm::StringRef description) {
   auto entry_up = llvm::make_unique<StructuredData::Dictionary>();
   entry_up->AddBooleanItem("value", value);
   entry_up->AddStringItem("description", description);
   dict.AddItem(name, std::move(entry_up));
 }
 
 static void AddLLVMTargets(StructuredData::Dictionary &dict) {
   auto array_up = llvm::make_unique<StructuredData::Array>();
 #define LLVM_TARGET(target)                                                    \
   array_up->AddItem(llvm::make_unique<StructuredData::String>(#target));
 #include "llvm/Config/Targets.def"
   auto entry_up = llvm::make_unique<StructuredData::Dictionary>();
   entry_up->AddItem("value", std::move(array_up));
   entry_up->AddStringItem("description", "A list of configured LLVM targets.");
   dict.AddItem("targets", std::move(entry_up));
 }
 
 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(),
       "A boolean value that indicates if XML support is enabled in LLDB");
   AddLLVMTargets(*config_up);
 
   SBStructuredData data;
   data.m_impl_up->SetObjectSP(std::move(config_up));
   return 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);
   if (log)
     log->Printf("SBDebugger::StateIsRunningState (state=%s) => %i",
                 StateAsCString(state), result);
 
   return result;
 }
 
 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);
   if (log)
     log->Printf("SBDebugger::StateIsStoppedState (state=%s) => %i",
                 StateAsCString(state), result);
 
   return result;
 }
 
 lldb::SBTarget SBDebugger::CreateTarget(const char *filename,
                                         const char *target_triple,
                                         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) {
     sb_error.Clear();
     OptionGroupPlatform platform_options(false);
     platform_options.SetPlatformName(platform_name);
 
     sb_error.ref() = m_opaque_sp->GetTargetList().CreateTarget(
log->Printf("SBDebugger(%p)::CreateTarget (filename=\"%s\", triple=%s, "
                 static_cast<void *>(target_sp.get()));
 
   return sb_target;
 }
 
 SBTarget
 SBDebugger::CreateTargetWithFileAndTargetTriple(const char *filename,
                                                 const char *target_triple) {
+  LLDB_RECORD_METHOD(lldb::SBTarget, SBDebugger,
+                     CreateTargetWithFileAndTargetTriple,
+                     (const char *, const char *), filename, target_triple);
+
   SBTarget sb_target;
   TargetSP target_sp;
   if (m_opaque_sp) {
     const bool add_dependent_modules = true;
     Status error(m_opaque_sp->GetTargetList().CreateTarget(
         *m_opaque_sp, filename, target_triple,
         add_dependent_modules ? eLoadDependentsYes : eLoadDependentsNo, nullptr,
         target_sp));
     sb_target.SetSP(target_sp);
   }
 
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   if (log)
     log->Printf("SBDebugger(%p)::CreateTargetWithFileAndTargetTriple "
                 "(filename=\"%s\", triple=%s) => SBTarget(%p)",
                 static_cast<void *>(m_opaque_sp.get()), filename, target_triple,
                 static_cast<void *>(target_sp.get()));
 
   return sb_target;
 }
 
 SBTarget SBDebugger::CreateTargetWithFileAndArch(const char *filename,
                                                  const char *arch_cstr) {
+  LLDB_RECORD_METHOD(lldb::SBTarget, SBDebugger, CreateTargetWithFileAndArch,
+                     (const char *, const char *), filename, arch_cstr);
+
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   SBTarget sb_target;
   TargetSP target_sp;
   if (m_opaque_sp) {
     Status error;
     const bool add_dependent_modules = true;
 
log->Printf("SBDebugger(%p)::CreateTargetWithFileAndArch (filename=\"%s\", "
                 "arch=%s) => SBTarget(%p)",
                 static_cast<void *>(m_opaque_sp.get()), filename, arch_cstr,
                 static_cast<void *>(target_sp.get()));
 
   return 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) {
     Status error;
     const bool add_dependent_modules = true;
     error = m_opaque_sp->GetTargetList().CreateTarget(
         *m_opaque_sp, filename, "",
         add_dependent_modules ? eLoadDependentsYes : eLoadDependentsNo, nullptr,
if (log)
     log->Printf(
         "SBDebugger(%p)::CreateTarget (filename=\"%s\") => SBTarget(%p)",
         static_cast<void *>(m_opaque_sp.get()), filename,
         static_cast<void *>(target_sp.get()));
   return 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());
   }
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   if (log)
     log->Printf(
         "SBDebugger(%p)::GetDummyTarget() => SBTarget(%p)",
         static_cast<void *>(m_opaque_sp.get()),
         static_cast<void *>(sb_target.GetSP().get()));
   return 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());
     if (target_sp) {
       // No need to lock, the target list is thread safe
       result = m_opaque_sp->GetTargetList().DeleteTarget(target_sp);
       target_sp->Destroy();
       target.Clear();
       const bool mandatory = true;
       ModuleList::RemoveOrphanSharedModules(mandatory);
     }
   }
 
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   if (log)
     log->Printf("SBDebugger(%p)::DeleteTarget (SBTarget(%p)) => %i",
                 static_cast<void *>(m_opaque_sp.get()),
                 static_cast<void *>(target.m_opaque_sp.get()), result);
 
   return result;
 }
 
 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;
 }
 
 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)
     return UINT32_MAX;
 
   if (!m_opaque_sp)
     return UINT32_MAX;
 
   return m_opaque_sp->GetTargetList().GetIndexOfTarget(target.GetSP());
 }
 
 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;
 }
 
 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
     ArchSpec arch = Platform::GetAugmentedArchSpec(
         m_opaque_sp->GetPlatformList().GetSelectedPlatform().get(), arch_name);
     TargetSP target_sp(
         m_opaque_sp->GetTargetList().FindTargetWithExecutableAndArchitecture(
             FileSpec(filename), arch_name ? &arch : nullptr));
     sb_target.SetSP(target_sp);
   }
   return sb_target;
 }
 
 SBTarget SBDebugger::FindTargetWithLLDBProcess(const ProcessSP &process_sp) {
   SBTarget sb_target;
   if (m_opaque_sp) {
     // No need to lock, the target list is thread safe
     sb_target.SetSP(
         m_opaque_sp->GetTargetList().FindTargetWithProcess(process_sp.get()));
   }
   return sb_target;
 }
 
 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();
   }
   return 0;
 }
 
 SBTarget SBDebugger::GetSelectedTarget() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTarget, SBDebugger, GetSelectedTarget);
+
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   SBTarget sb_target;
   TargetSP target_sp;
   if (m_opaque_sp) {
     // No need to lock, the target list is thread safe
     target_sp = m_opaque_sp->GetTargetList().GetSelectedTarget();
     sb_target.SetSP(target_sp);
   }
 
   if (log) {
     SBStream sstr;
     sb_target.GetDescription(sstr, eDescriptionLevelBrief);
     log->Printf("SBDebugger(%p)::GetSelectedTarget () => SBTarget(%p): %s",
                 static_cast<void *>(m_opaque_sp.get()),
                 static_cast<void *>(target_sp.get()), sstr.GetData());
   }
 
   return 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());
   if (m_opaque_sp) {
     m_opaque_sp->GetTargetList().SetSelectedTarget(target_sp.get());
   }
   if (log) {
     SBStream sstr;
     sb_target.GetDescription(sstr, eDescriptionLevelBrief);
     log->Printf("SBDebugger(%p)::SetSelectedTarget () => SBTarget(%p): %s",
                 static_cast<void *>(m_opaque_sp.get()),
                 static_cast<void *>(target_sp.get()), sstr.GetData());
   }
 }
 
 SBPlatform SBDebugger::GetSelectedPlatform() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBPlatform, SBDebugger, GetSelectedPlatform);
+
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   SBPlatform sb_platform;
   DebuggerSP debugger_sp(m_opaque_sp);
   if (debugger_sp) {
     sb_platform.SetSP(debugger_sp->GetPlatformList().GetSelectedPlatform());
   }
   if (log)
     log->Printf("SBDebugger(%p)::GetSelectedPlatform () => SBPlatform(%p): %s",
                 static_cast<void *>(m_opaque_sp.get()),
                 static_cast<void *>(sb_platform.GetSP().get()),
                 sb_platform.GetName());
   return 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);
   if (debugger_sp) {
     debugger_sp->GetPlatformList().SetSelectedPlatform(sb_platform.GetSP());
   }
 
   if (log)
     log->Printf("SBDebugger(%p)::SetSelectedPlatform (SBPlatform(%p) %s)",
                 static_cast<void *>(m_opaque_sp.get()),
                 static_cast<void *>(sb_platform.GetSP().get()),
                 sb_platform.GetName());
 }
 
 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();
   }
   return 0;
 }
 
 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;
 }
 
 uint32_t SBDebugger::GetNumAvailablePlatforms() {
+  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBDebugger, GetNumAvailablePlatforms);
+
   uint32_t idx = 0;
   while (true) {
     if (!PluginManager::GetPlatformPluginNameAtIndex(idx)) {
       break;
     }
     ++idx;
   }
   // +1 for the host platform, which should always appear first in the list.
   return idx + 1;
 }
 
 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");
 
   if (idx == 0) {
     PlatformSP host_platform_sp(Platform::GetHostPlatform());
     platform_dict->AddStringItem(
         name_str, host_platform_sp->GetPluginName().GetStringRef());
void SBDebugger::DispatchInput(const void *data, size_t data_len) {
   //                     (const char *) data,
   //                     (uint64_t)data_len);
   //
   //    if (m_opaque_sp)
   //        m_opaque_sp->DispatchInput ((const char *) data, 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;
 
     m_opaque_sp->GetCommandInterpreter().RunCommandInterpreter(
         auto_handle_events, spawn_thread, options);
   }
 }
 
 void SBDebugger::RunCommandInterpreter(bool auto_handle_events,
                                        bool spawn_thread,
                                        SBCommandInterpreterRunOptions &options,
                                        int &num_errors, bool &quit_requested,
                                        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,
                                  options.ref());
     num_errors = interp.GetNumErrors();
     quit_requested = interp.GetQuitRequested();
     stopped_for_crash = interp.GetStoppedForCrash();
   }
 }
 
 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;
 }
 
 void SBDebugger::reset(const DebuggerSP &debugger_sp) {
   m_opaque_sp = debugger_sp;
 }
 
 Debugger *SBDebugger::get() const { return m_opaque_sp.get(); }
 
 Debugger &SBDebugger::ref() const {
   assert(m_opaque_sp.get());
   return *m_opaque_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;
 }
 
 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)));
   Status error;
   if (debugger_sp) {
     ExecutionContext exe_ctx(
         debugger_sp->GetCommandInterpreter().GetExecutionContext());
     error = debugger_sp->SetPropertyValue(&exe_ctx, eVarSetOperationAssign,
                                           var_name, value);
   } else {
     error.SetErrorStringWithFormat("invalid debugger instance name '%s'",
                                    debugger_instance_name);
   }
   if (error.Fail())
     sb_error.SetError(error);
   return sb_error;
 }
 
 SBStringList
 SBDebugger::GetInternalVariableValue(const char *var_name,
                                      const char *debugger_instance_name) {
+  LLDB_RECORD_STATIC_METHOD(
+      lldb::SBStringList, SBDebugger, GetInternalVariableValue,
+      (const char *, const char *), var_name, debugger_instance_name);
+
   SBStringList ret_value;
   DebuggerSP debugger_sp(Debugger::FindDebuggerWithInstanceName(
       ConstString(debugger_instance_name)));
   Status error;
   if (debugger_sp) {
     ExecutionContext exe_ctx(
         debugger_sp->GetCommandInterpreter().GetExecutionContext());
     lldb::OptionValueSP value_sp(
         debugger_sp->GetPropertyValue(&exe_ctx, var_name, false, error));
     if (value_sp) {
       StreamString value_strm;
       value_sp->DumpValue(&exe_ctx, value_strm, OptionValue::eDumpOptionValue);
       const std::string &value_str = value_strm.GetString();
       if (!value_str.empty()) {
         StringList string_list;
         string_list.SplitIntoLines(value_str);
         return SBStringList(&string_list);
       }
     }
   }
   return 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)
     log->Printf("SBDebugger(%p)::GetPrompt () => \"%s\"",
                 static_cast<void *>(m_opaque_sp.get()),
                 (m_opaque_sp ? m_opaque_sp->GetPrompt().str().c_str() : ""));
 
   return (m_opaque_sp ? ConstString(m_opaque_sp->GetPrompt()).GetCString()
                       : nullptr);
 }
 
 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) {
     const char *name = m_opaque_sp->GetInstanceName().AsCString();
     user_id_t id = m_opaque_sp->GetID();
     strm.Printf("Debugger (instance: \"%s\", id: %" PRIu64 ")", name, id);
   } else
     strm.PutCString("No value");
 
   return true;
 }
 
 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]) {
       ConstString platform_name(platform_name_cstr);
       PlatformSP platform_sp(Platform::Find(platform_name));
 
       if (platform_sp) {
         // Already have a platform with this name, just select it
if (m_opaque_sp) {
     }
   } else {
     sb_error.ref().SetErrorString("invalid debugger");
   }
   return 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(
         m_opaque_sp->GetPlatformList().GetSelectedPlatform());
 
     if (platform_sp) {
       if (log && sysroot)
         log->Printf("SBDebugger::SetCurrentPlatformSDKRoot (\"%s\")", sysroot);
       platform_sp->SetSDKRootDirectory(ConstString(sysroot));
       return true;
     }
   }
   return false;
 }
 
 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();
 
   TypeCategoryImplSP category_sp;
 
   if (DataVisualization::Categories::GetCategory(ConstString(category_name),
                                                  category_sp, false))
     return SBTypeCategory(category_sp);
   else
     return 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();
 }
 
 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();
 
   TypeCategoryImplSP category_sp;
 
   if (DataVisualization::Categories::GetCategory(ConstString(category_name),
                                                  category_sp, true))
     return SBTypeCategory(category_sp);
   else
     return 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;
 
   return DataVisualization::Categories::Delete(ConstString(category_name));
 }
 
 uint32_t SBDebugger::GetNumCategories() {
+  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBDebugger, GetNumCategories);
+
   return DataVisualization::Categories::GetCount();
 }
 
 SBTypeCategory SBDebugger::GetCategoryAtIndex(uint32_t index) {
+  LLDB_RECORD_METHOD(lldb::SBTypeCategory, SBDebugger, GetCategoryAtIndex,
+                     (uint32_t), index);
+
   return SBTypeCategory(
       DataVisualization::Categories::GetCategoryAtIndex(index));
 }
 
 SBTypeCategory SBDebugger::GetDefaultCategory() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTypeCategory, SBDebugger,
+                             GetDefaultCategory);
+
   return 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();
 }
 
 #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()));
 }
 #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()));
 }
 
 #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()));
 }
 #endif // LLDB_DISABLE_PYTHON
 
 static llvm::ArrayRef<const char *> GetCategoryArray(const char **categories) {
   if (categories == nullptr)
     return {};
   size_t len = 0;
   while (categories[len] != nullptr)
     ++len;
   return llvm::makeArrayRef(categories, len);
 }
 
 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;
     std::string error;
     llvm::raw_string_ostream error_stream(error);
     return m_opaque_sp->EnableLog(channel, GetCategoryArray(categories), "",
                                   log_options, error_stream);
   } else

lldb/source/API/SBDeclaration.cpp

 //===-- SBDeclaration.cpp ----------------------------------------*- C++-*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBDeclaration.h"
+#include "SBReproducerPrivate.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/Host/PosixApi.h"
 #include "lldb/Symbol/Declaration.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/Stream.h"
 
 #include <limits.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();
 }
 
 SBDeclaration::SBDeclaration(const lldb_private::Declaration *lldb_object_ptr)
     : m_opaque_up() {
   if (lldb_object_ptr)
     ref() = *lldb_object_ptr;
 }
 
 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();
     else
       m_opaque_up.reset();
   }
   return *this;
 }
 
 void SBDeclaration::SetDeclaration(
     const lldb_private::Declaration &lldb_object_ref) {
   ref() = lldb_object_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;
   if (m_opaque_up.get() && m_opaque_up->GetFile())
     sb_file_spec.SetFileSpec(m_opaque_up->GetFile());
 
   if (log) {
     SBStream sstr;
     sb_file_spec.GetDescription(sstr);
     log->Printf("SBLineEntry(%p)::GetFileSpec () => SBFileSpec(%p): %s",
                 static_cast<void *>(m_opaque_up.get()),
                 static_cast<const void *>(sb_file_spec.get()), sstr.GetData());
   }
 
   return 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;
   if (m_opaque_up)
     line = m_opaque_up->GetLine();
 
   if (log)
     log->Printf("SBLineEntry(%p)::GetLine () => %u",
                 static_cast<void *>(m_opaque_up.get()), line);
 
   return line;
 }
 
 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();
 
   if (lhs_ptr && rhs_ptr)
     return lldb_private::Declaration::Compare(*lhs_ptr, *rhs_ptr) == 0;
 
   return lhs_ptr == rhs_ptr;
 }
 
 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();
 
   if (lhs_ptr && rhs_ptr)
     return lldb_private::Declaration::Compare(*lhs_ptr, *rhs_ptr) != 0;
 
   return lhs_ptr != rhs_ptr;
 }
 
 const lldb_private::Declaration *SBDeclaration::operator->() const {
   return m_opaque_up.get();
 }
 
 lldb_private::Declaration &SBDeclaration::ref() {
   if (m_opaque_up == NULL)
     m_opaque_up.reset(new lldb_private::Declaration());
   return *m_opaque_up;
 }
 
 const lldb_private::Declaration &SBDeclaration::ref() const {
   return *m_opaque_up;
 }
 
 bool SBDeclaration::GetDescription(SBStream &description) {
+  LLDB_RECORD_METHOD(bool, SBDeclaration, GetDescription, (lldb::SBStream &),
+                     description);
+
   Stream &strm = description.ref();
 
   if (m_opaque_up) {
     char file_path[PATH_MAX * 2];
     m_opaque_up->GetFile().GetPath(file_path, sizeof(file_path));
     strm.Printf("%s:%u", file_path, GetLine());
     if (GetColumn() > 0)
       strm.Printf(":%u", GetColumn());
   } else
     strm.PutCString("No value");
 
   return true;
 }
 
 lldb_private::Declaration *SBDeclaration::get() { return m_opaque_up.get(); }

lldb/source/API/SBError.cpp

 //===-- SBError.cpp ---------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBError.h"
+#include "SBReproducerPrivate.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/Status.h"
 
 #include <stdarg.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;
     else
       m_opaque_up.reset(new Status(*rhs));
   } else
     m_opaque_up.reset();
 
   return *this;
 }
 
 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;
   if (m_opaque_up)
     ret_value = m_opaque_up->Fail();
 
   if (log)
     log->Printf("SBError(%p)::Fail () => %i",
                 static_cast<void *>(m_opaque_up.get()), ret_value);
 
   return ret_value;
 }
 
 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)
     ret_value = m_opaque_up->Success();
 
   if (log)
     log->Printf("SBError(%p)::Success () => %i",
                 static_cast<void *>(m_opaque_up.get()), ret_value);
 
   return ret_value;
 }
 
 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;
   if (m_opaque_up)
     err = m_opaque_up->GetError();
 
   if (log)
     log->Printf("SBError(%p)::GetError () => 0x%8.8x",
                 static_cast<void *>(m_opaque_up.get()), err);
 
   return err;
 }
 
 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)
     err_type = m_opaque_up->GetType();
 
   if (log)
     log->Printf("SBError(%p)::GetType () => %i",
                 static_cast<void *>(m_opaque_up.get()), err_type);
 
   return err_type;
 }
 
 void SBError::SetError(uint32_t err, ErrorType type) {
+  LLDB_RECORD_METHOD(void, SBError, SetError, (uint32_t, lldb::ErrorType), err,
+                     type);
+
   CreateIfNeeded();
   m_opaque_up->SetError(err, type);
 }
 
 void SBError::SetError(const Status &lldb_error) {
   CreateIfNeeded();
   *m_opaque_up = lldb_error;
 }
 
 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);
 }
 
 int SBError::SetErrorStringWithFormat(const char *format, ...) {
   CreateIfNeeded();
   va_list args;
   va_start(args, format);
   int num_chars = m_opaque_up->SetErrorStringWithVarArg(format, args);
   va_end(args);
   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)
     m_opaque_up.reset(new Status());
 }
 
 lldb_private::Status *SBError::operator->() { return m_opaque_up.get(); }
 
 lldb_private::Status *SBError::get() { return m_opaque_up.get(); }
 
 lldb_private::Status &SBError::ref() {
   CreateIfNeeded();
   return *m_opaque_up;
 }
 
 const lldb_private::Status &SBError::operator*() const {
   // Be sure to call "IsValid()" before calling this function or it will crash
   return *m_opaque_up;
 }
 
 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");
     else {
       const char *err_string = GetCString();
       description.Printf("error: %s", (err_string != NULL ? err_string : ""));
     }
   } else
     description.Printf("error: <NULL>");
 
   return true;
 }

lldb/source/API/SBEvent.cpp

 //===-- SBEvent.cpp ---------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
+#include "SBReproducerPrivate.h"
+
 #include "lldb/API/SBEvent.h"
 #include "lldb/API/SBBroadcaster.h"
 #include "lldb/API/SBStream.h"
 
 #include "lldb/Breakpoint/Breakpoint.h"
 #include "lldb/Core/StreamFile.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/Event.h"
 #include "lldb/Utility/Stream.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;
   }
   return *this;
 }
 
 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();
     if (event_data)
       return lldb_event->GetData()->GetFlavor().AsCString();
   }
   return NULL;
 }
 
 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();
   uint32_t event_type = 0;
   if (lldb_event)
     event_type = lldb_event->GetType();
 
   if (log) {
     StreamString sstr;
     if (lldb_event && lldb_event->GetBroadcaster() &&
         lldb_event->GetBroadcaster()->GetEventNames(sstr, event_type, true))
       log->Printf("SBEvent(%p)::GetType () => 0x%8.8x (%s)",
                   static_cast<void *>(get()), event_type, sstr.GetData());
     else
       log->Printf("SBEvent(%p)::GetType () => 0x%8.8x",
                   static_cast<void *>(get()), event_type);
   }
 
   return event_type;
 }
 
 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;
 }
 
 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();
   else
     return "unknown class";
 }
 
 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;
   if (lldb_event)
     success = lldb_event->BroadcasterIs(broadcaster.get());
 
   // For logging, this gets a little chatty so only enable this when verbose
   // logging is on
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   LLDB_LOGV(log, "({0}) (SBBroadcaster({1}): {2}) => {3}", get(),
             broadcaster.get(), broadcaster.GetName(), success);
 
   return success;
 }
 
 void SBEvent::Clear() {
+  LLDB_RECORD_METHOD_NO_ARGS(void, SBEvent, Clear);
+
   Event *lldb_event = get();
   if (lldb_event)
     lldb_event->Clear();
 }
 
 EventSP &SBEvent::GetSP() const { return m_event_sp; }
 
 Event *SBEvent::get() const {

 }
 
 void SBEvent::reset(Event *event_ptr) {
   m_opaque_ptr = event_ptr;
   m_event_sp.reset();
 }
 
 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)
     log->Printf("SBEvent(%p)::GetCStringFromEvent () => \"%s\"",
                 static_cast<void *>(event.get()),
                 reinterpret_cast<const char *>(
                     EventDataBytes::GetBytesFromEvent(event.get())));
 
   return reinterpret_cast<const char *>(
       EventDataBytes::GetBytesFromEvent(event.get()));
 }
 
 bool SBEvent::GetDescription(SBStream &description) {
+  LLDB_RECORD_METHOD(bool, SBEvent, GetDescription, (lldb::SBStream &),
+                     description);
+
   Stream &strm = description.ref();
 
   if (get()) {
     m_opaque_ptr->Dump(&strm);
   } else
     strm.PutCString("No value");
 
   return true;
 }
 
 bool SBEvent::GetDescription(SBStream &description) const {
+  LLDB_RECORD_METHOD_CONST(bool, SBEvent, GetDescription, (lldb::SBStream &),
+                           description);
+
   Stream &strm = description.ref();
 
   if (get()) {
     m_opaque_ptr->Dump(&strm);
   } else
     strm.PutCString("No value");
 
   return true;
 }

lldb/source/API/SBExecutionContext.cpp

 //===-- SBExecutionContext.cpp ------------------------------------*- C++
 //-*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
+#include "SBReproducerPrivate.h"
+
 #include "lldb/API/SBExecutionContext.h"
 
 #include "lldb/API/SBFrame.h"
 #include "lldb/API/SBProcess.h"
 #include "lldb/API/SBTarget.h"
 #include "lldb/API/SBThread.h"
 
 #include "lldb/Target/ExecutionContext.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());
 }
 
 SBExecutionContext::~SBExecutionContext() {}
 
 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;
 }
 
 ExecutionContextRef *SBExecutionContext::get() const {
   return m_exe_ctx_sp.get();
 }
 
 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;
 }
 
 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;
 }
 
 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;
 }
 
 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;
 }

lldb/source/API/SBExpressionOptions.cpp

 //===-- SBExpressionOptions.cpp ---------------------------------------------*-
 //C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBExpressionOptions.h"
+#include "SBReproducerPrivate.h"
 #include "lldb/API/SBStream.h"
 
 #include "lldb/Target/Target.h"
 
 using namespace lldb;
 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();
   }
   return *this;
 }
 
 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);
 }
 
 void SBExpressionOptions::SetCancelCallback(
     lldb::ExpressionCancelCallback callback, void *baton) {
   m_opaque_up->SetCancelCallback(callback, baton);
 }
 
 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);
 }
 
 EvaluateExpressionOptions *SBExpressionOptions::get() const {
   return m_opaque_up.get();
 }
 
 EvaluateExpressionOptions &SBExpressionOptions::ref() const {
   return *(m_opaque_up.get());
 }

lldb/source/API/SBFileSpec.cpp

 //===-- SBFileSpec.cpp ------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include <inttypes.h>
 #include <limits.h>
 
+#include "SBReproducerPrivate.h"
 #include "lldb/API/SBFileSpec.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/Host/FileSystem.h"
 #include "lldb/Host/PosixApi.h"
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/Stream.h"
 
 #include "llvm/ADT/SmallString.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);
 
   if (log)
     log->Printf("SBFileSpec(%p)::Exists () => %s",
                 static_cast<void *>(m_opaque_up.get()),
                 (result ? "true" : "false"));
 
   return result;
 }
 
 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());
   return std::min(dst_len - 1, result.size());
 }
 
 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));
   if (log) {
     if (s)
       log->Printf("SBFileSpec(%p)::GetFilename () => \"%s\"",
                   static_cast<void *>(m_opaque_up.get()), s);
     else
       log->Printf("SBFileSpec(%p)::GetFilename () => NULL",
                   static_cast<void *>(m_opaque_up.get()));
   }
 
   return s;
 }
 
 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));
   if (log) {
     if (directory)
       log->Printf("SBFileSpec(%p)::GetDirectory () => \"%s\"",
                   static_cast<void *>(m_opaque_up.get()),
                   directory.GetCString());
     else
       log->Printf("SBFileSpec(%p)::GetDirectory () => NULL",
                   static_cast<void *>(m_opaque_up.get()));
   }
   return directory.GetCString();
 }
 
 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
     m_opaque_up->GetFilename().Clear();
 }
 
 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
     m_opaque_up->GetDirectory().Clear();
 }
 
 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);
 
   if (log)
     log->Printf("SBFileSpec(%p)::GetPath (dst_path=\"%.*s\", dst_len=%" PRIu64
                 ") => %u",
                 static_cast<void *>(m_opaque_up.get()), result, dst_path,

 
 const lldb_private::FileSpec &SBFileSpec::ref() const { return *m_opaque_up; }
 
 void SBFileSpec::SetFileSpec(const lldb_private::FileSpec &fs) {
   *m_opaque_up = fs;
 }
 
 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)))
     strm.PutCString(path);
   return true;
 }
 
 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

 //===-- SBFileSpecList.cpp --------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include <limits.h>
 
+#include "SBReproducerPrivate.h"
 #include "lldb/API/SBFileSpec.h"
 #include "lldb/API/SBFileSpecList.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/Core/FileSpecList.h"
 #include "lldb/Host/PosixApi.h"
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/Stream.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)
     m_opaque_up.reset(new FileSpecList(*(rhs.get())));
 
   if (log) {
     log->Printf("SBFileSpecList::SBFileSpecList (const SBFileSpecList "
                 "rhs.ap=%p) => SBFileSpecList(%p)",
                 static_cast<void *>(rhs.m_opaque_up.get()),
                 static_cast<void *>(m_opaque_up.get()));
   }
 }
 
 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;
 }
 
 const lldb_private::FileSpecList *SBFileSpecList::operator->() const {
   return m_opaque_up.get();
 }
 
 const lldb_private::FileSpecList *SBFileSpecList::get() const {
   return m_opaque_up.get();
 }
 
 const lldb_private::FileSpecList &SBFileSpecList::operator*() const {
   return *m_opaque_up;
 }
 
 const lldb_private::FileSpecList &SBFileSpecList::ref() const {
   return *m_opaque_up;
 }
 
 bool SBFileSpecList::GetDescription(SBStream &description) const {
+  LLDB_RECORD_METHOD_CONST(bool, SBFileSpecList, GetDescription,
+                           (lldb::SBStream &), description);
+
   Stream &strm = description.ref();
 
   if (m_opaque_up) {
     uint32_t num_files = m_opaque_up->GetSize();
     strm.Printf("%d files: ", num_files);
     for (uint32_t i = 0; i < num_files; i++) {
       char path[PATH_MAX];
       if (m_opaque_up->GetFileSpecAtIndex(i).GetPath(path, sizeof(path)))
         strm.Printf("\n    %s", path);
     }
   } else
     strm.PutCString("No value");
 
   return true;
 }

lldb/source/API/SBFrame.cpp

 //===-- SBFrame.cpp ---------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
+#include "SBReproducerPrivate.h"
+
 #include <algorithm>
 #include <set>
 #include <string>
 
 #include "lldb/API/SBFrame.h"
 
 #include "lldb/lldb-types.h"
 

 #include "lldb/API/SBValue.h"
 #include "lldb/API/SBVariablesOptions.h"
 
 #include "llvm/Support/PrettyStackTrace.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) {
     SBStream sstr;
     GetDescription(sstr);
     log->Printf("SBFrame::SBFrame (sp=%p) => SBFrame(%p): %s",
                 static_cast<void *>(lldb_object_sp.get()),
                 static_cast<void *>(lldb_object_sp.get()), sstr.GetData());
   }
 }
 
 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;
 }
 
 StackFrameSP SBFrame::GetFrameSP() const {
   return (m_opaque_sp ? m_opaque_sp->GetFrameSP() : StackFrameSP());
 }
 
 void SBFrame::SetFrameSP(const StackFrameSP &lldb_object_sp) {
   return m_opaque_sp->SetFrameSP(lldb_object_sp);
 }
 
 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);
 
   Target *target = exe_ctx.GetTargetPtr();
   Process *process = exe_ctx.GetProcessPtr();
   if (target && process) {
     Process::StopLocker stop_locker;
     if (stop_locker.TryLock(&process->GetRunLock()))
       return GetFrameSP().get() != nullptr;
   }
 
   // Without a target & process we can't have a valid stack frame.
   return false;
 }
 
 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;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
   SymbolContextItem scope = static_cast<SymbolContextItem>(resolve_scope);
   StackFrame *frame = nullptr;
   Target *target = exe_ctx.GetTargetPtr();
   Process *process = exe_ctx.GetProcessPtr();
log->Printf("SBFrame(%p)::GetSymbolContext (resolve_scope=0x%8.8x) => "
                 "SBSymbolContext(%p)",
                 static_cast<void *>(frame), resolve_scope,
                 static_cast<void *>(sb_sym_ctx.get()));
 
   return 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;
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
   StackFrame *frame = nullptr;
   Target *target = exe_ctx.GetTargetPtr();
if (log)
     log->Printf("SBFrame(%p)::GetModule () => SBModule(%p)",
                 static_cast<void *>(frame),
                 static_cast<void *>(module_sp.get()));
 
   return 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;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
   StackFrame *frame = nullptr;
   Target *target = exe_ctx.GetTargetPtr();
   Process *process = exe_ctx.GetProcessPtr();
if (log)
     log->Printf("SBFrame(%p)::GetCompileUnit () => SBCompileUnit(%p)",
                 static_cast<void *>(frame),
                 static_cast<void *>(sb_comp_unit.get()));
 
   return 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;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
   StackFrame *frame = nullptr;
   Target *target = exe_ctx.GetTargetPtr();
   Process *process = exe_ctx.GetProcessPtr();
if (log)
     log->Printf("SBFrame(%p)::GetFunction () => SBFunction(%p)",
                 static_cast<void *>(frame),
                 static_cast<void *>(sb_function.get()));
 
   return 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;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
   StackFrame *frame = nullptr;
   Target *target = exe_ctx.GetTargetPtr();
   Process *process = exe_ctx.GetProcessPtr();
SBSymbol SBFrame::GetSymbol() const {
   if (log)
     log->Printf("SBFrame(%p)::GetSymbol () => SBSymbol(%p)",
                 static_cast<void *>(frame),
                 static_cast<void *>(sb_symbol.get()));
   return 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;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
   StackFrame *frame = nullptr;
   Target *target = exe_ctx.GetTargetPtr();
   Process *process = exe_ctx.GetProcessPtr();
SBBlock SBFrame::GetBlock() const {
   if (log)
     log->Printf("SBFrame(%p)::GetBlock () => SBBlock(%p)",
                 static_cast<void *>(frame),
                 static_cast<void *>(sb_block.GetPtr()));
   return 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);
 
   StackFrame *frame = nullptr;
   Target *target = exe_ctx.GetTargetPtr();
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   Process *process = exe_ctx.GetProcessPtr();
SBBlock SBFrame::GetFrameBlock() const {
   if (log)
     log->Printf("SBFrame(%p)::GetFrameBlock () => SBBlock(%p)",
                 static_cast<void *>(frame),
                 static_cast<void *>(sb_block.GetPtr()));
   return 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;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
   StackFrame *frame = nullptr;
   Target *target = exe_ctx.GetTargetPtr();
   Process *process = exe_ctx.GetProcessPtr();
SBLineEntry SBFrame::GetLineEntry() const {
   if (log)
     log->Printf("SBFrame(%p)::GetLineEntry () => SBLineEntry(%p)",
                 static_cast<void *>(frame),
                 static_cast<void *>(sb_line_entry.get()));
   return 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;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
   StackFrame *frame = exe_ctx.GetFramePtr();
   if (frame)
     frame_idx = frame->GetFrameIndex();
 
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   if (log)
     log->Printf("SBFrame(%p)::GetFrameID () => %u", static_cast<void *>(frame),
                 frame_idx);
   return frame_idx;
 }
 
 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);
 
   StackFrame *frame = exe_ctx.GetFramePtr();
   if (frame)
     return frame->GetStackID().GetCallFrameAddress();
   return LLDB_INVALID_ADDRESS;
 }
 
 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;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
   StackFrame *frame = nullptr;
   Target *target = exe_ctx.GetTargetPtr();
   Process *process = exe_ctx.GetProcessPtr();
addr_t SBFrame::GetPC() const {
   if (log)
     log->Printf("SBFrame(%p)::GetPC () => 0x%" PRIx64,
                 static_cast<void *>(frame), addr);
 
   return addr;
 }
 
 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;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
   StackFrame *frame = nullptr;
   Target *target = exe_ctx.GetTargetPtr();
   Process *process = exe_ctx.GetProcessPtr();
bool SBFrame::SetPC(addr_t new_pc) {
   if (log)
     log->Printf("SBFrame(%p)::SetPC (new_pc=0x%" PRIx64 ") => %i",
                 static_cast<void *>(frame), new_pc, ret_val);
 
   return ret_val;
 }
 
 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;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
   StackFrame *frame = nullptr;
   Target *target = exe_ctx.GetTargetPtr();
   Process *process = exe_ctx.GetProcessPtr();
addr_t SBFrame::GetSP() const {
   if (log)
     log->Printf("SBFrame(%p)::GetSP () => 0x%" PRIx64,
                 static_cast<void *>(frame), addr);
 
   return addr;
 }
 
 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;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
   StackFrame *frame = nullptr;
   Target *target = exe_ctx.GetTargetPtr();
   Process *process = exe_ctx.GetProcessPtr();
addr_t SBFrame::GetFP() const {
 
   if (log)
     log->Printf("SBFrame(%p)::GetFP () => 0x%" PRIx64,
                 static_cast<void *>(frame), addr);
   return addr;
 }
 
 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;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
   StackFrame *frame = exe_ctx.GetFramePtr();
   Target *target = exe_ctx.GetTargetPtr();
   Process *process = exe_ctx.GetProcessPtr();
if (target && process) {
     }
   }
   if (log)
     log->Printf("SBFrame(%p)::GetPCAddress () => SBAddress(%p)",
                 static_cast<void *>(frame), static_cast<void *>(sb_addr.get()));
   return 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);
 
   StackFrame *frame = exe_ctx.GetFramePtr();
   Target *target = exe_ctx.GetTargetPtr();
   if (frame && target) {
     lldb::DynamicValueType use_dynamic =
         frame->CalculateTarget()->GetPreferDynamicValue();
     sb_value = GetValueForVariablePath(var_path, use_dynamic);
   }
   return sb_value;
 }
 
 lldb::SBValue SBFrame::GetValueForVariablePath(const char *var_path,
                                                DynamicValueType use_dynamic) {
+  LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, GetValueForVariablePath,
+                     (const char *, lldb::DynamicValueType), var_path,
+                     use_dynamic);
+
   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;
   }
if (stop_locker.TryLock(&process->GetRunLock())) {
         log->Printf(
             "SBFrame::GetValueForVariablePath () => error: process is running");
     }
   }
   return 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);
 
   StackFrame *frame = exe_ctx.GetFramePtr();
   Target *target = exe_ctx.GetTargetPtr();
   if (frame && target) {
     lldb::DynamicValueType use_dynamic =
         frame->CalculateTarget()->GetPreferDynamicValue();
     value = FindVariable(name, use_dynamic);
   }
   return value;
 }
 
 SBValue SBFrame::FindVariable(const char *name,
                               lldb::DynamicValueType use_dynamic) {
+  LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, FindVariable,
+                     (const char *, lldb::DynamicValueType), name, use_dynamic);
+
   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;
if (log)
     log->Printf("SBFrame(%p)::FindVariable (name=\"%s\") => SBValue(%p)",
                 static_cast<void *>(frame), name,
                 static_cast<void *>(value_sp.get()));
 
   return sb_value;
 }
 
 SBValue SBFrame::FindValue(const char *name, ValueType value_type) {
+  LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, FindValue,
+                     (const char *, lldb::ValueType), name, value_type);
+
   SBValue value;
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
   StackFrame *frame = exe_ctx.GetFramePtr();
   Target *target = exe_ctx.GetTargetPtr();
   if (frame && target) {
     lldb::DynamicValueType use_dynamic =
         frame->CalculateTarget()->GetPreferDynamicValue();
     value = FindValue(name, value_type, use_dynamic);
   }
   return value;
 }
 
 SBValue SBFrame::FindValue(const char *name, ValueType value_type,
                            lldb::DynamicValueType use_dynamic) {
+  LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, FindValue,
+                     (const char *, lldb::ValueType, lldb::DynamicValueType),
+                     name, value_type, use_dynamic);
+
   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;
   }
log->Printf("SBFrame(%p)::FindVariableInScope (name=\"%s\", value_type=%i) "
                 "=> SBValue(%p)",
                 static_cast<void *>(frame), name, value_type,
                 static_cast<void *>(value_sp.get()));
 
   return 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;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
   ThreadSP thread_sp(exe_ctx.GetThreadSP());
   SBThread sb_thread(thread_sp);
 
   if (log) {
     SBStream sstr;
     sb_thread.GetDescription(sstr);
     log->Printf("SBFrame(%p)::GetThread () => SBThread(%p): %s",
                 static_cast<void *>(exe_ctx.GetFramePtr()),
                 static_cast<void *>(thread_sp.get()), sstr.GetData());
   }
 
   return 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;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
   StackFrame *frame = nullptr;
   Target *target = exe_ctx.GetTargetPtr();
   Process *process = exe_ctx.GetProcessPtr();
if (log)
     log->Printf("SBFrame(%p)::Disassemble () => %s", static_cast<void *>(frame),
                 disassembly);
 
   return disassembly;
 }
 
 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);
 
   StackFrame *frame = exe_ctx.GetFramePtr();
   Target *target = exe_ctx.GetTargetPtr();
   if (frame && target) {
     lldb::DynamicValueType use_dynamic =
if (frame && target) {
     value_list = GetVariables(options);
   }
   return value_list;
 }
 
 lldb::SBValueList SBFrame::GetVariables(bool arguments, bool locals,
                                         bool statics, bool in_scope_only,
                                         lldb::DynamicValueType use_dynamic) {
+  LLDB_RECORD_METHOD(lldb::SBValueList, SBFrame, GetVariables,
+                     (bool, bool, bool, bool, lldb::DynamicValueType),
+                     arguments, locals, statics, in_scope_only, use_dynamic);
+
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
   Target *target = exe_ctx.GetTargetPtr();
   const bool include_runtime_support_values =
       target ? target->GetDisplayRuntimeSupportValues() : false;
   SBVariablesOptions options;
   options.SetIncludeArguments(arguments);
   options.SetIncludeLocals(locals);
   options.SetIncludeStatics(statics);
   options.SetInScopeOnly(in_scope_only);
   options.SetIncludeRuntimeSupportValues(include_runtime_support_values);
   options.SetUseDynamic(use_dynamic);
   return 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;
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
   StackFrame *frame = nullptr;
   Target *target = exe_ctx.GetTargetPtr();
if (log)
     log->Printf("SBFrame(%p)::GetVariables (...) => SBValueList(%p)",
                 static_cast<void *>(frame),
                 static_cast<void *>(value_list.opaque_ptr()));
 
   return value_list;
 }
 
 SBValueList SBFrame::GetRegisters() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBValueList, SBFrame, GetRegisters);
+
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   SBValueList value_list;
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
   StackFrame *frame = nullptr;
   Target *target = exe_ctx.GetTargetPtr();
if (log)
     log->Printf("SBFrame(%p)::GetRegisters () => SBValueList(%p)",
                 static_cast<void *>(frame),
                 static_cast<void *>(value_list.opaque_ptr()));
 
   return 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;
   ValueObjectSP value_sp;
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
   StackFrame *frame = nullptr;
if (log)
     log->Printf("SBFrame(%p)::FindRegister () => SBValue(%p)",
                 static_cast<void *>(frame),
                 static_cast<void *>(value_sp.get()));
 
   return 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();
 
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
   StackFrame *frame;
   Target *target = exe_ctx.GetTargetPtr();
bool SBFrame::GetDescription(SBStream &description) {
 
   } else
     strm.PutCString("No value");
 
   return true;
 }
 
 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);
 
   StackFrame *frame = exe_ctx.GetFramePtr();
   Target *target = exe_ctx.GetTargetPtr();
   if (frame && target) {
     SBExpressionOptions options;
if (frame && target) {
     return EvaluateExpression(expr, options);
   }
   return result;
 }
 
 SBValue
 SBFrame::EvaluateExpression(const char *expr,
                             lldb::DynamicValueType fetch_dynamic_value) {
+  LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, EvaluateExpression,
+                     (const char *, lldb::DynamicValueType), expr,
+                     fetch_dynamic_value);
+
   SBExpressionOptions options;
   options.SetFetchDynamicValue(fetch_dynamic_value);
   options.SetUnwindOnError(true);
   options.SetIgnoreBreakpoints(true);
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
   StackFrame *frame = exe_ctx.GetFramePtr();
   Target *target = exe_ctx.GetTargetPtr();
   if (target && target->GetLanguage() != eLanguageTypeUnknown)
     options.SetLanguage(target->GetLanguage());
   else if (frame)
     options.SetLanguage(frame->GetLanguage());
   return EvaluateExpression(expr, options);
 }
 
 SBValue SBFrame::EvaluateExpression(const char *expr,
                                     lldb::DynamicValueType fetch_dynamic_value,
                                     bool unwind_on_error) {
+  LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, EvaluateExpression,
+                     (const char *, lldb::DynamicValueType, bool), expr,
+                     fetch_dynamic_value, unwind_on_error);
+
   SBExpressionOptions options;
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
   options.SetFetchDynamicValue(fetch_dynamic_value);
   options.SetUnwindOnError(unwind_on_error);
   options.SetIgnoreBreakpoints(true);
   StackFrame *frame = exe_ctx.GetFramePtr();
   Target *target = exe_ctx.GetTargetPtr();
   if (target && target->GetLanguage() != eLanguageTypeUnknown)
     options.SetLanguage(target->GetLanguage());
   else if (frame)
     options.SetLanguage(frame->GetLanguage());
   return EvaluateExpression(expr, options);
 }
 
 lldb::SBValue SBFrame::EvaluateExpression(const char *expr,
                                           const SBExpressionOptions &options) {
+  LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, EvaluateExpression,
+                     (const char *, const lldb::SBExpressionOptions &), expr,
+                     options);
+
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
 #ifndef LLDB_DISABLE_PYTHON
   Log *expr_log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
 #endif
 
   ExpressionResults exe_results = eExpressionSetupError;
   SBValue expr_result;
log->Printf("SBFrame(%p)::EvaluateExpression (expr=\"%s\") => SBValue(%p) "
                 static_cast<void *>(frame), expr,
                 static_cast<void *>(expr_value_sp.get()), exe_results);
 #endif
 
   return 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);
 
   StackFrame *frame = nullptr;
   Target *target = exe_ctx.GetTargetPtr();
   Process *process = exe_ctx.GetProcessPtr();
   if (target && process) {
if (stop_locker.TryLock(&process->GetRunLock())) {
       if (log)
         log->Printf("SBFrame::IsInlined () => error: process is running");
     }
   }
   return false;
 }
 
 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);
 
   StackFrame *frame = exe_ctx.GetFramePtr();
   if (frame)
     return frame->IsArtificial();
 
   return false;
 }
 
 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);
   
   StackFrame *frame = nullptr;
   Target *target = exe_ctx.GetTargetPtr();
   Process *process = exe_ctx.GetProcessPtr();
   if (target && process) {
     Process::StopLocker stop_locker;
     if (stop_locker.TryLock(&process->GetRunLock())) {
       frame = exe_ctx.GetFramePtr();
       if (frame) {
         return frame->GuessLanguage();
       }
     }
   }
   return eLanguageTypeUnknown;
 }
 
 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;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
   StackFrame *frame = nullptr;
   Target *target = exe_ctx.GetTargetPtr();
   Process *process = exe_ctx.GetProcessPtr();
if (stop_locker.TryLock(&process->GetRunLock())) {
       if (log)
         log->Printf("SBFrame::GetFunctionName() => error: process is running");
     }
   }
   return name;
 }
 
 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;
 
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
   StackFrame *frame = nullptr;
   Target *target = exe_ctx.GetTargetPtr();

lldb/source/API/SBFunction.cpp

 //===-- SBFunction.cpp ------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
+#include "SBReproducerPrivate.h"
+
 #include "lldb/API/SBFunction.h"
 #include "lldb/API/SBProcess.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/Core/Disassembler.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Symbol/CompileUnit.h"
 #include "lldb/Symbol/Function.h"
 #include "lldb/Symbol/Type.h"
 #include "lldb/Symbol/VariableList.h"
 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/Log.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();
 
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   if (log) {
     if (cstr)
       log->Printf("SBFunction(%p)::GetName () => \"%s\"",
                   static_cast<void *>(m_opaque_ptr), cstr);
     else
       log->Printf("SBFunction(%p)::GetName () => NULL",
                   static_cast<void *>(m_opaque_ptr));
   }
   return cstr;
 }
 
 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()
                .GetDisplayDemangledName(m_opaque_ptr->GetLanguage())
                .AsCString();
 
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   if (log) {
     if (cstr)
       log->Printf("SBFunction(%p)::GetDisplayName () => \"%s\"",
                   static_cast<void *>(m_opaque_ptr), cstr);
     else
       log->Printf("SBFunction(%p)::GetDisplayName () => NULL",
                   static_cast<void *>(m_opaque_ptr));
   }
   return cstr;
 }
 
 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();
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   if (log) {
     if (cstr)
       log->Printf("SBFunction(%p)::GetMangledName () => \"%s\"",
                   static_cast<void *>(m_opaque_ptr), cstr);
     else
       log->Printf("SBFunction(%p)::GetMangledName () => NULL",
                   static_cast<void *>(m_opaque_ptr));
   }
   return cstr;
 }
 
 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());
     Type *func_type = m_opaque_ptr->GetType();
     if (func_type)
       s.Printf(", type = %s", func_type->GetName().AsCString());
     return true;
   }
   s.Printf("No value");
   return false;
 }
 
 SBInstructionList SBFunction::GetInstructions(SBTarget target) {
+  LLDB_RECORD_METHOD(lldb::SBInstructionList, SBFunction, GetInstructions,
+                     (lldb::SBTarget), target);
+
   return 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;
     TargetSP target_sp(target.GetSP());
     std::unique_lock<std::recursive_mutex> lock;
     if (target_sp) {
       lock = std::unique_lock<std::recursive_mutex>(target_sp->GetAPIMutex());
       target_sp->CalculateExecutionContext(exe_ctx);

 
 lldb_private::Function *SBFunction::get() { return m_opaque_ptr; }
 
 void SBFunction::reset(lldb_private::Function *lldb_object_ptr) {
   m_opaque_ptr = lldb_object_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;
 }
 
 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();
     if (byte_size > 0) {
       addr.SetAddress(&m_opaque_ptr->GetAddressRange().GetBaseAddress());
       addr->Slide(byte_size);
     }
   }
   return 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);
     if (variable_list_sp) {
       VariableList arguments;
       variable_list_sp->AppendVariablesWithScope(eValueTypeVariableArgument,
                                                  arguments, true);
       lldb::VariableSP variable_sp = arguments.GetVariableAtIndex(arg_idx);
       if (variable_sp)
         return variable_sp->GetName().GetCString();
     }
   }
   return nullptr;
 }
 
 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;
 }
 
 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;
 }
 
 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();
   }
   return lldb::eLanguageTypeUnknown;
 }
 
 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();
   }
   return false;
 }

lldb/source/API/SBHostOS.cpp

 //===-- SBHostOS.cpp --------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_DISABLE_PYTHON
 #include "Plugins/ScriptInterpreter/Python/lldb-python.h"
 #endif
 
+#include "SBReproducerPrivate.h"
 #include "lldb/API/SBError.h"
 #include "lldb/API/SBHostOS.h"
+#include "lldb/API/SBReproducer.h"
 #include "lldb/Host/FileSystem.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Host/HostNativeThread.h"
 #include "lldb/Host/HostThread.h"
 #include "lldb/Host/ThreadLauncher.h"
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/Log.h"
 
 #include "Plugins/ExpressionParser/Clang/ClangHost.h"
 #ifndef LLDB_DISABLE_PYTHON
 #include "Plugins/ScriptInterpreter/Python/ScriptInterpreterPython.h"
 #endif
 
 #include "llvm/ADT/SmallString.h"
 #include "llvm/Support/Path.h"
 
 using namespace lldb;
 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;
 }
 
 SBFileSpec SBHostOS::GetLLDBPythonPath() {
+  LLDB_RECORD_STATIC_METHOD_NO_ARGS(lldb::SBFileSpec, SBHostOS,
+                                    GetLLDBPythonPath);
+
   return 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:
     fspec = HostInfo::GetShlibDir();
     break;
   case ePathTypeSupportExecutableDir:
     fspec = HostInfo::GetSupportExeDir();
     break;
#endif
   }
 
   SBFileSpec sb_fspec;
   sb_fspec.SetFileSpec(fspec);
   return sb_fspec;
 }
 
 SBFileSpec SBHostOS::GetUserHomeDirectory() {
+  LLDB_RECORD_STATIC_METHOD_NO_ARGS(SBFileSpec, SBHostOS, GetUserHomeDirectory);
   SBFileSpec sb_fspec;
 
   llvm::SmallString<64> home_dir_path;
   llvm::sys::path::home_directory(home_dir_path);
   FileSpec homedir(home_dir_path.c_str());
   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,
                                       lldb::thread_func_t thread_function,
                                       void *thread_arg, SBError *error_ptr) {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   if (log)
     log->Printf(
         "SBHostOS::ThreadCreate (name=\"%s\", thread_function=%p, "
         "thread_arg=%p, error_ptr=%p)",
         name,
         reinterpret_cast<void *>(reinterpret_cast<intptr_t>(thread_function)),
         static_cast<void *>(thread_arg), static_cast<void *>(error_ptr));
 
   // FIXME: You should log the return value?
 
   HostThread thread(ThreadLauncher::LaunchThread(
       name, thread_function, thread_arg, error_ptr ? error_ptr->get() : NULL));
   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();
   if (error_ptr)
     error_ptr->SetError(error);
   host_thread.Release();
   return error.Success();
 }
 
 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)
     error_ptr->SetErrorString("ThreadDetach is not supported on this platform");
 #else
   HostThread host_thread(thread);
   error = host_thread.GetNativeThread().Detach();
   if (error_ptr)
     error_ptr->SetError(error);
   host_thread.Release();
 #endif
   return error.Success();
 }
 
 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);
   if (error_ptr)
     error_ptr->SetError(error);
   host_thread.Release();
   return error.Success();
 }

lldb/source/API/SBInitializerOptions.cpp

 //===-- SBInitializerOptions.cpp --------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
+#include "SBReproducerPrivate.h"
+
 #include "lldb/API/SBInitializerOptions.h"
 #include "lldb/Initialization/SystemInitializer.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 SBInitializerOptions::SBInitializerOptions(const SBInitializerOptions &rhs) {
+  LLDB_RECORD_CONSTRUCTOR(SBInitializerOptions,
+                          (const lldb::SBInitializerOptions &), rhs);
+
   m_opaque_up.reset(new InitializerOptions());
   *(m_opaque_up.get()) = rhs.ref();
 }
 
 const SBInitializerOptions &SBInitializerOptions::
 operator=(const SBInitializerOptions &rhs) {
+  LLDB_RECORD_METHOD(
+      const lldb::SBInitializerOptions &,
+      SBInitializerOptions, operator=,(const lldb::SBInitializerOptions &),
+      rhs);
+
   if (this != &rhs) {
     this->ref() = rhs.ref();
   }
   return *this;
 }
 
 SBInitializerOptions::~SBInitializerOptions() {}
 
 SBInitializerOptions::SBInitializerOptions() {
+  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBInitializerOptions);
+
   m_opaque_up.reset(new InitializerOptions());
 }
 
 void SBInitializerOptions::SetCaptureReproducer(bool b) {
+  LLDB_RECORD_METHOD(void, SBInitializerOptions, SetCaptureReproducer, (bool),
+                     b);
+
   m_opaque_up->reproducer_capture = b;
 }
 
 void SBInitializerOptions::SetReplayReproducer(bool b) {
+  LLDB_RECORD_METHOD(void, SBInitializerOptions, SetReplayReproducer, (bool),
+                     b);
+
   m_opaque_up->reproducer_replay = b;
 }
 
 void SBInitializerOptions::SetReproducerPath(const char *path) {
+  LLDB_RECORD_METHOD(void, SBInitializerOptions, SetReproducerPath,
+                     (const char *), path);
+
   m_opaque_up->reproducer_path = path;
 }
 
 InitializerOptions &SBInitializerOptions::ref() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb_private::InitializerOptions &,
+                                   SBInitializerOptions, ref);
+
   return *(m_opaque_up.get());
 }

lldb/source/API/SBInstruction.cpp

 //===-- SBInstruction.cpp ---------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
+#include "SBReproducerPrivate.h"
+
 #include "lldb/API/SBInstruction.h"
 
 #include "lldb/API/SBAddress.h"
 #include "lldb/API/SBFrame.h"
 
 #include "lldb/API/SBInstruction.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/API/SBTarget.h"

 protected:
   lldb::DisassemblerSP m_disasm_sp; // Can be empty/invalid
   lldb::InstructionSP m_inst_sp;
 };
 
 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;
 }
 
 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;
     TargetSP target_sp(target.GetSP());
     std::unique_lock<std::recursive_mutex> lock;
     if (target_sp) {
       lock = std::unique_lock<std::recursive_mutex>(target_sp->GetAPIMutex());
 
       target_sp->CalculateExecutionContext(exe_ctx);
       exe_ctx.SetProcessSP(target_sp->GetProcessSP());
     }
     return inst_sp->GetMnemonic(&exe_ctx);
   }
   return NULL;
 }
 
 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;
     TargetSP target_sp(target.GetSP());
     std::unique_lock<std::recursive_mutex> lock;
     if (target_sp) {
       lock = std::unique_lock<std::recursive_mutex>(target_sp->GetAPIMutex());
 
       target_sp->CalculateExecutionContext(exe_ctx);
       exe_ctx.SetProcessSP(target_sp->GetProcessSP());
     }
     return inst_sp->GetOperands(&exe_ctx);
   }
   return NULL;
 }
 
 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;
     TargetSP target_sp(target.GetSP());
     std::unique_lock<std::recursive_mutex> lock;
     if (target_sp) {
       lock = std::unique_lock<std::recursive_mutex>(target_sp->GetAPIMutex());
 
       target_sp->CalculateExecutionContext(exe_ctx);
       exe_ctx.SetProcessSP(target_sp->GetProcessSP());
     }
     return inst_sp->GetComment(&exe_ctx);
   }
   return NULL;
 }
 
 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();
   return 0;
 }
 
 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) {
     DataExtractorSP data_extractor_sp(new DataExtractor());
     if (inst_sp->GetData(*data_extractor_sp)) {
       sb_data.SetOpaque(data_extractor_sp);
     }
   }
   return 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();
   return false;
 }
 
 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();
   return false;
 }
 
 lldb::InstructionSP SBInstruction::GetOpaque() {
   if (m_opaque_sp)
     return m_opaque_sp->GetSP();
   else
     return lldb::InstructionSP();
 }
 
 void SBInstruction::SetOpaque(const lldb::DisassemblerSP &disasm_sp,
                               const lldb::InstructionSP &inst_sp) {
   m_opaque_sp = std::make_shared<InstructionImpl>(disasm_sp, inst_sp);
 }
 
 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;
     const Address &addr = inst_sp->GetAddress();
     ModuleSP module_sp(addr.GetModule());
     if (module_sp)
       module_sp->ResolveSymbolContextForAddress(addr, eSymbolContextEverything,
                                                 sc);
     // Use the "ref()" instead of the "get()" accessor in case the SBStream
     // didn't have a stream already created, one will get created...
     FormatEntity::Entry format;
     FormatEntity::Parse("${addr}: ", format);
     inst_sp->Dump(&s.ref(), 0, true, false, NULL, &sc, NULL, &format, 0);
     return true;
   }
   return false;
 }
 
 void SBInstruction::Print(FILE *out) {
+  LLDB_RECORD_METHOD(void, SBInstruction, Print, (FILE *), out);
+
   if (out == NULL)
     return;
 
   lldb::InstructionSP inst_sp(GetOpaque());
   if (inst_sp) {
     SymbolContext sc;
     const Address &addr = inst_sp->GetAddress();
     ModuleSP module_sp(addr.GetModule());
     if (module_sp)
       module_sp->ResolveSymbolContextForAddress(addr, eSymbolContextEverything,
                                                 sc);
     StreamFile out_stream(out, false);
     FormatEntity::Entry format;
     FormatEntity::Parse("${addr}: ", format);
     inst_sp->Dump(&out_stream, 0, true, false, NULL, &sc, NULL, &format, 0);
   }
 }
 
 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());
 
     if (frame_sp) {
       lldb_private::ExecutionContext exe_ctx;
       frame_sp->CalculateExecutionContext(exe_ctx);
       lldb_private::Target *target = exe_ctx.GetTargetPtr();
       lldb_private::ArchSpec arch = target->GetArchitecture();
 
       return inst_sp->Emulate(
           arch, evaluate_options, (void *)frame_sp.get(),
           &lldb_private::EmulateInstruction::ReadMemoryFrame,
           &lldb_private::EmulateInstruction::WriteMemoryFrame,
           &lldb_private::EmulateInstruction::ReadRegisterFrame,
           &lldb_private::EmulateInstruction::WriteRegisterFrame);
     }
   }
   return false;
 }
 
 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));
   }
   return false;
 }
 
 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::InstructionSP inst_sp(GetOpaque());
   if (inst_sp)
     return inst_sp->TestEmulation(output_stream.get(), test_file);
   return false;
 }

lldb/source/API/SBInstructionList.cpp

 //===-- SBInstructionList.cpp -----------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
+#include "SBReproducerPrivate.h"
+
 #include "lldb/API/SBInstructionList.h"
 #include "lldb/API/SBInstruction.h"
 #include "lldb/API/SBAddress.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/Core/Disassembler.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Symbol/SymbolContext.h"
 #include "lldb/Utility/Stream.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;
 }
 
 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;
   size_t lower_index = 0;
   size_t upper_index = 0;
   size_t instructions_to_skip = 0;
   for (i = 0; i < num_instructions; ++i) {
     addr = GetInstructionAtIndex(i).GetAddress();
     if (start == addr)
       lower_index = i;
     if (end == addr)
       upper_index = i;
   }
   if (canSetBreakpoint)
     for (i = lower_index; i <= upper_index; ++i) {
       SBInstruction insn = GetInstructionAtIndex(i);
       if (!insn.CanSetBreakpoint())
         ++instructions_to_skip;
     }
   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) {
       // Call the ref() to make sure a stream is created if one deesn't exist
       // already inside description...
       Stream &sref = description.ref();
       const uint32_t max_opcode_byte_size =
           m_opaque_sp->GetInstructionList().GetMaxOpcocdeByteSize();
if (num_instructions) {
       }
       return true;
     }
   }
   return false;
 }
 
 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) {
       if (!GetInstructionAtIndex((uint32_t)i).DumpEmulation(triple))
         return false;
     }
   }
   return true;
 }

lldb/source/API/SBLanguageRuntime.cpp

 //===-- SBLanguageRuntime.cpp -----------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
+#include "SBReproducerPrivate.h"
+
 #include "lldb/API/SBLanguageRuntime.h"
 #include "lldb/Target/Language.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 lldb::LanguageType
 SBLanguageRuntime::GetLanguageTypeFromString(const char *string) {
+  LLDB_RECORD_STATIC_METHOD(lldb::LanguageType, SBLanguageRuntime,
+                            GetLanguageTypeFromString, (const char *), string);
+
   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

 //===-- SBLaunchInfo.cpp ----------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
+#include "SBReproducerPrivate.h"
+
 #include "lldb/API/SBLaunchInfo.h"
 
 #include "lldb/API/SBFileSpec.h"
 #include "lldb/API/SBListener.h"
 #include "lldb/Host/ProcessLaunchInfo.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 class lldb_private::SBLaunchInfoImpl : public ProcessLaunchInfo {
 public:
   SBLaunchInfoImpl()
       : ProcessLaunchInfo(), m_envp(GetEnvironment().getEnvp()) {}
 
   const char *const *GetEnvp() const { return m_envp; }
   void RegenerateEnvp() { m_envp = GetEnvironment().getEnvp(); }
 
   SBLaunchInfoImpl &operator=(const ProcessLaunchInfo &rhs) {
+    LLDB_RECORD_METHOD(
+        lldb_private::SBLaunchInfoImpl &,
+        SBLaunchInfoImpl, operator=,(const lldb_private::ProcessLaunchInfo &),
+        rhs);
+
     ProcessLaunchInfo::operator=(rhs);
     RegenerateEnvp();
     return *this;
   }
 
 private:
   Environment::Envp m_envp;
 };
 
 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);
 }
 
 SBLaunchInfo::~SBLaunchInfo() {}
 
 const lldb_private::ProcessLaunchInfo &SBLaunchInfo::ref() const {
   return *m_opaque_sp;
 }
 
 void SBLaunchInfo::set_ref(const ProcessLaunchInfo &info) {
   *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() { return m_opaque_sp->GetUserID(); }
+uint32_t SBLaunchInfo::GetUserID() {
+  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBLaunchInfo, GetUserID);
+  return m_opaque_sp->GetUserID();
+}
 
-uint32_t SBLaunchInfo::GetGroupID() { return m_opaque_sp->GetGroupID(); }
+uint32_t SBLaunchInfo::GetGroupID() {
+  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBLaunchInfo, GetGroupID);
+  return m_opaque_sp->GetGroupID();
+}
 
-bool SBLaunchInfo::UserIDIsValid() { return m_opaque_sp->UserIDIsValid(); }
+bool SBLaunchInfo::UserIDIsValid() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBLaunchInfo, UserIDIsValid);
+  return m_opaque_sp->UserIDIsValid();
+}
 
-bool SBLaunchInfo::GroupIDIsValid() { return m_opaque_sp->GroupIDIsValid(); }
+bool SBLaunchInfo::GroupIDIsValid() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBLaunchInfo, GroupIDIsValid);
+  return m_opaque_sp->GroupIDIsValid();
+}
 
-void SBLaunchInfo::SetUserID(uint32_t uid) { m_opaque_sp->SetUserID(uid); }
+void SBLaunchInfo::SetUserID(uint32_t uid) {
+  LLDB_RECORD_METHOD(void, SBLaunchInfo, SetUserID, (uint32_t), uid);
+  m_opaque_sp->SetUserID(uid);
+}
 
-void SBLaunchInfo::SetGroupID(uint32_t gid) { m_opaque_sp->SetGroupID(gid); }
+void SBLaunchInfo::SetGroupID(uint32_t gid) {
+  LLDB_RECORD_METHOD(void, SBLaunchInfo, SetGroupID, (uint32_t), gid);
+  m_opaque_sp->SetGroupID(gid);
+}
 
 SBFileSpec SBLaunchInfo::GetExecutableFile() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBFileSpec, SBLaunchInfo, GetExecutableFile);
+
   return SBFileSpec(m_opaque_sp->GetExecutableFile());
 }
 
 void SBLaunchInfo::SetExecutableFile(SBFileSpec exe_file,
                                      bool add_as_first_arg) {
+  LLDB_RECORD_METHOD(void, SBLaunchInfo, SetExecutableFile,
+                     (lldb::SBFileSpec, bool), exe_file, add_as_first_arg);
+
   m_opaque_sp->SetExecutableFile(exe_file.ref(), add_as_first_arg);
 }
 
 SBListener SBLaunchInfo::GetListener() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBListener, SBLaunchInfo, GetListener);
+
   return 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);
   } else {
     if (argv)
       m_opaque_sp->GetArguments().SetArguments(argv);
     else
       m_opaque_sp->GetArguments().Clear();
   }
 }
 
 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());
   else
     m_opaque_sp->GetEnvironment() = env;
   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());
   return shell.AsCString();
 }
 
 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

 //===-- SBLineEntry.cpp -----------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include <limits.h>
 
+#include "SBReproducerPrivate.h"
 #include "lldb/API/SBLineEntry.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/Host/PosixApi.h"
 #include "lldb/Symbol/LineEntry.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/StreamString.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();
 }
 
 SBLineEntry::SBLineEntry(const lldb_private::LineEntry *lldb_object_ptr)
     : m_opaque_up() {
   if (lldb_object_ptr)
     ref() = *lldb_object_ptr;
 }
 
 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();
     else
       m_opaque_up.reset();
   }
   return *this;
 }
 
 void SBLineEntry::SetLineEntry(const lldb_private::LineEntry &lldb_object_ref) {
   ref() = lldb_object_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());
 
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   if (log) {
     StreamString sstr;
     const Address *addr = sb_address.get();
     if (addr)
       addr->Dump(&sstr, NULL, Address::DumpStyleModuleWithFileAddress,
                  Address::DumpStyleInvalid, 4);
     log->Printf("SBLineEntry(%p)::GetStartAddress () => SBAddress (%p): %s",
                 static_cast<void *>(m_opaque_up.get()),
                 static_cast<void *>(sb_address.get()), sstr.GetData());
   }
 
   return 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());
     sb_address.OffsetAddress(m_opaque_up->range.GetByteSize());
   }
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   if (log) {
     StreamString sstr;
     const Address *addr = sb_address.get();
     if (addr)
       addr->Dump(&sstr, NULL, Address::DumpStyleModuleWithFileAddress,
                  Address::DumpStyleInvalid, 4);
     log->Printf("SBLineEntry(%p)::GetEndAddress () => SBAddress (%p): %s",
                 static_cast<void *>(m_opaque_up.get()),
                 static_cast<void *>(sb_address.get()), sstr.GetData());
   }
   return 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;
   if (m_opaque_up.get() && m_opaque_up->file)
     sb_file_spec.SetFileSpec(m_opaque_up->file);
 
   if (log) {
     SBStream sstr;
     sb_file_spec.GetDescription(sstr);
     log->Printf("SBLineEntry(%p)::GetFileSpec () => SBFileSpec(%p): %s",
                 static_cast<void *>(m_opaque_up.get()),
                 static_cast<const void *>(sb_file_spec.get()), sstr.GetData());
   }
 
   return 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;
   if (m_opaque_up)
     line = m_opaque_up->line;
 
   if (log)
     log->Printf("SBLineEntry(%p)::GetLine () => %u",
                 static_cast<void *>(m_opaque_up.get()), line);
 
   return line;
 }
 
 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();
 
   if (lhs_ptr && rhs_ptr)
     return lldb_private::LineEntry::Compare(*lhs_ptr, *rhs_ptr) == 0;
 
   return lhs_ptr == rhs_ptr;
 }
 
 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();
 
   if (lhs_ptr && rhs_ptr)
     return lldb_private::LineEntry::Compare(*lhs_ptr, *rhs_ptr) != 0;
 
   return lhs_ptr != rhs_ptr;
 }
 
 const lldb_private::LineEntry *SBLineEntry::operator->() const {
   return m_opaque_up.get();
 }
 
 lldb_private::LineEntry &SBLineEntry::ref() {
   if (m_opaque_up == NULL)
     m_opaque_up.reset(new lldb_private::LineEntry());
   return *m_opaque_up;
 }
 
 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) {
     char file_path[PATH_MAX * 2];
     m_opaque_up->file.GetPath(file_path, sizeof(file_path));
     strm.Printf("%s:%u", file_path, GetLine());
     if (GetColumn() > 0)
       strm.Printf(":%u", GetColumn());
   } else
     strm.PutCString("No value");
 
   return true;
 }
 
 lldb_private::LineEntry *SBLineEntry::get() { return m_opaque_up.get(); }

lldb/source/API/SBListener.cpp

 //===-- SBListener.cpp ------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
+#include "SBReproducerPrivate.h"
+
 #include "lldb/API/SBListener.h"
 #include "lldb/API/SBBroadcaster.h"
 #include "lldb/API/SBDebugger.h"
 #include "lldb/API/SBEvent.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/Core/Debugger.h"
 #include "lldb/Utility/Broadcaster.h"
 #include "lldb/Utility/Listener.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/StreamString.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)
     log->Printf("SBListener::SBListener (name=\"%s\") => SBListener(%p)", name,
                 static_cast<void *>(m_opaque_sp.get()));
 }
 
 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;
   }
   return *this;
 }
 
 SBListener::SBListener(const lldb::ListenerSP &listener_sp)
     : m_opaque_sp(listener_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)
       return 0;
     BroadcastEventSpec event_spec(ConstString(broadcaster_class), event_mask);
     return m_opaque_sp->StartListeningForEventSpec(
         lldb_debugger->GetBroadcasterManager(), event_spec);
   } else
     return 0;
 }
 
 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)
       return false;
     BroadcastEventSpec event_spec(ConstString(broadcaster_class), event_mask);
     return m_opaque_sp->StopListeningForEventSpec(
         lldb_debugger->GetBroadcasterManager(), event_spec);
   } else
     return false;
 }
 
 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 =
         m_opaque_sp->StartListeningForEvents(broadcaster.get(), event_mask);
   }
 
   Log *log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API);
   if (log) {
if (log) {
     }
   }
 
   return 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);
   }
   return false;
 }
 
 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) {
       log->Printf("SBListener(%p)::WaitForEvent (timeout_secs=INFINITE, "
                   "SBEvent(%p))...",
                   static_cast<void *>(m_opaque_sp.get()),
                   static_cast<void *>(event.get()));
     } else {
bool SBListener::WaitForEvent(uint32_t timeout_secs, SBEvent &event) {
   if (!success)
     event.reset(NULL);
   return success;
 }
 
 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)
       timeout = std::chrono::seconds(num_seconds);
     EventSP event_sp;
     if (m_opaque_sp->GetEventForBroadcaster(broadcaster.get(), event_sp,
                                             timeout)) {
       event.reset(event_sp);
       return true;
     }
   }
   event.reset(NULL);
   return false;
 }
 
 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)
       timeout = std::chrono::seconds(num_seconds);
     EventSP event_sp;
     if (m_opaque_sp->GetEventForBroadcasterWithType(
             broadcaster.get(), event_type_mask, event_sp, timeout)) {
       event.reset(event_sp);
       return true;
     }
   }
   event.reset(NULL);
   return false;
 }
 
 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();
   }
   event.reset(NULL);
   return false;
 }
 
 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();
   }
   event.reset(NULL);
   return false;
 }
 
 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));
     return event.IsValid();
   }
   event.reset(NULL);
   return false;
 }
 
 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))) {
       event.reset(event_sp);
       return true;
     }
   }
   event.reset(NULL);
   return false;
 }
 
 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,
                                             std::chrono::seconds(0))) {
       event.reset(event_sp);
       return true;
     }
   }
   event.reset(NULL);
   return false;
 }
 
 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(),
                                                     event_type_mask, event_sp,
                                                     std::chrono::seconds(0))) {
       event.reset(event_sp);
       return true;
     }
   }
   event.reset(NULL);
   return false;
 }
 
 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::ListenerSP SBListener::GetSP() { return m_opaque_sp; }
 
 Listener *SBListener::operator->() const { return m_opaque_sp.get(); }
 
 Listener *SBListener::get() const { return m_opaque_sp.get(); }
 
 void SBListener::reset(ListenerSP listener_sp) {
   m_opaque_sp = listener_sp;
   m_unused_ptr = nullptr;
 }

lldb/source/API/SBMemoryRegionInfo.cpp

 //===-- SBMemoryRegionInfo.cpp ----------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBMemoryRegionInfo.h"
+#include "SBReproducerPrivate.h"
 #include "lldb/API/SBDefines.h"
 #include "lldb/API/SBError.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/Target/MemoryRegionInfo.h"
 #include "lldb/Utility/StreamString.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()) {
   if (lldb_object_ptr)
     ref() = *lldb_object_ptr;
 }
 
 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();
   }
   return *this;
 }
 
 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();
 }
 
 MemoryRegionInfo &SBMemoryRegionInfo::ref() { return *m_opaque_up; }
 
 const MemoryRegionInfo &SBMemoryRegionInfo::ref() const { return *m_opaque_up; }
 
 lldb::addr_t SBMemoryRegionInfo::GetRegionBase() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::addr_t, SBMemoryRegionInfo, GetRegionBase);
+
   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;
 
   strm.Printf("[0x%16.16" PRIx64 "-0x%16.16" PRIx64 " ", load_addr,
               load_addr + m_opaque_up->GetRange().size);
   strm.Printf(m_opaque_up->GetReadable() ? "R" : "-");
   strm.Printf(m_opaque_up->GetWritable() ? "W" : "-");
   strm.Printf(m_opaque_up->GetExecutable() ? "X" : "-");
   strm.Printf("]");
 
   return true;
 }

lldb/source/API/SBMemoryRegionInfoList.cpp

 //===-- SBMemoryRegionInfoList.cpp ------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBMemoryRegionInfoList.h"
+#include "SBReproducerPrivate.h"
 #include "lldb/API/SBMemoryRegionInfo.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/Target/MemoryRegionInfo.h"
 #include "lldb/Utility/Log.h"
 
 #include <vector>
 
 using namespace lldb;

 
 MemoryRegionInfos &SBMemoryRegionInfoList::ref() { return m_opaque_up->Ref(); }
 
 const MemoryRegionInfos &SBMemoryRegionInfoList::ref() const {
   return m_opaque_up->Ref();
 }
 
 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;
   }
   return *this;
 }
 
 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());
 
   if (log) {
     SBStream sstr;
     region_info.GetDescription(sstr);
     log->Printf("SBMemoryRegionInfoList::GetMemoryRegionAtIndex (this.ap=%p, "
                 "idx=%d) => SBMemoryRegionInfo (this.ap=%p, '%s')",
                 static_cast<void *>(m_opaque_up.get()), idx,
                 static_cast<void *>(region_info.m_opaque_up.get()),
                 sstr.GetData());
   }
 
   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);
 }
 
 const MemoryRegionInfoListImpl *SBMemoryRegionInfoList::operator->() const {
   return m_opaque_up.get();
 }
 
 const MemoryRegionInfoListImpl &SBMemoryRegionInfoList::operator*() const {
   assert(m_opaque_up.get());
   return *m_opaque_up;
 }

lldb/source/API/SBModule.cpp

 //===-- SBModule.cpp --------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
+#include "SBReproducerPrivate.h"
+
 #include "lldb/API/SBModule.h"
 #include "lldb/API/SBAddress.h"
 #include "lldb/API/SBFileSpec.h"
 #include "lldb/API/SBModuleSpec.h"
 #include "lldb/API/SBProcess.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/API/SBSymbolContextList.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/Section.h"
 #include "lldb/Core/ValueObjectList.h"
 #include "lldb/Core/ValueObjectVariable.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/SymbolFile.h"
 #include "lldb/Symbol/SymbolVendor.h"
 #include "lldb/Symbol/Symtab.h"
 #include "lldb/Symbol/TypeSystem.h"
 #include "lldb/Symbol/VariableList.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/StreamString.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);
   if (module_sp)
     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);
     if (m_opaque_sp) {
       Target &target = process_sp->GetTarget();
       bool changed = false;
       m_opaque_sp->SetLoadAddress(target, 0, true, changed);
       target.GetImages().Append(m_opaque_sp);
     }
   }
 }
 
 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() { m_opaque_sp.reset(); }
+void SBModule::Clear() {
+  LLDB_RECORD_METHOD_NO_ARGS(void, SBModule, Clear);
+  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;
   ModuleSP module_sp(GetSP());
   if (module_sp)
     file_spec.SetFileSpec(module_sp->GetFileSpec());
 
   if (log)
     log->Printf("SBModule(%p)::GetFileSpec () => SBFileSpec(%p)",
                 static_cast<void *>(module_sp.get()),
                 static_cast<const void *>(file_spec.get()));
 
   return 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;
   ModuleSP module_sp(GetSP());
   if (module_sp)
     file_spec.SetFileSpec(module_sp->GetPlatformFileSpec());
 
   if (log)
     log->Printf("SBModule(%p)::GetPlatformFileSpec () => SBFileSpec(%p)",
                 static_cast<void *>(module_sp.get()),
                 static_cast<const void *>(file_spec.get()));
 
   return 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));
 
   ModuleSP module_sp(GetSP());
   if (module_sp) {
     module_sp->SetPlatformFileSpec(*platform_file);
     result = true;
   }
 
   if (log)
     log->Printf("SBModule(%p)::SetPlatformFileSpec (SBFileSpec(%p (%s)) => %i",
                 static_cast<void *>(module_sp.get()),
                 static_cast<const void *>(platform_file.get()),
                 platform_file->GetPath().c_str(), result);
   return result;
 }
 
 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;
 }
 
 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());
     return true;
   }
   return false;
 }
 
 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;
   ModuleSP module_sp(GetSP());
   if (module_sp)
     uuid_bytes = module_sp->GetUUID().GetBytes().data();
 
   if (log) {
     if (uuid_bytes) {
       StreamString s;
       module_sp->GetUUID().Dump(&s);
       log->Printf("SBModule(%p)::GetUUIDBytes () => %s",
                   static_cast<void *>(module_sp.get()), s.GetData());
     } else
       log->Printf("SBModule(%p)::GetUUIDBytes () => NULL",
                   static_cast<void *>(module_sp.get()));
   }
   return uuid_bytes;
 }
 
 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;
   ModuleSP module_sp(GetSP());
   if (module_sp) {
     // We are going to return a "const char *" value through the public API, so
     // we need to constify it so it gets added permanently the string pool and
     // then we don't need to worry about the lifetime of the string as it will
const char *SBModule::GetUUIDString() const {
 
   if (log)
     log->Printf("SBModule(%p)::GetUUIDString () => NULL",
                 static_cast<void *>(module_sp.get()));
   return 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;
 }
 
 ModuleSP SBModule::GetSP() const { return m_opaque_sp; }
 
 void SBModule::SetSP(const ModuleSP &module_sp) { m_opaque_sp = module_sp; }
 
 SBAddress SBModule::ResolveFileAddress(lldb::addr_t vm_addr) {
+  LLDB_RECORD_METHOD(lldb::SBAddress, SBModule, ResolveFileAddress,
+                     (lldb::addr_t), vm_addr);
+
   lldb::SBAddress sb_addr;
   ModuleSP module_sp(GetSP());
   if (module_sp) {
     Address addr;
     if (module_sp->ResolveFileAddress(vm_addr, addr))
       sb_addr.ref() = addr;
   }
   return sb_addr;
 }
 
 SBSymbolContext
 SBModule::ResolveSymbolContextForAddress(const SBAddress &addr,
                                          uint32_t resolve_scope) {
+  LLDB_RECORD_METHOD(lldb::SBSymbolContext, SBModule,
+                     ResolveSymbolContextForAddress,
+                     (const lldb::SBAddress &, uint32_t), addr, resolve_scope);
+
   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;
 }
 
 bool SBModule::GetDescription(SBStream &description) {
+  LLDB_RECORD_METHOD(bool, SBModule, GetDescription, (lldb::SBStream &),
+                     description);
+
   Stream &strm = description.ref();
 
   ModuleSP module_sp(GetSP());
   if (module_sp) {
     module_sp->GetDescription(&strm);
   } else
     strm.PutCString("No value");
 
   return true;
 }
 
 uint32_t SBModule::GetNumCompileUnits() {
+  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBModule, GetNumCompileUnits);
+
   ModuleSP module_sp(GetSP());
   if (module_sp) {
     return module_sp->GetNumCompileUnits();
   }
   return 0;
 }
 
 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;
 }
 
-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;
 }
 
 static Symtab *GetUnifiedSymbolTable(const lldb::ModuleSP &module_sp) {
   if (module_sp) {
     SymbolVendor *symbols = module_sp->GetSymbolVendor();
     if (symbols)
       return symbols->GetSymtab();
   }
   return NULL;
 }
 
 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);
     if (symtab)
       return symtab->GetNumSymbols();
   }
   return 0;
 }
 
 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;
 }
 
 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());
     Symtab *symtab = GetUnifiedSymbolTable(module_sp);
     if (symtab)
       sb_symbol.SetSymbol(symtab->FindFirstSymbolWithNameAndType(
           ConstString(name), symbol_type, Symtab::eDebugAny,
           Symtab::eVisibilityAny));
   }
   return sb_symbol;
 }
 
 lldb::SBSymbolContextList SBModule::FindSymbols(const char *name,
                                                 lldb::SymbolType symbol_type) {
+  LLDB_RECORD_METHOD(lldb::SBSymbolContextList, SBModule, FindSymbols,
+                     (const char *, lldb::SymbolType), name, symbol_type);
+
   SBSymbolContextList sb_sc_list;
   if (name && name[0]) {
     ModuleSP module_sp(GetSP());
     Symtab *symtab = GetUnifiedSymbolTable(module_sp);
     if (symtab) {
       std::vector<uint32_t> matching_symbol_indexes;
       const size_t num_matches = symtab->FindAllSymbolsWithNameAndType(
           ConstString(name), symbol_type, matching_symbol_indexes);
       if (num_matches) {
         SymbolContext sc;
         sc.module_sp = module_sp;
         SymbolContextList &sc_list = *sb_sc_list;
         for (size_t i = 0; i < num_matches; ++i) {
           sc.symbol = symtab->SymbolAtIndex(matching_symbol_indexes[i]);
           if (sc.symbol)
             sc_list.Append(sc);
         }
       }
     }
   }
   return 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.
     module_sp->GetSymbolVendor();
     SectionList *section_list = module_sp->GetSectionList();
     if (section_list)
       return section_list->GetSize();
   }
   return 0;
 }
 
 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) {
     // Give the symbol vendor a chance to add to the unified section list.
     module_sp->GetSymbolVendor();
     SectionList *section_list = module_sp->GetSectionList();
 
     if (section_list)
       sb_section.SetSP(section_list->GetSectionAtIndex(idx));
   }
   return sb_section;
 }
 
 lldb::SBSymbolContextList SBModule::FindFunctions(const char *name,
                                                   uint32_t name_type_mask) {
+  LLDB_RECORD_METHOD(lldb::SBSymbolContextList, SBModule, FindFunctions,
+                     (const char *, uint32_t), name, name_type_mask);
+
   lldb::SBSymbolContextList sb_sc_list;
   ModuleSP module_sp(GetSP());
   if (name && module_sp) {
     const bool append = true;
     const bool symbols_ok = true;
     const bool inlines_ok = true;
     FunctionNameType type = static_cast<FunctionNameType>(name_type_mask);
     module_sp->FindFunctions(ConstString(name), NULL, type, symbols_ok,
                              inlines_ok, append, *sb_sc_list);
   }
   return sb_sc_list;
 }
 
 SBValueList SBModule::FindGlobalVariables(SBTarget &target, const char *name,
                                           uint32_t max_matches) {
+  LLDB_RECORD_METHOD(lldb::SBValueList, SBModule, FindGlobalVariables,
+                     (lldb::SBTarget &, const char *, uint32_t), target, name,
+                     max_matches);
+
   SBValueList sb_value_list;
   ModuleSP module_sp(GetSP());
   if (name && module_sp) {
     VariableList variable_list;
     const uint32_t match_count = module_sp->FindGlobalVariables(
         ConstString(name), NULL, max_matches, variable_list);
 
     if (match_count > 0) {
       for (uint32_t i = 0; i < match_count; ++i) {
         lldb::ValueObjectSP valobj_sp;
         TargetSP target_sp(target.GetSP());
         valobj_sp = ValueObjectVariable::Create(
             target_sp.get(), variable_list.GetVariableAtIndex(i));
         if (valobj_sp)
           sb_value_list.Append(SBValue(valobj_sp));
       }
     }
   }
 
   return sb_value_list;
 }
 
 lldb::SBValue SBModule::FindFirstGlobalVariable(lldb::SBTarget &target,
                                                 const char *name) {
+  LLDB_RECORD_METHOD(lldb::SBValue, SBModule, FindFirstGlobalVariable,
+                     (lldb::SBTarget &, const char *), target, name);
+
   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();
 }
 
 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) {
     SymbolContext sc;
     const bool exact_match = false;
     ConstString name(name_cstr);
 
     sb_type = SBType(module_sp->FindFirstType(sc, name, exact_match));
 
     if (!sb_type.IsValid()) {
       TypeSystem *type_system =
           module_sp->GetTypeSystemForLanguage(eLanguageTypeC);
       if (type_system)
         sb_type = SBType(type_system->GetBuiltinTypeByName(name));
     }
   }
   return 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 SBType();
 }
 
 lldb::SBTypeList SBModule::FindTypes(const char *type) {
+  LLDB_RECORD_METHOD(lldb::SBTypeList, SBModule, FindTypes, (const char *),
+                     type);
+
   SBTypeList retval;
 
   ModuleSP module_sp(GetSP());
   if (type && module_sp) {
     TypeList type_list;
     const bool exact_match = false;
     ConstString name(type);
     llvm::DenseSet<SymbolFile *> searched_symbol_files;
if (num_matches > 0) {
       }
     }
   }
 
   return 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 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;
   SymbolVendor *vendor = module_sp->GetSymbolVendor();
   if (!vendor)
     return 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;
 }
 
 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());
   if (sect_name && module_sp) {
     // Give the symbol vendor a chance to add to the unified section list.
     module_sp->GetSymbolVendor();
     SectionList *section_list = module_sp->GetSectionList();
     if (section_list) {
       ConstString const_sect_name(sect_name);
       SectionSP section_sp(section_list->FindSectionByName(const_sect_name));
       if (section_sp) {
         sb_section.SetSP(section_sp);
       }
     }
   }
   return 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();
   return eByteOrderInvalid;
 }
 
 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());
     // 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
     // comes out
     ConstString const_triple(triple.c_str());
     return const_triple.GetCString();
   }
   return NULL;
 }
 
 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();
   return sizeof(void *);
 }
 
 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();
   uint32_t result = 0;
   if (!version.empty())
     ++result;
   if (version.getMinor())
     ++result;
uint32_t SBModule::GetVersion(uint32_t *versions, uint32_t num_versions) {
   if (num_versions > 2)
     versions[2] = version.getSubminor().getValueOr(UINT32_MAX);
   for (uint32_t i = 3; i < num_versions; ++i)
     versions[i] = UINT32_MAX;
   return result;
 }
 
 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) {
     SymbolVendor *symbol_vendor_ptr = module_sp->GetSymbolVendor();
     if (symbol_vendor_ptr)
       sb_file_spec.SetFileSpec(symbol_vendor_ptr->GetMainFileSpec());
   }
   return 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) {
     ObjectFile *objfile_ptr = module_sp->GetObjectFile();
     if (objfile_ptr)
       sb_addr.ref() = objfile_ptr->GetBaseAddress();
   }
   return 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) {
     ObjectFile *objfile_ptr = module_sp->GetObjectFile();
     if (objfile_ptr)
       sb_addr.ref() = objfile_ptr->GetEntryPointAddress();
   }
   return sb_addr;
 }

lldb/source/API/SBModuleSpec.cpp

 //===-- SBModuleSpec.cpp ----------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBModuleSpec.h"
+#include "SBReproducerPrivate.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Utility/Stream.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() { m_opaque_up->Clear(); }
+void SBModuleSpec::Clear() {
+  LLDB_RECORD_METHOD_NO_ARGS(void, SBModuleSpec, 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;
 }
 
 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() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBFileSpec, SBModuleSpec,
+                             GetPlatformFileSpec);
+
   return SBFileSpec(m_opaque_up->GetPlatformFileSpec());
 }
 
 void SBModuleSpec::SetPlatformFileSpec(const lldb::SBFileSpec &sb_spec) {
+  LLDB_RECORD_METHOD(void, SBModuleSpec, SetPlatformFileSpec,
+                     (const lldb::SBFileSpec &), sb_spec);
+
   m_opaque_up->GetPlatformFileSpec() = *sb_spec;
 }
 
 lldb::SBFileSpec SBModuleSpec::GetSymbolFileSpec() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBFileSpec, SBModuleSpec, GetSymbolFileSpec);
+
   return SBFileSpec(m_opaque_up->GetSymbolFileSpec());
 }
 
 void SBModuleSpec::SetSymbolFileSpec(const lldb::SBFileSpec &sb_spec) {
+  LLDB_RECORD_METHOD(void, SBModuleSpec, SetSymbolFileSpec,
+                     (const lldb::SBFileSpec &), sb_spec);
+
   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
   // comes out
   ConstString const_triple(triple.c_str());
   return const_triple.GetCString();
 }
 
 void SBModuleSpec::SetTriple(const char *triple) {
+  LLDB_RECORD_METHOD(void, SBModuleSpec, SetTriple, (const char *), triple);
+
   m_opaque_up->GetArchitecture().SetTriple(triple);
 }
 
 const uint8_t *SBModuleSpec::GetUUIDBytes() {
+  LLDB_RECORD_METHOD_NO_ARGS(const uint8_t *, SBModuleSpec, GetUUIDBytes);
+
   return m_opaque_up->GetUUID().GetBytes().data();
 }
 
 size_t SBModuleSpec::GetUUIDLength() {
+  LLDB_RECORD_METHOD_NO_ARGS(size_t, SBModuleSpec, GetUUIDLength);
+
   return m_opaque_up->GetUUID().GetBytes().size();
 }
 
 bool SBModuleSpec::SetUUIDBytes(const uint8_t *uuid, size_t uuid_len) {
+  LLDB_RECORD_METHOD(bool, SBModuleSpec, SetUUIDBytes,
+                     (const uint8_t *, size_t), uuid, uuid_len);
+
   m_opaque_up->GetUUID() = UUID::fromOptionalData(uuid, uuid_len);
   return m_opaque_up->GetUUID().IsValid();
 }
 
 bool SBModuleSpec::GetDescription(lldb::SBStream &description) {
+  LLDB_RECORD_METHOD(bool, SBModuleSpec, GetDescription, (lldb::SBStream &),
+                     description);
+
   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;
 }
 
 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;
 }
 
 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;
 }
 
 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;
 }
 
 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

 //===-- SBPlatform.cpp ------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
+#include "SBReproducerPrivate.h"
+
 #include "lldb/API/SBPlatform.h"
 #include "lldb/API/SBError.h"
 #include "lldb/API/SBFileSpec.h"
 #include "lldb/API/SBLaunchInfo.h"
 #include "lldb/API/SBUnixSignals.h"
 #include "lldb/Host/File.h"
 #include "lldb/Target/Platform.h"
 #include "lldb/Target/Target.h"
struct PlatformShellCommand {
   int m_status;
   int m_signo;
   Timeout<std::ratio<1>> m_timeout = llvm::None;
 };
 //----------------------------------------------------------------------
 // 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
     m_opaque_ptr->m_url.clear();
 }
 
 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;
   if (remote_path_prefix && remote_path_prefix[0])
     m_opaque_ptr->m_rsync_remote_path_prefix = remote_path_prefix;
   else
     m_opaque_ptr->m_rsync_remote_path_prefix.clear();
 
   if (options && options[0])
     m_opaque_ptr->m_rsync_options = options;
   else
     m_opaque_ptr->m_rsync_options.clear();
 }
 
 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
     m_opaque_ptr->m_local_cache_directory = ConstString();
 }
 
 //----------------------------------------------------------------------
 // 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
     m_opaque_ptr->m_command.clear();
 }
 
 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
     m_opaque_ptr->m_working_dir.clear();
 }
 
 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() { return m_opaque_ptr->m_status; }
+int SBPlatformShellCommand::GetStatus() {
+  LLDB_RECORD_METHOD_NO_ARGS(int, SBPlatformShellCommand, GetStatus);
+  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() { m_opaque_sp.reset(); }
+void SBPlatform::Clear() {
+  LLDB_RECORD_METHOD_NO_ARGS(void, SBPlatform, Clear);
+  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();
   return NULL;
 }
 
 lldb::PlatformSP SBPlatform::GetSP() const { return m_opaque_sp; }
 
 void SBPlatform::SetSP(const lldb::PlatformSP &platform_sp) {
   m_opaque_sp = platform_sp;
 }
 
 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();
   return NULL;
 }
 
 bool SBPlatform::SetWorkingDirectory(const char *path) {
+  LLDB_RECORD_METHOD(bool, SBPlatform, SetWorkingDirectory, (const char *),
+                     path);
+
   PlatformSP platform_sp(GetSP());
   if (platform_sp) {
     if (path)
       platform_sp->SetWorkingDirectory(FileSpec(path));
     else
       platform_sp->SetWorkingDirectory(FileSpec());
     return true;
   }
   return false;
 }
 
 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()) {
     Args args;
     args.AppendArgument(
         llvm::StringRef::withNullAsEmpty(connect_options.GetURL()));
     sb_error.ref() = platform_sp->ConnectRemote(args);
   } else {
     sb_error.SetErrorString("invalid platform");
   }
   return 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();
   return false;
 }
 
 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());
     if (arch.IsValid()) {
       // Const-ify the string so we don't need to worry about the lifetime of
       // the string
       return ConstString(arch.GetTriple().getTriple().c_str()).GetCString();
     }
   }
   return NULL;
 }
 
 const char *SBPlatform::GetOSBuild() {
+  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBPlatform, GetOSBuild);
+
   PlatformSP platform_sp(GetSP());
   if (platform_sp) {
     std::string s;
     if (platform_sp->GetOSBuildString(s)) {
       if (!s.empty()) {
         // Const-ify the string so we don't need to worry about the lifetime of
         // the string
         return ConstString(s.c_str()).GetCString();
       }
     }
   }
   return NULL;
 }
 
 const char *SBPlatform::GetOSDescription() {
+  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBPlatform, GetOSDescription);
+
   PlatformSP platform_sp(GetSP());
   if (platform_sp) {
     std::string s;
     if (platform_sp->GetOSKernelDescription(s)) {
       if (!s.empty()) {
         // Const-ify the string so we don't need to worry about the lifetime of
         // the string
         return ConstString(s.c_str()).GetCString();
       }
     }
   }
   return NULL;
 }
 
 const char *SBPlatform::GetHostname() {
+  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBPlatform, GetHostname);
+
   PlatformSP platform_sp(GetSP());
   if (platform_sp)
     return platform_sp->GetHostname();
   return NULL;
 }
 
 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();
   return version.empty() ? UINT32_MAX : version.getMajor();
 }
 
 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();
   return version.getMinor().getValueOr(UINT32_MAX);
 }
 
 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();
   return version.getSubminor().getValueOr(UINT32_MAX);
 }
 
 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) {
     sb_error.ref() = platform_sp->GetFile(src.ref(), dst.ref());
   } else {
     sb_error.SetErrorString("invalid platform");
   }
   return sb_error;
 }
 
 SBError SBPlatform::Put(SBFileSpec &src, SBFileSpec &dst) {
+  LLDB_RECORD_METHOD(lldb::SBError, SBPlatform, Put,
+                     (lldb::SBFileSpec &, lldb::SBFileSpec &), src, dst);
+
   return ExecuteConnected([&](const lldb::PlatformSP &platform_sp) {
     if (src.Exists()) {
       uint32_t permissions = FileSystem::Instance().GetPermissions(src.ref());
       if (permissions == 0) {
         if (FileSystem::Instance().IsDirectory(src.ref()))
           permissions = eFilePermissionsDirectoryDefault;
         else
           permissions = eFilePermissionsFileDefault;
       }
 
       return platform_sp->PutFile(src.ref(), dst.ref(), permissions);
     }
 
     Status error;
     error.SetErrorStringWithFormat("'src' argument doesn't exist: '%s'",
                                    src.ref().GetPath().c_str());
     return error;
   });
 }
 
 SBError SBPlatform::Install(SBFileSpec &src, SBFileSpec &dst) {
+  LLDB_RECORD_METHOD(lldb::SBError, SBPlatform, Install,
+                     (lldb::SBFileSpec &, lldb::SBFileSpec &), src, dst);
+
   return 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) {
+  LLDB_RECORD_METHOD(lldb::SBError, SBPlatform, Run,
+                     (lldb::SBPlatformShellCommand &), shell_command);
+
   return ExecuteConnected([&](const lldb::PlatformSP &platform_sp) {
     const char *command = shell_command.GetCommand();
     if (!command)
       return Status("invalid shell command (empty)");
 
     const char *working_dir = shell_command.GetWorkingDirectory();
     if (working_dir == NULL) {
       working_dir = platform_sp->GetWorkingDirectory().GetCString();
       if (working_dir)
         shell_command.SetWorkingDirectory(working_dir);
     }
     return platform_sp->RunShellCommand(command, FileSpec(working_dir),
                                         &shell_command.m_opaque_ptr->m_status,
                                         &shell_command.m_opaque_ptr->m_signo,
                                         &shell_command.m_opaque_ptr->m_output,
                                         shell_command.m_opaque_ptr->m_timeout);
   });
 }
 
 SBError SBPlatform::Launch(SBLaunchInfo &launch_info) {
+  LLDB_RECORD_METHOD(lldb::SBError, SBPlatform, Launch, (lldb::SBLaunchInfo &),
+                     launch_info);
+
   return ExecuteConnected([&](const lldb::PlatformSP &platform_sp) {
     ProcessLaunchInfo info = launch_info.ref();
     Status error = platform_sp->LaunchProcess(info);
     launch_info.set_ref(info);
     return error;
   });
 }
 
 SBError SBPlatform::Kill(const lldb::pid_t pid) {
+  LLDB_RECORD_METHOD(lldb::SBError, SBPlatform, Kill, (const lldb::pid_t), pid);
+
   return ExecuteConnected([&](const lldb::PlatformSP &platform_sp) {
     return platform_sp->KillProcess(pid);
   });
 }
 
 SBError SBPlatform::ExecuteConnected(
     const std::function<Status(const lldb::PlatformSP &)> &func) {
   SBError sb_error;
   const auto platform_sp(GetSP());
   if (platform_sp) {
     if (platform_sp->IsConnected())
       sb_error.ref() = func(platform_sp);
     else
       sb_error.SetErrorString("not connected");
   } else
     sb_error.SetErrorString("invalid platform");
 
   return sb_error;
 }
 
 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) {
     sb_error.ref() =
         platform_sp->MakeDirectory(FileSpec(path), file_permissions);
   } else {
     sb_error.SetErrorString("invalid platform");
   }
   return 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;
     platform_sp->GetFilePermissions(FileSpec(path), file_permissions);
     return file_permissions;
   }
   return 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) {
     sb_error.ref() =
         platform_sp->SetFilePermissions(FileSpec(path), file_permissions);
   } else {
     sb_error.SetErrorString("invalid platform");
   }
   return 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/source/API/SBProcess.cpp

 //===-- SBProcess.cpp -------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
+#include "SBReproducerPrivate.h"
+
 #include "lldb/API/SBProcess.h"
 
 #include <inttypes.h>
 
 #include "lldb/lldb-defines.h"
 #include "lldb/lldb-types.h"
 
 #include "lldb/Core/Debugger.h"

 #include "lldb/API/SBThreadCollection.h"
 #include "lldb/API/SBTrace.h"
 #include "lldb/API/SBTraceOptions.h"
 #include "lldb/API/SBUnixSignals.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;
 }
 
 //----------------------------------------------------------------------
 // Destructor
 //----------------------------------------------------------------------
 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();
   }
   return "<Unknown>";
 }
 
 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();
   }
   return "<Unknown>";
 }
 
 lldb::ProcessSP SBProcess::GetSP() const { return m_opaque_wp.lock(); }
 
 void SBProcess::SetSP(const ProcessSP &process_sp) { m_opaque_wp = process_sp; }
 
-void SBProcess::Clear() { 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());
 }
 
 bool SBProcess::RemoteLaunch(char const **argv, char const **envp,
                              const char *stdin_path, const char *stdout_path,
                              const char *stderr_path,
                              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, "
                 "stdout=%s, stderr=%s, working-dir=%s, launch_flags=0x%x, "
                 "stop_at_entry=%i, &error (%p))...",
                 static_cast<void *>(m_opaque_wp.lock().get()),
                 static_cast<void *>(argv), static_cast<void *>(envp),
                 stdin_path ? stdin_path : "NULL",
log->Printf("SBProcess(%p)::RemoteLaunch (...) => SBError (%p): %s",
                 static_cast<void *>(error.get()), sstr.GetData());
   }
 
   return error.Success();
 }
 
 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(
         process_sp->GetTarget().GetAPIMutex());
     if (process_sp->GetState() == eStateConnected) {
       ProcessAttachInfo attach_info;
       attach_info.SetProcessID(pid);
       error.SetError(process_sp->Attach(attach_info));
log->Printf("SBProcess(%p)::RemoteAttachToProcessWithID (%" PRIu64
                 static_cast<void *>(process_sp.get()), pid,
                 static_cast<void *>(error.get()), sstr.GetData());
   }
 
   return error.Success();
 }
 
 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;
   ProcessSP process_sp(GetSP());
   if (process_sp) {
     Process::StopLocker stop_locker;
 
     const bool can_update = stop_locker.TryLock(&process_sp->GetRunLock());
     std::lock_guard<std::recursive_mutex> guard(
         process_sp->GetTarget().GetAPIMutex());
     num_threads = process_sp->GetThreadList().GetSize(can_update);
   }
 
   if (log)
     log->Printf("SBProcess(%p)::GetNumThreads () => %d",
                 static_cast<void *>(process_sp.get()), num_threads);
 
   return num_threads;
 }
 
 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;
   ThreadSP thread_sp;
   ProcessSP process_sp(GetSP());
   if (process_sp) {
     std::lock_guard<std::recursive_mutex> guard(
         process_sp->GetTarget().GetAPIMutex());
     thread_sp = process_sp->GetThreadList().GetSelectedThread();
     sb_thread.SetThread(thread_sp);
   }
 
   if (log)
     log->Printf("SBProcess(%p)::GetSelectedThread () => SBThread(%p)",
                 static_cast<void *>(process_sp.get()),
                 static_cast<void *>(thread_sp.get()));
 
   return sb_thread;
 }
 
 SBThread SBProcess::CreateOSPluginThread(lldb::tid_t tid,
                                          lldb::addr_t context) {
+  LLDB_RECORD_METHOD(lldb::SBThread, SBProcess, CreateOSPluginThread,
+                     (lldb::tid_t, lldb::addr_t), tid, context);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   SBThread sb_thread;
   ThreadSP thread_sp;
   ProcessSP process_sp(GetSP());
   if (process_sp) {
     std::lock_guard<std::recursive_mutex> guard(
         process_sp->GetTarget().GetAPIMutex());
     thread_sp = process_sp->CreateOSPluginThread(tid, context);
     sb_thread.SetThread(thread_sp);
   }
 
   if (log)
     log->Printf("SBProcess(%p)::CreateOSPluginThread (tid=0x%" PRIx64
                 ", context=0x%" PRIx64 ") => SBThread(%p)",
                 static_cast<void *>(process_sp.get()), tid, context,
                 static_cast<void *>(thread_sp.get()));
 
   return 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;
   TargetSP target_sp;
   ProcessSP process_sp(GetSP());
   if (process_sp) {
     target_sp = process_sp->GetTarget().shared_from_this();
     sb_target.SetSP(target_sp);
   }
 
   if (log)
     log->Printf("SBProcess(%p)::GetTarget () => SBTarget(%p)",
                 static_cast<void *>(process_sp.get()),
                 static_cast<void *>(target_sp.get()));
 
   return sb_target;
 }
 
 size_t SBProcess::PutSTDIN(const char *src, size_t src_len) {
+  LLDB_RECORD_METHOD(size_t, SBProcess, PutSTDIN, (const char *, size_t), src,
+                     src_len);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   size_t ret_val = 0;
   ProcessSP process_sp(GetSP());
   if (process_sp) {
     Status error;
     ret_val = process_sp->PutSTDIN(src, src_len, error);
   }
 
   if (log)
     log->Printf("SBProcess(%p)::PutSTDIN (src=\"%s\", src_len=%" PRIu64
                 ") => %" PRIu64,
                 static_cast<void *>(process_sp.get()), src,
                 static_cast<uint64_t>(src_len), static_cast<uint64_t>(ret_val));
 
   return ret_val;
 }
 
 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) {
     Status error;
     bytes_read = process_sp->GetSTDOUT(dst, dst_len, error);
   }
 
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   if (log)
     log->Printf(
         "SBProcess(%p)::GetSTDOUT (dst=\"%.*s\", dst_len=%" PRIu64
         ") => %" PRIu64,
         static_cast<void *>(process_sp.get()), static_cast<int>(bytes_read),
         dst, static_cast<uint64_t>(dst_len), static_cast<uint64_t>(bytes_read));
 
   return bytes_read;
 }
 
 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) {
     Status error;
     bytes_read = process_sp->GetSTDERR(dst, dst_len, error);
   }
 
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   if (log)
     log->Printf(
         "SBProcess(%p)::GetSTDERR (dst=\"%.*s\", dst_len=%" PRIu64
         ") => %" PRIu64,
         static_cast<void *>(process_sp.get()), static_cast<int>(bytes_read),
         dst, static_cast<uint64_t>(dst_len), static_cast<uint64_t>(bytes_read));
 
   return bytes_read;
 }
 
 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) {
     Status error;
     bytes_read = process_sp->GetAsyncProfileData(dst, dst_len, error);
   }
 
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   if (log)
     log->Printf(
         "SBProcess(%p)::GetAsyncProfileData (dst=\"%.*s\", dst_len=%" PRIu64
         ") => %" PRIu64,
         static_cast<void *>(process_sp.get()), static_cast<int>(bytes_read),
         dst, static_cast<uint64_t>(dst_len), static_cast<uint64_t>(bytes_read));
 
   return bytes_read;
 }
 
 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();
   SBTrace trace_instance;
   trace_instance.SetSP(process_sp);
   lldb::user_id_t uid = LLDB_INVALID_UID;
 
   if (!process_sp) {
     error.SetErrorString("invalid process");
   } else {
     uid = process_sp->StartTrace(*(options.m_traceoptions_sp), error.ref());
     trace_instance.SetTraceUID(uid);
     LLDB_LOG(log, "SBProcess::returned uid - {0}", uid);
   }
   return 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;
 
   ProcessSP process_sp(GetSP());
   if (process_sp) {
     const StateType event_state = SBProcess::GetStateFromEvent(event);
     char message[1024];
     int message_len = ::snprintf(
         message, sizeof(message), "Process %" PRIu64 " %s\n",
         process_sp->GetID(), SBDebugger::StateAsCString(event_state));
 
     if (message_len > 0)
       ::fwrite(message, 1, message_len, out);
   }
 }
 
 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);
     char message[1024];
     ::snprintf(message, sizeof(message), "Process %" PRIu64 " %s\n",
                process_sp->GetID(), SBDebugger::StateAsCString(event_state));
 
     result.AppendMessage(message);
   }
 }
 
 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(
         process_sp->GetTarget().GetAPIMutex());
     return process_sp->GetThreadList().SetSelectedThreadByID(
         thread.GetThreadID());
   }
   return false;
 }
 
 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;
   ProcessSP process_sp(GetSP());
   if (process_sp) {
     std::lock_guard<std::recursive_mutex> guard(
         process_sp->GetTarget().GetAPIMutex());
     ret_val = process_sp->GetThreadList().SetSelectedThreadByID(tid);
   }
 
   if (log)
     log->Printf("SBProcess(%p)::SetSelectedThreadByID (tid=0x%4.4" PRIx64
                 ") => %s",
                 static_cast<void *>(process_sp.get()), tid,
                 (ret_val ? "true" : "false"));
 
   return ret_val;
 }
 
 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;
   ProcessSP process_sp(GetSP());
   if (process_sp) {
     std::lock_guard<std::recursive_mutex> guard(
         process_sp->GetTarget().GetAPIMutex());
     ret_val = process_sp->GetThreadList().SetSelectedThreadByIndexID(index_id);
   }
 
   if (log)
     log->Printf("SBProcess(%p)::SetSelectedThreadByID (tid=0x%x) => %s",
                 static_cast<void *>(process_sp.get()), index_id,
                 (ret_val ? "true" : "false"));
 
   return ret_val;
 }
 
 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;
   ThreadSP thread_sp;
   ProcessSP process_sp(GetSP());
   if (process_sp) {
     Process::StopLocker stop_locker;
     const bool can_update = stop_locker.TryLock(&process_sp->GetRunLock());
     std::lock_guard<std::recursive_mutex> guard(
         process_sp->GetTarget().GetAPIMutex());
     thread_sp = process_sp->GetThreadList().GetThreadAtIndex(index, can_update);
     sb_thread.SetThread(thread_sp);
   }
 
   if (log)
     log->Printf("SBProcess(%p)::GetThreadAtIndex (index=%d) => SBThread(%p)",
                 static_cast<void *>(process_sp.get()),
                 static_cast<uint32_t>(index),
                 static_cast<void *>(thread_sp.get()));
 
   return 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;
   ProcessSP process_sp(GetSP());
   if (process_sp) {
     Process::StopLocker stop_locker;
     if (stop_locker.TryLock(&process_sp->GetRunLock())) {
       std::lock_guard<std::recursive_mutex> guard(
           process_sp->GetTarget().GetAPIMutex());
       num_queues = process_sp->GetQueueList().GetSize();
     }
   }
 
   if (log)
     log->Printf("SBProcess(%p)::GetNumQueues () => %d",
                 static_cast<void *>(process_sp.get()), num_queues);
 
   return num_queues;
 }
 
 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;
   QueueSP queue_sp;
   ProcessSP process_sp(GetSP());
   if (process_sp) {
     Process::StopLocker stop_locker;
     if (stop_locker.TryLock(&process_sp->GetRunLock())) {
log->Printf("SBProcess(%p)::GetQueueAtIndex (index=%d) => SBQueue(%p)",
                 static_cast<void *>(process_sp.get()),
                 static_cast<uint32_t>(index),
                 static_cast<void *>(queue_sp.get()));
 
   return 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(
         process_sp->GetTarget().GetAPIMutex());
     if (include_expression_stops)
       return process_sp->GetStopID();
     else
       return process_sp->GetLastNaturalStopID();
   }
   return 0;
 }
 
 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;
   EventSP event_sp;
   ProcessSP process_sp(GetSP());
   if (process_sp) {
     std::lock_guard<std::recursive_mutex> guard(
         process_sp->GetTarget().GetAPIMutex());
     event_sp = process_sp->GetStopEventForStopID(stop_id);
     sb_event.reset(event_sp);
   }
 
   if (log)
     log->Printf("SBProcess(%p)::GetStopEventForStopID (stop_id=%" PRIu32
                 ") => SBEvent(%p)",
                 static_cast<void *>(process_sp.get()), stop_id,
                 static_cast<void *>(event_sp.get()));
 
   return sb_event;
 }
 
 StateType SBProcess::GetState() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::StateType, SBProcess, GetState);
 
   StateType ret_val = eStateInvalid;
   ProcessSP process_sp(GetSP());
   if (process_sp) {
     std::lock_guard<std::recursive_mutex> guard(
         process_sp->GetTarget().GetAPIMutex());
     ret_val = process_sp->GetState();
   }
 
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   if (log)
     log->Printf("SBProcess(%p)::GetState () => %s",
                 static_cast<void *>(process_sp.get()),
                 lldb_private::StateAsCString(ret_val));
 
   return ret_val;
 }
 
 int SBProcess::GetExitStatus() {
+  LLDB_RECORD_METHOD_NO_ARGS(int, SBProcess, GetExitStatus);
+
   int exit_status = 0;
   ProcessSP process_sp(GetSP());
   if (process_sp) {
     std::lock_guard<std::recursive_mutex> guard(
         process_sp->GetTarget().GetAPIMutex());
     exit_status = process_sp->GetExitStatus();
   }
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   if (log)
     log->Printf("SBProcess(%p)::GetExitStatus () => %i (0x%8.8x)",
                 static_cast<void *>(process_sp.get()), exit_status,
                 exit_status);
 
   return exit_status;
 }
 
 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) {
     std::lock_guard<std::recursive_mutex> guard(
         process_sp->GetTarget().GetAPIMutex());
     exit_desc = process_sp->GetExitDescription();
   }
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   if (log)
     log->Printf("SBProcess(%p)::GetExitDescription () => %s",
                 static_cast<void *>(process_sp.get()), exit_desc);
   return exit_desc;
 }
 
 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)
     ret_val = process_sp->GetID();
 
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   if (log)
     log->Printf("SBProcess(%p)::GetProcessID () => %" PRIu64,
                 static_cast<void *>(process_sp.get()), ret_val);
 
   return ret_val;
 }
 
 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)
     ret_val = process_sp->GetUniqueID();
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   if (log)
     log->Printf("SBProcess(%p)::GetUniqueID () => %" PRIu32,
                 static_cast<void *>(process_sp.get()), ret_val);
   return ret_val;
 }
 
 ByteOrder SBProcess::GetByteOrder() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::ByteOrder, SBProcess, GetByteOrder);
+
   ByteOrder byteOrder = eByteOrderInvalid;
   ProcessSP process_sp(GetSP());
   if (process_sp)
     byteOrder = process_sp->GetTarget().GetArchitecture().GetByteOrder();
 
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   if (log)
     log->Printf("SBProcess(%p)::GetByteOrder () => %d",
                 static_cast<void *>(process_sp.get()), byteOrder);
 
   return byteOrder;
 }
 
 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)
     size = process_sp->GetTarget().GetArchitecture().GetAddressByteSize();
 
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   if (log)
     log->Printf("SBProcess(%p)::GetAddressByteSize () => %d",
                 static_cast<void *>(process_sp.get()), size);
 
   return size;
 }
 
 SBError SBProcess::Continue() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBProcess, Continue);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   SBError sb_error;
   ProcessSP process_sp(GetSP());
 
   if (log)
     log->Printf("SBProcess(%p)::Continue ()...",
                 static_cast<void *>(process_sp.get()));
log->Printf("SBProcess(%p)::Continue () => SBError (%p): %s",
                 static_cast<void *>(process_sp.get()),
                 static_cast<void *>(sb_error.get()), sstr.GetData());
   }
 
   return sb_error;
 }
 
 SBError SBProcess::Destroy() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBProcess, Destroy);
+
   SBError sb_error;
   ProcessSP process_sp(GetSP());
   if (process_sp) {
     std::lock_guard<std::recursive_mutex> guard(
         process_sp->GetTarget().GetAPIMutex());
     sb_error.SetError(process_sp->Destroy(false));
   } else
     sb_error.SetErrorString("SBProcess is invalid");
 
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   if (log) {
     SBStream sstr;
     sb_error.GetDescription(sstr);
     log->Printf("SBProcess(%p)::Destroy () => SBError (%p): %s",
                 static_cast<void *>(process_sp.get()),
                 static_cast<void *>(sb_error.get()), sstr.GetData());
   }
 
   return sb_error;
 }
 
 SBError SBProcess::Stop() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBProcess, Stop);
+
   SBError sb_error;
   ProcessSP process_sp(GetSP());
   if (process_sp) {
     std::lock_guard<std::recursive_mutex> guard(
         process_sp->GetTarget().GetAPIMutex());
     sb_error.SetError(process_sp->Halt());
   } else
     sb_error.SetErrorString("SBProcess is invalid");
 
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   if (log) {
     SBStream sstr;
     sb_error.GetDescription(sstr);
     log->Printf("SBProcess(%p)::Stop () => SBError (%p): %s",
                 static_cast<void *>(process_sp.get()),
                 static_cast<void *>(sb_error.get()), sstr.GetData());
   }
 
   return sb_error;
 }
 
 SBError SBProcess::Kill() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBProcess, Kill);
+
   SBError sb_error;
   ProcessSP process_sp(GetSP());
   if (process_sp) {
     std::lock_guard<std::recursive_mutex> guard(
         process_sp->GetTarget().GetAPIMutex());
     sb_error.SetError(process_sp->Destroy(true));
   } else
     sb_error.SetErrorString("SBProcess is invalid");
 
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   if (log) {
     SBStream sstr;
     sb_error.GetDescription(sstr);
     log->Printf("SBProcess(%p)::Kill () => SBError (%p): %s",
                 static_cast<void *>(process_sp.get()),
                 static_cast<void *>(sb_error.get()), sstr.GetData());
   }
 
   return 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);
 }
 
 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) {
     std::lock_guard<std::recursive_mutex> guard(
         process_sp->GetTarget().GetAPIMutex());
     sb_error.SetError(process_sp->Detach(keep_stopped));
   } else
     sb_error.SetErrorString("SBProcess is invalid");
 
   return 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) {
     std::lock_guard<std::recursive_mutex> guard(
         process_sp->GetTarget().GetAPIMutex());
     sb_error.SetError(process_sp->Signal(signo));
   } else
     sb_error.SetErrorString("SBProcess is invalid");
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   if (log) {
     SBStream sstr;
     sb_error.GetDescription(sstr);
     log->Printf("SBProcess(%p)::Signal (signo=%i) => SBError (%p): %s",
                 static_cast<void *>(process_sp.get()), signo,
                 static_cast<void *>(sb_error.get()), sstr.GetData());
   }
   return sb_error;
 }
 
 SBUnixSignals SBProcess::GetUnixSignals() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBUnixSignals, SBProcess, GetUnixSignals);
+
   if (auto process_sp = GetSP())
     return SBUnixSignals{process_sp};
 
   return {};
 }
 
 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());
   if (process_sp) {
     Process::StopLocker stop_locker;
     const bool can_update = stop_locker.TryLock(&process_sp->GetRunLock());
     std::lock_guard<std::recursive_mutex> guard(
         process_sp->GetTarget().GetAPIMutex());
     thread_sp = process_sp->GetThreadList().FindThreadByID(tid, can_update);
     sb_thread.SetThread(thread_sp);
   }
 
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   if (log)
     log->Printf("SBProcess(%p)::GetThreadByID (tid=0x%4.4" PRIx64
                 ") => SBThread (%p)",
                 static_cast<void *>(process_sp.get()), tid,
                 static_cast<void *>(thread_sp.get()));
 
   return 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());
   if (process_sp) {
     Process::StopLocker stop_locker;
     const bool can_update = stop_locker.TryLock(&process_sp->GetRunLock());
     std::lock_guard<std::recursive_mutex> guard(
         process_sp->GetTarget().GetAPIMutex());
     thread_sp =
         process_sp->GetThreadList().FindThreadByIndexID(index_id, can_update);
     sb_thread.SetThread(thread_sp);
   }
 
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   if (log)
     log->Printf("SBProcess(%p)::GetThreadByID (tid=0x%x) => SBThread (%p)",
                 static_cast<void *>(process_sp.get()), index_id,
                 static_cast<void *>(thread_sp.get()));
 
   return 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());
 
   if (log)
     log->Printf("SBProcess::GetStateFromEvent (event.sp=%p) => %s",
                 static_cast<void *>(event.get()),
                 lldb_private::StateAsCString(ret_val));
 
   return ret_val;
 }
 
 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());
 
   if (log)
     log->Printf("SBProcess::%s (event.sp=%p) => %d", __FUNCTION__,
                 static_cast<void *>(event.get()), ret_val);
 
   return ret_val;
 }
 
 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) {
     // StructuredData events also know the process they come from. Try that.
     process_sp = EventDataStructuredData::GetProcessFromEvent(event.get());
   }
 
   return 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) {
+  LLDB_RECORD_STATIC_METHOD(lldb::SBStructuredData, SBProcess,
+                            GetStructuredDataFromEvent, (const lldb::SBEvent &),
+                            event);
+
   return 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() ==
                         EventDataStructuredData::GetFlavorString());
 }
 
 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());
 
   SBBroadcaster broadcaster(process_sp.get(), false);
 
   if (log)
     log->Printf("SBProcess(%p)::GetBroadcaster () => SBBroadcaster (%p)",
                 static_cast<void *>(process_sp.get()),
                 static_cast<void *>(broadcaster.get()));
 
   return broadcaster;
 }
 
 const char *SBProcess::GetBroadcasterClass() {
+  LLDB_RECORD_STATIC_METHOD_NO_ARGS(const char *, SBProcess,
+                                    GetBroadcasterClass);
+
   return Process::GetStaticBroadcasterClass().AsCString();
 }
 
 size_t SBProcess::ReadMemory(addr_t addr, void *dst, size_t dst_len,
                              SBError &sb_error) {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   size_t bytes_read = 0;
size_t SBProcess::ReadCStringFromMemory(addr_t addr, void *buf, size_t size,
   } else {
     sb_error.SetErrorString("SBProcess is invalid");
   }
   return bytes_read;
 }
 
 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) {
     Process::StopLocker stop_locker;
     if (stop_locker.TryLock(&process_sp->GetRunLock())) {
       std::lock_guard<std::recursive_mutex> guard(
           process_sp->GetTarget().GetAPIMutex());
       value = process_sp->ReadUnsignedIntegerFromMemory(addr, byte_size, 0,
uint64_t SBProcess::ReadUnsignedFromMemory(addr_t addr, uint32_t byte_size,
   } else {
     sb_error.SetErrorString("SBProcess is invalid");
   }
   return value;
 }
 
 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) {
     Process::StopLocker stop_locker;
     if (stop_locker.TryLock(&process_sp->GetRunLock())) {
       std::lock_guard<std::recursive_mutex> guard(
           process_sp->GetTarget().GetAPIMutex());
       ptr = process_sp->ReadPointerFromMemory(addr, sb_error.ref());
log->Printf("SBProcess(%p)::WriteMemory (addr=0x%" PRIx64
                 static_cast<void *>(sb_error.get()), sstr.GetData(),
                 static_cast<uint64_t>(bytes_written));
   }
 
   return bytes_written;
 }
 
 bool SBProcess::GetDescription(SBStream &description) {
+  LLDB_RECORD_METHOD(bool, SBProcess, GetDescription, (lldb::SBStream &),
+                     description);
+
   Stream &strm = description.ref();
 
   ProcessSP process_sp(GetSP());
   if (process_sp) {
     char path[PATH_MAX];
     GetTarget().GetExecutable().GetPath(path, sizeof(path));
     Module *exe_module = process_sp->GetTarget().GetExecutableModulePointer();
     const char *exe_name = NULL;
     if (exe_module)
       exe_name = exe_module->GetFileSpec().GetFilename().AsCString();
 
     strm.Printf("SBProcess: pid = %" PRIu64 ", state = %s, threads = %d%s%s",
                 process_sp->GetID(), lldb_private::StateAsCString(GetState()),
                 GetNumThreads(), exe_name ? ", executable = " : "",
                 exe_name ? exe_name : "");
   } else
     strm.PutCString("No value");
 
   return true;
 }
 
 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;
   ProcessSP process_sp(GetSP());
   if (process_sp) {
     std::lock_guard<std::recursive_mutex> guard(
         process_sp->GetTarget().GetAPIMutex());
     sb_error.SetError(process_sp->GetWatchpointSupportInfo(num));
     if (log)
       log->Printf("SBProcess(%p)::GetNumSupportedHardwareWatchpoints () => %u",
                   static_cast<void *>(process_sp.get()), num);
   } else {
     sb_error.SetErrorString("SBProcess is invalid");
   }
   return num;
 }
 
 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) {
     Process::StopLocker stop_locker;
     if (stop_locker.TryLock(&process_sp->GetRunLock())) {
       if (log)
         log->Printf("SBProcess(%p)::LoadImage() => calling Platform::LoadImage"
                     "for: %s",
if (log)
                     static_cast<void *>(process_sp.get()));
     sb_error.SetErrorString("process is invalid");
   }
   return LLDB_INVALID_IMAGE_TOKEN;
 }
 
 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) {
     Process::StopLocker stop_locker;
     if (stop_locker.TryLock(&process_sp->GetRunLock())) {
       if (log)
         log->Printf("SBProcess(%p)::LoadImageUsingPaths() => "
                     "calling Platform::LoadImageUsingPaths for: %s",
if (log)
                     static_cast<void *>(process_sp.get()));
     error.SetErrorString("process is invalid");
   }
   
   return LLDB_INVALID_IMAGE_TOKEN;
 }
 
 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) {
     Process::StopLocker stop_locker;
     if (stop_locker.TryLock(&process_sp->GetRunLock())) {
       std::lock_guard<std::recursive_mutex> guard(
           process_sp->GetTarget().GetAPIMutex());
       PlatformSP platform_sp = process_sp->GetTarget().GetPlatform();
       sb_error.SetError(
           platform_sp->UnloadImage(process_sp.get(), image_token));
     } else {
       Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
       if (log)
         log->Printf("SBProcess(%p)::UnloadImage() => error: process is running",
                     static_cast<void *>(process_sp.get()));
       sb_error.SetErrorString("process is running");
     }
   } else
     sb_error.SetErrorString("invalid process");
   return 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) {
     Process::StopLocker stop_locker;
     if (stop_locker.TryLock(&process_sp->GetRunLock())) {
       std::lock_guard<std::recursive_mutex> guard(
           process_sp->GetTarget().GetAPIMutex());
       sb_error.SetError(process_sp->SendEventData(event_data));
     } else {
       Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
       if (log)
         log->Printf(
             "SBProcess(%p)::SendEventData() => error: process is running",
             static_cast<void *>(process_sp.get()));
       sb_error.SetErrorString("process is running");
     }
   } else
     sb_error.SetErrorString("invalid process");
   return 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();
     return runtime->GetExtendedBacktraceTypes().size();
   }
   return 0;
 }
 
 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();
     const std::vector<ConstString> &names =
         runtime->GetExtendedBacktraceTypes();
     if (idx < names.size()) {
       return names[idx].AsCString();
     } else {
       Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
       if (log)
         log->Printf("SBProcess(%p)::GetExtendedBacktraceTypeAtIndex() => "
                     "error: requested extended backtrace name out of bounds",
                     static_cast<void *>(process_sp.get()));
     }
   }
   return NULL;
 }
 
 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;
 }
 
 bool SBProcess::IsInstrumentationRuntimePresent(
     InstrumentationRuntimeType type) {
+  LLDB_RECORD_METHOD(bool, SBProcess, IsInstrumentationRuntimePresent,
+                     (lldb::InstrumentationRuntimeType), type);
+
   ProcessSP process_sp(GetSP());
   if (!process_sp)
     return false;
 
   InstrumentationRuntimeSP runtime_sp =
       process_sp->GetInstrumentationRuntime(type);
 
   if (!runtime_sp.get())
     return false;
 
   return runtime_sp->IsActive();
 }
 
 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;
   }
 
   std::lock_guard<std::recursive_mutex> guard(
       process_sp->GetTarget().GetAPIMutex());
 
   if (process_sp->GetState() != eStateStopped) {
     error.SetErrorString("the process is not stopped");
     return error;
   }
 
   FileSpec core_file(file_name);
   error.ref() = PluginManager::SaveCore(process_sp, core_file);
   return error;
 }
 
 lldb::SBError
 SBProcess::GetMemoryRegionInfo(lldb::addr_t load_addr,
                                SBMemoryRegionInfo &sb_region_info) {
+  LLDB_RECORD_METHOD(lldb::SBError, SBProcess, GetMemoryRegionInfo,
+                     (lldb::addr_t, lldb::SBMemoryRegionInfo &), load_addr,
+                     sb_region_info);
+
   lldb::SBError sb_error;
   ProcessSP process_sp(GetSP());
   if (process_sp) {
     Process::StopLocker stop_locker;
     if (stop_locker.TryLock(&process_sp->GetRunLock())) {
       std::lock_guard<std::recursive_mutex> guard(
           process_sp->GetTarget().GetAPIMutex());
 
if (process_sp) {
     }
   } else {
     sb_error.SetErrorString("SBProcess is invalid");
   }
   return sb_error;
 }
 
 lldb::SBMemoryRegionInfoList SBProcess::GetMemoryRegions() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBMemoryRegionInfoList, SBProcess,
+                             GetMemoryRegions);
+
   lldb::SBMemoryRegionInfoList sb_region_list;
 
   ProcessSP process_sp(GetSP());
   Process::StopLocker stop_locker;
   if (process_sp && stop_locker.TryLock(&process_sp->GetRunLock())) {
     std::lock_guard<std::recursive_mutex> guard(
         process_sp->GetTarget().GetAPIMutex());
 
     process_sp->GetMemoryRegions(sb_region_list.ref());
   } else {
     Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
     if (log)
       log->Printf(
           "SBProcess(%p)::GetMemoryRegionInfo() => error: process is running",
           static_cast<void *>(process_sp.get()));
   }
 
   return 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;
 }

lldb/source/API/SBProcessInfo.cpp

 //===-- SBProcessInfo.cpp ---------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #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;
     else
       m_opaque_up.reset();
   }
   return *this;
 }
 
 ProcessInstanceInfo &SBProcessInfo::ref() {
   if (m_opaque_up == nullptr) {
     m_opaque_up.reset(new ProcessInstanceInfo());
   }
   return *m_opaque_up;
 }
 
 void SBProcessInfo::SetProcessInfo(const ProcessInstanceInfo &proc_info_ref) {
   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();
   }
   return name;
 }
 
 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;
 }
 
 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();
   }
   return proc_id;
 }
 
 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();
   }
   return user_id;
 }
 
 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();
   }
   return group_id;
 }
 
 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();
   }
   return is_valid;
 }
 
 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();
   }
   return is_valid;
 }
 
 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();
   }
   return user_id;
 }
 
 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();
   }
   return group_id;
 }
 
 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();
   }
   return is_valid;
 }
 
 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();
   }
   return is_valid;
 }
 
 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();
   }
   return proc_id;
 }

lldb/source/API/SBQueue.cpp

 //===-- SBQueue.cpp ---------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
+#include "SBReproducerPrivate.h"
+
 #include <inttypes.h>
 
 #include "lldb/API/SBQueue.h"
 
 #include "lldb/API/SBProcess.h"
 #include "lldb/API/SBQueueItem.h"
 #include "lldb/API/SBThread.h"
 
std::vector<lldb::ThreadWP>
       m_threads; // threads currently executing this queue's items
   bool
       m_thread_list_fetched; // have we tried to fetch the threads list already?
   std::vector<lldb::QueueItemSP> m_pending_items; // items currently enqueued
   bool m_pending_items_fetched; // have we tried to fetch the item list already?
 };
 }
 
-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;
 
   m_opaque_sp = rhs.m_opaque_sp;
 }
 
 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)
     log->Printf("SBQueue(0x%" PRIx64 ")::IsValid() == %s",
                 m_opaque_sp->GetQueueID(), is_valid ? "true" : "false");
   return is_valid;
 }
 
 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());
   m_opaque_sp->Clear();
 }
 
 void SBQueue::SetQueue(const QueueSP &queue_sp) {
   m_opaque_sp->SetQueue(queue_sp);
 }
 
 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)
     log->Printf("SBQueue(0x%" PRIx64 ")::GetQueueID() == 0x%" PRIx64,
                 m_opaque_sp->GetQueueID(), (uint64_t)qid);
   return qid;
 }
 
 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)
     log->Printf("SBQueue(0x%" PRIx64 ")::GetIndexID() == 0x%" PRIx32,
                 m_opaque_sp->GetQueueID(), index_id);
   return index_id;
 }
 
 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)
     log->Printf("SBQueue(0x%" PRIx64 ")::GetName() == %s",
                 m_opaque_sp->GetQueueID(), name ? name : "");
   return name;
 }
 
 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)
     log->Printf("SBQueue(0x%" PRIx64 ")::GetNumThreads() == %d",
                 m_opaque_sp->GetQueueID(), numthreads);
   return numthreads;
 }
 
 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;
 }
 
 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)
     log->Printf("SBQueue(0x%" PRIx64 ")::GetNumPendingItems() == %d",
                 m_opaque_sp->GetQueueID(), pending_items);
   return pending_items;
 }
 
 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);
 }
 
 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)
     log->Printf("SBQueue(0x%" PRIx64 ")::GetNumRunningItems() == %d",
                 m_opaque_sp->GetQueueID(), running_items);
   return running_items;
 }
 
-SBProcess SBQueue::GetProcess() { return m_opaque_sp->GetProcess(); }
+SBProcess SBQueue::GetProcess() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBProcess, SBQueue, GetProcess);
+  return m_opaque_sp->GetProcess();
+}
 
-lldb::QueueKind SBQueue::GetKind() { return m_opaque_sp->GetKind(); }
+lldb::QueueKind SBQueue::GetKind() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::QueueKind, SBQueue, GetKind);
+  return m_opaque_sp->GetKind();
+}

lldb/source/API/SBQueueItem.cpp

 //===-- SBQueueItem.cpp -----------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
+#include "SBReproducerPrivate.h"
+
 #include "lldb/lldb-forward.h"
 
 #include "lldb/API/SBAddress.h"
 #include "lldb/API/SBQueueItem.h"
 #include "lldb/API/SBThread.h"
 #include "lldb/Core/Address.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/QueueItem.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/Log.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 //----------------------------------------------------------------------
 // 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)
     log->Printf("SBQueueItem(%p)::IsValid() == %s",
                 static_cast<void *>(m_queue_item_sp.get()),
                 is_valid ? "true" : "false");
   return is_valid;
 }
 
 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()",
                 static_cast<void *>(m_queue_item_sp.get()));
   m_queue_item_sp.reset();
 }
 
 void SBQueueItem::SetQueueItem(const QueueItemSP &queue_item_sp) {
+  LLDB_RECORD_METHOD(void, SBQueueItem, SetQueueItem,
+                     (const lldb::QueueItemSP &), queue_item_sp);
+
   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) {
     result = m_queue_item_sp->GetKind();
   }
   if (log)
     log->Printf("SBQueueItem(%p)::GetKind() == %d",
                 static_cast<void *>(m_queue_item_sp.get()),
                 static_cast<int>(result));
   return result;
 }
 
 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) {
     result.SetAddress(&m_queue_item_sp->GetAddress());
   }
   if (log) {
     StreamString sstr;
     const Address *addr = result.get();
     if (addr)
       addr->Dump(&sstr, NULL, Address::DumpStyleModuleWithFileAddress,
                  Address::DumpStyleInvalid, 4);
     log->Printf("SBQueueItem(%p)::GetAddress() == SBAddress(%p): %s",
                 static_cast<void *>(m_queue_item_sp.get()),
                 static_cast<void *>(result.get()), sstr.GetData());
   }
   return 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) {
     ProcessSP process_sp = m_queue_item_sp->GetProcessSP();
     Process::StopLocker stop_locker;
     if (process_sp && stop_locker.TryLock(&process_sp->GetRunLock())) {
       ThreadSP thread_sp;
       ConstString type_const(type);

lldb/source/API/SBSection.cpp

 //===-- SBSection.cpp -------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
+#include "SBReproducerPrivate.h"
+
 #include "lldb/API/SBSection.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/API/SBTarget.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/Section.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Utility/DataBuffer.h"
 #include "lldb/Utility/DataExtractor.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/StreamString.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
                     // section_sp doesn't contain a valid Section *
 {
   if (section_sp)
     m_opaque_wp = section_sp;
 }
 
 const SBSection &SBSection::operator=(const SBSection &rhs) {
+  LLDB_RECORD_METHOD(const lldb::SBSection &,
+                     SBSection, operator=,(const lldb::SBSection &), rhs);
+
   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();
   return NULL;
 }
 
 lldb::SBSection SBSection::GetParent() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBSection, SBSection, GetParent);
+
   lldb::SBSection sb_section;
   SectionSP section_sp(GetSP());
   if (section_sp) {
     SectionSP parent_section_sp(section_sp->GetParent());
     if (parent_section_sp)
       sb_section.SetSP(parent_section_sp);
   }
   return 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());
     if (section_sp) {
       ConstString const_sect_name(sect_name);
       sb_section.SetSP(
           section_sp->GetChildren().FindSectionByName(const_sect_name));
     }
   }
   return 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();
   return 0;
 }
 
 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;
 }
 
 lldb::SectionSP SBSection::GetSP() const { return m_opaque_wp.lock(); }
 
 void SBSection::SetSP(const lldb::SectionSP &section_sp) {
   m_opaque_wp = section_sp;
 }
 
 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)
     return section_sp->GetFileAddress();
   return file_addr;
 }
 
 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());
     if (section_sp)
       return section_sp->GetLoadBaseAddress(target_sp.get());
   }
   return LLDB_INVALID_ADDRESS;
 }
 
 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();
   return 0;
 }
 
 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());
     if (module_sp) {
       ObjectFile *objfile = module_sp->GetObjectFile();
       if (objfile)
         return objfile->GetFileOffset() + section_sp->GetFileOffset();
     }
   }
   return UINT64_MAX;
 }
 
 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 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) {
     const uint64_t sect_file_size = section_sp->GetFileSize();
     if (sect_file_size > 0) {
       ModuleSP module_sp(section_sp->GetModule());
       if (module_sp) {
         ObjectFile *objfile = module_sp->GetObjectFile();
if (sect_file_size > 0) {
         }
       }
     }
   }
   return 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();
   return 0;
 }
 
 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)
     return lhs_section_sp == rhs_section_sp;
   return false;
 }
 
 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());
   if (section_sp) {
     const addr_t file_addr = section_sp->GetFileAddress();
     strm.Printf("[0x%16.16" PRIx64 "-0x%16.16" PRIx64 ") ", file_addr,
                 file_addr + section_sp->GetByteSize());
     section_sp->DumpName(&strm);
   } else {
     strm.PutCString("No value");
   }
 
   return true;
 }

lldb/source/API/SBSourceManager.cpp

 //===-- SBSourceManager.cpp -------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBSourceManager.h"
+#include "SBReproducerPrivate.h"
 #include "lldb/API/SBDebugger.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/API/SBTarget.h"
 
 #include "lldb/API/SBFileSpec.h"
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/SourceManager.h"
 #include "lldb/Core/StreamFile.h"
private:
   lldb::TargetWP m_target_wp;
 };
 }
 
 using namespace lldb;
 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;
 
   m_opaque_up.reset(new SourceManagerImpl(*(rhs.m_opaque_up.get())));
 }
 
 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;
 }
 
 SBSourceManager::~SBSourceManager() {}
 
 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,
       current_line_cstr, s);
 }
 
 size_t SBSourceManager::DisplaySourceLinesWithLineNumbersAndColumn(
     const SBFileSpec &file, uint32_t line, uint32_t column,
     uint32_t context_before, uint32_t context_after,
     const char *current_line_cstr, SBStream &s) {
+  LLDB_RECORD_METHOD(
+      size_t, SBSourceManager, DisplaySourceLinesWithLineNumbersAndColumn,
+      (const lldb::SBFileSpec &, uint32_t, uint32_t, uint32_t, uint32_t,
+       const char *, lldb::SBStream &),
+      file, line, column, context_before, context_after, current_line_cstr, s);
+
   if (m_opaque_up == NULL)
     return 0;
 
   return m_opaque_up->DisplaySourceLinesWithLineNumbers(
       file.ref(), line, column, context_before, context_after,
       current_line_cstr, s.get());
 }

lldb/source/API/SBStream.cpp

 //===-- SBStream.cpp ----------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBStream.h"
+#include "SBReproducerPrivate.h"
 
 #include "lldb/Core/StreamFile.h"
 #include "lldb/Host/FileSystem.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/Stream.h"
 #include "lldb/Utility/StreamString.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;
 
   return static_cast<StreamString *>(m_opaque_up.get())->GetData();
 }
 
 // If this stream is not redirected to a file, it will maintain a local cache
 // for the stream output whose length can be accessed using this accessor.
 size_t SBStream::GetSize() {
+  LLDB_RECORD_METHOD_NO_ARGS(size_t, SBStream, GetSize);
+
   if (m_is_file || m_opaque_up == NULL)
     return 0;
 
   return static_cast<StreamString *>(m_opaque_up.get())->GetSize();
 }
 
 void SBStream::Printf(const char *format, ...) {
   if (!format)
     return;
   va_list args;
   va_start(args, format);
   ref().PrintfVarArg(format, args);
   va_end(args);
 }
 
 void SBStream::RedirectToFile(const char *path, bool append) {
+  LLDB_RECORD_METHOD(void, SBStream, RedirectToFile, (const char *, bool), path,
+                     append);
+
   if (path == nullptr)
     return;
 
   std::string local_data;
   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
     if (!m_is_file)
if (m_opaque_up) {
     // the to new file we are redirecting to.
     if (!local_data.empty())
       m_opaque_up->Write(&local_data[0], local_data.size());
   } else
     m_is_file = false;
 }
 
 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;
 
   std::string local_data;
   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
     if (!m_is_file)
       local_data = static_cast<StreamString *>(m_opaque_up.get())->GetString();
   }
   m_opaque_up.reset(new StreamFile(fh, transfer_fh_ownership));
 
   if (m_opaque_up) {
     m_is_file = true;
 
     // If we had any data locally in our StreamString, then pass that along to
     // the to new file we are redirecting to.
     if (!local_data.empty())
       m_opaque_up->Write(&local_data[0], local_data.size());
   } else
     m_is_file = false;
 }
 
 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
     // redirect it to the file so we don't lose the data
     if (!m_is_file)
       local_data = static_cast<StreamString *>(m_opaque_up.get())->GetString();
   }
 

 
 lldb_private::Stream &SBStream::ref() {
   if (m_opaque_up == NULL)
     m_opaque_up.reset(new StreamString());
   return *m_opaque_up;
 }
 
 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
     if (m_is_file)
       m_opaque_up.reset();
     else
       static_cast<StreamString *>(m_opaque_up.get())->Clear();
   }
 }

lldb/source/API/SBStringList.cpp

 //===-- SBStringList.cpp ----------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #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() {
   if (lldb_strings_ptr)
     m_opaque_up.reset(new lldb_private::StringList(*lldb_strings_ptr));
 }
 
 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));
     else
       m_opaque_up.reset();
   }
   return *this;
 }
 
 SBStringList::~SBStringList() {}
 
 const lldb_private::StringList *SBStringList::operator->() const {
   return m_opaque_up.get();
 }
 
 const lldb_private::StringList &SBStringList::operator*() const {
   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);
     else
       m_opaque_up.reset(new lldb_private::StringList(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);
     else
       m_opaque_up.reset(new lldb_private::StringList(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());
     m_opaque_up->AppendList(*(strings.m_opaque_up));
   }
 }
 
 void SBStringList::AppendList(const StringList &strings) {
   if (!IsValid())
     m_opaque_up.reset(new lldb_private::StringList());
   m_opaque_up->AppendList(strings);
 }
 
 uint32_t SBStringList::GetSize() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBStringList, GetSize);
+
   if (IsValid()) {
     return m_opaque_up->GetSize();
   }
   return 0;
 }
 
 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);
   }
   return NULL;
 }
 
 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);
   }
   return NULL;
 }
 
 void SBStringList::Clear() {
+  LLDB_RECORD_METHOD_NO_ARGS(void, SBStringList, Clear);
+
   if (IsValid()) {
     m_opaque_up->Clear();
   }
 }

lldb/source/API/SBStructuredData.cpp

 //===-- SBStructuredData.cpp ------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
+#include "SBReproducerPrivate.h"
+
 #include "lldb/API/SBStructuredData.h"
 
 #include "lldb/API/SBStream.h"
 #include "lldb/API/SBStringList.h"
 #include "lldb/Core/StructuredDataImpl.h"
 #include "lldb/Target/StructuredDataPlugin.h"
 #include "lldb/Utility/Event.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/Stream.h"
 #include "lldb/Utility/StructuredData.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 #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());
 
   StructuredData::ObjectSP json_obj = StructuredData::ParseJSON(json_str);
   m_impl_up->SetObjectSP(json_obj);
 
   if (!json_obj || json_obj->GetType() != eStructuredDataTypeDictionary)
     error.SetErrorString("Invalid Syntax");
   return error;
 }
 
-bool SBStructuredData::IsValid() const { return m_impl_up->IsValid(); }
+bool SBStructuredData::IsValid() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBStructuredData, IsValid);
+  return m_impl_up->IsValid();
+}
 
-void SBStructuredData::Clear() { m_impl_up->Clear(); }
+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;
 }
 
 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;
 }
 
 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;
   
   if (GetType() != eStructuredDataTypeDictionary)
     return false;
   
   StructuredData::ObjectSP obj_sp = m_impl_up->GetObjectSP();
   if (!obj_sp)
key_arr->ForEach([&keys] (StructuredData::Object *object) -> bool {
     llvm::StringRef key = object->GetStringValue("");
     keys.AppendString(key.str().c_str());
     return true;
   });
   return true;
 }
 
 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();
 
   SBStructuredData result;
   result.m_impl_up->SetObjectSP(m_impl_up->GetValueForKey(key));
   return 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();
 
   SBStructuredData result;
   result.m_impl_up->SetObjectSP(m_impl_up->GetItemAtIndex(idx));
   return 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

 //===-- SBSymbol.cpp --------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
+#include "SBReproducerPrivate.h"
+
 #include "lldb/API/SBSymbol.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/Core/Disassembler.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Symbol/Symbol.h"
 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/Log.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;
 }
 
 SBSymbol::~SBSymbol() { m_opaque_ptr = NULL; }
 
 void SBSymbol::SetSymbol(lldb_private::Symbol *lldb_object_ptr) {
   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();
 
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   if (log)
     log->Printf("SBSymbol(%p)::GetName () => \"%s\"",
                 static_cast<void *>(m_opaque_ptr), name ? name : "");
   return name;
 }
 
 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()
                .GetDisplayDemangledName(m_opaque_ptr->GetLanguage())
                .AsCString();
 
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   if (log)
     log->Printf("SBSymbol(%p)::GetDisplayName () => \"%s\"",
                 static_cast<void *>(m_opaque_ptr), name ? name : "");
   return name;
 }
 
 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();
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   if (log)
     log->Printf("SBSymbol(%p)::GetMangledName () => \"%s\"",
                 static_cast<void *>(m_opaque_ptr), name ? name : "");
 
   return name;
 }
 
 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) {
     m_opaque_ptr->GetDescription(&strm, lldb::eDescriptionLevelFull, NULL);
   } else
     strm.PutCString("No value");
 
   return true;
 }
 
 SBInstructionList SBSymbol::GetInstructions(SBTarget target) {
+  LLDB_RECORD_METHOD(lldb::SBInstructionList, SBSymbol, GetInstructions,
+                     (lldb::SBTarget), target);
+
   return 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;
     TargetSP target_sp(target.GetSP());
     std::unique_lock<std::recursive_mutex> lock;
     if (target_sp) {
       lock = std::unique_lock<std::recursive_mutex>(target_sp->GetAPIMutex());
 
SBInstructionList SBSymbol::GetInstructions(SBTarget target,
   return 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;
 }
 
 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();
     if (range_size > 0) {
       addr.SetAddress(&m_opaque_ptr->GetAddressRef());
       addr->Slide(m_opaque_ptr->GetByteSize());
     }
   }
   return 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

 //===-- SBSymbolContext.cpp -------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBSymbolContext.h"
+#include "SBReproducerPrivate.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Symbol/Function.h"
 #include "lldb/Symbol/Symbol.h"
 #include "lldb/Symbol/SymbolContext.h"
 #include "lldb/Utility/Log.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;
     else
       ref() = *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));
   }
   return *this;
 }
 
 void SBSymbolContext::SetSymbolContext(const SymbolContext *sc_ptr) {
   if (sc_ptr) {
     if (m_opaque_up)
       *m_opaque_up = *sc_ptr;
     else
       m_opaque_up.reset(new SymbolContext(*sc_ptr));
   } else {
     if (m_opaque_up)
       m_opaque_up->Clear(true);
   }
 }
 
-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;
   ModuleSP module_sp;
   if (m_opaque_up) {
     module_sp = m_opaque_up->module_sp;
     sb_module.SetSP(module_sp);
   }
 
   if (log) {
     SBStream sstr;
     sb_module.GetDescription(sstr);
     log->Printf("SBSymbolContext(%p)::GetModule () => SBModule(%p): %s",
                 static_cast<void *>(m_opaque_up.get()),
                 static_cast<void *>(module_sp.get()), sstr.GetData());
   }
 
   return sb_module;
 }
 
 SBCompileUnit SBSymbolContext::GetCompileUnit() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBCompileUnit, SBSymbolContext,
+                             GetCompileUnit);
+
   return 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;
 
   if (m_opaque_up)
     function = m_opaque_up->function;
 
   SBFunction sb_function(function);
 
   if (log)
     log->Printf("SBSymbolContext(%p)::GetFunction () => SBFunction(%p)",
                 static_cast<void *>(m_opaque_up.get()),
                 static_cast<void *>(function));
 
   return sb_function;
 }
 
 SBBlock SBSymbolContext::GetBlock() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBBlock, SBSymbolContext, GetBlock);
+
   return 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;
   if (m_opaque_up)
     sb_line_entry.SetLineEntry(m_opaque_up->line_entry);
 
   if (log) {
     log->Printf("SBSymbolContext(%p)::GetLineEntry () => SBLineEntry(%p)",
                 static_cast<void *>(m_opaque_up.get()),
                 static_cast<void *>(sb_line_entry.get()));
   }
 
   return 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;
 
   if (m_opaque_up)
     symbol = m_opaque_up->symbol;
 
   SBSymbol sb_symbol(symbol);
 
   if (log)
     log->Printf("SBSymbolContext(%p)::GetSymbol () => SBSymbol(%p)",
                 static_cast<void *>(m_opaque_up.get()),
                 static_cast<void *>(symbol));
 
   return 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
     ref().line_entry.Clear();
 }
 
 void SBSymbolContext::SetSymbol(lldb::SBSymbol symbol) {
+  LLDB_RECORD_METHOD(void, SBSymbolContext, SetSymbol, (lldb::SBSymbol),
+                     symbol);
+
   ref().symbol = symbol.get();
 }
 
 lldb_private::SymbolContext *SBSymbolContext::operator->() const {
   return m_opaque_up.get();
 }
 
 const lldb_private::SymbolContext &SBSymbolContext::operator*() const {
lldb_private::SymbolContext &SBSymbolContext::ref() {
   return *m_opaque_up;
 }
 
 lldb_private::SymbolContext *SBSymbolContext::get() const {
   return m_opaque_up.get();
 }
 
 bool SBSymbolContext::GetDescription(SBStream &description) {
+  LLDB_RECORD_METHOD(bool, SBSymbolContext, GetDescription, (lldb::SBStream &),
+                     description);
+
   Stream &strm = description.ref();
 
   if (m_opaque_up) {
     m_opaque_up->GetDescription(&strm, lldb::eDescriptionLevelFull, NULL);
   } else
     strm.PutCString("No value");
 
   return true;
 }
 
 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 SBSymbolContext();
 }

lldb/source/API/SBSymbolContextList.cpp

 //===-- SBSymbolContextList.cpp ---------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBSymbolContextList.h"
+#include "SBReproducerPrivate.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/Symbol/SymbolContext.h"
 
 using namespace lldb;
 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;
   }
   return *this;
 }
 
 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;
     if (m_opaque_up->GetContextAtIndex(idx, sc)) {
       sb_sc.SetSymbolContext(&sc);
     }
   }
   return 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();
 }
 
 lldb_private::SymbolContextList &SBSymbolContextList::operator*() const {
   assert(m_opaque_up.get());
   return *m_opaque_up;
 }
 
 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);
   return true;
 }

lldb/source/API/SBTarget.cpp

 //===-- SBTarget.cpp --------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
+#include "SBReproducerPrivate.h"
+
 #include "lldb/API/SBTarget.h"
 
 #include "lldb/lldb-public.h"
 
 #include "lldb/API/SBBreakpoint.h"
 #include "lldb/API/SBDebugger.h"
 #include "lldb/API/SBEvent.h"
 #include "lldb/API/SBExpressionOptions.h"
Status AttachToProcess(ProcessAttachInfo &attach_info, Target &target) {
   return target.Attach(attach_info, nullptr);
 }
 
 } // namespace
 
 //----------------------------------------------------------------------
 // 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;
 }
 
 //----------------------------------------------------------------------
 // Destructor
 //----------------------------------------------------------------------
 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) {
+  LLDB_RECORD_STATIC_METHOD(lldb::SBTarget, SBTarget, GetTargetFromEvent,
+                            (const lldb::SBEvent &), event);
+
   return Target::TargetEventData::GetTargetFromEvent(event.get());
 }
 
 uint32_t SBTarget::GetNumModulesFromEvent(const SBEvent &event) {
+  LLDB_RECORD_STATIC_METHOD(uint32_t, SBTarget, GetNumModulesFromEvent,
+                            (const lldb::SBEvent &), event);
+
   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));
 }
 
 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());
   if (target_sp) {
     process_sp = target_sp->GetProcessSP();
     sb_process.SetSP(process_sp);
   }
 
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   if (log)
     log->Printf("SBTarget(%p)::GetProcess () => SBProcess(%p)",
                 static_cast<void *>(target_sp.get()),
                 static_cast<void *>(process_sp.get()));
 
   return sb_process;
 }
 
 SBPlatform SBTarget::GetPlatform() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBPlatform, SBTarget, GetPlatform);
+
   TargetSP target_sp(GetSP());
   if (!target_sp)
     return SBPlatform();
 
   SBPlatform platform;
   platform.m_opaque_sp = target_sp->GetPlatform();
 
   return 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;
 }
 
 SBStructuredData SBTarget::GetStatistics() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBStructuredData, SBTarget, GetStatistics);
+
   SBStructuredData data;
   TargetSP target_sp(GetSP());
   if (!target_sp)
     return data;
 
   auto stats_up = llvm::make_unique<StructuredData::Dictionary>();
   int i = 0;
   for (auto &Entry : target_sp->GetStatistics()) {
     std::string Desc = lldb_private::GetStatDescription(
         static_cast<lldb_private::StatisticKind>(i));
     stats_up->AddIntegerItem(Desc, Entry);
     i += 1;
   }
 
   data.m_impl_up->SetObjectSP(std::move(stats_up));
   return data;
 }
 
 void SBTarget::SetCollectingStats(bool v) {
+  LLDB_RECORD_METHOD(void, SBTarget, SetCollectingStats, (bool), v);
+
   TargetSP target_sp(GetSP());
   if (!target_sp)
     return;
   return target_sp->SetCollectingStats(v);
 }
 
 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);
 }
 
 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) {
     FileSpec filespec(core_file);
     FileSystem::Instance().Resolve(filespec);
     ProcessSP process_sp(target_sp->CreateProcess(
         target_sp->GetDebugger().GetListener(), "", &filespec));
     if (process_sp) {
       error.SetError(process_sp->LoadCore());
       if (error.Success())
         sb_process.SetSP(process_sp);
     } else {
       error.SetErrorString("Failed to create the process");
     }
   } else {
     error.SetErrorString("SBTarget is invalid");
   }
   return sb_process;
 }
 
 SBProcess SBTarget::LaunchSimple(char const **argv, char const **envp,
                                  const char *working_directory) {
+  LLDB_RECORD_METHOD(lldb::SBProcess, SBTarget, LaunchSimple,
+                     (const char **, const char **, const char *), argv, envp,
+                     working_directory);
+
   char *stdin_path = NULL;
   char *stdout_path = NULL;
   char *stderr_path = NULL;
   uint32_t launch_flags = 0;
   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);
 }
 
 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;
 }
 
 SBProcess SBTarget::Launch(SBListener &listener, char const **argv,
                            char const **envp, const char *stdin_path,
                            const char *stdout_path, const char *stderr_path,
                            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;
   ProcessSP process_sp;
   TargetSP target_sp(GetSP());
 
   if (log)
     log->Printf("SBTarget(%p)::Launch (argv=%p, envp=%p, stdin=%s, stdout=%s, "
log->Printf("SBTarget(%p)::Launch (...) => SBProcess(%p), SBError(%s)",
                 static_cast<void *>(target_sp.get()),
                 static_cast<void *>(sb_process.GetSP().get()),
                 error.GetCString());
 
   return sb_process;
 }
 
 SBProcess SBTarget::Launch(SBLaunchInfo &sb_launch_info, SBError &error) {
+  LLDB_RECORD_METHOD(lldb::SBProcess, SBTarget, Launch,
+                     (lldb::SBLaunchInfo &, lldb::SBError &), sb_launch_info,
+                     error);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   SBProcess sb_process;
   TargetSP target_sp(GetSP());
 
   if (log)
     log->Printf("SBTarget(%p)::Launch (launch_info, error)...",
                 static_cast<void *>(target_sp.get()));
if (log)
     log->Printf("SBTarget(%p)::Launch (...) => SBProcess(%p)",
                 static_cast<void *>(target_sp.get()),
                 static_cast<void *>(sb_process.GetSP().get()));
 
   return sb_process;
 }
 
 lldb::SBProcess SBTarget::Attach(SBAttachInfo &sb_attach_info, SBError &error) {
+  LLDB_RECORD_METHOD(lldb::SBProcess, SBTarget, Attach,
+                     (lldb::SBAttachInfo &, lldb::SBError &), sb_attach_info,
+                     error);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   SBProcess sb_process;
   TargetSP target_sp(GetSP());
 
   if (log)
     log->Printf("SBTarget(%p)::Attach (sb_attach_info, error)...",
                 static_cast<void *>(target_sp.get()));
lldb::SBProcess SBTarget::Attach(SBAttachInfo &sb_attach_info, SBError &error) {
 
   return 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;
   TargetSP target_sp(GetSP());
 
   if (log)
     log->Printf("SBTarget(%p)::%s (listener, pid=%" PRId64 ", error)...",
                 static_cast<void *>(target_sp.get()), __FUNCTION__, pid);
) {
   return sb_process;
 }
 
 lldb::SBProcess SBTarget::AttachToProcessWithName(
     SBListener &listener,
     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;
   TargetSP target_sp(GetSP());
 
   if (log)
     log->Printf("SBTarget(%p)::%s (listener, name=%s, wait_for=%s, error)...",
                 static_cast<void *>(target_sp.get()), __FUNCTION__, name,
log->Printf("SBTarget(%p)::%s (...) => SBProcess(%p)",
                 static_cast<void *>(target_sp.get()), __FUNCTION__,
                 static_cast<void *>(sb_process.GetSP().get()));
   return sb_process;
 }
 
 lldb::SBProcess SBTarget::ConnectRemote(SBListener &listener, const char *url,
                                         const char *plugin_name,
                                         SBError &error) {
+  LLDB_RECORD_METHOD(
+      lldb::SBProcess, SBTarget, ConnectRemote,
+      (lldb::SBListener &, const char *, const char *, lldb::SBError &),
+      listener, url, plugin_name, error);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   SBProcess sb_process;
   ProcessSP process_sp;
   TargetSP target_sp(GetSP());
 
   if (log)
     log->Printf("SBTarget(%p)::ConnectRemote (listener, url=%s, "
lldb::SBProcess SBTarget::ConnectRemote(SBListener &listener, const char *url,
   if (log)
     log->Printf("SBTarget(%p)::ConnectRemote (...) => SBProcess(%p)",
                 static_cast<void *>(target_sp.get()),
                 static_cast<void *>(process_sp.get()));
   return sb_process;
 }
 
 SBFileSpec SBTarget::GetExecutable() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBFileSpec, SBTarget, GetExecutable);
 
   SBFileSpec exe_file_spec;
   TargetSP target_sp(GetSP());
   if (target_sp) {
     Module *exe_module = target_sp->GetExecutableModulePointer();
     if (exe_module)
       exe_file_spec.SetFileSpec(exe_module->GetFileSpec());
   }
 
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   if (log) {
     log->Printf("SBTarget(%p)::GetExecutable () => SBFileSpec(%p)",
                 static_cast<void *>(target_sp.get()),
                 static_cast<const void *>(exe_file_spec.get()));
   }
 
   return 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::TargetSP SBTarget::GetSP() const { return m_opaque_sp; }
 
 void SBTarget::SetSP(const lldb::TargetSP &target_sp) {
   m_opaque_sp = target_sp;
 }
 
 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;
   }
 
   // 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;
 }
 
 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;
   }
 
   addr.SetRawAddress(file_addr);
   return sb_addr;
 }
 
 lldb::SBAddress SBTarget::ResolvePastLoadAddress(uint32_t stop_id,
                                                  lldb::addr_t vm_addr) {
+  LLDB_RECORD_METHOD(lldb::SBAddress, SBTarget, ResolvePastLoadAddress,
+                     (uint32_t, lldb::addr_t), stop_id, vm_addr);
+
   lldb::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;
   }
 
   // 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;
 }
 
 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()) {
     TargetSP target_sp(GetSP());
     if (target_sp)
       target_sp->GetImages().ResolveSymbolContextForAddress(addr.ref(), scope,
                                                             sc.ref());
   }
if (target_sp) {
     sb_error.SetErrorString("invalid target");
   }
 
   return bytes_read;
 }
 
 SBBreakpoint SBTarget::BreakpointCreateByLocation(const char *file,
                                                   uint32_t line) {
+  LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByLocation,
+                     (const char *, uint32_t), file, line);
+
   return SBBreakpoint(
       BreakpointCreateByLocation(SBFileSpec(file, false), line));
 }
 
 SBBreakpoint
 SBTarget::BreakpointCreateByLocation(const SBFileSpec &sb_file_spec,
                                      uint32_t line) {
+  LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByLocation,
+                     (const lldb::SBFileSpec &, uint32_t), sb_file_spec, line);
+
   return BreakpointCreateByLocation(sb_file_spec, line, 0);
 }
 
 SBBreakpoint
 SBTarget::BreakpointCreateByLocation(const SBFileSpec &sb_file_spec,
                                      uint32_t line, lldb::addr_t offset) {
+  LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByLocation,
+                     (const lldb::SBFileSpec &, uint32_t, lldb::addr_t),
+                     sb_file_spec, line, offset);
+
   SBFileSpecList empty_list;
   return BreakpointCreateByLocation(sb_file_spec, line, offset, empty_list);
 }
 
 SBBreakpoint
 SBTarget::BreakpointCreateByLocation(const SBFileSpec &sb_file_spec,
                                      uint32_t line, lldb::addr_t offset,
                                      SBFileSpecList &sb_module_list) {
+  LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByLocation,
+                     (const lldb::SBFileSpec &, uint32_t, lldb::addr_t,
+                      lldb::SBFileSpecList &),
+                     sb_file_spec, line, offset, sb_module_list);
+
   return BreakpointCreateByLocation(sb_file_spec, line, 0, offset,
                                     sb_module_list);
 }
 
 SBBreakpoint SBTarget::BreakpointCreateByLocation(
     const SBFileSpec &sb_file_spec, uint32_t line, uint32_t column,
     lldb::addr_t offset, SBFileSpecList &sb_module_list) {
+  LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByLocation,
+                     (const lldb::SBFileSpec &, uint32_t, uint32_t,
+                      lldb::addr_t, lldb::SBFileSpecList &),
+                     sb_file_spec, line, column, offset, sb_module_list);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   SBBreakpoint sb_bp;
   TargetSP target_sp(GetSP());
   if (target_sp && line != 0) {
     std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
 
     const LazyBool check_inlines = eLazyBoolCalculate;
log->Printf("SBTarget(%p)::BreakpointCreateByLocation ( %s:%u ) => "
                 static_cast<void *>(sb_bp.GetSP().get()), sstr.GetData());
   }
 
   return sb_bp;
 }
 
 SBBreakpoint SBTarget::BreakpointCreateByName(const char *symbol_name,
                                               const char *module_name) {
+  LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByName,
+                     (const char *, const char *), symbol_name, module_name);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   SBBreakpoint sb_bp;
   TargetSP target_sp(GetSP());
   if (target_sp.get()) {
     std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
 
     const bool internal = false;
SBBreakpoint SBTarget::BreakpointCreateByName(const char *symbol_name,
 
   return sb_bp;
 }
 
 lldb::SBBreakpoint
 SBTarget::BreakpointCreateByName(const char *symbol_name,
                                  const SBFileSpecList &module_list,
                                  const SBFileSpecList &comp_unit_list) {
+  LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByName,
+                     (const char *, const lldb::SBFileSpecList &,
+                      const lldb::SBFileSpecList &),
+                     symbol_name, module_list, comp_unit_list);
+
   lldb::FunctionNameType name_type_mask = eFunctionNameTypeAuto;
   return BreakpointCreateByName(symbol_name, name_type_mask,
                                 eLanguageTypeUnknown, module_list,
                                 comp_unit_list);
 }
 
 lldb::SBBreakpoint SBTarget::BreakpointCreateByName(
     const char *symbol_name, uint32_t name_type_mask,
     const SBFileSpecList &module_list, const SBFileSpecList &comp_unit_list) {
+  LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByName,
+                     (const char *, uint32_t, const lldb::SBFileSpecList &,
+                      const lldb::SBFileSpecList &),
+                     symbol_name, name_type_mask, module_list, comp_unit_list);
+
   return BreakpointCreateByName(symbol_name, name_type_mask,
                                 eLanguageTypeUnknown, module_list,
                                 comp_unit_list);
 }
 
 lldb::SBBreakpoint SBTarget::BreakpointCreateByName(
     const char *symbol_name, uint32_t name_type_mask,
     LanguageType symbol_language, const SBFileSpecList &module_list,
     const SBFileSpecList &comp_unit_list) {
+  LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByName,
+                     (const char *, uint32_t, lldb::LanguageType,
+                      const lldb::SBFileSpecList &,
+                      const lldb::SBFileSpecList &),
+                     symbol_name, name_type_mask, symbol_language, module_list,
+                     comp_unit_list);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   SBBreakpoint sb_bp;
   TargetSP target_sp(GetSP());
   if (target_sp && symbol_name && symbol_name[0]) {
     const bool internal = false;
     const bool hardware = false;
     const LazyBool skip_prologue = eLazyBoolCalculate;
log->Printf("SBTarget(%p)::BreakpointCreateByName (symbol=\"%s\", "
                 name_type_mask, static_cast<void *>(sb_bp.GetSP().get()));
 
   return sb_bp;
 }
 
 lldb::SBBreakpoint SBTarget::BreakpointCreateByNames(
     const char *symbol_names[], uint32_t num_names, uint32_t name_type_mask,
     const SBFileSpecList &module_list, const SBFileSpecList &comp_unit_list) {
+  LLDB_RECORD_METHOD(
+      lldb::SBBreakpoint, SBTarget, BreakpointCreateByNames,
+      (const char **, uint32_t, uint32_t, const lldb::SBFileSpecList &,
+       const lldb::SBFileSpecList &),
+      symbol_names, num_names, name_type_mask, module_list, comp_unit_list);
+
   return BreakpointCreateByNames(symbol_names, num_names, name_type_mask,
                                  eLanguageTypeUnknown, module_list,
                                  comp_unit_list);
 }
 
 lldb::SBBreakpoint SBTarget::BreakpointCreateByNames(
     const char *symbol_names[], uint32_t num_names, uint32_t name_type_mask,
     LanguageType symbol_language, const SBFileSpecList &module_list,
     const SBFileSpecList &comp_unit_list) {
+  LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByNames,
+                     (const char **, uint32_t, uint32_t, lldb::LanguageType,
+                      const lldb::SBFileSpecList &,
+                      const lldb::SBFileSpecList &),
+                     symbol_names, num_names, name_type_mask, symbol_language,
+                     module_list, comp_unit_list);
+
   return BreakpointCreateByNames(symbol_names, num_names, name_type_mask,
                                  eLanguageTypeUnknown, 0, module_list,
                                  comp_unit_list);
 }
 
 lldb::SBBreakpoint SBTarget::BreakpointCreateByNames(
     const char *symbol_names[], uint32_t num_names, uint32_t name_type_mask,
     LanguageType symbol_language, lldb::addr_t offset,
     const SBFileSpecList &module_list, const SBFileSpecList &comp_unit_list) {
+  LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByNames,
+                     (const char **, uint32_t, uint32_t, lldb::LanguageType,
+                      lldb::addr_t, const lldb::SBFileSpecList &,
+                      const lldb::SBFileSpecList &),
+                     symbol_names, num_names, name_type_mask, symbol_language,
+                     offset, module_list, comp_unit_list);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   SBBreakpoint sb_bp;
   TargetSP target_sp(GetSP());
   if (target_sp && num_names > 0) {
     std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
     const bool internal = false;
     const bool hardware = false;
log->Printf("name_type: %d) => SBBreakpoint(%p)", name_type_mask,
                 static_cast<void *>(sb_bp.GetSP().get()));
   }
 
   return sb_bp;
 }
 
 SBBreakpoint SBTarget::BreakpointCreateByRegex(const char *symbol_name_regex,
                                                const char *module_name) {
+  LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByRegex,
+                     (const char *, const char *), symbol_name_regex,
+                     module_name);
+
   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);
 }
 
 lldb::SBBreakpoint
 SBTarget::BreakpointCreateByRegex(const char *symbol_name_regex,
                                   const SBFileSpecList &module_list,
                                   const SBFileSpecList &comp_unit_list) {
+  LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByRegex,
+                     (const char *, const lldb::SBFileSpecList &,
+                      const lldb::SBFileSpecList &),
+                     symbol_name_regex, module_list, comp_unit_list);
+
   return BreakpointCreateByRegex(symbol_name_regex, eLanguageTypeUnknown,
                                  module_list, comp_unit_list);
 }
 
 lldb::SBBreakpoint SBTarget::BreakpointCreateByRegex(
     const char *symbol_name_regex, LanguageType symbol_language,
     const SBFileSpecList &module_list, const SBFileSpecList &comp_unit_list) {
+  LLDB_RECORD_METHOD(
+      lldb::SBBreakpoint, SBTarget, BreakpointCreateByRegex,
+      (const char *, lldb::LanguageType, const lldb::SBFileSpecList &,
+       const lldb::SBFileSpecList &),
+      symbol_name_regex, symbol_language, module_list, comp_unit_list);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   SBBreakpoint sb_bp;
   TargetSP target_sp(GetSP());
   if (target_sp && symbol_name_regex && symbol_name_regex[0]) {
     std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
     RegularExpression regexp((llvm::StringRef(symbol_name_regex)));
     const bool internal = false;
log->Printf("SBTarget(%p)::BreakpointCreateByRegex (symbol_regex=\"%s\") "
                 "=> SBBreakpoint(%p)",
                 static_cast<void *>(target_sp.get()), symbol_name_regex,
                 static_cast<void *>(sb_bp.GetSP().get()));
 
   return 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;
   TargetSP target_sp(GetSP());
   if (target_sp) {
     std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
     const bool hardware = false;
     sb_bp = target_sp->CreateBreakpoint(address, false, hardware);
   }
 
   if (log)
     log->Printf("SBTarget(%p)::BreakpointCreateByAddress (address=%" PRIu64
                 ") => SBBreakpoint(%p)",
                 static_cast<void *>(target_sp.get()),
                 static_cast<uint64_t>(address),
                 static_cast<void *>(sb_bp.GetSP().get()));
 
   return 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;
   TargetSP target_sp(GetSP());
   if (!sb_address.IsValid()) {
     if (log)
       log->Printf("SBTarget(%p)::BreakpointCreateBySBAddress called with "
                   "invalid address",
SBBreakpoint SBTarget::BreakpointCreateBySBAddress(SBAddress &sb_address) {
 
   return sb_bp;
 }
 
 lldb::SBBreakpoint
 SBTarget::BreakpointCreateBySourceRegex(const char *source_regex,
                                         const lldb::SBFileSpec &source_file,
                                         const char *module_name) {
+  LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget,
+                     BreakpointCreateBySourceRegex,
+                     (const char *, const lldb::SBFileSpec &, const char *),
+                     source_regex, source_file, module_name);
+
   SBFileSpecList module_spec_list;
 
   if (module_name && module_name[0]) {
     module_spec_list.Append(FileSpec(module_name));
   }
 
   SBFileSpecList source_file_list;
   if (source_file.IsValid()) {
     source_file_list.Append(source_file);
   }
 
   return BreakpointCreateBySourceRegex(source_regex, module_spec_list,
                                        source_file_list);
 }
 
 lldb::SBBreakpoint SBTarget::BreakpointCreateBySourceRegex(
     const char *source_regex, const SBFileSpecList &module_list,
     const lldb::SBFileSpecList &source_file_list) {
+  LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget,
+                     BreakpointCreateBySourceRegex,
+                     (const char *, const lldb::SBFileSpecList &,
+                      const lldb::SBFileSpecList &),
+                     source_regex, module_list, source_file_list);
+
   return BreakpointCreateBySourceRegex(source_regex, module_list,
                                        source_file_list, SBStringList());
 }
 
 lldb::SBBreakpoint SBTarget::BreakpointCreateBySourceRegex(
     const char *source_regex, const SBFileSpecList &module_list,
     const lldb::SBFileSpecList &source_file_list,
     const SBStringList &func_names) {
+  LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget,
+                     BreakpointCreateBySourceRegex,
+                     (const char *, const lldb::SBFileSpecList &,
+                      const lldb::SBFileSpecList &, const lldb::SBStringList &),
+                     source_regex, module_list, source_file_list, func_names);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   SBBreakpoint sb_bp;
   TargetSP target_sp(GetSP());
   if (target_sp && source_regex && source_regex[0]) {
     std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
     const bool hardware = false;
     const LazyBool move_to_nearest_code = eLazyBoolCalculate;
log->Printf("SBTarget(%p)::BreakpointCreateByRegex (source_regex=\"%s\") "
                 static_cast<void *>(sb_bp.GetSP().get()));
 
   return sb_bp;
 }
 
 lldb::SBBreakpoint
 SBTarget::BreakpointCreateForException(lldb::LanguageType language,
                                        bool catch_bp, bool throw_bp) {
+  LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateForException,
+                     (lldb::LanguageType, bool, bool), language, catch_bp,
+                     throw_bp);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   SBBreakpoint sb_bp;
   TargetSP target_sp(GetSP());
   if (target_sp) {
     std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
     const bool hardware = false;
     sb_bp = target_sp->CreateExceptionBreakpoint(language, catch_bp, throw_bp,
                                                   hardware);
   }
 
   if (log)
     log->Printf("SBTarget(%p)::BreakpointCreateForException (Language: %s, catch: "
                 "%s throw: %s) => SBBreakpoint(%p)",
                 static_cast<void *>(target_sp.get()),
                 Language::GetNameForLanguageType(language),
                 catch_bp ? "on" : "off", throw_bp ? "on" : "off",
                 static_cast<void *>(sb_bp.GetSP().get()));
 
   return sb_bp;
 }
 
-lldb::SBBreakpoint
-SBTarget::BreakpointCreateFromScript(const char *class_name,
-                                     SBStructuredData &extra_args,
-                                     const SBFileSpecList &module_list,
-                                     const SBFileSpecList &file_list,
-                                     bool request_hardware)
-{
+lldb::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;
   TargetSP target_sp(GetSP());
   if (target_sp) {
     std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
     Status error;
     
log->Printf("SBTarget(%p)::BreakpointCreateFromScript (class name: %s) "
                 " => SBBreakpoint(%p)",
                 static_cast<void *>(target_sp.get()),
                 class_name,
                 static_cast<void *>(sb_bp.GetSP().get()));
 
   return 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
     return target_sp->GetBreakpointList().GetSize();
   }
   return 0;
 }
 
 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;
 }
 
 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;
   TargetSP target_sp(GetSP());
   if (target_sp) {
     std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
     result = target_sp->RemoveBreakpointByID(bp_id);
   }
 
   if (log)
     log->Printf("SBTarget(%p)::BreakpointDelete (bp_id=%d) => %i",
                 static_cast<void *>(target_sp.get()),
                 static_cast<uint32_t>(bp_id), result);
 
   return result;
 }
 
 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;
   TargetSP target_sp(GetSP());
   if (target_sp && bp_id != LLDB_INVALID_BREAK_ID) {
     std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
     sb_breakpoint = target_sp->GetBreakpointByID(bp_id);
   }
 
   if (log)
     log->Printf(
         "SBTarget(%p)::FindBreakpointByID (bp_id=%d) => SBBreakpoint(%p)",
         static_cast<void *>(target_sp.get()), static_cast<uint32_t>(bp_id),
         static_cast<void *>(sb_breakpoint.GetSP().get()));
 
   return 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());
     BreakpointList bkpt_list(false);
     bool is_valid =
         target_sp->GetBreakpointList().FindBreakpointsByName(name, bkpt_list);
     if (!is_valid)
       return false;
     for (BreakpointSP bkpt_sp : bkpt_list.Breakpoints()) {
       bkpts.AppendByID(bkpt_sp->GetID());
     }
   }
   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());
   if (target_sp) {
     std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
 
     std::vector<std::string> name_vec;
     target_sp->GetBreakpointNames(name_vec);
     for (auto name : name_vec)
       names.AppendString(name.c_str());
   }
 }
 
-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());
     target_sp->DeleteBreakpointName(ConstString(name));
   }
 }
 
 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());
     target_sp->EnableAllowedBreakpoints();
     return true;
   }
   return false;
 }
 
 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());
     target_sp->DisableAllowedBreakpoints();
     return true;
   }
   return false;
 }
 
 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());
     target_sp->RemoveAllowedBreakpoints();
     return true;
   }
   return false;
 }
 
 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);
 }
 
 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;
   }
   std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
lldb::SBError SBTarget::BreakpointsCreateFromFile(SBFileSpec &source_file,
   for (size_t i = 0; i < num_bkpts; i++) {
     BreakpointID bp_id = bp_ids.GetBreakpointIDAtIndex(i);
     new_bps.AppendByID(bp_id.GetBreakpointID());
   }
   return 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;
   }
   SBBreakpointList bkpt_list(*this);
   return BreakpointsWriteToFile(dest_file, bkpt_list);
 }
 
 lldb::SBError SBTarget::BreakpointsWriteToFile(SBFileSpec &dest_file,
                                                SBBreakpointList &bkpt_list,
                                                bool append) {
+  LLDB_RECORD_METHOD(lldb::SBError, SBTarget, BreakpointsWriteToFile,
+                     (lldb::SBFileSpec &, lldb::SBBreakpointList &, bool),
+                     dest_file, bkpt_list, append);
+
   SBError sberr;
   TargetSP target_sp(GetSP());
   if (!target_sp) {
     sberr.SetErrorString("BreakpointWriteToFile called with invalid target.");
     return sberr;
   }
 
   std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
   BreakpointIDList bp_id_list;
   bkpt_list.CopyToBreakpointIDList(bp_id_list);
   sberr.ref() = target_sp->SerializeBreakpointsToFile(dest_file.ref(),
                                                       bp_id_list, append);
   return 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
     return target_sp->GetWatchpointList().GetSize();
   }
   return 0;
 }
 
 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;
 }
 
 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;
   TargetSP target_sp(GetSP());
   if (target_sp) {
     std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
     std::unique_lock<std::recursive_mutex> lock;
     target_sp->GetWatchpointList().GetListMutex(lock);
     result = target_sp->RemoveWatchpointByID(wp_id);
   }
 
   if (log)
     log->Printf("SBTarget(%p)::WatchpointDelete (wp_id=%d) => %i",
                 static_cast<void *>(target_sp.get()),
                 static_cast<uint32_t>(wp_id), result);
 
   return result;
 }
 
 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;
   lldb::WatchpointSP watchpoint_sp;
   TargetSP target_sp(GetSP());
   if (target_sp && wp_id != LLDB_INVALID_WATCH_ID) {
     std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
     std::unique_lock<std::recursive_mutex> lock;
log->Printf(
         static_cast<void *>(watchpoint_sp.get()));
 
   return sb_watchpoint;
 }
 
 lldb::SBWatchpoint SBTarget::WatchAddress(lldb::addr_t addr, size_t size,
                                           bool read, bool write,
                                           SBError &error) {
+  LLDB_RECORD_METHOD(lldb::SBWatchpoint, SBTarget, WatchAddress,
+                     (lldb::addr_t, size_t, bool, bool, lldb::SBError &), addr,
+                     size, read, write, error);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   SBWatchpoint sb_watchpoint;
   lldb::WatchpointSP watchpoint_sp;
   TargetSP target_sp(GetSP());
   if (target_sp && (read || write) && addr != LLDB_INVALID_ADDRESS &&
       size > 0) {
     std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
log->Printf("SBTarget(%p)::WatchAddress (addr=0x%" PRIx64
                 static_cast<void *>(target_sp.get()), addr,
                 static_cast<uint32_t>(size),
                 static_cast<void *>(watchpoint_sp.get()));
 
   return 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());
     std::unique_lock<std::recursive_mutex> lock;
     target_sp->GetWatchpointList().GetListMutex(lock);
     target_sp->EnableAllWatchpoints();
     return true;
   }
   return false;
 }
 
 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());
     std::unique_lock<std::recursive_mutex> lock;
     target_sp->GetWatchpointList().GetListMutex(lock);
     target_sp->DisableAllWatchpoints();
     return true;
   }
   return false;
 }
 
 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()) {
     lldb::addr_t load_addr(addr.GetLoadAddress(*this));
     ExecutionContext exe_ctx(
         ExecutionContextRef(ExecutionContext(m_opaque_sp.get(), false)));
     CompilerType ast_type(type.GetSP()->GetCompilerType(true));
     new_value_sp = ValueObject::CreateValueObjectFromAddress(name, load_addr,
else
       log->Printf("SBTarget(%p)::CreateValueFromAddress => NULL",
                   static_cast<void *>(m_opaque_sp.get()));
   }
   return sb_value;
 }
 
 lldb::SBValue SBTarget::CreateValueFromData(const char *name, lldb::SBData data,
                                             lldb::SBType type) {
+  LLDB_RECORD_METHOD(lldb::SBValue, SBTarget, CreateValueFromData,
+                     (const char *, lldb::SBData, lldb::SBType), name, data,
+                     type);
+
   SBValue sb_value;
   lldb::ValueObjectSP new_value_sp;
   if (IsValid() && name && *name && data.IsValid() && type.IsValid()) {
     DataExtractorSP extractor(*data);
     ExecutionContext exe_ctx(
         ExecutionContextRef(ExecutionContext(m_opaque_sp.get(), false)));
     CompilerType ast_type(type.GetSP()->GetCompilerType(true));
     new_value_sp = ValueObject::CreateValueObjectFromData(name, *extractor,
else
       log->Printf("SBTarget(%p)::CreateValueFromData => NULL",
                   static_cast<void *>(m_opaque_sp.get()));
   }
   return sb_value;
 }
 
 lldb::SBValue SBTarget::CreateValueFromExpression(const char *name,
                                                   const char *expr) {
+  LLDB_RECORD_METHOD(lldb::SBValue, SBTarget, CreateValueFromExpression,
+                     (const char *, const char *), name, expr);
+
   SBValue sb_value;
   lldb::ValueObjectSP new_value_sp;
   if (IsValid() && name && *name && expr && *expr) {
     ExecutionContext exe_ctx(
         ExecutionContextRef(ExecutionContext(m_opaque_sp.get(), false)));
     new_value_sp =
         ValueObject::CreateValueObjectFromExpression(name, expr, exe_ctx);
   }
   sb_value.SetSP(new_value_sp);
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   if (log) {
     if (new_value_sp)
       log->Printf("SBTarget(%p)::CreateValueFromExpression => \"%s\"",
                   static_cast<void *>(m_opaque_sp.get()),
                   new_value_sp->GetName().AsCString());
     else
       log->Printf("SBTarget(%p)::CreateValueFromExpression => NULL",
                   static_cast<void *>(m_opaque_sp.get()));
   }
   return 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());
     std::unique_lock<std::recursive_mutex> lock;
     target_sp->GetWatchpointList().GetListMutex(lock);
     target_sp->RemoveAllWatchpoints();
     return true;
   }
   return false;
 }
 
 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");
 
   const ConstString csFrom(from), csTo(to);
   if (!csFrom)
     return error.SetErrorString("<from> path can't be empty");
   if (!csTo)
     return error.SetErrorString("<to> path can't be empty");
 
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   if (log)
     log->Printf("SBTarget(%p)::%s: '%s' -> '%s'",
                 static_cast<void *>(target_sp.get()),  __FUNCTION__,
                 from, to);
   target_sp->GetImageSearchPathList().Append(csFrom, csTo, true);
 }
 
 lldb::SBModule SBTarget::AddModule(const char *path, const char *triple,
                                    const char *uuid_cstr) {
+  LLDB_RECORD_METHOD(lldb::SBModule, SBTarget, AddModule,
+                     (const char *, const char *, const char *), path, triple,
+                     uuid_cstr);
+
   return 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) {
     ModuleSpec module_spec;
     if (path)
       module_spec.GetFileSpec().SetFile(path, FileSpec::Style::native);
 
     if (uuid_cstr)
if (symfile)
       module_spec.GetSymbolFileSpec().SetFile(symfile, FileSpec::Style::native);
 
     sb_module.SetSP(target_sp->GetSharedModule(module_spec));
   }
   return 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;
 }
 
 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());
     return true;
   }
   return false;
 }
 
 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;
   TargetSP target_sp(GetSP());
   if (target_sp) {
     // The module list is thread safe, no need to lock
     num = target_sp->GetImages().GetSize();
   }
 
   if (log)
     log->Printf("SBTarget(%p)::GetNumModules () => %d",
                 static_cast<void *>(target_sp.get()), num);
 
   return num;
 }
 
 void SBTarget::Clear() {
+  LLDB_RECORD_METHOD_NO_ARGS(void, SBTarget, Clear);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   if (log)
     log->Printf("SBTarget(%p)::Clear ()",
                 static_cast<void *>(m_opaque_sp.get()));
 
   m_opaque_sp.reset();
 }
 
 SBModule SBTarget::FindModule(const SBFileSpec &sb_file_spec) {
+  LLDB_RECORD_METHOD(lldb::SBModule, SBTarget, FindModule,
+                     (const lldb::SBFileSpec &), sb_file_spec);
+
   SBModule sb_module;
   TargetSP target_sp(GetSP());
   if (target_sp && sb_file_spec.IsValid()) {
     ModuleSpec module_spec(*sb_file_spec);
     // The module list is thread safe, no need to lock
     sb_module.SetSP(target_sp->GetImages().FindFirstModule(module_spec));
   }
   return 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()) {
     const bool append = true;
     target_sp->GetImages().FindCompileUnits(*sb_file_spec,
                                             append, *sb_sc_list);
   }
   return 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();
   return eByteOrderInvalid;
 }
 
 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());
     // 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
     // comes out
     ConstString const_triple(triple.c_str());
     return const_triple.GetCString();
   }
   return NULL;
 }
 
 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();
   }
   return 0;
 }
 
 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();
   }
   return 0;
 }
 
 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();
   return sizeof(void *);
 }
 
 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;
   ModuleSP module_sp;
   TargetSP target_sp(GetSP());
   if (target_sp) {
     // The module list is thread safe, no need to lock
     module_sp = target_sp->GetImages().GetModuleAtIndex(idx);
     sb_module.SetSP(module_sp);
   }
 
   if (log)
     log->Printf("SBTarget(%p)::GetModuleAtIndex (idx=%d) => SBModule(%p)",
                 static_cast<void *>(target_sp.get()), idx,
                 static_cast<void *>(module_sp.get()));
 
   return 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());
   return false;
 }
 
 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());
   SBBroadcaster broadcaster(target_sp.get(), false);
 
   if (log)
     log->Printf("SBTarget(%p)::GetBroadcaster () => SBBroadcaster(%p)",
                 static_cast<void *>(target_sp.get()),
                 static_cast<void *>(broadcaster.get()));
 
   return 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());
   if (target_sp) {
     target_sp->Dump(&strm, description_level);
   } else
     strm.PutCString("No value");
 
   return true;
 }
 
 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;
 
   TargetSP target_sp(GetSP());
   if (!target_sp)
     return sb_sc_list;
 
   const bool symbols_ok = true;
   const bool inlines_ok = true;
   const bool append = 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;
 }
 
 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);
     TargetSP target_sp(GetSP());
     if (target_sp) {
       std::string regexstr;
       switch (matchtype) {
       case eMatchTypeRegex:
if (target_sp) {
         break;
       }
     }
   }
   return 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);
     SymbolContext sc;
     const bool exact_match = false;
 
     const ModuleList &module_list = target_sp->GetImages();
     size_t count = module_list.GetSize();
if (typename_cstr && typename_cstr[0] && target_sp) {
     if (clang_ast)
       return SBType(ClangASTContext::GetBasicType(clang_ast->getASTContext(),
                                                   const_typename));
   }
   return 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 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) {
     ModuleList &images = target_sp->GetImages();
     ConstString const_typename(typename_cstr);
     bool exact_match = false;
     TypeList type_list;
     llvm::DenseSet<SymbolFile *> searched_symbol_files;
if (sb_type_list.GetSize() == 0) {
             clang_ast->getASTContext(), const_typename)));
     }
   }
   return sb_type_list;
 }
 
 SBValueList SBTarget::FindGlobalVariables(const char *name,
                                           uint32_t max_matches) {
+  LLDB_RECORD_METHOD(lldb::SBValueList, SBTarget, FindGlobalVariables,
+                     (const char *, uint32_t), name, max_matches);
+
   SBValueList sb_value_list;
 
   TargetSP target_sp(GetSP());
   if (name && target_sp) {
     VariableList variable_list;
     const uint32_t match_count = target_sp->GetImages().FindGlobalVariables(
         ConstString(name), max_matches, variable_list);
 
SBValueList SBTarget::FindGlobalVariables(const char *name,
   }
 
   return sb_value_list;
 }
 
 SBValueList SBTarget::FindGlobalVariables(const char *name,
                                           uint32_t max_matches,
                                           MatchType matchtype) {
+  LLDB_RECORD_METHOD(lldb::SBValueList, SBTarget, FindGlobalVariables,
+                     (const char *, uint32_t, lldb::MatchType), name,
+                     max_matches, matchtype);
+
   SBValueList sb_value_list;
 
   TargetSP target_sp(GetSP());
   if (name && target_sp) {
     llvm::StringRef name_ref(name);
     VariableList variable_list;
 
     std::string regexstr;
if (match_count > 0) {
       }
     }
   }
 
   return 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();
 }
 
 SBSourceManager SBTarget::GetSourceManager() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBSourceManager, SBTarget, GetSourceManager);
+
   SBSourceManager source_manager(*this);
   return source_manager;
 }
 
 lldb::SBInstructionList SBTarget::ReadInstructions(lldb::SBAddress base_addr,
                                                    uint32_t count) {
+  LLDB_RECORD_METHOD(lldb::SBInstructionList, SBTarget, ReadInstructions,
+                     (lldb::SBAddress, uint32_t), base_addr, count);
+
   return 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());
   if (target_sp) {
     Address *addr_ptr = base_addr.get();
 
     if (addr_ptr) {
       DataBufferHeap data(
SBTarget::GetInstructionsWithFlavor(lldb::addr_t base_addr,
                                     const char *flavor_string, const void *buf,
                                     size_t size) {
   return GetInstructionsWithFlavor(ResolveLoadAddress(base_addr), flavor_string,
                                    buf, size);
 }
 
 SBError SBTarget::SetSectionLoadAddress(lldb::SBSection section,
                                         lldb::addr_t section_base_addr) {
+  LLDB_RECORD_METHOD(lldb::SBError, SBTarget, SetSectionLoadAddress,
+                     (lldb::SBSection, lldb::addr_t), section,
+                     section_base_addr);
+
   SBError sb_error;
   TargetSP target_sp(GetSP());
   if (target_sp) {
     if (!section.IsValid()) {
       sb_error.SetErrorStringWithFormat("invalid section");
     } else {
       SectionSP section_sp(section.GetSP());
       if (section_sp) {
if (target_sp) {
     }
   } else {
     sb_error.SetErrorString("invalid target");
   }
   return 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());
   if (target_sp) {
     if (!section.IsValid()) {
       sb_error.SetErrorStringWithFormat("invalid section");
     } else {
       SectionSP section_sp(section.GetSP());
SBError SBTarget::ClearSectionLoadAddress(lldb::SBSection section) {
   } else {
     sb_error.SetErrorStringWithFormat("invalid target");
   }
   return sb_error;
 }
 
 SBError SBTarget::SetModuleLoadAddress(lldb::SBModule module,
                                        int64_t slide_offset) {
+  LLDB_RECORD_METHOD(lldb::SBError, SBTarget, SetModuleLoadAddress,
+                     (lldb::SBModule, int64_t), module, slide_offset);
+
   SBError sb_error;
 
   TargetSP target_sp(GetSP());
   if (target_sp) {
     ModuleSP module_sp(module.GetSP());
     if (module_sp) {
       bool changed = false;
       if (module_sp->SetLoadAddress(*target_sp, slide_offset, true, changed)) {
SBError SBTarget::SetModuleLoadAddress(lldb::SBModule module,
 
   } else {
     sb_error.SetErrorStringWithFormat("invalid target");
   }
   return 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];
   TargetSP target_sp(GetSP());
   if (target_sp) {
     ModuleSP module_sp(module.GetSP());
     if (module_sp) {
       ObjectFile *objfile = module_sp->GetObjectFile();
SBError SBTarget::ClearModuleLoadAddress(lldb::SBModule module) {
   } else {
     sb_error.SetErrorStringWithFormat("invalid target");
   }
   return sb_error;
 }
 
 lldb::SBSymbolContextList SBTarget::FindSymbols(const char *name,
                                                 lldb::SymbolType symbol_type) {
+  LLDB_RECORD_METHOD(lldb::SBSymbolContextList, SBTarget, FindSymbols,
+                     (const char *, lldb::SymbolType), name, symbol_type);
+
   SBSymbolContextList sb_sc_list;
   if (name && name[0]) {
     TargetSP target_sp(GetSP());
     if (target_sp) {
       bool append = true;
       target_sp->GetImages().FindSymbolsWithNameAndType(
           ConstString(name), symbol_type, *sb_sc_list, append);
     }
   }
   return 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();
 
   SBExpressionOptions options;
   lldb::DynamicValueType fetch_dynamic_value =
       target_sp->GetPreferDynamicValue();
   options.SetFetchDynamicValue(fetch_dynamic_value);
   options.SetUnwindOnError(true);
   return EvaluateExpression(expr, options);
 }
 
 lldb::SBValue SBTarget::EvaluateExpression(const char *expr,
                                            const SBExpressionOptions &options) {
+  LLDB_RECORD_METHOD(lldb::SBValue, SBTarget, EvaluateExpression,
+                     (const char *, const lldb::SBExpressionOptions &), expr,
+                     options);
+
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 #if !defined(LLDB_DISABLE_PYTHON)
   Log *expr_log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
 #endif
   SBValue expr_result;
   ExpressionResults exe_results = eExpressionSetupError;
   ValueObjectSP expr_value_sp;
   TargetSP target_sp(GetSP());
log->Printf("SBTarget(%p)::EvaluateExpression (expr=\"%s\") => SBValue(%p) "
                 static_cast<void *>(frame), expr,
                 static_cast<void *>(expr_value_sp.get()), exe_results);
 #endif
 
   return 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;
     ProcessSP process_sp(target_sp->GetProcessSP());
     if (process_sp)
       abi_sp = process_sp->GetABI();
     else
       abi_sp = ABI::FindPlugin(ProcessSP(), target_sp->GetArchitecture());
     if (abi_sp)
       return abi_sp->GetRedZoneSize();
   }
   return 0;
 }
 
 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;
 }
 
 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

 //===-- SBThread.cpp --------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
+#include "SBReproducerPrivate.h"
+
 #include "lldb/API/SBThread.h"
 
 #include "lldb/API/SBFileSpec.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/API/SBSymbolContext.h"
 #include "lldb/Breakpoint/BreakpointLocation.h"
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/StreamFile.h"

 #include "lldb/lldb-enumerations.h"
 
 #include <memory>
 
 using namespace lldb;
 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;
 }
 
 //----------------------------------------------------------------------
 // Destructor
 //----------------------------------------------------------------------
 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;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   if (exe_ctx.HasThreadScope()) {
     Process::StopLocker stop_locker;
if (log)
     log->Printf("SBThread(%p)::GetQueue () => SBQueue(%p)",
                 static_cast<void *>(exe_ctx.GetThreadPtr()),
                 static_cast<void *>(queue_sp.get()));
 
   return 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);
 
   Target *target = exe_ctx.GetTargetPtr();
   Process *process = exe_ctx.GetProcessPtr();
   if (target && process) {
     Process::StopLocker stop_locker;
     if (stop_locker.TryLock(&process->GetRunLock()))
       return m_opaque_sp->GetThreadSP().get() != NULL;
   }
   // Without a valid target & process, this thread can't be valid.
   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;
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
   if (exe_ctx.HasThreadScope()) {
     Process::StopLocker stop_locker;
if (log)
     log->Printf("SBThread(%p)::GetStopReason () => %s",
                 static_cast<void *>(exe_ctx.GetThreadPtr()),
                 Thread::StopReasonAsCString(reason));
 
   return reason;
 }
 
 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);
 
   if (exe_ctx.HasThreadScope()) {
     Process::StopLocker stop_locker;
     if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock())) {
       StopInfoSP stop_info_sp = exe_ctx.GetThreadPtr()->GetStopInfo();
       if (stop_info_sp) {
if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock())) {
                     "is running",
                     static_cast<void *>(exe_ctx.GetThreadPtr()));
     }
   }
   return 0;
 }
 
 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);
 
   if (exe_ctx.HasThreadScope()) {
     Process::StopLocker stop_locker;
     if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock())) {
       Thread *thread = exe_ctx.GetThreadPtr();
       StopInfoSP stop_info_sp = thread->GetStopInfo();
if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock())) {
                     "process is running",
                     static_cast<void *>(exe_ctx.GetThreadPtr()));
     }
   }
   return 0;
 }
 
 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;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
   if (!exe_ctx.HasThreadScope())
     return false;
 
   StopInfoSP stop_info = exe_ctx.GetThreadPtr()->GetStopInfo();
   StructuredData::ObjectSP info = stop_info->GetExtendedInfo();
   if (!info)
     return false;
 
   info->Dump(strm);
 
   return true;
 }
 
 SBThreadCollection
 SBThread::GetStopReasonExtendedBacktraces(InstrumentationRuntimeType type) {
+  LLDB_RECORD_METHOD(lldb::SBThreadCollection, SBThread,
+                     GetStopReasonExtendedBacktraces,
+                     (lldb::InstrumentationRuntimeType), type);
+
   ThreadCollectionSP threads;
   threads = std::make_shared<ThreadCollection>();
 
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
   if (!exe_ctx.HasThreadScope())
     return 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 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;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
   if (exe_ctx.HasThreadScope()) {
     Process::StopLocker stop_locker;
     if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock())) {
if (exe_ctx.HasThreadScope()) {
     }
   }
   if (dst)
     *dst = 0;
   return 0;
 }
 
 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;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
   if (exe_ctx.HasThreadScope()) {
     Process::StopLocker stop_locker;
     if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock())) {
SBValue SBThread::GetStopReturnValue() {
   return SBValue(return_valobj_sp);
 }
 
 void SBThread::SetThread(const ThreadSP &lldb_object_sp) {
   m_opaque_sp->SetThreadSP(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();
   return LLDB_INVALID_THREAD_ID;
 }
 
 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();
   return LLDB_INVALID_INDEX32;
 }
 
 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;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
   if (exe_ctx.HasThreadScope()) {
     Process::StopLocker stop_locker;
     if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock())) {
if (log)
     log->Printf("SBThread(%p)::GetName () => %s",
                 static_cast<void *>(exe_ctx.GetThreadPtr()),
                 name ? name : "NULL");
 
   return name;
 }
 
 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);
 
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   if (exe_ctx.HasThreadScope()) {
     Process::StopLocker stop_locker;
     if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock())) {
if (log)
     log->Printf("SBThread(%p)::GetQueueName () => %s",
                 static_cast<void *>(exe_ctx.GetThreadPtr()),
                 name ? name : "NULL");
 
   return name;
 }
 
 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);
 
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   if (exe_ctx.HasThreadScope()) {
     Process::StopLocker stop_locker;
     if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock())) {
       id = exe_ctx.GetThreadPtr()->GetQueueID();
     } else {
       if (log)
         log->Printf("SBThread(%p)::GetQueueID() => error: process is running",
                     static_cast<void *>(exe_ctx.GetThreadPtr()));
     }
   }
 
   if (log)
     log->Printf("SBThread(%p)::GetQueueID () => 0x%" PRIx64,
                 static_cast<void *>(exe_ctx.GetThreadPtr()), id);
 
   return id;
 }
 
 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;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
   if (exe_ctx.HasThreadScope()) {
     Process::StopLocker stop_locker;
     if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock())) {
if (process->GetTarget().GetDebugger().GetAsyncExecution())
     sb_error.ref() = process->Resume();
   else
     sb_error.ref() = process->ResumeSynchronous(NULL);
 
   return sb_error;
 }
 
 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;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
   if (log)
     log->Printf("SBThread(%p)::StepOver (stop_other_threads='%s')",
                 static_cast<void *>(exe_ctx.GetThreadPtr()),
if (frame_sp->HasDebugInformation()) {
       new_plan_sp = thread->QueueThreadPlanForStepSingleInstruction(
           true, abort_other_plans, stop_other_threads, new_plan_status);
     }
   }
   error = ResumeNewPlan(exe_ctx, new_plan_sp.get());
 }
 
 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;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
   if (log)
     log->Printf(
         "SBThread(%p)::StepInto (target_name='%s', stop_other_threads='%s')",
void SBThread::StepInto(const char *target_name, uint32_t end_line,
 
   if (new_plan_status.Success())
     error = ResumeNewPlan(exe_ctx, new_plan_sp.get());
   else
     error.SetErrorString(new_plan_status.AsCString());
 }
 
 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;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
   if (log)
     log->Printf("SBThread(%p)::StepOut ()",
                 static_cast<void *>(exe_ctx.GetThreadPtr()));
void SBThread::StepOut(SBError &error) {
 
   if (new_plan_status.Success())
     error = ResumeNewPlan(exe_ctx, new_plan_sp.get());
   else
     error.SetErrorString(new_plan_status.AsCString());
 }
 
 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;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
   if (!sb_frame.IsValid()) {
     if (log)
       log->Printf(
void SBThread::StepOutOfFrame(SBFrame &sb_frame, SBError &error) {
 
   if (new_plan_status.Success())
     error = ResumeNewPlan(exe_ctx, new_plan_sp.get());
   else
     error.SetErrorString(new_plan_status.AsCString());
 }
 
 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;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
   if (log)
     log->Printf("SBThread(%p)::StepInstruction (step_over=%i)",
                 static_cast<void *>(exe_ctx.GetThreadPtr()), step_over);
void SBThread::StepInstruction(bool step_over, SBError &error) {
 
   if (new_plan_status.Success())
     error = ResumeNewPlan(exe_ctx, new_plan_sp.get());
   else
     error.SetErrorString(new_plan_status.AsCString());
 }
 
 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;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
   if (log)
     log->Printf("SBThread(%p)::RunToAddress (addr=0x%" PRIx64 ")",
                 static_cast<void *>(exe_ctx.GetThreadPtr()), addr);
void SBThread::RunToAddress(lldb::addr_t addr, SBError &error) {
   if (new_plan_status.Success())
     error = ResumeNewPlan(exe_ctx, new_plan_sp.get());
   else
     error.SetErrorString(new_plan_status.AsCString());
 }
 
 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];
 
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
   StackFrameSP frame_sp(sb_frame.GetFrameSP());
if (exe_ctx.HasThreadScope()) {
     }
   } else {
     sb_error.SetErrorString("this SBThread object is invalid");
   }
   return sb_error;
 }
 
 SBError SBThread::StepUsingScriptedThreadPlan(const char *script_class_name) {
+  LLDB_RECORD_METHOD(lldb::SBError, SBThread, StepUsingScriptedThreadPlan,
+                     (const char *), script_class_name);
+
   return StepUsingScriptedThreadPlan(script_class_name, true);
 }
 
 SBError SBThread::StepUsingScriptedThreadPlan(const char *script_class_name,
                                               bool resume_immediately) {
+  LLDB_RECORD_METHOD(lldb::SBError, SBThread, StepUsingScriptedThreadPlan,
+                     (const char *, bool), script_class_name,
+                     resume_immediately);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   SBError error;
 
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
   if (log) {
     log->Printf("SBThread(%p)::StepUsingScriptedThreadPlan: class name: %s",
if (new_plan_status.Success())
     error = ResumeNewPlan(exe_ctx, new_plan_sp.get());
   else
     error.SetErrorString(new_plan_status.AsCString());
 
   return error;
 }
 
 SBError SBThread::JumpToLine(lldb::SBFileSpec &file_spec, uint32_t line) {
+  LLDB_RECORD_METHOD(lldb::SBError, SBThread, JumpToLine,
+                     (lldb::SBFileSpec &, uint32_t), file_spec, line);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   SBError sb_error;
 
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
   if (log)
     log->Printf("SBThread(%p)::JumpToLine (file+line = %s:%u)",
                 static_cast<void *>(exe_ctx.GetThreadPtr()),
                 file_spec->GetPath().c_str(), line);
 
   if (!exe_ctx.HasThreadScope()) {
     sb_error.SetErrorString("this SBThread object is invalid");
     return sb_error;
   }
 
   Thread *thread = exe_ctx.GetThreadPtr();
 
   Status err = thread->JumpToLine(file_spec.get(), line, true);
   sb_error.SetError(err);
   return sb_error;
 }
 
 SBError SBThread::ReturnFromFrame(SBFrame &frame, SBValue &return_value) {
+  LLDB_RECORD_METHOD(lldb::SBError, SBThread, ReturnFromFrame,
+                     (lldb::SBFrame &, lldb::SBValue &), frame, return_value);
+
   SBError sb_error;
 
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
   if (log)
     log->Printf("SBThread(%p)::ReturnFromFrame (frame=%d)",
                 static_cast<void *>(exe_ctx.GetThreadPtr()),
                 frame.GetFrameID());
 
   if (exe_ctx.HasThreadScope()) {
     Thread *thread = exe_ctx.GetThreadPtr();
     sb_error.SetError(
         thread->ReturnFromFrame(frame.GetFrameSP(), return_value.GetSP()));
   }
 
   return 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));
 
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
   if (log)
     log->Printf("SBThread(%p)::UnwindExpressionEvaluation",
                 static_cast<void *>(exe_ctx.GetThreadPtr()));
 
   if (exe_ctx.HasThreadScope()) {
     Thread *thread = exe_ctx.GetThreadPtr();
     sb_error.SetError(thread->UnwindInnermostExpression());
     if (sb_error.Success())
       thread->SetSelectedFrameByIndex(0, false);
   }
 
   return 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 result = false;
   if (exe_ctx.HasThreadScope()) {
     Process::StopLocker stop_locker;
     if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock())) {
if (exe_ctx.HasThreadScope()) {
     error.SetErrorString("this SBThread object is invalid");
   if (log)
     log->Printf("SBThread(%p)::Suspend() => %i",
                 static_cast<void *>(exe_ctx.GetThreadPtr()), result);
   return result;
 }
 
 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 result = false;
   if (exe_ctx.HasThreadScope()) {
     Process::StopLocker stop_locker;
     if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock())) {
if (exe_ctx.HasThreadScope()) {
     error.SetErrorString("this SBThread object is invalid");
   if (log)
     log->Printf("SBThread(%p)::Resume() => %i",
                 static_cast<void *>(exe_ctx.GetThreadPtr()), result);
   return result;
 }
 
 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);
 
   if (exe_ctx.HasThreadScope())
     return exe_ctx.GetThreadPtr()->GetResumeState() == eStateSuspended;
   return false;
 }
 
 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);
 
   if (exe_ctx.HasThreadScope())
     return StateIsStoppedState(exe_ctx.GetThreadPtr()->GetState(), true);
   return false;
 }
 
 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);
 
   if (exe_ctx.HasThreadScope()) {
     // Have to go up to the target so we can get a shared pointer to our
     // process...
     sb_process.SetSP(exe_ctx.GetProcessSP());
   }
 
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   if (log) {
     SBStream frame_desc_strm;
     sb_process.GetDescription(frame_desc_strm);
     log->Printf("SBThread(%p)::GetProcess () => SBProcess(%p): %s",
                 static_cast<void *>(exe_ctx.GetThreadPtr()),
                 static_cast<void *>(sb_process.GetSP().get()),
                 frame_desc_strm.GetData());
   }
 
   return 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;
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
   if (exe_ctx.HasThreadScope()) {
     Process::StopLocker stop_locker;
uint32_t SBThread::GetNumFrames() {
   if (log)
     log->Printf("SBThread(%p)::GetNumFrames () => %u",
                 static_cast<void *>(exe_ctx.GetThreadPtr()), num_frames);
 
   return num_frames;
 }
 
 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;
   StackFrameSP frame_sp;
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
   if (exe_ctx.HasThreadScope()) {
log->Printf("SBThread(%p)::GetFrameAtIndex (idx=%d) => SBFrame(%p): %s",
                 static_cast<void *>(exe_ctx.GetThreadPtr()), idx,
                 static_cast<void *>(frame_sp.get()), frame_desc_strm.GetData());
   }
 
   return 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;
   StackFrameSP frame_sp;
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
   if (exe_ctx.HasThreadScope()) {
log->Printf("SBThread(%p)::GetSelectedFrame () => SBFrame(%p): %s",
                 static_cast<void *>(exe_ctx.GetThreadPtr()),
                 static_cast<void *>(frame_sp.get()), frame_desc_strm.GetData());
   }
 
   return 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;
   StackFrameSP frame_sp;
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
   if (exe_ctx.HasThreadScope()) {
if (log) {
     log->Printf("SBThread(%p)::SetSelectedFrame (idx=%u) => SBFrame(%p): %s",
                 static_cast<void *>(exe_ctx.GetThreadPtr()), idx,
                 static_cast<void *>(frame_sp.get()), frame_desc_strm.GetData());
   }
   return 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) {
+  LLDB_RECORD_STATIC_METHOD(lldb::SBFrame, SBThread, GetStackFrameFromEvent,
+                            (const lldb::SBEvent &), event);
+
   return Thread::ThreadEventData::GetStackFrameFromEvent(event.get());
 }
 
 SBThread SBThread::GetThreadFromEvent(const SBEvent &event) {
+  LLDB_RECORD_STATIC_METHOD(lldb::SBThread, SBThread, GetThreadFromEvent,
+                            (const lldb::SBEvent &), event);
+
   return 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;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
   if (exe_ctx.HasThreadScope()) {
     exe_ctx.GetThreadPtr()->GetStatus(strm, 0, 1, 1, true);
   } else
     strm.PutCString("No status");
 
   return true;
 }
 
 bool SBThread::GetDescription(SBStream &description) const {
-    return GetDescription(description, false);
+  LLDB_RECORD_METHOD_CONST(bool, SBThread, GetDescription, (lldb::SBStream &),
+                           description);
+
 }
 
 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;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
   if (exe_ctx.HasThreadScope()) {
     exe_ctx.GetThreadPtr()->DumpUsingSettingsFormat(strm,
                                                     LLDB_INVALID_THREAD_ID,
                                                     stop_format);
     // strm.Printf("SBThread: tid = 0x%4.4" PRIx64,
     // exe_ctx.GetThreadPtr()->GetID());
   } else
     strm.PutCString("No value");
 
   return true;
 }
 
 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);
   SBThread sb_origin_thread;
 
   if (exe_ctx.HasThreadScope()) {
     Process::StopLocker stop_locker;
     if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock())) {
SBThread SBThread::GetExtendedBacktraceThread(const char *type) {
   if (log && !sb_origin_thread.IsValid())
     log->Printf("SBThread(%p)::GetExtendedBacktraceThread() is not returning a "
                 "Valid thread",
                 static_cast<void *>(exe_ctx.GetThreadPtr()));
   return 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();
   return LLDB_INVALID_INDEX32;
 }
 
 SBValue SBThread::GetCurrentException() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBValue, SBThread, GetCurrentException);
+
   ThreadSP thread_sp(m_opaque_sp->GetThreadSP());
   if (!thread_sp) return SBValue();
 
   return 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();
 
   return 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();
   return true;
 }
 
 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();
   else
     return NULL;
 }
 
 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();
   else
     return NULL;
 }

lldb/source/API/SBThreadCollection.cpp

 //===-- SBThreadCollection.cpp ----------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
+#include "SBReproducerPrivate.h"
+
 #include "lldb/API/SBThreadCollection.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;
 }
 
 SBThreadCollection::SBThreadCollection(const ThreadCollectionSP &threads)
     : m_opaque_sp(threads) {}
 

 lldb::ThreadCollectionSP &SBThreadCollection::operator*() {
   return m_opaque_sp;
 }
 
 const lldb::ThreadCollectionSP &SBThreadCollection::operator*() const {
   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;
 }

lldb/source/API/SBThreadPlan.cpp

 //===-- SBThreadPlan.cpp ----------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
+#include "SBReproducerPrivate.h"
+
 #include "lldb/API/SBThread.h"
 
 #include "lldb/API/SBFileSpec.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/API/SBSymbolContext.h"
 #include "lldb/Breakpoint/BreakpointLocation.h"
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/StreamFile.h"

 #include <memory>
 
 using namespace lldb;
 using namespace lldb_private;
 
 //----------------------------------------------------------------------
 // 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);
 }
 
 //----------------------------------------------------------------------
 // Assignment operator
 //----------------------------------------------------------------------
 
 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;
 }
 //----------------------------------------------------------------------
 // Destructor
 //----------------------------------------------------------------------
 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 { return m_opaque_sp.get() != NULL; }
+bool SBThreadPlan::IsValid() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBThreadPlan, IsValid);
+  return m_opaque_sp.get() != NULL;
+}
 
-void SBThreadPlan::Clear() { m_opaque_sp.reset(); }
+void SBThreadPlan::Clear() {
+  LLDB_RECORD_METHOD_NO_ARGS(void, SBThreadPlan, Clear);
+  m_opaque_sp.reset();
+}
 
-lldb::StopReason SBThreadPlan::GetStopReason() { return eStopReasonNone; }
+lldb::StopReason SBThreadPlan::GetStopReason() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::StopReason, SBThreadPlan, GetStopReason);
+  return eStopReasonNone;
+}
 
-size_t SBThreadPlan::GetStopReasonDataCount() { return 0; }
+size_t SBThreadPlan::GetStopReasonDataCount() {
+  LLDB_RECORD_METHOD_NO_ARGS(size_t, SBThreadPlan, GetStopReasonDataCount);
+  return 0;
+}
 
-uint64_t SBThreadPlan::GetStopReasonDataAtIndex(uint32_t idx) { return 0; }
+uint64_t SBThreadPlan::GetStopReasonDataAtIndex(uint32_t idx) {
+  LLDB_RECORD_METHOD(uint64_t, SBThreadPlan, GetStopReasonDataAtIndex,
+                     (uint32_t), idx);
+  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());
   } else
     return 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 {
     description.Printf("Empty SBThreadPlan");
   }
   return true;
 }
 
 void SBThreadPlan::SetThreadPlan(const ThreadPlanSP &lldb_object_sp) {
   m_opaque_sp = lldb_object_sp;
 }
 
 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
     return true;
 }
 
 bool SBThreadPlan::IsPlanStale() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBThreadPlan, IsPlanStale);
+
   if (m_opaque_sp)
     return m_opaque_sp->IsPlanStale();
   else
     return true;
 }
 
 bool SBThreadPlan::IsValid() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBThreadPlan, IsValid);
+
   if (m_opaque_sp)
     return m_opaque_sp->ValidatePlan(nullptr);
   else
     return false;
 }
 
 // This section allows an SBThreadPlan to push another of the common types of
 // plans...
 //
 // FIXME, you should only be able to queue thread plans from inside the methods
 // of a Scripted Thread Plan.  Need a way to enforce that.
 
 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);
 }
 
 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();
     }
 
     AddressRange range(*start_address, size);
     SymbolContext sc;
SBThreadPlan SBThreadPlan::QueueThreadPlanForStepOverRange(
   } else {
     return SBThreadPlan();
   }
 }
 
 SBThreadPlan
 SBThreadPlan::QueueThreadPlanForStepInRange(SBAddress &sb_start_address,
                                             lldb::addr_t size) {
+  LLDB_RECORD_METHOD(lldb::SBThreadPlan, SBThreadPlan,
+                     QueueThreadPlanForStepInRange,
+                     (lldb::SBAddress &, lldb::addr_t), sb_start_address, size);
+
   SBError error;
   return QueueThreadPlanForStepInRange(sb_start_address, size, error);
 }
 
 SBThreadPlan
 SBThreadPlan::QueueThreadPlanForStepInRange(SBAddress &sb_start_address,
                                             lldb::addr_t size, SBError &error) {
+  LLDB_RECORD_METHOD(lldb::SBThreadPlan, SBThreadPlan,
+                     QueueThreadPlanForStepInRange,
+                     (lldb::SBAddress &, lldb::addr_t, lldb::SBError &),
+                     sb_start_address, size, error);
+
   if (m_opaque_sp) {
     Address *start_address = sb_start_address.get();
     if (!start_address) {
       return SBThreadPlan();
     }
 
     AddressRange range(*start_address, size);
     SymbolContext sc;
SBThreadPlan::QueueThreadPlanForStepInRange(SBAddress &sb_start_address,
   } else {
     return SBThreadPlan();
   }
 }
 
 SBThreadPlan
 SBThreadPlan::QueueThreadPlanForStepOut(uint32_t frame_idx_to_step_to,
                                         bool first_insn) {
+  LLDB_RECORD_METHOD(lldb::SBThreadPlan, SBThreadPlan,
+                     QueueThreadPlanForStepOut, (uint32_t, bool),
+                     frame_idx_to_step_to, first_insn);
+
   SBError error;
   return QueueThreadPlanForStepOut(frame_idx_to_step_to, first_insn, error);
 }
 
 SBThreadPlan
 SBThreadPlan::QueueThreadPlanForStepOut(uint32_t frame_idx_to_step_to,
                                         bool first_insn, SBError &error) {
+  LLDB_RECORD_METHOD(lldb::SBThreadPlan, SBThreadPlan,
+                     QueueThreadPlanForStepOut,
+                     (uint32_t, bool, lldb::SBError &), frame_idx_to_step_to,
+                     first_insn, error);
+
   if (m_opaque_sp) {
     SymbolContext sc;
     sc = m_opaque_sp->GetThread().GetStackFrameAtIndex(0)->GetSymbolContext(
         lldb::eSymbolContextEverything);
 
     Status plan_status;
     SBThreadPlan plan =
         SBThreadPlan(m_opaque_sp->GetThread().QueueThreadPlanForStepOut(
             false, &sc, first_insn, false, eVoteYes, eVoteNoOpinion,
             frame_idx_to_step_to, plan_status));
 
     if (plan_status.Fail())
       error.SetErrorString(plan_status.AsCString());
 
     return plan;
   } else {
     return 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);
 }
 
 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();
 
     Status plan_status;
     SBThreadPlan plan =
         SBThreadPlan(m_opaque_sp->GetThread().QueueThreadPlanForRunToAddress(
             false, *address, false, plan_status));
 
     if (plan_status.Fail())
       error.SetErrorString(plan_status.AsCString());
 
     return plan;
   } else {
     return 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);
 }
 
 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 =
         SBThreadPlan(m_opaque_sp->GetThread().QueueThreadPlanForStepScripted(
             false, script_class_name, false, plan_status));
 
     if (plan_status.Fail())
       error.SetErrorString(plan_status.AsCString());
 
     return plan;
   } else {
     return SBThreadPlan();
   }
 }

lldb/source/API/SBTrace.cpp

 //===-- SBTrace.cpp ---------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
+#include "SBReproducerPrivate.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Utility/Log.h"
 
 #include "lldb/API/SBTrace.h"
 #include "lldb/API/SBTraceOptions.h"
 
 #include <memory>
 
if (!process_sp) {
     error.SetError(
         process_sp->GetMetaData(GetTraceUID(), thread_id, buffer, offset));
     LLDB_LOG(log, "SBTrace::bytes_read - {0}", buffer.size());
   }
   return buffer.size();
 }
 
 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();
 
   if (!process_sp) {
     error.SetErrorString("invalid process");
     return;
   }
   error.SetError(process_sp->StopTrace(GetTraceUID(), thread_id));
 }
 
 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();
 
   if (!process_sp) {
     error.SetErrorString("invalid process");
   } else {
     error.SetError(process_sp->GetTraceConfig(GetTraceUID(),
                                               *(options.m_traceoptions_sp)));
   }
 }
 
 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;
 }
 
 void SBTrace::SetTraceUID(lldb::user_id_t uid) {
   if (m_trace_impl_sp)
     m_trace_impl_sp->uid = 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())
     return false;
   return true;
 }

lldb/source/API/SBTraceOptions.cpp

 //===-- SBTraceOptions.cpp --------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBTraceOptions.h"
+#include "SBReproducerPrivate.h"
 #include "lldb/API/SBError.h"
 #include "lldb/API/SBStructuredData.h"
 #include "lldb/Core/StructuredDataImpl.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/TraceOptions.h"
 
 #include <memory>
 
 using namespace lldb;
 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();
   lldb::SBStructuredData structData;
   if (dict_obj && structData.m_impl_up)
     structData.m_impl_up->SetObjectSP(dict_obj->shared_from_this());
   else
     error.SetErrorString("Empty trace params");
   return 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)
       m_traceoptions_sp->setTraceParams(
           std::static_pointer_cast<StructuredData::Dictionary>(obj_sp));
   }
   return;
 }
 
 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

 //===-- SBType.cpp ----------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBType.h"
+#include "SBReproducerPrivate.h"
 #include "lldb/API/SBDefines.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/API/SBTypeEnumMember.h"
 #include "lldb/Core/Mangled.h"
 #include "lldb/Symbol/CompilerType.h"
 #include "lldb/Symbol/Type.h"
 #include "lldb/Symbol/TypeSystem.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/Stream.h"
 
 #include "llvm/ADT/APSInt.h"
 
 #include <memory>
 
 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(
           CompilerType(type.GetTypeSystem(), type.GetOpaqueQualType()))) {}
 
 SBType::SBType(const lldb::TypeSP &type_sp)
     : m_opaque_sp(new TypeImpl(type_sp)) {}
 
 SBType::SBType(const lldb::TypeImplSP &type_impl_sp)
     : m_opaque_sp(type_impl_sp) {}
 
 SBType::SBType(const SBType &rhs) : m_opaque_sp() {
+  LLDB_RECORD_CONSTRUCTOR(SBType, (const lldb::SBType &), rhs);
+
   if (this != &rhs) {
     m_opaque_sp = rhs.m_opaque_sp;
   }
 }
 
 // SBType::SBType (TypeImpl* impl) :
 //    m_opaque_up(impl)
 //{}
 //
 bool SBType::operator==(SBType &rhs) {
+  LLDB_RECORD_METHOD(bool, SBType, operator==,(lldb::SBType &), rhs);
+
   if (!IsValid())
     return !rhs.IsValid();
 
   if (!rhs.IsValid())
     return false;
 
   return *m_opaque_sp.get() == *rhs.m_opaque_sp.get();
 }
 
 bool SBType::operator!=(SBType &rhs) {
+  LLDB_RECORD_METHOD(bool, SBType, operator!=,(lldb::SBType &), rhs);
+
   if (!IsValid())
     return rhs.IsValid();
 
   if (!rhs.IsValid())
     return true;
 
   return *m_opaque_sp.get() != *rhs.m_opaque_sp.get();
 }
 
 lldb::TypeImplSP SBType::GetSP() { return m_opaque_sp; }
 
 void SBType::SetSP(const lldb::TypeImplSP &type_impl_sp) {
   m_opaque_sp = type_impl_sp;
 }
 
 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;
   }
   return *this;
 }
 
 SBType::~SBType() {}
 
 TypeImpl &SBType::ref() {
   if (m_opaque_sp.get() == NULL)
     m_opaque_sp = std::make_shared<TypeImpl>();
   return *m_opaque_sp;
 }
 
 const TypeImpl &SBType::ref() const {
   // "const SBAddress &addr" should already have checked "addr.IsValid()" prior
   // to calling this function. In case you didn't we will assert and die to let
   // you know.
   assert(m_opaque_sp.get());
   return *m_opaque_sp;
 }
 
 bool SBType::IsValid() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBType, IsValid);
+
   if (m_opaque_sp.get() == NULL)
     return false;
 
   return m_opaque_sp->IsValid();
 }
 
 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))
       return *size;
   return 0;
 }
 
 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,
                                                         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 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())));
 }
 
 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())));
 }
 
 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())));
 }
 
 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())));
 }
 
 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())));
 }
 
 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))));
 }
 
 SBType SBType::GetVectorElementType() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBType, GetVectorElementType);
+
   SBType type_sb;
   if (IsValid()) {
     CompilerType vector_element_type;
     if (m_opaque_sp->GetCompilerType(true).IsVectorType(&vector_element_type,
                                                         nullptr))
       type_sb.SetSP(TypeImplSP(new TypeImpl(vector_element_type)));
   }
   return 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::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));
     size_t count = func_type.GetNumberOfFunctionArguments();
     for (size_t i = 0; i < count; i++) {
       sb_type_list.Append(SBType(func_type.GetFunctionArgumentAtIndex(i)));
     }
   }
   return 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();
   }
   return 0;
 }
 
 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;
 }
 
 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())));
 }
 
 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();
 }
 
 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();
 }
 
 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) {
     m_opaque_sp->GetDescription(strm, description_level);
   } else
     strm.PutCString("No value");
 
   return true;
 }
 
 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;
     CompilerType base_class_type =
         m_opaque_sp->GetCompilerType(true).GetDirectBaseClassAtIndex(
             idx, &bit_offset);
     if (base_class_type.IsValid())
       sb_type_member.reset(new TypeMemberImpl(
           TypeImplSP(new TypeImpl(base_class_type)), bit_offset));
   }
   return 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;
     CompilerType base_class_type =
         m_opaque_sp->GetCompilerType(true).GetVirtualBaseClassAtIndex(
             idx, &bit_offset);
     if (base_class_type.IsValid())
       sb_type_member.reset(new TypeMemberImpl(
           TypeImplSP(new TypeImpl(base_class_type)), bit_offset));
   }
   return 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));
     if (this_type.IsValid()) {
       this_type.ForEachEnumerator([&sb_enum_member_list](
                                       const CompilerType &integer_type,
                                       const ConstString &name,
                                       const llvm::APSInt &value) -> bool {
         SBTypeEnumMember enum_member(
             lldb::TypeEnumMemberImplSP(new TypeEnumMemberImpl(
                 lldb::TypeImplSP(new TypeImpl(integer_type)), name, value)));
         sb_enum_member_list.Append(enum_member);
         return true; // Keep iterating
       });
     }
   }
   return 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));
     if (this_type.IsValid()) {
       uint64_t bit_offset = 0;
       uint32_t bitfield_bit_size = 0;
       bool is_bitfield = false;
       std::string name_sstr;
       CompilerType field_type(this_type.GetFieldAtIndex(
           idx, name_sstr, &bit_offset, &bitfield_bit_size, &is_bitfield));
       if (field_type.IsValid()) {
         ConstString name;
         if (!name_sstr.empty())
           name.SetCString(name_sstr.c_str());
         sb_type_member.reset(
             new TypeMemberImpl(TypeImplSP(new TypeImpl(field_type)), bit_offset,
                                name, bitfield_bit_size, is_bitfield));
       }
     }
   }
   return 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();
 
   CompilerType type;
   switch(GetTemplateArgumentKind(idx)) {
     case eTemplateArgumentKindType:
       type = m_opaque_sp->GetCompilerType(false).GetTypeTemplateArgument(idx);
       break;
     case eTemplateArgumentKindIntegral:
       type = m_opaque_sp->GetCompilerType(false)
                  .GetIntegralTemplateArgument(idx)
                  ->type;
       break;
     default:
       break;
   }
   if (type.IsValid())
     return SBType(type);
   return 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();
          i < rhs_size; i++)
       Append(const_cast<SBTypeList &>(rhs).GetTypeAtIndex(i));
   }
   return *this;
 }
 
 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();
 }
 
-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;
 }
 
 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 uint32_t bit_offset = m_opaque_up->GetBitOffset();
     const uint32_t byte_offset = bit_offset / 8u;
     const uint32_t byte_bit_offset = bit_offset % 8u;
     const char *name = m_opaque_up->GetName().GetCString();
     if (byte_bit_offset)

 TypeMemberImpl &SBTypeMember::ref() {
   if (m_opaque_up == NULL)
     m_opaque_up.reset(new TypeMemberImpl());
   return *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) {
       Mangled mangled(mangled_str, true);
       return mangled.GetDemangledName(mangled.GuessLanguage()).GetCString();
     }
   }
   return NULL;
 }
 
 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;
 }
 
 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;
 }
 
 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;
 }
 
 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)
     return m_opaque_sp->GetDescription(strm);
 
   return false;
 }
 

lldb/source/API/SBTypeCategory.cpp

 //===-- SBTypeCategory.cpp ----------------------------------------*- C++
 //-*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
+#include "SBReproducerPrivate.h"
+
 #include "lldb/API/SBTypeCategory.h"
 
 #include "lldb/API/SBStream.h"
 #include "lldb/API/SBTypeFilter.h"
 #include "lldb/API/SBTypeFormat.h"
 #include "lldb/API/SBTypeNameSpecifier.h"
 #include "lldb/API/SBTypeSummary.h"
 #include "lldb/API/SBTypeSynthetic.h"
 
 #include "lldb/Core/Debugger.h"
 #include "lldb/DataFormatters/DataVisualization.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Interpreter/ScriptInterpreter.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 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)
     DataVisualization::Categories::Enable(m_opaque_sp);
   else
     DataVisualization::Categories::Disable(m_opaque_sp);
 }
 
 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;
 
   return m_opaque_sp->GetTypeFormatsContainer()->GetCount() +
          m_opaque_sp->GetRegexTypeFormatsContainer()->GetCount();
 }
 
 uint32_t SBTypeCategory::GetNumSummaries() {
+  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeCategory, GetNumSummaries);
+
   if (!IsValid())
     return 0;
   return m_opaque_sp->GetTypeSummariesContainer()->GetCount() +
          m_opaque_sp->GetRegexTypeSummariesContainer()->GetCount();
 }
 
 uint32_t SBTypeCategory::GetNumFilters() {
+  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeCategory, GetNumFilters);
+
   if (!IsValid())
     return 0;
   return m_opaque_sp->GetTypeFiltersContainer()->GetCount() +
          m_opaque_sp->GetRegexTypeFiltersContainer()->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() +
          m_opaque_sp->GetRegexTypeSyntheticsContainer()->GetCount();
 }
 #endif
 
 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));
 }
 
 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));
 }
 
 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));
 }
 
 #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));
 }
 #endif
 
 SBTypeFilter SBTypeCategory::GetFilterForType(SBTypeNameSpecifier spec) {
+  LLDB_RECORD_METHOD(lldb::SBTypeFilter, SBTypeCategory, GetFilterForType,
+                     (lldb::SBTypeNameSpecifier), spec);
+
   if (!IsValid())
     return SBTypeFilter();
 
   if (!spec.IsValid())
     return SBTypeFilter();
 
   lldb::TypeFilterImplSP children_sp;
 
   if (spec.IsRegex())
     m_opaque_sp->GetRegexTypeFiltersContainer()->GetExact(
         ConstString(spec.GetName()), children_sp);
   else
     m_opaque_sp->GetTypeFiltersContainer()->GetExact(
         ConstString(spec.GetName()), children_sp);
 
   if (!children_sp)
     return lldb::SBTypeFilter();
 
   TypeFilterImplSP filter_sp =
       std::static_pointer_cast<TypeFilterImpl>(children_sp);
 
   return lldb::SBTypeFilter(filter_sp);
 }
 SBTypeFormat SBTypeCategory::GetFormatForType(SBTypeNameSpecifier spec) {
+  LLDB_RECORD_METHOD(lldb::SBTypeFormat, SBTypeCategory, GetFormatForType,
+                     (lldb::SBTypeNameSpecifier), spec);
+
   if (!IsValid())
     return SBTypeFormat();
 
   if (!spec.IsValid())
     return SBTypeFormat();
 
   lldb::TypeFormatImplSP format_sp;
 
   if (spec.IsRegex())
     m_opaque_sp->GetRegexTypeFormatsContainer()->GetExact(
         ConstString(spec.GetName()), format_sp);
   else
     m_opaque_sp->GetTypeFormatsContainer()->GetExact(
         ConstString(spec.GetName()), format_sp);
 
   if (!format_sp)
     return lldb::SBTypeFormat();
 
   return 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();
 
   if (!spec.IsValid())
     return SBTypeSummary();
 
   lldb::TypeSummaryImplSP summary_sp;
 
   if (spec.IsRegex())
     m_opaque_sp->GetRegexTypeSummariesContainer()->GetExact(
         ConstString(spec.GetName()), summary_sp);
   else
     m_opaque_sp->GetTypeSummariesContainer()->GetExact(
         ConstString(spec.GetName()), summary_sp);
 
   if (!summary_sp)
     return lldb::SBTypeSummary();
 
   return 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();
 
   if (!spec.IsValid())
     return SBTypeSynthetic();
 
   lldb::SyntheticChildrenSP children_sp;
 
ScriptedSyntheticChildrenSP synth_sp =
       std::static_pointer_cast<ScriptedSyntheticChildren>(children_sp);
 
   return 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();
   lldb::SyntheticChildrenSP children_sp =
       m_opaque_sp->GetSyntheticAtIndex((index));
 
   if (!children_sp.get())
     return lldb::SBTypeFilter();
 
   TypeFilterImplSP filter_sp =
       std::static_pointer_cast<TypeFilterImpl>(children_sp);
 
   return 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)));
 }
 
 #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)));
 }
 #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();
   lldb::SyntheticChildrenSP children_sp =
       m_opaque_sp->GetSyntheticAtIndex((index));
 
   if (!children_sp.get())
     return lldb::SBTypeSynthetic();
 
   ScriptedSyntheticChildrenSP synth_sp =
       std::static_pointer_cast<ScriptedSyntheticChildren>(children_sp);
 
   return 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;
 
   if (!type_name.IsValid())
     return false;
 
   if (!format.IsValid())
     return false;
 
   if (type_name.IsRegex())
     m_opaque_sp->GetRegexTypeFormatsContainer()->Add(
         lldb::RegularExpressionSP(new RegularExpression(
             llvm::StringRef::withNullAsEmpty(type_name.GetName()))),
         format.GetSP());
   else
     m_opaque_sp->GetTypeFormatsContainer()->Add(
         ConstString(type_name.GetName()), format.GetSP());
 
   return true;
 }
 
 bool SBTypeCategory::DeleteTypeFormat(SBTypeNameSpecifier type_name) {
+  LLDB_RECORD_METHOD(bool, SBTypeCategory, DeleteTypeFormat,
+                     (lldb::SBTypeNameSpecifier), type_name);
+
   if (!IsValid())
     return false;
 
   if (!type_name.IsValid())
     return false;
 
   if (type_name.IsRegex())
     return m_opaque_sp->GetRegexTypeFormatsContainer()->Delete(
         ConstString(type_name.GetName()));
   else
     return m_opaque_sp->GetTypeFormatsContainer()->Delete(
         ConstString(type_name.GetName()));
 }
 
 #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;
 
   if (!type_name.IsValid())
     return false;
 
   if (!summary.IsValid())
     return false;
else
     m_opaque_sp->GetTypeSummariesContainer()->Add(
         ConstString(type_name.GetName()), summary.GetSP());
 
   return true;
 }
 #endif
 
 bool SBTypeCategory::DeleteTypeSummary(SBTypeNameSpecifier type_name) {
+  LLDB_RECORD_METHOD(bool, SBTypeCategory, DeleteTypeSummary,
+                     (lldb::SBTypeNameSpecifier), type_name);
+
   if (!IsValid())
     return false;
 
   if (!type_name.IsValid())
     return false;
 
   if (type_name.IsRegex())
     return m_opaque_sp->GetRegexTypeSummariesContainer()->Delete(
         ConstString(type_name.GetName()));
   else
     return m_opaque_sp->GetTypeSummariesContainer()->Delete(
         ConstString(type_name.GetName()));
 }
 
 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;
 
   if (!type_name.IsValid())
     return false;
 
   if (!filter.IsValid())
     return false;
 
   if (type_name.IsRegex())
     m_opaque_sp->GetRegexTypeFiltersContainer()->Add(
         lldb::RegularExpressionSP(new RegularExpression(
             llvm::StringRef::withNullAsEmpty(type_name.GetName()))),
         filter.GetSP());
   else
     m_opaque_sp->GetTypeFiltersContainer()->Add(
         ConstString(type_name.GetName()), filter.GetSP());
 
   return true;
 }
 
 bool SBTypeCategory::DeleteTypeFilter(SBTypeNameSpecifier type_name) {
+  LLDB_RECORD_METHOD(bool, SBTypeCategory, DeleteTypeFilter,
+                     (lldb::SBTypeNameSpecifier), type_name);
+
   if (!IsValid())
     return false;
 
   if (!type_name.IsValid())
     return false;
 
   if (type_name.IsRegex())
     return m_opaque_sp->GetRegexTypeFiltersContainer()->Delete(
         ConstString(type_name.GetName()));
   else
     return m_opaque_sp->GetTypeFiltersContainer()->Delete(
         ConstString(type_name.GetName()));
 }
 
 #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;
 
   if (!type_name.IsValid())
     return false;
 
   if (!synth.IsValid())
     return false;
bool SBTypeCategory::AddTypeSynthetic(SBTypeNameSpecifier type_name,
   else
     m_opaque_sp->GetTypeSyntheticsContainer()->Add(
         ConstString(type_name.GetName()), synth.GetSP());
 
   return true;
 }
 
 bool SBTypeCategory::DeleteTypeSynthetic(SBTypeNameSpecifier type_name) {
+  LLDB_RECORD_METHOD(bool, SBTypeCategory, DeleteTypeSynthetic,
+                     (lldb::SBTypeNameSpecifier), type_name);
+
   if (!IsValid())
     return false;
 
   if (!type_name.IsValid())
     return false;
 
   if (type_name.IsRegex())
     return m_opaque_sp->GetRegexTypeSyntheticsContainer()->Delete(
         ConstString(type_name.GetName()));
   else
     return m_opaque_sp->GetTypeSyntheticsContainer()->Delete(
         ConstString(type_name.GetName()));
 }
 #endif // LLDB_DISABLE_PYTHON
 
 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());
   return true;
 }
 
 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;
   }
   return *this;
 }
 
 bool SBTypeCategory::operator==(lldb::SBTypeCategory &rhs) {
+  LLDB_RECORD_METHOD(bool, SBTypeCategory, operator==,(lldb::SBTypeCategory &),
+                     rhs);
+
   if (!IsValid())
     return !rhs.IsValid();
 
   return m_opaque_sp.get() == rhs.m_opaque_sp.get();
 }
 
 bool SBTypeCategory::operator!=(lldb::SBTypeCategory &rhs) {
+  LLDB_RECORD_METHOD(bool, SBTypeCategory, operator!=,(lldb::SBTypeCategory &),
+                     rhs);
+
   if (!IsValid())
     return rhs.IsValid();
 
   return m_opaque_sp.get() != rhs.m_opaque_sp.get();
 }
 
 lldb::TypeCategoryImplSP SBTypeCategory::GetSP() {
   if (!IsValid())

lldb/source/API/SBTypeEnumMember.cpp

 //===-- SBTypeEnumMember.cpp ---------------------------------- -*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBTypeEnumMember.h"
+#include "SBReproducerPrivate.h"
 #include "lldb/API/SBDefines.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/API/SBType.h"
 #include "lldb/Symbol/CompilerType.h"
 #include "lldb/Symbol/Type.h"
 #include "lldb/Utility/Stream.h"
 
 #include <memory>
 
 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(
     const lldb::TypeEnumMemberImplSP &enum_member_sp)
     : m_opaque_sp(enum_member_sp) {}
 
 SBTypeEnumMember::SBTypeEnumMember(const SBTypeEnumMember &rhs)
     : m_opaque_sp() {
+  LLDB_RECORD_CONSTRUCTOR(SBTypeEnumMember, (const lldb::SBTypeEnumMember &),
+                          rhs);
+
   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;
 }
 
 void SBTypeEnumMember::reset(TypeEnumMemberImpl *type_member_impl) {
   m_opaque_sp.reset(type_member_impl);
 }
 
 TypeEnumMemberImpl &SBTypeEnumMember::ref() {
   if (m_opaque_sp.get() == NULL)
     m_opaque_sp = std::make_shared<TypeEnumMemberImpl>();
   return *m_opaque_sp.get();
 }
 
 const TypeEnumMemberImpl &SBTypeEnumMember::ref() const {
   return *m_opaque_sp.get();
 }
 
 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,
                   rhs_size = const_cast<SBTypeEnumMemberList &>(rhs).GetSize();
          i < rhs_size; i++)
       Append(
           const_cast<SBTypeEnumMemberList &>(rhs).GetTypeEnumMemberAtIndex(i));
   }
   return *this;
 }
 
 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();
 }
 
-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()) {
     if (m_opaque_sp->GetIntegerType()->GetDescription(strm,
                                                       description_level)) {
       strm.Printf(" %s", m_opaque_sp->GetName().GetCString());
     }
   } else {
     strm.PutCString("No value");
   }
   return true;
 }

lldb/source/API/SBTypeFilter.cpp

 //===-- SBTypeFilter.cpp ------------------------------------------*- C++
 //-*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
+#include "SBReproducerPrivate.h"
+
 #include "lldb/API/SBTypeFilter.h"
 
 #include "lldb/API/SBStream.h"
 
 #include "lldb/DataFormatters/DataVisualization.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 {
     description.Printf("%s\n", m_opaque_sp->GetDescription().c_str());
     return true;
   }
 }
 
 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 == '.')
       item++;
     return item;
   }
   return NULL;
 }
 
 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
     return false;
 }
 
 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;
   }
   return *this;
 }
 
 bool SBTypeFilter::operator==(lldb::SBTypeFilter &rhs) {
+  LLDB_RECORD_METHOD(bool, SBTypeFilter, operator==,(lldb::SBTypeFilter &),
+                     rhs);
+
   if (!IsValid())
     return !rhs.IsValid();
 
   return m_opaque_sp == rhs.m_opaque_sp;
 }
 
 bool SBTypeFilter::IsEqualTo(lldb::SBTypeFilter &rhs) {
+  LLDB_RECORD_METHOD(bool, SBTypeFilter, IsEqualTo, (lldb::SBTypeFilter &),
+                     rhs);
+
   if (!IsValid())
     return !rhs.IsValid();
 
   if (GetNumberOfExpressionPaths() != rhs.GetNumberOfExpressionPaths())
     return false;
 
   for (uint32_t j = 0; j < GetNumberOfExpressionPaths(); j++)
     if (strcmp(GetExpressionPathAtIndex(j), rhs.GetExpressionPathAtIndex(j)) !=
         0)
       return false;
 
   return GetOptions() == rhs.GetOptions();
 }
 
 bool SBTypeFilter::operator!=(lldb::SBTypeFilter &rhs) {
+  LLDB_RECORD_METHOD(bool, SBTypeFilter, operator!=,(lldb::SBTypeFilter &),
+                     rhs);
+
   if (!IsValid())
     return !rhs.IsValid();
 
   return m_opaque_sp != rhs.m_opaque_sp;
 }
 
 lldb::TypeFilterImplSP SBTypeFilter::GetSP() { return m_opaque_sp; }
 

lldb/source/API/SBTypeFormat.cpp

 //===-- SBTypeFormat.cpp ------------------------------------------*- C++
 //-*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
+#include "SBReproducerPrivate.h"
+
 #include "lldb/API/SBTypeFormat.h"
 
 #include "lldb/API/SBStream.h"
 
 #include "lldb/DataFormatters/DataVisualization.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()
         .AsCString("");
   return "";
 }
 
 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 {
     description.Printf("%s\n", m_opaque_sp->GetDescription().c_str());
     return true;
   }
 }
 
 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;
   }
   return *this;
 }
 
 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();
 
   if (GetFormat() == rhs.GetFormat())
     return GetOptions() == rhs.GetOptions();
   else
     return false;
 }
 
 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::TypeFormatImplSP SBTypeFormat::GetSP() { return m_opaque_sp; }
 
 void SBTypeFormat::SetSP(const lldb::TypeFormatImplSP &typeformat_impl_sp) {

lldb/source/API/SBTypeNameSpecifier.cpp

 //===-- SBTypeNameSpecifier.cpp ------------------------------------*- C++
 //-*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
+#include "SBReproducerPrivate.h"
+
 #include "lldb/API/SBTypeNameSpecifier.h"
 
 #include "lldb/API/SBStream.h"
 #include "lldb/API/SBType.h"
 
 #include "lldb/DataFormatters/DataVisualization.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;
 
   return m_opaque_sp->GetName();
 }
 
 SBType SBTypeNameSpecifier::GetType() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBTypeNameSpecifier, GetType);
+
   if (!IsValid())
     return SBType();
   lldb_private::CompilerType c_type = m_opaque_sp->GetCompilerType();
   if (c_type.IsValid())
     return SBType(c_type);
   return SBType();
 }
 
 bool SBTypeNameSpecifier::IsRegex() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBTypeNameSpecifier, IsRegex);
+
   if (!IsValid())
     return false;
 
   return m_opaque_sp->IsRegex();
 }
 
 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(),
                      IsRegex() ? "regex" : "plain");
   return true;
 }
 
 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;
   }
   return *this;
 }
 
 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();
 
   if (IsRegex() != rhs.IsRegex())
     return false;
   if (GetName() == NULL || rhs.GetName() == NULL)
     return false;
 
   return (strcmp(GetName(), rhs.GetName()) == 0);
 }
 
 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::TypeNameSpecifierImplSP SBTypeNameSpecifier::GetSP() {
   return m_opaque_sp;
 }

lldb/source/API/SBTypeSummary.cpp

 //===-- SBTypeSummary.cpp -----------------------------------------*- C++
 //-*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBTypeSummary.h"
+#include "SBReproducerPrivate.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/API/SBValue.h"
 #include "lldb/DataFormatters/DataVisualization.h"
 
 #include "llvm/Support/Casting.h"
 
 using namespace lldb;
 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
     m_opaque_up.reset(new TypeSummaryOptions());
 }
 
 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);
 }
 
 lldb_private::TypeSummaryOptions *SBTypeSummaryOptions::operator->() {
   return m_opaque_up.get();
 }
 

 }
 
 const lldb_private::TypeSummaryOptions &SBTypeSummaryOptions::ref() const {
   return *m_opaque_up;
 }
 
 SBTypeSummaryOptions::SBTypeSummaryOptions(
     const lldb_private::TypeSummaryOptions *lldb_object_ptr) {
+  LLDB_RECORD_CONSTRUCTOR(SBTypeSummaryOptions,
+                          (const lldb_private::TypeSummaryOptions *),
+                          lldb_object_ptr);
+
   SetOptions(lldb_object_ptr);
 }
 
 void SBTypeSummaryOptions::SetOptions(
     const lldb_private::TypeSummaryOptions *lldb_object_ptr) {
   if (lldb_object_ptr)
     m_opaque_up.reset(new TypeSummaryOptions(*lldb_object_ptr));
   else
     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 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 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 SBTypeSummary(
       TypeSummaryImplSP(new ScriptSummaryFormat(options, "", data)));
 }
 
 SBTypeSummary SBTypeSummary::CreateWithCallback(FormatCallback cb,
retval.SetSP(TypeSummaryImplSP(new CXXFunctionSummaryFormat(
         },
         description ? description : "callback summary formatter")));
   }
 
   return retval;
 }
 
 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 =
           llvm::dyn_cast<ScriptSummaryFormat>(m_opaque_sp.get())) {
     const char *ftext = script_summary_ptr->GetPythonScript();
     return (ftext && *ftext != 0);
   }
   return false;
 }
 
 bool SBTypeSummary::IsFunctionName() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBTypeSummary, IsFunctionName);
+
   if (!IsValid())
     return false;
   if (ScriptSummaryFormat *script_summary_ptr =
           llvm::dyn_cast<ScriptSummaryFormat>(m_opaque_sp.get())) {
     const char *ftext = script_summary_ptr->GetPythonScript();
     return (!ftext || *ftext == 0);
   }
   return false;
 }
 
 bool SBTypeSummary::IsSummaryString() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBTypeSummary, IsSummaryString);
+
   if (!IsValid())
     return false;
 
   return m_opaque_sp->GetKind() == TypeSummaryImpl::Kind::eSummaryString;
 }
 
 const char *SBTypeSummary::GetData() {
+  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTypeSummary, GetData);
+
   if (!IsValid())
     return NULL;
   if (ScriptSummaryFormat *script_summary_ptr =
           llvm::dyn_cast<ScriptSummaryFormat>(m_opaque_sp.get())) {
     const char *fname = script_summary_ptr->GetFunctionName();
     const char *ftext = script_summary_ptr->GetPythonScript();
     if (ftext && *ftext)
       return ftext;
     return fname;
   } else if (StringSummaryFormat *string_summary_ptr =
                  llvm::dyn_cast<StringSummaryFormat>(m_opaque_sp.get()))
     return string_summary_ptr->GetSummaryString();
   return nullptr;
 }
 
 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()))
     ChangeSummaryType(false);
   if (StringSummaryFormat *string_summary_ptr =
           llvm::dyn_cast<StringSummaryFormat>(m_opaque_sp.get()))
     string_summary_ptr->SetSummaryString(data);
 }
 
 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()))
     ChangeSummaryType(true);
   if (ScriptSummaryFormat *script_summary_ptr =
           llvm::dyn_cast<ScriptSummaryFormat>(m_opaque_sp.get()))
     script_summary_ptr->SetFunctionName(data);
 }
 
 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()))
     ChangeSummaryType(true);
   if (ScriptSummaryFormat *script_summary_ptr =
           llvm::dyn_cast<ScriptSummaryFormat>(m_opaque_sp.get()))
     script_summary_ptr->SetPythonScript(data);
 }
 
 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 {
     description.Printf("%s\n", m_opaque_sp->GetDescription().c_str());
     return true;
   }
 }
 
 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();
   return m_opaque_sp->DoesPrintValue(value_sp.get());
 }
 
 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;
   }
   return *this;
 }
 
 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())
       return false;
   } else {
     // invalid and valid are different
     if (rhs.IsValid())
       return false;
bool SBTypeSummary::IsEqualTo(lldb::SBTypeSummary &rhs) {
   case TypeSummaryImpl::Kind::eInternal:
     return (m_opaque_sp.get() == rhs.m_opaque_sp.get());
   }
 
   return false;
 }
 
 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::TypeSummaryImplSP SBTypeSummary::GetSP() { return m_opaque_sp; }
 
 void SBTypeSummary::SetSP(const lldb::TypeSummaryImplSP &typesummary_impl_sp) {

lldb/source/API/SBTypeSynthetic.cpp

 //===-- SBTypeSynthetic.cpp -----------------------------------------*- C++
 //-*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-#include "lldb/API/SBTypeSynthetic.h"
+#include "SBReproducerPrivate.h"
 
 #include "lldb/API/SBStream.h"
+#include "lldb/API/SBTypeSynthetic.h"
 
 #include "lldb/DataFormatters/DataVisualization.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 #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, "")));
 }
 
 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)));
 }
 
 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();
   return (code && *code);
 }
 
 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())
     return m_opaque_sp->GetPythonCode();
   else
     return m_opaque_sp->GetPythonClassName();
 }
 
 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;
   }
   return false;
 }
 
 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;
   }
   return *this;
 }
 
 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();
 
   if (m_opaque_sp->IsScripted() != rhs.m_opaque_sp->IsScripted())
     return false;
 
   if (IsClassCode() != rhs.IsClassCode())
     return false;
 
   if (strcmp(GetData(), rhs.GetData()))
     return false;
 
   return GetOptions() == rhs.GetOptions();
 }
 
 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::ScriptedSyntheticChildrenSP SBTypeSynthetic::GetSP() {
   return m_opaque_sp;
 }

lldb/source/API/SBUnixSignals.cpp

 //===-- SBUnixSignals.cpp -------------------------------------------*- C++
 //-*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
+#include "SBReproducerPrivate.h"
+
 #include "lldb/Target/Platform.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/UnixSignals.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/lldb-defines.h"
 
 #include "lldb/API/SBUnixSignals.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) {}
 
 SBUnixSignals::SBUnixSignals(PlatformSP &platform_sp)
     : m_opaque_wp(platform_sp ? platform_sp->GetUnixSignals() : nullptr) {}
 
 const SBUnixSignals &SBUnixSignals::operator=(const SBUnixSignals &rhs) {
+  LLDB_RECORD_METHOD(const lldb::SBUnixSignals &,
+                     SBUnixSignals, operator=,(const lldb::SBUnixSignals &),
+                     rhs);
+
   if (this != &rhs)
     m_opaque_wp = rhs.m_opaque_wp;
   return *this;
 }
 
 SBUnixSignals::~SBUnixSignals() {}
 
 UnixSignalsSP SBUnixSignals::GetSP() const { return m_opaque_wp.lock(); }
 
 void SBUnixSignals::SetSP(const UnixSignalsSP &signals_sp) {
   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);
 
   return nullptr;
 }
 
 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);
 
   return LLDB_INVALID_SIGNAL_NUMBER;
 }
 
 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);
 
   return false;
 }
 
 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();
 
   if (log) {
     log->Printf("SBUnixSignals(%p)::SetShouldSuppress (signo=%d, value=%d)",
                 static_cast<void *>(signals_sp.get()), signo, value);
   }
 
   if (signals_sp)
     return signals_sp->SetShouldSuppress(signo, value);
 
   return false;
 }
 
 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);
 
   return false;
 }
 
 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();
 
   if (log) {
     log->Printf("SBUnixSignals(%p)::SetShouldStop (signo=%d, value=%d)",
                 static_cast<void *>(signals_sp.get()), signo, value);
   }
 
   if (signals_sp)
     return signals_sp->SetShouldStop(signo, value);
 
   return false;
 }
 
 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);
 
   return false;
 }
 
 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();
 
   if (log) {
     log->Printf("SBUnixSignals(%p)::SetShouldNotify (signo=%d, value=%d)",
                 static_cast<void *>(signals_sp.get()), signo, value);
   }
 
   if (signals_sp)
     return signals_sp->SetShouldNotify(signo, value);
 
   return false;
 }
 
 int32_t SBUnixSignals::GetNumSignals() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(int32_t, SBUnixSignals, GetNumSignals);
+
   if (auto signals_sp = GetSP())
     return signals_sp->GetNumSignals();
 
   return -1;
 }
 
 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);
 
   return LLDB_INVALID_SIGNAL_NUMBER;
 }

lldb/source/API/SBValue.cpp

 //===-- SBValue.cpp ---------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
+#include "SBReproducerPrivate.h"
+
 #include "lldb/API/SBValue.h"
 
 #include "lldb/API/SBDeclaration.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/API/SBTypeFilter.h"
 #include "lldb/API/SBTypeFormat.h"
 #include "lldb/API/SBTypeSummary.h"
 #include "lldb/API/SBTypeSynthetic.h"
public:
   Status &GetError() { return m_lock_error; }
 
 private:
   Process::StopLocker m_stop_locker;
   std::unique_lock<std::recursive_mutex> m_lock;
   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);
+  SetSP(value_sp);
+}
 
-SBValue::SBValue(const SBValue &rhs) { SetSP(rhs.m_opaque_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);
   }
   return *this;
 }
 
 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.
   return m_opaque_sp.get() != NULL && m_opaque_sp->IsValid() &&
          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;
   lldb::ValueObjectSP value_sp(GetSP(locker));
   if (value_sp)
     sb_error.SetError(value_sp->GetError());
   else
     sb_error.SetErrorStringWithFormat("error: %s",
                                       locker.GetError().AsCString());
 
   return 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)
     return value_sp->GetID();
   return LLDB_INVALID_UID;
 }
 
 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));
   if (value_sp)
     name = value_sp->GetName().GetCString();
 
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   if (log) {
     if (name)
       log->Printf("SBValue(%p)::GetName () => \"%s\"",
                   static_cast<void *>(value_sp.get()), name);
     else
       log->Printf("SBValue(%p)::GetName () => NULL",
                   static_cast<void *>(value_sp.get()));
   }
 
   return name;
 }
 
 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;
   lldb::ValueObjectSP value_sp(GetSP(locker));
   if (value_sp) {
     name = value_sp->GetQualifiedTypeName().GetCString();
   }
 
   if (log) {
     if (name)
       log->Printf("SBValue(%p)::GetTypeName () => \"%s\"",
                   static_cast<void *>(value_sp.get()), name);
     else
       log->Printf("SBValue(%p)::GetTypeName () => NULL",
                   static_cast<void *>(value_sp.get()));
   }
 
   return name;
 }
 
 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;
   lldb::ValueObjectSP value_sp(GetSP(locker));
   if (value_sp) {
     name = value_sp->GetDisplayTypeName().GetCString();
   }
 
   if (log) {
     if (name)
       log->Printf("SBValue(%p)::GetTypeName () => \"%s\"",
                   static_cast<void *>(value_sp.get()), name);
     else
       log->Printf("SBValue(%p)::GetTypeName () => NULL",
                   static_cast<void *>(value_sp.get()));
   }
 
   return name;
 }
 
 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;
 
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));
   if (value_sp) {
     result = value_sp->GetByteSize();
   }
 
   if (log)
     log->Printf("SBValue(%p)::GetByteSize () => %" PRIu64,
                 static_cast<void *>(value_sp.get()),
                 static_cast<uint64_t>(result));
 
   return result;
 }
 
 bool SBValue::IsInScope() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBValue, IsInScope);
+
   bool result = false;
 
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));
   if (value_sp) {
     result = value_sp->IsInScope();
   }
 
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   if (log)
     log->Printf("SBValue(%p)::IsInScope () => %i",
                 static_cast<void *>(value_sp.get()), result);
 
   return result;
 }
 
 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;
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));
   if (value_sp) {
     cstr = value_sp->GetValueAsCString();
   }
   if (log) {
     if (cstr)
       log->Printf("SBValue(%p)::GetValue() => \"%s\"",
                   static_cast<void *>(value_sp.get()), cstr);
     else
       log->Printf("SBValue(%p)::GetValue() => NULL",
                   static_cast<void *>(value_sp.get()));
   }
 
   return cstr;
 }
 
 ValueType SBValue::GetValueType() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::ValueType, SBValue, GetValueType);
+
   ValueType result = eValueTypeInvalid;
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));
   if (value_sp)
     result = value_sp->GetValueType();
 
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   if (log) {
case eValueTypeVariableThreadLocal:
           static_cast<void *>(value_sp.get()));
       break;
     }
   }
   return result;
 }
 
 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;
   lldb::ValueObjectSP value_sp(GetSP(locker));
   if (value_sp) {
     cstr = value_sp->GetObjectDescription();
   }
   if (log) {
     if (cstr)
       log->Printf("SBValue(%p)::GetObjectDescription() => \"%s\"",
                   static_cast<void *>(value_sp.get()), cstr);
     else
       log->Printf("SBValue(%p)::GetObjectDescription() => NULL",
                   static_cast<void *>(value_sp.get()));
   }
   return cstr;
 }
 
 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;
   lldb::ValueObjectSP value_sp(GetSP(locker));
   if (value_sp) {
     const auto &validation(value_sp->GetValidationStatus());
     if (TypeValidatorResult::Failure == validation.first) {
       if (validation.second.empty())
if (log) {
     else
       log->Printf("SBValue(%p)::GetTypeValidatorResult() => NULL",
                   static_cast<void *>(value_sp.get()));
   }
   return cstr;
 }
 
 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;
   lldb::ValueObjectSP value_sp(GetSP(locker));
   TypeImplSP type_sp;
   if (value_sp) {
     type_sp = std::make_shared<TypeImpl>(value_sp->GetTypeImpl());
     sb_type.SetSP(type_sp);
   }
   if (log) {
     if (type_sp)
       log->Printf("SBValue(%p)::GetType => SBType(%p)",
                   static_cast<void *>(value_sp.get()),
                   static_cast<void *>(type_sp.get()));
     else
       log->Printf("SBValue(%p)::GetType => NULL",
                   static_cast<void *>(value_sp.get()));
   }
   return 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;
   lldb::ValueObjectSP value_sp(GetSP(locker));
   if (value_sp) {
     if (value_sp->UpdateValueIfNeeded(false))
       result = value_sp->GetValueDidChange();
   }
   if (log)
     log->Printf("SBValue(%p)::GetValueDidChange() => %i",
                 static_cast<void *>(value_sp.get()), result);
 
   return result;
 }
 
 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;
   lldb::ValueObjectSP value_sp(GetSP(locker));
   if (value_sp) {
     cstr = value_sp->GetSummaryAsCString();
   }
   if (log) {
     if (cstr)
       log->Printf("SBValue(%p)::GetSummary() => \"%s\"",
                   static_cast<void *>(value_sp.get()), cstr);
     else
       log->Printf("SBValue(%p)::GetSummary() => NULL",
                   static_cast<void *>(value_sp.get()));
   }
   return cstr;
 }
 
 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));
   if (value_sp) {
     std::string buffer;
     if (value_sp->GetSummaryAsCString(buffer, options.ref()) && !buffer.empty())
       stream.Printf("%s", buffer.c_str());
   }
   const char *cstr = stream.GetData();
   if (log) {
     if (cstr)
       log->Printf("SBValue(%p)::GetSummary() => \"%s\"",
                   static_cast<void *>(value_sp.get()), cstr);
     else
       log->Printf("SBValue(%p)::GetSummary() => NULL",
                   static_cast<void *>(value_sp.get()));
   }
   return cstr;
 }
 
 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;
   lldb::ValueObjectSP value_sp(GetSP(locker));
   if (value_sp) {
     cstr = value_sp->GetLocationAsCString();
   }
   if (log) {
     if (cstr)
       log->Printf("SBValue(%p)::GetLocation() => \"%s\"",
                   static_cast<void *>(value_sp.get()), cstr);
     else
       log->Printf("SBValue(%p)::GetLocation() => NULL",
                   static_cast<void *>(value_sp.get()));
   }
   return cstr;
 }
 
 // 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));
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   if (value_sp) {
     success = value_sp->SetValueFromCString(value_str, error.ref());
   } else
     error.SetErrorStringWithFormat("Could not get value: %s",
                                    locker.GetError().AsCString());
 
   if (log)
     log->Printf("SBValue(%p)::SetValueFromCString(\"%s\") => %i",
                 static_cast<void *>(value_sp.get()), value_str, success);
 
   return success;
 }
 
 lldb::SBTypeFormat SBValue::GetTypeFormat() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTypeFormat, SBValue, GetTypeFormat);
+
   lldb::SBTypeFormat format;
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));
   if (value_sp) {
     if (value_sp->UpdateValueIfNeeded(true)) {
       lldb::TypeFormatImplSP format_sp = value_sp->GetValueFormat();
       if (format_sp)
         format.SetSP(format_sp);
     }
   }
   return 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));
   if (value_sp) {
     if (value_sp->UpdateValueIfNeeded(true)) {
       lldb::TypeSummaryImplSP summary_sp = value_sp->GetSummaryFormat();
       if (summary_sp)
         summary.SetSP(summary_sp);
     }
   }
   return 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));
   if (value_sp) {
     if (value_sp->UpdateValueIfNeeded(true)) {
       lldb::SyntheticChildrenSP synthetic_sp = value_sp->GetSyntheticChildren();
 
       if (synthetic_sp && !synthetic_sp->IsScripted()) {
         TypeFilterImplSP filter_sp =
             std::static_pointer_cast<TypeFilterImpl>(synthetic_sp);
         filter.SetSP(filter_sp);
       }
     }
   }
   return 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));
   if (value_sp) {
     if (value_sp->UpdateValueIfNeeded(true)) {
       lldb::SyntheticChildrenSP children_sp = value_sp->GetSyntheticChildren();
 
       if (children_sp && children_sp->IsScripted()) {
         ScriptedSyntheticChildrenSP synth_sp =
             std::static_pointer_cast<ScriptedSyntheticChildren>(children_sp);
         synthetic.SetSP(synth_sp);
       }
     }
   }
   return 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));
   lldb::ValueObjectSP new_value_sp;
   if (value_sp) {
     TypeImplSP type_sp(type.GetSP());
     if (type.IsValid()) {
       sb_value.SetSP(value_sp->GetSyntheticChildAtOffset(
if (log) {
     else
       log->Printf("SBValue(%p)::CreateChildAtOffset => NULL",
                   static_cast<void *>(value_sp.get()));
   }
   return 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));
   TypeImplSP type_sp(type.GetSP());
   if (value_sp && type_sp)
     sb_value.SetSP(value_sp->Cast(type_sp->GetCompilerType(false)),
                    GetPreferDynamicValue(), GetPreferSyntheticValue());
   return sb_value;
 }
 
 lldb::SBValue SBValue::CreateValueFromExpression(const char *name,
                                                  const char *expression) {
+  LLDB_RECORD_METHOD(lldb::SBValue, SBValue, CreateValueFromExpression,
+                     (const char *, const char *), name, expression);
+
   SBExpressionOptions options;
   options.ref().SetKeepInMemory(true);
   return CreateValueFromExpression(name, expression, options);
 }
 
 lldb::SBValue SBValue::CreateValueFromExpression(const char *name,
                                                  const char *expression,
                                                  SBExpressionOptions &options) {
+  LLDB_RECORD_METHOD(lldb::SBValue, SBValue, CreateValueFromExpression,
+                     (const char *, const char *, lldb::SBExpressionOptions &),
+                     name, expression, options);
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   lldb::SBValue sb_value;
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));
   lldb::ValueObjectSP new_value_sp;
   if (value_sp) {
     ExecutionContext exe_ctx(value_sp->GetExecutionContextRef());
     new_value_sp = ValueObject::CreateValueObjectFromExpression(
else
                   static_cast<void *>(value_sp.get()), name, expression);
   }
   return sb_value;
 }
 
 lldb::SBValue SBValue::CreateValueFromAddress(const char *name,
                                               lldb::addr_t address,
                                               SBType sb_type) {
+  LLDB_RECORD_METHOD(lldb::SBValue, SBValue, CreateValueFromAddress,
+                     (const char *, lldb::addr_t, lldb::SBType), name, address,
+                     sb_type);
+
   lldb::SBValue sb_value;
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));
   lldb::ValueObjectSP new_value_sp;
   lldb::TypeImplSP type_impl_sp(sb_type.GetSP());
   if (value_sp && type_impl_sp) {
     CompilerType ast_type(type_impl_sp->GetCompilerType(true));
     ExecutionContext exe_ctx(value_sp->GetExecutionContextRef());
else
       log->Printf("SBValue(%p)::CreateValueFromAddress => NULL",
                   static_cast<void *>(value_sp.get()));
   }
   return sb_value;
 }
 
 lldb::SBValue SBValue::CreateValueFromData(const char *name, SBData data,
                                            SBType sb_type) {
+  LLDB_RECORD_METHOD(lldb::SBValue, SBValue, CreateValueFromData,
+                     (const char *, lldb::SBData, lldb::SBType), name, data,
+                     sb_type);
+
   lldb::SBValue sb_value;
   lldb::ValueObjectSP new_value_sp;
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));
   lldb::TypeImplSP type_impl_sp(sb_type.GetSP());
   if (value_sp && type_impl_sp) {
     ExecutionContext exe_ctx(value_sp->GetExecutionContextRef());
     new_value_sp = ValueObject::CreateValueObjectFromData(
if (log) {
     else
       log->Printf("SBValue(%p)::CreateValueFromData => NULL",
                   static_cast<void *>(value_sp.get()));
   }
   return 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 (m_opaque_sp)
     target_sp = m_opaque_sp->GetTargetSP();
 
   if (target_sp)
     use_dynamic = target_sp->GetPreferDynamicValue();
 
   return GetChildAtIndex(idx, use_dynamic, can_create_synthetic);
 }
 
 SBValue SBValue::GetChildAtIndex(uint32_t idx,
                                  lldb::DynamicValueType use_dynamic,
                                  bool can_create_synthetic) {
+  LLDB_RECORD_METHOD(lldb::SBValue, SBValue, GetChildAtIndex,
+                     (uint32_t, lldb::DynamicValueType, bool), idx, use_dynamic,
+                     can_create_synthetic);
+
   lldb::ValueObjectSP child_sp;
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));
   if (value_sp) {
     const bool can_create = true;
     child_sp = value_sp->GetChildAtIndex(idx, can_create);
     if (can_create_synthetic && !child_sp) {
       child_sp = value_sp->GetSyntheticArrayMember(idx, can_create);
     }
   }
 
   SBValue sb_value;
   sb_value.SetSP(child_sp, use_dynamic, GetPreferSyntheticValue());
   if (log)
     log->Printf("SBValue(%p)::GetChildAtIndex (%u) => SBValue(%p)",
                 static_cast<void *>(value_sp.get()), idx,
                 static_cast<void *>(value_sp.get()));
 
   return 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));
   if (value_sp) {
     idx = value_sp->GetIndexOfChildWithName(ConstString(name));
   }
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   if (log) {
     if (idx == UINT32_MAX)
       log->Printf(
           "SBValue(%p)::GetIndexOfChildWithName (name=\"%s\") => NOT FOUND",
           static_cast<void *>(value_sp.get()), name);
     else
       log->Printf("SBValue(%p)::GetIndexOfChildWithName (name=\"%s\") => %u",
                   static_cast<void *>(value_sp.get()), name, idx);
   }
   return idx;
 }
 
 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)
     target_sp = m_opaque_sp->GetTargetSP();
 
   if (target_sp)
     use_dynamic_value = target_sp->GetPreferDynamicValue();
   return GetChildMemberWithName(name, use_dynamic_value);
 }
 
 SBValue
 SBValue::GetChildMemberWithName(const char *name,
                                 lldb::DynamicValueType use_dynamic_value) {
+  LLDB_RECORD_METHOD(lldb::SBValue, SBValue, GetChildMemberWithName,
+                     (const char *, lldb::DynamicValueType), name,
+                     use_dynamic_value);
+
   lldb::ValueObjectSP child_sp;
   const ConstString str_name(name);
 
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));
   if (value_sp) {
     child_sp = value_sp->GetChildMemberWithName(str_name, true);
   }
 
   SBValue sb_value;
   sb_value.SetSP(child_sp, use_dynamic_value, GetPreferSyntheticValue());
 
   if (log)
     log->Printf(
         "SBValue(%p)::GetChildMemberWithName (name=\"%s\") => SBValue(%p)",
         static_cast<void *>(value_sp.get()), name,
         static_cast<void *>(value_sp.get()));
 
   return 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;
 }
 
 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(),
                                        eNoDynamicValues,
                                        m_opaque_sp->GetUseSynthetic()));
     value_sb.SetSP(proxy_sp);
   }
   return 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;
 }
 
 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)
     return value_sp->IsDynamic();
   return false;
 }
 
 bool SBValue::IsSynthetic() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBValue, IsSynthetic);
+
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));
   if (value_sp)
     return value_sp->IsSynthetic();
   return false;
 }
 
 bool SBValue::IsSyntheticChildrenGenerated() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBValue, IsSyntheticChildrenGenerated);
+
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));
   if (value_sp)
     return value_sp->IsSyntheticChildrenGenerated();
   return false;
 }
 
 void SBValue::SetSyntheticChildrenGenerated(bool is) {
+  LLDB_RECORD_METHOD(void, SBValue, SetSyntheticChildrenGenerated, (bool), is);
+
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));
   if (value_sp)
     return value_sp->SetSyntheticChildrenGenerated(is);
 }
 
 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;
   lldb::ValueObjectSP value_sp(GetSP(locker));
   if (value_sp) {
     // using default values for all the fancy options, just do it if you can
     child_sp = value_sp->GetValueForExpressionPath(expr_path);
   }
 
   SBValue sb_value;
   sb_value.SetSP(child_sp, GetPreferDynamicValue(), GetPreferSyntheticValue());
 
   if (log)
     log->Printf("SBValue(%p)::GetValueForExpressionPath (expr_path=\"%s\") => "
                 "SBValue(%p)",
                 static_cast<void *>(value_sp.get()), expr_path,
                 static_cast<void *>(value_sp.get()));
 
   return sb_value;
 }
 
 int64_t SBValue::GetValueAsSigned(SBError &error, int64_t fail_value) {
+  LLDB_RECORD_METHOD(int64_t, SBValue, GetValueAsSigned,
+                     (lldb::SBError &, int64_t), error, fail_value);
+
   error.Clear();
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));
   if (value_sp) {
     bool success = true;
     uint64_t ret_val = fail_value;
     ret_val = value_sp->GetValueAsSigned(fail_value, &success);
     if (!success)
       error.SetErrorString("could not resolve value");
     return ret_val;
   } else
     error.SetErrorStringWithFormat("could not get SBValue: %s",
                                    locker.GetError().AsCString());
 
   return fail_value;
 }
 
 uint64_t SBValue::GetValueAsUnsigned(SBError &error, uint64_t fail_value) {
+  LLDB_RECORD_METHOD(uint64_t, SBValue, GetValueAsUnsigned,
+                     (lldb::SBError &, uint64_t), error, fail_value);
+
   error.Clear();
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));
   if (value_sp) {
     bool success = true;
     uint64_t ret_val = fail_value;
     ret_val = value_sp->GetValueAsUnsigned(fail_value, &success);
     if (!success)
       error.SetErrorString("could not resolve value");
     return ret_val;
   } else
     error.SetErrorStringWithFormat("could not get SBValue: %s",
                                    locker.GetError().AsCString());
 
   return fail_value;
 }
 
 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) {
     return value_sp->GetValueAsSigned(fail_value);
   }
   return fail_value;
 }
 
 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) {
     return value_sp->GetValueAsUnsigned(fail_value);
   }
   return fail_value;
 }
 
 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;
   lldb::ValueObjectSP value_sp(GetSP(locker));
   if (value_sp)
     has_children = value_sp->MightHaveChildren();
 
   if (log)
     log->Printf("SBValue(%p)::MightHaveChildren() => %i",
                 static_cast<void *>(value_sp.get()), has_children);
   return has_children;
 }
 
 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;
   lldb::ValueObjectSP value_sp(GetSP(locker));
   if (value_sp)
     is_support = value_sp->IsRuntimeSupportValue();
 
   if (log)
     log->Printf("SBValue(%p)::IsRuntimeSupportValue() => %i",
                 static_cast<void *>(value_sp.get()), is_support);
   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));
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));
   if (value_sp)
     num_children = value_sp->GetNumChildren(max);
 
   if (log)
     log->Printf("SBValue(%p)::GetNumChildren (%u) => %u",
                 static_cast<void *>(value_sp.get()), max, num_children);
 
   return num_children;
 }
 
 SBValue SBValue::Dereference() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBValue, SBValue, Dereference);
+
   SBValue sb_value;
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));
   if (value_sp) {
     Status error;
     sb_value = value_sp->Dereference(error);
   }
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   if (log)
     log->Printf("SBValue(%p)::Dereference () => SBValue(%p)",
                 static_cast<void *>(value_sp.get()),
                 static_cast<void *>(value_sp.get()));
 
   return 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)
     return value_sp->GetCompilerType().GetOpaqueQualType();
   return NULL;
 }
 
 lldb::SBTarget SBValue::GetTarget() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTarget, SBValue, GetTarget);
+
   SBTarget sb_target;
   TargetSP target_sp;
   if (m_opaque_sp) {
     target_sp = m_opaque_sp->GetTargetSP();
     sb_target.SetSP(target_sp);
   }
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   if (log) {
     if (target_sp.get() == NULL)
       log->Printf("SBValue(%p)::GetTarget () => NULL",
                   static_cast<void *>(m_opaque_sp.get()));
     else
       log->Printf("SBValue(%p)::GetTarget () => %p",
                   static_cast<void *>(m_opaque_sp.get()),
                   static_cast<void *>(target_sp.get()));
   }
   return 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) {
     process_sp = m_opaque_sp->GetProcessSP();
     sb_process.SetSP(process_sp);
   }
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   if (log) {
     if (process_sp.get() == NULL)
       log->Printf("SBValue(%p)::GetProcess () => NULL",
                   static_cast<void *>(m_opaque_sp.get()));
     else
       log->Printf("SBValue(%p)::GetProcess () => %p",
                   static_cast<void *>(m_opaque_sp.get()),
                   static_cast<void *>(process_sp.get()));
   }
   return 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) {
     thread_sp = m_opaque_sp->GetThreadSP();
     sb_thread.SetThread(thread_sp);
   }
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   if (log) {
     if (thread_sp.get() == NULL)
       log->Printf("SBValue(%p)::GetThread () => NULL",
                   static_cast<void *>(m_opaque_sp.get()));
     else
       log->Printf("SBValue(%p)::GetThread () => %p",
                   static_cast<void *>(m_opaque_sp.get()),
                   static_cast<void *>(thread_sp.get()));
   }
   return 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) {
     frame_sp = m_opaque_sp->GetFrameSP();
     sb_frame.SetFrameSP(frame_sp);
   }
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   if (log) {
lldb::ValueObjectSP SBValue::GetSP(ValueLocker &locker) const {
   if (!m_opaque_sp || !m_opaque_sp->IsValid()) {
     locker.GetError().SetErrorString("No value");
     return ValueObjectSP();
   }
   return locker.GetLockedSP(*m_opaque_sp.get());
 }
 
 lldb::ValueObjectSP SBValue::GetSP() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::ValueObjectSP, SBValue, GetSP);
+
   ValueLocker locker;
   return GetSP(locker);
 }
 
 void SBValue::SetSP(ValueImplSP impl_sp) { m_opaque_sp = impl_sp; }
 
 void SBValue::SetSP(const lldb::ValueObjectSP &sp) {
   if (sp) {

 void SBValue::SetSP(const lldb::ValueObjectSP &sp,
                     lldb::DynamicValueType use_dynamic, bool use_synthetic,
                     const char *name) {
   m_opaque_sp =
       ValueImplSP(new ValueImpl(sp, use_dynamic, use_synthetic, name));
 }
 
 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) {
     value_sp->GetExpressionPath(description.ref(), false);
     return true;
   }
   return false;
 }
 
 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) {
     value_sp->GetExpressionPath(description.ref(), qualify_cxx_base_classes);
     return true;
   }
   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);
 
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));
   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();
   if (!target_sp) {
     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());
   ExecutionContext exe_ctx(target_sp.get());
 
   StackFrame *frame = exe_ctx.GetFramePtr();
   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;
   ExpressionResults expr_res = target_sp->EvaluateExpression(
       expr, frame, res_val_sp, options.ref(), nullptr, value_sp.get());
 
   if (name)
     res_val_sp->SetName(ConstString(name));
 
   LLDB_LOG(log,
            "SBValue(Name=\"{0}\")::EvaluateExpression (expr=\"{1}\") => "
            "SBValue(Success={2}) (execution result={3})",
            value_sp->GetName(), expr, res_val_sp->GetError().Success(),
            expr_res);
 
   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::ValueObjectSP value_sp(GetSP(locker));
   if (value_sp)
     value_sp->Dump(strm);
   else
     strm.PutCString("No value");
 
   return true;
 }
 
 lldb::Format SBValue::GetFormat() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::Format, SBValue, GetFormat);
+
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));
   if (value_sp)
     return value_sp->GetFormat();
   return eFormatDefault;
 }
 
 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)
     value_sp->SetFormat(format);
 }
 
 lldb::SBValue SBValue::AddressOf() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBValue, SBValue, AddressOf);
+
   SBValue sb_value;
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));
   if (value_sp) {
     Status error;
     sb_value.SetSP(value_sp->AddressOf(error), GetPreferDynamicValue(),
                    GetPreferSyntheticValue());
   }
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   if (log)
     log->Printf("SBValue(%p)::AddressOf () => SBValue(%p)",
                 static_cast<void *>(value_sp.get()),
                 static_cast<void *>(value_sp.get()));
 
   return 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));
   if (value_sp) {
     TargetSP target_sp(value_sp->GetTargetSP());
     if (target_sp) {
       const bool scalar_is_load_address = true;
       AddressType addr_type;
lldb::addr_t SBValue::GetLoadAddress() {
   if (log)
     log->Printf("SBValue(%p)::GetLoadAddress () => (%" PRIu64 ")",
                 static_cast<void *>(value_sp.get()), value);
 
   return value;
 }
 
 lldb::SBAddress SBValue::GetAddress() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBAddress, SBValue, GetAddress);
+
   Address addr;
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));
   if (value_sp) {
     TargetSP target_sp(value_sp->GetTargetSP());
     if (target_sp) {
       lldb::addr_t value = LLDB_INVALID_ADDRESS;
       const bool scalar_is_load_address = true;
log->Printf("SBValue(%p)::GetAddress () => (%s,%" PRIu64 ")",
                 static_cast<void *>(value_sp.get()),
                 (addr.GetSection() ? addr.GetSection()->GetName().GetCString()
                                    : "NULL"),
                 addr.GetOffset());
   return 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;
   lldb::ValueObjectSP value_sp(GetSP(locker));
   if (value_sp) {
     TargetSP target_sp(value_sp->GetTargetSP());
     if (target_sp) {
       DataExtractorSP data_sp(new DataExtractor());
       value_sp->GetPointeeData(*data_sp, item_idx, item_count);
       if (data_sp->GetByteSize() > 0)
         *sb_data = data_sp;
     }
   }
   if (log)
     log->Printf("SBValue(%p)::GetPointeeData (%d, %d) => SBData(%p)",
                 static_cast<void *>(value_sp.get()), item_idx, item_count,
                 static_cast<void *>(sb_data.get()));
 
   return 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;
   lldb::ValueObjectSP value_sp(GetSP(locker));
   if (value_sp) {
     DataExtractorSP data_sp(new DataExtractor());
     Status error;
     value_sp->GetData(*data_sp, error);
     if (error.Success())
       *sb_data = data_sp;
   }
   if (log)
     log->Printf("SBValue(%p)::GetData () => SBData(%p)",
                 static_cast<void *>(value_sp.get()),
                 static_cast<void *>(sb_data.get()));
 
   return 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));
   bool ret = true;
 
   if (value_sp) {
     DataExtractor *data_extractor = data.get();
 
bool SBValue::SetData(lldb::SBData &data, SBError &error) {
   if (log)
     log->Printf("SBValue(%p)::SetData (%p) => %s",
                 static_cast<void *>(value_sp.get()),
                 static_cast<void *>(data.get()), ret ? "true" : "false");
   return ret;
 }
 
 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) {
     Declaration decl;
     if (value_sp->GetDeclaration(decl))
       decl_sb.SetDeclaration(decl);
   }
   return decl_sb;
 }
 
 lldb::SBWatchpoint SBValue::Watch(bool resolve_location, bool read, bool write,
                                   SBError &error) {
+  LLDB_RECORD_METHOD(lldb::SBWatchpoint, SBValue, Watch,
+                     (bool, bool, bool, lldb::SBError &), resolve_location,
+                     read, write, error);
+
   SBWatchpoint sb_watchpoint;
 
   // If the SBValue is not valid, there's no point in even trying to watch it.
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));
   TargetSP target_sp(GetTarget().GetSP());
   if (value_sp && target_sp) {
     // Read and Write cannot both be false.
lldb::SBWatchpoint SBValue::Watch(bool resolve_location, bool read, bool write,
   return sb_watchpoint;
 }
 
 // FIXME: Remove this method impl (as well as the decl in .h) once it is no
 // longer needed.
 // 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);
 }
 
 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;
 }
 
 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;
 }

lldb/source/API/SBValueList.cpp

 //===-- SBValueList.cpp -----------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBValueList.h"
+#include "SBReproducerPrivate.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/API/SBValue.h"
 #include "lldb/Core/ValueObjectList.h"
 #include "lldb/Utility/Log.h"
 
 #include <vector>
 
 using namespace lldb;
lldb::SBValue GetFirstValueByName(const char *name) const {
     }
     return lldb::SBValue();
   }
 
 private:
   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())
     m_opaque_up.reset(new ValueListImpl(*rhs));
 
   if (log) {
     log->Printf(
         "SBValueList::SBValueList (rhs.ap=%p) => this.ap = %p",
if (log) {
     log->Printf("SBValueList::SBValueList (lldb_object_ptr=%p) => this.ap = %p",
                 static_cast<const void *>(lldb_object_ptr),
                 static_cast<void *>(m_opaque_up.get()));
   }
 }
 
 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));
     else
       m_opaque_up.reset();
   }
   return *this;
 }
 
 ValueListImpl *SBValueList::operator->() { return m_opaque_up.get(); }
 
 ValueListImpl &SBValueList::operator*() { return *m_opaque_up; }
 
 const ValueListImpl *SBValueList::operator->() const {
   return m_opaque_up.get();
 }
 
 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(lldb::ValueObjectSP &val_obj_sp) {
   if (val_obj_sp) {
     CreateIfNeeded();
     m_opaque_up->Append(SBValue(val_obj_sp));
   }
 }
 
 void SBValueList::Append(const lldb::SBValueList &value_list) {
+  LLDB_RECORD_METHOD(void, SBValueList, Append, (const lldb::SBValueList &),
+                     value_list);
+
   if (value_list.IsValid()) {
     CreateIfNeeded();
     m_opaque_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)
   //    log->Printf ("SBValueList::GetValueAtIndex (uint32_t idx) idx = %d",
   //    idx);
 
   SBValue sb_value;
   if (m_opaque_up)
     sb_value = m_opaque_up->GetValueAtIndex(idx);
 
   if (log) {
     SBStream sstr;
     sb_value.GetDescription(sstr);
     log->Printf("SBValueList::GetValueAtIndex (this.ap=%p, idx=%d) => SBValue "
                 "(this.sp = %p, '%s')",
                 static_cast<void *>(m_opaque_up.get()), idx,
                 static_cast<void *>(sb_value.GetSP().get()), sstr.GetData());
   }
 
   return 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)
   //    log->Printf ("SBValueList::GetSize ()");
 
   uint32_t size = 0;
   if (m_opaque_up)
     size = m_opaque_up->GetSize();
 
   if (log)
     log->Printf("SBValueList::GetSize (this.ap=%p) => %d",
                 static_cast<void *>(m_opaque_up.get()), size);
 
   return size;
 }
 
 void SBValueList::CreateIfNeeded() {
   if (m_opaque_up == NULL)
     m_opaque_up.reset(new ValueListImpl());
 }
 
 SBValue SBValueList::FindValueObjectByUID(lldb::user_id_t uid) {
+  LLDB_RECORD_METHOD(lldb::SBValue, SBValueList, FindValueObjectByUID,
+                     (lldb::user_id_t), uid);
+
   SBValue sb_value;
   if (m_opaque_up)
     sb_value = m_opaque_up->FindValueByUID(uid);
   return 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;
 }
 
 void *SBValueList::opaque_ptr() { return m_opaque_up.get(); }
 
 ValueListImpl &SBValueList::ref() {
   CreateIfNeeded();
   return *m_opaque_up;
 }

lldb/source/API/SBVariablesOptions.cpp

 //===-- SBVariablesOptions.cpp --------------------------------------*- C++
 //-*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBVariablesOptions.h"
+#include "SBReproducerPrivate.h"
 #include "lldb/API/SBTarget.h"
 #include "lldb/Target/Target.h"
 
 #include "lldb/lldb-private.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
private:
   bool m_include_statics : 1;
   bool m_in_scope_only : 1;
   bool m_include_runtime_support_values : 1;
   LazyBool m_include_recognized_arguments; // can be overridden with a setting
   lldb::DynamicValueType m_use_dynamic;
 };
 
 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);
 }
 
 VariablesOptionsImpl *SBVariablesOptions::operator->() {
   return m_opaque_up.operator->();
 }
 
 const VariablesOptionsImpl *SBVariablesOptions::operator->() const {

lldb/source/API/SBWatchpoint.cpp

 //===-- SBWatchpoint.cpp --------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
+#include "SBReproducerPrivate.h"
+
 #include "lldb/API/SBWatchpoint.h"
 #include "lldb/API/SBAddress.h"
 #include "lldb/API/SBDebugger.h"
 #include "lldb/API/SBDefines.h"
 #include "lldb/API/SBEvent.h"
 #include "lldb/API/SBStream.h"
 
 #include "lldb/Breakpoint/Watchpoint.h"
 #include "lldb/Breakpoint/WatchpointList.h"
 #include "lldb/Core/StreamFile.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/Stream.h"
 #include "lldb/lldb-defines.h"
 #include "lldb/lldb-types.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) {
     SBStream sstr;
     GetDescription(sstr, lldb::eDescriptionLevelBrief);
     LLDB_LOG(log, "watchpoint = {0} ({1})", wp_sp.get(), sstr.GetData());
   }
 }
 
 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;
   lldb::WatchpointSP watchpoint_sp(GetSP());
   if (watchpoint_sp)
     watch_id = watchpoint_sp->GetID();
 
   if (log) {
     if (watch_id == LLDB_INVALID_WATCH_ID)
       log->Printf("SBWatchpoint(%p)::GetID () => LLDB_INVALID_WATCH_ID",
                   static_cast<void *>(watchpoint_sp.get()));
     else
       log->Printf("SBWatchpoint(%p)::GetID () => %u",
                   static_cast<void *>(watchpoint_sp.get()), 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;
 }
 
 int32_t SBWatchpoint::GetHardwareIndex() {
+  LLDB_RECORD_METHOD_NO_ARGS(int32_t, SBWatchpoint, GetHardwareIndex);
+
   int32_t hw_index = -1;
 
   lldb::WatchpointSP watchpoint_sp(GetSP());
   if (watchpoint_sp) {
     std::lock_guard<std::recursive_mutex> guard(
         watchpoint_sp->GetTarget().GetAPIMutex());
     hw_index = watchpoint_sp->GetHardwareIndex();
   }
 
   return hw_index;
 }
 
 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());
   if (watchpoint_sp) {
     std::lock_guard<std::recursive_mutex> guard(
         watchpoint_sp->GetTarget().GetAPIMutex());
     ret_addr = watchpoint_sp->GetLoadAddress();
   }
 
   return ret_addr;
 }
 
 size_t SBWatchpoint::GetWatchSize() {
+  LLDB_RECORD_METHOD_NO_ARGS(size_t, SBWatchpoint, GetWatchSize);
+
   size_t watch_size = 0;
 
   lldb::WatchpointSP watchpoint_sp(GetSP());
   if (watchpoint_sp) {
     std::lock_guard<std::recursive_mutex> guard(
         watchpoint_sp->GetTarget().GetAPIMutex());
     watch_size = watchpoint_sp->GetByteSize();
   }
 
   return watch_size;
 }
 
 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();
     std::lock_guard<std::recursive_mutex> guard(target.GetAPIMutex());
     ProcessSP process_sp = target.GetProcessSP();
     const bool notify = true;
     if (process_sp) {
       if (enabled)
         process_sp->EnableWatchpoint(watchpoint_sp.get(), notify);
       else
         process_sp->DisableWatchpoint(watchpoint_sp.get(), notify);
     } else {
       watchpoint_sp->SetEnabled(enabled, notify);
     }
   }
 }
 
 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(
         watchpoint_sp->GetTarget().GetAPIMutex());
     return watchpoint_sp->IsEnabled();
   } else
     return false;
 }
 
 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) {
     std::lock_guard<std::recursive_mutex> guard(
         watchpoint_sp->GetTarget().GetAPIMutex());
     count = watchpoint_sp->GetHitCount();
   }
 
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   if (log)
     log->Printf("SBWatchpoint(%p)::GetHitCount () => %u",
                 static_cast<void *>(watchpoint_sp.get()), count);
 
   return count;
 }
 
 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(
         watchpoint_sp->GetTarget().GetAPIMutex());
     return watchpoint_sp->GetIgnoreCount();
   } else
     return 0;
 }
 
 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(
         watchpoint_sp->GetTarget().GetAPIMutex());
     watchpoint_sp->SetIgnoreCount(n);
   }
 }
 
 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(
         watchpoint_sp->GetTarget().GetAPIMutex());
     return watchpoint_sp->GetConditionText();
   }
   return NULL;
 }
 
 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(
         watchpoint_sp->GetTarget().GetAPIMutex());
     watchpoint_sp->SetCondition(condition);
   }
 }
 
 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());
   if (watchpoint_sp) {
     std::lock_guard<std::recursive_mutex> guard(
         watchpoint_sp->GetTarget().GetAPIMutex());
     watchpoint_sp->GetDescription(&strm, level);
     strm.EOL();
   } else
     strm.PutCString("No value");
 
   return true;
 }
 
-void SBWatchpoint::Clear() { m_opaque_wp.reset(); }
+void SBWatchpoint::Clear() {
+  LLDB_RECORD_METHOD_NO_ARGS(void, SBWatchpoint, Clear);
+  m_opaque_wp.reset();
+}
 
-lldb::WatchpointSP SBWatchpoint::GetSP() const { return m_opaque_wp.lock(); }
+lldb::WatchpointSP SBWatchpoint::GetSP() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::WatchpointSP, SBWatchpoint, GetSP);
+  return m_opaque_wp.lock();
+}
 
-void SBWatchpoint::SetSP(const lldb::WatchpointSP &sp) { m_opaque_wp = sp; }
+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());
   return eWatchpointEventTypeInvalidType;
 }
 
 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;
 }