[SBAPI] Log from record macro

The current record macros already log the function being called. This
patch extends the macros to also log their input arguments and removes
explicit logging from the SB API.

This might degrade the amount of information in some cases (because of
smarter casts or efforts to log return values). However I think this is
outweighed by the increased coverage and consistency. Furthermore, using
the reproducer infrastructure, diagnosing bugs in the API layer should
become much easier compared to relying on log messages.

Differential revision: https://reviews.llvm.org/D59101

llvm-svn: 355649

1 files changed, 10 insertions, 380 deletions

diff --git a/lldb/source/API/SBProcess.cpp b/lldb/source/API/SBProcess.cpp
index f1e288d32a3..1a9fa14edbe 100644
--- a/lldb/source/API/SBProcess.cpp
+++ b/lldb/source/API/SBProcess.cpp
@@ -25,7 +25,6 @@
 #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"
@@ -138,19 +137,6 @@ bool SBProcess::RemoteLaunch(char const **argv, char const **envp,
                      argv, envp, stdin_path, stdout_path, stderr_path,
                      working_directory, launch_flags, stop_at_entry, error);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  if (log)
-    log->Printf("SBProcess(%p)::RemoteLaunch (argv=%p, envp=%p, stdin=%s, "
-                "stdout=%s, stderr=%s, working-dir=%s, launch_flags=0x%x, "
-                "stop_at_entry=%i, &error (%p))...",
-                static_cast<void *>(m_opaque_wp.lock().get()),
-                static_cast<void *>(argv), static_cast<void *>(envp),
-                stdin_path ? stdin_path : "NULL",
-                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()));
-
   ProcessSP process_sp(GetSP());
   if (process_sp) {
     std::lock_guard<std::recursive_mutex> guard(
@@ -176,14 +162,6 @@ 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();
 }
 
@@ -208,24 +186,12 @@ 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() {
   LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBProcess, GetNumThreads);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-
   uint32_t num_threads = 0;
   ProcessSP process_sp(GetSP());
   if (process_sp) {
@@ -237,10 +203,6 @@ 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;
 }
 
@@ -248,8 +210,6 @@ SBThread SBProcess::GetSelectedThread() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBThread, SBProcess,
                                    GetSelectedThread);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-
   SBThread sb_thread;
   ThreadSP thread_sp;
   ProcessSP process_sp(GetSP());
@@ -260,11 +220,6 @@ 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 LLDB_RECORD_RESULT(sb_thread);
 }
 
@@ -273,8 +228,6 @@ SBThread SBProcess::CreateOSPluginThread(lldb::tid_t tid,
   LLDB_RECORD_METHOD(lldb::SBThread, SBProcess, CreateOSPluginThread,
                      (lldb::tid_t, lldb::addr_t), tid, context);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-
   SBThread sb_thread;
   ThreadSP thread_sp;
   ProcessSP process_sp(GetSP());
@@ -285,20 +238,12 @@ 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 LLDB_RECORD_RESULT(sb_thread);
 }
 
 SBTarget SBProcess::GetTarget() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBTarget, SBProcess, GetTarget);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-
   SBTarget sb_target;
   TargetSP target_sp;
   ProcessSP process_sp(GetSP());
@@ -307,11 +252,6 @@ 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 LLDB_RECORD_RESULT(sb_target);
 }
 
@@ -319,8 +259,6 @@ size_t SBProcess::PutSTDIN(const char *src, size_t src_len) {
   LLDB_RECORD_METHOD(size_t, SBProcess, PutSTDIN, (const char *, size_t), src,
                      src_len);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-
   size_t ret_val = 0;
   ProcessSP process_sp(GetSP());
   if (process_sp) {
@@ -328,12 +266,6 @@ 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;
 }
 
@@ -348,14 +280,6 @@ 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;
 }
 
@@ -370,14 +294,6 @@ 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;
 }
 
@@ -392,14 +308,6 @@ 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;
 }
 
@@ -408,7 +316,6 @@ lldb::SBTrace SBProcess::StartTrace(SBTraceOptions &options,
   LLDB_RECORD_METHOD(lldb::SBTrace, SBProcess, StartTrace,
                      (lldb::SBTraceOptions &, lldb::SBError &), options, error);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   ProcessSP process_sp(GetSP());
   error.Clear();
   SBTrace trace_instance;
@@ -420,7 +327,6 @@ 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 LLDB_RECORD_RESULT(trace_instance);
 }
@@ -480,7 +386,6 @@ bool SBProcess::SetSelectedThreadByID(lldb::tid_t tid) {
   LLDB_RECORD_METHOD(bool, SBProcess, SetSelectedThreadByID, (lldb::tid_t),
                      tid);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   bool ret_val = false;
   ProcessSP process_sp(GetSP());
@@ -490,12 +395,6 @@ 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;
 }
 
