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

1 files changed, 119 insertions, 339 deletions

diff --git a/lldb/source/API/SBProcess.cpp b/lldb/source/API/SBProcess.cpp
index 797e19462800..2538013412b6 100644
--- a/lldb/source/API/SBProcess.cpp
+++ b/lldb/source/API/SBProcess.cpp
@@ -7,7 +7,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBProcess.h"
-#include "SBReproducerPrivate.h"
+#include "lldb/Utility/Instrumentation.h"
 
 #include <cinttypes>
 
@@ -49,42 +49,38 @@
 using namespace lldb;
 using namespace lldb_private;
 
-SBProcess::SBProcess() : m_opaque_wp() {
-  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBProcess);
-}
+SBProcess::SBProcess() { LLDB_INSTRUMENT_VA(this); }
 
 // SBProcess constructor
 
 SBProcess::SBProcess(const SBProcess &rhs) : m_opaque_wp(rhs.m_opaque_wp) {
-  LLDB_RECORD_CONSTRUCTOR(SBProcess, (const lldb::SBProcess &), rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 }
 
 SBProcess::SBProcess(const lldb::ProcessSP &process_sp)
     : m_opaque_wp(process_sp) {
-  LLDB_RECORD_CONSTRUCTOR(SBProcess, (const lldb::ProcessSP &), process_sp);
+  LLDB_INSTRUMENT_VA(this, process_sp);
 }
 
 const SBProcess &SBProcess::operator=(const SBProcess &rhs) {
-  LLDB_RECORD_METHOD(const lldb::SBProcess &,
-                     SBProcess, operator=,(const lldb::SBProcess &), rhs);
+  LLDB_INSTRUMENT_VA(this, rhs);
 
   if (this != &rhs)
     m_opaque_wp = rhs.m_opaque_wp;
-  return LLDB_RECORD_RESULT(*this);
+  return *this;
 }
 
 // Destructor
 SBProcess::~SBProcess() = default;
 
 const char *SBProcess::GetBroadcasterClassName() {
-  LLDB_RECORD_STATIC_METHOD_NO_ARGS(const char *, SBProcess,
-                                    GetBroadcasterClassName);
+  LLDB_INSTRUMENT();
 
   return Process::GetStaticBroadcasterClass().AsCString();
 }
 
 const char *SBProcess::GetPluginName() {
-  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBProcess, GetPluginName);
+  LLDB_INSTRUMENT_VA(this);
 
   ProcessSP process_sp(GetSP());
   if (process_sp) {
@@ -94,7 +90,7 @@ const char *SBProcess::GetPluginName() {
 }
 
 const char *SBProcess::GetShortPluginName() {
-  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBProcess, GetShortPluginName);
+  LLDB_INSTRUMENT_VA(this);
 
   ProcessSP process_sp(GetSP());
   if (process_sp) {
@@ -108,17 +104,17 @@ lldb::ProcessSP SBProcess::GetSP() const { return m_opaque_wp.lock(); }
 void SBProcess::SetSP(const ProcessSP &process_sp) { m_opaque_wp = process_sp; }
 
 void SBProcess::Clear() {
-  LLDB_RECORD_METHOD_NO_ARGS(void, SBProcess, Clear);
+  LLDB_INSTRUMENT_VA(this);
 
   m_opaque_wp.reset();
 }
 
 bool SBProcess::IsValid() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBProcess, IsValid);
+  LLDB_INSTRUMENT_VA(this);
   return this->operator bool();
 }
 SBProcess::operator bool() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBProcess, operator bool);
+  LLDB_INSTRUMENT_VA(this);
 
   ProcessSP process_sp(m_opaque_wp.lock());
   return ((bool)process_sp && process_sp->IsValid());
