1 files changed, 406 insertions, 414 deletions

diff --git a/source/API/SBProcess.cpp b/source/API/SBProcess.cpp
index cb1124607ec01..4226ff77ecdc3 100644
--- a/source/API/SBProcess.cpp
+++ b/source/API/SBProcess.cpp
@@ -1,13 +1,13 @@
 //===-- SBProcess.cpp -------------------------------------------*- C++ -*-===//
 //
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
+// 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/SBProcess.h"
+#include "SBReproducerPrivate.h"
 
 #include <inttypes.h>
 
@@ -25,7 +25,7 @@
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/Args.h"
-#include "lldb/Utility/Log.h"
+#include "lldb/Utility/ProcessInfo.h"
 #include "lldb/Utility/State.h"
 #include "lldb/Utility/Stream.h"
 
@@ -49,33 +49,43 @@
 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;
+  return LLDB_RECORD_RESULT(*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();
@@ -84,6 +94,8 @@ const char *SBProcess::GetPluginName() {
 }
 
 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();
@@ -95,9 +107,19 @@ 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);
+  return this->operator bool();
+}
+SBProcess::operator bool() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBProcess, operator bool);
+
   ProcessSP process_sp(m_opaque_wp.lock());
   return ((bool)process_sp && process_sp->IsValid());
 }