@@ -503,8 +402,6 @@ bool SBProcess::SetSelectedThreadByIndexID(uint32_t index_id) {
   LLDB_RECORD_METHOD(bool, SBProcess, SetSelectedThreadByIndexID, (uint32_t),
                      index_id);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-
   bool ret_val = false;
   ProcessSP process_sp(GetSP());
   if (process_sp) {
@@ -513,10 +410,6 @@ 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;
 }
@@ -525,8 +418,6 @@ SBThread SBProcess::GetThreadAtIndex(size_t index) {
   LLDB_RECORD_METHOD(lldb::SBThread, SBProcess, GetThreadAtIndex, (size_t),
                      index);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-
   SBThread sb_thread;
   ThreadSP thread_sp;
   ProcessSP process_sp(GetSP());
@@ -539,20 +430,12 @@ 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 LLDB_RECORD_RESULT(sb_thread);
 }
 
 uint32_t SBProcess::GetNumQueues() {
   LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBProcess, GetNumQueues);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-
   uint32_t num_queues = 0;
   ProcessSP process_sp(GetSP());
   if (process_sp) {
@@ -564,10 +447,6 @@ uint32_t SBProcess::GetNumQueues() {
     }
   }
 
-  if (log)
-    log->Printf("SBProcess(%p)::GetNumQueues () => %d",
-                static_cast<void *>(process_sp.get()), num_queues);
-
   return num_queues;
 }
 
@@ -575,8 +454,6 @@ SBQueue SBProcess::GetQueueAtIndex(size_t index) {
   LLDB_RECORD_METHOD(lldb::SBQueue, SBProcess, GetQueueAtIndex, (size_t),
                      index);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-
   SBQueue sb_queue;
   QueueSP queue_sp;
   ProcessSP process_sp(GetSP());
@@ -590,12 +467,6 @@ 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 LLDB_RECORD_RESULT(sb_queue);
 }
 
@@ -619,8 +490,6 @@ SBEvent SBProcess::GetStopEventForStopID(uint32_t stop_id) {
   LLDB_RECORD_METHOD(lldb::SBEvent, SBProcess, GetStopEventForStopID,
                      (uint32_t), stop_id);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-
   SBEvent sb_event;
   EventSP event_sp;
   ProcessSP process_sp(GetSP());
@@ -631,12 +500,6 @@ 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 LLDB_RECORD_RESULT(sb_event);
 }
 
@@ -651,12 +514,6 @@ 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;
 }
 
@@ -670,11 +527,6 @@ 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;
 }
@@ -689,10 +541,6 @@ const char *SBProcess::GetExitDescription() {
         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;
 }
 
@@ -704,11 +552,6 @@ lldb::pid_t SBProcess::GetProcessID() {
   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;
 }
 
@@ -719,10 +562,6 @@ uint32_t SBProcess::GetUniqueID() {
   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;
 }
 
@@ -734,10 +573,6 @@ ByteOrder SBProcess::GetByteOrder() const {
   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;
 }
@@ -750,10 +585,6 @@ uint32_t SBProcess::GetAddressByteSize() const {
   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;
 }
@@ -761,15 +592,9 @@ uint32_t SBProcess::GetAddressByteSize() const {
 SBError SBProcess::Continue() {
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBProcess, Continue);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-
   SBError sb_error;
   ProcessSP process_sp(GetSP());
 
-  if (log)
-    log->Printf("SBProcess(%p)::Continue ()...",
-                static_cast<void *>(process_sp.get()));
-
   if (process_sp) {
     std::lock_guard<std::recursive_mutex> guard(
         process_sp->GetTarget().GetAPIMutex());
@@ -781,14 +606,6 @@ SBError SBProcess::Continue() {
   } 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 LLDB_RECORD_RESULT(sb_error);
 }
 
@@ -804,15 +621,6 @@ 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 LLDB_RECORD_RESULT(sb_error);
 }
 
@@ -828,15 +636,6 @@ 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 LLDB_RECORD_RESULT(sb_error);
 }
 
@@ -852,15 +651,6 @@ 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 LLDB_RECORD_RESULT(sb_error);
 }
 
@@ -898,14 +688,7 @@ 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 LLDB_RECORD_RESULT(sb_error);
 }
 
@@ -943,13 +726,6 @@ 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 LLDB_RECORD_RESULT(sb_thread);
 }
 
@@ -970,12 +746,6 @@ 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 LLDB_RECORD_RESULT(sb_thread);
 }
 