@@ -130,11 +126,7 @@ bool SBProcess::RemoteLaunch(char const **argv, char const **envp,
                              const char *working_directory,
                              uint32_t launch_flags, bool stop_at_entry,
                              lldb::SBError &error) {
-  LLDB_RECORD_METHOD(bool, SBProcess, RemoteLaunch,
-                     (const char **, const char **, const char *, const char *,
-                      const char *, const char *, uint32_t, bool,
-                      lldb::SBError &),
-                     argv, envp, stdin_path, stdout_path, stderr_path,
+  LLDB_INSTRUMENT_VA(this, argv, envp, stdin_path, stdout_path, stderr_path,
                      working_directory, launch_flags, stop_at_entry, error);
 
   ProcessSP process_sp(GetSP());
@@ -167,8 +159,7 @@ bool SBProcess::RemoteLaunch(char const **argv, char const **envp,
 
 bool SBProcess::RemoteAttachToProcessWithID(lldb::pid_t pid,
                                             lldb::SBError &error) {
-  LLDB_RECORD_METHOD(bool, SBProcess, RemoteAttachToProcessWithID,
-                     (lldb::pid_t, lldb::SBError &), pid, error);
+  LLDB_INSTRUMENT_VA(this, pid, error);
 
   ProcessSP process_sp(GetSP());
   if (process_sp) {
@@ -190,7 +181,7 @@ bool SBProcess::RemoteAttachToProcessWithID(lldb::pid_t pid,
 }
 
 uint32_t SBProcess::GetNumThreads() {
-  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBProcess, GetNumThreads);
+  LLDB_INSTRUMENT_VA(this);
 
   uint32_t num_threads = 0;
   ProcessSP process_sp(GetSP());
@@ -207,8 +198,7 @@ uint32_t SBProcess::GetNumThreads() {
 }
 
 SBThread SBProcess::GetSelectedThread() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBThread, SBProcess,
-                                   GetSelectedThread);
+  LLDB_INSTRUMENT_VA(this);
 
   SBThread sb_thread;
   ThreadSP thread_sp;
@@ -220,13 +210,12 @@ SBThread SBProcess::GetSelectedThread() const {
     sb_thread.SetThread(thread_sp);
   }
 
-  return LLDB_RECORD_RESULT(sb_thread);
+  return sb_thread;
 }
 
 SBThread SBProcess::CreateOSPluginThread(lldb::tid_t tid,
                                          lldb::addr_t context) {
-  LLDB_RECORD_METHOD(lldb::SBThread, SBProcess, CreateOSPluginThread,
-                     (lldb::tid_t, lldb::addr_t), tid, context);
+  LLDB_INSTRUMENT_VA(this, tid, context);
 
   SBThread sb_thread;
   ThreadSP thread_sp;
@@ -238,11 +227,11 @@ SBThread SBProcess::CreateOSPluginThread(lldb::tid_t tid,
     sb_thread.SetThread(thread_sp);
   }
 
-  return LLDB_RECORD_RESULT(sb_thread);
+  return sb_thread;
 }
 
 SBTarget SBProcess::GetTarget() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBTarget, SBProcess, GetTarget);
+  LLDB_INSTRUMENT_VA(this);
 
   SBTarget sb_target;
   TargetSP target_sp;
@@ -252,12 +241,11 @@ SBTarget SBProcess::GetTarget() const {
     sb_target.SetSP(target_sp);
   }
 
-  return LLDB_RECORD_RESULT(sb_target);
+  return sb_target;
 }
 
 size_t SBProcess::PutSTDIN(const char *src, size_t src_len) {
-  LLDB_RECORD_METHOD(size_t, SBProcess, PutSTDIN, (const char *, size_t), src,
-                     src_len);
+  LLDB_INSTRUMENT_VA(this, src, src_len);
 
   size_t ret_val = 0;
   ProcessSP process_sp(GetSP());
@@ -270,8 +258,7 @@ size_t SBProcess::PutSTDIN(const char *src, size_t src_len) {
 }
 
 size_t SBProcess::GetSTDOUT(char *dst, size_t dst_len) const {
-  LLDB_RECORD_CHAR_PTR_METHOD_CONST(size_t, SBProcess, GetSTDOUT,
-                                    (char *, size_t), dst, "", dst_len);
+  LLDB_INSTRUMENT_VA(this, dst, dst_len);
 
   size_t bytes_read = 0;
   ProcessSP process_sp(GetSP());
@@ -284,8 +271,7 @@ size_t SBProcess::GetSTDOUT(char *dst, size_t dst_len) const {
 }
 
 size_t SBProcess::GetSTDERR(char *dst, size_t dst_len) const {
-  LLDB_RECORD_CHAR_PTR_METHOD_CONST(size_t, SBProcess, GetSTDERR,
-                                    (char *, size_t), dst, "", dst_len);
+  LLDB_INSTRUMENT_VA(this, dst, dst_len);
 
   size_t bytes_read = 0;
   ProcessSP process_sp(GetSP());
@@ -298,8 +284,7 @@ size_t SBProcess::GetSTDERR(char *dst, size_t dst_len) const {
 }
 
 size_t SBProcess::GetAsyncProfileData(char *dst, size_t dst_len) const {
-  LLDB_RECORD_CHAR_PTR_METHOD_CONST(size_t, SBProcess, GetAsyncProfileData,
-                                    (char *, size_t), dst, "", dst_len);
+  LLDB_INSTRUMENT_VA(this, dst, dst_len);
 
   size_t bytes_read = 0;
   ProcessSP process_sp(GetSP());
@@ -312,23 +297,20 @@ size_t SBProcess::GetAsyncProfileData(char *dst, size_t dst_len) const {
 }
 
 void SBProcess::ReportEventState(const SBEvent &event, SBFile out) const {
-  LLDB_RECORD_METHOD_CONST(void, SBProcess, ReportEventState,
-                           (const SBEvent &, SBFile), event, out);
+  LLDB_INSTRUMENT_VA(this, event, out);
 
   return ReportEventState(event, out.m_opaque_sp);
 }
 
 void SBProcess::ReportEventState(const SBEvent &event, FILE *out) const {
-  LLDB_RECORD_METHOD_CONST(void, SBProcess, ReportEventState,
-                           (const lldb::SBEvent &, FILE *), event, out);
+  LLDB_INSTRUMENT_VA(this, event, out);
   FileSP outfile = std::make_shared<NativeFile>(out, false);
   return ReportEventState(event, outfile);
 }
 
 void SBProcess::ReportEventState(const SBEvent &event, FileSP out) const {
 
-  LLDB_RECORD_METHOD_CONST(void, SBProcess, ReportEventState,
-                           (const SBEvent &, FileSP), event, out);
+  LLDB_INSTRUMENT_VA(this, event, out);
 
   if (!out || !out->IsValid())
     return;
@@ -344,9 +326,7 @@ void SBProcess::ReportEventState(const SBEvent &event, FileSP out) const {
 
 void SBProcess::AppendEventStateReport(const SBEvent &event,
                                        SBCommandReturnObject &result) {
-  LLDB_RECORD_METHOD(void, SBProcess, AppendEventStateReport,
-                     (const lldb::SBEvent &, lldb::SBCommandReturnObject &),
-                     event, result);
+  LLDB_INSTRUMENT_VA(this, event, result);
 
   ProcessSP process_sp(GetSP());
   if (process_sp) {
@@ -360,8 +340,7 @@ void SBProcess::AppendEventStateReport(const SBEvent &event,
 }
 
 bool SBProcess::SetSelectedThread(const SBThread &thread) {
-  LLDB_RECORD_METHOD(bool, SBProcess, SetSelectedThread,
-                     (const lldb::SBThread &), thread);
+  LLDB_INSTRUMENT_VA(this, thread);
 
   ProcessSP process_sp(GetSP());
   if (process_sp) {
@@ -374,9 +353,7 @@ bool SBProcess::SetSelectedThread(const SBThread &thread) {
 }
 
 bool SBProcess::SetSelectedThreadByID(lldb::tid_t tid) {
-  LLDB_RECORD_METHOD(bool, SBProcess, SetSelectedThreadByID, (lldb::tid_t),
-                     tid);
-
+  LLDB_INSTRUMENT_VA(this, tid);
 
   bool ret_val = false;
   ProcessSP process_sp(GetSP());
@@ -390,8 +367,7 @@ bool SBProcess::SetSelectedThreadByID(lldb::tid_t tid) {
 }
 
 bool SBProcess::SetSelectedThreadByIndexID(uint32_t index_id) {
-  LLDB_RECORD_METHOD(bool, SBProcess, SetSelectedThreadByIndexID, (uint32_t),
-                     index_id);
+  LLDB_INSTRUMENT_VA(this, index_id);
 
   bool ret_val = false;
   ProcessSP process_sp(GetSP());
@@ -406,8 +382,7 @@ bool SBProcess::SetSelectedThreadByIndexID(uint32_t index_id) {
 }
 
 SBThread SBProcess::GetThreadAtIndex(size_t index) {
-  LLDB_RECORD_METHOD(lldb::SBThread, SBProcess, GetThreadAtIndex, (size_t),
-                     index);
+  LLDB_INSTRUMENT_VA(this, index);
 
   SBThread sb_thread;
   ThreadSP thread_sp;
@@ -421,11 +396,11 @@ SBThread SBProcess::GetThreadAtIndex(size_t index) {
     sb_thread.SetThread(thread_sp);
   }
 
-  return LLDB_RECORD_RESULT(sb_thread);
+  return sb_thread;
 }
 
 uint32_t SBProcess::GetNumQueues() {
-  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBProcess, GetNumQueues);
+  LLDB_INSTRUMENT_VA(this);
 
   uint32_t num_queues = 0;
   ProcessSP process_sp(GetSP());
@@ -442,8 +417,7 @@ uint32_t SBProcess::GetNumQueues() {
 }
 
 SBQueue SBProcess::GetQueueAtIndex(size_t index) {
-  LLDB_RECORD_METHOD(lldb::SBQueue, SBProcess, GetQueueAtIndex, (size_t),
-                     index);
+  LLDB_INSTRUMENT_VA(this, index);
 
   SBQueue sb_queue;
   QueueSP queue_sp;
@@ -458,12 +432,11 @@ SBQueue SBProcess::GetQueueAtIndex(size_t index) {
     }
   }
 
-  return LLDB_RECORD_RESULT(sb_queue);
+  return sb_queue;
 }
 
 uint32_t SBProcess::GetStopID(bool include_expression_stops) {
-  LLDB_RECORD_METHOD(uint32_t, SBProcess, GetStopID, (bool),
-                     include_expression_stops);
+  LLDB_INSTRUMENT_VA(this, include_expression_stops);
 
   ProcessSP process_sp(GetSP());
   if (process_sp) {
@@ -478,8 +451,7 @@ uint32_t SBProcess::GetStopID(bool include_expression_stops) {
 }
 
 SBEvent SBProcess::GetStopEventForStopID(uint32_t stop_id) {
-  LLDB_RECORD_METHOD(lldb::SBEvent, SBProcess, GetStopEventForStopID,
-                     (uint32_t), stop_id);
+  LLDB_INSTRUMENT_VA(this, stop_id);
 
   SBEvent sb_event;
   EventSP event_sp;
@@ -491,11 +463,11 @@ SBEvent SBProcess::GetStopEventForStopID(uint32_t stop_id) {
     sb_event.reset(event_sp);
   }
 
-  return LLDB_RECORD_RESULT(sb_event);
+  return sb_event;
 }
 
 StateType SBProcess::GetState() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::StateType, SBProcess, GetState);
+  LLDB_INSTRUMENT_VA(this);
 
   StateType ret_val = eStateInvalid;
   ProcessSP process_sp(GetSP());
@@ -509,7 +481,7 @@ StateType SBProcess::GetState() {
 }
 
 int SBProcess::GetExitStatus() {
-  LLDB_RECORD_METHOD_NO_ARGS(int, SBProcess, GetExitStatus);
+  LLDB_INSTRUMENT_VA(this);
 
   int exit_status = 0;
   ProcessSP process_sp(GetSP());
@@ -523,7 +495,7 @@ int SBProcess::GetExitStatus() {
 }
 
 const char *SBProcess::GetExitDescription() {
-  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBProcess, GetExitDescription);
+  LLDB_INSTRUMENT_VA(this);
 
   const char *exit_desc = nullptr;
   ProcessSP process_sp(GetSP());
@@ -536,7 +508,7 @@ const char *SBProcess::GetExitDescription() {
 }
 
 lldb::pid_t SBProcess::GetProcessID() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::pid_t, SBProcess, GetProcessID);
+  LLDB_INSTRUMENT_VA(this);
 
   lldb::pid_t ret_val = LLDB_INVALID_PROCESS_ID;
   ProcessSP process_sp(GetSP());
@@ -547,7 +519,7 @@ lldb::pid_t SBProcess::GetProcessID() {
 }
 
 uint32_t SBProcess::GetUniqueID() {
-  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBProcess, GetUniqueID);
+  LLDB_INSTRUMENT_VA(this);
 
   uint32_t ret_val = 0;
   ProcessSP process_sp(GetSP());
@@ -557,7 +529,7 @@ uint32_t SBProcess::GetUniqueID() {
 }
 
 ByteOrder SBProcess::GetByteOrder() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::ByteOrder, SBProcess, GetByteOrder);
+  LLDB_INSTRUMENT_VA(this);
 
   ByteOrder byteOrder = eByteOrderInvalid;
   ProcessSP process_sp(GetSP());
@@ -569,7 +541,7 @@ ByteOrder SBProcess::GetByteOrder() const {
 }
 
 uint32_t SBProcess::GetAddressByteSize() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBProcess, GetAddressByteSize);
+  LLDB_INSTRUMENT_VA(this);
 
   uint32_t size = 0;
   ProcessSP process_sp(GetSP());
@@ -581,7 +553,7 @@ uint32_t SBProcess::GetAddressByteSize() const {
 }
 
 SBError SBProcess::Continue() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBProcess, Continue);
+  LLDB_INSTRUMENT_VA(this);
 
   SBError sb_error;
   ProcessSP process_sp(GetSP());
@@ -597,11 +569,11 @@ SBError SBProcess::Continue() {
   } else
     sb_error.SetErrorString("SBProcess is invalid");
 
-  return LLDB_RECORD_RESULT(sb_error);
+  return sb_error;
 }
 
 SBError SBProcess::Destroy() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBProcess, Destroy);
+  LLDB_INSTRUMENT_VA(this);
 
   SBError sb_error;
   ProcessSP process_sp(GetSP());
@@ -612,11 +584,11 @@ SBError SBProcess::Destroy() {
   } else
     sb_error.SetErrorString("SBProcess is invalid");
 
-  return LLDB_RECORD_RESULT(sb_error);
+  return sb_error;
 }
 
 SBError SBProcess::Stop() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBProcess, Stop);
+  LLDB_INSTRUMENT_VA(this);
 
   SBError sb_error;
   ProcessSP process_sp(GetSP());
@@ -627,11 +599,11 @@ SBError SBProcess::Stop() {
   } else
     sb_error.SetErrorString("SBProcess is invalid");
 
-  return LLDB_RECORD_RESULT(sb_error);
+  return sb_error;
 }
 
 SBError SBProcess::Kill() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBProcess, Kill);
+  LLDB_INSTRUMENT_VA(this);
 
   SBError sb_error;
   ProcessSP process_sp(GetSP());
@@ -642,19 +614,19 @@ SBError SBProcess::Kill() {
   } else
     sb_error.SetErrorString("SBProcess is invalid");
 
-  return LLDB_RECORD_RESULT(sb_error);
+  return sb_error;
 }
 
 SBError SBProcess::Detach() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBProcess, Detach);
+  LLDB_INSTRUMENT_VA(this);
 
   // FIXME: This should come from a process default.
   bool keep_stopped = false;
-  return LLDB_RECORD_RESULT(Detach(keep_stopped));
+  return Detach(keep_stopped);
 }
 
 SBError SBProcess::Detach(bool keep_stopped) {
-  LLDB_RECORD_METHOD(lldb::SBError, SBProcess, Detach, (bool), keep_stopped);
+  LLDB_INSTRUMENT_VA(this, keep_stopped);
 
   SBError sb_error;
   ProcessSP process_sp(GetSP());
@@ -665,11 +637,11 @@ SBError SBProcess::Detach(bool keep_stopped) {
   } else
     sb_error.SetErrorString("SBProcess is invalid");
 
-  return LLDB_RECORD_RESULT(sb_error);
+  return sb_error;
 }
 
 SBError SBProcess::Signal(int signo) {
-  LLDB_RECORD_METHOD(lldb::SBError, SBProcess, Signal, (int), signo);
+  LLDB_INSTRUMENT_VA(this, signo);
 
   SBError sb_error;
   ProcessSP process_sp(GetSP());
@@ -680,20 +652,20 @@ SBError SBProcess::Signal(int signo) {
   } else
     sb_error.SetErrorString("SBProcess is invalid");
 
-  return LLDB_RECORD_RESULT(sb_error);
+  return sb_error;
 }
 
 SBUnixSignals SBProcess::GetUnixSignals() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBUnixSignals, SBProcess, GetUnixSignals);