@@ -108,18 +130,12 @@ bool SBProcess::RemoteLaunch(char const **argv, char const **envp,
                              const char *working_directory,
                              uint32_t launch_flags, bool stop_at_entry,
                              lldb::SBError &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",
-                stdout_path ? stdout_path : "NULL",
-                stderr_path ? stderr_path : "NULL",
-                working_directory ? working_directory : "NULL", launch_flags,
-                stop_at_entry, static_cast<void *>(error.get()));
+  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);
 
   ProcessSP process_sp(GetSP());
   if (process_sp) {
@@ -146,19 +162,14 @@ bool SBProcess::RemoteLaunch(char const **argv, char const **envp,
     error.SetErrorString("unable to attach pid");
   }
 
-  if (log) {
-    SBStream sstr;
-    error.GetDescription(sstr);
-    log->Printf("SBProcess(%p)::RemoteLaunch (...) => SBError (%p): %s",
-                static_cast<void *>(process_sp.get()),
-                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(
@@ -175,21 +186,11 @@ bool SBProcess::RemoteAttachToProcessWithID(lldb::pid_t pid,
     error.SetErrorString("unable to attach pid");
   }
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  if (log) {
-    SBStream sstr;
-    error.GetDescription(sstr);
-    log->Printf("SBProcess(%p)::RemoteAttachToProcessWithID (%" PRIu64
-                ") => SBError (%p): %s",
-                static_cast<void *>(process_sp.get()), pid,
-                static_cast<void *>(error.get()), sstr.GetData());
-  }
-
   return error.Success();
 }
 
 uint32_t SBProcess::GetNumThreads() {
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
+  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBProcess, GetNumThreads);
 
   uint32_t num_threads = 0;
   ProcessSP process_sp(GetSP());
@@ -202,15 +203,12 @@ uint32_t SBProcess::GetNumThreads() {
     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 {
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBThread, SBProcess,
+                                   GetSelectedThread);
 
   SBThread sb_thread;
   ThreadSP thread_sp;
@@ -222,17 +220,13 @@ SBThread SBProcess::GetSelectedThread() const {
     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;
+  return LLDB_RECORD_RESULT(sb_thread);
 }
 
 SBThread SBProcess::CreateOSPluginThread(lldb::tid_t tid,
                                          lldb::addr_t context) {
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
+  LLDB_RECORD_METHOD(lldb::SBThread, SBProcess, CreateOSPluginThread,
+                     (lldb::tid_t, lldb::addr_t), tid, context);
 
   SBThread sb_thread;
   ThreadSP thread_sp;
@@ -244,17 +238,11 @@ SBThread SBProcess::CreateOSPluginThread(lldb::tid_t tid,
     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;
+  return LLDB_RECORD_RESULT(sb_thread);
 }
 
 SBTarget SBProcess::GetTarget() const {
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBTarget, SBProcess, GetTarget);
 
   SBTarget sb_target;
   TargetSP target_sp;
@@ -264,16 +252,12 @@ SBTarget SBProcess::GetTarget() const {
     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;
+  return LLDB_RECORD_RESULT(sb_target);
 }
 
 size_t SBProcess::PutSTDIN(const char *src, size_t src_len) {
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
+  LLDB_RECORD_METHOD(size_t, SBProcess, PutSTDIN, (const char *, size_t), src,
+                     src_len);
 
   size_t ret_val = 0;
   ProcessSP process_sp(GetSP());
@@ -282,16 +266,13 @@ size_t SBProcess::PutSTDIN(const char *src, size_t src_len) {
     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) {
@@ -299,18 +280,13 @@ size_t SBProcess::GetSTDOUT(char *dst, size_t dst_len) const {
     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) {
@@ -318,18 +294,13 @@ size_t SBProcess::GetSTDERR(char *dst, size_t dst_len) const {
     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) {
@@ -337,20 +308,14 @@ size_t SBProcess::GetAsyncProfileData(char *dst, size_t dst_len) const {
     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) {
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
+  LLDB_RECORD_METHOD(lldb::SBTrace, SBProcess, StartTrace,
+                     (lldb::SBTraceOptions &, lldb::SBError &), options, error);
+
   ProcessSP process_sp(GetSP());
   error.Clear();
   SBTrace trace_instance;
@@ -362,13 +327,15 @@ lldb::SBTrace SBProcess::StartTrace(SBTraceOptions &options,
   } 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;
+  return LLDB_RECORD_RESULT(trace_instance);
 }
 
 void SBProcess::ReportEventState(const SBEvent &event, FILE *out) const {
-  if (out == NULL)
+  LLDB_RECORD_METHOD_CONST(void, SBProcess, ReportEventState,
+                           (const lldb::SBEvent &, FILE *), event, out);
+
+  if (out == nullptr)
     return;
 
   ProcessSP process_sp(GetSP());
@@ -386,6 +353,10 @@ void SBProcess::ReportEventState(const SBEvent &event, FILE *out) const {
 
 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);
@@ -398,6 +369,9 @@ void SBProcess::AppendEventStateReport(const SBEvent &event,
 }
 
 bool SBProcess::SetSelectedThread(const SBThread &thread) {
+  LLDB_RECORD_METHOD(bool, SBProcess, SetSelectedThread,
+                     (const lldb::SBThread &), thread);
+
   ProcessSP process_sp(GetSP());
   if (process_sp) {
     std::lock_guard<std::recursive_mutex> guard(
@@ -409,7 +383,9 @@ bool SBProcess::SetSelectedThread(const SBThread &thread) {
 }
 
 bool SBProcess::SetSelectedThreadByID(lldb::tid_t tid) {
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
+  LLDB_RECORD_METHOD(bool, SBProcess, SetSelectedThreadByID, (lldb::tid_t),
+                     tid);
+
 
   bool ret_val = false;
   ProcessSP process_sp(GetSP());
@@ -419,17 +395,12 @@ bool SBProcess::SetSelectedThreadByID(lldb::tid_t tid) {
     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) {
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
+  LLDB_RECORD_METHOD(bool, SBProcess, SetSelectedThreadByIndexID, (uint32_t),
+                     index_id);
 
   bool ret_val = false;
   ProcessSP process_sp(GetSP());
@@ -439,16 +410,13 @@ bool SBProcess::SetSelectedThreadByIndexID(uint32_t index_id) {
     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) {
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
+  LLDB_RECORD_METHOD(lldb::SBThread, SBProcess, GetThreadAtIndex, (size_t),
+                     index);
 
   SBThread sb_thread;
   ThreadSP thread_sp;
@@ -462,17 +430,11 @@ SBThread SBProcess::GetThreadAtIndex(size_t index) {
     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;
+  return LLDB_RECORD_RESULT(sb_thread);
 }
 
 uint32_t SBProcess::GetNumQueues() {
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
+  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBProcess, GetNumQueues);
 
   uint32_t num_queues = 0;
   ProcessSP process_sp(GetSP());
@@ -485,15 +447,12 @@ uint32_t SBProcess::GetNumQueues() {
     }
   }
 
-  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) {
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
+  LLDB_RECORD_METHOD(lldb::SBQueue, SBProcess, GetQueueAtIndex, (size_t),
+                     index);
 
   SBQueue sb_queue;
   QueueSP queue_sp;
@@ -508,16 +467,13 @@ SBQueue SBProcess::GetQueueAtIndex(size_t index) {
     }
   }
 
-  if (log)
-    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;
+  return LLDB_RECORD_RESULT(sb_queue);
 }
 
 uint32_t SBProcess::GetStopID(bool include_expression_stops) {
+  LLDB_RECORD_METHOD(uint32_t, SBProcess, GetStopID, (bool),
+                     include_expression_stops);
+
   ProcessSP process_sp(GetSP());
   if (process_sp) {
     std::lock_guard<std::recursive_mutex> guard(
@@ -531,7 +487,8 @@ uint32_t SBProcess::GetStopID(bool include_expression_stops) {
 }
 
 SBEvent SBProcess::GetStopEventForStopID(uint32_t stop_id) {
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
+  LLDB_RECORD_METHOD(lldb::SBEvent, SBProcess, GetStopEventForStopID,
+                     (uint32_t), stop_id);
 
   SBEvent sb_event;
   EventSP event_sp;
@@ -543,16 +500,11 @@ SBEvent SBProcess::GetStopEventForStopID(uint32_t 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;
+  return LLDB_RECORD_RESULT(sb_event);
 }
 
 StateType SBProcess::GetState() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::StateType, SBProcess, GetState);
 
   StateType ret_val = eStateInvalid;
   ProcessSP process_sp(GetSP());
@@ -562,16 +514,12 @@ StateType SBProcess::GetState() {
     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) {
@@ -579,94 +527,74 @@ int SBProcess::GetExitStatus() {
         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() {
-  const char *exit_desc = NULL;
+  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBProcess, GetExitDescription);
+
+  const char *exit_desc = nullptr;
   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() {
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBProcess, Continue);
 
   SBError sb_error;
   ProcessSP process_sp(GetSP());
 
-  if (log)
-    log->Printf("SBProcess(%p)::Continue ()...",
-                static_cast<void *>(process_sp.get()));
-
   if (process_sp) {
     std::lock_guard<std::recursive_mutex> guard(
         process_sp->GetTarget().GetAPIMutex());
@@ -674,22 +602,16 @@ SBError SBProcess::Continue() {
     if (process_sp->GetTarget().GetDebugger().GetAsyncExecution())
       sb_error.ref() = process_sp->Resume();
     else
-      sb_error.ref() = process_sp->ResumeSynchronous(NULL);
+      sb_error.ref() = process_sp->ResumeSynchronous(nullptr);
   } else
     sb_error.SetErrorString("SBProcess is invalid");
 
-  if (log) {
-    SBStream sstr;
-    sb_error.GetDescription(sstr);
-    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;
+  return LLDB_RECORD_RESULT(sb_error);
 }
 
 SBError SBProcess::Destroy() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBProcess, Destroy);
+
   SBError sb_error;
   ProcessSP process_sp(GetSP());
   if (process_sp) {
@@ -699,19 +621,12 @@ SBError SBProcess::Destroy() {
   } 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;
+  return LLDB_RECORD_RESULT(sb_error);
 }
 
 SBError SBProcess::Stop() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBProcess, Stop);
+
   SBError sb_error;
   ProcessSP process_sp(GetSP());
   if (process_sp) {
@@ -721,19 +636,12 @@ SBError SBProcess::Stop() {
   } 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;
+  return LLDB_RECORD_RESULT(sb_error);
 }
 
 SBError SBProcess::Kill() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBProcess, Kill);
+
   SBError sb_error;
   ProcessSP process_sp(GetSP());
   if (process_sp) {
@@ -743,25 +651,20 @@ SBError SBProcess::Kill() {
   } 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;
+  return LLDB_RECORD_RESULT(sb_error);
 }
 
 SBError SBProcess::Detach() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBProcess, Detach);
+
   // FIXME: This should come from a process default.
   bool keep_stopped = false;
-  return Detach(keep_stopped);
+  return LLDB_RECORD_RESULT(Detach(keep_stopped));
 }
 
 SBError SBProcess::Detach(bool keep_stopped) {
+  LLDB_RECORD_METHOD(lldb::SBError, SBProcess, Detach, (bool), keep_stopped);
+
   SBError sb_error;
   ProcessSP process_sp(GetSP());
   if (process_sp) {
@@ -771,10 +674,12 @@ SBError SBProcess::Detach(bool keep_stopped) {
   } else
     sb_error.SetErrorString("SBProcess is invalid");
 
-  return sb_error;
+  return LLDB_RECORD_RESULT(sb_error);
 }
 
 SBError SBProcess::Signal(int signo) {
+  LLDB_RECORD_METHOD(lldb::SBError, SBProcess, Signal, (int), signo);
+
   SBError sb_error;
   ProcessSP process_sp(GetSP());
   if (process_sp) {
@@ -783,25 +688,22 @@ SBError SBProcess::Signal(int signo) {
     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;
+
+  return LLDB_RECORD_RESULT(sb_error);
 }
 
 SBUnixSignals SBProcess::GetUnixSignals() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBUnixSignals, SBProcess, GetUnixSignals);
+
   if (auto process_sp = GetSP())
-    return SBUnixSignals{process_sp};
+    return LLDB_RECORD_RESULT(SBUnixSignals{process_sp});
 
-  return {};
+  return LLDB_RECORD_RESULT(SBUnixSignals{});
 }
 
 void SBProcess::SendAsyncInterrupt() {
+  LLDB_RECORD_METHOD_NO_ARGS(void, SBProcess, SendAsyncInterrupt);
+
   ProcessSP process_sp(GetSP());
   if (process_sp) {
     process_sp->SendAsyncInterrupt();
@@ -809,6 +711,9 @@ void SBProcess::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());
@@ -821,17 +726,13 @@ SBThread SBProcess::GetThreadByID(tid_t tid) {
     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;
+  return LLDB_RECORD_RESULT(sb_thread);
 }
 
 SBThread SBProcess::GetThreadByIndexID(uint32_t index_id) {
+  LLDB_RECORD_METHOD(lldb::SBThread, SBProcess, GetThreadByIndexID, (uint32_t),
+                     index_id);
+
   SBThread sb_thread;
   ThreadSP thread_sp;
   ProcessSP process_sp(GetSP());
@@ -845,51 +746,48 @@ SBThread SBProcess::GetThreadByIndexID(uint32_t index_id) {
     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;
+  return LLDB_RECORD_RESULT(sb_thread);
 }
 
 StateType SBProcess::GetStateFromEvent(const SBEvent &event) {
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
+  LLDB_RECORD_STATIC_METHOD(lldb::StateType, SBProcess, GetStateFromEvent,
+                            (const lldb::SBEvent &), event);
 
   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) {
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
+  LLDB_RECORD_STATIC_METHOD(bool, SBProcess, GetRestartedFromEvent,
+                            (const lldb::SBEvent &), event);
 
   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) {
@@ -897,24 +795,37 @@ SBProcess SBProcess::GetProcessFromEvent(const SBEvent &event) {
     process_sp = EventDataStructuredData::GetProcessFromEvent(event.get());
   }
 
-  return SBProcess(process_sp);
+  return LLDB_RECORD_RESULT(SBProcess(process_sp));
 }
 
 bool SBProcess::GetInterruptedFromEvent(const SBEvent &event) {
+  LLDB_RECORD_STATIC_METHOD(bool, SBProcess, GetInterruptedFromEvent,
+                            (const lldb::SBEvent &), event);
+
   return Process::ProcessEventData::GetInterruptedFromEvent(event.get());
 }
 
 lldb::SBStructuredData
 SBProcess::GetStructuredDataFromEvent(const lldb::SBEvent &event) {
-  return SBStructuredData(event.GetSP());
+  LLDB_RECORD_STATIC_METHOD(lldb::SBStructuredData, SBProcess,
+                            GetStructuredDataFromEvent, (const lldb::SBEvent &),
+                            event);
+
+  return LLDB_RECORD_RESULT(SBStructuredData(event.GetSP()));
 }
 
 bool SBProcess::EventIsProcessEvent(const SBEvent &event) {
+  LLDB_RECORD_STATIC_METHOD(bool, SBProcess, EventIsProcessEvent,
+                            (const lldb::SBEvent &), event);
+
   return (event.GetBroadcasterClass() == SBProcess::GetBroadcasterClass()) &&
          !EventIsStructuredDataEvent(event);
 }
 
 bool SBProcess::EventIsStructuredDataEvent(const lldb::SBEvent &event) {
+  LLDB_RECORD_STATIC_METHOD(bool, SBProcess, EventIsStructuredDataEvent,
+                            (const lldb::SBEvent &), event);
+
   EventSP event_sp = event.GetSP();
   EventData *event_data = event_sp ? event_sp->GetData() : nullptr;
   return event_data && (event_data->GetFlavor() ==
@@ -922,38 +833,35 @@ bool SBProcess::EventIsStructuredDataEvent(const lldb::SBEvent &event) {
 }
 
 SBBroadcaster SBProcess::GetBroadcaster() const {
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBBroadcaster, SBProcess,
+                                   GetBroadcaster);
+
 
   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;
+  return LLDB_RECORD_RESULT(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));
+  LLDB_RECORD_DUMMY(size_t, SBProcess, ReadMemory,
+                    (lldb::addr_t, void *, size_t, lldb::SBError &), addr, dst,
+                    dst_len, sb_error);
 
   size_t bytes_read = 0;
 
   ProcessSP process_sp(GetSP());
 
-  if (log)
-    log->Printf("SBProcess(%p)::ReadMemory (addr=0x%" PRIx64
-                ", dst=%p, dst_len=%" PRIu64 ", SBError (%p))...",
-                static_cast<void *>(process_sp.get()), addr,
-                static_cast<void *>(dst), static_cast<uint64_t>(dst_len),
-                static_cast<void *>(sb_error.get()));
 
   if (process_sp) {
     Process::StopLocker stop_locker;
@@ -962,31 +870,21 @@ size_t SBProcess::ReadMemory(addr_t addr, void *dst, size_t dst_len,
           process_sp->GetTarget().GetAPIMutex());
       bytes_read = process_sp->ReadMemory(addr, dst, dst_len, sb_error.ref());
     } else {
-      if (log)
-        log->Printf("SBProcess(%p)::ReadMemory() => error: process is running",
-                    static_cast<void *>(process_sp.get()));
       sb_error.SetErrorString("process is running");
     }
   } else {
     sb_error.SetErrorString("SBProcess is invalid");
   }
 
-  if (log) {
-    SBStream sstr;
-    sb_error.GetDescription(sstr);
-    log->Printf("SBProcess(%p)::ReadMemory (addr=0x%" PRIx64
-                ", dst=%p, dst_len=%" PRIu64 ", SBError (%p): %s) => %" PRIu64,
-                static_cast<void *>(process_sp.get()), addr,
-                static_cast<void *>(dst), static_cast<uint64_t>(dst_len),
-                static_cast<void *>(sb_error.get()), sstr.GetData(),
-                static_cast<uint64_t>(bytes_read));
-  }
-
   return bytes_read;
 }
 
 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);
+
   size_t bytes_read = 0;
   ProcessSP process_sp(GetSP());
   if (process_sp) {
@@ -997,11 +895,6 @@ size_t SBProcess::ReadCStringFromMemory(addr_t addr, void *buf, size_t size,
       bytes_read = process_sp->ReadCStringFromMemory(addr, (char *)buf, size,
                                                      sb_error.ref());
     } else {
-      Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-      if (log)
-        log->Printf("SBProcess(%p)::ReadCStringFromMemory() => error: process "
-                    "is running",
-                    static_cast<void *>(process_sp.get()));
       sb_error.SetErrorString("process is running");
     }
   } else {
@@ -1012,6 +905,10 @@ 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);
+
   uint64_t value = 0;
   ProcessSP process_sp(GetSP());
   if (process_sp) {
@@ -1022,11 +919,6 @@ uint64_t SBProcess::ReadUnsignedFromMemory(addr_t addr, uint32_t byte_size,
       value = process_sp->ReadUnsignedIntegerFromMemory(addr, byte_size, 0,
                                                         sb_error.ref());
     } else {
-      Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-      if (log)
-        log->Printf("SBProcess(%p)::ReadUnsignedFromMemory() => error: process "
-                    "is running",
-                    static_cast<void *>(process_sp.get()));
       sb_error.SetErrorString("process is running");
     }
   } else {
@@ -1037,6 +929,9 @@ 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::addr_t ptr = LLDB_INVALID_ADDRESS;
   ProcessSP process_sp(GetSP());
   if (process_sp) {
@@ -1046,11 +941,6 @@ lldb::addr_t SBProcess::ReadPointerFromMemory(addr_t addr,
           process_sp->GetTarget().GetAPIMutex());
       ptr = process_sp->ReadPointerFromMemory(addr, sb_error.ref());
     } else {
-      Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-      if (log)
-        log->Printf("SBProcess(%p)::ReadPointerFromMemory() => error: process "
-                    "is running",
-                    static_cast<void *>(process_sp.get()));
       sb_error.SetErrorString("process is running");
     }
   } else {
@@ -1061,19 +951,14 @@ 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) {
-  size_t bytes_written = 0;
+  LLDB_RECORD_DUMMY(size_t, SBProcess, WriteMemory,
+                    (lldb::addr_t, const void *, size_t, lldb::SBError &), addr,
+                    src, src_len, sb_error);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
+  size_t bytes_written = 0;
 
   ProcessSP process_sp(GetSP());
 
-  if (log)
-    log->Printf("SBProcess(%p)::WriteMemory (addr=0x%" PRIx64
-                ", src=%p, src_len=%" PRIu64 ", SBError (%p))...",
-                static_cast<void *>(process_sp.get()), addr,
-                static_cast<const void *>(src), static_cast<uint64_t>(src_len),
-                static_cast<void *>(sb_error.get()));
-
   if (process_sp) {
     Process::StopLocker stop_locker;
     if (stop_locker.TryLock(&process_sp->GetRunLock())) {
@@ -1082,28 +967,17 @@ size_t SBProcess::WriteMemory(addr_t addr, const void *src, size_t src_len,
       bytes_written =
           process_sp->WriteMemory(addr, src, src_len, sb_error.ref());
     } else {
-      if (log)
-        log->Printf("SBProcess(%p)::WriteMemory() => error: process is running",
-                    static_cast<void *>(process_sp.get()));
       sb_error.SetErrorString("process is running");
     }
   }
 
-  if (log) {
-    SBStream sstr;
-    sb_error.GetDescription(sstr);
-    log->Printf("SBProcess(%p)::WriteMemory (addr=0x%" PRIx64
-                ", src=%p, src_len=%" PRIu64 ", SBError (%p): %s) => %" PRIu64,
-                static_cast<void *>(process_sp.get()), addr,
-                static_cast<const void *>(src), static_cast<uint64_t>(src_len),
-                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());
@@ -1111,7 +985,7 @@ bool SBProcess::GetDescription(SBStream &description) {
     char path[PATH_MAX];
     GetTarget().GetExecutable().GetPath(path, sizeof(path));
     Module *exe_module = process_sp->GetTarget().GetExecutableModulePointer();
-    const char *exe_name = NULL;
+    const char *exe_name = nullptr;
     if (exe_module)
       exe_name = exe_module->GetFileSpec().GetFilename().AsCString();
 
@@ -1127,7 +1001,9 @@ bool SBProcess::GetDescription(SBStream &description) {
 
 uint32_t
 SBProcess::GetNumSupportedHardwareWatchpoints(lldb::SBError &sb_error) const {
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
+  LLDB_RECORD_METHOD_CONST(uint32_t, SBProcess,
+                           GetNumSupportedHardwareWatchpoints,
+                           (lldb::SBError &), sb_error);
 
   uint32_t num = 0;
   ProcessSP process_sp(GetSP());
@@ -1135,9 +1011,6 @@ SBProcess::GetNumSupportedHardwareWatchpoints(lldb::SBError &sb_error) const {
     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");
   }
@@ -1146,39 +1019,34 @@ 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);
+
   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) {
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
+  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);
+
   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",
-                    static_cast<void *>(process_sp.get()),
-                    sb_local_image_spec.GetFilename());
-
       std::lock_guard<std::recursive_mutex> guard(
         process_sp->GetTarget().GetAPIMutex());
       PlatformSP platform_sp = process_sp->GetTarget().GetPlatform();
       return platform_sp->LoadImage(process_sp.get(), *sb_local_image_spec,
                                     *sb_remote_image_spec, sb_error.ref());
     } else {
-      if (log)
-        log->Printf("SBProcess(%p)::LoadImage() => error: process is running",
-                    static_cast<void *>(process_sp.get()));
       sb_error.SetErrorString("process is running");
     }
-  } else { 
-    if (log)
-      log->Printf("SBProcess(%p)::LoadImage() => error: called with invalid"
-                    " process",
-                    static_cast<void *>(process_sp.get()));
+  } else {
     sb_error.SetErrorString("process is invalid");
   }
   return LLDB_INVALID_IMAGE_TOKEN;
@@ -1186,19 +1054,17 @@ uint32_t SBProcess::LoadImage(const lldb::SBFileSpec &sb_local_image_spec,
 
 uint32_t SBProcess::LoadImageUsingPaths(const lldb::SBFileSpec &image_spec,
                                         SBStringList &paths,
-                                        lldb::SBFileSpec &loaded_path, 
+                                        lldb::SBFileSpec &loaded_path,
                                         lldb::SBError &error) {
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
+  LLDB_RECORD_METHOD(uint32_t, SBProcess, LoadImageUsingPaths,
+                     (const lldb::SBFileSpec &, lldb::SBStringList &,
+                      lldb::SBFileSpec &, lldb::SBError &),
+                     image_spec, paths, loaded_path, error);
+
   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",
-                    static_cast<void *>(process_sp.get()),
-                    image_spec.GetFilename());
-
       std::lock_guard<std::recursive_mutex> guard(
         process_sp->GetTarget().GetAPIMutex());
       PlatformSP platform_sp = process_sp->GetTarget().GetPlatform();
@@ -1208,34 +1074,26 @@ uint32_t SBProcess::LoadImageUsingPaths(const lldb::SBFileSpec &image_spec,
       for (size_t i = 0; i < num_paths; i++)
         paths_vec.push_back(paths.GetStringAtIndex(i));
       FileSpec loaded_spec;
-      
-      uint32_t token = platform_sp->LoadImageUsingPaths(process_sp.get(),
-                                                        *image_spec, 
-                                                        paths_vec, 
-                                                        error.ref(), 
-                                                        &loaded_spec);
-       if (token != LLDB_INVALID_IMAGE_TOKEN)
-          loaded_path = loaded_spec;
-       return token;
+
+      uint32_t token = platform_sp->LoadImageUsingPaths(
+          process_sp.get(), *image_spec, paths_vec, error.ref(), &loaded_spec);
+      if (token != LLDB_INVALID_IMAGE_TOKEN)
+        loaded_path = loaded_spec;
+      return token;
     } else {
-      if (log)
-        log->Printf("SBProcess(%p)::LoadImageUsingPaths() => error: "
-                    "process is running",
-                    static_cast<void *>(process_sp.get()));
       error.SetErrorString("process is running");
     }
-  } else { 
-    if (log)
-      log->Printf("SBProcess(%p)::LoadImageUsingPaths() => error: "
-                   "called with invalid process",
-                    static_cast<void *>(process_sp.get()));
+  } else {
     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) {
@@ -1247,18 +1105,17 @@ lldb::SBError SBProcess::UnloadImage(uint32_t image_token) {
       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;
+  return LLDB_RECORD_RESULT(sb_error);
 }
 
 lldb::SBError SBProcess::SendEventData(const char *event_data) {
+  LLDB_RECORD_METHOD(lldb::SBError, SBProcess, SendEventData, (const char *),
+                     event_data);
+
   lldb::SBError sb_error;
   ProcessSP process_sp(GetSP());
   if (process_sp) {
@@ -1268,19 +1125,16 @@ lldb::SBError SBProcess::SendEventData(const char *event_data) {
           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;
+  return LLDB_RECORD_RESULT(sb_error);
 }
 
 uint32_t SBProcess::GetNumExtendedBacktraceTypes() {
+  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBProcess, GetNumExtendedBacktraceTypes);
+
   ProcessSP process_sp(GetSP());
   if (process_sp && process_sp->GetSystemRuntime()) {
     SystemRuntime *runtime = process_sp->GetSystemRuntime();
@@ -1290,6 +1144,9 @@ uint32_t SBProcess::GetNumExtendedBacktraceTypes() {
 }
 
 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();
@@ -1297,28 +1154,28 @@ const char *SBProcess::GetExtendedBacktraceTypeAtIndex(uint32_t idx) {
         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;
+  return nullptr;
 }
 
 SBThreadCollection SBProcess::GetHistoryThreads(addr_t addr) {
+  LLDB_RECORD_METHOD(lldb::SBThreadCollection, SBProcess, GetHistoryThreads,
+                     (lldb::addr_t), addr);
+
   ProcessSP process_sp(GetSP());
   SBThreadCollection threads;
   if (process_sp) {
     threads = SBThreadCollection(process_sp->GetHistoryThreads(addr));
   }
-  return threads;
+  return LLDB_RECORD_RESULT(threads);
 }
 
 bool SBProcess::IsInstrumentationRuntimePresent(
     InstrumentationRuntimeType type) {
+  LLDB_RECORD_METHOD(bool, SBProcess, IsInstrumentationRuntimePresent,
+                     (lldb::InstrumentationRuntimeType), type);
+
   ProcessSP process_sp(GetSP());
   if (!process_sp)
     return false;
@@ -1333,11 +1190,14 @@ bool SBProcess::IsInstrumentationRuntimePresent(
 }
 
 lldb::SBError SBProcess::SaveCore(const char *file_name) {
+  LLDB_RECORD_METHOD(lldb::SBError, SBProcess, SaveCore, (const char *),
+                     file_name);
+
   lldb::SBError error;
   ProcessSP process_sp(GetSP());
   if (!process_sp) {
     error.SetErrorString("SBProcess is invalid");
-    return error;
+    return LLDB_RECORD_RESULT(error);
   }
 
   std::lock_guard<std::recursive_mutex> guard(
@@ -1345,17 +1205,21 @@ lldb::SBError SBProcess::SaveCore(const char *file_name) {
 
   if (process_sp->GetState() != eStateStopped) {
     error.SetErrorString("the process is not stopped");
-    return error;
+    return LLDB_RECORD_RESULT(error);
   }
 
   FileSpec core_file(file_name);
   error.ref() = PluginManager::SaveCore(process_sp, core_file);
-  return error;
+  return LLDB_RECORD_RESULT(error);
 }
 
 lldb::SBError
 SBProcess::GetMemoryRegionInfo(lldb::addr_t load_addr,
                                SBMemoryRegionInfo &sb_region_info) {
+  LLDB_RECORD_METHOD(lldb::SBError, SBProcess, GetMemoryRegionInfo,
+                     (lldb::addr_t, lldb::SBMemoryRegionInfo &), load_addr,
+                     sb_region_info);
+
   lldb::SBError sb_error;
   ProcessSP process_sp(GetSP());
   if (process_sp) {
@@ -1367,20 +1231,18 @@ SBProcess::GetMemoryRegionInfo(lldb::addr_t load_addr,
       sb_error.ref() =
           process_sp->GetMemoryRegionInfo(load_addr, sb_region_info.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()));
       sb_error.SetErrorString("process is running");
     }
   } else {
     sb_error.SetErrorString("SBProcess is invalid");
   }
-  return sb_error;
+  return LLDB_RECORD_RESULT(sb_error);
 }
 
 lldb::SBMemoryRegionInfoList SBProcess::GetMemoryRegions() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBMemoryRegionInfoList, SBProcess,
+                             GetMemoryRegions);
+
   lldb::SBMemoryRegionInfoList sb_region_list;
 
   ProcessSP process_sp(GetSP());
@@ -1390,23 +1252,153 @@ lldb::SBMemoryRegionInfoList SBProcess::GetMemoryRegions() {
         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;
+  return LLDB_RECORD_RESULT(sb_region_list);
 }
 
 lldb::SBProcessInfo SBProcess::GetProcessInfo() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBProcessInfo, SBProcess, GetProcessInfo);
+
   lldb::SBProcessInfo sb_proc_info;
   ProcessSP process_sp(GetSP());
   ProcessInstanceInfo proc_info;
   if (process_sp && process_sp->GetProcessInfo(proc_info)) {
     sb_proc_info.SetProcessInfo(proc_info);
   }
-  return sb_proc_info;
+  return LLDB_RECORD_RESULT(sb_proc_info);
+}
+
+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(size_t, SBProcess, GetSTDOUT, (char *, size_t));
+  LLDB_REGISTER_METHOD_CONST(size_t, SBProcess, GetSTDERR, (char *, size_t));
+  LLDB_REGISTER_METHOD_CONST(size_t, SBProcess, GetAsyncProfileData,
+                             (char *, size_t));
+  LLDB_REGISTER_METHOD(lldb::SBTrace, SBProcess, StartTrace,
+                       (lldb::SBTraceOptions &, lldb::SBError &));
+  LLDB_REGISTER_METHOD_CONST(void, SBProcess, ReportEventState,
+                             (const lldb::SBEvent &, FILE *));
+  LLDB_REGISTER_METHOD(
+      void, SBProcess, AppendEventStateReport,
+      (const lldb::SBEvent &, lldb::SBCommandReturnObject &));
+  LLDB_REGISTER_METHOD(bool, SBProcess, SetSelectedThread,
+                       (const lldb::SBThread &));
+  LLDB_REGISTER_METHOD(bool, SBProcess, SetSelectedThreadByID, (lldb::tid_t));
+  LLDB_REGISTER_METHOD(bool, SBProcess, SetSelectedThreadByIndexID,
+                       (uint32_t));
+  LLDB_REGISTER_METHOD(lldb::SBThread, SBProcess, GetThreadAtIndex, (size_t));
+  LLDB_REGISTER_METHOD(uint32_t, SBProcess, GetNumQueues, ());
+  LLDB_REGISTER_METHOD(lldb::SBQueue, SBProcess, GetQueueAtIndex, (size_t));
+  LLDB_REGISTER_METHOD(uint32_t, SBProcess, GetStopID, (bool));
+  LLDB_REGISTER_METHOD(lldb::SBEvent, SBProcess, GetStopEventForStopID,
+                       (uint32_t));
+  LLDB_REGISTER_METHOD(lldb::StateType, SBProcess, GetState, ());
+  LLDB_REGISTER_METHOD(int, SBProcess, GetExitStatus, ());
+  LLDB_REGISTER_METHOD(const char *, SBProcess, GetExitDescription, ());
+  LLDB_REGISTER_METHOD(lldb::pid_t, SBProcess, GetProcessID, ());
+  LLDB_REGISTER_METHOD(uint32_t, SBProcess, GetUniqueID, ());
+  LLDB_REGISTER_METHOD_CONST(lldb::ByteOrder, SBProcess, GetByteOrder, ());
+  LLDB_REGISTER_METHOD_CONST(uint32_t, SBProcess, GetAddressByteSize, ());
+  LLDB_REGISTER_METHOD(lldb::SBError, SBProcess, Continue, ());
+  LLDB_REGISTER_METHOD(lldb::SBError, SBProcess, Destroy, ());
+  LLDB_REGISTER_METHOD(lldb::SBError, SBProcess, Stop, ());
+  LLDB_REGISTER_METHOD(lldb::SBError, SBProcess, Kill, ());
+  LLDB_REGISTER_METHOD(lldb::SBError, SBProcess, Detach, ());
+  LLDB_REGISTER_METHOD(lldb::SBError, SBProcess, Detach, (bool));
+  LLDB_REGISTER_METHOD(lldb::SBError, SBProcess, Signal, (int));
+  LLDB_REGISTER_METHOD(lldb::SBUnixSignals, SBProcess, GetUnixSignals, ());
+  LLDB_REGISTER_METHOD(void, SBProcess, SendAsyncInterrupt, ());
+  LLDB_REGISTER_METHOD(lldb::SBThread, SBProcess, GetThreadByID,
+                       (lldb::tid_t));
+  LLDB_REGISTER_METHOD(lldb::SBThread, SBProcess, GetThreadByIndexID,
+                       (uint32_t));
+  LLDB_REGISTER_STATIC_METHOD(lldb::StateType, SBProcess, GetStateFromEvent,
+                              (const lldb::SBEvent &));
+  LLDB_REGISTER_STATIC_METHOD(bool, SBProcess, GetRestartedFromEvent,
+                              (const lldb::SBEvent &));
+  LLDB_REGISTER_STATIC_METHOD(size_t, SBProcess,
+                              GetNumRestartedReasonsFromEvent,
+                              (const lldb::SBEvent &));
+  LLDB_REGISTER_STATIC_METHOD(const char *, SBProcess,
+                              GetRestartedReasonAtIndexFromEvent,
+                              (const lldb::SBEvent &, size_t));
+  LLDB_REGISTER_STATIC_METHOD(lldb::SBProcess, SBProcess, GetProcessFromEvent,
+                              (const lldb::SBEvent &));
+  LLDB_REGISTER_STATIC_METHOD(bool, SBProcess, GetInterruptedFromEvent,
+                              (const lldb::SBEvent &));
+  LLDB_REGISTER_STATIC_METHOD(lldb::SBStructuredData, SBProcess,
+                              GetStructuredDataFromEvent,
+                              (const lldb::SBEvent &));
+  LLDB_REGISTER_STATIC_METHOD(bool, SBProcess, EventIsProcessEvent,
+                              (const lldb::SBEvent &));
+  LLDB_REGISTER_STATIC_METHOD(bool, SBProcess, EventIsStructuredDataEvent,
+                              (const lldb::SBEvent &));
+  LLDB_REGISTER_METHOD_CONST(lldb::SBBroadcaster, SBProcess, GetBroadcaster,
+                             ());
+  LLDB_REGISTER_STATIC_METHOD(const char *, SBProcess, GetBroadcasterClass,
+                              ());
+  LLDB_REGISTER_METHOD(uint64_t, SBProcess, ReadUnsignedFromMemory,
+                       (lldb::addr_t, uint32_t, lldb::SBError &));
+  LLDB_REGISTER_METHOD(lldb::addr_t, SBProcess, ReadPointerFromMemory,
+                       (lldb::addr_t, lldb::SBError &));
+  LLDB_REGISTER_METHOD(bool, SBProcess, GetDescription, (lldb::SBStream &));
+  LLDB_REGISTER_METHOD_CONST(uint32_t, SBProcess,
+                             GetNumSupportedHardwareWatchpoints,
+                             (lldb::SBError &));
+  LLDB_REGISTER_METHOD(uint32_t, SBProcess, LoadImage,
+                       (lldb::SBFileSpec &, lldb::SBError &));
+  LLDB_REGISTER_METHOD(
+      uint32_t, SBProcess, LoadImage,
+      (const lldb::SBFileSpec &, const lldb::SBFileSpec &, lldb::SBError &));
+  LLDB_REGISTER_METHOD(uint32_t, SBProcess, LoadImageUsingPaths,
+                       (const lldb::SBFileSpec &, lldb::SBStringList &,
+                        lldb::SBFileSpec &, lldb::SBError &));
+  LLDB_REGISTER_METHOD(lldb::SBError, SBProcess, UnloadImage, (uint32_t));
+  LLDB_REGISTER_METHOD(lldb::SBError, SBProcess, SendEventData,
+                       (const char *));
+  LLDB_REGISTER_METHOD(uint32_t, SBProcess, GetNumExtendedBacktraceTypes, ());
+  LLDB_REGISTER_METHOD(const char *, SBProcess,
+                       GetExtendedBacktraceTypeAtIndex, (uint32_t));
+  LLDB_REGISTER_METHOD(lldb::SBThreadCollection, SBProcess, GetHistoryThreads,
+                       (lldb::addr_t));
+  LLDB_REGISTER_METHOD(bool, SBProcess, IsInstrumentationRuntimePresent,
+                       (lldb::InstrumentationRuntimeType));
+  LLDB_REGISTER_METHOD(lldb::SBError, SBProcess, SaveCore, (const char *));
+  LLDB_REGISTER_METHOD(lldb::SBError, SBProcess, GetMemoryRegionInfo,
+                       (lldb::addr_t, lldb::SBMemoryRegionInfo &));
+  LLDB_REGISTER_METHOD(lldb::SBMemoryRegionInfoList, SBProcess,
+                       GetMemoryRegions, ());
+  LLDB_REGISTER_METHOD(lldb::SBProcessInfo, SBProcess, GetProcessInfo, ());
+}
+
+}
 }