@@ -983,15 +753,8 @@ StateType SBProcess::GetStateFromEvent(const SBEvent &event) {
   LLDB_RECORD_STATIC_METHOD(lldb::StateType, SBProcess, GetStateFromEvent,
                             (const lldb::SBEvent &), event);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-
   StateType ret_val = Process::ProcessEventData::GetStateFromEvent(event.get());
 
-  if (log)
-    log->Printf("SBProcess::GetStateFromEvent (event.sp=%p) => %s",
-                static_cast<void *>(event.get()),
-                lldb_private::StateAsCString(ret_val));
-
   return ret_val;
 }
 
@@ -999,14 +762,8 @@ bool SBProcess::GetRestartedFromEvent(const SBEvent &event) {
   LLDB_RECORD_STATIC_METHOD(bool, SBProcess, GetRestartedFromEvent,
                             (const lldb::SBEvent &), event);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-
   bool ret_val = Process::ProcessEventData::GetRestartedFromEvent(event.get());
 
-  if (log)
-    log->Printf("SBProcess::%s (event.sp=%p) => %d", __FUNCTION__,
-                static_cast<void *>(event.get()), ret_val);
-
   return ret_val;
 }
 
@@ -1079,16 +836,11 @@ SBBroadcaster SBProcess::GetBroadcaster() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBBroadcaster, SBProcess,
                                    GetBroadcaster);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   ProcessSP process_sp(GetSP());
 
   SBBroadcaster broadcaster(process_sp.get(), false);
 
-  if (log)
-    log->Printf("SBProcess(%p)::GetBroadcaster () => SBBroadcaster (%p)",
-                static_cast<void *>(process_sp.get()),
-                static_cast<void *>(broadcaster.get()));
 
   return LLDB_RECORD_RESULT(broadcaster);
 }
@@ -1102,18 +854,11 @@ const char *SBProcess::GetBroadcasterClass() {
 
 size_t SBProcess::ReadMemory(addr_t addr, void *dst, size_t dst_len,
                              SBError &sb_error) {
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   size_t bytes_read = 0;
 
   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;
@@ -1122,26 +867,12 @@ 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;
 }
 
@@ -1157,11 +888,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 {
@@ -1186,11 +912,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 {
@@ -1213,11 +934,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 {
@@ -1230,17 +946,8 @@ size_t SBProcess::WriteMemory(addr_t addr, const void *src, size_t src_len,
                               SBError &sb_error) {
   size_t bytes_written = 0;
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-
   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())) {
@@ -1249,24 +956,10 @@ 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;
 }
 
@@ -1301,17 +994,12 @@ SBProcess::GetNumSupportedHardwareWatchpoints(lldb::SBError &sb_error) const {
                            GetNumSupportedHardwareWatchpoints,
                            (lldb::SBError &), sb_error);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-
   uint32_t num = 0;
   ProcessSP process_sp(GetSP());
   if (process_sp) {
     std::lock_guard<std::recursive_mutex> guard(
         process_sp->GetTarget().GetAPIMutex());
     sb_error.SetError(process_sp->GetWatchpointSupportInfo(num));
-    if (log)
-      log->Printf("SBProcess(%p)::GetNumSupportedHardwareWatchpoints () => %u",
-                  static_cast<void *>(process_sp.get()), num);
   } else {
     sb_error.SetErrorString("SBProcess is invalid");
   }
@@ -1335,33 +1023,19 @@ uint32_t SBProcess::LoadImage(const lldb::SBFileSpec &sb_local_image_spec,
       (const lldb::SBFileSpec &, const lldb::SBFileSpec &, lldb::SBError &),
       sb_local_image_spec, sb_remote_image_spec, sb_error);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   ProcessSP process_sp(GetSP());
   if (process_sp) {
     Process::StopLocker stop_locker;
     if (stop_locker.TryLock(&process_sp->GetRunLock())) {
-      if (log)
-        log->Printf("SBProcess(%p)::LoadImage() => calling Platform::LoadImage"
-                    "for: %s",
-                    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;
@@ -1376,17 +1050,10 @@ uint32_t SBProcess::LoadImageUsingPaths(const lldb::SBFileSpec &image_spec,
                       lldb::SBFileSpec &, lldb::SBError &),
                      image_spec, paths, loaded_path, error);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   ProcessSP process_sp(GetSP());
   if (process_sp) {
     Process::StopLocker stop_locker;
     if (stop_locker.TryLock(&process_sp->GetRunLock())) {
-      if (log)
-        log->Printf("SBProcess(%p)::LoadImageUsingPaths() => "
-                    "calling Platform::LoadImageUsingPaths for: %s",
-                    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();
@@ -1396,30 +1063,19 @@ 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;
 }
 
@@ -1438,10 +1094,6 @@ 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
@@ -1462,11 +1114,6 @@ 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
@@ -1496,12 +1143,6 @@ 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;
@@ -1579,11 +1220,6 @@ 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 {
@@ -1605,12 +1241,6 @@ 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 LLDB_RECORD_RESULT(sb_region_list);