+  LLDB_INSTRUMENT_VA(this);
 
   if (auto process_sp = GetSP())
-    return LLDB_RECORD_RESULT(SBUnixSignals{process_sp});
+    return SBUnixSignals{process_sp};
 
-  return LLDB_RECORD_RESULT(SBUnixSignals{});
+  return SBUnixSignals{};
 }
 
 void SBProcess::SendAsyncInterrupt() {
-  LLDB_RECORD_METHOD_NO_ARGS(void, SBProcess, SendAsyncInterrupt);
+  LLDB_INSTRUMENT_VA(this);
 
   ProcessSP process_sp(GetSP());
   if (process_sp) {
@@ -702,8 +674,7 @@ void SBProcess::SendAsyncInterrupt() {
 }
 
 SBThread SBProcess::GetThreadByID(tid_t tid) {
-  LLDB_RECORD_METHOD(lldb::SBThread, SBProcess, GetThreadByID, (lldb::tid_t),
-                     tid);
+  LLDB_INSTRUMENT_VA(this, tid);
 
   SBThread sb_thread;
   ThreadSP thread_sp;
@@ -717,12 +688,11 @@ SBThread SBProcess::GetThreadByID(tid_t tid) {
     sb_thread.SetThread(thread_sp);
   }
 
-  return LLDB_RECORD_RESULT(sb_thread);
+  return sb_thread;
 }
 
 SBThread SBProcess::GetThreadByIndexID(uint32_t index_id) {
-  LLDB_RECORD_METHOD(lldb::SBThread, SBProcess, GetThreadByIndexID, (uint32_t),
-                     index_id);
+  LLDB_INSTRUMENT_VA(this, index_id);
 
   SBThread sb_thread;
   ThreadSP thread_sp;
@@ -737,12 +707,11 @@ SBThread SBProcess::GetThreadByIndexID(uint32_t index_id) {
     sb_thread.SetThread(thread_sp);
   }
 
-  return LLDB_RECORD_RESULT(sb_thread);
+  return sb_thread;
 }
 
 StateType SBProcess::GetStateFromEvent(const SBEvent &event) {
-  LLDB_RECORD_STATIC_METHOD(lldb::StateType, SBProcess, GetStateFromEvent,
-                            (const lldb::SBEvent &), event);
+  LLDB_INSTRUMENT_VA(event);
 
   StateType ret_val = Process::ProcessEventData::GetStateFromEvent(event.get());
 
@@ -750,8 +719,7 @@ StateType SBProcess::GetStateFromEvent(const SBEvent &event) {
 }
 
 bool SBProcess::GetRestartedFromEvent(const SBEvent &event) {
-  LLDB_RECORD_STATIC_METHOD(bool, SBProcess, GetRestartedFromEvent,
-                            (const lldb::SBEvent &), event);
+  LLDB_INSTRUMENT_VA(event);
 
   bool ret_val = Process::ProcessEventData::GetRestartedFromEvent(event.get());
 
@@ -759,8 +727,7 @@ bool SBProcess::GetRestartedFromEvent(const SBEvent &event) {
 }
 
 size_t SBProcess::GetNumRestartedReasonsFromEvent(const lldb::SBEvent &event) {
-  LLDB_RECORD_STATIC_METHOD(size_t, SBProcess, GetNumRestartedReasonsFromEvent,
-                            (const lldb::SBEvent &), event);
+  LLDB_INSTRUMENT_VA(event);
 
   return Process::ProcessEventData::GetNumRestartedReasons(event.get());
 }
@@ -768,16 +735,13 @@ size_t SBProcess::GetNumRestartedReasonsFromEvent(const lldb::SBEvent &event) {
 const char *
 SBProcess::GetRestartedReasonAtIndexFromEvent(const lldb::SBEvent &event,
                                               size_t idx) {
-  LLDB_RECORD_STATIC_METHOD(const char *, SBProcess,
-                            GetRestartedReasonAtIndexFromEvent,
-                            (const lldb::SBEvent &, size_t), event, idx);
+  LLDB_INSTRUMENT_VA(event, idx);
 
   return Process::ProcessEventData::GetRestartedReasonAtIndex(event.get(), idx);
 }
 
 SBProcess SBProcess::GetProcessFromEvent(const SBEvent &event) {
-  LLDB_RECORD_STATIC_METHOD(lldb::SBProcess, SBProcess, GetProcessFromEvent,
-                            (const lldb::SBEvent &), event);
+  LLDB_INSTRUMENT_VA(event);
 
   ProcessSP process_sp =
       Process::ProcessEventData::GetProcessFromEvent(event.get());
@@ -786,36 +750,31 @@ SBProcess SBProcess::GetProcessFromEvent(const SBEvent &event) {
     process_sp = EventDataStructuredData::GetProcessFromEvent(event.get());
   }
 
-  return LLDB_RECORD_RESULT(SBProcess(process_sp));
+  return SBProcess(process_sp);
 }
 
 bool SBProcess::GetInterruptedFromEvent(const SBEvent &event) {
-  LLDB_RECORD_STATIC_METHOD(bool, SBProcess, GetInterruptedFromEvent,
-                            (const lldb::SBEvent &), event);
+  LLDB_INSTRUMENT_VA(event);
 
   return Process::ProcessEventData::GetInterruptedFromEvent(event.get());
 }
 
 lldb::SBStructuredData
 SBProcess::GetStructuredDataFromEvent(const lldb::SBEvent &event) {
-  LLDB_RECORD_STATIC_METHOD(lldb::SBStructuredData, SBProcess,
-                            GetStructuredDataFromEvent, (const lldb::SBEvent &),
-                            event);
+  LLDB_INSTRUMENT_VA(event);
 
-  return LLDB_RECORD_RESULT(SBStructuredData(event.GetSP()));
+  return SBStructuredData(event.GetSP());
 }
 
 bool SBProcess::EventIsProcessEvent(const SBEvent &event) {
-  LLDB_RECORD_STATIC_METHOD(bool, SBProcess, EventIsProcessEvent,
-                            (const lldb::SBEvent &), event);
+  LLDB_INSTRUMENT_VA(event);
 
   return (event.GetBroadcasterClass() == SBProcess::GetBroadcasterClass()) &&
          !EventIsStructuredDataEvent(event);
 }
 
 bool SBProcess::EventIsStructuredDataEvent(const lldb::SBEvent &event) {
-  LLDB_RECORD_STATIC_METHOD(bool, SBProcess, EventIsStructuredDataEvent,
-                            (const lldb::SBEvent &), event);
+  LLDB_INSTRUMENT_VA(event);
 
   EventSP event_sp = event.GetSP();
   EventData *event_data = event_sp ? event_sp->GetData() : nullptr;
@@ -824,30 +783,24 @@ bool SBProcess::EventIsStructuredDataEvent(const lldb::SBEvent &event) {
 }
 
 SBBroadcaster SBProcess::GetBroadcaster() const {
-  LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBBroadcaster, SBProcess,
-                                   GetBroadcaster);
-
+  LLDB_INSTRUMENT_VA(this);
 
   ProcessSP process_sp(GetSP());
 
   SBBroadcaster broadcaster(process_sp.get(), false);
 
-
-  return LLDB_RECORD_RESULT(broadcaster);
+  return broadcaster;
 }
 
 const char *SBProcess::GetBroadcasterClass() {
-  LLDB_RECORD_STATIC_METHOD_NO_ARGS(const char *, SBProcess,
-                                    GetBroadcasterClass);
+  LLDB_INSTRUMENT();
 
   return Process::GetStaticBroadcasterClass().AsCString();
 }
 
 size_t SBProcess::ReadMemory(addr_t addr, void *dst, size_t dst_len,
                              SBError &sb_error) {
-  LLDB_RECORD_DUMMY(size_t, SBProcess, ReadMemory,
-                    (lldb::addr_t, void *, size_t, lldb::SBError &), addr, dst,
-                    dst_len, sb_error);
+  LLDB_INSTRUMENT_VA(this, addr, dst, dst_len, sb_error);
 
   size_t bytes_read = 0;
 
@@ -872,9 +825,7 @@ size_t SBProcess::ReadMemory(addr_t addr, void *dst, size_t dst_len,
 
 size_t SBProcess::ReadCStringFromMemory(addr_t addr, void *buf, size_t size,
                                         lldb::SBError &sb_error) {
-  LLDB_RECORD_DUMMY(size_t, SBProcess, ReadCStringFromMemory,
-                    (lldb::addr_t, void *, size_t, lldb::SBError &), addr, buf,
-                    size, sb_error);
+  LLDB_INSTRUMENT_VA(this, addr, buf, size, sb_error);
 
   size_t bytes_read = 0;
   ProcessSP process_sp(GetSP());
@@ -896,9 +847,7 @@ size_t SBProcess::ReadCStringFromMemory(addr_t addr, void *buf, size_t size,
 
 uint64_t SBProcess::ReadUnsignedFromMemory(addr_t addr, uint32_t byte_size,
                                            lldb::SBError &sb_error) {
-  LLDB_RECORD_METHOD(uint64_t, SBProcess, ReadUnsignedFromMemory,
-                     (lldb::addr_t, uint32_t, lldb::SBError &), addr, byte_size,
-                     sb_error);
+  LLDB_INSTRUMENT_VA(this, addr, byte_size, sb_error);
 
   uint64_t value = 0;
   ProcessSP process_sp(GetSP());
@@ -920,8 +869,7 @@ uint64_t SBProcess::ReadUnsignedFromMemory(addr_t addr, uint32_t byte_size,
 
 lldb::addr_t SBProcess::ReadPointerFromMemory(addr_t addr,
                                               lldb::SBError &sb_error) {
-  LLDB_RECORD_METHOD(lldb::addr_t, SBProcess, ReadPointerFromMemory,
-                     (lldb::addr_t, lldb::SBError &), addr, sb_error);
+  LLDB_INSTRUMENT_VA(this, addr, sb_error);
 
   lldb::addr_t ptr = LLDB_INVALID_ADDRESS;
   ProcessSP process_sp(GetSP());
@@ -942,9 +890,7 @@ lldb::addr_t SBProcess::ReadPointerFromMemory(addr_t addr,
 
 size_t SBProcess::WriteMemory(addr_t addr, const void *src, size_t src_len,
                               SBError &sb_error) {
-  LLDB_RECORD_DUMMY(size_t, SBProcess, WriteMemory,
-                    (lldb::addr_t, const void *, size_t, lldb::SBError &), addr,
-                    src, src_len, sb_error);
+  LLDB_INSTRUMENT_VA(this, addr, src, src_len, sb_error);
 
   size_t bytes_written = 0;
 
@@ -966,8 +912,7 @@ size_t SBProcess::WriteMemory(addr_t addr, const void *src, size_t src_len,
 }
 
 bool SBProcess::GetDescription(SBStream &description) {
-  LLDB_RECORD_METHOD(bool, SBProcess, GetDescription, (lldb::SBStream &),
-                     description);
+  LLDB_INSTRUMENT_VA(this, description);
 
   Stream &strm = description.ref();
 
@@ -991,34 +936,31 @@ bool SBProcess::GetDescription(SBStream &description) {
 }
 
 SBStructuredData SBProcess::GetExtendedCrashInformation() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBStructuredData, SBProcess,
-                             GetExtendedCrashInformation);
+  LLDB_INSTRUMENT_VA(this);
   SBStructuredData data;
   ProcessSP process_sp(GetSP());
   if (!process_sp)
-    return LLDB_RECORD_RESULT(data);
+    return data;
 
   PlatformSP platform_sp = process_sp->GetTarget().GetPlatform();
 
   if (!platform_sp)
-    return LLDB_RECORD_RESULT(data);
+    return data;
 
   auto expected_data =
       platform_sp->FetchExtendedCrashInformation(*process_sp.get());
 
   if (!expected_data)
-    return LLDB_RECORD_RESULT(data);
+    return data;
 
   StructuredData::ObjectSP fetched_data = *expected_data;
   data.m_impl_up->SetObjectSP(fetched_data);
-  return LLDB_RECORD_RESULT(data);
+  return data;
 }
 
 uint32_t
 SBProcess::GetNumSupportedHardwareWatchpoints(lldb::SBError &sb_error) const {
-  LLDB_RECORD_METHOD_CONST(uint32_t, SBProcess,
-                           GetNumSupportedHardwareWatchpoints,
-                           (lldb::SBError &), sb_error);
+  LLDB_INSTRUMENT_VA(this, sb_error);
 
   uint32_t num = 0;
   ProcessSP process_sp(GetSP());
@@ -1034,9 +976,7 @@ SBProcess::GetNumSupportedHardwareWatchpoints(lldb::SBError &sb_error) const {
 
 uint32_t SBProcess::LoadImage(lldb::SBFileSpec &sb_remote_image_spec,
                               lldb::SBError &sb_error) {
-  LLDB_RECORD_METHOD(uint32_t, SBProcess, LoadImage,
-                     (lldb::SBFileSpec &, lldb::SBError &),
-                     sb_remote_image_spec, sb_error);
+  LLDB_INSTRUMENT_VA(this, sb_remote_image_spec, sb_error);
 
   return LoadImage(SBFileSpec(), sb_remote_image_spec, sb_error);
 }
@@ -1044,10 +984,7 @@ uint32_t SBProcess::LoadImage(lldb::SBFileSpec &sb_remote_image_spec,
 uint32_t SBProcess::LoadImage(const lldb::SBFileSpec &sb_local_image_spec,
                               const lldb::SBFileSpec &sb_remote_image_spec,
                               lldb::SBError &sb_error) {
-  LLDB_RECORD_METHOD(
-      uint32_t, SBProcess, LoadImage,
-      (const lldb::SBFileSpec &, const lldb::SBFileSpec &, lldb::SBError &),
-      sb_local_image_spec, sb_remote_image_spec, sb_error);
+  LLDB_INSTRUMENT_VA(this, sb_local_image_spec, sb_remote_image_spec, sb_error);
 
   ProcessSP process_sp(GetSP());
   if (process_sp) {
@@ -1071,10 +1008,7 @@ uint32_t SBProcess::LoadImageUsingPaths(const lldb::SBFileSpec &image_spec,
                                         SBStringList &paths,
                                         lldb::SBFileSpec &loaded_path,
                                         lldb::SBError &error) {
-  LLDB_RECORD_METHOD(uint32_t, SBProcess, LoadImageUsingPaths,
-                     (const lldb::SBFileSpec &, lldb::SBStringList &,
-                      lldb::SBFileSpec &, lldb::SBError &),
-                     image_spec, paths, loaded_path, error);
+  LLDB_INSTRUMENT_VA(this, image_spec, paths, loaded_path, error);
 
   ProcessSP process_sp(GetSP());
   if (process_sp) {
@@ -1106,8 +1040,7 @@ uint32_t SBProcess::LoadImageUsingPaths(const lldb::SBFileSpec &image_spec,
 }
 
 lldb::SBError SBProcess::UnloadImage(uint32_t image_token) {
-  LLDB_RECORD_METHOD(lldb::SBError, SBProcess, UnloadImage, (uint32_t),
-                     image_token);
+  LLDB_INSTRUMENT_VA(this, image_token);
 
   lldb::SBError sb_error;
   ProcessSP process_sp(GetSP());
@@ -1124,12 +1057,11 @@ lldb::SBError SBProcess::UnloadImage(uint32_t image_token) {
     }
   } else
     sb_error.SetErrorString("invalid process");
-  return LLDB_RECORD_RESULT(sb_error);
+  return sb_error;
 }
 
 lldb::SBError SBProcess::SendEventData(const char *event_data) {
-  LLDB_RECORD_METHOD(lldb::SBError, SBProcess, SendEventData, (const char *),
-                     event_data);
+  LLDB_INSTRUMENT_VA(this, event_data);
 
   lldb::SBError sb_error;
   ProcessSP process_sp(GetSP());
@@ -1144,11 +1076,11 @@ lldb::SBError SBProcess::SendEventData(const char *event_data) {
     }
   } else
     sb_error.SetErrorString("invalid process");
-  return LLDB_RECORD_RESULT(sb_error);
+  return sb_error;
 }
 
 uint32_t SBProcess::GetNumExtendedBacktraceTypes() {
-  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBProcess, GetNumExtendedBacktraceTypes);
+  LLDB_INSTRUMENT_VA(this);
 
   ProcessSP process_sp(GetSP());
   if (process_sp && process_sp->GetSystemRuntime()) {
@@ -1159,8 +1091,7 @@ uint32_t SBProcess::GetNumExtendedBacktraceTypes() {
 }
 
 const char *SBProcess::GetExtendedBacktraceTypeAtIndex(uint32_t idx) {
-  LLDB_RECORD_METHOD(const char *, SBProcess, GetExtendedBacktraceTypeAtIndex,
-                     (uint32_t), idx);
+  LLDB_INSTRUMENT_VA(this, idx);
 
   ProcessSP process_sp(GetSP());
   if (process_sp && process_sp->GetSystemRuntime()) {
@@ -1175,21 +1106,19 @@ const char *SBProcess::GetExtendedBacktraceTypeAtIndex(uint32_t idx) {
 }
 
 SBThreadCollection SBProcess::GetHistoryThreads(addr_t addr) {
-  LLDB_RECORD_METHOD(lldb::SBThreadCollection, SBProcess, GetHistoryThreads,
-                     (lldb::addr_t), addr);
+  LLDB_INSTRUMENT_VA(this, addr);
 
   ProcessSP process_sp(GetSP());
   SBThreadCollection threads;
   if (process_sp) {
     threads = SBThreadCollection(process_sp->GetHistoryThreads(addr));
   }
-  return LLDB_RECORD_RESULT(threads);
+  return threads;
 }
 
 bool SBProcess::IsInstrumentationRuntimePresent(
     InstrumentationRuntimeType type) {
-  LLDB_RECORD_METHOD(bool, SBProcess, IsInstrumentationRuntimePresent,
-                     (lldb::InstrumentationRuntimeType), type);
+  LLDB_INSTRUMENT_VA(this, type);
 
   ProcessSP process_sp(GetSP());
   if (!process_sp)
@@ -1208,14 +1137,13 @@ bool SBProcess::IsInstrumentationRuntimePresent(
 }
 
 lldb::SBError SBProcess::SaveCore(const char *file_name) {
-  LLDB_RECORD_METHOD(lldb::SBError, SBProcess, SaveCore, (const char *),
-                     file_name);
+  LLDB_INSTRUMENT_VA(this, file_name);
 
   lldb::SBError error;
   ProcessSP process_sp(GetSP());
   if (!process_sp) {
     error.SetErrorString("SBProcess is invalid");
-    return LLDB_RECORD_RESULT(error);
+    return error;
   }
 
   std::lock_guard<std::recursive_mutex> guard(
@@ -1223,21 +1151,19 @@ lldb::SBError SBProcess::SaveCore(const char *file_name) {
 
   if (process_sp->GetState() != eStateStopped) {
     error.SetErrorString("the process is not stopped");
-    return LLDB_RECORD_RESULT(error);
+    return error;
   }
 
   FileSpec core_file(file_name);
   SaveCoreStyle core_style = SaveCoreStyle::eSaveCoreFull;
   error.ref() = PluginManager::SaveCore(process_sp, core_file, core_style, "");
-  return LLDB_RECORD_RESULT(error);
+  return error;
 }
 
 lldb::SBError
 SBProcess::GetMemoryRegionInfo(lldb::addr_t load_addr,
                                SBMemoryRegionInfo &sb_region_info) {
-  LLDB_RECORD_METHOD(lldb::SBError, SBProcess, GetMemoryRegionInfo,
-                     (lldb::addr_t, lldb::SBMemoryRegionInfo &), load_addr,
-                     sb_region_info);
+  LLDB_INSTRUMENT_VA(this, load_addr, sb_region_info);
 
   lldb::SBError sb_error;
   ProcessSP process_sp(GetSP());
@@ -1255,12 +1181,11 @@ SBProcess::GetMemoryRegionInfo(lldb::addr_t load_addr,
   } else {
     sb_error.SetErrorString("SBProcess is invalid");
   }
-  return LLDB_RECORD_RESULT(sb_error);
+  return sb_error;
 }
 
 lldb::SBMemoryRegionInfoList SBProcess::GetMemoryRegions() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBMemoryRegionInfoList, SBProcess,
-                             GetMemoryRegions);
+  LLDB_INSTRUMENT_VA(this);
 
   lldb::SBMemoryRegionInfoList sb_region_list;
 
@@ -1273,11 +1198,11 @@ lldb::SBMemoryRegionInfoList SBProcess::GetMemoryRegions() {
     process_sp->GetMemoryRegions(sb_region_list.ref());
   }
 
-  return LLDB_RECORD_RESULT(sb_region_list);
+  return sb_region_list;
 }
 
 lldb::SBProcessInfo SBProcess::GetProcessInfo() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBProcessInfo, SBProcess, GetProcessInfo);
+  LLDB_INSTRUMENT_VA(this);
 
   lldb::SBProcessInfo sb_proc_info;
   ProcessSP process_sp(GetSP());
@@ -1285,14 +1210,12 @@ lldb::SBProcessInfo SBProcess::GetProcessInfo() {
   if (process_sp && process_sp->GetProcessInfo(proc_info)) {
     sb_proc_info.SetProcessInfo(proc_info);
   }
-  return LLDB_RECORD_RESULT(sb_proc_info);
+  return sb_proc_info;
 }
 
 lldb::addr_t SBProcess::AllocateMemory(size_t size, uint32_t permissions,
                                        lldb::SBError &sb_error) {
-  LLDB_RECORD_METHOD(lldb::addr_t, SBProcess, AllocateMemory,
-                     (size_t, uint32_t, lldb::SBError &), size, permissions,
-                     sb_error);
+  LLDB_INSTRUMENT_VA(this, size, permissions, sb_error);
 
   lldb::addr_t addr = LLDB_INVALID_ADDRESS;
   ProcessSP process_sp(GetSP());
@@ -1312,8 +1235,7 @@ lldb::addr_t SBProcess::AllocateMemory(size_t size, uint32_t permissions,
 }
 
 lldb::SBError SBProcess::DeallocateMemory(lldb::addr_t ptr) {
-  LLDB_RECORD_METHOD(lldb::SBError, SBProcess, DeallocateMemory, (lldb::addr_t),
-                     ptr);
+  LLDB_INSTRUMENT_VA(this, ptr);
 
   lldb::SBError sb_error;
   ProcessSP process_sp(GetSP());
@@ -1332,145 +1254,3 @@ lldb::SBError SBProcess::DeallocateMemory(lldb::addr_t ptr) {
   }
   return sb_error;
 }
-
-namespace lldb_private {
-namespace repro {
-
-template <>
-void RegisterMethods<SBProcess>(Registry &R) {
-  LLDB_REGISTER_CONSTRUCTOR(SBProcess, ());
-  LLDB_REGISTER_CONSTRUCTOR(SBProcess, (const lldb::SBProcess &));
-  LLDB_REGISTER_CONSTRUCTOR(SBProcess, (const lldb::ProcessSP &));
-  LLDB_REGISTER_METHOD(const lldb::SBProcess &,
-                       SBProcess, operator=,(const lldb::SBProcess &));
-  LLDB_REGISTER_STATIC_METHOD(const char *, SBProcess,
-                              GetBroadcasterClassName, ());
-  LLDB_REGISTER_METHOD(const char *, SBProcess, GetPluginName, ());
-  LLDB_REGISTER_METHOD(const char *, SBProcess, GetShortPluginName, ());
-  LLDB_REGISTER_METHOD(void, SBProcess, Clear, ());
-  LLDB_REGISTER_METHOD_CONST(bool, SBProcess, IsValid, ());
-  LLDB_REGISTER_METHOD_CONST(bool, SBProcess, operator bool, ());
-  LLDB_REGISTER_METHOD(bool, SBProcess, RemoteLaunch,
-                       (const char **, const char **, const char *,
-                        const char *, const char *, const char *, uint32_t,
-                        bool, lldb::SBError &));
-  LLDB_REGISTER_METHOD(bool, SBProcess, RemoteAttachToProcessWithID,
-                       (lldb::pid_t, lldb::SBError &));
-  LLDB_REGISTER_METHOD(uint32_t, SBProcess, GetNumThreads, ());
-  LLDB_REGISTER_METHOD_CONST(lldb::SBThread, SBProcess, GetSelectedThread,
-                             ());
-  LLDB_REGISTER_METHOD(lldb::SBThread, SBProcess, CreateOSPluginThread,
-                       (lldb::tid_t, lldb::addr_t));
-  LLDB_REGISTER_METHOD_CONST(lldb::SBTarget, SBProcess, GetTarget, ());
-  LLDB_REGISTER_METHOD(size_t, SBProcess, PutSTDIN, (const char *, size_t));
-  LLDB_REGISTER_METHOD_CONST(void, SBProcess, ReportEventState,
-                             (const lldb::SBEvent &, FILE *));
-  LLDB_REGISTER_METHOD_CONST(void, SBProcess, ReportEventState,
-                             (const lldb::SBEvent &, FileSP));
-  LLDB_REGISTER_METHOD_CONST(void, SBProcess, ReportEventState,
-                             (const lldb::SBEvent &, SBFile));
-  LLDB_REGISTER_METHOD(
-      void, SBProcess, AppendEventStateReport,
-      (const lldb::SBEvent &, lldb::SBCommandReturnObject &));
-  LLDB_REGISTER_METHOD(bool, SBProcess, SetSelectedThread,
-                       (const lldb::SBThread &));
-  LLDB_REGISTER_METHOD(bool, SBProcess, SetSelectedThreadByID, (lldb::tid_t));
-  LLDB_REGISTER_METHOD(bool, SBProcess, SetSelectedThreadByIndexID,
-                       (uint32_t));
-  LLDB_REGISTER_METHOD(lldb::SBThread, SBProcess, GetThreadAtIndex, (size_t));
-  LLDB_REGISTER_METHOD(uint32_t, SBProcess, GetNumQueues, ());
-  LLDB_REGISTER_METHOD(lldb::SBQueue, SBProcess, GetQueueAtIndex, (size_t));
-  LLDB_REGISTER_METHOD(uint32_t, SBProcess, GetStopID, (bool));
-  LLDB_REGISTER_METHOD(lldb::SBEvent, SBProcess, GetStopEventForStopID,
-                       (uint32_t));
-  LLDB_REGISTER_METHOD(lldb::StateType, SBProcess, GetState, ());
-  LLDB_REGISTER_METHOD(int, SBProcess, GetExitStatus, ());
-  LLDB_REGISTER_METHOD(const char *, SBProcess, GetExitDescription, ());
-  LLDB_REGISTER_METHOD(lldb::pid_t, SBProcess, GetProcessID, ());
-  LLDB_REGISTER_METHOD(uint32_t, SBProcess, GetUniqueID, ());
-  LLDB_REGISTER_METHOD_CONST(lldb::ByteOrder, SBProcess, GetByteOrder, ());
-  LLDB_REGISTER_METHOD_CONST(uint32_t, SBProcess, GetAddressByteSize, ());
-  LLDB_REGISTER_METHOD(lldb::SBError, SBProcess, Continue, ());
-  LLDB_REGISTER_METHOD(lldb::SBError, SBProcess, Destroy, ());
-  LLDB_REGISTER_METHOD(lldb::SBError, SBProcess, Stop, ());
-  LLDB_REGISTER_METHOD(lldb::SBError, SBProcess, Kill, ());
-  LLDB_REGISTER_METHOD(lldb::SBError, SBProcess, Detach, ());
-  LLDB_REGISTER_METHOD(lldb::SBError, SBProcess, Detach, (bool));
-  LLDB_REGISTER_METHOD(lldb::SBError, SBProcess, Signal, (int));
-  LLDB_REGISTER_METHOD(lldb::SBUnixSignals, SBProcess, GetUnixSignals, ());
-  LLDB_REGISTER_METHOD(void, SBProcess, SendAsyncInterrupt, ());
-  LLDB_REGISTER_METHOD(lldb::SBThread, SBProcess, GetThreadByID,
-                       (lldb::tid_t));
-  LLDB_REGISTER_METHOD(lldb::SBThread, SBProcess, GetThreadByIndexID,
-                       (uint32_t));
-  LLDB_REGISTER_STATIC_METHOD(lldb::StateType, SBProcess, GetStateFromEvent,
-                              (const lldb::SBEvent &));
-  LLDB_REGISTER_STATIC_METHOD(bool, SBProcess, GetRestartedFromEvent,
-                              (const lldb::SBEvent &));
-  LLDB_REGISTER_STATIC_METHOD(size_t, SBProcess,
-                              GetNumRestartedReasonsFromEvent,
-                              (const lldb::SBEvent &));
-  LLDB_REGISTER_STATIC_METHOD(const char *, SBProcess,
-                              GetRestartedReasonAtIndexFromEvent,
-                              (const lldb::SBEvent &, size_t));
-  LLDB_REGISTER_STATIC_METHOD(lldb::SBProcess, SBProcess, GetProcessFromEvent,
-                              (const lldb::SBEvent &));
-  LLDB_REGISTER_STATIC_METHOD(bool, SBProcess, GetInterruptedFromEvent,
-                              (const lldb::SBEvent &));
-  LLDB_REGISTER_STATIC_METHOD(lldb::SBStructuredData, SBProcess,
-                              GetStructuredDataFromEvent,
-                              (const lldb::SBEvent &));
-  LLDB_REGISTER_STATIC_METHOD(bool, SBProcess, EventIsProcessEvent,
-                              (const lldb::SBEvent &));
-  LLDB_REGISTER_STATIC_METHOD(bool, SBProcess, EventIsStructuredDataEvent,
-                              (const lldb::SBEvent &));
-  LLDB_REGISTER_METHOD_CONST(lldb::SBBroadcaster, SBProcess, GetBroadcaster,
-                             ());
-  LLDB_REGISTER_STATIC_METHOD(const char *, SBProcess, GetBroadcasterClass,
-                              ());
-  LLDB_REGISTER_METHOD(uint64_t, SBProcess, ReadUnsignedFromMemory,
-                       (lldb::addr_t, uint32_t, lldb::SBError &));
-  LLDB_REGISTER_METHOD(lldb::addr_t, SBProcess, ReadPointerFromMemory,
-                       (lldb::addr_t, lldb::SBError &));
-  LLDB_REGISTER_METHOD(bool, SBProcess, GetDescription, (lldb::SBStream &));
-  LLDB_REGISTER_METHOD(lldb::SBStructuredData, SBProcess,
-                       GetExtendedCrashInformation, ());
-  LLDB_REGISTER_METHOD_CONST(uint32_t, SBProcess,
-                             GetNumSupportedHardwareWatchpoints,
-                             (lldb::SBError &));
-  LLDB_REGISTER_METHOD(uint32_t, SBProcess, LoadImage,
-                       (lldb::SBFileSpec &, lldb::SBError &));
-  LLDB_REGISTER_METHOD(
-      uint32_t, SBProcess, LoadImage,
-      (const lldb::SBFileSpec &, const lldb::SBFileSpec &, lldb::SBError &));
-  LLDB_REGISTER_METHOD(uint32_t, SBProcess, LoadImageUsingPaths,
-                       (const lldb::SBFileSpec &, lldb::SBStringList &,
-                        lldb::SBFileSpec &, lldb::SBError &));
-  LLDB_REGISTER_METHOD(lldb::SBError, SBProcess, UnloadImage, (uint32_t));
-  LLDB_REGISTER_METHOD(lldb::SBError, SBProcess, SendEventData,
-                       (const char *));
-  LLDB_REGISTER_METHOD(uint32_t, SBProcess, GetNumExtendedBacktraceTypes, ());
-  LLDB_REGISTER_METHOD(const char *, SBProcess,
-                       GetExtendedBacktraceTypeAtIndex, (uint32_t));
-  LLDB_REGISTER_METHOD(lldb::SBThreadCollection, SBProcess, GetHistoryThreads,
-                       (lldb::addr_t));
-  LLDB_REGISTER_METHOD(bool, SBProcess, IsInstrumentationRuntimePresent,
-                       (lldb::InstrumentationRuntimeType));
-  LLDB_REGISTER_METHOD(lldb::SBError, SBProcess, SaveCore, (const char *));
-  LLDB_REGISTER_METHOD(lldb::SBError, SBProcess, GetMemoryRegionInfo,
-                       (lldb::addr_t, lldb::SBMemoryRegionInfo &));
-  LLDB_REGISTER_METHOD(lldb::SBMemoryRegionInfoList, SBProcess,
-                       GetMemoryRegions, ());
-  LLDB_REGISTER_METHOD(lldb::SBProcessInfo, SBProcess, GetProcessInfo, ());
-  LLDB_REGISTER_METHOD(lldb::addr_t, SBProcess, AllocateMemory,
-                       (size_t, uint32_t, lldb::SBError &));
-  LLDB_REGISTER_METHOD(lldb::SBError, SBProcess, DeallocateMemory,
-                       (lldb::addr_t));
-
-  LLDB_REGISTER_CHAR_PTR_METHOD_CONST(size_t, SBProcess, GetSTDOUT);
-  LLDB_REGISTER_CHAR_PTR_METHOD_CONST(size_t, SBProcess, GetSTDERR);
-  LLDB_REGISTER_CHAR_PTR_METHOD_CONST(size_t, SBProcess, GetAsyncProfileData);
-}
-
-}
-}