[SBAPI] Log from record macro

[JDevlieghere]

Summary

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.

[clayborg]

As long as we are still seeing all argument values, I check the first 10 or so calls and it looked like this was the case, then I am good with this.

[JDevlieghere]

In D59101#1422129, @clayborg wrote:

As long as we are still seeing all argument values, I check the first 10 or so calls and it looked like this was the case, then I am good with this.

Correct, the macros forward the arguments to the log.

[kastiglione]

I'm getting build failures that appear to be caused by this patch. I'm compiling on macOS with Xcode 10.1. The failures are uses of LLDB_RECORD_DUMMY(), passing a callback function pointer as one of the args. This results in errors like:

../../tools/lldb/include/lldb/Utility/ReproducerInstrumentation.h:37:6: error: invalid operands to binary expression ('llvm::raw_string_ostream' and 'bool (*)(void *, lldb::SBProcess &, lldb::SBThread &, lldb::SBBreakpointLocation &)')
  ss << t;
  ~~ ^  ~

and

../../include/llvm/Support/raw_ostream.h:202:16: note: candidate function not viable: no known conversion from 'bool (*)(void *, lldb::SBProcess &, lldb::SBThread &, lldb::SBBreakpointLocation &)' to 'const void *' for 1st argument; take the address of the argument with &
  raw_ostream &operator<<(const void *P);

include/lldb/Utility/ReproducerInstrumentation.h

 #include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/Logging.h"
 
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/ErrorHandling.h"
 
+#include <iostream>
 #include <map>
+#include <type_traits>
+
+template <typename T,
+          typename std::enable_if<std::is_fundamental<T>::value, int>::type = 0>
+void log_append(llvm::raw_string_ostream &ss, const T &t) {
+  ss << t;
+}
+
+template <typename T, typename std::enable_if<!std::is_fundamental<T>::value,
+                                              int>::type = 0>
+void log_append(llvm::raw_string_ostream &ss, const T &t) {
+  ss << &t;
+}
+
+template <typename T>
+void log_append(llvm::raw_string_ostream &ss, const T *t) {
+  ss << t;
+}
+
+void log_append(llvm::raw_string_ostream &ss, const char *t) { ss << t; }
+
+template <typename Head>
+void log_helper(llvm::raw_string_ostream &ss, const Head &head) {
+  log_append(ss, head);
+}
+
+template <typename Head, typename... Tail>
+void log_helper(llvm::raw_string_ostream &ss, const Head &head,
+                const Tail &... tail) {
+  log_append(ss, head);
+  ss << ", ";
+  log_helper(ss, tail...);
+}
+
+template <typename... Ts> std::string log_args(const Ts &... ts) {
+  std::string buffer;
+  llvm::raw_string_ostream ss(buffer);
+  log_helper(ss, ts...);
+  return ss.str();
+}
 
 // Define LLDB_REPRO_INSTR_TRACE to trace to stderr instead of LLDB's log
 // infrastructure. This is useful when you need to see traces before the logger
 // is initialized or enabled.
 // #define LLDB_REPRO_INSTR_TRACE
 
 #define LLDB_REGISTER_CONSTRUCTOR(Class, Signature)                            \
   Register<Class * Signature>(&construct<Class Signature>::doit, "", #Class,   \
                               #Class, #Signature)
 #define LLDB_REGISTER_METHOD(Result, Class, Method, Signature)                 \
   Register(&invoke<Result(Class::*) Signature>::method<&Class::Method>::doit,  \
            #Result, #Class, #Method, #Signature)
 #define LLDB_REGISTER_METHOD_CONST(Result, Class, Method, Signature)           \
   Register(&invoke<Result(Class::*)                                            \
                        Signature const>::method_const<&Class::Method>::doit,   \
            #Result, #Class, #Method, #Signature)
 #define LLDB_REGISTER_STATIC_METHOD(Result, Class, Method, Signature)          \
   Register<Result Signature>(static_cast<Result(*) Signature>(&Class::Method), \
                              #Result, #Class, #Method, #Signature)
 
 #define LLDB_RECORD_CONSTRUCTOR(Class, Signature, ...)                         \
-  LLDB_LOG(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API), "{0}",                   \
-           LLVM_PRETTY_FUNCTION);                                              \
+  LLDB_LOG(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API), "{0} ({1})",             \
+           LLVM_PRETTY_FUNCTION, log_args(__VA_ARGS__));                       \
   if (lldb_private::repro::InstrumentationData data =                          \
           LLDB_GET_INSTRUMENTATION_DATA()) {                                   \
     lldb_private::repro::Recorder sb_recorder(                                 \
         data.GetSerializer(), data.GetRegistry(), LLVM_PRETTY_FUNCTION);       \
     sb_recorder.Record(&lldb_private::repro::construct<Class Signature>::doit, \
                        __VA_ARGS__);                                           \
     sb_recorder.RecordResult(this);                                            \
   }
 
 #define LLDB_RECORD_CONSTRUCTOR_NO_ARGS(Class)                                 \
   LLDB_LOG(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API), "{0}",                   \
            LLVM_PRETTY_FUNCTION);                                              \
   if (lldb_private::repro::InstrumentationData data =                          \
           LLDB_GET_INSTRUMENTATION_DATA()) {                                   \
     lldb_private::repro::Recorder sb_recorder(                                 \
         data.GetSerializer(), data.GetRegistry(), LLVM_PRETTY_FUNCTION);       \
     sb_recorder.Record(&lldb_private::repro::construct<Class()>::doit);        \
     sb_recorder.RecordResult(this);                                            \
   }
 
 #define LLDB_RECORD_METHOD(Result, Class, Method, Signature, ...)              \
-  LLDB_LOG(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API), "{0}",                   \
-           LLVM_PRETTY_FUNCTION);                                              \
+  LLDB_LOG(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API), "{0} ({1})",             \
+           LLVM_PRETTY_FUNCTION, log_args(__VA_ARGS__));                       \
   llvm::Optional<lldb_private::repro::Recorder> sb_recorder;                   \
   if (lldb_private::repro::InstrumentationData data =                          \
           LLDB_GET_INSTRUMENTATION_DATA()) {                                   \
     sb_recorder.emplace(data.GetSerializer(), data.GetRegistry(),              \
                         LLVM_PRETTY_FUNCTION);                                 \
     sb_recorder->Record(                                                       \
         &lldb_private::repro::invoke<Result(                                   \
             Class::*) Signature>::method<&Class::Method>::doit,                \
         this, __VA_ARGS__);                                                    \
   }
 
 #define LLDB_RECORD_METHOD_CONST(Result, Class, Method, Signature, ...)        \
-  LLDB_LOG(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API), "{0}",                   \
-           LLVM_PRETTY_FUNCTION);                                              \
+  LLDB_LOG(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API), "{0} ({1})",             \
+           LLVM_PRETTY_FUNCTION, log_args(__VA_ARGS__));                       \
   llvm::Optional<lldb_private::repro::Recorder> sb_recorder;                   \
   if (lldb_private::repro::InstrumentationData data =                          \
           LLDB_GET_INSTRUMENTATION_DATA()) {                                   \
     sb_recorder.emplace(data.GetSerializer(), data.GetRegistry(),              \
                         LLVM_PRETTY_FUNCTION);                                 \
     sb_recorder->Record(                                                       \
         &lldb_private::repro::invoke<Result(                                   \
             Class::*) Signature const>::method_const<&Class::Method>::doit,    \
sb_recorder.emplace(data.GetSerializer(), data.GetRegistry(),              \
                         LLVM_PRETTY_FUNCTION);                                 \
     sb_recorder->Record(                                                       \
         &lldb_private::repro::invoke<Result (                                  \
             Class::*)() const>::method_const<&Class::Method>::doit,            \
         this);                                                                 \
   }
 
 #define LLDB_RECORD_STATIC_METHOD(Result, Class, Method, Signature, ...)       \
-  LLDB_LOG(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API), "{0}",                   \
-           LLVM_PRETTY_FUNCTION);                                              \
+  LLDB_LOG(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API), "{0} ({1})",             \
+           LLVM_PRETTY_FUNCTION, log_args(__VA_ARGS__));                       \
   llvm::Optional<lldb_private::repro::Recorder> sb_recorder;                   \
   if (lldb_private::repro::InstrumentationData data =                          \
           LLDB_GET_INSTRUMENTATION_DATA()) {                                   \
     sb_recorder.emplace(data.GetSerializer(), data.GetRegistry(),              \
                         LLVM_PRETTY_FUNCTION);                                 \
     sb_recorder->Record(static_cast<Result(*) Signature>(&Class::Method),      \
                         __VA_ARGS__);                                          \
   }

source/API/SBAddress.cpp

 #include "Utils.h"
 #include "lldb/API/SBProcess.h"
 #include "lldb/API/SBSection.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/Core/Address.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Symbol/LineEntry.h"
 #include "lldb/Target/Target.h"
-#include "lldb/Utility/Log.h"
 #include "lldb/Utility/StreamString.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 SBAddress::SBAddress() : m_opaque_up(new Address()) {
   LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBAddress);
 }
lldb::addr_t SBAddress::GetFileAddress() const {
   else
     return LLDB_INVALID_ADDRESS;
 }
 
 lldb::addr_t SBAddress::GetLoadAddress(const SBTarget &target) const {
   LLDB_RECORD_METHOD_CONST(lldb::addr_t, SBAddress, GetLoadAddress,
                            (const lldb::SBTarget &), target);
 
-  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-
   lldb::addr_t addr = LLDB_INVALID_ADDRESS;
   TargetSP target_sp(target.GetSP());
   if (target_sp) {
     if (m_opaque_up->IsValid()) {
       std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
       addr = m_opaque_up->GetLoadAddress(target_sp.get());
     }
   }
 
-  if (log) {
-    if (addr == LLDB_INVALID_ADDRESS)
-      log->Printf(
-          "SBAddress::GetLoadAddress (SBTarget(%p)) => LLDB_INVALID_ADDRESS",
-          static_cast<void *>(target_sp.get()));
-    else
-      log->Printf("SBAddress::GetLoadAddress (SBTarget(%p)) => 0x%" PRIx64,
-                  static_cast<void *>(target_sp.get()), addr);
-  }
-
   return addr;
 }
 
 void SBAddress::SetLoadAddress(lldb::addr_t load_addr, lldb::SBTarget &target) {
   LLDB_RECORD_METHOD(void, SBAddress, SetLoadAddress,
                      (lldb::addr_t, lldb::SBTarget &), load_addr, target);
 
   // Create the address object if we don't already have one

source/API/SBBlock.cpp

 #include "lldb/Core/AddressRange.h"
 #include "lldb/Core/ValueObjectVariable.h"
 #include "lldb/Symbol/Block.h"
 #include "lldb/Symbol/Function.h"
 #include "lldb/Symbol/SymbolContext.h"
 #include "lldb/Symbol/VariableList.h"
 #include "lldb/Target/StackFrame.h"
 #include "lldb/Target/Target.h"
-#include "lldb/Utility/Log.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 SBBlock::SBBlock() : m_opaque_ptr(NULL) {
   LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBBlock);
 }
 

source/API/SBBreakpoint.cpp

 #include "lldb/Core/StreamFile.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Interpreter/ScriptInterpreter.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/SectionLoadList.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Target/ThreadSpec.h"
-#include "lldb/Utility/Log.h"
 #include "lldb/Utility/Stream.h"
 
 #include "SBBreakpointOptionCommon.h"
 
 #include "lldb/lldb-enumerations.h"
 
 #include "llvm/ADT/STLExtras.h"
 
LLDB_RECORD_METHOD(
       bool, SBBreakpoint, operator!=,(const lldb::SBBreakpoint &), rhs);
 
   return m_opaque_wp.lock() != rhs.m_opaque_wp.lock();
 }
 
 break_id_t SBBreakpoint::GetID() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::break_id_t, SBBreakpoint, GetID);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-
   break_id_t break_id = LLDB_INVALID_BREAK_ID;
   BreakpointSP bkpt_sp = GetSP();
   if (bkpt_sp)
     break_id = bkpt_sp->GetID();
 
-  LLDB_LOG(log, "breakpoint = {0}, id = {1}", bkpt_sp.get(), break_id);
   return break_id;
 }
 
 bool SBBreakpoint::IsValid() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBreakpoint, IsValid);
 
   BreakpointSP bkpt_sp = GetSP();
   if (!bkpt_sp)
SBBreakpointLocation SBBreakpoint::GetLocationAtIndex(uint32_t index) {
   }
 
   return LLDB_RECORD_RESULT(sb_bp_location);
 }
 
 void SBBreakpoint::SetEnabled(bool enable) {
   LLDB_RECORD_METHOD(void, SBBreakpoint, SetEnabled, (bool), enable);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   BreakpointSP bkpt_sp = GetSP();
 
-  LLDB_LOG(log, "breakpoint = {0}, enable = {1}", bkpt_sp.get(), enable);
-
   if (bkpt_sp) {
     std::lock_guard<std::recursive_mutex> guard(
         bkpt_sp->GetTarget().GetAPIMutex());
     bkpt_sp->SetEnabled(enable);
   }
 }
 
 bool SBBreakpoint::IsEnabled() {
   LLDB_RECORD_METHOD_NO_ARGS(bool, SBBreakpoint, IsEnabled);
 
   BreakpointSP bkpt_sp = GetSP();
   if (bkpt_sp) {
     std::lock_guard<std::recursive_mutex> guard(
         bkpt_sp->GetTarget().GetAPIMutex());
     return bkpt_sp->IsEnabled();
   } else
     return false;
 }
 
 void SBBreakpoint::SetOneShot(bool one_shot) {
   LLDB_RECORD_METHOD(void, SBBreakpoint, SetOneShot, (bool), one_shot);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   BreakpointSP bkpt_sp = GetSP();
 
-  LLDB_LOG(log, "breakpoint = {0}, one_shot = {1}", bkpt_sp.get(), one_shot);
-
   if (bkpt_sp) {
     std::lock_guard<std::recursive_mutex> guard(
         bkpt_sp->GetTarget().GetAPIMutex());
     bkpt_sp->SetOneShot(one_shot);
   }
 }
 
 bool SBBreakpoint::IsOneShot() const {
if (bkpt_sp) {
     return bkpt_sp->IsInternal();
   } else
     return false;
 }
 
 void SBBreakpoint::SetIgnoreCount(uint32_t count) {
   LLDB_RECORD_METHOD(void, SBBreakpoint, SetIgnoreCount, (uint32_t), count);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   BreakpointSP bkpt_sp = GetSP();
 
-  LLDB_LOG(log, "breakpoint = {0}, count = {1}", bkpt_sp.get(), count);
-
   if (bkpt_sp) {
     std::lock_guard<std::recursive_mutex> guard(
         bkpt_sp->GetTarget().GetAPIMutex());
     bkpt_sp->SetIgnoreCount(count);
   }
 }
 
 void SBBreakpoint::SetCondition(const char *condition) {
uint32_t SBBreakpoint::GetHitCount() const {
   uint32_t count = 0;
   BreakpointSP bkpt_sp = GetSP();
   if (bkpt_sp) {
     std::lock_guard<std::recursive_mutex> guard(
         bkpt_sp->GetTarget().GetAPIMutex());
     count = bkpt_sp->GetHitCount();
   }
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  LLDB_LOG(log, "breakpoint = {0}, count = {1}", bkpt_sp.get(), count);
-
   return count;
 }
 
 uint32_t SBBreakpoint::GetIgnoreCount() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBBreakpoint, GetIgnoreCount);
 
   uint32_t count = 0;
   BreakpointSP bkpt_sp = GetSP();
   if (bkpt_sp) {
     std::lock_guard<std::recursive_mutex> guard(
         bkpt_sp->GetTarget().GetAPIMutex());
     count = bkpt_sp->GetIgnoreCount();
   }
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  LLDB_LOG(log, "breakpoint = {0}, count = {1}", bkpt_sp.get(), count);
-
   return count;
 }
 
 void SBBreakpoint::SetThreadID(tid_t tid) {
   LLDB_RECORD_METHOD(void, SBBreakpoint, SetThreadID, (lldb::tid_t), tid);
 
   BreakpointSP bkpt_sp = GetSP();
   if (bkpt_sp) {
     std::lock_guard<std::recursive_mutex> guard(
         bkpt_sp->GetTarget().GetAPIMutex());
     bkpt_sp->SetThreadID(tid);
   }
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  LLDB_LOG(log, "breakpoint = {0}, tid = {1:x}", bkpt_sp.get(), tid);
 }
 
 tid_t SBBreakpoint::GetThreadID() {
   LLDB_RECORD_METHOD_NO_ARGS(lldb::tid_t, SBBreakpoint, GetThreadID);
 
   tid_t tid = LLDB_INVALID_THREAD_ID;
   BreakpointSP bkpt_sp = GetSP();
   if (bkpt_sp) {
     std::lock_guard<std::recursive_mutex> guard(
         bkpt_sp->GetTarget().GetAPIMutex());
     tid = bkpt_sp->GetThreadID();
   }
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  LLDB_LOG(log, "breakpoint = {0}, tid = {1:x}", bkpt_sp.get(), tid);
   return tid;
 }
 
 void SBBreakpoint::SetThreadIndex(uint32_t index) {
   LLDB_RECORD_METHOD(void, SBBreakpoint, SetThreadIndex, (uint32_t), index);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   BreakpointSP bkpt_sp = GetSP();
-  LLDB_LOG(log, "breakpoint = {0}, index = {1}", bkpt_sp.get(), index);
   if (bkpt_sp) {
     std::lock_guard<std::recursive_mutex> guard(
         bkpt_sp->GetTarget().GetAPIMutex());
     bkpt_sp->GetOptions()->GetThreadSpec()->SetIndex(index);
   }
 }
 
 uint32_t SBBreakpoint::GetThreadIndex() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBBreakpoint, GetThreadIndex);
 
   uint32_t thread_idx = UINT32_MAX;
   BreakpointSP bkpt_sp = GetSP();
   if (bkpt_sp) {
     std::lock_guard<std::recursive_mutex> guard(
         bkpt_sp->GetTarget().GetAPIMutex());
     const ThreadSpec *thread_spec =
         bkpt_sp->GetOptions()->GetThreadSpecNoCreate();
     if (thread_spec != nullptr)
       thread_idx = thread_spec->GetIndex();
   }
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  LLDB_LOG(log, "breakpoint = {0}, index = {1}", bkpt_sp.get(), thread_idx);
 
   return thread_idx;
 }
 
 void SBBreakpoint::SetThreadName(const char *thread_name) {
   LLDB_RECORD_METHOD(void, SBBreakpoint, SetThreadName, (const char *),
                      thread_name);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   BreakpointSP bkpt_sp = GetSP();
-  LLDB_LOG(log, "breakpoint = {0}, name = {1}", bkpt_sp.get(), thread_name);
 
   if (bkpt_sp) {
     std::lock_guard<std::recursive_mutex> guard(
         bkpt_sp->GetTarget().GetAPIMutex());
     bkpt_sp->GetOptions()->GetThreadSpec()->SetName(thread_name);
   }
 }
 
 const char *SBBreakpoint::GetThreadName() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBBreakpoint, GetThreadName);
 
   const char *name = nullptr;
   BreakpointSP bkpt_sp = GetSP();
   if (bkpt_sp) {
     std::lock_guard<std::recursive_mutex> guard(
         bkpt_sp->GetTarget().GetAPIMutex());
     const ThreadSpec *thread_spec =
         bkpt_sp->GetOptions()->GetThreadSpecNoCreate();
     if (thread_spec != nullptr)
       name = thread_spec->GetName();
   }
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  LLDB_LOG(log, "breakpoint = {0}, name = {1}", bkpt_sp.get(), name);
 
   return name;
 }
 
 void SBBreakpoint::SetQueueName(const char *queue_name) {
   LLDB_RECORD_METHOD(void, SBBreakpoint, SetQueueName, (const char *),
                      queue_name);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   BreakpointSP bkpt_sp = GetSP();
-  LLDB_LOG(log, "breakpoint = {0}, queue_name = {1}", bkpt_sp.get(),
-           queue_name);
   if (bkpt_sp) {
     std::lock_guard<std::recursive_mutex> guard(
         bkpt_sp->GetTarget().GetAPIMutex());
     bkpt_sp->GetOptions()->GetThreadSpec()->SetQueueName(queue_name);
   }
 }
 
 const char *SBBreakpoint::GetQueueName() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBBreakpoint, GetQueueName);
 
   const char *name = nullptr;
   BreakpointSP bkpt_sp = GetSP();
   if (bkpt_sp) {
     std::lock_guard<std::recursive_mutex> guard(
         bkpt_sp->GetTarget().GetAPIMutex());
     const ThreadSpec *thread_spec =
         bkpt_sp->GetOptions()->GetThreadSpecNoCreate();
     if (thread_spec)
       name = thread_spec->GetQueueName();
   }
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  LLDB_LOG(log, "breakpoint = {0}, name = {1}", bkpt_sp.get(), name);
 
   return name;
 }
 
 size_t SBBreakpoint::GetNumResolvedLocations() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(size_t, SBBreakpoint,
                                    GetNumResolvedLocations);
 
   size_t num_resolved = 0;
   BreakpointSP bkpt_sp = GetSP();
   if (bkpt_sp) {
     std::lock_guard<std::recursive_mutex> guard(
         bkpt_sp->GetTarget().GetAPIMutex());
     num_resolved = bkpt_sp->GetNumResolvedLocations();
   }
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  LLDB_LOG(log, "breakpoint = {0}, num_resolved = {1}", bkpt_sp.get(),
-           num_resolved);
   return num_resolved;
 }
 
 size_t SBBreakpoint::GetNumLocations() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(size_t, SBBreakpoint, GetNumLocations);
 
   BreakpointSP bkpt_sp = GetSP();
   size_t num_locs = 0;
   if (bkpt_sp) {
     std::lock_guard<std::recursive_mutex> guard(
         bkpt_sp->GetTarget().GetAPIMutex());
     num_locs = bkpt_sp->GetNumLocations();
   }
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  LLDB_LOG(log, "breakpoint = {0}, num_locs = {1}", bkpt_sp.get(), num_locs);
   return num_locs;
 }
 
 void SBBreakpoint::SetCommandLineCommands(SBStringList &commands) {
   LLDB_RECORD_METHOD(void, SBBreakpoint, SetCommandLineCommands,
                      (lldb::SBStringList &), commands);
 
   BreakpointSP bkpt_sp = GetSP();
error.SetErrorStringWithFormat("Address: %s didn't pass the filter.",
                                    s.GetData());
   }
   return LLDB_RECORD_RESULT(error);
 }
 
 void SBBreakpoint
   ::SetCallback(SBBreakpointHitCallback callback,
   void *baton) {
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   BreakpointSP bkpt_sp = GetSP();
-  LLDB_LOG(log, "breakpoint = {0}, callback = {1}, baton = {2}", bkpt_sp.get(),
-           callback, baton);
 
   if (bkpt_sp) {
     std::lock_guard<std::recursive_mutex> guard(
         bkpt_sp->GetTarget().GetAPIMutex());
     BatonSP baton_sp(new SBBreakpointCallbackBaton(callback, baton));
     bkpt_sp->SetCallback(SBBreakpointCallbackBaton
       ::PrivateBreakpointHitCallback, baton_sp,
                          false);
   }
 }
 
 void SBBreakpoint::SetScriptCallbackFunction(
     const char *callback_function_name) {
   LLDB_RECORD_METHOD(void, SBBreakpoint, SetScriptCallbackFunction,
                      (const char *), callback_function_name);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   BreakpointSP bkpt_sp = GetSP();
-  LLDB_LOG(log, "breakpoint = {0}, callback = {1}", bkpt_sp.get(),
-           callback_function_name);
 
   if (bkpt_sp) {
     std::lock_guard<std::recursive_mutex> guard(
         bkpt_sp->GetTarget().GetAPIMutex());
     BreakpointOptions *bp_options = bkpt_sp->GetOptions();
     bkpt_sp->GetTarget()
         .GetDebugger()
         .GetCommandInterpreter()
         .GetScriptInterpreter()
         ->SetBreakpointCommandCallbackFunction(bp_options,
                                                callback_function_name);
   }
 }
 
 SBError SBBreakpoint::SetScriptCallbackBody(const char *callback_body_text) {
   LLDB_RECORD_METHOD(lldb::SBError, SBBreakpoint, SetScriptCallbackBody,
                      (const char *), callback_body_text);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   BreakpointSP bkpt_sp = GetSP();
-  LLDB_LOG(log, "breakpoint = {0}, callback body:\n{1}", bkpt_sp.get(),
-           callback_body_text);
 
   SBError sb_error;
   if (bkpt_sp) {
     std::lock_guard<std::recursive_mutex> guard(
         bkpt_sp->GetTarget().GetAPIMutex());
     BreakpointOptions *bp_options = bkpt_sp->GetOptions();
     Status error =
         bkpt_sp->GetTarget()
             .GetDebugger()
             .GetCommandInterpreter()
             .GetScriptInterpreter()
             ->SetBreakpointCommandCallback(bp_options, callback_body_text);
     sb_error.SetError(error);
   } else
     sb_error.SetErrorString("invalid breakpoint");
 
   return LLDB_RECORD_RESULT(sb_error);
 }
 
 bool SBBreakpoint::AddName(const char *new_name) {
   LLDB_RECORD_METHOD(bool, SBBreakpoint, AddName, (const char *), new_name);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   BreakpointSP bkpt_sp = GetSP();
-  LLDB_LOG(log, "breakpoint = {0}, name = {1}", bkpt_sp.get(), new_name);
 
   if (bkpt_sp) {
     std::lock_guard<std::recursive_mutex> guard(
         bkpt_sp->GetTarget().GetAPIMutex());
     Status error; // Think I'm just going to swallow the error here, it's
                   // probably more annoying to have to provide it.
     bkpt_sp->GetTarget().AddNameToBreakpoint(bkpt_sp, new_name, error);
     if (error.Fail())
-    {
-      if (log)
-        log->Printf("Failed to add name: '%s' to breakpoint: %s", 
-            new_name, error.AsCString());
       return false;
-    }
-  }
 
   return true;
 }
 
 void SBBreakpoint::RemoveName(const char *name_to_remove) {
   LLDB_RECORD_METHOD(void, SBBreakpoint, RemoveName, (const char *),
                      name_to_remove);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   BreakpointSP bkpt_sp = GetSP();
-  LLDB_LOG(log, "breakpoint = {0}, name = {1}", bkpt_sp.get(), name_to_remove);
 
   if (bkpt_sp) {
     std::lock_guard<std::recursive_mutex> guard(
         bkpt_sp->GetTarget().GetAPIMutex());
-    bkpt_sp->GetTarget().RemoveNameFromBreakpoint(bkpt_sp, 
+    bkpt_sp->GetTarget().RemoveNameFromBreakpoint(bkpt_sp,
                                                   ConstString(name_to_remove));
   }
 }
 
 bool SBBreakpoint::MatchesName(const char *name) {
   LLDB_RECORD_METHOD(bool, SBBreakpoint, MatchesName, (const char *), name);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   BreakpointSP bkpt_sp = GetSP();
-  LLDB_LOG(log, "breakpoint = {0}, name = {1}", bkpt_sp.get(), name);
 
   if (bkpt_sp) {
     std::lock_guard<std::recursive_mutex> guard(
         bkpt_sp->GetTarget().GetAPIMutex());
     return bkpt_sp->MatchesName(name);
   }
 
   return false;
 }
 
 void SBBreakpoint::GetNames(SBStringList &names) {
   LLDB_RECORD_METHOD(void, SBBreakpoint, GetNames, (lldb::SBStringList &),
                      names);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   BreakpointSP bkpt_sp = GetSP();
-  LLDB_LOG(log, "breakpoint = {0}", bkpt_sp.get());
 
   if (bkpt_sp) {
     std::lock_guard<std::recursive_mutex> guard(
         bkpt_sp->GetTarget().GetAPIMutex());
     std::vector<std::string> names_vec;
     bkpt_sp->GetNames(names_vec);
     for (std::string name : names_vec) {
       names.AppendString(name.c_str());

source/API/SBBreakpointLocation.cpp

 #include "lldb/Breakpoint/Breakpoint.h"
 #include "lldb/Breakpoint/BreakpointLocation.h"
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/StreamFile.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Interpreter/ScriptInterpreter.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/ThreadSpec.h"
-#include "lldb/Utility/Log.h"
 #include "lldb/Utility/Stream.h"
 #include "lldb/lldb-defines.h"
 #include "lldb/lldb-types.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 SBBreakpointLocation::SBBreakpointLocation() {
   LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBBreakpointLocation);
 }
 
 SBBreakpointLocation::SBBreakpointLocation(
     const lldb::BreakpointLocationSP &break_loc_sp)
     : m_opaque_wp(break_loc_sp) {
   LLDB_RECORD_CONSTRUCTOR(SBBreakpointLocation,
                           (const lldb::BreakpointLocationSP &), break_loc_sp);
-
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-
-  if (log) {
-    SBStream sstr;
-    GetDescription(sstr, lldb::eDescriptionLevelBrief);
-    LLDB_LOG(log, "location = {0} ({1})", break_loc_sp.get(), sstr.GetData());
-  }
 }
 
 SBBreakpointLocation::SBBreakpointLocation(const SBBreakpointLocation &rhs)
     : m_opaque_wp(rhs.m_opaque_wp) {
   LLDB_RECORD_CONSTRUCTOR(SBBreakpointLocation,
                           (const lldb::SBBreakpointLocation &), rhs);
 }
 
bool SBBreakpointLocation::GetAutoContinue() {
   return false;
 }
 
 void SBBreakpointLocation::SetScriptCallbackFunction(
     const char *callback_function_name) {
   LLDB_RECORD_METHOD(void, SBBreakpointLocation, SetScriptCallbackFunction,
                      (const char *), callback_function_name);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   BreakpointLocationSP loc_sp = GetSP();
-  LLDB_LOG(log, "location = {0}, callback = {1}", loc_sp.get(),
-           callback_function_name);
 
   if (loc_sp) {
     std::lock_guard<std::recursive_mutex> guard(
         loc_sp->GetTarget().GetAPIMutex());
     BreakpointOptions *bp_options = loc_sp->GetLocationOptions();
     loc_sp->GetBreakpoint()
         .GetTarget()
         .GetDebugger()
         .GetCommandInterpreter()
         .GetScriptInterpreter()
         ->SetBreakpointCommandCallbackFunction(bp_options,
                                                callback_function_name);
   }
 }
 
 SBError
 SBBreakpointLocation::SetScriptCallbackBody(const char *callback_body_text) {
   LLDB_RECORD_METHOD(lldb::SBError, SBBreakpointLocation, SetScriptCallbackBody,
                      (const char *), callback_body_text);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   BreakpointLocationSP loc_sp = GetSP();
-  LLDB_LOG(log, "location = {0}: callback body:\n{1}", loc_sp.get(),
-           callback_body_text);
 
   SBError sb_error;
   if (loc_sp) {
     std::lock_guard<std::recursive_mutex> guard(
         loc_sp->GetTarget().GetAPIMutex());
     BreakpointOptions *bp_options = loc_sp->GetLocationOptions();
     Status error =
         loc_sp->GetBreakpoint()
break_id_t SBBreakpointLocation::GetID() {
   } else
     return LLDB_INVALID_BREAK_ID;
 }
 
 SBBreakpoint SBBreakpointLocation::GetBreakpoint() {
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBBreakpoint, SBBreakpointLocation,
                              GetBreakpoint);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   BreakpointLocationSP loc_sp = GetSP();
 
   SBBreakpoint sb_bp;
   if (loc_sp) {
     std::lock_guard<std::recursive_mutex> guard(
         loc_sp->GetTarget().GetAPIMutex());
     sb_bp = loc_sp->GetBreakpoint().shared_from_this();
   }
 
-  if (log) {
-    SBStream sstr;
-    sb_bp.GetDescription(sstr);
-    LLDB_LOG(log, "location = {0}, breakpoint = {1} ({2})", loc_sp.get(),
-             sb_bp.GetSP().get(), sstr.GetData());
-  }
   return LLDB_RECORD_RESULT(sb_bp);
 }

source/API/SBBreakpointName.cpp

 
 #include "lldb/Breakpoint/BreakpointName.h"
 #include "lldb/Breakpoint/StoppointCallbackContext.h"
 #include "lldb/Core/Debugger.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Interpreter/ScriptInterpreter.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/ThreadSpec.h"
-#include "lldb/Utility/Log.h"
 #include "lldb/Utility/Stream.h"
 
 #include "SBBreakpointOptionCommon.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 namespace lldb
 {
 class SBBreakpointNameImpl {
 public:
   SBBreakpointNameImpl(TargetSP target_sp, const char *name) {
     if (!name || name[0] == '\0')
       return;
     m_name.assign(name);
-    
     if (!target_sp)
       return;
-    
     m_target_wp = target_sp;
   }
 
   SBBreakpointNameImpl(SBTarget &sb_target, const char *name);
   bool operator==(const SBBreakpointNameImpl &rhs);
   bool operator!=(const SBBreakpointNameImpl &rhs);
 
   // For now we take a simple approach and only keep the name, and relook up
   // the location when we need it.
-  
   TargetSP GetTarget() const {
     return m_target_wp.lock();
   }
-  
   const char *GetName() const {
     return m_name.c_str();
   }
-  
   bool IsValid() const {
     return !m_name.empty() && m_target_wp.lock();
   }
 
   lldb_private::BreakpointName *GetBreakpointName() const;
 
 private:
   TargetWP m_target_wp;
SBBreakpointName::SBBreakpointName(SBBreakpoint &sb_bkpt, const char *name) {
   if (!sb_bkpt.IsValid()) {
     m_impl_up.reset();
     return;
   }
   BreakpointSP bkpt_sp = sb_bkpt.GetSP();
   Target &target = bkpt_sp->GetTarget();
 
   m_impl_up.reset(new SBBreakpointNameImpl(target.shared_from_this(), name));
-  
   // Call FindBreakpointName here to make sure the name is valid, reset if not:
   BreakpointName *bp_name = GetBreakpointName();
   if (!bp_name) {
     m_impl_up.reset();
     return;
   }
-  
   // Now copy over the breakpoint's options:
   target.ConfigureBreakpointName(*bp_name, *bkpt_sp->GetOptions(),
                                  BreakpointName::Permissions());
 }
 
 SBBreakpointName::SBBreakpointName(const SBBreakpointName &rhs) {
   LLDB_RECORD_CONSTRUCTOR(SBBreakpointName, (const lldb::SBBreakpointName &),
                           rhs);
operator=(const SBBreakpointName &rhs) {
   LLDB_RECORD_METHOD(
       const lldb::SBBreakpointName &,
       SBBreakpointName, operator=,(const lldb::SBBreakpointName &), rhs);
 
   if (!rhs.m_impl_up) {
     m_impl_up.reset();
     return *this;
   }
-  
   m_impl_up.reset(new SBBreakpointNameImpl(rhs.m_impl_up->GetTarget(),
                                            rhs.m_impl_up->GetName()));
   return *this;
 }
 
 bool SBBreakpointName::operator==(const lldb::SBBreakpointName &rhs) {
   LLDB_RECORD_METHOD(
       bool, SBBreakpointName, operator==,(const lldb::SBBreakpointName &), rhs);
const char *SBBreakpointName::GetName() const {
   if (!m_impl_up)
     return "<Invalid Breakpoint Name Object>";
   return m_impl_up->GetName();
 }
 
 void SBBreakpointName::SetEnabled(bool enable) {
   LLDB_RECORD_METHOD(void, SBBreakpointName, SetEnabled, (bool), enable);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  
   BreakpointName *bp_name = GetBreakpointName();
   if (!bp_name)
     return;
- 
-  LLDB_LOG(log, "Name: {0} enabled: {1}\n", bp_name->GetName(), enable);
   std::lock_guard<std::recursive_mutex> guard(
         m_impl_up->GetTarget()->GetAPIMutex());
 
   bp_name->GetOptions().SetEnabled(enable);
 }
 
 void SBBreakpointName::UpdateName(BreakpointName &bp_name) {
   if (!IsValid())
     return;
 
   TargetSP target_sp = m_impl_up->GetTarget();
   if (!target_sp)
     return;
   target_sp->ApplyNameToBreakpoints(bp_name);
 
 }
 
 bool SBBreakpointName::IsEnabled() {
   LLDB_RECORD_METHOD_NO_ARGS(bool, SBBreakpointName, IsEnabled);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  
   BreakpointName *bp_name = GetBreakpointName();
   if (!bp_name)
     return false;
- 
-  LLDB_LOG(log, "Name: {0}\n", bp_name->GetName());
   std::lock_guard<std::recursive_mutex> guard(
         m_impl_up->GetTarget()->GetAPIMutex());
 
   return bp_name->GetOptions().IsEnabled();
 }
 
 void SBBreakpointName::SetOneShot(bool one_shot) {
   LLDB_RECORD_METHOD(void, SBBreakpointName, SetOneShot, (bool), one_shot);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  
   BreakpointName *bp_name = GetBreakpointName();
   if (!bp_name)
     return;
- 
-  LLDB_LOG(log, "Name: {0} one_shot: {1}\n", bp_name->GetName(), one_shot);
   std::lock_guard<std::recursive_mutex> guard(
         m_impl_up->GetTarget()->GetAPIMutex());
 
   bp_name->GetOptions().SetOneShot(one_shot);
   UpdateName(*bp_name);
 }
 
 bool SBBreakpointName::IsOneShot() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBreakpointName, IsOneShot);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  
   const BreakpointName *bp_name = GetBreakpointName();
   if (!bp_name)
     return false;
- 
-  LLDB_LOG(log, "Name: {0}\n", bp_name->GetName());
   std::lock_guard<std::recursive_mutex> guard(
         m_impl_up->GetTarget()->GetAPIMutex());
 
   return bp_name->GetOptions().IsOneShot();
 }
 
 void SBBreakpointName::SetIgnoreCount(uint32_t count) {
   LLDB_RECORD_METHOD(void, SBBreakpointName, SetIgnoreCount, (uint32_t), count);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  
   BreakpointName *bp_name = GetBreakpointName();
   if (!bp_name)
     return;
- 
-  LLDB_LOG(log, "Name: {0} one_shot: {1}\n", bp_name->GetName(), count);
   std::lock_guard<std::recursive_mutex> guard(
         m_impl_up->GetTarget()->GetAPIMutex());
 
   bp_name->GetOptions().SetIgnoreCount(count);
   UpdateName(*bp_name);
 }
 
 uint32_t SBBreakpointName::GetIgnoreCount() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBBreakpointName, GetIgnoreCount);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  
   BreakpointName *bp_name = GetBreakpointName();
   if (!bp_name)
     return false;
- 
-  LLDB_LOG(log, "Name: {0}\n", bp_name->GetName());
   std::lock_guard<std::recursive_mutex> guard(
         m_impl_up->GetTarget()->GetAPIMutex());
 
   return bp_name->GetOptions().GetIgnoreCount();
 }
 
 void SBBreakpointName::SetCondition(const char *condition) {
   LLDB_RECORD_METHOD(void, SBBreakpointName, SetCondition, (const char *),
                      condition);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  
   BreakpointName *bp_name = GetBreakpointName();
   if (!bp_name)
     return;
- 
-  LLDB_LOG(log, "Name: {0} one_shot: {1}\n", bp_name->GetName(),
-          condition ? condition : "<NULL>");
-  
   std::lock_guard<std::recursive_mutex> guard(
         m_impl_up->GetTarget()->GetAPIMutex());
 
   bp_name->GetOptions().SetCondition(condition);
   UpdateName(*bp_name);
 }
 
 const char *SBBreakpointName::GetCondition() {
   LLDB_RECORD_METHOD_NO_ARGS(const char *, SBBreakpointName, GetCondition);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  
   BreakpointName *bp_name = GetBreakpointName();
   if (!bp_name)
     return nullptr;
- 
-  LLDB_LOG(log, "Name: {0}\n", bp_name->GetName());
   std::lock_guard<std::recursive_mutex> guard(
         m_impl_up->GetTarget()->GetAPIMutex());
 
   return bp_name->GetOptions().GetConditionText();
 }
 
 void SBBreakpointName::SetAutoContinue(bool auto_continue) {
   LLDB_RECORD_METHOD(void, SBBreakpointName, SetAutoContinue, (bool),
                      auto_continue);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  
   BreakpointName *bp_name = GetBreakpointName();
   if (!bp_name)
     return;
- 
-  LLDB_LOG(log, "Name: {0} auto-continue: {1}\n", bp_name->GetName(), auto_continue);
-  
   std::lock_guard<std::recursive_mutex> guard(
         m_impl_up->GetTarget()->GetAPIMutex());
 
   bp_name->GetOptions().SetAutoContinue(auto_continue);
   UpdateName(*bp_name);
 }
 
 bool SBBreakpointName::GetAutoContinue() {
   LLDB_RECORD_METHOD_NO_ARGS(bool, SBBreakpointName, GetAutoContinue);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  
   BreakpointName *bp_name = GetBreakpointName();
   if (!bp_name)
     return false;
- 
-  LLDB_LOG(log, "Name: {0}\n", bp_name->GetName());
   std::lock_guard<std::recursive_mutex> guard(
         m_impl_up->GetTarget()->GetAPIMutex());
 
   return bp_name->GetOptions().IsAutoContinue();
 }
 
 void SBBreakpointName::SetThreadID(tid_t tid) {
   LLDB_RECORD_METHOD(void, SBBreakpointName, SetThreadID, (lldb::tid_t), tid);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  
   BreakpointName *bp_name = GetBreakpointName();
   if (!bp_name)
     return;
- 
-  LLDB_LOG(log, "Name: {0} tid: {1:x}\n", bp_name->GetName(), tid);
-  
   std::lock_guard<std::recursive_mutex> guard(
         m_impl_up->GetTarget()->GetAPIMutex());
 
   bp_name->GetOptions().SetThreadID(tid);
   UpdateName(*bp_name);
 }
 
 tid_t SBBreakpointName::GetThreadID() {
   LLDB_RECORD_METHOD_NO_ARGS(lldb::tid_t, SBBreakpointName, GetThreadID);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  
   BreakpointName *bp_name = GetBreakpointName();
   if (!bp_name)
     return LLDB_INVALID_THREAD_ID;
- 
-  LLDB_LOG(log, "Name: {0}\n", bp_name->GetName());
   std::lock_guard<std::recursive_mutex> guard(
         m_impl_up->GetTarget()->GetAPIMutex());
 
   return bp_name->GetOptions().GetThreadSpec()->GetTID();
 }
 
 void SBBreakpointName::SetThreadIndex(uint32_t index) {
   LLDB_RECORD_METHOD(void, SBBreakpointName, SetThreadIndex, (uint32_t), index);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  
   BreakpointName *bp_name = GetBreakpointName();
   if (!bp_name)
     return;
- 
-  LLDB_LOG(log, "Name: {0} thread index: {1}\n", bp_name->GetName(), index);
-  
   std::lock_guard<std::recursive_mutex> guard(
         m_impl_up->GetTarget()->GetAPIMutex());
 
   bp_name->GetOptions().GetThreadSpec()->SetIndex(index);
   UpdateName(*bp_name);
 }
 
 uint32_t SBBreakpointName::GetThreadIndex() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBBreakpointName, GetThreadIndex);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  
   BreakpointName *bp_name = GetBreakpointName();
   if (!bp_name)
     return LLDB_INVALID_THREAD_ID;
- 
-  LLDB_LOG(log, "Name: {0}\n", bp_name->GetName());
   std::lock_guard<std::recursive_mutex> guard(
         m_impl_up->GetTarget()->GetAPIMutex());
 
   return bp_name->GetOptions().GetThreadSpec()->GetIndex();
 }
 
 void SBBreakpointName::SetThreadName(const char *thread_name) {
   LLDB_RECORD_METHOD(void, SBBreakpointName, SetThreadName, (const char *),
                      thread_name);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  
   BreakpointName *bp_name = GetBreakpointName();
   if (!bp_name)
     return;
- 
-  LLDB_LOG(log, "Name: {0} thread name: {1}\n", bp_name->GetName(), thread_name);
-  
   std::lock_guard<std::recursive_mutex> guard(
         m_impl_up->GetTarget()->GetAPIMutex());
 
   bp_name->GetOptions().GetThreadSpec()->SetName(thread_name);
   UpdateName(*bp_name);
 }
 
 const char *SBBreakpointName::GetThreadName() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBBreakpointName,
                                    GetThreadName);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  
   BreakpointName *bp_name = GetBreakpointName();
   if (!bp_name)
     return nullptr;
- 
-  LLDB_LOG(log, "Name: {0}\n", bp_name->GetName());
   std::lock_guard<std::recursive_mutex> guard(
         m_impl_up->GetTarget()->GetAPIMutex());
 
   return bp_name->GetOptions().GetThreadSpec()->GetName();
 }
 
 void SBBreakpointName::SetQueueName(const char *queue_name) {
   LLDB_RECORD_METHOD(void, SBBreakpointName, SetQueueName, (const char *),
                      queue_name);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  
   BreakpointName *bp_name = GetBreakpointName();
   if (!bp_name)
     return;
- 
-  LLDB_LOG(log, "Name: {0} queue name: {1}\n", bp_name->GetName(), queue_name);
-  
   std::lock_guard<std::recursive_mutex> guard(
         m_impl_up->GetTarget()->GetAPIMutex());
 
   bp_name->GetOptions().GetThreadSpec()->SetQueueName(queue_name);
   UpdateName(*bp_name);
 }
 
 const char *SBBreakpointName::GetQueueName() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBBreakpointName,
                                    GetQueueName);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  
   BreakpointName *bp_name = GetBreakpointName();
   if (!bp_name)
     return nullptr;
- 
-  LLDB_LOG(log, "Name: {0}\n", bp_name->GetName());
   std::lock_guard<std::recursive_mutex> guard(
         m_impl_up->GetTarget()->GetAPIMutex());
 
   return bp_name->GetOptions().GetThreadSpec()->GetQueueName();
 }
 
 void SBBreakpointName::SetCommandLineCommands(SBStringList &commands) {
   LLDB_RECORD_METHOD(void, SBBreakpointName, SetCommandLineCommands,
                      (lldb::SBStringList &), commands);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   BreakpointName *bp_name = GetBreakpointName();
   if (!bp_name)
     return;
   if (commands.GetSize() == 0)
     return;
 
-  LLDB_LOG(log, "Name: {0} commands\n", bp_name->GetName());
 
   std::lock_guard<std::recursive_mutex> guard(
         m_impl_up->GetTarget()->GetAPIMutex());
   std::unique_ptr<BreakpointOptions::CommandData> cmd_data_up(
       new BreakpointOptions::CommandData(*commands, eScriptLanguageNone));
 
   bp_name->GetOptions().SetCommandDataCallback(cmd_data_up);
   UpdateName(*bp_name);
 }
 
 bool SBBreakpointName::GetCommandLineCommands(SBStringList &commands) {
   LLDB_RECORD_METHOD(bool, SBBreakpointName, GetCommandLineCommands,
                      (lldb::SBStringList &), commands);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  
   BreakpointName *bp_name = GetBreakpointName();
   if (!bp_name)
     return false;
- 
-  LLDB_LOG(log, "Name: {0}\n", bp_name->GetName());
   StringList command_list;
   bool has_commands =
       bp_name->GetOptions().GetCommandLineCallbacks(command_list);
   if (has_commands)
     commands.AppendList(command_list);
   return has_commands;
 }
 
 const char *SBBreakpointName::GetHelpString() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBBreakpointName,
                                    GetHelpString);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  
   BreakpointName *bp_name = GetBreakpointName();
   if (!bp_name)
     return "";
- 
-  LLDB_LOG(log, "Help: {0}\n", bp_name->GetHelp());
   return bp_name->GetHelp();
 }
 
 void SBBreakpointName::SetHelpString(const char *help_string) {
   LLDB_RECORD_METHOD(void, SBBreakpointName, SetHelpString, (const char *),
                      help_string);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   BreakpointName *bp_name = GetBreakpointName();
   if (!bp_name)
     return;
 
-  LLDB_LOG(log, "Name: {0} help: {1}\n", bp_name->GetName(), help_string);
 
   std::lock_guard<std::recursive_mutex> guard(
         m_impl_up->GetTarget()->GetAPIMutex());
   bp_name->SetHelp(help_string);
 }
 
 bool SBBreakpointName::GetDescription(SBStream &s) {
   LLDB_RECORD_METHOD(bool, SBBreakpointName, GetDescription, (lldb::SBStream &),
                      s);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  
   BreakpointName *bp_name = GetBreakpointName();
   if (!bp_name)
   {
     s.Printf("No value");
     return false;
   }
- 
-  LLDB_LOG(log, "Name: {0}\n", bp_name->GetName());
   std::lock_guard<std::recursive_mutex> guard(
         m_impl_up->GetTarget()->GetAPIMutex());
   bp_name->GetDescription(s.get(), eDescriptionLevelFull);
   return true;
 }
 
 void SBBreakpointName::SetCallback(SBBreakpointHitCallback callback,
                                    void *baton) {
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   BreakpointName *bp_name = GetBreakpointName();
   if (!bp_name)
     return;
-  LLDB_LOG(log, "callback = {1}, baton = {2}", callback, baton);
   std::lock_guard<std::recursive_mutex> guard(
         m_impl_up->GetTarget()->GetAPIMutex());
 
   BatonSP baton_sp(new SBBreakpointCallbackBaton(callback, baton));
   bp_name->GetOptions().SetCallback(SBBreakpointCallbackBaton
                                        ::PrivateBreakpointHitCallback,
                                     baton_sp,
                                     false);
   UpdateName(*bp_name);
 }
 
 void SBBreakpointName::SetScriptCallbackFunction(
     const char *callback_function_name) {
   LLDB_RECORD_METHOD(void, SBBreakpointName, SetScriptCallbackFunction,
                      (const char *), callback_function_name);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  
   BreakpointName *bp_name = GetBreakpointName();
   if (!bp_name)
     return;
- 
-  LLDB_LOG(log, "Name: {0} callback: {1}\n", bp_name->GetName(),
-           callback_function_name);
-  
   std::lock_guard<std::recursive_mutex> guard(
         m_impl_up->GetTarget()->GetAPIMutex());
 
   BreakpointOptions &bp_options = bp_name->GetOptions();
   m_impl_up->GetTarget()
       ->GetDebugger()
       .GetCommandInterpreter()
       .GetScriptInterpreter()
       ->SetBreakpointCommandCallbackFunction(&bp_options,
                                              callback_function_name);
   UpdateName(*bp_name);
 }
 
 SBError
 SBBreakpointName::SetScriptCallbackBody(const char *callback_body_text) {
   LLDB_RECORD_METHOD(lldb::SBError, SBBreakpointName, SetScriptCallbackBody,
                      (const char *), callback_body_text);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   SBError sb_error;
   BreakpointName *bp_name = GetBreakpointName();
   if (!bp_name)
     return LLDB_RECORD_RESULT(sb_error);
 
-  LLDB_LOG(log, "Name: {0} callback: {1}\n", bp_name->GetName(),
-           callback_body_text);
-  
   std::lock_guard<std::recursive_mutex> guard(
         m_impl_up->GetTarget()->GetAPIMutex());
 
   BreakpointOptions &bp_options = bp_name->GetOptions();
   Status error =
       m_impl_up->GetTarget()
           ->GetDebugger()
           .GetCommandInterpreter()
bool SBBreakpointName::GetAllowList() const {
   if (!bp_name)
     return false;
   return bp_name->GetPermissions().GetAllowList();
 }
 
 void SBBreakpointName::SetAllowList(bool value) {
   LLDB_RECORD_METHOD(void, SBBreakpointName, SetAllowList, (bool), value);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   BreakpointName *bp_name = GetBreakpointName();
   if (!bp_name)
     return;
-  if (log)
-    log->Printf("Setting allow list to %u for %s.", value, 
-                bp_name->GetName().AsCString());
   bp_name->GetPermissions().SetAllowList(value);
 }
 
 bool SBBreakpointName::GetAllowDelete() {
   LLDB_RECORD_METHOD_NO_ARGS(bool, SBBreakpointName, GetAllowDelete);
 
   BreakpointName *bp_name = GetBreakpointName();
   if (!bp_name)
     return false;
   return bp_name->GetPermissions().GetAllowDelete();
 }
 
 void SBBreakpointName::SetAllowDelete(bool value) {
   LLDB_RECORD_METHOD(void, SBBreakpointName, SetAllowDelete, (bool), value);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   BreakpointName *bp_name = GetBreakpointName();
   if (!bp_name)
     return;
-  if (log)
-    log->Printf("Setting allow delete to %u for %s.", value, 
-                bp_name->GetName().AsCString());
   bp_name->GetPermissions().SetAllowDelete(value);
 }
 
 bool SBBreakpointName::GetAllowDisable() {
   LLDB_RECORD_METHOD_NO_ARGS(bool, SBBreakpointName, GetAllowDisable);
 
   BreakpointName *bp_name = GetBreakpointName();
   if (!bp_name)
     return false;
   return bp_name->GetPermissions().GetAllowDisable();
 }
 
 void SBBreakpointName::SetAllowDisable(bool value) {
   LLDB_RECORD_METHOD(void, SBBreakpointName, SetAllowDisable, (bool), value);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-
   BreakpointName *bp_name = GetBreakpointName();
   if (!bp_name)
     return;
-  if (log)
-    log->Printf("Setting allow disable to %u for %s.", value, 
-                bp_name->GetName().AsCString());
   bp_name->GetPermissions().SetAllowDisable(value);
 }
 
 lldb_private::BreakpointName *SBBreakpointName::GetBreakpointName() const
 {
   if (!IsValid())
     return nullptr;
   return m_impl_up->GetBreakpointName();
 }
 

source/API/SBBroadcaster.cpp

 //===-- SBBroadcaster.cpp ---------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "SBReproducerPrivate.h"
 #include "lldb/Utility/Broadcaster.h"
-#include "lldb/Utility/Log.h"
 
 #include "lldb/API/SBBroadcaster.h"
 #include "lldb/API/SBEvent.h"
 #include "lldb/API/SBListener.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 SBBroadcaster::SBBroadcaster() : m_opaque_sp(), m_opaque_ptr(NULL) {
   LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBBroadcaster);
 }
 
 SBBroadcaster::SBBroadcaster(const char *name)
     : m_opaque_sp(new Broadcaster(NULL, name)), m_opaque_ptr(NULL) {
   LLDB_RECORD_CONSTRUCTOR(SBBroadcaster, (const char *), name);
 
   m_opaque_ptr = m_opaque_sp.get();
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  LLDB_LOGV(log, "(name=\"{0}\") => SBBroadcaster({1})", name, m_opaque_ptr);
 }
 
 SBBroadcaster::SBBroadcaster(lldb_private::Broadcaster *broadcaster, bool owns)
     : m_opaque_sp(owns ? broadcaster : NULL), m_opaque_ptr(broadcaster) {
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  LLDB_LOGV(log, "(broadcaster={0}, owns={1}) => SBBroadcaster({2})",
-            broadcaster, owns, m_opaque_ptr);
 }
 
 SBBroadcaster::SBBroadcaster(const SBBroadcaster &rhs)
     : m_opaque_sp(rhs.m_opaque_sp), m_opaque_ptr(rhs.m_opaque_ptr) {
   LLDB_RECORD_CONSTRUCTOR(SBBroadcaster, (const lldb::SBBroadcaster &), rhs);
 }
 
 const SBBroadcaster &SBBroadcaster::operator=(const SBBroadcaster &rhs) {

 }
 
 SBBroadcaster::~SBBroadcaster() { reset(NULL, false); }
 
 void SBBroadcaster::BroadcastEventByType(uint32_t event_type, bool unique) {
   LLDB_RECORD_METHOD(void, SBBroadcaster, BroadcastEventByType,
                      (uint32_t, bool), event_type, unique);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-
-  if (log)
-    log->Printf("SBBroadcaster(%p)::BroadcastEventByType (event_type=0x%8.8x, "
-                "unique=%i)",
-                static_cast<void *>(m_opaque_ptr), event_type, unique);
-
   if (m_opaque_ptr == NULL)
     return;
 
   if (unique)
     m_opaque_ptr->BroadcastEventIfUnique(event_type);
   else
     m_opaque_ptr->BroadcastEvent(event_type);
 }
 
 void SBBroadcaster::BroadcastEvent(const SBEvent &event, bool unique) {
   LLDB_RECORD_METHOD(void, SBBroadcaster, BroadcastEvent,
                      (const lldb::SBEvent &, bool), event, unique);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-
-  if (log)
-    log->Printf(
-        "SBBroadcaster(%p)::BroadcastEventByType (SBEvent(%p), unique=%i)",
-        static_cast<void *>(m_opaque_ptr), static_cast<void *>(event.get()),
-        unique);
-
   if (m_opaque_ptr == NULL)
     return;
 
   EventSP event_sp = event.GetSP();
   if (unique)
     m_opaque_ptr->BroadcastEventIfUnique(event_sp);
   else
     m_opaque_ptr->BroadcastEvent(event_sp);
 }
 
 void SBBroadcaster::AddInitialEventsToListener(const SBListener &listener,
                                                uint32_t requested_events) {
   LLDB_RECORD_METHOD(void, SBBroadcaster, AddInitialEventsToListener,
                      (const lldb::SBListener &, uint32_t), listener,
                      requested_events);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  if (log)
-    log->Printf("SBBroadcaster(%p)::AddInitialEventsToListener "
-                "(SBListener(%p), event_mask=0x%8.8x)",
-                static_cast<void *>(m_opaque_ptr),
-                static_cast<void *>(listener.get()), requested_events);
   if (m_opaque_ptr)
     m_opaque_ptr->AddInitialEventsToListener(listener.m_opaque_sp,
                                              requested_events);
 }
 
 uint32_t SBBroadcaster::AddListener(const SBListener &listener,
                                     uint32_t event_mask) {
   LLDB_RECORD_METHOD(uint32_t, SBBroadcaster, AddListener,

source/API/SBCommandInterpreter.cpp

protected:
   std::shared_ptr<lldb::SBCommandPluginInterface> m_backend;
 };
 
 SBCommandInterpreter::SBCommandInterpreter(CommandInterpreter *interpreter)
     : m_opaque_ptr(interpreter) {
   LLDB_RECORD_CONSTRUCTOR(SBCommandInterpreter,
                           (lldb_private::CommandInterpreter *), interpreter);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-
-  if (log)
-    log->Printf("SBCommandInterpreter::SBCommandInterpreter (interpreter=%p)"
-                " => SBCommandInterpreter(%p)",
-                static_cast<void *>(interpreter),
-                static_cast<void *>(m_opaque_ptr));
 }
 
 SBCommandInterpreter::SBCommandInterpreter(const SBCommandInterpreter &rhs)
     : m_opaque_ptr(rhs.m_opaque_ptr) {
   LLDB_RECORD_CONSTRUCTOR(SBCommandInterpreter,
                           (const lldb::SBCommandInterpreter &), rhs);
 }
 

 lldb::ReturnStatus SBCommandInterpreter::HandleCommand(
     const char *command_line, SBExecutionContext &override_context,
     SBCommandReturnObject &result, bool add_to_history) {
   LLDB_RECORD_METHOD(lldb::ReturnStatus, SBCommandInterpreter, HandleCommand,
                      (const char *, lldb::SBExecutionContext &,
                       lldb::SBCommandReturnObject &, bool),
                      command_line, override_context, result, add_to_history);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-
-  if (log)
-    log->Printf("SBCommandInterpreter(%p)::HandleCommand (command=\"%s\", "
-                "SBCommandReturnObject(%p), add_to_history=%i)",
-                static_cast<void *>(m_opaque_ptr), command_line,
-                static_cast<void *>(result.get()), add_to_history);
 
   ExecutionContext ctx, *ctx_ptr;
   if (override_context.get()) {
     ctx = override_context.get()->Lock(true);
     ctx_ptr = &ctx;
   } else
     ctx_ptr = nullptr;
 
   result.Clear();
   if (command_line && IsValid()) {
     result.ref().SetInteractive(false);
     m_opaque_ptr->HandleCommand(command_line,
                                 add_to_history ? eLazyBoolYes : eLazyBoolNo,
                                 result.ref(), ctx_ptr);
   } else {
     result->AppendError(
         "SBCommandInterpreter or the command line is not valid");
     result->SetStatus(eReturnStatusFailed);
   }
 
-  // We need to get the value again, in case the command disabled the log!
-  log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API);
-  if (log) {
-    SBStream sstr;
-    result.GetDescription(sstr);
-    log->Printf("SBCommandInterpreter(%p)::HandleCommand (command=\"%s\", "
-                "SBCommandReturnObject(%p): %s, add_to_history=%i) => %i",
-                static_cast<void *>(m_opaque_ptr), command_line,
-                static_cast<void *>(result.get()), sstr.GetData(),
-                add_to_history, result.GetStatus());
-  }
 
   return result.GetStatus();
 }
 
 void SBCommandInterpreter::HandleCommandsFromFile(
     lldb::SBFileSpec &file, lldb::SBExecutionContext &override_context,
     lldb::SBCommandInterpreterRunOptions &options,
     lldb::SBCommandReturnObject result) {
   LLDB_RECORD_METHOD(void, SBCommandInterpreter, HandleCommandsFromFile,
                      (lldb::SBFileSpec &, lldb::SBExecutionContext &,
                       lldb::SBCommandInterpreterRunOptions &,
                       lldb::SBCommandReturnObject),
                      file, override_context, options, result);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-
-  if (log) {
-    SBStream s;
-    file.GetDescription(s);
-    log->Printf("SBCommandInterpreter(%p)::HandleCommandsFromFile "
-                "(file=\"%s\", SBCommandReturnObject(%p))",
-                static_cast<void *>(m_opaque_ptr), s.GetData(),
-                static_cast<void *>(result.get()));
-  }
-
   if (!IsValid()) {
     result->AppendError("SBCommandInterpreter is not valid.");
     result->SetStatus(eReturnStatusFailed);
     return;
   }
 
   if (!file.IsValid()) {
     SBStream s;
int SBCommandInterpreter::HandleCompletionWithDescriptions(
     SBStringList &descriptions) {
   LLDB_RECORD_METHOD(int, SBCommandInterpreter,
                      HandleCompletionWithDescriptions,
                      (const char *, const char *, const char *, int, int,
                       lldb::SBStringList &, lldb::SBStringList &),
                      current_line, cursor, last_char, match_start_point,
                      max_return_elements, matches, descriptions);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   int num_completions = 0;
 
   // Sanity check the arguments that are passed in: cursor & last_char have to
   // be within the current_line.
   if (current_line == nullptr || cursor == nullptr || last_char == nullptr)
     return 0;
 
   if (cursor < current_line || last_char < current_line)
     return 0;
 
   size_t current_line_size = strlen(current_line);
   if (cursor - current_line > static_cast<ptrdiff_t>(current_line_size) ||
       last_char - current_line > static_cast<ptrdiff_t>(current_line_size))
     return 0;
 
-  if (log)
-    log->Printf("SBCommandInterpreter(%p)::HandleCompletion "
-                "(current_line=\"%s\", cursor at: %" PRId64
-                ", last char at: %" PRId64
-                ", match_start_point: %d, max_return_elements: %d)",
-                static_cast<void *>(m_opaque_ptr), current_line,
-                static_cast<uint64_t>(cursor - current_line),
-                static_cast<uint64_t>(last_char - current_line),
-                match_start_point, max_return_elements);
 
   if (IsValid()) {
     lldb_private::StringList lldb_matches, lldb_descriptions;
     num_completions = m_opaque_ptr->HandleCompletion(
         current_line, cursor, last_char, match_start_point, max_return_elements,
         lldb_matches, lldb_descriptions);
 
     SBStringList temp_matches_list(&lldb_matches);
     matches.AppendList(temp_matches_list);
     SBStringList temp_descriptions_list(&lldb_descriptions);
     descriptions.AppendList(temp_descriptions_list);
   }
-  if (log)
-    log->Printf(
-        "SBCommandInterpreter(%p)::HandleCompletion - Found %d completions.",
-        static_cast<void *>(m_opaque_ptr), num_completions);
 
   return num_completions;
 }
 
 int SBCommandInterpreter::HandleCompletionWithDescriptions(
     const char *current_line, uint32_t cursor_pos, int match_start_point,
     int max_return_elements, SBStringList &matches,
     SBStringList &descriptions) {
SBProcess SBCommandInterpreter::GetProcess() {
   if (IsValid()) {
     TargetSP target_sp(m_opaque_ptr->GetDebugger().GetSelectedTarget());
     if (target_sp) {
       std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
       process_sp = target_sp->GetProcessSP();
       sb_process.SetSP(process_sp);
     }
   }
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-
-  if (log)
-    log->Printf("SBCommandInterpreter(%p)::GetProcess () => SBProcess(%p)",
-                static_cast<void *>(m_opaque_ptr),
-                static_cast<void *>(process_sp.get()));
 
   return LLDB_RECORD_RESULT(sb_process);
 }
 
 SBDebugger SBCommandInterpreter::GetDebugger() {
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBDebugger, SBCommandInterpreter,
                              GetDebugger);
 
   SBDebugger sb_debugger;
   if (IsValid())
     sb_debugger.reset(m_opaque_ptr->GetDebugger().shared_from_this());
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-
-  if (log)
-    log->Printf("SBCommandInterpreter(%p)::GetDebugger () => SBDebugger(%p)",
-                static_cast<void *>(m_opaque_ptr),
-                static_cast<void *>(sb_debugger.get()));
 
   return LLDB_RECORD_RESULT(sb_debugger);
 }
 
 bool SBCommandInterpreter::GetPromptOnQuit() {
   LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommandInterpreter, GetPromptOnQuit);
 
   return (IsValid() ? m_opaque_ptr->GetPromptOnQuit() : false);
if (IsValid()) {
     std::unique_lock<std::recursive_mutex> lock;
     if (target_sp)
       lock = std::unique_lock<std::recursive_mutex>(target_sp->GetAPIMutex());
     m_opaque_ptr->SourceInitFile(false, result.ref());
   } else {
     result->AppendError("SBCommandInterpreter is not valid");
     result->SetStatus(eReturnStatusFailed);
   }
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-
-  if (log)
-    log->Printf("SBCommandInterpreter(%p)::SourceInitFileInHomeDirectory "
-                "(&SBCommandReturnObject(%p))",
-                static_cast<void *>(m_opaque_ptr),
-                static_cast<void *>(result.get()));
 }
 
 void SBCommandInterpreter::SourceInitFileInCurrentWorkingDirectory(
     SBCommandReturnObject &result) {
   LLDB_RECORD_METHOD(void, SBCommandInterpreter,
                      SourceInitFileInCurrentWorkingDirectory,
                      (lldb::SBCommandReturnObject &), result);
 
   result.Clear();
   if (IsValid()) {
     TargetSP target_sp(m_opaque_ptr->GetDebugger().GetSelectedTarget());
     std::unique_lock<std::recursive_mutex> lock;
     if (target_sp)
       lock = std::unique_lock<std::recursive_mutex>(target_sp->GetAPIMutex());
     m_opaque_ptr->SourceInitFile(true, result.ref());
   } else {
     result->AppendError("SBCommandInterpreter is not valid");
     result->SetStatus(eReturnStatusFailed);
   }
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-
-  if (log)
-    log->Printf(
-        "SBCommandInterpreter(%p)::SourceInitFileInCurrentWorkingDirectory "
-        "(&SBCommandReturnObject(%p))",
-        static_cast<void *>(m_opaque_ptr), static_cast<void *>(result.get()));
 }
 
 SBBroadcaster SBCommandInterpreter::GetBroadcaster() {
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBBroadcaster, SBCommandInterpreter,
                              GetBroadcaster);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   SBBroadcaster broadcaster(m_opaque_ptr, false);
 
-  if (log)
-    log->Printf(
-        "SBCommandInterpreter(%p)::GetBroadcaster() => SBBroadcaster(%p)",
-        static_cast<void *>(m_opaque_ptr),
-        static_cast<void *>(broadcaster.get()));
 
   return LLDB_RECORD_RESULT(broadcaster);
 }
 
 const char *SBCommandInterpreter::GetBroadcasterClass() {
   LLDB_RECORD_STATIC_METHOD_NO_ARGS(const char *, SBCommandInterpreter,
                                     GetBroadcasterClass);
 

source/API/SBCommandReturnObject.cpp

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

source/API/SBCommunication.cpp

 //===-- SBCommunication.cpp -------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBCommunication.h"
 #include "SBReproducerPrivate.h"
 #include "lldb/API/SBBroadcaster.h"
 #include "lldb/Core/Communication.h"
 #include "lldb/Host/ConnectionFileDescriptor.h"
 #include "lldb/Host/Host.h"
-#include "lldb/Utility/Log.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 SBCommunication::SBCommunication() : m_opaque(NULL), m_opaque_owned(false) {
   LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBCommunication);
 }
 
 SBCommunication::SBCommunication(const char *broadcaster_name)
     : m_opaque(new Communication(broadcaster_name)), m_opaque_owned(true) {
   LLDB_RECORD_CONSTRUCTOR(SBCommunication, (const char *), broadcaster_name);
-
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-
-  if (log)
-    log->Printf("SBCommunication::SBCommunication (broadcaster_name=\"%s\") => "
-                "SBCommunication(%p)",
-                broadcaster_name, static_cast<void *>(m_opaque));
 }
 
 SBCommunication::~SBCommunication() {
   if (m_opaque && m_opaque_owned)
     delete m_opaque;
   m_opaque = NULL;
   m_opaque_owned = false;
 }
ConnectionStatus SBCommunication::Connect(const char *url) {
   }
   return eConnectionStatusNoConnection;
 }
 
 ConnectionStatus SBCommunication::AdoptFileDesriptor(int fd, bool owns_fd) {
   LLDB_RECORD_METHOD(lldb::ConnectionStatus, SBCommunication,
                      AdoptFileDesriptor, (int, bool), fd, owns_fd);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-
   ConnectionStatus status = eConnectionStatusNoConnection;
   if (m_opaque) {
     if (m_opaque->HasConnection()) {
       if (m_opaque->IsConnected())
         m_opaque->Disconnect();
     }
     m_opaque->SetConnection(new ConnectionFileDescriptor(fd, owns_fd));
     if (m_opaque->IsConnected())
       status = eConnectionStatusSuccess;
     else
       status = eConnectionStatusLostConnection;
   }
-
-  if (log)
-    log->Printf(
-        "SBCommunication(%p)::AdoptFileDescriptor (fd=%d, ownd_fd=%i) => %s",
-        static_cast<void *>(m_opaque), fd, owns_fd,
-        Communication::ConnectionStatusAsCString(status));
-
   return status;
 }
 
 ConnectionStatus SBCommunication::Disconnect() {
   LLDB_RECORD_METHOD_NO_ARGS(lldb::ConnectionStatus, SBCommunication,
                              Disconnect);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-
   ConnectionStatus status = eConnectionStatusNoConnection;
   if (m_opaque)
     status = m_opaque->Disconnect();
-
-  if (log)
-    log->Printf("SBCommunication(%p)::Disconnect () => %s",
-                static_cast<void *>(m_opaque),
-                Communication::ConnectionStatusAsCString(status));
-
   return status;
 }
 
 bool SBCommunication::IsConnected() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommunication, IsConnected);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  bool result = false;
-  if (m_opaque)
-    result = m_opaque->IsConnected();
-
-  if (log)
-    log->Printf("SBCommunication(%p)::IsConnected () => %i",
-                static_cast<void *>(m_opaque), result);
-
-  return false;
+  return m_opaque ? m_opaque->IsConnected() : false;
 }
 
 size_t SBCommunication::Read(void *dst, size_t dst_len, uint32_t timeout_usec,
                              ConnectionStatus &status) {
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  if (log)
-    log->Printf("SBCommunication(%p)::Read (dst=%p, dst_len=%" PRIu64
-                ", timeout_usec=%u, &status)...",
-                static_cast<void *>(m_opaque), static_cast<void *>(dst),
-                static_cast<uint64_t>(dst_len), timeout_usec);
   size_t bytes_read = 0;
   Timeout<std::micro> timeout = timeout_usec == UINT32_MAX
                                     ? Timeout<std::micro>(llvm::None)
                                     : std::chrono::microseconds(timeout_usec);
   if (m_opaque)
     bytes_read = m_opaque->Read(dst, dst_len, timeout, status, NULL);
   else
     status = eConnectionStatusNoConnection;
 
-  if (log)
-    log->Printf("SBCommunication(%p)::Read (dst=%p, dst_len=%" PRIu64
-                ", timeout_usec=%u, &status=%s) => %" PRIu64,
-                static_cast<void *>(m_opaque), static_cast<void *>(dst),
-                static_cast<uint64_t>(dst_len), timeout_usec,
-                Communication::ConnectionStatusAsCString(status),
-                static_cast<uint64_t>(bytes_read));
   return bytes_read;
 }
 
 size_t SBCommunication::Write(const void *src, size_t src_len,
                               ConnectionStatus &status) {
   size_t bytes_written = 0;
   if (m_opaque)
     bytes_written = m_opaque->Write(src, src_len, status, NULL);
   else
     status = eConnectionStatusNoConnection;
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  if (log)
-    log->Printf("SBCommunication(%p)::Write (src=%p, src_len=%" PRIu64
-                ", &status=%s) => %" PRIu64,
-                static_cast<void *>(m_opaque), static_cast<const void *>(src),
-                static_cast<uint64_t>(src_len),
-                Communication::ConnectionStatusAsCString(status),
-                static_cast<uint64_t>(bytes_written));
-
-  return 0;
+  return bytes_written;
 }
 
 bool SBCommunication::ReadThreadStart() {
   LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommunication, ReadThreadStart);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-
-  bool success = false;
-  if (m_opaque)
-    success = m_opaque->StartReadThread();
-
-  if (log)
-    log->Printf("SBCommunication(%p)::ReadThreadStart () => %i",
-                static_cast<void *>(m_opaque), success);
-
-  return success;
+  return m_opaque ? m_opaque->StartReadThread() : false;
 }
 
 bool SBCommunication::ReadThreadStop() {
   LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommunication, ReadThreadStop);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  if (log)
-    log->Printf("SBCommunication(%p)::ReadThreadStop ()...",
-                static_cast<void *>(m_opaque));
-
-  bool success = false;
-  if (m_opaque)
-    success = m_opaque->StopReadThread();
-
-  if (log)
-    log->Printf("SBCommunication(%p)::ReadThreadStop () => %i",
-                static_cast<void *>(m_opaque), success);
-
-  return success;
+  return m_opaque ? m_opaque->StopReadThread() : false;
 }
 
 bool SBCommunication::ReadThreadIsRunning() {
   LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommunication, ReadThreadIsRunning);
 
-  bool result = false;
-  if (m_opaque)
-    result = m_opaque->ReadThreadIsRunning();
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  if (log)
-    log->Printf("SBCommunication(%p)::ReadThreadIsRunning () => %i",
-                static_cast<void *>(m_opaque), result);
-  return result;
+  return m_opaque ? m_opaque->ReadThreadIsRunning() : false;
 }
 
 bool SBCommunication::SetReadThreadBytesReceivedCallback(
     ReadThreadBytesReceived callback, void *callback_baton) {
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-
   bool result = false;
   if (m_opaque) {
     m_opaque->SetReadThreadBytesReceivedCallback(callback, callback_baton);
     result = true;
   }
-
-  if (log)
-    log->Printf("SBCommunication(%p)::SetReadThreadBytesReceivedCallback "
-                "(callback=%p, baton=%p) => %i",
-                static_cast<void *>(m_opaque),
-                reinterpret_cast<void *>(reinterpret_cast<intptr_t>(callback)),
-                static_cast<void *>(callback_baton), result);
-
   return result;
 }
 
 SBBroadcaster SBCommunication::GetBroadcaster() {
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBBroadcaster, SBCommunication,
                              GetBroadcaster);
 
   SBBroadcaster broadcaster(m_opaque, false);
-
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-
-  if (log)
-    log->Printf("SBCommunication(%p)::GetBroadcaster () => SBBroadcaster (%p)",
-                static_cast<void *>(m_opaque),
-                static_cast<void *>(broadcaster.get()));
-
   return LLDB_RECORD_RESULT(broadcaster);
 }
 
 const char *SBCommunication::GetBroadcasterClass() {
   LLDB_RECORD_STATIC_METHOD_NO_ARGS(const char *, SBCommunication,
                                     GetBroadcasterClass);
 
   return Communication::GetStaticBroadcasterClass().AsCString();
 }
-
-//
-// void
-// SBCommunication::CreateIfNeeded ()
-//{
-//    if (m_opaque == NULL)
-//    {
-//        static uint32_t g_broadcaster_num;
-//        char broadcaster_name[256];
-//        ::snprintf (name, broadcaster_name, "%p SBCommunication", this);
-//        m_opaque = new Communication (broadcaster_name);
-//        m_opaque_owned = true;
-//    }
-//    assert (m_opaque);
-//}
-//
-//

source/API/SBCompileUnit.cpp

 #include "lldb/API/SBLineEntry.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Symbol/CompileUnit.h"
 #include "lldb/Symbol/LineEntry.h"
 #include "lldb/Symbol/LineTable.h"
 #include "lldb/Symbol/SymbolVendor.h"
 #include "lldb/Symbol/Type.h"
-#include "lldb/Utility/Log.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 SBCompileUnit::SBCompileUnit() : m_opaque_ptr(NULL) {
   LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBCompileUnit);
 }
 
SBFileSpec SBCompileUnit::GetFileSpec() const {
   if (m_opaque_ptr)
     file_spec.SetFileSpec(*m_opaque_ptr);
   return LLDB_RECORD_RESULT(file_spec);
 }
 
 uint32_t SBCompileUnit::GetNumLineEntries() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBCompileUnit, GetNumLineEntries);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   if (m_opaque_ptr) {
     LineTable *line_table = m_opaque_ptr->GetLineTable();
     if (line_table) {
-      if (log)
-        log->Printf("SBCompileUnit(%p)::GetNumLineEntries() => %d",
-                    static_cast<void *>(m_opaque_ptr),
-                    (int)line_table->GetSize());
       return line_table->GetSize();
     }
   }
   return 0;
 }
 
 SBLineEntry SBCompileUnit::GetLineEntryAtIndex(uint32_t idx) const {
   LLDB_RECORD_METHOD_CONST(lldb::SBLineEntry, SBCompileUnit,
                            GetLineEntryAtIndex, (uint32_t), idx);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-
   SBLineEntry sb_line_entry;
   if (m_opaque_ptr) {
     LineTable *line_table = m_opaque_ptr->GetLineTable();
     if (line_table) {
       LineEntry line_entry;
       if (line_table->GetLineEntryAtIndex(idx, line_entry))
         sb_line_entry.SetLineEntry(line_entry);
     }
   }
 
-  if (log) {
-    SBStream sstr;
-    sb_line_entry.GetDescription(sstr);
-    log->Printf("SBCompileUnit(%p)::GetLineEntryAtIndex (idx=%u) => "
-                "SBLineEntry(%p): '%s'",
-                static_cast<void *>(m_opaque_ptr), idx,
-                static_cast<void *>(sb_line_entry.get()), sstr.GetData());
-  }
-
   return LLDB_RECORD_RESULT(sb_line_entry);
 }
 
 uint32_t SBCompileUnit::FindLineEntryIndex(uint32_t start_idx, uint32_t line,
                                            SBFileSpec *inline_file_spec) const {
   LLDB_RECORD_METHOD_CONST(uint32_t, SBCompileUnit, FindLineEntryIndex,
                            (uint32_t, uint32_t, lldb::SBFileSpec *), start_idx,
                            line, inline_file_spec);
 
   const bool exact = true;
   return FindLineEntryIndex(start_idx, line, inline_file_spec, exact);
 }
 
 uint32_t SBCompileUnit::FindLineEntryIndex(uint32_t start_idx, uint32_t line,
                                            SBFileSpec *inline_file_spec,
                                            bool exact) const {
   LLDB_RECORD_METHOD_CONST(uint32_t, SBCompileUnit, FindLineEntryIndex,
                            (uint32_t, uint32_t, lldb::SBFileSpec *, bool),
                            start_idx, line, inline_file_spec, exact);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-
   uint32_t index = UINT32_MAX;
   if (m_opaque_ptr) {
     FileSpec file_spec;
     if (inline_file_spec && inline_file_spec->IsValid())
       file_spec = inline_file_spec->ref();
     else
       file_spec = *m_opaque_ptr;
 
     index = m_opaque_ptr->FindLineEntry(
         start_idx, line, inline_file_spec ? inline_file_spec->get() : NULL,
         exact, NULL);
   }
 
-  if (log) {
-    SBStream sstr;
-    if (index == UINT32_MAX) {
-      log->Printf("SBCompileUnit(%p)::FindLineEntryIndex (start_idx=%u, "
-                  "line=%u, SBFileSpec(%p)) => NOT FOUND",
-                  static_cast<void *>(m_opaque_ptr), start_idx, line,
-                  inline_file_spec
-                      ? static_cast<const void *>(inline_file_spec->get())
-                      : NULL);
-    } else {
-      log->Printf("SBCompileUnit(%p)::FindLineEntryIndex (start_idx=%u, "
-                  "line=%u, SBFileSpec(%p)) => %u",
-                  static_cast<void *>(m_opaque_ptr), start_idx, line,
-                  inline_file_spec
-                      ? static_cast<const void *>(inline_file_spec->get())
-                      : NULL,
-                  index);
-    }
-  }
-
   return index;
 }
 
 uint32_t SBCompileUnit::GetNumSupportFiles() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBCompileUnit, GetNumSupportFiles);
 
   if (m_opaque_ptr) {
     FileSpecList &support_files = m_opaque_ptr->GetSupportFiles();
lldb::SBTypeList SBCompileUnit::GetTypes(uint32_t type_mask) {
   sb_type_list.m_opaque_up->Append(type_list);
   return LLDB_RECORD_RESULT(sb_type_list);
 }
 
 SBFileSpec SBCompileUnit::GetSupportFileAtIndex(uint32_t idx) const {
   LLDB_RECORD_METHOD_CONST(lldb::SBFileSpec, SBCompileUnit,
                            GetSupportFileAtIndex, (uint32_t), idx);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-
   SBFileSpec sb_file_spec;
   if (m_opaque_ptr) {
     FileSpecList &support_files = m_opaque_ptr->GetSupportFiles();
     FileSpec file_spec = support_files.GetFileSpecAtIndex(idx);
     sb_file_spec.SetFileSpec(file_spec);
   }
 
-  if (log) {
-    SBStream sstr;
-    sb_file_spec.GetDescription(sstr);
-    log->Printf("SBCompileUnit(%p)::GetGetFileSpecAtIndex (idx=%u) => "
-                "SBFileSpec(%p): '%s'",
-                static_cast<void *>(m_opaque_ptr), idx,
-                static_cast<const void *>(sb_file_spec.get()), sstr.GetData());
-  }
 
   return LLDB_RECORD_RESULT(sb_file_spec);
 }
 
 uint32_t SBCompileUnit::FindSupportFileIndex(uint32_t start_idx,
                                              const SBFileSpec &sb_file,
                                              bool full) {
   LLDB_RECORD_METHOD(uint32_t, SBCompileUnit, FindSupportFileIndex,

source/API/SBData.cpp

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

source/API/SBDebugger.cpp

void SBDebugger::Initialize() {
   LLDB_RECORD_STATIC_METHOD_NO_ARGS(void, SBDebugger, Initialize);
   SBError ignored = SBDebugger::InitializeWithErrorHandling();
 }
 
 lldb::SBError SBDebugger::InitializeWithErrorHandling() {
   LLDB_RECORD_STATIC_METHOD_NO_ARGS(lldb::SBError, SBDebugger,
                                     InitializeWithErrorHandling);
 
-  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
-  if (log)
-    log->Printf("SBDebugger::Initialize ()");
 
   SBError error;
   if (auto e = g_debugger_lifetime->Initialize(
           llvm::make_unique<SystemInitializerFull>(), LoadPlugin)) {
     error.SetError(Status(std::move(e)));
   }
   return LLDB_RECORD_RESULT(error);
 }
 
 void SBDebugger::Terminate() {
   LLDB_RECORD_STATIC_METHOD_NO_ARGS(void, SBDebugger, Terminate);
 
   g_debugger_lifetime->Terminate();
 }
 
 void SBDebugger::Clear() {
   LLDB_RECORD_METHOD_NO_ARGS(void, SBDebugger, Clear);
 
-  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-
-  if (log)
-    log->Printf("SBDebugger(%p)::Clear ()",
-                static_cast<void *>(m_opaque_sp.get()));
 
   if (m_opaque_sp)
     m_opaque_sp->ClearIOHandlers();
 
   m_opaque_sp.reset();
 }
 
 SBDebugger SBDebugger::Create() {
SBDebugger SBDebugger::Create(bool source_init_files) {
   return LLDB_RECORD_RESULT(
       SBDebugger::Create(source_init_files, nullptr, nullptr));
 }
 
 SBDebugger SBDebugger::Create(bool source_init_files,
                               lldb::LogOutputCallback callback, void *baton)
 
 {
-  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   SBDebugger debugger;
 
   // Currently we have issues if this function is called simultaneously on two
   // different threads. The issues mainly revolve around the fact that the
   // lldb_private::FormatManager uses global collections and having two threads
   // parsing the .lldbinit files can cause mayhem. So to get around this for
   // now we need to use a mutex to prevent bad things from happening.
   static std::recursive_mutex g_mutex;
   std::lock_guard<std::recursive_mutex> guard(g_mutex);
 
   debugger.reset(Debugger::CreateInstance(callback, baton));
 
-  if (log) {
-    SBStream sstr;
-    debugger.GetDescription(sstr);
-    log->Printf("SBDebugger::Create () => SBDebugger(%p): %s",
-                static_cast<void *>(debugger.m_opaque_sp.get()),
-                sstr.GetData());
-  }
 
   SBCommandInterpreter interp = debugger.GetCommandInterpreter();
   if (source_init_files) {
     interp.get()->SkipLLDBInitFiles(false);
     interp.get()->SkipAppInitFiles(false);
     SBCommandReturnObject result;
     interp.SourceInitFileInHomeDirectory(result);
   } else {
     interp.get()->SkipLLDBInitFiles(true);
     interp.get()->SkipAppInitFiles(true);
   }
   return debugger;
 }
 
 void SBDebugger::Destroy(SBDebugger &debugger) {
   LLDB_RECORD_STATIC_METHOD(void, SBDebugger, Destroy, (lldb::SBDebugger &),
                             debugger);
 
-  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-
-  if (log) {
-    SBStream sstr;
-    debugger.GetDescription(sstr);
-    log->Printf("SBDebugger::Destroy () => SBDebugger(%p): %s",
-                static_cast<void *>(debugger.m_opaque_sp.get()),
-                sstr.GetData());
-  }
 
   Debugger::Destroy(debugger.m_opaque_sp);
 
   if (debugger.m_opaque_sp.get() != nullptr)
     debugger.m_opaque_sp.reset();
 }
 
 void SBDebugger::MemoryPressureDetected() {
   LLDB_RECORD_STATIC_METHOD_NO_ARGS(void, SBDebugger, MemoryPressureDetected);
 
   // Since this function can be call asynchronously, we allow it to be non-
   // mandatory. We have seen deadlocks with this function when called so we
   // need to safeguard against this until we can determine what is causing the
   // deadlocks.
-  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   const bool mandatory = false;
-  if (log) {
-    log->Printf("SBDebugger::MemoryPressureDetected (), mandatory = %d",
-                mandatory);
-  }
 
   ModuleList::RemoveOrphanSharedModules(mandatory);
 }
 
 bool SBDebugger::IsValid() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBDebugger, IsValid);
 
   return m_opaque_sp.get() != nullptr;

 
 // Shouldn't really be settable after initialization as this could cause lots
 // of problems; don't want users trying to switch modes in the middle of a
 // debugging session.
 void SBDebugger::SetInputFileHandle(FILE *fh, bool transfer_ownership) {
   LLDB_RECORD_METHOD(void, SBDebugger, SetInputFileHandle, (FILE *, bool), fh,
                      transfer_ownership);
 
-  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-
-  if (log)
-    log->Printf(
-        "SBDebugger(%p)::SetInputFileHandle (fh=%p, transfer_ownership=%i)",
-        static_cast<void *>(m_opaque_sp.get()), static_cast<void *>(fh),
-        transfer_ownership);
-
   if (!m_opaque_sp)
     return;
 
   repro::DataRecorder *recorder = nullptr;
   if (repro::Generator *g = repro::Reproducer::Instance().GetGenerator())
     recorder = g->GetOrCreate<repro::CommandProvider>().GetNewDataRecorder();
 
   static std::unique_ptr<CommandLoader> loader = CommandLoader::Create();
   if (loader)
     fh = loader->GetNextFile();
 
   m_opaque_sp->SetInputFileHandle(fh, transfer_ownership, recorder);
 }
 
 void SBDebugger::SetOutputFileHandle(FILE *fh, bool transfer_ownership) {
   LLDB_RECORD_METHOD(void, SBDebugger, SetOutputFileHandle, (FILE *, bool), fh,
                      transfer_ownership);
 
-  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-
-  if (log)
-    log->Printf(
-        "SBDebugger(%p)::SetOutputFileHandle (fh=%p, transfer_ownership=%i)",
-        static_cast<void *>(m_opaque_sp.get()), static_cast<void *>(fh),
-        transfer_ownership);
-
   if (m_opaque_sp)
     m_opaque_sp->SetOutputFileHandle(fh, transfer_ownership);
 }
 
 void SBDebugger::SetErrorFileHandle(FILE *fh, bool transfer_ownership) {
   LLDB_RECORD_METHOD(void, SBDebugger, SetErrorFileHandle, (FILE *, bool), fh,
                      transfer_ownership);
 
-  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-
-  if (log)
-    log->Printf(
-        "SBDebugger(%p)::SetErrorFileHandle (fh=%p, transfer_ownership=%i)",
-        static_cast<void *>(m_opaque_sp.get()), static_cast<void *>(fh),
-        transfer_ownership);
 
   if (m_opaque_sp)
     m_opaque_sp->SetErrorFileHandle(fh, transfer_ownership);
 }
 
 FILE *SBDebugger::GetInputFileHandle() {
   LLDB_RECORD_METHOD_NO_ARGS(FILE *, SBDebugger, GetInputFileHandle);
 
void SBDebugger::RestoreInputTerminalState() {
 
   if (m_opaque_sp)
     m_opaque_sp->RestoreInputTerminalState();
 }
 SBCommandInterpreter SBDebugger::GetCommandInterpreter() {
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBCommandInterpreter, SBDebugger,
                              GetCommandInterpreter);
 
-  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   SBCommandInterpreter sb_interpreter;
   if (m_opaque_sp)
     sb_interpreter.reset(&m_opaque_sp->GetCommandInterpreter());
 
-  if (log)
-    log->Printf(
-        "SBDebugger(%p)::GetCommandInterpreter () => SBCommandInterpreter(%p)",
-        static_cast<void *>(m_opaque_sp.get()),
-        static_cast<void *>(sb_interpreter.get()));
 
   return LLDB_RECORD_RESULT(sb_interpreter);
 }
 
 void SBDebugger::HandleCommand(const char *command) {
   LLDB_RECORD_METHOD(void, SBDebugger, HandleCommand, (const char *), command);
 
   if (m_opaque_sp) {
if (!m_opaque_sp->GetAsyncExecution()) {
       }
     }
   }
 }
 
 SBListener SBDebugger::GetListener() {
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBListener, SBDebugger, GetListener);
 
-  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   SBListener sb_listener;
   if (m_opaque_sp)
     sb_listener.reset(m_opaque_sp->GetListener());
 
-  if (log)
-    log->Printf("SBDebugger(%p)::GetListener () => SBListener(%p)",
-                static_cast<void *>(m_opaque_sp.get()),
-                static_cast<void *>(sb_listener.get()));
 
   return LLDB_RECORD_RESULT(sb_listener);
 }
 
 void SBDebugger::HandleProcessEvent(const SBProcess &process,
                                     const SBEvent &event, FILE *out,
                                     FILE *err) {
   LLDB_RECORD_METHOD(
SBStructuredData SBDebugger::GetBuildConfiguration() {
   data.m_impl_up->SetObjectSP(std::move(config_up));
   return LLDB_RECORD_RESULT(data);
 }
 
 bool SBDebugger::StateIsRunningState(StateType state) {
   LLDB_RECORD_STATIC_METHOD(bool, SBDebugger, StateIsRunningState,
                             (lldb::StateType), state);
 
-  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   const bool result = lldb_private::StateIsRunningState(state);
-  if (log)
-    log->Printf("SBDebugger::StateIsRunningState (state=%s) => %i",
-                StateAsCString(state), result);
 
   return result;
 }
 
 bool SBDebugger::StateIsStoppedState(StateType state) {
   LLDB_RECORD_STATIC_METHOD(bool, SBDebugger, StateIsStoppedState,
                             (lldb::StateType), state);
 
-  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   const bool result = lldb_private::StateIsStoppedState(state, false);
-  if (log)
-    log->Printf("SBDebugger::StateIsStoppedState (state=%s) => %i",
-                StateAsCString(state), result);
 
   return result;
 }
 
 lldb::SBTarget SBDebugger::CreateTarget(const char *filename,
                                         const char *target_triple,
                                         const char *platform_name,
                                         bool add_dependent_modules,

source/API/SBDeclaration.cpp

 //===-- SBDeclaration.cpp ----------------------------------------*- C++-*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBDeclaration.h"
 #include "SBReproducerPrivate.h"
 #include "Utils.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/Host/PosixApi.h"
 #include "lldb/Symbol/Declaration.h"
-#include "lldb/Utility/Log.h"
 #include "lldb/Utility/Stream.h"
 
 #include <limits.h>
 
 using namespace lldb;
 using namespace lldb_private;
 
 SBDeclaration::SBDeclaration() : m_opaque_up() {
bool SBDeclaration::IsValid() const {
 
   return m_opaque_up.get() && m_opaque_up->IsValid();
 }
 
 SBFileSpec SBDeclaration::GetFileSpec() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBFileSpec, SBDeclaration,
                                    GetFileSpec);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   SBFileSpec sb_file_spec;
   if (m_opaque_up.get() && m_opaque_up->GetFile())
     sb_file_spec.SetFileSpec(m_opaque_up->GetFile());
 
-  if (log) {
-    SBStream sstr;
-    sb_file_spec.GetDescription(sstr);
-    log->Printf("SBLineEntry(%p)::GetFileSpec () => SBFileSpec(%p): %s",
-                static_cast<void *>(m_opaque_up.get()),
-                static_cast<const void *>(sb_file_spec.get()), sstr.GetData());
-  }
 
   return LLDB_RECORD_RESULT(sb_file_spec);
 }
 
 uint32_t SBDeclaration::GetLine() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBDeclaration, GetLine);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   uint32_t line = 0;
   if (m_opaque_up)
     line = m_opaque_up->GetLine();
 
-  if (log)
-    log->Printf("SBLineEntry(%p)::GetLine () => %u",
-                static_cast<void *>(m_opaque_up.get()), line);
 
   return line;
 }
 
 uint32_t SBDeclaration::GetColumn() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBDeclaration, GetColumn);
 
   if (m_opaque_up)

source/API/SBError.cpp

 //===-- SBError.cpp ---------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBError.h"
 #include "SBReproducerPrivate.h"
 #include "Utils.h"
 #include "lldb/API/SBStream.h"
-#include "lldb/Utility/Log.h"
 #include "lldb/Utility/Status.h"
 
 #include <stdarg.h>
 
 using namespace lldb;
 using namespace lldb_private;
 
 SBError::SBError() : m_opaque_up() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBError); }
void SBError::Clear() {
 
   if (m_opaque_up)
     m_opaque_up->Clear();
 }
 
 bool SBError::Fail() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBError, Fail);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-
   bool ret_value = false;
   if (m_opaque_up)
     ret_value = m_opaque_up->Fail();
 
-  if (log)
-    log->Printf("SBError(%p)::Fail () => %i",
-                static_cast<void *>(m_opaque_up.get()), ret_value);
 
   return ret_value;
 }
 
 bool SBError::Success() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBError, Success);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   bool ret_value = true;
   if (m_opaque_up)
     ret_value = m_opaque_up->Success();
 
-  if (log)
-    log->Printf("SBError(%p)::Success () => %i",
-                static_cast<void *>(m_opaque_up.get()), ret_value);
-
   return ret_value;
 }
 
 uint32_t SBError::GetError() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBError, GetError);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   uint32_t err = 0;
   if (m_opaque_up)
     err = m_opaque_up->GetError();
 
-  if (log)
-    log->Printf("SBError(%p)::GetError () => 0x%8.8x",
-                static_cast<void *>(m_opaque_up.get()), err);
 
   return err;
 }
 
 ErrorType SBError::GetType() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::ErrorType, SBError, GetType);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   ErrorType err_type = eErrorTypeInvalid;
   if (m_opaque_up)
     err_type = m_opaque_up->GetType();
 
-  if (log)
-    log->Printf("SBError(%p)::GetType () => %i",
-                static_cast<void *>(m_opaque_up.get()), err_type);
-
   return err_type;
 }
 
 void SBError::SetError(uint32_t err, ErrorType type) {
   LLDB_RECORD_METHOD(void, SBError, SetError, (uint32_t, lldb::ErrorType), err,
                      type);
 
   CreateIfNeeded();

source/API/SBEvent.cpp

if (event_data)
       return lldb_event->GetData()->GetFlavor().AsCString();
   }
   return NULL;
 }
 
 uint32_t SBEvent::GetType() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBEvent, GetType);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   const Event *lldb_event = get();
   uint32_t event_type = 0;
   if (lldb_event)
     event_type = lldb_event->GetType();
 
-  if (log) {
-    StreamString sstr;
-    if (lldb_event && lldb_event->GetBroadcaster() &&
-        lldb_event->GetBroadcaster()->GetEventNames(sstr, event_type, true))
-      log->Printf("SBEvent(%p)::GetType () => 0x%8.8x (%s)",
-                  static_cast<void *>(get()), event_type, sstr.GetData());
-    else
-      log->Printf("SBEvent(%p)::GetType () => 0x%8.8x",
-                  static_cast<void *>(get()), event_type);
-  }
 
   return event_type;
 }
 
 SBBroadcaster SBEvent::GetBroadcaster() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBBroadcaster, SBEvent,
                                    GetBroadcaster);
 
bool SBEvent::BroadcasterMatchesRef(const SBBroadcaster &broadcaster) {
   LLDB_RECORD_METHOD(bool, SBEvent, BroadcasterMatchesRef,
                      (const lldb::SBBroadcaster &), broadcaster);
 
   Event *lldb_event = get();
   bool success = false;
   if (lldb_event)
     success = lldb_event->BroadcasterIs(broadcaster.get());
 
-  // For logging, this gets a little chatty so only enable this when verbose
-  // logging is on
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  LLDB_LOGV(log, "({0}) (SBBroadcaster({1}): {2}) => {3}", get(),
-            broadcaster.get(), broadcaster.GetName(), success);
 
   return success;
 }
 
 void SBEvent::Clear() {
   LLDB_RECORD_METHOD_NO_ARGS(void, SBEvent, Clear);
 
   Event *lldb_event = get();
bool SBEvent::IsValid() const {
   // See comments in SBEvent::get()....
   return SBEvent::get() != NULL;
 }
 
 const char *SBEvent::GetCStringFromEvent(const SBEvent &event) {
   LLDB_RECORD_STATIC_METHOD(const char *, SBEvent, GetCStringFromEvent,
                             (const lldb::SBEvent &), event);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-
-  if (log)
-    log->Printf("SBEvent(%p)::GetCStringFromEvent () => \"%s\"",
-                static_cast<void *>(event.get()),
-                reinterpret_cast<const char *>(
-                    EventDataBytes::GetBytesFromEvent(event.get())));
-
   return reinterpret_cast<const char *>(
       EventDataBytes::GetBytesFromEvent(event.get()));
 }
 
 bool SBEvent::GetDescription(SBStream &description) {
   LLDB_RECORD_METHOD(bool, SBEvent, GetDescription, (lldb::SBStream &),
                      description);
 

source/API/SBFileSpec.cpp

 //===-- SBFileSpec.cpp ------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBFileSpec.h"
 #include "SBReproducerPrivate.h"
 #include "Utils.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/Host/FileSystem.h"
 #include "lldb/Host/PosixApi.h"
 #include "lldb/Utility/FileSpec.h"
-#include "lldb/Utility/Log.h"
 #include "lldb/Utility/Stream.h"
 
 #include "llvm/ADT/SmallString.h"
 
 #include <inttypes.h>
 #include <limits.h>
 
 using namespace lldb;
bool SBFileSpec::IsValid() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBFileSpec, IsValid);
 
   return m_opaque_up->operator bool();
 }
 
 bool SBFileSpec::Exists() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBFileSpec, Exists);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-
-  bool result = FileSystem::Instance().Exists(*m_opaque_up);
-
-  if (log)
-    log->Printf("SBFileSpec(%p)::Exists () => %s",
-                static_cast<void *>(m_opaque_up.get()),
-                (result ? "true" : "false"));
-
-  return result;
+  return FileSystem::Instance().Exists(*m_opaque_up);
 }
 
 bool SBFileSpec::ResolveExecutableLocation() {
   LLDB_RECORD_METHOD_NO_ARGS(bool, SBFileSpec, ResolveExecutableLocation);
 
   return FileSystem::Instance().ResolveExecutableLocation(*m_opaque_up);
 }
 
 int SBFileSpec::ResolvePath(const char *src_path, char *dst_path,
                             size_t dst_len) {
   LLDB_RECORD_STATIC_METHOD(int, SBFileSpec, ResolvePath,
                             (const char *, char *, size_t), src_path, dst_path,
                             dst_len);
 
   llvm::SmallString<64> result(src_path);
   FileSystem::Instance().Resolve(result);
   ::snprintf(dst_path, dst_len, "%s", result.c_str());
   return std::min(dst_len - 1, result.size());
 }
 
 const char *SBFileSpec::GetFilename() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBFileSpec, GetFilename);
 
-  const char *s = m_opaque_up->GetFilename().AsCString();
-
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  if (log) {
-    if (s)
-      log->Printf("SBFileSpec(%p)::GetFilename () => \"%s\"",
-                  static_cast<void *>(m_opaque_up.get()), s);
-    else
-      log->Printf("SBFileSpec(%p)::GetFilename () => NULL",
-                  static_cast<void *>(m_opaque_up.get()));
-  }
-
-  return s;
+  return m_opaque_up->GetFilename().AsCString();
 }
 
 const char *SBFileSpec::GetDirectory() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBFileSpec, GetDirectory);
 
   FileSpec directory{*m_opaque_up};
   directory.GetFilename().Clear();
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  if (log) {
-    if (directory)
-      log->Printf("SBFileSpec(%p)::GetDirectory () => \"%s\"",
-                  static_cast<void *>(m_opaque_up.get()),
-                  directory.GetCString());
-    else
-      log->Printf("SBFileSpec(%p)::GetDirectory () => NULL",
-                  static_cast<void *>(m_opaque_up.get()));
-  }
   return directory.GetCString();
 }
 
 void SBFileSpec::SetFilename(const char *filename) {
   LLDB_RECORD_METHOD(void, SBFileSpec, SetFilename, (const char *), filename);
 
   if (filename && filename[0])
     m_opaque_up->GetFilename().SetCString(filename);
void SBFileSpec::SetDirectory(const char *directory) {
   else
     m_opaque_up->GetDirectory().Clear();
 }
 
 uint32_t SBFileSpec::GetPath(char *dst_path, size_t dst_len) const {
   LLDB_RECORD_METHOD_CONST(uint32_t, SBFileSpec, GetPath, (char *, size_t),
                            dst_path, dst_len);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-
   uint32_t result = m_opaque_up->GetPath(dst_path, dst_len);
 
-  if (log)
-    log->Printf("SBFileSpec(%p)::GetPath (dst_path=\"%.*s\", dst_len=%" PRIu64
-                ") => %u",
-                static_cast<void *>(m_opaque_up.get()), result, dst_path,
-                static_cast<uint64_t>(dst_len), result);
-
   if (result == 0 && dst_path && dst_len > 0)
     *dst_path = '\0';
   return result;
 }
 
 const lldb_private::FileSpec *SBFileSpec::operator->() const {
   return m_opaque_up.get();
 }

source/API/SBFileSpecList.cpp

 //===-- SBFileSpecList.cpp --------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBFileSpecList.h"
 #include "SBReproducerPrivate.h"
 #include "Utils.h"
 #include "lldb/API/SBFileSpec.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/Core/FileSpecList.h"
 #include "lldb/Host/PosixApi.h"
 #include "lldb/Utility/FileSpec.h"
-#include "lldb/Utility/Log.h"
 #include "lldb/Utility/Stream.h"
 
 #include <limits.h>
 
 using namespace lldb;
 using namespace lldb_private;
 
 SBFileSpecList::SBFileSpecList() : m_opaque_up(new FileSpecList()) {
   LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBFileSpecList);
 }
 
 SBFileSpecList::SBFileSpecList(const SBFileSpecList &rhs) : m_opaque_up() {
   LLDB_RECORD_CONSTRUCTOR(SBFileSpecList, (const lldb::SBFileSpecList &), rhs);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   m_opaque_up = clone(rhs.m_opaque_up);
-
-  if (log) {
-    log->Printf("SBFileSpecList::SBFileSpecList (const SBFileSpecList "
-                "rhs.ap=%p) => SBFileSpecList(%p)",
-                static_cast<void *>(rhs.m_opaque_up.get()),
-                static_cast<void *>(m_opaque_up.get()));
-  }
 }
 
 SBFileSpecList::~SBFileSpecList() {}
 
 const SBFileSpecList &SBFileSpecList::operator=(const SBFileSpecList &rhs) {
   LLDB_RECORD_METHOD(const lldb::SBFileSpecList &,
                      SBFileSpecList, operator=,(const lldb::SBFileSpecList &),
                      rhs);

source/API/SBFrame.cpp

 #include "lldb/Target/Process.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/StackFrame.h"
 #include "lldb/Target/StackFrameRecognizer.h"
 #include "lldb/Target/StackID.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/ConstString.h"
-#include "lldb/Utility/Log.h"
 #include "lldb/Utility/Stream.h"
 
 #include "lldb/API/SBAddress.h"
 #include "lldb/API/SBDebugger.h"
 #include "lldb/API/SBExpressionOptions.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/API/SBSymbolContext.h"
 #include "lldb/API/SBThread.h"
 #include "lldb/API/SBValue.h"
 #include "lldb/API/SBVariablesOptions.h"
 
 #include "llvm/Support/PrettyStackTrace.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 SBFrame::SBFrame() : m_opaque_sp(new ExecutionContextRef()) {
   LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBFrame);
 }
 
 SBFrame::SBFrame(const StackFrameSP &lldb_object_sp)
     : m_opaque_sp(new ExecutionContextRef(lldb_object_sp)) {
   LLDB_RECORD_CONSTRUCTOR(SBFrame, (const lldb::StackFrameSP &),
                           lldb_object_sp);
-
-  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-
-  if (log) {
-    SBStream sstr;
-    GetDescription(sstr);
-    log->Printf("SBFrame::SBFrame (sp=%p) => SBFrame(%p): %s",
-                static_cast<void *>(lldb_object_sp.get()),
-                static_cast<void *>(lldb_object_sp.get()), sstr.GetData());
-  }
 }
 
 SBFrame::SBFrame(const SBFrame &rhs) : m_opaque_sp() {
   LLDB_RECORD_CONSTRUCTOR(SBFrame, (const lldb::SBFrame &), rhs);
 
   m_opaque_sp = clone(rhs.m_opaque_sp);
 }
 
bool SBFrame::IsValid() const {
   // Without a target & process we can't have a valid stack frame.
   return false;
 }
 
 SBSymbolContext SBFrame::GetSymbolContext(uint32_t resolve_scope) const {
   LLDB_RECORD_METHOD_CONST(lldb::SBSymbolContext, SBFrame, GetSymbolContext,
                            (uint32_t), resolve_scope);
 
-  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   SBSymbolContext sb_sym_ctx;
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
   SymbolContextItem scope = static_cast<SymbolContextItem>(resolve_scope);
   StackFrame *frame = nullptr;
   Target *target = exe_ctx.GetTargetPtr();
   Process *process = exe_ctx.GetProcessPtr();
   if (target && process) {
     Process::StopLocker stop_locker;
     if (stop_locker.TryLock(&process->GetRunLock())) {
       frame = exe_ctx.GetFramePtr();
-      if (frame) {
+      if (frame)
         sb_sym_ctx.SetSymbolContext(&frame->GetSymbolContext(scope));
-      } else {
-        if (log)
-          log->Printf("SBFrame::GetVariables () => error: could not "
-                      "reconstruct frame object for this SBFrame.");
-      }
-    } else {
-      if (log)
-        log->Printf(
-            "SBFrame::GetSymbolContext () => error: process is running");
     }
   }
 
-  if (log)
-    log->Printf("SBFrame(%p)::GetSymbolContext (resolve_scope=0x%8.8x) => "
-                "SBSymbolContext(%p)",
-                static_cast<void *>(frame), resolve_scope,
-                static_cast<void *>(sb_sym_ctx.get()));
-
   return LLDB_RECORD_RESULT(sb_sym_ctx);
 }
 
 SBModule SBFrame::GetModule() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBModule, SBFrame, GetModule);
 
-  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   SBModule sb_module;
   ModuleSP module_sp;
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
   StackFrame *frame = nullptr;
   Target *target = exe_ctx.GetTargetPtr();
   Process *process = exe_ctx.GetProcessPtr();
   if (target && process) {
     Process::StopLocker stop_locker;
     if (stop_locker.TryLock(&process->GetRunLock())) {
       frame = exe_ctx.GetFramePtr();
       if (frame) {
         module_sp = frame->GetSymbolContext(eSymbolContextModule).module_sp;
         sb_module.SetSP(module_sp);
-      } else {
-        if (log)
-          log->Printf("SBFrame::GetModule () => error: could not reconstruct "
-                      "frame object for this SBFrame.");
       }
-    } else {
-      if (log)
-        log->Printf("SBFrame::GetModule () => error: process is running");
     }
   }
 
-  if (log)
-    log->Printf("SBFrame(%p)::GetModule () => SBModule(%p)",
-                static_cast<void *>(frame),
-                static_cast<void *>(module_sp.get()));
-
   return LLDB_RECORD_RESULT(sb_module);
 }
 
 SBCompileUnit SBFrame::GetCompileUnit() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBCompileUnit, SBFrame,
                                    GetCompileUnit);
 
-  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   SBCompileUnit sb_comp_unit;
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
   StackFrame *frame = nullptr;
   Target *target = exe_ctx.GetTargetPtr();
   Process *process = exe_ctx.GetProcessPtr();
   if (target && process) {
     Process::StopLocker stop_locker;
     if (stop_locker.TryLock(&process->GetRunLock())) {
       frame = exe_ctx.GetFramePtr();
       if (frame) {
         sb_comp_unit.reset(
             frame->GetSymbolContext(eSymbolContextCompUnit).comp_unit);
-      } else {
-        if (log)
-          log->Printf("SBFrame::GetCompileUnit () => error: could not "
-                      "reconstruct frame object for this SBFrame.");
-      }
-    } else {
-      if (log)
-        log->Printf("SBFrame::GetCompileUnit () => error: process is running");
       }
     }
-  if (log)
-    log->Printf("SBFrame(%p)::GetCompileUnit () => SBCompileUnit(%p)",
-                static_cast<void *>(frame),
-                static_cast<void *>(sb_comp_unit.get()));
+  }
 
   return LLDB_RECORD_RESULT(sb_comp_unit);
 }
 
 SBFunction SBFrame::GetFunction() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBFunction, SBFrame, GetFunction);
 
-  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   SBFunction sb_function;
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
   StackFrame *frame = nullptr;
   Target *target = exe_ctx.GetTargetPtr();
   Process *process = exe_ctx.GetProcessPtr();
   if (target && process) {
     Process::StopLocker stop_locker;
     if (stop_locker.TryLock(&process->GetRunLock())) {
       frame = exe_ctx.GetFramePtr();
       if (frame) {
         sb_function.reset(
             frame->GetSymbolContext(eSymbolContextFunction).function);
-      } else {
-        if (log)
-          log->Printf("SBFrame::GetFunction () => error: could not reconstruct "
-                      "frame object for this SBFrame.");
-      }
-    } else {
-      if (log)
-        log->Printf("SBFrame::GetFunction () => error: process is running");
       }
     }
-  if (log)
-    log->Printf("SBFrame(%p)::GetFunction () => SBFunction(%p)",
-                static_cast<void *>(frame),
-                static_cast<void *>(sb_function.get()));
+  }
 
   return LLDB_RECORD_RESULT(sb_function);
 }
 
 SBSymbol SBFrame::GetSymbol() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBSymbol, SBFrame, GetSymbol);
 
-  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   SBSymbol sb_symbol;
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
   StackFrame *frame = nullptr;
   Target *target = exe_ctx.GetTargetPtr();
   Process *process = exe_ctx.GetProcessPtr();
   if (target && process) {
     Process::StopLocker stop_locker;
     if (stop_locker.TryLock(&process->GetRunLock())) {
       frame = exe_ctx.GetFramePtr();
       if (frame) {
         sb_symbol.reset(frame->GetSymbolContext(eSymbolContextSymbol).symbol);
-      } else {
-        if (log)
-          log->Printf("SBFrame::GetSymbol () => error: could not reconstruct "
-                      "frame object for this SBFrame.");
-      }
-    } else {
-      if (log)
-        log->Printf("SBFrame::GetSymbol () => error: process is running");
       }
     }
-  if (log)
-    log->Printf("SBFrame(%p)::GetSymbol () => SBSymbol(%p)",
-                static_cast<void *>(frame),
-                static_cast<void *>(sb_symbol.get()));
+  }
+
   return LLDB_RECORD_RESULT(sb_symbol);
 }
 
 SBBlock SBFrame::GetBlock() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBBlock, SBFrame, GetBlock);
 
-  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   SBBlock sb_block;
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
   StackFrame *frame = nullptr;
   Target *target = exe_ctx.GetTargetPtr();
   Process *process = exe_ctx.GetProcessPtr();
   if (target && process) {
     Process::StopLocker stop_locker;
     if (stop_locker.TryLock(&process->GetRunLock())) {
       frame = exe_ctx.GetFramePtr();
-      if (frame) {
+      if (frame)
         sb_block.SetPtr(frame->GetSymbolContext(eSymbolContextBlock).block);
-      } else {
-        if (log)
-          log->Printf("SBFrame::GetBlock () => error: could not reconstruct "
-                      "frame object for this SBFrame.");
-      }
-    } else {
-      if (log)
-        log->Printf("SBFrame(%p)::GetBlock () => error: process is running",
-                    static_cast<void *>(frame));
     }
   }
-  if (log)
-    log->Printf("SBFrame(%p)::GetBlock () => SBBlock(%p)",
-                static_cast<void *>(frame),
-                static_cast<void *>(sb_block.GetPtr()));
   return LLDB_RECORD_RESULT(sb_block);
 }
 
 SBBlock SBFrame::GetFrameBlock() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBBlock, SBFrame, GetFrameBlock);
 
   SBBlock sb_block;
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
   StackFrame *frame = nullptr;
   Target *target = exe_ctx.GetTargetPtr();
-  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   Process *process = exe_ctx.GetProcessPtr();
   if (target && process) {
     Process::StopLocker stop_locker;
     if (stop_locker.TryLock(&process->GetRunLock())) {
       frame = exe_ctx.GetFramePtr();
-      if (frame) {
+      if (frame)
         sb_block.SetPtr(frame->GetFrameBlock());
-      } else {
-        if (log)
-          log->Printf("SBFrame::GetFrameBlock () => error: could not "
-                      "reconstruct frame object for this SBFrame.");
-      }
-    } else {
-      if (log)
-        log->Printf("SBFrame::GetFrameBlock () => error: process is running");
     }
   }
-  if (log)
-    log->Printf("SBFrame(%p)::GetFrameBlock () => SBBlock(%p)",
-                static_cast<void *>(frame),
-                static_cast<void *>(sb_block.GetPtr()));
   return LLDB_RECORD_RESULT(sb_block);
 }
 
 SBLineEntry SBFrame::GetLineEntry() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBLineEntry, SBFrame, GetLineEntry);
 
-  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   SBLineEntry sb_line_entry;
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
   StackFrame *frame = nullptr;
   Target *target = exe_ctx.GetTargetPtr();
   Process *process = exe_ctx.GetProcessPtr();
   if (target && process) {
     Process::StopLocker stop_locker;
     if (stop_locker.TryLock(&process->GetRunLock())) {
       frame = exe_ctx.GetFramePtr();
       if (frame) {
         sb_line_entry.SetLineEntry(
             frame->GetSymbolContext(eSymbolContextLineEntry).line_entry);
-      } else {
-        if (log)
-          log->Printf("SBFrame::GetLineEntry () => error: could not "
-                      "reconstruct frame object for this SBFrame.");
-      }
-    } else {
-      if (log)
-        log->Printf("SBFrame::GetLineEntry () => error: process is running");
       }
     }
-  if (log)
-    log->Printf("SBFrame(%p)::GetLineEntry () => SBLineEntry(%p)",
-                static_cast<void *>(frame),
-                static_cast<void *>(sb_line_entry.get()));
+  }
   return LLDB_RECORD_RESULT(sb_line_entry);
 }
 
 uint32_t SBFrame::GetFrameID() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBFrame, GetFrameID);
 
   uint32_t frame_idx = UINT32_MAX;
 
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
   StackFrame *frame = exe_ctx.GetFramePtr();
   if (frame)
     frame_idx = frame->GetFrameIndex();
 
-  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  if (log)
-    log->Printf("SBFrame(%p)::GetFrameID () => %u", static_cast<void *>(frame),
-                frame_idx);
   return frame_idx;
 }
 
 lldb::addr_t SBFrame::GetCFA() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::addr_t, SBFrame, GetCFA);
 
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
   StackFrame *frame = exe_ctx.GetFramePtr();
   if (frame)
     return frame->GetStackID().GetCallFrameAddress();
   return LLDB_INVALID_ADDRESS;
 }
 
 addr_t SBFrame::GetPC() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::addr_t, SBFrame, GetPC);
 
-  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   addr_t addr = LLDB_INVALID_ADDRESS;
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
   StackFrame *frame = nullptr;
   Target *target = exe_ctx.GetTargetPtr();
   Process *process = exe_ctx.GetProcessPtr();
   if (target && process) {
     Process::StopLocker stop_locker;
     if (stop_locker.TryLock(&process->GetRunLock())) {
       frame = exe_ctx.GetFramePtr();
       if (frame) {
         addr = frame->GetFrameCodeAddress().GetOpcodeLoadAddress(
             target, AddressClass::eCode);
-      } else {
-        if (log)
-          log->Printf("SBFrame::GetPC () => error: could not reconstruct frame "
-                      "object for this SBFrame.");
       }
-    } else {
-      if (log)
-        log->Printf("SBFrame::GetPC () => error: process is running");
     }
   }
 
-  if (log)
-    log->Printf("SBFrame(%p)::GetPC () => 0x%" PRIx64,
-                static_cast<void *>(frame), addr);
-
   return addr;
 }
 
 bool SBFrame::SetPC(addr_t new_pc) {
   LLDB_RECORD_METHOD(bool, SBFrame, SetPC, (lldb::addr_t), new_pc);
 
-  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   bool ret_val = false;
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
   StackFrame *frame = nullptr;
   Target *target = exe_ctx.GetTargetPtr();
   Process *process = exe_ctx.GetProcessPtr();
   if (target && process) {
     Process::StopLocker stop_locker;
     if (stop_locker.TryLock(&process->GetRunLock())) {
       frame = exe_ctx.GetFramePtr();
       if (frame) {
         ret_val = frame->GetRegisterContext()->SetPC(new_pc);
-      } else {
-        if (log)
-          log->Printf("SBFrame::SetPC () => error: could not reconstruct frame "
-                      "object for this SBFrame.");
       }
-    } else {
-      if (log)
-        log->Printf("SBFrame::SetPC () => error: process is running");
     }
   }
 
-  if (log)
-    log->Printf("SBFrame(%p)::SetPC (new_pc=0x%" PRIx64 ") => %i",
-                static_cast<void *>(frame), new_pc, ret_val);
-
   return ret_val;
 }
 
 addr_t SBFrame::GetSP() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::addr_t, SBFrame, GetSP);
 
-  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   addr_t addr = LLDB_INVALID_ADDRESS;
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
   StackFrame *frame = nullptr;
   Target *target = exe_ctx.GetTargetPtr();
   Process *process = exe_ctx.GetProcessPtr();
   if (target && process) {
     Process::StopLocker stop_locker;
     if (stop_locker.TryLock(&process->GetRunLock())) {
       frame = exe_ctx.GetFramePtr();
       if (frame) {
         addr = frame->GetRegisterContext()->GetSP();
-      } else {
-        if (log)
-          log->Printf("SBFrame::GetSP () => error: could not reconstruct frame "
-                      "object for this SBFrame.");
-      }
-    } else {
-      if (log)
-        log->Printf("SBFrame::GetSP () => error: process is running");
       }
     }
-  if (log)
-    log->Printf("SBFrame(%p)::GetSP () => 0x%" PRIx64,
-                static_cast<void *>(frame), addr);
+  }
 
   return addr;
 }
 
 addr_t SBFrame::GetFP() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::addr_t, SBFrame, GetFP);
 
-  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   addr_t addr = LLDB_INVALID_ADDRESS;
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
   StackFrame *frame = nullptr;
   Target *target = exe_ctx.GetTargetPtr();
   Process *process = exe_ctx.GetProcessPtr();
   if (target && process) {
     Process::StopLocker stop_locker;
     if (stop_locker.TryLock(&process->GetRunLock())) {
       frame = exe_ctx.GetFramePtr();
-      if (frame) {
+      if (frame)
         addr = frame->GetRegisterContext()->GetFP();
-      } else {
-        if (log)
-          log->Printf("SBFrame::GetFP () => error: could not reconstruct frame "
-                      "object for this SBFrame.");
-      }
-    } else {
-      if (log)
-        log->Printf("SBFrame::GetFP () => error: process is running");
     }
   }
 
-  if (log)
-    log->Printf("SBFrame(%p)::GetFP () => 0x%" PRIx64,
-                static_cast<void *>(frame), addr);
   return addr;
 }
 
 SBAddress SBFrame::GetPCAddress() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBAddress, SBFrame, GetPCAddress);
 
-  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   SBAddress sb_addr;
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
   StackFrame *frame = exe_ctx.GetFramePtr();
   Target *target = exe_ctx.GetTargetPtr();
   Process *process = exe_ctx.GetProcessPtr();
   if (target && process) {
     Process::StopLocker stop_locker;
     if (stop_locker.TryLock(&process->GetRunLock())) {
       frame = exe_ctx.GetFramePtr();
-      if (frame) {
+      if (frame)
         sb_addr.SetAddress(&frame->GetFrameCodeAddress());
-      } else {
-        if (log)
-          log->Printf("SBFrame::GetPCAddress () => error: could not "
-                      "reconstruct frame object for this SBFrame.");
-      }
-    } else {
-      if (log)
-        log->Printf("SBFrame::GetPCAddress () => error: process is running");
     }
   }
-  if (log)
-    log->Printf("SBFrame(%p)::GetPCAddress () => SBAddress(%p)",
-                static_cast<void *>(frame), static_cast<void *>(sb_addr.get()));
   return LLDB_RECORD_RESULT(sb_addr);
 }
 
 void SBFrame::Clear() {
   LLDB_RECORD_METHOD_NO_ARGS(void, SBFrame, Clear);
 
   m_opaque_sp->Clear();
 }

 
 lldb::SBValue SBFrame::GetValueForVariablePath(const char *var_path,
                                                DynamicValueType use_dynamic) {
   LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, GetValueForVariablePath,
                      (const char *, lldb::DynamicValueType), var_path,
                      use_dynamic);
 
   SBValue sb_value;
-  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   if (var_path == nullptr || var_path[0] == '\0') {
-    if (log)
-      log->Printf(
-          "SBFrame::GetValueForVariablePath called with empty variable path.");
     return LLDB_RECORD_RESULT(sb_value);
   }
 
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
   StackFrame *frame = nullptr;
   Target *target = exe_ctx.GetTargetPtr();
   Process *process = exe_ctx.GetProcessPtr();
   if (target && process) {
     Process::StopLocker stop_locker;
     if (stop_locker.TryLock(&process->GetRunLock())) {
       frame = exe_ctx.GetFramePtr();
       if (frame) {
         VariableSP var_sp;
         Status error;
         ValueObjectSP value_sp(frame->GetValueForVariableExpressionPath(
             var_path, eNoDynamicValues,
             StackFrame::eExpressionPathOptionCheckPtrVsMember |
                 StackFrame::eExpressionPathOptionsAllowDirectIVarAccess,
             var_sp, error));
         sb_value.SetSP(value_sp, use_dynamic);
-      } else {
-        if (log)
-          log->Printf("SBFrame::GetValueForVariablePath () => error: could not "
-                      "reconstruct frame object for this SBFrame.");
-      }
-    } else {
-      if (log)
-        log->Printf(
-            "SBFrame::GetValueForVariablePath () => error: process is running");
+      }
     }
   }
   return LLDB_RECORD_RESULT(sb_value);
 }
 
 SBValue SBFrame::FindVariable(const char *name) {
   LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, FindVariable, (const char *),
                      name);
SBValue SBFrame::FindVariable(const char *name) {
   return LLDB_RECORD_RESULT(value);
 }
 
 SBValue SBFrame::FindVariable(const char *name,
                               lldb::DynamicValueType use_dynamic) {
   LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, FindVariable,
                      (const char *, lldb::DynamicValueType), name, use_dynamic);
 
-  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   VariableSP var_sp;
   SBValue sb_value;
 
   if (name == nullptr || name[0] == '\0') {
-    if (log)
-      log->Printf("SBFrame::FindVariable called with empty name");
     return LLDB_RECORD_RESULT(sb_value);
   }
 
   ValueObjectSP value_sp;
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
   StackFrame *frame = nullptr;
   Target *target = exe_ctx.GetTargetPtr();
   Process *process = exe_ctx.GetProcessPtr();
   if (target && process) {
     Process::StopLocker stop_locker;
     if (stop_locker.TryLock(&process->GetRunLock())) {
       frame = exe_ctx.GetFramePtr();
       if (frame) {
         value_sp = frame->FindVariable(ConstString(name));
 
         if (value_sp)
           sb_value.SetSP(value_sp, use_dynamic);
-      } else {
-        if (log)
-          log->Printf("SBFrame::FindVariable () => error: could not "
-                      "reconstruct frame object for this SBFrame.");
       }
-    } else {
-      if (log)
-        log->Printf("SBFrame::FindVariable () => error: process is running");
     }
   }
 
-  if (log)
-    log->Printf("SBFrame(%p)::FindVariable (name=\"%s\") => SBValue(%p)",
-                static_cast<void *>(frame), name,
-                static_cast<void *>(value_sp.get()));
-
   return LLDB_RECORD_RESULT(sb_value);
 }
 
 SBValue SBFrame::FindValue(const char *name, ValueType value_type) {
   LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, FindValue,
                      (const char *, lldb::ValueType), name, value_type);
 
   SBValue value;

 }
 
 SBValue SBFrame::FindValue(const char *name, ValueType value_type,
                            lldb::DynamicValueType use_dynamic) {
   LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, FindValue,
                      (const char *, lldb::ValueType, lldb::DynamicValueType),
                      name, value_type, use_dynamic);
 
-  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   SBValue sb_value;
 
   if (name == nullptr || name[0] == '\0') {
-    if (log)
-      log->Printf("SBFrame::FindValue called with empty name.");
     return LLDB_RECORD_RESULT(sb_value);
   }
 
   ValueObjectSP value_sp;
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
   StackFrame *frame = nullptr;
if (stop_locker.TryLock(&process->GetRunLock())) {
             value_sp = expr_var_sp->GetValueObject();
             sb_value.SetSP(value_sp, use_dynamic);
           }
         } break;
 
         default:
           break;
         }
-      } else {
-        if (log)
-          log->Printf("SBFrame::FindValue () => error: could not reconstruct "
-                      "frame object for this SBFrame.");
-      }
-    } else {
-      if (log)
-        log->Printf("SBFrame::FindValue () => error: process is running");
       }
     }
-
-  if (log)
-    log->Printf("SBFrame(%p)::FindVariableInScope (name=\"%s\", value_type=%i) "
-                "=> SBValue(%p)",
-                static_cast<void *>(frame), name, value_type,
-                static_cast<void *>(value_sp.get()));
+  }
 
   return LLDB_RECORD_RESULT(sb_value);
 }
 
 bool SBFrame::IsEqual(const SBFrame &that) const {
   LLDB_RECORD_METHOD_CONST(bool, SBFrame, IsEqual, (const lldb::SBFrame &),
                            that);
 
LLDB_RECORD_METHOD_CONST(bool, SBFrame, operator!=,(const lldb::SBFrame &),
                            rhs);
 
   return !IsEqual(rhs);
 }
 
 SBThread SBFrame::GetThread() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBThread, SBFrame, GetThread);
 
-  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
   ThreadSP thread_sp(exe_ctx.GetThreadSP());
   SBThread sb_thread(thread_sp);
 
-  if (log) {
-    SBStream sstr;
-    sb_thread.GetDescription(sstr);
-    log->Printf("SBFrame(%p)::GetThread () => SBThread(%p): %s",
-                static_cast<void *>(exe_ctx.GetFramePtr()),
-                static_cast<void *>(thread_sp.get()), sstr.GetData());
-  }
-
   return LLDB_RECORD_RESULT(sb_thread);
 }
 
 const char *SBFrame::Disassemble() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBFrame, Disassemble);
 
-  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   const char *disassembly = nullptr;
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
   StackFrame *frame = nullptr;
   Target *target = exe_ctx.GetTargetPtr();
   Process *process = exe_ctx.GetProcessPtr();
   if (target && process) {
     Process::StopLocker stop_locker;
     if (stop_locker.TryLock(&process->GetRunLock())) {
       frame = exe_ctx.GetFramePtr();
       if (frame) {
         disassembly = frame->Disassemble();
-      } else {
-        if (log)
-          log->Printf("SBFrame::Disassemble () => error: could not reconstruct "
-                      "frame object for this SBFrame.");
       }
-    } else {
-      if (log)
-        log->Printf("SBFrame::Disassemble () => error: process is running");
     }
   }
 
-  if (log)
-    log->Printf("SBFrame(%p)::Disassemble () => %s", static_cast<void *>(frame),
-                disassembly);
-
   return disassembly;
 }
 
 SBValueList SBFrame::GetVariables(bool arguments, bool locals, bool statics,
                                   bool in_scope_only) {
   LLDB_RECORD_METHOD(lldb::SBValueList, SBFrame, GetVariables,
                      (bool, bool, bool, bool), arguments, locals, statics,
                      in_scope_only);
lldb::SBValueList SBFrame::GetVariables(bool arguments, bool locals,
   options.SetUseDynamic(use_dynamic);
   return LLDB_RECORD_RESULT(GetVariables(options));
 }
 
 SBValueList SBFrame::GetVariables(const lldb::SBVariablesOptions &options) {
   LLDB_RECORD_METHOD(lldb::SBValueList, SBFrame, GetVariables,
                      (const lldb::SBVariablesOptions &), options);
 
-  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-
   SBValueList value_list;
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
   StackFrame *frame = nullptr;
   Target *target = exe_ctx.GetTargetPtr();
 
   const bool statics = options.GetIncludeStatics();
   const bool arguments = options.GetIncludeArguments();
   const bool recognized_arguments =
         options.GetIncludeRecognizedArguments(SBTarget(exe_ctx.GetTargetSP()));
   const bool locals = options.GetIncludeLocals();
   const bool in_scope_only = options.GetInScopeOnly();
   const bool include_runtime_support_values =
       options.GetIncludeRuntimeSupportValues();
   const lldb::DynamicValueType use_dynamic = options.GetUseDynamic();
 
-  if (log)
-    log->Printf(
-        "SBFrame::GetVariables (arguments=%i, recognized_arguments=%i, "
-        "locals=%i, statics=%i, in_scope_only=%i runtime=%i dynamic=%i)",
-        arguments, recognized_arguments, locals, statics, in_scope_only,
-        include_runtime_support_values, use_dynamic);
 
   std::set<VariableSP> variable_set;
   Process *process = exe_ctx.GetProcessPtr();
   if (target && process) {
     Process::StopLocker stop_locker;
     if (stop_locker.TryLock(&process->GetRunLock())) {
       frame = exe_ctx.GetFramePtr();
       if (frame) {
if (stop_locker.TryLock(&process->GetRunLock())) {
               for (auto &rec_value_sp : recognized_arg_list->GetObjects()) {
                 SBValue value_sb;
                 value_sb.SetSP(rec_value_sp, use_dynamic);
                 value_list.Append(value_sb);
               }
             }
           }
         }
-      } else {
-        if (log)
-          log->Printf("SBFrame::GetVariables () => error: could not "
-                      "reconstruct frame object for this SBFrame.");
       }
-    } else {
-      if (log)
-        log->Printf("SBFrame::GetVariables () => error: process is running");
     }
   }
 
-  if (log)
-    log->Printf("SBFrame(%p)::GetVariables (...) => SBValueList(%p)",
-                static_cast<void *>(frame),
-                static_cast<void *>(value_list.opaque_ptr()));
-
   return LLDB_RECORD_RESULT(value_list);
 }
 
 SBValueList SBFrame::GetRegisters() {
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBValueList, SBFrame, GetRegisters);
 
-  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-
   SBValueList value_list;
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
   StackFrame *frame = nullptr;
   Target *target = exe_ctx.GetTargetPtr();
   Process *process = exe_ctx.GetProcessPtr();
   if (target && process) {
     Process::StopLocker stop_locker;
     if (stop_locker.TryLock(&process->GetRunLock())) {
       frame = exe_ctx.GetFramePtr();
       if (frame) {
         RegisterContextSP reg_ctx(frame->GetRegisterContext());
         if (reg_ctx) {
           const uint32_t num_sets = reg_ctx->GetRegisterSetCount();
           for (uint32_t set_idx = 0; set_idx < num_sets; ++set_idx) {
             value_list.Append(
                 ValueObjectRegisterSet::Create(frame, reg_ctx, set_idx));
           }
         }
-      } else {
-        if (log)
-          log->Printf("SBFrame::GetRegisters () => error: could not "
-                      "reconstruct frame object for this SBFrame.");
       }
-    } else {
-      if (log)
-        log->Printf("SBFrame::GetRegisters () => error: process is running");
     }
   }
 
-  if (log)
-    log->Printf("SBFrame(%p)::GetRegisters () => SBValueList(%p)",
-                static_cast<void *>(frame),
-                static_cast<void *>(value_list.opaque_ptr()));
-
   return LLDB_RECORD_RESULT(value_list);
 }
 
 SBValue SBFrame::FindRegister(const char *name) {
   LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, FindRegister, (const char *),
                      name);
 
-  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-
   SBValue result;
   ValueObjectSP value_sp;
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
   StackFrame *frame = nullptr;
   Target *target = exe_ctx.GetTargetPtr();
   Process *process = exe_ctx.GetProcessPtr();
if (stop_locker.TryLock(&process->GetRunLock())) {
                  (reg_info->alt_name &&
                   strcasecmp(reg_info->alt_name, name) == 0))) {
               value_sp = ValueObjectRegister::Create(frame, reg_ctx, reg_idx);
               result.SetSP(value_sp);
               break;
             }
           }
         }
-      } else {
-        if (log)
-          log->Printf("SBFrame::FindRegister () => error: could not "
-                      "reconstruct frame object for this SBFrame.");
       }
-    } else {
-      if (log)
-        log->Printf("SBFrame::FindRegister () => error: process is running");
     }
   }
 
-  if (log)
-    log->Printf("SBFrame(%p)::FindRegister () => SBValue(%p)",
-                static_cast<void *>(frame),
-                static_cast<void *>(value_sp.get()));
-
   return LLDB_RECORD_RESULT(result);
 }
 
 bool SBFrame::GetDescription(SBStream &description) {
   LLDB_RECORD_METHOD(bool, SBFrame, GetDescription, (lldb::SBStream &),
                      description);
 
-  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   Stream &strm = description.ref();
 
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
   StackFrame *frame;
   Target *target = exe_ctx.GetTargetPtr();
   Process *process = exe_ctx.GetProcessPtr();
   if (target && process) {
     Process::StopLocker stop_locker;
     if (stop_locker.TryLock(&process->GetRunLock())) {
       frame = exe_ctx.GetFramePtr();
       if (frame) {
         frame->DumpUsingSettingsFormat(&strm);
-      } else {
-        if (log)
-          log->Printf("SBFrame::GetDescription () => error: could not "
-                      "reconstruct frame object for this SBFrame.");
-      }
-    } else {
-      if (log)
-        log->Printf("SBFrame::GetDescription () => error: process is running");
+      }
     }
 
   } else
     strm.PutCString("No value");
 
   return true;
 }
 

 }
 
 lldb::SBValue SBFrame::EvaluateExpression(const char *expr,
                                           const SBExpressionOptions &options) {
   LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, EvaluateExpression,
                      (const char *, const lldb::SBExpressionOptions &), expr,
                      options);
 
-  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-
 #ifndef LLDB_DISABLE_PYTHON
   Log *expr_log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
 #endif
 
   ExpressionResults exe_results = eExpressionSetupError;
   SBValue expr_result;
 
   if (expr == nullptr || expr[0] == '\0') {
-    if (log)
-      log->Printf(
-          "SBFrame::EvaluateExpression called with an empty expression");
     return LLDB_RECORD_RESULT(expr_result);
   }
 
   ValueObjectSP expr_value_sp;
 
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
-  if (log)
-    log->Printf("SBFrame()::EvaluateExpression (expr=\"%s\")...", expr);
 
   StackFrame *frame = nullptr;
   Target *target = exe_ctx.GetTargetPtr();
   Process *process = exe_ctx.GetProcessPtr();
 
   if (target && process) {
     Process::StopLocker stop_locker;
     if (stop_locker.TryLock(&process->GetRunLock())) {
       frame = exe_ctx.GetFramePtr();
       if (frame) {
         std::unique_ptr<llvm::PrettyStackTraceFormat> stack_trace;
         if (target->GetDisplayExpressionsInCrashlogs()) {
           StreamString frame_description;
           frame->DumpUsingSettingsFormat(&frame_description);
           stack_trace = llvm::make_unique<llvm::PrettyStackTraceFormat>(
               "SBFrame::EvaluateExpression (expr = \"%s\", fetch_dynamic_value "
               "= %u) %s",
               expr, options.GetFetchDynamicValue(),
               frame_description.GetData());
         }
 
         exe_results = target->EvaluateExpression(expr, frame, expr_value_sp,
                                                  options.ref());
         expr_result.SetSP(expr_value_sp, options.GetFetchDynamicValue());
-      } else {
-        if (log)
-          log->Printf("SBFrame::EvaluateExpression () => error: could not "
-                      "reconstruct frame object for this SBFrame.");
-      }
-    } else {
-      if (log)
-        log->Printf(
-            "SBFrame::EvaluateExpression () => error: process is running");
+      }
     }
   }
 
 #ifndef LLDB_DISABLE_PYTHON
   if (expr_log)
     expr_log->Printf("** [SBFrame::EvaluateExpression] Expression result is "
                      "%s, summary %s **",
                      expr_result.GetValue(), expr_result.GetSummary());
-
-  if (log)
-    log->Printf("SBFrame(%p)::EvaluateExpression (expr=\"%s\") => SBValue(%p) "
-                "(execution result=%d)",
-                static_cast<void *>(frame), expr,
-                static_cast<void *>(expr_value_sp.get()), exe_results);
 #endif
 
   return LLDB_RECORD_RESULT(expr_result);
 }
 
 bool SBFrame::IsInlined() {
   LLDB_RECORD_METHOD_NO_ARGS(bool, SBFrame, IsInlined);
 
   return static_cast<const SBFrame *>(this)->IsInlined();
 }
 
 bool SBFrame::IsInlined() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBFrame, IsInlined);
 
-  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
   StackFrame *frame = nullptr;
   Target *target = exe_ctx.GetTargetPtr();
   Process *process = exe_ctx.GetProcessPtr();
   if (target && process) {
     Process::StopLocker stop_locker;
     if (stop_locker.TryLock(&process->GetRunLock())) {
       frame = exe_ctx.GetFramePtr();
       if (frame) {
 
         Block *block = frame->GetSymbolContext(eSymbolContextBlock).block;
         if (block)
           return block->GetContainingInlinedBlock() != nullptr;
-      } else {
-        if (log)
-          log->Printf("SBFrame::IsInlined () => error: could not reconstruct "
-                      "frame object for this SBFrame.");
-      }
-    } else {
-      if (log)
-        log->Printf("SBFrame::IsInlined () => error: process is running");
+      }
     }
   }
   return false;
 }
 
 bool SBFrame::IsArtificial() {
   LLDB_RECORD_METHOD_NO_ARGS(bool, SBFrame, IsArtificial);
 
if (target && process) {
     }
   }
   return eLanguageTypeUnknown;
 }
 
 const char *SBFrame::GetFunctionName() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBFrame, GetFunctionName);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   const char *name = nullptr;
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
   StackFrame *frame = nullptr;
   Target *target = exe_ctx.GetTargetPtr();
   Process *process = exe_ctx.GetProcessPtr();
   if (target && process) {
if (stop_locker.TryLock(&process->GetRunLock())) {
           if (sc.function)
             name = sc.function->GetName().GetCString();
         }
 
         if (name == nullptr) {
           if (sc.symbol)
             name = sc.symbol->GetName().GetCString();
         }
-      } else {
-        if (log)
-          log->Printf("SBFrame::GetFunctionName () => error: could not "
-                      "reconstruct frame object for this SBFrame.");
-      }
-    } else {
-      if (log)
-        log->Printf("SBFrame::GetFunctionName() => error: process is running");
+      }
     }
   }
   return name;
 }
 
 const char *SBFrame::GetDisplayFunctionName() {
   LLDB_RECORD_METHOD_NO_ARGS(const char *, SBFrame, GetDisplayFunctionName);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   const char *name = nullptr;
 
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
   StackFrame *frame = nullptr;
   Target *target = exe_ctx.GetTargetPtr();
   Process *process = exe_ctx.GetProcessPtr();
if (stop_locker.TryLock(&process->GetRunLock())) {
           if (sc.function)
             name = sc.function->GetDisplayName().GetCString();
         }
 
         if (name == nullptr) {
           if (sc.symbol)
             name = sc.symbol->GetDisplayName().GetCString();
         }
-      } else {
-        if (log)
-          log->Printf("SBFrame::GetDisplayFunctionName () => error: could not "
-                      "reconstruct frame object for this SBFrame.");
-      }
-    } else {
-      if (log)
-        log->Printf(
-            "SBFrame::GetDisplayFunctionName() => error: process is running");
+      }
     }
   }
   return name;
 }

source/API/SBFunction.cpp

 #include "lldb/Core/Disassembler.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Symbol/CompileUnit.h"
 #include "lldb/Symbol/Function.h"
 #include "lldb/Symbol/Type.h"
 #include "lldb/Symbol/VariableList.h"
 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Target/Target.h"
-#include "lldb/Utility/Log.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 SBFunction::SBFunction() : m_opaque_ptr(NULL) {
   LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBFunction);
 }
 

 
 const char *SBFunction::GetName() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBFunction, GetName);
 
   const char *cstr = NULL;
   if (m_opaque_ptr)
     cstr = m_opaque_ptr->GetName().AsCString();
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  if (log) {
-    if (cstr)
-      log->Printf("SBFunction(%p)::GetName () => \"%s\"",
-                  static_cast<void *>(m_opaque_ptr), cstr);
-    else
-      log->Printf("SBFunction(%p)::GetName () => NULL",
-                  static_cast<void *>(m_opaque_ptr));
-  }
   return cstr;
 }
 
 const char *SBFunction::GetDisplayName() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBFunction, GetDisplayName);
 
   const char *cstr = NULL;
   if (m_opaque_ptr)
     cstr = m_opaque_ptr->GetMangled()
                .GetDisplayDemangledName(m_opaque_ptr->GetLanguage())
                .AsCString();
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  if (log) {
-    if (cstr)
-      log->Printf("SBFunction(%p)::GetDisplayName () => \"%s\"",
-                  static_cast<void *>(m_opaque_ptr), cstr);
-    else
-      log->Printf("SBFunction(%p)::GetDisplayName () => NULL",
-                  static_cast<void *>(m_opaque_ptr));
-  }
   return cstr;
 }
 
 const char *SBFunction::GetMangledName() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBFunction, GetMangledName);
 
   const char *cstr = NULL;
   if (m_opaque_ptr)
     cstr = m_opaque_ptr->GetMangled().GetMangledName().AsCString();
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  if (log) {
-    if (cstr)
-      log->Printf("SBFunction(%p)::GetMangledName () => \"%s\"",
-                  static_cast<void *>(m_opaque_ptr), cstr);
-    else
-      log->Printf("SBFunction(%p)::GetMangledName () => NULL",
-                  static_cast<void *>(m_opaque_ptr));
-  }
   return cstr;
 }
 
 bool SBFunction::operator==(const SBFunction &rhs) const {
   LLDB_RECORD_METHOD_CONST(
       bool, SBFunction, operator==,(const lldb::SBFunction &), rhs);
 
   return m_opaque_ptr == rhs.m_opaque_ptr;

source/API/SBHostOS.cpp

 #include "lldb/API/SBHostOS.h"
 #include "lldb/Host/FileSystem.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Host/HostNativeThread.h"
 #include "lldb/Host/HostThread.h"
 #include "lldb/Host/ThreadLauncher.h"
 #include "lldb/Utility/FileSpec.h"
-#include "lldb/Utility/Log.h"
 
 #include "Plugins/ExpressionParser/Clang/ClangHost.h"
 #ifndef LLDB_DISABLE_PYTHON
 #include "Plugins/ScriptInterpreter/Python/ScriptInterpreterPython.h"
 #endif
 
 #include "llvm/ADT/SmallString.h"
 #include "llvm/Support/Path.h"
SBFileSpec SBHostOS::GetUserHomeDirectory() {
 
   sb_fspec.SetFileSpec(homedir);
   return LLDB_RECORD_RESULT(sb_fspec);
 }
 
 lldb::thread_t SBHostOS::ThreadCreate(const char *name,
                                       lldb::thread_func_t thread_function,
                                       void *thread_arg, SBError *error_ptr) {
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-
-  if (log)
-    log->Printf(
-        "SBHostOS::ThreadCreate (name=\"%s\", thread_function=%p, "
-        "thread_arg=%p, error_ptr=%p)",
-        name,
-        reinterpret_cast<void *>(reinterpret_cast<intptr_t>(thread_function)),
-        static_cast<void *>(thread_arg), static_cast<void *>(error_ptr));
-
-  // FIXME: You should log the return value?
-
   HostThread thread(ThreadLauncher::LaunchThread(
       name, thread_function, thread_arg, error_ptr ? error_ptr->get() : NULL));
   return thread.Release();
 }
 
 void SBHostOS::ThreadCreated(const char *name) {
   LLDB_RECORD_STATIC_METHOD(void, SBHostOS, ThreadCreated, (const char *),
                             name);

source/API/SBLineEntry.cpp

 //===-- SBLineEntry.cpp -----------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBLineEntry.h"
 #include "SBReproducerPrivate.h"
 #include "Utils.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/Host/PosixApi.h"
 #include "lldb/Symbol/LineEntry.h"
-#include "lldb/Utility/Log.h"
 #include "lldb/Utility/StreamString.h"
 
 #include <limits.h>
 
 using namespace lldb;
 using namespace lldb_private;
 
 SBLineEntry::SBLineEntry() : m_opaque_up() {

 SBAddress SBLineEntry::GetStartAddress() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBAddress, SBLineEntry,
                                    GetStartAddress);
 
   SBAddress sb_address;
   if (m_opaque_up)
     sb_address.SetAddress(&m_opaque_up->range.GetBaseAddress());
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  if (log) {
-    StreamString sstr;
-    const Address *addr = sb_address.get();
-    if (addr)
-      addr->Dump(&sstr, NULL, Address::DumpStyleModuleWithFileAddress,
-                 Address::DumpStyleInvalid, 4);
-    log->Printf("SBLineEntry(%p)::GetStartAddress () => SBAddress (%p): %s",
-                static_cast<void *>(m_opaque_up.get()),
-                static_cast<void *>(sb_address.get()), sstr.GetData());
-  }
-
   return LLDB_RECORD_RESULT(sb_address);
 }
 
 SBAddress SBLineEntry::GetEndAddress() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBAddress, SBLineEntry, GetEndAddress);
 
   SBAddress sb_address;
   if (m_opaque_up) {
     sb_address.SetAddress(&m_opaque_up->range.GetBaseAddress());
     sb_address.OffsetAddress(m_opaque_up->range.GetByteSize());
   }
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  if (log) {
-    StreamString sstr;
-    const Address *addr = sb_address.get();
-    if (addr)
-      addr->Dump(&sstr, NULL, Address::DumpStyleModuleWithFileAddress,
-                 Address::DumpStyleInvalid, 4);
-    log->Printf("SBLineEntry(%p)::GetEndAddress () => SBAddress (%p): %s",
-                static_cast<void *>(m_opaque_up.get()),
-                static_cast<void *>(sb_address.get()), sstr.GetData());
-  }
   return LLDB_RECORD_RESULT(sb_address);
 }
 
 bool SBLineEntry::IsValid() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBLineEntry, IsValid);
 
   return m_opaque_up.get() && m_opaque_up->IsValid();
 }
 
 SBFileSpec SBLineEntry::GetFileSpec() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBFileSpec, SBLineEntry, GetFileSpec);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-
   SBFileSpec sb_file_spec;
   if (m_opaque_up.get() && m_opaque_up->file)
     sb_file_spec.SetFileSpec(m_opaque_up->file);
 
-  if (log) {
-    SBStream sstr;
-    sb_file_spec.GetDescription(sstr);
-    log->Printf("SBLineEntry(%p)::GetFileSpec () => SBFileSpec(%p): %s",
-                static_cast<void *>(m_opaque_up.get()),
-                static_cast<const void *>(sb_file_spec.get()), sstr.GetData());
-  }
-
   return LLDB_RECORD_RESULT(sb_file_spec);
 }
 
 uint32_t SBLineEntry::GetLine() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBLineEntry, GetLine);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-
   uint32_t line = 0;
   if (m_opaque_up)
     line = m_opaque_up->line;
 
-  if (log)
-    log->Printf("SBLineEntry(%p)::GetLine () => %u",
-                static_cast<void *>(m_opaque_up.get()), line);
-
   return line;
 }
 
 uint32_t SBLineEntry::GetColumn() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBLineEntry, GetColumn);
 
   if (m_opaque_up)
     return m_opaque_up->column;

source/API/SBListener.cpp

 #include "SBReproducerPrivate.h"
 #include "lldb/API/SBBroadcaster.h"
 #include "lldb/API/SBDebugger.h"
 #include "lldb/API/SBEvent.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/Core/Debugger.h"
 #include "lldb/Utility/Broadcaster.h"
 #include "lldb/Utility/Listener.h"
-#include "lldb/Utility/Log.h"
 #include "lldb/Utility/StreamString.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 SBListener::SBListener() : m_opaque_sp(), m_unused_ptr(NULL) {
   LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBListener);
 }
 
 SBListener::SBListener(const char *name)
     : m_opaque_sp(Listener::MakeListener(name)), m_unused_ptr(nullptr) {
   LLDB_RECORD_CONSTRUCTOR(SBListener, (const char *), name);
-
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-
-  if (log)
-    log->Printf("SBListener::SBListener (name=\"%s\") => SBListener(%p)", name,
-                static_cast<void *>(m_opaque_sp.get()));
 }
 
 SBListener::SBListener(const SBListener &rhs)
     : m_opaque_sp(rhs.m_opaque_sp), m_unused_ptr(nullptr) {
   LLDB_RECORD_CONSTRUCTOR(SBListener, (const lldb::SBListener &), rhs);
 }
 
 const lldb::SBListener &SBListener::operator=(const lldb::SBListener &rhs) {
LLDB_RECORD_METHOD(uint32_t, SBListener, StartListeningForEvents,
                      event_mask);
 
   uint32_t acquired_event_mask = 0;
   if (m_opaque_sp && broadcaster.IsValid()) {
     acquired_event_mask =
         m_opaque_sp->StartListeningForEvents(broadcaster.get(), event_mask);
   }
 
-  Log *log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API);
-  if (log) {
-    StreamString sstr_requested;
-    StreamString sstr_acquired;
-
-    Broadcaster *lldb_broadcaster = broadcaster.get();
-    if (lldb_broadcaster) {
-      const bool got_requested_names =
-          lldb_broadcaster->GetEventNames(sstr_requested, event_mask, false);
-      const bool got_acquired_names = lldb_broadcaster->GetEventNames(
-          sstr_acquired, acquired_event_mask, false);
-      log->Printf("SBListener(%p)::StartListeneingForEvents "
-                  "(SBBroadcaster(%p): %s, event_mask=0x%8.8x%s%s%s) => "
-                  "0x%8.8x%s%s%s",
-                  static_cast<void *>(m_opaque_sp.get()),
-                  static_cast<void *>(lldb_broadcaster),
-                  lldb_broadcaster->GetBroadcasterName().GetCString(),
-                  event_mask, got_requested_names ? " (" : "",
-                  sstr_requested.GetData(), got_requested_names ? ")" : "",
-                  acquired_event_mask, got_acquired_names ? " (" : "",
-                  sstr_acquired.GetData(), got_acquired_names ? ")" : "");
-    } else {
-      log->Printf("SBListener(%p)::StartListeneingForEvents "
-                  "(SBBroadcaster(%p), event_mask=0x%8.8x) => 0x%8.8x",
-                  static_cast<void *>(m_opaque_sp.get()),
-                  static_cast<void *>(lldb_broadcaster), event_mask,
-                  acquired_event_mask);
-    }
-  }
-
   return acquired_event_mask;
 }
 
 bool SBListener::StopListeningForEvents(const SBBroadcaster &broadcaster,
                                         uint32_t event_mask) {
   LLDB_RECORD_METHOD(bool, SBListener, StopListeningForEvents,
                      (const lldb::SBBroadcaster &, uint32_t), broadcaster,
                      event_mask);
 
   if (m_opaque_sp && broadcaster.IsValid()) {
     return m_opaque_sp->StopListeningForEvents(broadcaster.get(), event_mask);
   }
   return false;
 }
 
 bool SBListener::WaitForEvent(uint32_t timeout_secs, SBEvent &event) {
   LLDB_RECORD_METHOD(bool, SBListener, WaitForEvent,
                      (uint32_t, lldb::SBEvent &), timeout_secs, event);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  if (log) {
-    if (timeout_secs == UINT32_MAX) {
-      log->Printf("SBListener(%p)::WaitForEvent (timeout_secs=INFINITE, "
-                  "SBEvent(%p))...",
-                  static_cast<void *>(m_opaque_sp.get()),
-                  static_cast<void *>(event.get()));
-    } else {
-      log->Printf(
-          "SBListener(%p)::WaitForEvent (timeout_secs=%d, SBEvent(%p))...",
-          static_cast<void *>(m_opaque_sp.get()), timeout_secs,
-          static_cast<void *>(event.get()));
-    }
-  }
   bool success = false;
 
   if (m_opaque_sp) {
     Timeout<std::micro> timeout(llvm::None);
     if (timeout_secs != UINT32_MAX) {
       assert(timeout_secs != 0); // Take this out after all calls with timeout
                                  // set to zero have been removed....
       timeout = std::chrono::seconds(timeout_secs);
     }
     EventSP event_sp;
     if (m_opaque_sp->GetEvent(event_sp, timeout)) {
       event.reset(event_sp);
       success = true;
     }
   }
 
-  if (log) {
-    if (timeout_secs == UINT32_MAX) {
-      log->Printf("SBListener(%p)::WaitForEvent (timeout_secs=INFINITE, "
-                  "SBEvent(%p)) => %i",
-                  static_cast<void *>(m_opaque_sp.get()),
-                  static_cast<void *>(event.get()), success);
-    } else {
-      log->Printf(
-          "SBListener(%p)::WaitForEvent (timeout_secs=%d, SBEvent(%p)) => %i",
-          static_cast<void *>(m_opaque_sp.get()), timeout_secs,
-          static_cast<void *>(event.get()), success);
-    }
-  }
   if (!success)
     event.reset(NULL);
   return success;
 }
 
 bool SBListener::WaitForEventForBroadcaster(uint32_t num_seconds,
                                             const SBBroadcaster &broadcaster,
                                             SBEvent &event) {

source/API/SBMemoryRegionInfoList.cpp

 //===-- SBMemoryRegionInfoList.cpp ------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBMemoryRegionInfoList.h"
 #include "SBReproducerPrivate.h"
 #include "lldb/API/SBMemoryRegionInfo.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/Target/MemoryRegionInfo.h"
-#include "lldb/Utility/Log.h"
 
 #include <vector>
 
 using namespace lldb;
 using namespace lldb_private;
 
 class MemoryRegionInfoListImpl {
 public:
uint32_t SBMemoryRegionInfoList::GetSize() const {
   return m_opaque_up->GetSize();
 }
 
 bool SBMemoryRegionInfoList::GetMemoryRegionAtIndex(
     uint32_t idx, SBMemoryRegionInfo &region_info) {
   LLDB_RECORD_METHOD(bool, SBMemoryRegionInfoList, GetMemoryRegionAtIndex,
                      (uint32_t, lldb::SBMemoryRegionInfo &), idx, region_info);
 
-  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-
-  bool result = m_opaque_up->GetMemoryRegionInfoAtIndex(idx, region_info.ref());
-
-  if (log) {
-    SBStream sstr;
-    region_info.GetDescription(sstr);
-    log->Printf("SBMemoryRegionInfoList::GetMemoryRegionAtIndex (this.ap=%p, "
-                "idx=%d) => SBMemoryRegionInfo (this.ap=%p, '%s')",
-                static_cast<void *>(m_opaque_up.get()), idx,
-                static_cast<void *>(region_info.m_opaque_up.get()),
-                sstr.GetData());
-  }
-
-  return result;
+  return m_opaque_up->GetMemoryRegionInfoAtIndex(idx, region_info.ref());
 }
 
 void SBMemoryRegionInfoList::Clear() {
   LLDB_RECORD_METHOD_NO_ARGS(void, SBMemoryRegionInfoList, Clear);
 
   m_opaque_up->Clear();
 }
 

source/API/SBModule.cpp

 #include "lldb/Core/ValueObjectVariable.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/SymbolFile.h"
 #include "lldb/Symbol/SymbolVendor.h"
 #include "lldb/Symbol/Symtab.h"
 #include "lldb/Symbol/TypeSystem.h"
 #include "lldb/Symbol/VariableList.h"
 #include "lldb/Target/Target.h"
-#include "lldb/Utility/Log.h"
 #include "lldb/Utility/StreamString.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 SBModule::SBModule() : m_opaque_sp() {
   LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBModule);
 }
void SBModule::Clear() {
   LLDB_RECORD_METHOD_NO_ARGS(void, SBModule, Clear);
 
   m_opaque_sp.reset();
 }
 
 SBFileSpec SBModule::GetFileSpec() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBFileSpec, SBModule, GetFileSpec);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-
   SBFileSpec file_spec;
   ModuleSP module_sp(GetSP());
   if (module_sp)
     file_spec.SetFileSpec(module_sp->GetFileSpec());
 
-  if (log)
-    log->Printf("SBModule(%p)::GetFileSpec () => SBFileSpec(%p)",
-                static_cast<void *>(module_sp.get()),
-                static_cast<const void *>(file_spec.get()));
-
   return LLDB_RECORD_RESULT(file_spec);
 }
 
 lldb::SBFileSpec SBModule::GetPlatformFileSpec() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBFileSpec, SBModule,
                                    GetPlatformFileSpec);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   SBFileSpec file_spec;
   ModuleSP module_sp(GetSP());
   if (module_sp)
     file_spec.SetFileSpec(module_sp->GetPlatformFileSpec());
 
-  if (log)
-    log->Printf("SBModule(%p)::GetPlatformFileSpec () => SBFileSpec(%p)",
-                static_cast<void *>(module_sp.get()),
-                static_cast<const void *>(file_spec.get()));
-
   return LLDB_RECORD_RESULT(file_spec);
 }
 
 bool SBModule::SetPlatformFileSpec(const lldb::SBFileSpec &platform_file) {
   LLDB_RECORD_METHOD(bool, SBModule, SetPlatformFileSpec,
                      (const lldb::SBFileSpec &), platform_file);
 
   bool result = false;
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   ModuleSP module_sp(GetSP());
   if (module_sp) {
     module_sp->SetPlatformFileSpec(*platform_file);
     result = true;
   }
 
-  if (log)
-    log->Printf("SBModule(%p)::SetPlatformFileSpec (SBFileSpec(%p (%s)) => %i",
-                static_cast<void *>(module_sp.get()),
-                static_cast<const void *>(platform_file.get()),
-                platform_file->GetPath().c_str(), result);
   return result;
 }
 
 lldb::SBFileSpec SBModule::GetRemoteInstallFileSpec() {
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBFileSpec, SBModule,
                              GetRemoteInstallFileSpec);
 
   SBFileSpec sb_file_spec;
if (module_sp) {
     return true;
   }
   return false;
 }
 
 const uint8_t *SBModule::GetUUIDBytes() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(const uint8_t *, SBModule, GetUUIDBytes);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-
   const uint8_t *uuid_bytes = NULL;
   ModuleSP module_sp(GetSP());
   if (module_sp)
     uuid_bytes = module_sp->GetUUID().GetBytes().data();
 
-  if (log) {
-    if (uuid_bytes) {
-      StreamString s;
-      module_sp->GetUUID().Dump(&s);
-      log->Printf("SBModule(%p)::GetUUIDBytes () => %s",
-                  static_cast<void *>(module_sp.get()), s.GetData());
-    } else
-      log->Printf("SBModule(%p)::GetUUIDBytes () => NULL",
-                  static_cast<void *>(module_sp.get()));
-  }
   return uuid_bytes;
 }
 
 const char *SBModule::GetUUIDString() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBModule, GetUUIDString);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   const char *uuid_cstr = NULL;
   ModuleSP module_sp(GetSP());
   if (module_sp) {
     // We are going to return a "const char *" value through the public API, so
     // we need to constify it so it gets added permanently the string pool and
     // then we don't need to worry about the lifetime of the string as it will
     // never go away once it has been put into the ConstString string pool
     uuid_cstr = ConstString(module_sp->GetUUID().GetAsString()).GetCString();
   }
 
   if (uuid_cstr && uuid_cstr[0]) {
-    if (log)
-      log->Printf("SBModule(%p)::GetUUIDString () => %s",
-                  static_cast<void *>(module_sp.get()), uuid_cstr);
     return uuid_cstr;
   }
 
-  if (log)
-    log->Printf("SBModule(%p)::GetUUIDString () => NULL",
-                static_cast<void *>(module_sp.get()));
   return NULL;
 }
 
 bool SBModule::operator==(const SBModule &rhs) const {
   LLDB_RECORD_METHOD_CONST(bool, SBModule, operator==,(const lldb::SBModule &),
                            rhs);
 
   if (m_opaque_sp)

source/API/SBProcess.cpp

 #include "lldb/Core/StreamFile.h"
 #include "lldb/Target/MemoryRegionInfo.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/SystemRuntime.h"
 #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"
 
 
 #include "lldb/API/SBBroadcaster.h"
 #include "lldb/API/SBCommandReturnObject.h"
 #include "lldb/API/SBDebugger.h"
bool SBProcess::RemoteLaunch(char const **argv, char const **envp,
                              lldb::SBError &error) {
   LLDB_RECORD_METHOD(bool, SBProcess, RemoteLaunch,
                      (const char **, const char **, const char *, const char *,
                       const char *, const char *, uint32_t, bool,
                       lldb::SBError &),
                      argv, envp, stdin_path, stdout_path, stderr_path,
                      working_directory, launch_flags, stop_at_entry, error);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  if (log)
-    log->Printf("SBProcess(%p)::RemoteLaunch (argv=%p, envp=%p, stdin=%s, "
-                "stdout=%s, stderr=%s, working-dir=%s, launch_flags=0x%x, "
-                "stop_at_entry=%i, &error (%p))...",
-                static_cast<void *>(m_opaque_wp.lock().get()),
-                static_cast<void *>(argv), static_cast<void *>(envp),
-                stdin_path ? stdin_path : "NULL",
-                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(
         process_sp->GetTarget().GetAPIMutex());
     if (process_sp->GetState() == eStateConnected) {
       if (stop_at_entry)
         launch_flags |= eLaunchFlagStopAtEntry;
       ProcessLaunchInfo launch_info(FileSpec(stdin_path), FileSpec(stdout_path),
if (process_sp->GetState() == eStateConnected) {
       error.SetError(process_sp->Launch(launch_info));
     } else {
       error.SetErrorString("must be in eStateConnected to call RemoteLaunch");
     }
   } else {
     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(
         process_sp->GetTarget().GetAPIMutex());
     if (process_sp->GetState() == eStateConnected) {
       ProcessAttachInfo attach_info;
       attach_info.SetProcessID(pid);
       error.SetError(process_sp->Attach(attach_info));
     } else {
       error.SetErrorString(
           "must be in eStateConnected to call RemoteAttachToProcessWithID");
     }
   } else {
     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) {
     Process::StopLocker stop_locker;
 
     const bool can_update = stop_locker.TryLock(&process_sp->GetRunLock());
     std::lock_guard<std::recursive_mutex> guard(
         process_sp->GetTarget().GetAPIMutex());
     num_threads = process_sp->GetThreadList().GetSize(can_update);
   }
 
-  if (log)
-    log->Printf("SBProcess(%p)::GetNumThreads () => %d",
-                static_cast<void *>(process_sp.get()), num_threads);
-
   return num_threads;
 }
 
 SBThread SBProcess::GetSelectedThread() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBThread, SBProcess,
                                    GetSelectedThread);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-
   SBThread sb_thread;
   ThreadSP thread_sp;
   ProcessSP process_sp(GetSP());
   if (process_sp) {
     std::lock_guard<std::recursive_mutex> guard(
         process_sp->GetTarget().GetAPIMutex());
     thread_sp = process_sp->GetThreadList().GetSelectedThread();
     sb_thread.SetThread(thread_sp);
   }
 
-  if (log)
-    log->Printf("SBProcess(%p)::GetSelectedThread () => SBThread(%p)",
-                static_cast<void *>(process_sp.get()),
-                static_cast<void *>(thread_sp.get()));
-
   return LLDB_RECORD_RESULT(sb_thread);
 }
 
 SBThread SBProcess::CreateOSPluginThread(lldb::tid_t tid,
                                          lldb::addr_t context) {
   LLDB_RECORD_METHOD(lldb::SBThread, SBProcess, CreateOSPluginThread,
                      (lldb::tid_t, lldb::addr_t), tid, context);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-
   SBThread sb_thread;
   ThreadSP thread_sp;
   ProcessSP process_sp(GetSP());
   if (process_sp) {
     std::lock_guard<std::recursive_mutex> guard(
         process_sp->GetTarget().GetAPIMutex());
     thread_sp = process_sp->CreateOSPluginThread(tid, context);
     sb_thread.SetThread(thread_sp);
   }
 
-  if (log)
-    log->Printf("SBProcess(%p)::CreateOSPluginThread (tid=0x%" PRIx64
-                ", context=0x%" PRIx64 ") => SBThread(%p)",
-                static_cast<void *>(process_sp.get()), tid, context,
-                static_cast<void *>(thread_sp.get()));
-
   return 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());
   if (process_sp) {
     target_sp = process_sp->GetTarget().shared_from_this();
     sb_target.SetSP(target_sp);
   }
 
-  if (log)
-    log->Printf("SBProcess(%p)::GetTarget () => SBTarget(%p)",
-                static_cast<void *>(process_sp.get()),
-                static_cast<void *>(target_sp.get()));
-
   return LLDB_RECORD_RESULT(sb_target);
 }
 
 size_t SBProcess::PutSTDIN(const char *src, size_t src_len) {
   LLDB_RECORD_METHOD(size_t, SBProcess, PutSTDIN, (const char *, size_t), src,
                      src_len);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-
   size_t ret_val = 0;
   ProcessSP process_sp(GetSP());
   if (process_sp) {
     Status error;
     ret_val = process_sp->PutSTDIN(src, src_len, error);
   }
 
-  if (log)
-    log->Printf("SBProcess(%p)::PutSTDIN (src=\"%s\", src_len=%" PRIu64
-                ") => %" PRIu64,
-                static_cast<void *>(process_sp.get()), src,
-                static_cast<uint64_t>(src_len), static_cast<uint64_t>(ret_val));
-
   return ret_val;
 }
 
 size_t SBProcess::GetSTDOUT(char *dst, size_t dst_len) const {
   LLDB_RECORD_METHOD_CONST(size_t, SBProcess, GetSTDOUT, (char *, size_t), dst,
                            dst_len);
 
   size_t bytes_read = 0;
   ProcessSP process_sp(GetSP());
   if (process_sp) {
     Status error;
     bytes_read = process_sp->GetSTDOUT(dst, dst_len, error);
   }
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  if (log)
-    log->Printf(
-        "SBProcess(%p)::GetSTDOUT (dst=\"%.*s\", dst_len=%" PRIu64
-        ") => %" PRIu64,
-        static_cast<void *>(process_sp.get()), static_cast<int>(bytes_read),
-        dst, static_cast<uint64_t>(dst_len), static_cast<uint64_t>(bytes_read));
-
   return bytes_read;
 }
 
 size_t SBProcess::GetSTDERR(char *dst, size_t dst_len) const {
   LLDB_RECORD_METHOD_CONST(size_t, SBProcess, GetSTDERR, (char *, size_t), dst,
                            dst_len);
 
   size_t bytes_read = 0;
   ProcessSP process_sp(GetSP());
   if (process_sp) {
     Status error;
     bytes_read = process_sp->GetSTDERR(dst, dst_len, error);
   }
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  if (log)
-    log->Printf(
-        "SBProcess(%p)::GetSTDERR (dst=\"%.*s\", dst_len=%" PRIu64
-        ") => %" PRIu64,
-        static_cast<void *>(process_sp.get()), static_cast<int>(bytes_read),
-        dst, static_cast<uint64_t>(dst_len), static_cast<uint64_t>(bytes_read));
-
   return bytes_read;
 }
 
 size_t SBProcess::GetAsyncProfileData(char *dst, size_t dst_len) const {
   LLDB_RECORD_METHOD_CONST(size_t, SBProcess, GetAsyncProfileData,
                            (char *, size_t), dst, dst_len);
 
   size_t bytes_read = 0;
   ProcessSP process_sp(GetSP());
   if (process_sp) {
     Status error;
     bytes_read = process_sp->GetAsyncProfileData(dst, dst_len, error);
   }
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  if (log)
-    log->Printf(
-        "SBProcess(%p)::GetAsyncProfileData (dst=\"%.*s\", dst_len=%" PRIu64
-        ") => %" PRIu64,
-        static_cast<void *>(process_sp.get()), static_cast<int>(bytes_read),
-        dst, static_cast<uint64_t>(dst_len), static_cast<uint64_t>(bytes_read));
-
   return bytes_read;
 }
 
 lldb::SBTrace SBProcess::StartTrace(SBTraceOptions &options,
                                     lldb::SBError &error) {
   LLDB_RECORD_METHOD(lldb::SBTrace, SBProcess, StartTrace,
                      (lldb::SBTraceOptions &, lldb::SBError &), options, error);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   ProcessSP process_sp(GetSP());
   error.Clear();
   SBTrace trace_instance;
   trace_instance.SetSP(process_sp);
   lldb::user_id_t uid = LLDB_INVALID_UID;
 
   if (!process_sp) {
     error.SetErrorString("invalid process");
   } else {
     uid = process_sp->StartTrace(*(options.m_traceoptions_sp), error.ref());
     trace_instance.SetTraceUID(uid);
-    LLDB_LOG(log, "SBProcess::returned uid - {0}", uid);
   }
   return LLDB_RECORD_RESULT(trace_instance);
 }
 
 void SBProcess::ReportEventState(const SBEvent &event, FILE *out) const {
   LLDB_RECORD_METHOD_CONST(void, SBProcess, ReportEventState,
                            (const lldb::SBEvent &, FILE *), event, out);
 
bool SBProcess::SetSelectedThread(const SBThread &thread) {
   }
   return false;
 }
 
 bool SBProcess::SetSelectedThreadByID(lldb::tid_t tid) {
   LLDB_RECORD_METHOD(bool, SBProcess, SetSelectedThreadByID, (lldb::tid_t),
                      tid);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   bool ret_val = false;
   ProcessSP process_sp(GetSP());
   if (process_sp) {
     std::lock_guard<std::recursive_mutex> guard(
         process_sp->GetTarget().GetAPIMutex());
     ret_val = process_sp->GetThreadList().SetSelectedThreadByID(tid);
   }
 
-  if (log)
-    log->Printf("SBProcess(%p)::SetSelectedThreadByID (tid=0x%4.4" PRIx64
-                ") => %s",
-                static_cast<void *>(process_sp.get()), tid,
-                (ret_val ? "true" : "false"));
-
   return ret_val;
 }
 
 bool SBProcess::SetSelectedThreadByIndexID(uint32_t index_id) {
   LLDB_RECORD_METHOD(bool, SBProcess, SetSelectedThreadByIndexID, (uint32_t),
                      index_id);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-
   bool ret_val = false;
   ProcessSP process_sp(GetSP());
   if (process_sp) {
     std::lock_guard<std::recursive_mutex> guard(
         process_sp->GetTarget().GetAPIMutex());
     ret_val = process_sp->GetThreadList().SetSelectedThreadByIndexID(index_id);
   }
 
-  if (log)
-    log->Printf("SBProcess(%p)::SetSelectedThreadByID (tid=0x%x) => %s",
-                static_cast<void *>(process_sp.get()), index_id,
-                (ret_val ? "true" : "false"));
 
   return ret_val;
 }
 
 SBThread SBProcess::GetThreadAtIndex(size_t index) {
   LLDB_RECORD_METHOD(lldb::SBThread, SBProcess, GetThreadAtIndex, (size_t),
                      index);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-
   SBThread sb_thread;
   ThreadSP thread_sp;
   ProcessSP process_sp(GetSP());
   if (process_sp) {
     Process::StopLocker stop_locker;
     const bool can_update = stop_locker.TryLock(&process_sp->GetRunLock());
     std::lock_guard<std::recursive_mutex> guard(
         process_sp->GetTarget().GetAPIMutex());
     thread_sp = process_sp->GetThreadList().GetThreadAtIndex(index, can_update);
     sb_thread.SetThread(thread_sp);
   }
 
-  if (log)
-    log->Printf("SBProcess(%p)::GetThreadAtIndex (index=%d) => SBThread(%p)",
-                static_cast<void *>(process_sp.get()),
-                static_cast<uint32_t>(index),
-                static_cast<void *>(thread_sp.get()));
-
   return 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) {
     Process::StopLocker stop_locker;
     if (stop_locker.TryLock(&process_sp->GetRunLock())) {
       std::lock_guard<std::recursive_mutex> guard(
           process_sp->GetTarget().GetAPIMutex());
       num_queues = process_sp->GetQueueList().GetSize();
     }
   }
 
-  if (log)
-    log->Printf("SBProcess(%p)::GetNumQueues () => %d",
-                static_cast<void *>(process_sp.get()), num_queues);
-
   return num_queues;
 }
 
 SBQueue SBProcess::GetQueueAtIndex(size_t index) {
   LLDB_RECORD_METHOD(lldb::SBQueue, SBProcess, GetQueueAtIndex, (size_t),
                      index);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-
   SBQueue sb_queue;
   QueueSP queue_sp;
   ProcessSP process_sp(GetSP());
   if (process_sp) {
     Process::StopLocker stop_locker;
     if (stop_locker.TryLock(&process_sp->GetRunLock())) {
       std::lock_guard<std::recursive_mutex> guard(
           process_sp->GetTarget().GetAPIMutex());
       queue_sp = process_sp->GetQueueList().GetQueueAtIndex(index);
       sb_queue.SetQueue(queue_sp);
     }
   }
 
-  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);
 }
 
 uint32_t SBProcess::GetStopID(bool include_expression_stops) {
   LLDB_RECORD_METHOD(uint32_t, SBProcess, GetStopID, (bool),
                      include_expression_stops);
 
   ProcessSP process_sp(GetSP());
   if (process_sp) {
     std::lock_guard<std::recursive_mutex> guard(
         process_sp->GetTarget().GetAPIMutex());
     if (include_expression_stops)
       return process_sp->GetStopID();
     else
       return process_sp->GetLastNaturalStopID();
   }
   return 0;
 }
 
 SBEvent SBProcess::GetStopEventForStopID(uint32_t stop_id) {
   LLDB_RECORD_METHOD(lldb::SBEvent, SBProcess, GetStopEventForStopID,
                      (uint32_t), stop_id);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-
   SBEvent sb_event;
   EventSP event_sp;
   ProcessSP process_sp(GetSP());
   if (process_sp) {
     std::lock_guard<std::recursive_mutex> guard(
         process_sp->GetTarget().GetAPIMutex());
     event_sp = process_sp->GetStopEventForStopID(stop_id);
     sb_event.reset(event_sp);
   }
 
-  if (log)
-    log->Printf("SBProcess(%p)::GetStopEventForStopID (stop_id=%" PRIu32
-                ") => SBEvent(%p)",
-                static_cast<void *>(process_sp.get()), stop_id,
-                static_cast<void *>(event_sp.get()));
-
   return 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());
   if (process_sp) {
     std::lock_guard<std::recursive_mutex> guard(
         process_sp->GetTarget().GetAPIMutex());
     ret_val = process_sp->GetState();
   }
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  if (log)
-    log->Printf("SBProcess(%p)::GetState () => %s",
-                static_cast<void *>(process_sp.get()),
-                lldb_private::StateAsCString(ret_val));
-
   return ret_val;
 }
 
 int SBProcess::GetExitStatus() {
   LLDB_RECORD_METHOD_NO_ARGS(int, SBProcess, GetExitStatus);
 
   int exit_status = 0;
   ProcessSP process_sp(GetSP());
   if (process_sp) {
     std::lock_guard<std::recursive_mutex> guard(
         process_sp->GetTarget().GetAPIMutex());
     exit_status = process_sp->GetExitStatus();
   }
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  if (log)
-    log->Printf("SBProcess(%p)::GetExitStatus () => %i (0x%8.8x)",
-                static_cast<void *>(process_sp.get()), exit_status,
-                exit_status);
 
   return exit_status;
 }
 
 const char *SBProcess::GetExitDescription() {
   LLDB_RECORD_METHOD_NO_ARGS(const char *, SBProcess, GetExitDescription);
 
   const char *exit_desc = NULL;
   ProcessSP process_sp(GetSP());
   if (process_sp) {
     std::lock_guard<std::recursive_mutex> guard(
         process_sp->GetTarget().GetAPIMutex());
     exit_desc = process_sp->GetExitDescription();
   }
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  if (log)
-    log->Printf("SBProcess(%p)::GetExitDescription () => %s",
-                static_cast<void *>(process_sp.get()), exit_desc);
   return exit_desc;
 }
 
 lldb::pid_t SBProcess::GetProcessID() {
   LLDB_RECORD_METHOD_NO_ARGS(lldb::pid_t, SBProcess, GetProcessID);
 
   lldb::pid_t ret_val = LLDB_INVALID_PROCESS_ID;
   ProcessSP process_sp(GetSP());
   if (process_sp)
     ret_val = process_sp->GetID();
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  if (log)
-    log->Printf("SBProcess(%p)::GetProcessID () => %" PRIu64,
-                static_cast<void *>(process_sp.get()), ret_val);
-
   return ret_val;
 }
 
 uint32_t SBProcess::GetUniqueID() {
   LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBProcess, GetUniqueID);
 
   uint32_t ret_val = 0;
   ProcessSP process_sp(GetSP());
   if (process_sp)
     ret_val = process_sp->GetUniqueID();
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  if (log)
-    log->Printf("SBProcess(%p)::GetUniqueID () => %" PRIu32,
-                static_cast<void *>(process_sp.get()), ret_val);
   return ret_val;
 }
 
 ByteOrder SBProcess::GetByteOrder() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::ByteOrder, SBProcess, GetByteOrder);
 
   ByteOrder byteOrder = eByteOrderInvalid;
   ProcessSP process_sp(GetSP());
   if (process_sp)
     byteOrder = process_sp->GetTarget().GetArchitecture().GetByteOrder();
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  if (log)
-    log->Printf("SBProcess(%p)::GetByteOrder () => %d",
-                static_cast<void *>(process_sp.get()), byteOrder);
 
   return byteOrder;
 }
 
 uint32_t SBProcess::GetAddressByteSize() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBProcess, GetAddressByteSize);
 
   uint32_t size = 0;
   ProcessSP process_sp(GetSP());
   if (process_sp)
     size = process_sp->GetTarget().GetArchitecture().GetAddressByteSize();
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  if (log)
-    log->Printf("SBProcess(%p)::GetAddressByteSize () => %d",
-                static_cast<void *>(process_sp.get()), size);
 
   return size;
 }
 
 SBError SBProcess::Continue() {
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBProcess, Continue);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-
   SBError sb_error;
   ProcessSP process_sp(GetSP());
 
-  if (log)
-    log->Printf("SBProcess(%p)::Continue ()...",
-                static_cast<void *>(process_sp.get()));
-
   if (process_sp) {
     std::lock_guard<std::recursive_mutex> guard(
         process_sp->GetTarget().GetAPIMutex());
 
     if (process_sp->GetTarget().GetDebugger().GetAsyncExecution())
       sb_error.ref() = process_sp->Resume();
     else
       sb_error.ref() = process_sp->ResumeSynchronous(NULL);
   } 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);
 }
 
 SBError SBProcess::Destroy() {
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBProcess, Destroy);
 
   SBError sb_error;
   ProcessSP process_sp(GetSP());
   if (process_sp) {
     std::lock_guard<std::recursive_mutex> guard(
         process_sp->GetTarget().GetAPIMutex());
     sb_error.SetError(process_sp->Destroy(false));
   } else
     sb_error.SetErrorString("SBProcess is invalid");
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  if (log) {
-    SBStream sstr;
-    sb_error.GetDescription(sstr);
-    log->Printf("SBProcess(%p)::Destroy () => SBError (%p): %s",
-                static_cast<void *>(process_sp.get()),
-                static_cast<void *>(sb_error.get()), sstr.GetData());
-  }
-
   return 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) {
     std::lock_guard<std::recursive_mutex> guard(
         process_sp->GetTarget().GetAPIMutex());
     sb_error.SetError(process_sp->Halt());
   } else
     sb_error.SetErrorString("SBProcess is invalid");
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  if (log) {
-    SBStream sstr;
-    sb_error.GetDescription(sstr);
-    log->Printf("SBProcess(%p)::Stop () => SBError (%p): %s",
-                static_cast<void *>(process_sp.get()),
-                static_cast<void *>(sb_error.get()), sstr.GetData());
-  }
-
   return 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) {
     std::lock_guard<std::recursive_mutex> guard(
         process_sp->GetTarget().GetAPIMutex());
     sb_error.SetError(process_sp->Destroy(true));
   } else
     sb_error.SetErrorString("SBProcess is invalid");
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  if (log) {
-    SBStream sstr;
-    sb_error.GetDescription(sstr);
-    log->Printf("SBProcess(%p)::Kill () => SBError (%p): %s",
-                static_cast<void *>(process_sp.get()),
-                static_cast<void *>(sb_error.get()), sstr.GetData());
-  }
-
   return 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;
SBError SBProcess::Signal(int signo) {
   SBError sb_error;
   ProcessSP process_sp(GetSP());
   if (process_sp) {
     std::lock_guard<std::recursive_mutex> guard(
         process_sp->GetTarget().GetAPIMutex());
     sb_error.SetError(process_sp->Signal(signo));
   } else
     sb_error.SetErrorString("SBProcess is invalid");
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  if (log) {
-    SBStream sstr;
-    sb_error.GetDescription(sstr);
-    log->Printf("SBProcess(%p)::Signal (signo=%i) => SBError (%p): %s",
-                static_cast<void *>(process_sp.get()), signo,
-                static_cast<void *>(sb_error.get()), sstr.GetData());
-  }
+
   return LLDB_RECORD_RESULT(sb_error);
 }
 
 SBUnixSignals SBProcess::GetUnixSignals() {
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBUnixSignals, SBProcess, GetUnixSignals);
 
   if (auto process_sp = GetSP())
     return LLDB_RECORD_RESULT(SBUnixSignals{process_sp});
if (process_sp) {
     Process::StopLocker stop_locker;
     const bool can_update = stop_locker.TryLock(&process_sp->GetRunLock());
     std::lock_guard<std::recursive_mutex> guard(
         process_sp->GetTarget().GetAPIMutex());
     thread_sp = process_sp->GetThreadList().FindThreadByID(tid, can_update);
     sb_thread.SetThread(thread_sp);
   }
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  if (log)
-    log->Printf("SBProcess(%p)::GetThreadByID (tid=0x%4.4" PRIx64
-                ") => SBThread (%p)",
-                static_cast<void *>(process_sp.get()), tid,
-                static_cast<void *>(thread_sp.get()));
-
   return 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());
   if (process_sp) {
     Process::StopLocker stop_locker;
     const bool can_update = stop_locker.TryLock(&process_sp->GetRunLock());
     std::lock_guard<std::recursive_mutex> guard(
         process_sp->GetTarget().GetAPIMutex());
     thread_sp =
         process_sp->GetThreadList().FindThreadByIndexID(index_id, can_update);
     sb_thread.SetThread(thread_sp);
   }
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  if (log)
-    log->Printf("SBProcess(%p)::GetThreadByID (tid=0x%x) => SBThread (%p)",
-                static_cast<void *>(process_sp.get()), index_id,
-                static_cast<void *>(thread_sp.get()));
-
   return LLDB_RECORD_RESULT(sb_thread);
 }
 
 StateType SBProcess::GetStateFromEvent(const SBEvent &event) {
   LLDB_RECORD_STATIC_METHOD(lldb::StateType, SBProcess, GetStateFromEvent,
                             (const lldb::SBEvent &), event);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-
   StateType ret_val = Process::ProcessEventData::GetStateFromEvent(event.get());
 
-  if (log)
-    log->Printf("SBProcess::GetStateFromEvent (event.sp=%p) => %s",
-                static_cast<void *>(event.get()),
-                lldb_private::StateAsCString(ret_val));
-
   return ret_val;
 }
 
 bool SBProcess::GetRestartedFromEvent(const SBEvent &event) {
   LLDB_RECORD_STATIC_METHOD(bool, SBProcess, GetRestartedFromEvent,
                             (const lldb::SBEvent &), event);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-
   bool ret_val = Process::ProcessEventData::GetRestartedFromEvent(event.get());
 
-  if (log)
-    log->Printf("SBProcess::%s (event.sp=%p) => %d", __FUNCTION__,
-                static_cast<void *>(event.get()), ret_val);
-
   return ret_val;
 }
 
 size_t SBProcess::GetNumRestartedReasonsFromEvent(const lldb::SBEvent &event) {
   LLDB_RECORD_STATIC_METHOD(size_t, SBProcess, GetNumRestartedReasonsFromEvent,
                             (const lldb::SBEvent &), event);
 
   return Process::ProcessEventData::GetNumRestartedReasons(event.get());
bool SBProcess::EventIsStructuredDataEvent(const lldb::SBEvent &event) {
   return event_data && (event_data->GetFlavor() ==
                         EventDataStructuredData::GetFlavorString());
 }
 
 SBBroadcaster SBProcess::GetBroadcaster() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBBroadcaster, SBProcess,
                                    GetBroadcaster);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   ProcessSP process_sp(GetSP());
 
   SBBroadcaster broadcaster(process_sp.get(), false);
 
-  if (log)
-    log->Printf("SBProcess(%p)::GetBroadcaster () => SBBroadcaster (%p)",
-                static_cast<void *>(process_sp.get()),
-                static_cast<void *>(broadcaster.get()));
 
   return 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));
 
   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;
     if (stop_locker.TryLock(&process_sp->GetRunLock())) {
       std::lock_guard<std::recursive_mutex> guard(
           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) {
   size_t bytes_read = 0;
   ProcessSP process_sp(GetSP());
   if (process_sp) {
     Process::StopLocker stop_locker;
     if (stop_locker.TryLock(&process_sp->GetRunLock())) {
       std::lock_guard<std::recursive_mutex> guard(
           process_sp->GetTarget().GetAPIMutex());
       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 {
     sb_error.SetErrorString("SBProcess is invalid");
   }
   return bytes_read;
 }
 
 uint64_t SBProcess::ReadUnsignedFromMemory(addr_t addr, uint32_t byte_size,
                                            lldb::SBError &sb_error) {
   LLDB_RECORD_METHOD(uint64_t, SBProcess, ReadUnsignedFromMemory,
                      (lldb::addr_t, uint32_t, lldb::SBError &), addr, byte_size,
                      sb_error);
 
   uint64_t value = 0;
   ProcessSP process_sp(GetSP());
   if (process_sp) {
     Process::StopLocker stop_locker;
     if (stop_locker.TryLock(&process_sp->GetRunLock())) {
       std::lock_guard<std::recursive_mutex> guard(
           process_sp->GetTarget().GetAPIMutex());
       value = process_sp->ReadUnsignedIntegerFromMemory(addr, byte_size, 0,
                                                         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 {
     sb_error.SetErrorString("SBProcess is invalid");
   }
   return value;
 }
 
 lldb::addr_t SBProcess::ReadPointerFromMemory(addr_t addr,
                                               lldb::SBError &sb_error) {
   LLDB_RECORD_METHOD(lldb::addr_t, SBProcess, ReadPointerFromMemory,
                      (lldb::addr_t, lldb::SBError &), addr, sb_error);
 
   lldb::addr_t ptr = LLDB_INVALID_ADDRESS;
   ProcessSP process_sp(GetSP());
   if (process_sp) {
     Process::StopLocker stop_locker;
     if (stop_locker.TryLock(&process_sp->GetRunLock())) {
       std::lock_guard<std::recursive_mutex> guard(
           process_sp->GetTarget().GetAPIMutex());
       ptr = process_sp->ReadPointerFromMemory(addr, sb_error.ref());
     } 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 {
     sb_error.SetErrorString("SBProcess is invalid");
   }
   return ptr;
 }
 
 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())) {
       std::lock_guard<std::recursive_mutex> guard(
           process_sp->GetTarget().GetAPIMutex());
       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();

 }
 
 uint32_t
 SBProcess::GetNumSupportedHardwareWatchpoints(lldb::SBError &sb_error) const {
   LLDB_RECORD_METHOD_CONST(uint32_t, SBProcess,
                            GetNumSupportedHardwareWatchpoints,
                            (lldb::SBError &), sb_error);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-
   uint32_t num = 0;
   ProcessSP process_sp(GetSP());
   if (process_sp) {
     std::lock_guard<std::recursive_mutex> guard(
         process_sp->GetTarget().GetAPIMutex());
     sb_error.SetError(process_sp->GetWatchpointSupportInfo(num));
-    if (log)
-      log->Printf("SBProcess(%p)::GetNumSupportedHardwareWatchpoints () => %u",
-                  static_cast<void *>(process_sp.get()), num);
   } else {
     sb_error.SetErrorString("SBProcess is invalid");
   }
   return num;
 }
 
 uint32_t SBProcess::LoadImage(lldb::SBFileSpec &sb_remote_image_spec,
                               lldb::SBError &sb_error) {
   LLDB_RECORD_METHOD(uint32_t, SBProcess, LoadImage,
                      (lldb::SBFileSpec &, lldb::SBError &),
                      sb_remote_image_spec, sb_error);
 
   return LoadImage(SBFileSpec(), sb_remote_image_spec, sb_error);
 }
 
 uint32_t SBProcess::LoadImage(const lldb::SBFileSpec &sb_local_image_spec,
                               const lldb::SBFileSpec &sb_remote_image_spec,
                               lldb::SBError &sb_error) {
   LLDB_RECORD_METHOD(
       uint32_t, SBProcess, LoadImage,
       (const lldb::SBFileSpec &, const lldb::SBFileSpec &, lldb::SBError &),
       sb_local_image_spec, sb_remote_image_spec, sb_error);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   ProcessSP process_sp(GetSP());
   if (process_sp) {
     Process::StopLocker stop_locker;
     if (stop_locker.TryLock(&process_sp->GetRunLock())) {
-      if (log)
-        log->Printf("SBProcess(%p)::LoadImage() => calling Platform::LoadImage"
-                    "for: %s",
-                    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;
 }
 
 uint32_t SBProcess::LoadImageUsingPaths(const lldb::SBFileSpec &image_spec,
                                         SBStringList &paths,
                                         lldb::SBFileSpec &loaded_path,
                                         lldb::SBError &error) {
   LLDB_RECORD_METHOD(uint32_t, SBProcess, LoadImageUsingPaths,
                      (const lldb::SBFileSpec &, lldb::SBStringList &,
                       lldb::SBFileSpec &, lldb::SBError &),
                      image_spec, paths, loaded_path, error);
 
-  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();
       size_t num_paths = paths.GetSize();
       std::vector<std::string> paths_vec;
       paths_vec.reserve(num_paths);
       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);
     } 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) {
     Process::StopLocker stop_locker;
     if (stop_locker.TryLock(&process_sp->GetRunLock())) {
       std::lock_guard<std::recursive_mutex> guard(
           process_sp->GetTarget().GetAPIMutex());
       PlatformSP platform_sp = process_sp->GetTarget().GetPlatform();
       sb_error.SetError(
           platform_sp->UnloadImage(process_sp.get(), image_token));
     } else {
-      Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-      if (log)
-        log->Printf("SBProcess(%p)::UnloadImage() => error: process is running",
-                    static_cast<void *>(process_sp.get()));
       sb_error.SetErrorString("process is running");
     }
   } else
     sb_error.SetErrorString("invalid process");
   return 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) {
     Process::StopLocker stop_locker;
     if (stop_locker.TryLock(&process_sp->GetRunLock())) {
       std::lock_guard<std::recursive_mutex> guard(
           process_sp->GetTarget().GetAPIMutex());
       sb_error.SetError(process_sp->SendEventData(event_data));
     } else {
-      Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-      if (log)
-        log->Printf(
-            "SBProcess(%p)::SendEventData() => error: process is running",
-            static_cast<void *>(process_sp.get()));
       sb_error.SetErrorString("process is running");
     }
   } else
     sb_error.SetErrorString("invalid process");
   return LLDB_RECORD_RESULT(sb_error);
 }
 
 uint32_t SBProcess::GetNumExtendedBacktraceTypes() {
const char *SBProcess::GetExtendedBacktraceTypeAtIndex(uint32_t idx) {
 
   ProcessSP process_sp(GetSP());
   if (process_sp && process_sp->GetSystemRuntime()) {
     SystemRuntime *runtime = process_sp->GetSystemRuntime();
     const std::vector<ConstString> &names =
         runtime->GetExtendedBacktraceTypes();
     if (idx < names.size()) {
       return names[idx].AsCString();
-    } else {
-      Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-      if (log)
-        log->Printf("SBProcess(%p)::GetExtendedBacktraceTypeAtIndex() => "
-                    "error: requested extended backtrace name out of bounds",
-                    static_cast<void *>(process_sp.get()));
     }
   }
   return NULL;
 }
 
 SBThreadCollection SBProcess::GetHistoryThreads(addr_t addr) {
   LLDB_RECORD_METHOD(lldb::SBThreadCollection, SBProcess, GetHistoryThreads,
                      (lldb::addr_t), addr);
if (process_sp) {
     Process::StopLocker stop_locker;
     if (stop_locker.TryLock(&process_sp->GetRunLock())) {
       std::lock_guard<std::recursive_mutex> guard(
           process_sp->GetTarget().GetAPIMutex());
 
       sb_error.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 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());
   Process::StopLocker stop_locker;
   if (process_sp && stop_locker.TryLock(&process_sp->GetRunLock())) {
     std::lock_guard<std::recursive_mutex> guard(
         process_sp->GetTarget().GetAPIMutex());
 
     process_sp->GetMemoryRegions(sb_region_list.ref());
-  } else {
-    Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-    if (log)
-      log->Printf(
-          "SBProcess(%p)::GetMemoryRegionInfo() => error: process is running",
-          static_cast<void *>(process_sp.get()));
   }
 
   return 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 LLDB_RECORD_RESULT(sb_proc_info);
 }

source/API/SBQueue.cpp

 #include "lldb/API/SBProcess.h"
 #include "lldb/API/SBQueueItem.h"
 #include "lldb/API/SBThread.h"
 
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Queue.h"
 #include "lldb/Target/QueueItem.h"
 #include "lldb/Target/Thread.h"
-#include "lldb/Utility/Log.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 namespace lldb_private {
 
 class QueueImpl {
 public:
public:
   }
 
   lldb::queue_id_t GetQueueID() const {
     lldb::queue_id_t result = LLDB_INVALID_QUEUE_ID;
     lldb::QueueSP queue_sp = m_queue_wp.lock();
     if (queue_sp) {
       result = queue_sp->GetID();
     }
-    Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-    if (log)
-      log->Printf("SBQueue(%p)::GetQueueID () => 0x%" PRIx64,
-                  static_cast<const void *>(this), result);
     return result;
   }
 
   uint32_t GetIndexID() const {
     uint32_t result = LLDB_INVALID_INDEX32;
     lldb::QueueSP queue_sp = m_queue_wp.lock();
     if (queue_sp) {
       result = queue_sp->GetIndexID();
     }
-    Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-    if (log)
-      log->Printf("SBQueueImpl(%p)::GetIndexID () => %d",
-                  static_cast<const void *>(this), result);
     return result;
   }
 
   const char *GetName() const {
     const char *name = NULL;
     lldb::QueueSP queue_sp = m_queue_wp.lock();
     if (queue_sp.get()) {
       name = queue_sp->GetName();
     }
-
-    Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-    if (log)
-      log->Printf("SBQueueImpl(%p)::GetName () => %s",
-                  static_cast<const void *>(this), name ? name : "NULL");
-
     return name;
   }
 
   void FetchThreads() {
     if (!m_thread_list_fetched) {
       lldb::QueueSP queue_sp = m_queue_wp.lock();
       if (queue_sp) {
         Process::StopLocker stop_locker;
const lldb::SBQueue &SBQueue::operator=(const lldb::SBQueue &rhs) {
   return *this;
 }
 
 SBQueue::~SBQueue() {}
 
 bool SBQueue::IsValid() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBQueue, IsValid);
 
-  bool is_valid = m_opaque_sp->IsValid();
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  if (log)
-    log->Printf("SBQueue(0x%" PRIx64 ")::IsValid() == %s",
-                m_opaque_sp->GetQueueID(), is_valid ? "true" : "false");
-  return is_valid;
+  return m_opaque_sp->IsValid();
 }
 
 void SBQueue::Clear() {
   LLDB_RECORD_METHOD_NO_ARGS(void, SBQueue, Clear);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  if (log)
-    log->Printf("SBQueue(0x%" PRIx64 ")::Clear()", m_opaque_sp->GetQueueID());
   m_opaque_sp->Clear();
 }
 
 void SBQueue::SetQueue(const QueueSP &queue_sp) {
   m_opaque_sp->SetQueue(queue_sp);
 }
 
 lldb::queue_id_t SBQueue::GetQueueID() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::queue_id_t, SBQueue, GetQueueID);
 
-  lldb::queue_id_t qid = m_opaque_sp->GetQueueID();
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  if (log)
-    log->Printf("SBQueue(0x%" PRIx64 ")::GetQueueID() == 0x%" PRIx64,
-                m_opaque_sp->GetQueueID(), (uint64_t)qid);
-  return qid;
+  return m_opaque_sp->GetQueueID();
 }
 
 uint32_t SBQueue::GetIndexID() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBQueue, GetIndexID);
 
   uint32_t index_id = m_opaque_sp->GetIndexID();
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  if (log)
-    log->Printf("SBQueue(0x%" PRIx64 ")::GetIndexID() == 0x%" PRIx32,
-                m_opaque_sp->GetQueueID(), index_id);
   return index_id;
 }
 
 const char *SBQueue::GetName() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBQueue, GetName);
 
-  const char *name = m_opaque_sp->GetName();
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  if (log)
-    log->Printf("SBQueue(0x%" PRIx64 ")::GetName() == %s",
-                m_opaque_sp->GetQueueID(), name ? name : "");
-  return name;
+  return m_opaque_sp->GetName();
 }
 
 uint32_t SBQueue::GetNumThreads() {
   LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBQueue, GetNumThreads);
 
-  uint32_t numthreads = m_opaque_sp->GetNumThreads();
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  if (log)
-    log->Printf("SBQueue(0x%" PRIx64 ")::GetNumThreads() == %d",
-                m_opaque_sp->GetQueueID(), numthreads);
-  return numthreads;
+  return m_opaque_sp->GetNumThreads();
 }
 
 SBThread SBQueue::GetThreadAtIndex(uint32_t idx) {
   LLDB_RECORD_METHOD(lldb::SBThread, SBQueue, GetThreadAtIndex, (uint32_t),
                      idx);
 
   SBThread th = m_opaque_sp->GetThreadAtIndex(idx);
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  if (log)
-    log->Printf("SBQueue(0x%" PRIx64 ")::GetThreadAtIndex(%d)",
-                m_opaque_sp->GetQueueID(), idx);
   return LLDB_RECORD_RESULT(th);
 }
 
 uint32_t SBQueue::GetNumPendingItems() {
   LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBQueue, GetNumPendingItems);
 
-  uint32_t pending_items = m_opaque_sp->GetNumPendingItems();
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  if (log)
-    log->Printf("SBQueue(0x%" PRIx64 ")::GetNumPendingItems() == %d",
-                m_opaque_sp->GetQueueID(), pending_items);
-  return pending_items;
+  return m_opaque_sp->GetNumPendingItems();
 }
 
 SBQueueItem SBQueue::GetPendingItemAtIndex(uint32_t idx) {
   LLDB_RECORD_METHOD(lldb::SBQueueItem, SBQueue, GetPendingItemAtIndex,
                      (uint32_t), idx);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  if (log)
-    log->Printf("SBQueue(0x%" PRIx64 ")::GetPendingItemAtIndex(%d)",
-                m_opaque_sp->GetQueueID(), idx);
   return LLDB_RECORD_RESULT(m_opaque_sp->GetPendingItemAtIndex(idx));
 }
 
 uint32_t SBQueue::GetNumRunningItems() {
   LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBQueue, GetNumRunningItems);
 
-  uint32_t running_items = m_opaque_sp->GetNumRunningItems();
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  if (log)
-    log->Printf("SBQueue(0x%" PRIx64 ")::GetNumRunningItems() == %d",
-                m_opaque_sp->GetQueueID(), running_items);
-  return running_items;
+  return m_opaque_sp->GetNumRunningItems();
 }
 
 SBProcess SBQueue::GetProcess() {
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBProcess, SBQueue, GetProcess);
 
   return LLDB_RECORD_RESULT(m_opaque_sp->GetProcess());
 }
 
 lldb::QueueKind SBQueue::GetKind() {
   LLDB_RECORD_METHOD_NO_ARGS(lldb::QueueKind, SBQueue, GetKind);
 
   return m_opaque_sp->GetKind();
 }

source/API/SBQueueItem.cpp

 #include "SBReproducerPrivate.h"
 #include "lldb/API/SBAddress.h"
 #include "lldb/API/SBQueueItem.h"
 #include "lldb/API/SBThread.h"
 #include "lldb/Core/Address.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/QueueItem.h"
 #include "lldb/Target/Thread.h"
-#include "lldb/Utility/Log.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 //----------------------------------------------------------------------
 // Constructors
 //----------------------------------------------------------------------
 SBQueueItem::SBQueueItem() : m_queue_item_sp() {

 //----------------------------------------------------------------------
 // Destructor
 //----------------------------------------------------------------------
 SBQueueItem::~SBQueueItem() { m_queue_item_sp.reset(); }
 
 bool SBQueueItem::IsValid() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBQueueItem, IsValid);
 
-  bool is_valid = m_queue_item_sp.get() != NULL;
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  if (log)
-    log->Printf("SBQueueItem(%p)::IsValid() == %s",
-                static_cast<void *>(m_queue_item_sp.get()),
-                is_valid ? "true" : "false");
-  return is_valid;
+  return m_queue_item_sp.get() != NULL;
 }
 
 void SBQueueItem::Clear() {
   LLDB_RECORD_METHOD_NO_ARGS(void, SBQueueItem, Clear);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  if (log)
-    log->Printf("SBQueueItem(%p)::Clear()",
-                static_cast<void *>(m_queue_item_sp.get()));
   m_queue_item_sp.reset();
 }
 
 void SBQueueItem::SetQueueItem(const QueueItemSP &queue_item_sp) {
   LLDB_RECORD_METHOD(void, SBQueueItem, SetQueueItem,
                      (const lldb::QueueItemSP &), queue_item_sp);
 
   m_queue_item_sp = queue_item_sp;
 }
 
 lldb::QueueItemKind SBQueueItem::GetKind() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::QueueItemKind, SBQueueItem, GetKind);
 
   QueueItemKind result = eQueueItemKindUnknown;
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   if (m_queue_item_sp) {
     result = m_queue_item_sp->GetKind();
   }
-  if (log)
-    log->Printf("SBQueueItem(%p)::GetKind() == %d",
-                static_cast<void *>(m_queue_item_sp.get()),
-                static_cast<int>(result));
   return result;
 }
 
 void SBQueueItem::SetKind(lldb::QueueItemKind kind) {
   LLDB_RECORD_METHOD(void, SBQueueItem, SetKind, (lldb::QueueItemKind), kind);
 
   if (m_queue_item_sp) {
     m_queue_item_sp->SetKind(kind);
   }
 }
 
 SBAddress SBQueueItem::GetAddress() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBAddress, SBQueueItem, GetAddress);
 
   SBAddress result;
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   if (m_queue_item_sp) {
     result.SetAddress(&m_queue_item_sp->GetAddress());
   }
-  if (log) {
-    StreamString sstr;
-    const Address *addr = result.get();
-    if (addr)
-      addr->Dump(&sstr, NULL, Address::DumpStyleModuleWithFileAddress,
-                 Address::DumpStyleInvalid, 4);
-    log->Printf("SBQueueItem(%p)::GetAddress() == SBAddress(%p): %s",
-                static_cast<void *>(m_queue_item_sp.get()),
-                static_cast<void *>(result.get()), sstr.GetData());
-  }
   return LLDB_RECORD_RESULT(result);
 }
 
 void SBQueueItem::SetAddress(SBAddress addr) {
   LLDB_RECORD_METHOD(void, SBQueueItem, SetAddress, (lldb::SBAddress), addr);
 
   if (m_queue_item_sp) {
     m_queue_item_sp->SetAddress(addr.ref());
   }
 }
 
 SBThread SBQueueItem::GetExtendedBacktraceThread(const char *type) {
   LLDB_RECORD_METHOD(lldb::SBThread, SBQueueItem, GetExtendedBacktraceThread,
                      (const char *), type);
 
   SBThread result;
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   if (m_queue_item_sp) {
     ProcessSP process_sp = m_queue_item_sp->GetProcessSP();
     Process::StopLocker stop_locker;
     if (process_sp && stop_locker.TryLock(&process_sp->GetRunLock())) {
       ThreadSP thread_sp;
       ConstString type_const(type);
       thread_sp = m_queue_item_sp->GetExtendedBacktraceThread(type_const);
       if (thread_sp) {
         // Save this in the Process' ExtendedThreadList so a strong pointer
         // retains the object
         process_sp->GetExtendedThreadList().AddThread(thread_sp);
         result.SetThread(thread_sp);
-        if (log) {
-          const char *queue_name = thread_sp->GetQueueName();
-          if (queue_name == NULL)
-            queue_name = "";
-          log->Printf(
-              "SBQueueItem(%p)::GetExtendedBacktraceThread() = new extended "
-              "Thread created (%p) with queue_id 0x%" PRIx64 " queue name '%s'",
-              static_cast<void *>(m_queue_item_sp.get()),
-              static_cast<void *>(thread_sp.get()),
-              static_cast<uint64_t>(thread_sp->GetQueueID()), queue_name);
-        }
       }
     }
   }
   return LLDB_RECORD_RESULT(result);
 }

source/API/SBSection.cpp

 #include "SBReproducerPrivate.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/API/SBTarget.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/Section.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Utility/DataBuffer.h"
 #include "lldb/Utility/DataExtractor.h"
-#include "lldb/Utility/Log.h"
 #include "lldb/Utility/StreamString.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 SBSection::SBSection() : m_opaque_wp() {
   LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBSection);
 }

source/API/SBSymbol.cpp

 //===-- SBSymbol.cpp --------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBSymbol.h"
 #include "SBReproducerPrivate.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/Core/Disassembler.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Symbol/Symbol.h"
 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Target/Target.h"
-#include "lldb/Utility/Log.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 SBSymbol::SBSymbol() : m_opaque_ptr(NULL) {
   LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBSymbol);
 }
 

 
 const char *SBSymbol::GetName() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBSymbol, GetName);
 
   const char *name = NULL;
   if (m_opaque_ptr)
     name = m_opaque_ptr->GetName().AsCString();
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  if (log)
-    log->Printf("SBSymbol(%p)::GetName () => \"%s\"",
-                static_cast<void *>(m_opaque_ptr), name ? name : "");
   return name;
 }
 
 const char *SBSymbol::GetDisplayName() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBSymbol, GetDisplayName);
 
   const char *name = NULL;
   if (m_opaque_ptr)
     name = m_opaque_ptr->GetMangled()
                .GetDisplayDemangledName(m_opaque_ptr->GetLanguage())
                .AsCString();
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  if (log)
-    log->Printf("SBSymbol(%p)::GetDisplayName () => \"%s\"",
-                static_cast<void *>(m_opaque_ptr), name ? name : "");
   return name;
 }
 
 const char *SBSymbol::GetMangledName() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBSymbol, GetMangledName);
 
   const char *name = NULL;
   if (m_opaque_ptr)
     name = m_opaque_ptr->GetMangled().GetMangledName().AsCString();
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  if (log)
-    log->Printf("SBSymbol(%p)::GetMangledName () => \"%s\"",
-                static_cast<void *>(m_opaque_ptr), name ? name : "");
-
   return name;
 }
 
 bool SBSymbol::operator==(const SBSymbol &rhs) const {
   LLDB_RECORD_METHOD_CONST(bool, SBSymbol, operator==,(const lldb::SBSymbol &),
                            rhs);
 
   return m_opaque_ptr == rhs.m_opaque_ptr;

source/API/SBSymbolContext.cpp

 //===-- SBSymbolContext.cpp -------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBSymbolContext.h"
 #include "SBReproducerPrivate.h"
 #include "Utils.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Symbol/Function.h"
 #include "lldb/Symbol/Symbol.h"
 #include "lldb/Symbol/SymbolContext.h"
-#include "lldb/Utility/Log.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 SBSymbolContext::SBSymbolContext() : m_opaque_up() {
   LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBSymbolContext);
 }
 
bool SBSymbolContext::IsValid() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBSymbolContext, IsValid);
 
   return m_opaque_up != NULL;
 }
 
 SBModule SBSymbolContext::GetModule() {
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBModule, SBSymbolContext, GetModule);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-
   SBModule sb_module;
   ModuleSP module_sp;
   if (m_opaque_up) {
     module_sp = m_opaque_up->module_sp;
     sb_module.SetSP(module_sp);
   }
 
-  if (log) {
-    SBStream sstr;
-    sb_module.GetDescription(sstr);
-    log->Printf("SBSymbolContext(%p)::GetModule () => SBModule(%p): %s",
-                static_cast<void *>(m_opaque_up.get()),
-                static_cast<void *>(module_sp.get()), sstr.GetData());
-  }
-
   return LLDB_RECORD_RESULT(sb_module);
 }
 
 SBCompileUnit SBSymbolContext::GetCompileUnit() {
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBCompileUnit, SBSymbolContext,
                              GetCompileUnit);
 
   return LLDB_RECORD_RESULT(
       SBCompileUnit(m_opaque_up ? m_opaque_up->comp_unit : NULL));
 }
 
 SBFunction SBSymbolContext::GetFunction() {
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBFunction, SBSymbolContext, GetFunction);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-
   Function *function = NULL;
 
   if (m_opaque_up)
     function = m_opaque_up->function;
 
   SBFunction sb_function(function);
 
-  if (log)
-    log->Printf("SBSymbolContext(%p)::GetFunction () => SBFunction(%p)",
-                static_cast<void *>(m_opaque_up.get()),
-                static_cast<void *>(function));
-
   return LLDB_RECORD_RESULT(sb_function);
 }
 
 SBBlock SBSymbolContext::GetBlock() {
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBBlock, SBSymbolContext, GetBlock);
 
   return LLDB_RECORD_RESULT(SBBlock(m_opaque_up ? m_opaque_up->block : NULL));
 }
 
 SBLineEntry SBSymbolContext::GetLineEntry() {
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBLineEntry, SBSymbolContext, GetLineEntry);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-
   SBLineEntry sb_line_entry;
   if (m_opaque_up)
     sb_line_entry.SetLineEntry(m_opaque_up->line_entry);
 
-  if (log) {
-    log->Printf("SBSymbolContext(%p)::GetLineEntry () => SBLineEntry(%p)",
-                static_cast<void *>(m_opaque_up.get()),
-                static_cast<void *>(sb_line_entry.get()));
-  }
-
   return LLDB_RECORD_RESULT(sb_line_entry);
 }
 
 SBSymbol SBSymbolContext::GetSymbol() {
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBSymbol, SBSymbolContext, GetSymbol);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-
   Symbol *symbol = NULL;
 
   if (m_opaque_up)
     symbol = m_opaque_up->symbol;
 
   SBSymbol sb_symbol(symbol);
 
-  if (log)
-    log->Printf("SBSymbolContext(%p)::GetSymbol () => SBSymbol(%p)",
-                static_cast<void *>(m_opaque_up.get()),
-                static_cast<void *>(symbol));
-
   return LLDB_RECORD_RESULT(sb_symbol);
 }
 
 void SBSymbolContext::SetModule(lldb::SBModule module) {
   LLDB_RECORD_METHOD(void, SBSymbolContext, SetModule, (lldb::SBModule),
                      module);
 
   ref().module_sp = module.GetSP();

source/API/SBTarget.cpp

 #include "lldb/Target/ObjCLanguageRuntime.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/StackFrame.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/TargetList.h"
 #include "lldb/Utility/ArchSpec.h"
 #include "lldb/Utility/Args.h"
 #include "lldb/Utility/FileSpec.h"
-#include "lldb/Utility/Log.h"
 #include "lldb/Utility/ProcessInfo.h"
 #include "lldb/Utility/RegularExpression.h"
 
 #include "Commands/CommandObjectBreakpoint.h"
 #include "lldb/Interpreter/CommandReturnObject.h"
 #include "llvm/Support/PrettyStackTrace.h"
 #include "llvm/Support/Regex.h"
 
SBProcess SBTarget::GetProcess() {
   SBProcess sb_process;
   ProcessSP process_sp;
   TargetSP target_sp(GetSP());
   if (target_sp) {
     process_sp = target_sp->GetProcessSP();
     sb_process.SetSP(process_sp);
   }
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  if (log)
-    log->Printf("SBTarget(%p)::GetProcess () => SBProcess(%p)",
-                static_cast<void *>(target_sp.get()),
-                static_cast<void *>(process_sp.get()));
-
   return LLDB_RECORD_RESULT(sb_process);
 }
 
 SBPlatform SBTarget::GetPlatform() {
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBPlatform, SBTarget, GetPlatform);
 
   TargetSP target_sp(GetSP());
   if (!target_sp)
SBProcess SBTarget::Launch(SBListener &listener, char const **argv,
                            bool stop_at_entry, lldb::SBError &error) {
   LLDB_RECORD_METHOD(lldb::SBProcess, SBTarget, Launch,
                      (lldb::SBListener &, const char **, const char **,
                       const char *, const char *, const char *, const char *,
                       uint32_t, bool, lldb::SBError &),
                      listener, argv, envp, stdin_path, stdout_path, stderr_path,
                      working_directory, launch_flags, stop_at_entry, error);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-
   SBProcess sb_process;
   ProcessSP process_sp;
   TargetSP target_sp(GetSP());
 
-  if (log)
-    log->Printf("SBTarget(%p)::Launch (argv=%p, envp=%p, stdin=%s, stdout=%s, "
-                "stderr=%s, working-dir=%s, launch_flags=0x%x, "
-                "stop_at_entry=%i, &error (%p))...",
-                static_cast<void *>(target_sp.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()));
-
   if (target_sp) {
     std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
 
     if (stop_at_entry)
       launch_flags |= eLaunchFlagStopAtEntry;
 
     if (getenv("LLDB_LAUNCH_FLAG_DISABLE_ASLR"))
       launch_flags |= eLaunchFlagDisableASLR;
if (target_sp) {
 
     error.SetError(target_sp->Launch(launch_info, NULL));
 
     sb_process.SetSP(target_sp->GetProcessSP());
   } else {
     error.SetErrorString("SBTarget is invalid");
   }
 
-  log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API);
-  if (log)
-    log->Printf("SBTarget(%p)::Launch (...) => SBProcess(%p), SBError(%s)",
-                static_cast<void *>(target_sp.get()),
-                static_cast<void *>(sb_process.GetSP().get()),
-                error.GetCString());
-
   return LLDB_RECORD_RESULT(sb_process);
 }
 
 SBProcess SBTarget::Launch(SBLaunchInfo &sb_launch_info, SBError &error) {
   LLDB_RECORD_METHOD(lldb::SBProcess, SBTarget, Launch,
                      (lldb::SBLaunchInfo &, lldb::SBError &), sb_launch_info,
                      error);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   SBProcess sb_process;
   TargetSP target_sp(GetSP());
 
-  if (log)
-    log->Printf("SBTarget(%p)::Launch (launch_info, error)...",
-                static_cast<void *>(target_sp.get()));
-
   if (target_sp) {
     std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
     StateType state = eStateInvalid;
     {
       ProcessSP process_sp = target_sp->GetProcessSP();
       if (process_sp) {
         state = process_sp->GetState();
 
if (target_sp) {
 
     error.SetError(target_sp->Launch(launch_info, NULL));
     sb_launch_info.set_ref(launch_info);
     sb_process.SetSP(target_sp->GetProcessSP());
   } else {
     error.SetErrorString("SBTarget is invalid");
   }
 
-  log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API);
-  if (log)
-    log->Printf("SBTarget(%p)::Launch (...) => SBProcess(%p)",
-                static_cast<void *>(target_sp.get()),
-                static_cast<void *>(sb_process.GetSP().get()));
-
   return LLDB_RECORD_RESULT(sb_process);
 }
 
 lldb::SBProcess SBTarget::Attach(SBAttachInfo &sb_attach_info, SBError &error) {
   LLDB_RECORD_METHOD(lldb::SBProcess, SBTarget, Attach,
                      (lldb::SBAttachInfo &, lldb::SBError &), sb_attach_info,
                      error);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-
   SBProcess sb_process;
   TargetSP target_sp(GetSP());
 
-  if (log)
-    log->Printf("SBTarget(%p)::Attach (sb_attach_info, error)...",
-                static_cast<void *>(target_sp.get()));
-
   if (target_sp) {
     ProcessAttachInfo &attach_info = sb_attach_info.ref();
     if (attach_info.ProcessIDIsValid() && !attach_info.UserIDIsValid()) {
       PlatformSP platform_sp = target_sp->GetPlatform();
       // See if we can pre-verify if a process exists or not
       if (platform_sp && platform_sp->IsConnected()) {
         lldb::pid_t attach_pid = attach_info.GetProcessID();
         ProcessInstanceInfo instance_info;
         if (platform_sp->GetProcessInfo(attach_pid, instance_info)) {
           attach_info.SetUserID(instance_info.GetEffectiveUserID());
         } else {
           error.ref().SetErrorStringWithFormat(
               "no process found with process ID %" PRIu64, attach_pid);
-          if (log) {
-            log->Printf("SBTarget(%p)::Attach (...) => error %s",
-                        static_cast<void *>(target_sp.get()),
-                        error.GetCString());
-          }
           return LLDB_RECORD_RESULT(sb_process);
         }
       }
     }
     error.SetError(AttachToProcess(attach_info, *target_sp));
     if (error.Success())
       sb_process.SetSP(target_sp->GetProcessSP());
   } else {
     error.SetErrorString("SBTarget is invalid");
   }
 
-  if (log)
-    log->Printf("SBTarget(%p)::Attach (...) => SBProcess(%p)",
-                static_cast<void *>(target_sp.get()),
-                static_cast<void *>(sb_process.GetSP().get()));
-
   return LLDB_RECORD_RESULT(sb_process);
 }
 
 lldb::SBProcess SBTarget::AttachToProcessWithID(
     SBListener &listener,
     lldb::pid_t pid, // The process ID to attach to
     SBError &error   // An error explaining what went wrong if attach fails
 ) {
   LLDB_RECORD_METHOD(lldb::SBProcess, SBTarget, AttachToProcessWithID,
                      (lldb::SBListener &, lldb::pid_t, lldb::SBError &),
                      listener, pid, error);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-
   SBProcess sb_process;
   TargetSP target_sp(GetSP());
 
-  if (log)
-    log->Printf("SBTarget(%p)::%s (listener, pid=%" PRId64 ", error)...",
-                static_cast<void *>(target_sp.get()), __FUNCTION__, pid);
-
   if (target_sp) {
     ProcessAttachInfo attach_info;
     attach_info.SetProcessID(pid);
     if (listener.IsValid())
       attach_info.SetListener(listener.GetSP());
 
     ProcessInstanceInfo instance_info;
     if (target_sp->GetPlatform()->GetProcessInfo(pid, instance_info))
       attach_info.SetUserID(instance_info.GetEffectiveUserID());
 
     error.SetError(AttachToProcess(attach_info, *target_sp));
     if (error.Success())
       sb_process.SetSP(target_sp->GetProcessSP());
   } else
     error.SetErrorString("SBTarget is invalid");
 
-  if (log)
-    log->Printf("SBTarget(%p)::%s (...) => SBProcess(%p)",
-                static_cast<void *>(target_sp.get()), __FUNCTION__,
-                static_cast<void *>(sb_process.GetSP().get()));
   return LLDB_RECORD_RESULT(sb_process);
 }
 
 lldb::SBProcess SBTarget::AttachToProcessWithName(
     SBListener &listener,
     const char *name, // basename of process to attach to
     bool wait_for, // if true wait for a new instance of "name" to be launched
     SBError &error // An error explaining what went wrong if attach fails
 ) {
   LLDB_RECORD_METHOD(lldb::SBProcess, SBTarget, AttachToProcessWithName,
                      (lldb::SBListener &, const char *, bool, lldb::SBError &),
                      listener, name, wait_for, error);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-
   SBProcess sb_process;
   TargetSP target_sp(GetSP());
 
-  if (log)
-    log->Printf("SBTarget(%p)::%s (listener, name=%s, wait_for=%s, error)...",
-                static_cast<void *>(target_sp.get()), __FUNCTION__, name,
-                wait_for ? "true" : "false");
-
   if (name && target_sp) {
     ProcessAttachInfo attach_info;
     attach_info.GetExecutableFile().SetFile(name, FileSpec::Style::native);
     attach_info.SetWaitForLaunch(wait_for);
     if (listener.IsValid())
       attach_info.SetListener(listener.GetSP());
 
     error.SetError(AttachToProcess(attach_info, *target_sp));
     if (error.Success())
       sb_process.SetSP(target_sp->GetProcessSP());
   } else
     error.SetErrorString("SBTarget is invalid");
 
-  if (log)
-    log->Printf("SBTarget(%p)::%s (...) => SBProcess(%p)",
-                static_cast<void *>(target_sp.get()), __FUNCTION__,
-                static_cast<void *>(sb_process.GetSP().get()));
   return LLDB_RECORD_RESULT(sb_process);
 }
 
 lldb::SBProcess SBTarget::ConnectRemote(SBListener &listener, const char *url,
                                         const char *plugin_name,
                                         SBError &error) {
   LLDB_RECORD_METHOD(
       lldb::SBProcess, SBTarget, ConnectRemote,
       (lldb::SBListener &, const char *, const char *, lldb::SBError &),
       listener, url, plugin_name, error);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-
   SBProcess sb_process;
   ProcessSP process_sp;
   TargetSP target_sp(GetSP());
 
-  if (log)
-    log->Printf("SBTarget(%p)::ConnectRemote (listener, url=%s, "
-                "plugin_name=%s, error)...",
-                static_cast<void *>(target_sp.get()), url, plugin_name);
-
   if (target_sp) {
     std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
     if (listener.IsValid())
       process_sp =
           target_sp->CreateProcess(listener.m_opaque_sp, plugin_name, NULL);
     else
       process_sp = target_sp->CreateProcess(
           target_sp->GetDebugger().GetListener(), plugin_name, NULL);
 
     if (process_sp) {
       sb_process.SetSP(process_sp);
       error.SetError(process_sp->ConnectRemote(NULL, url));
     } else {
       error.SetErrorString("unable to create lldb_private::Process");
     }
   } else {
     error.SetErrorString("SBTarget is invalid");
   }
 
-  if (log)
-    log->Printf("SBTarget(%p)::ConnectRemote (...) => SBProcess(%p)",
-                static_cast<void *>(target_sp.get()),
-                static_cast<void *>(process_sp.get()));
   return LLDB_RECORD_RESULT(sb_process);
 }
 
 SBFileSpec SBTarget::GetExecutable() {
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBFileSpec, SBTarget, GetExecutable);
 
   SBFileSpec exe_file_spec;
   TargetSP target_sp(GetSP());
   if (target_sp) {
     Module *exe_module = target_sp->GetExecutableModulePointer();
     if (exe_module)
       exe_file_spec.SetFileSpec(exe_module->GetFileSpec());
   }
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  if (log) {
-    log->Printf("SBTarget(%p)::GetExecutable () => SBFileSpec(%p)",
-                static_cast<void *>(target_sp.get()),
-                static_cast<const void *>(exe_file_spec.get()));
-  }
-
   return LLDB_RECORD_RESULT(exe_file_spec);
 }
 
 bool SBTarget::operator==(const SBTarget &rhs) const {
   LLDB_RECORD_METHOD_CONST(bool, SBTarget, operator==,(const lldb::SBTarget &),
                            rhs);
 
   return m_opaque_sp.get() == rhs.m_opaque_sp.get();

 SBBreakpoint SBTarget::BreakpointCreateByLocation(
     const SBFileSpec &sb_file_spec, uint32_t line, uint32_t column,
     lldb::addr_t offset, SBFileSpecList &sb_module_list) {
   LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByLocation,
                      (const lldb::SBFileSpec &, uint32_t, uint32_t,
                       lldb::addr_t, lldb::SBFileSpecList &),
                      sb_file_spec, line, column, offset, sb_module_list);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-
   SBBreakpoint sb_bp;
   TargetSP target_sp(GetSP());
   if (target_sp && line != 0) {
     std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
 
     const LazyBool check_inlines = eLazyBoolCalculate;
     const LazyBool skip_prologue = eLazyBoolCalculate;
     const bool internal = false;
     const bool hardware = false;
     const LazyBool move_to_nearest_code = eLazyBoolCalculate;
     const FileSpecList *module_list = nullptr;
     if (sb_module_list.GetSize() > 0) {
       module_list = sb_module_list.get();
     }
     sb_bp = target_sp->CreateBreakpoint(
         module_list, *sb_file_spec, line, column, offset, check_inlines,
         skip_prologue, internal, hardware, move_to_nearest_code);
   }
 
-  if (log) {
-    SBStream sstr;
-    sb_bp.GetDescription(sstr);
-    char path[PATH_MAX];
-    sb_file_spec->GetPath(path, sizeof(path));
-    log->Printf("SBTarget(%p)::BreakpointCreateByLocation ( %s:%u ) => "
-                "SBBreakpoint(%p): %s",
-                static_cast<void *>(target_sp.get()), path, line,
-                static_cast<void *>(sb_bp.GetSP().get()), sstr.GetData());
-  }
-
   return LLDB_RECORD_RESULT(sb_bp);
 }
 
 SBBreakpoint SBTarget::BreakpointCreateByName(const char *symbol_name,
                                               const char *module_name) {
   LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByName,
                      (const char *, const char *), symbol_name, module_name);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-
   SBBreakpoint sb_bp;
   TargetSP target_sp(GetSP());
   if (target_sp.get()) {
     std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
 
     const bool internal = false;
     const bool hardware = false;
     const LazyBool skip_prologue = eLazyBoolCalculate;
     const lldb::addr_t offset = 0;
     if (module_name && module_name[0]) {
       FileSpecList module_spec_list;
       module_spec_list.Append(FileSpec(module_name));
       sb_bp = target_sp->CreateBreakpoint(
           &module_spec_list, NULL, symbol_name, eFunctionNameTypeAuto,
           eLanguageTypeUnknown, offset, skip_prologue, internal, hardware);
     } else {
       sb_bp = target_sp->CreateBreakpoint(
           NULL, NULL, symbol_name, eFunctionNameTypeAuto, eLanguageTypeUnknown,
           offset, skip_prologue, internal, hardware);
     }
   }
 
-  if (log)
-    log->Printf("SBTarget(%p)::BreakpointCreateByName (symbol=\"%s\", "
-                "module=\"%s\") => SBBreakpoint(%p)",
-                static_cast<void *>(target_sp.get()), symbol_name, module_name,
-                static_cast<void *>(sb_bp.GetSP().get()));
-
   return LLDB_RECORD_RESULT(sb_bp);
 }
 
 lldb::SBBreakpoint
 SBTarget::BreakpointCreateByName(const char *symbol_name,
                                  const SBFileSpecList &module_list,
                                  const SBFileSpecList &comp_unit_list) {
   LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByName,
lldb::SBBreakpoint SBTarget::BreakpointCreateByName(
     const SBFileSpecList &comp_unit_list) {
   LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByName,
                      (const char *, uint32_t, lldb::LanguageType,
                       const lldb::SBFileSpecList &,
                       const lldb::SBFileSpecList &),
                      symbol_name, name_type_mask, symbol_language, module_list,
                      comp_unit_list);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-
   SBBreakpoint sb_bp;
   TargetSP target_sp(GetSP());
   if (target_sp && symbol_name && symbol_name[0]) {
     const bool internal = false;
     const bool hardware = false;
     const LazyBool skip_prologue = eLazyBoolCalculate;
     std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
     FunctionNameType mask = static_cast<FunctionNameType>(name_type_mask);
     sb_bp = target_sp->CreateBreakpoint(module_list.get(), comp_unit_list.get(),
                                         symbol_name, mask, symbol_language, 0,
                                         skip_prologue, internal, hardware);
   }
 
-  if (log)
-    log->Printf("SBTarget(%p)::BreakpointCreateByName (symbol=\"%s\", "
-                "name_type: %d) => SBBreakpoint(%p)",
-                static_cast<void *>(target_sp.get()), symbol_name,
-                name_type_mask, static_cast<void *>(sb_bp.GetSP().get()));
-
   return LLDB_RECORD_RESULT(sb_bp);
 }
 
 lldb::SBBreakpoint SBTarget::BreakpointCreateByNames(
     const char *symbol_names[], uint32_t num_names, uint32_t name_type_mask,
     const SBFileSpecList &module_list, const SBFileSpecList &comp_unit_list) {
   LLDB_RECORD_METHOD(
       lldb::SBBreakpoint, SBTarget, BreakpointCreateByNames,
lldb::SBBreakpoint SBTarget::BreakpointCreateByNames(
     const SBFileSpecList &module_list, const SBFileSpecList &comp_unit_list) {
   LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByNames,
                      (const char **, uint32_t, uint32_t, lldb::LanguageType,
                       lldb::addr_t, const lldb::SBFileSpecList &,
                       const lldb::SBFileSpecList &),
                      symbol_names, num_names, name_type_mask, symbol_language,
                      offset, module_list, comp_unit_list);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-
   SBBreakpoint sb_bp;
   TargetSP target_sp(GetSP());
   if (target_sp && num_names > 0) {
     std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
     const bool internal = false;
     const bool hardware = false;
     FunctionNameType mask = static_cast<FunctionNameType>(name_type_mask);
     const LazyBool skip_prologue = eLazyBoolCalculate;
     sb_bp = target_sp->CreateBreakpoint(
         module_list.get(), comp_unit_list.get(), symbol_names, num_names, mask,
         symbol_language, offset, skip_prologue, internal, hardware);
   }
 
-  if (log) {
-    log->Printf("SBTarget(%p)::BreakpointCreateByName (symbols={",
-                static_cast<void *>(target_sp.get()));
-    for (uint32_t i = 0; i < num_names; i++) {
-      char sep;
-      if (i < num_names - 1)
-        sep = ',';
-      else
-        sep = '}';
-      if (symbol_names[i] != NULL)
-        log->Printf("\"%s\"%c ", symbol_names[i], sep);
-      else
-        log->Printf("\"<NULL>\"%c ", sep);
-    }
-    log->Printf("name_type: %d) => SBBreakpoint(%p)", name_type_mask,
-                static_cast<void *>(sb_bp.GetSP().get()));
-  }
-
   return LLDB_RECORD_RESULT(sb_bp);
 }
 
 SBBreakpoint SBTarget::BreakpointCreateByRegex(const char *symbol_name_regex,
                                                const char *module_name) {
   LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByRegex,
                      (const char *, const char *), symbol_name_regex,
                      module_name);
lldb::SBBreakpoint SBTarget::BreakpointCreateByRegex(
     const char *symbol_name_regex, LanguageType symbol_language,
     const SBFileSpecList &module_list, const SBFileSpecList &comp_unit_list) {
   LLDB_RECORD_METHOD(
       lldb::SBBreakpoint, SBTarget, BreakpointCreateByRegex,
       (const char *, lldb::LanguageType, const lldb::SBFileSpecList &,
        const lldb::SBFileSpecList &),
       symbol_name_regex, symbol_language, module_list, comp_unit_list);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   SBBreakpoint sb_bp;
   TargetSP target_sp(GetSP());
   if (target_sp && symbol_name_regex && symbol_name_regex[0]) {
     std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
     RegularExpression regexp((llvm::StringRef(symbol_name_regex)));
     const bool internal = false;
     const bool hardware = false;
     const LazyBool skip_prologue = eLazyBoolCalculate;
 
     sb_bp = target_sp->CreateFuncRegexBreakpoint(
         module_list.get(), comp_unit_list.get(), regexp, symbol_language,
         skip_prologue, internal, hardware);
   }
 
-  if (log)
-    log->Printf("SBTarget(%p)::BreakpointCreateByRegex (symbol_regex=\"%s\") "
-                "=> SBBreakpoint(%p)",
-                static_cast<void *>(target_sp.get()), symbol_name_regex,
-                static_cast<void *>(sb_bp.GetSP().get()));
-
   return LLDB_RECORD_RESULT(sb_bp);
 }
 
 SBBreakpoint SBTarget::BreakpointCreateByAddress(addr_t address) {
   LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByAddress,
                      (lldb::addr_t), address);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-
   SBBreakpoint sb_bp;
   TargetSP target_sp(GetSP());
   if (target_sp) {
     std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
     const bool hardware = false;
     sb_bp = target_sp->CreateBreakpoint(address, false, hardware);
   }
 
-  if (log)
-    log->Printf("SBTarget(%p)::BreakpointCreateByAddress (address=%" PRIu64
-                ") => SBBreakpoint(%p)",
-                static_cast<void *>(target_sp.get()),
-                static_cast<uint64_t>(address),
-                static_cast<void *>(sb_bp.GetSP().get()));
-
   return LLDB_RECORD_RESULT(sb_bp);
 }
 
 SBBreakpoint SBTarget::BreakpointCreateBySBAddress(SBAddress &sb_address) {
   LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateBySBAddress,
                      (lldb::SBAddress &), sb_address);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-
   SBBreakpoint sb_bp;
   TargetSP target_sp(GetSP());
   if (!sb_address.IsValid()) {
-    if (log)
-      log->Printf("SBTarget(%p)::BreakpointCreateBySBAddress called with "
-                  "invalid address",
-                  static_cast<void *>(target_sp.get()));
     return LLDB_RECORD_RESULT(sb_bp);
   }
 
   if (target_sp) {
     std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
     const bool hardware = false;
     sb_bp = target_sp->CreateBreakpoint(sb_address.ref(), false, hardware);
   }
 
-  if (log) {
-    SBStream s;
-    sb_address.GetDescription(s);
-    log->Printf("SBTarget(%p)::BreakpointCreateBySBAddress (address=%s) => "
-                "SBBreakpoint(%p)",
-                static_cast<void *>(target_sp.get()), s.GetData(),
-                static_cast<void *>(sb_bp.GetSP().get()));
-  }
-
   return LLDB_RECORD_RESULT(sb_bp);
 }
 
 lldb::SBBreakpoint
 SBTarget::BreakpointCreateBySourceRegex(const char *source_regex,
                                         const lldb::SBFileSpec &source_file,
                                         const char *module_name) {
   LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget,
lldb::SBBreakpoint SBTarget::BreakpointCreateBySourceRegex(
     const lldb::SBFileSpecList &source_file_list,
     const SBStringList &func_names) {
   LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget,
                      BreakpointCreateBySourceRegex,
                      (const char *, const lldb::SBFileSpecList &,
                       const lldb::SBFileSpecList &, const lldb::SBStringList &),
                      source_regex, module_list, source_file_list, func_names);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-
   SBBreakpoint sb_bp;
   TargetSP target_sp(GetSP());
   if (target_sp && source_regex && source_regex[0]) {
     std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
     const bool hardware = false;
     const LazyBool move_to_nearest_code = eLazyBoolCalculate;
     RegularExpression regexp((llvm::StringRef(source_regex)));
     std::unordered_set<std::string> func_names_set;
     for (size_t i = 0; i < func_names.GetSize(); i++) {
       func_names_set.insert(func_names.GetStringAtIndex(i));
     }
 
     sb_bp = target_sp->CreateSourceRegexBreakpoint(
         module_list.get(), source_file_list.get(), func_names_set, regexp,
         false, hardware, move_to_nearest_code);
   }
 
-  if (log)
-    log->Printf("SBTarget(%p)::BreakpointCreateByRegex (source_regex=\"%s\") "
-                "=> SBBreakpoint(%p)",
-                static_cast<void *>(target_sp.get()), source_regex,
-                static_cast<void *>(sb_bp.GetSP().get()));
-
   return LLDB_RECORD_RESULT(sb_bp);
 }
 
 lldb::SBBreakpoint
 SBTarget::BreakpointCreateForException(lldb::LanguageType language,
                                        bool catch_bp, bool throw_bp) {
   LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateForException,
                      (lldb::LanguageType, bool, bool), language, catch_bp,
                      throw_bp);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-
   SBBreakpoint sb_bp;
   TargetSP target_sp(GetSP());
   if (target_sp) {
     std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
     const bool hardware = false;
     sb_bp = target_sp->CreateExceptionBreakpoint(language, catch_bp, throw_bp,
                                                   hardware);
   }
 
-  if (log)
-    log->Printf("SBTarget(%p)::BreakpointCreateForException (Language: %s, catch: "
-                "%s throw: %s) => SBBreakpoint(%p)",
-                static_cast<void *>(target_sp.get()),
-                Language::GetNameForLanguageType(language),
-                catch_bp ? "on" : "off", throw_bp ? "on" : "off",
-                static_cast<void *>(sb_bp.GetSP().get()));
-
   return LLDB_RECORD_RESULT(sb_bp);
 }
 
 lldb::SBBreakpoint SBTarget::BreakpointCreateFromScript(
     const char *class_name, SBStructuredData &extra_args,
     const SBFileSpecList &module_list, const SBFileSpecList &file_list,
     bool request_hardware) {
   LLDB_RECORD_METHOD(
       lldb::SBBreakpoint, SBTarget, BreakpointCreateFromScript,
       (const char *, lldb::SBStructuredData &, const lldb::SBFileSpecList &,
        const lldb::SBFileSpecList &, bool),
       class_name, extra_args, module_list, file_list, request_hardware);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-
   SBBreakpoint sb_bp;
   TargetSP target_sp(GetSP());
   if (target_sp) {
     std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
     Status error;
-    
     StructuredData::ObjectSP obj_sp = extra_args.m_impl_up->GetObjectSP();
     sb_bp =
         target_sp->CreateScriptedBreakpoint(class_name,
                                             module_list.get(),
                                             file_list.get(),
                                             false, /* internal */
                                             request_hardware,
                                             obj_sp,
                                             &error);
   }
-  if (log)
-    log->Printf("SBTarget(%p)::BreakpointCreateFromScript (class name: %s) "
-                " => SBBreakpoint(%p)",
-                static_cast<void *>(target_sp.get()),
-                class_name,
-                static_cast<void *>(sb_bp.GetSP().get()));
 
   return LLDB_RECORD_RESULT(sb_bp);
 }
 
 uint32_t SBTarget::GetNumBreakpoints() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBTarget, GetNumBreakpoints);
 
   TargetSP target_sp(GetSP());
SBBreakpoint SBTarget::GetBreakpointAtIndex(uint32_t idx) const {
   }
   return LLDB_RECORD_RESULT(sb_breakpoint);
 }
 
 bool SBTarget::BreakpointDelete(break_id_t bp_id) {
   LLDB_RECORD_METHOD(bool, SBTarget, BreakpointDelete, (lldb::break_id_t),
                      bp_id);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-
   bool result = false;
   TargetSP target_sp(GetSP());
   if (target_sp) {
     std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
     result = target_sp->RemoveBreakpointByID(bp_id);
   }
 
-  if (log)
-    log->Printf("SBTarget(%p)::BreakpointDelete (bp_id=%d) => %i",
-                static_cast<void *>(target_sp.get()),
-                static_cast<uint32_t>(bp_id), result);
-
   return result;
 }
 
 SBBreakpoint SBTarget::FindBreakpointByID(break_id_t bp_id) {
   LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, FindBreakpointByID,
                      (lldb::break_id_t), bp_id);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-
   SBBreakpoint sb_breakpoint;
   TargetSP target_sp(GetSP());
   if (target_sp && bp_id != LLDB_INVALID_BREAK_ID) {
     std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
     sb_breakpoint = target_sp->GetBreakpointByID(bp_id);
   }
 
-  if (log)
-    log->Printf(
-        "SBTarget(%p)::FindBreakpointByID (bp_id=%d) => SBBreakpoint(%p)",
-        static_cast<void *>(target_sp.get()), static_cast<uint32_t>(bp_id),
-        static_cast<void *>(sb_breakpoint.GetSP().get()));
-
   return LLDB_RECORD_RESULT(sb_breakpoint);
 }
 
 bool SBTarget::FindBreakpointsByName(const char *name,
                                      SBBreakpointList &bkpts) {
   LLDB_RECORD_METHOD(bool, SBTarget, FindBreakpointsByName,
                      (const char *, lldb::SBBreakpointList &), name, bkpts);
 
SBWatchpoint SBTarget::GetWatchpointAtIndex(uint32_t idx) const {
   }
   return LLDB_RECORD_RESULT(sb_watchpoint);
 }
 
 bool SBTarget::DeleteWatchpoint(watch_id_t wp_id) {
   LLDB_RECORD_METHOD(bool, SBTarget, DeleteWatchpoint, (lldb::watch_id_t),
                      wp_id);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   bool result = false;
   TargetSP target_sp(GetSP());
   if (target_sp) {
     std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
     std::unique_lock<std::recursive_mutex> lock;
     target_sp->GetWatchpointList().GetListMutex(lock);
     result = target_sp->RemoveWatchpointByID(wp_id);
   }
 
-  if (log)
-    log->Printf("SBTarget(%p)::WatchpointDelete (wp_id=%d) => %i",
-                static_cast<void *>(target_sp.get()),
-                static_cast<uint32_t>(wp_id), result);
-
   return result;
 }
 
 SBWatchpoint SBTarget::FindWatchpointByID(lldb::watch_id_t wp_id) {
   LLDB_RECORD_METHOD(lldb::SBWatchpoint, SBTarget, FindWatchpointByID,
                      (lldb::watch_id_t), wp_id);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   SBWatchpoint sb_watchpoint;
   lldb::WatchpointSP watchpoint_sp;
   TargetSP target_sp(GetSP());
   if (target_sp && wp_id != LLDB_INVALID_WATCH_ID) {
     std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
     std::unique_lock<std::recursive_mutex> lock;
     target_sp->GetWatchpointList().GetListMutex(lock);
     watchpoint_sp = target_sp->GetWatchpointList().FindByID(wp_id);
     sb_watchpoint.SetSP(watchpoint_sp);
   }
 
-  if (log)
-    log->Printf(
-        "SBTarget(%p)::FindWatchpointByID (bp_id=%d) => SBWatchpoint(%p)",
-        static_cast<void *>(target_sp.get()), static_cast<uint32_t>(wp_id),
-        static_cast<void *>(watchpoint_sp.get()));
-
   return LLDB_RECORD_RESULT(sb_watchpoint);
 }
 
 lldb::SBWatchpoint SBTarget::WatchAddress(lldb::addr_t addr, size_t size,
                                           bool read, bool write,
                                           SBError &error) {
   LLDB_RECORD_METHOD(lldb::SBWatchpoint, SBTarget, WatchAddress,
                      (lldb::addr_t, size_t, bool, bool, lldb::SBError &), addr,
                      size, read, write, error);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-
   SBWatchpoint sb_watchpoint;
   lldb::WatchpointSP watchpoint_sp;
   TargetSP target_sp(GetSP());
   if (target_sp && (read || write) && addr != LLDB_INVALID_ADDRESS &&
       size > 0) {
     std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
     uint32_t watch_type = 0;
     if (read)
if (target_sp && (read || write) && addr != LLDB_INVALID_ADDRESS &&
     // This API doesn't take in a type, so we can't figure out what it is.
     CompilerType *type = NULL;
     watchpoint_sp =
         target_sp->CreateWatchpoint(addr, size, type, watch_type, cw_error);
     error.SetError(cw_error);
     sb_watchpoint.SetSP(watchpoint_sp);
   }
 
-  if (log)
-    log->Printf("SBTarget(%p)::WatchAddress (addr=0x%" PRIx64
-                ", 0x%u) => SBWatchpoint(%p)",
-                static_cast<void *>(target_sp.get()), addr,
-                static_cast<uint32_t>(size),
-                static_cast<void *>(watchpoint_sp.get()));
-
   return LLDB_RECORD_RESULT(sb_watchpoint);
 }
 
 bool SBTarget::EnableAllWatchpoints() {
   LLDB_RECORD_METHOD_NO_ARGS(bool, SBTarget, EnableAllWatchpoints);
 
   TargetSP target_sp(GetSP());
   if (target_sp) {
if (IsValid() && name && *name && addr.IsValid() && type.IsValid()) {
     lldb::addr_t load_addr(addr.GetLoadAddress(*this));
     ExecutionContext exe_ctx(
         ExecutionContextRef(ExecutionContext(m_opaque_sp.get(), false)));
     CompilerType ast_type(type.GetSP()->GetCompilerType(true));
     new_value_sp = ValueObject::CreateValueObjectFromAddress(name, load_addr,
                                                              exe_ctx, ast_type);
   }
   sb_value.SetSP(new_value_sp);
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  if (log) {
-    if (new_value_sp)
-      log->Printf("SBTarget(%p)::CreateValueFromAddress => \"%s\"",
-                  static_cast<void *>(m_opaque_sp.get()),
-                  new_value_sp->GetName().AsCString());
-    else
-      log->Printf("SBTarget(%p)::CreateValueFromAddress => NULL",
-                  static_cast<void *>(m_opaque_sp.get()));
-  }
   return LLDB_RECORD_RESULT(sb_value);
 }
 
 lldb::SBValue SBTarget::CreateValueFromData(const char *name, lldb::SBData data,
                                             lldb::SBType type) {
   LLDB_RECORD_METHOD(lldb::SBValue, SBTarget, CreateValueFromData,
                      (const char *, lldb::SBData, lldb::SBType), name, data,
                      type);
 
   SBValue sb_value;
   lldb::ValueObjectSP new_value_sp;
   if (IsValid() && name && *name && data.IsValid() && type.IsValid()) {
     DataExtractorSP extractor(*data);
     ExecutionContext exe_ctx(
         ExecutionContextRef(ExecutionContext(m_opaque_sp.get(), false)));
     CompilerType ast_type(type.GetSP()->GetCompilerType(true));
     new_value_sp = ValueObject::CreateValueObjectFromData(name, *extractor,
                                                           exe_ctx, ast_type);
   }
   sb_value.SetSP(new_value_sp);
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  if (log) {
-    if (new_value_sp)
-      log->Printf("SBTarget(%p)::CreateValueFromData => \"%s\"",
-                  static_cast<void *>(m_opaque_sp.get()),
-                  new_value_sp->GetName().AsCString());
-    else
-      log->Printf("SBTarget(%p)::CreateValueFromData => NULL",
-                  static_cast<void *>(m_opaque_sp.get()));
-  }
   return LLDB_RECORD_RESULT(sb_value);
 }
 
 lldb::SBValue SBTarget::CreateValueFromExpression(const char *name,
                                                   const char *expr) {
   LLDB_RECORD_METHOD(lldb::SBValue, SBTarget, CreateValueFromExpression,
                      (const char *, const char *), name, expr);
 
   SBValue sb_value;
   lldb::ValueObjectSP new_value_sp;
   if (IsValid() && name && *name && expr && *expr) {
     ExecutionContext exe_ctx(
         ExecutionContextRef(ExecutionContext(m_opaque_sp.get(), false)));
     new_value_sp =
         ValueObject::CreateValueObjectFromExpression(name, expr, exe_ctx);
   }
   sb_value.SetSP(new_value_sp);
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  if (log) {
-    if (new_value_sp)
-      log->Printf("SBTarget(%p)::CreateValueFromExpression => \"%s\"",
-                  static_cast<void *>(m_opaque_sp.get()),
-                  new_value_sp->GetName().AsCString());
-    else
-      log->Printf("SBTarget(%p)::CreateValueFromExpression => NULL",
-                  static_cast<void *>(m_opaque_sp.get()));
-  }
   return LLDB_RECORD_RESULT(sb_value);
 }
 
 bool SBTarget::DeleteAllWatchpoints() {
   LLDB_RECORD_METHOD_NO_ARGS(bool, SBTarget, DeleteAllWatchpoints);
 
   TargetSP target_sp(GetSP());
   if (target_sp) {
if (!target_sp)
     return error.SetErrorString("invalid target");
 
   const ConstString csFrom(from), csTo(to);
   if (!csFrom)
     return error.SetErrorString("<from> path can't be empty");
   if (!csTo)
     return error.SetErrorString("<to> path can't be empty");
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  if (log)
-    log->Printf("SBTarget(%p)::%s: '%s' -> '%s'",
-                static_cast<void *>(target_sp.get()),  __FUNCTION__,
-                from, to);
   target_sp->GetImageSearchPathList().Append(csFrom, csTo, true);
 }
 
 lldb::SBModule SBTarget::AddModule(const char *path, const char *triple,
                                    const char *uuid_cstr) {
   LLDB_RECORD_METHOD(lldb::SBModule, SBTarget, AddModule,
                      (const char *, const char *, const char *), path, triple,
                      uuid_cstr);
if (target_sp) {
     return true;
   }
   return false;
 }
 
 uint32_t SBTarget::GetNumModules() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBTarget, GetNumModules);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-
   uint32_t num = 0;
   TargetSP target_sp(GetSP());
   if (target_sp) {
     // The module list is thread safe, no need to lock
     num = target_sp->GetImages().GetSize();
   }
 
-  if (log)
-    log->Printf("SBTarget(%p)::GetNumModules () => %d",
-                static_cast<void *>(target_sp.get()), num);
-
   return num;
 }
 
 void SBTarget::Clear() {
   LLDB_RECORD_METHOD_NO_ARGS(void, SBTarget, Clear);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-
-  if (log)
-    log->Printf("SBTarget(%p)::Clear ()",
-                static_cast<void *>(m_opaque_sp.get()));
-
   m_opaque_sp.reset();
 }
 
 SBModule SBTarget::FindModule(const SBFileSpec &sb_file_spec) {
   LLDB_RECORD_METHOD(lldb::SBModule, SBTarget, FindModule,
                      (const lldb::SBFileSpec &), sb_file_spec);
 
   SBModule sb_module;
if (target_sp)
     return target_sp->GetArchitecture().GetAddressByteSize();
   return sizeof(void *);
 }
 
 SBModule SBTarget::GetModuleAtIndex(uint32_t idx) {
   LLDB_RECORD_METHOD(lldb::SBModule, SBTarget, GetModuleAtIndex, (uint32_t),
                      idx);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-
   SBModule sb_module;
   ModuleSP module_sp;
   TargetSP target_sp(GetSP());
   if (target_sp) {
     // The module list is thread safe, no need to lock
     module_sp = target_sp->GetImages().GetModuleAtIndex(idx);
     sb_module.SetSP(module_sp);
   }
 
-  if (log)
-    log->Printf("SBTarget(%p)::GetModuleAtIndex (idx=%d) => SBModule(%p)",
-                static_cast<void *>(target_sp.get()), idx,
-                static_cast<void *>(module_sp.get()));
-
   return LLDB_RECORD_RESULT(sb_module);
 }
 
 bool SBTarget::RemoveModule(lldb::SBModule module) {
   LLDB_RECORD_METHOD(bool, SBTarget, RemoveModule, (lldb::SBModule), module);
 
   TargetSP target_sp(GetSP());
   if (target_sp)
     return target_sp->GetImages().Remove(module.GetSP());
   return false;
 }
 
 SBBroadcaster SBTarget::GetBroadcaster() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBBroadcaster, SBTarget,
                                    GetBroadcaster);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   TargetSP target_sp(GetSP());
   SBBroadcaster broadcaster(target_sp.get(), false);
 
-  if (log)
-    log->Printf("SBTarget(%p)::GetBroadcaster () => SBBroadcaster(%p)",
-                static_cast<void *>(target_sp.get()),
-                static_cast<void *>(broadcaster.get()));
 
   return LLDB_RECORD_RESULT(broadcaster);
 }
 
 bool SBTarget::GetDescription(SBStream &description,
                               lldb::DescriptionLevel description_level) {
   LLDB_RECORD_METHOD(bool, SBTarget, GetDescription,
                      (lldb::SBStream &, lldb::DescriptionLevel), description,

 }
 
 lldb::SBValue SBTarget::EvaluateExpression(const char *expr,
                                            const SBExpressionOptions &options) {
   LLDB_RECORD_METHOD(lldb::SBValue, SBTarget, EvaluateExpression,
                      (const char *, const lldb::SBExpressionOptions &), expr,
                      options);
 
-  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 #if !defined(LLDB_DISABLE_PYTHON)
   Log *expr_log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
 #endif
   SBValue expr_result;
   ExpressionResults exe_results = eExpressionSetupError;
   ValueObjectSP expr_value_sp;
   TargetSP target_sp(GetSP());
   StackFrame *frame = NULL;
   if (target_sp) {
     if (expr == NULL || expr[0] == '\0') {
-      if (log)
-        log->Printf(
-            "SBTarget::EvaluateExpression called with an empty expression");
       return LLDB_RECORD_RESULT(expr_result);
     }
 
     std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
     ExecutionContext exe_ctx(m_opaque_sp.get());
 
-    if (log)
-      log->Printf("SBTarget()::EvaluateExpression (expr=\"%s\")...", expr);
 
     frame = exe_ctx.GetFramePtr();
     Target *target = exe_ctx.GetTargetPtr();
 
     if (target) {
 #ifdef LLDB_CONFIGURATION_DEBUG
       StreamString frame_description;
       if (frame)
         frame->DumpUsingSettingsFormat(&frame_description);
       llvm::PrettyStackTraceFormat stack_trace(
           "SBTarget::EvaluateExpression (expr = \"%s\", fetch_dynamic_value = "
           "%u) %s",
           expr, options.GetFetchDynamicValue(),
           frame_description.GetString().str().c_str());
 #endif
       exe_results =
           target->EvaluateExpression(expr, frame, expr_value_sp, options.ref());
 
       expr_result.SetSP(expr_value_sp, options.GetFetchDynamicValue());
-    } else {
-      if (log)
-        log->Printf("SBTarget::EvaluateExpression () => error: could not "
-                    "reconstruct frame object for this SBTarget.");
     }
   }
 #ifndef LLDB_DISABLE_PYTHON
   if (expr_log)
     expr_log->Printf("** [SBTarget::EvaluateExpression] Expression result is "
                      "%s, summary %s **",
                      expr_result.GetValue(), expr_result.GetSummary());
-
-  if (log)
-    log->Printf("SBTarget(%p)::EvaluateExpression (expr=\"%s\") => SBValue(%p) "
-                "(execution result=%d)",
-                static_cast<void *>(frame), expr,
-                static_cast<void *>(expr_value_sp.get()), exe_results);
 #endif
 
   return LLDB_RECORD_RESULT(expr_result);
 }
 
 lldb::addr_t SBTarget::GetStackRedZoneSize() {
   LLDB_RECORD_METHOD_NO_ARGS(lldb::addr_t, SBTarget, GetStackRedZoneSize);
 

source/API/SBThread.cpp

 lldb::SBQueue SBThread::GetQueue() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBQueue, SBThread, GetQueue);
 
   SBQueue sb_queue;
   QueueSP queue_sp;
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   if (exe_ctx.HasThreadScope()) {
     Process::StopLocker stop_locker;
     if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock())) {
       queue_sp = exe_ctx.GetThreadPtr()->GetQueue();
       if (queue_sp) {
         sb_queue.SetQueue(queue_sp);
       }
-    } else {
-      if (log)
-        log->Printf("SBThread(%p)::GetQueue() => error: process is running",
-                    static_cast<void *>(exe_ctx.GetThreadPtr()));
     }
   }
 
-  if (log)
-    log->Printf("SBThread(%p)::GetQueue () => SBQueue(%p)",
-                static_cast<void *>(exe_ctx.GetThreadPtr()),
-                static_cast<void *>(queue_sp.get()));
-
   return LLDB_RECORD_RESULT(sb_queue);
 }
 
 bool SBThread::IsValid() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBThread, IsValid);
 
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
void SBThread::Clear() {
   LLDB_RECORD_METHOD_NO_ARGS(void, SBThread, Clear);
 
   m_opaque_sp->Clear();
 }
 
 StopReason SBThread::GetStopReason() {
   LLDB_RECORD_METHOD_NO_ARGS(lldb::StopReason, SBThread, GetStopReason);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-
   StopReason reason = eStopReasonInvalid;
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
   if (exe_ctx.HasThreadScope()) {
     Process::StopLocker stop_locker;
     if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock())) {
       return exe_ctx.GetThreadPtr()->GetStopReason();
-    } else {
-      if (log)
-        log->Printf(
-            "SBThread(%p)::GetStopReason() => error: process is running",
-            static_cast<void *>(exe_ctx.GetThreadPtr()));
     }
   }
 
-  if (log)
-    log->Printf("SBThread(%p)::GetStopReason () => %s",
-                static_cast<void *>(exe_ctx.GetThreadPtr()),
-                Thread::StopReasonAsCString(reason));
-
   return reason;
 }
 
 size_t SBThread::GetStopReasonDataCount() {
   LLDB_RECORD_METHOD_NO_ARGS(size_t, SBThread, GetStopReasonDataCount);
 
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock())) {
 
         case eStopReasonSignal:
           return 1;
 
         case eStopReasonException:
           return 1;
         }
       }
-    } else {
-      Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-      if (log)
-        log->Printf("SBThread(%p)::GetStopReasonDataCount() => error: process "
-                    "is running",
-                    static_cast<void *>(exe_ctx.GetThreadPtr()));
     }
   }
   return 0;
 }
 
 uint64_t SBThread::GetStopReasonDataAtIndex(uint32_t idx) {
   LLDB_RECORD_METHOD(uint64_t, SBThread, GetStopReasonDataAtIndex, (uint32_t),
                      idx);
if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock())) {
 
         case eStopReasonSignal:
           return stop_info_sp->GetValue();
 
         case eStopReasonException:
           return stop_info_sp->GetValue();
         }
       }
-    } else {
-      Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-      if (log)
-        log->Printf("SBThread(%p)::GetStopReasonDataAtIndex() => error: "
-                    "process is running",
-                    static_cast<void *>(exe_ctx.GetThreadPtr()));
     }
   }
   return 0;
 }
 
 bool SBThread::GetStopReasonExtendedInfoAsJSON(lldb::SBStream &stream) {
   LLDB_RECORD_METHOD(bool, SBThread, GetStopReasonExtendedInfoAsJSON,
                      (lldb::SBStream &), stream);
SBThread::GetStopReasonExtendedBacktraces(InstrumentationRuntimeType type) {
   return LLDB_RECORD_RESULT(process_sp->GetInstrumentationRuntime(type)
                                 ->GetBacktracesFromExtendedStopInfo(info));
 }
 
 size_t SBThread::GetStopDescription(char *dst, size_t dst_len) {
   LLDB_RECORD_METHOD(size_t, SBThread, GetStopDescription, (char *, size_t),
                      dst, dst_len);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
   if (exe_ctx.HasThreadScope()) {
     Process::StopLocker stop_locker;
     if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock())) {
 
       StopInfoSP stop_info_sp = exe_ctx.GetThreadPtr()->GetStopInfo();
       if (stop_info_sp) {
         const char *stop_desc = stop_info_sp->GetDescription();
         if (stop_desc) {
-          if (log)
-            log->Printf(
-                "SBThread(%p)::GetStopDescription (dst, dst_len) => \"%s\"",
-                static_cast<void *>(exe_ctx.GetThreadPtr()), stop_desc);
           if (dst)
             return ::snprintf(dst, dst_len, "%s", stop_desc);
           else {
             // NULL dst passed in, return the length needed to contain the
             // description
             return ::strlen(stop_desc) + 1; // Include the NULL byte for size
           }
         } else {
if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock())) {
             stop_desc = limbo_desc;
             stop_desc_len = sizeof(limbo_desc);
           } break;
           default:
             break;
           }
 
           if (stop_desc && stop_desc[0]) {
-            if (log)
-              log->Printf(
-                  "SBThread(%p)::GetStopDescription (dst, dst_len) => '%s'",
-                  static_cast<void *>(exe_ctx.GetThreadPtr()), stop_desc);
-
             if (dst)
               return ::snprintf(dst, dst_len, "%s", stop_desc) +
                      1; // Include the NULL byte
 
             if (stop_desc_len == 0)
               stop_desc_len = ::strlen(stop_desc) + 1; // Include the NULL byte
 
             return stop_desc_len;
           }
         }
       }
-    } else {
-      Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-      if (log)
-        log->Printf(
-            "SBThread(%p)::GetStopDescription() => error: process is running",
-            static_cast<void *>(exe_ctx.GetThreadPtr()));
     }
   }
   if (dst)
     *dst = 0;
   return 0;
 }
 
 SBValue SBThread::GetStopReturnValue() {
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBValue, SBThread, GetStopReturnValue);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   ValueObjectSP return_valobj_sp;
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
   if (exe_ctx.HasThreadScope()) {
     Process::StopLocker stop_locker;
     if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock())) {
       StopInfoSP stop_info_sp = exe_ctx.GetThreadPtr()->GetStopInfo();
       if (stop_info_sp) {
         return_valobj_sp = StopInfo::GetReturnValueObject(stop_info_sp);
       }
-    } else {
-      if (log)
-        log->Printf(
-            "SBThread(%p)::GetStopReturnValue() => error: process is running",
-            static_cast<void *>(exe_ctx.GetThreadPtr()));
     }
   }
 
-  if (log)
-    log->Printf("SBThread(%p)::GetStopReturnValue () => %s",
-                static_cast<void *>(exe_ctx.GetThreadPtr()),
-                return_valobj_sp.get() ? return_valobj_sp->GetValueAsCString()
-                                       : "<no return value>");
-
   return LLDB_RECORD_RESULT(SBValue(return_valobj_sp));
 }
 
 void SBThread::SetThread(const ThreadSP &lldb_object_sp) {
   m_opaque_sp->SetThreadSP(lldb_object_sp);
 }
 
 lldb::tid_t SBThread::GetThreadID() const {
uint32_t SBThread::GetIndexID() const {
   if (thread_sp)
     return thread_sp->GetIndexID();
   return LLDB_INVALID_INDEX32;
 }
 
 const char *SBThread::GetName() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBThread, GetName);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   const char *name = NULL;
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
   if (exe_ctx.HasThreadScope()) {
     Process::StopLocker stop_locker;
     if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock())) {
       name = exe_ctx.GetThreadPtr()->GetName();
-    } else {
-      if (log)
-        log->Printf("SBThread(%p)::GetName() => error: process is running",
-                    static_cast<void *>(exe_ctx.GetThreadPtr()));
     }
   }
 
-  if (log)
-    log->Printf("SBThread(%p)::GetName () => %s",
-                static_cast<void *>(exe_ctx.GetThreadPtr()),
-                name ? name : "NULL");
-
   return name;
 }
 
 const char *SBThread::GetQueueName() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBThread, GetQueueName);
 
   const char *name = NULL;
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   if (exe_ctx.HasThreadScope()) {
     Process::StopLocker stop_locker;
     if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock())) {
       name = exe_ctx.GetThreadPtr()->GetQueueName();
-    } else {
-      if (log)
-        log->Printf("SBThread(%p)::GetQueueName() => error: process is running",
-                    static_cast<void *>(exe_ctx.GetThreadPtr()));
     }
   }
 
-  if (log)
-    log->Printf("SBThread(%p)::GetQueueName () => %s",
-                static_cast<void *>(exe_ctx.GetThreadPtr()),
-                name ? name : "NULL");
-
   return name;
 }
 
 lldb::queue_id_t SBThread::GetQueueID() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::queue_id_t, SBThread, GetQueueID);
 
   queue_id_t id = LLDB_INVALID_QUEUE_ID;
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   if (exe_ctx.HasThreadScope()) {
     Process::StopLocker stop_locker;
     if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock())) {
       id = exe_ctx.GetThreadPtr()->GetQueueID();
-    } else {
-      if (log)
-        log->Printf("SBThread(%p)::GetQueueID() => error: process is running",
-                    static_cast<void *>(exe_ctx.GetThreadPtr()));
     }
   }
 
-  if (log)
-    log->Printf("SBThread(%p)::GetQueueID () => 0x%" PRIx64,
-                static_cast<void *>(exe_ctx.GetThreadPtr()), id);
-
   return id;
 }
 
 bool SBThread::GetInfoItemByPathAsString(const char *path, SBStream &strm) {
   LLDB_RECORD_METHOD(bool, SBThread, GetInfoItemByPathAsString,
                      (const char *, lldb::SBStream &), path, strm);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   bool success = false;
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
   if (exe_ctx.HasThreadScope()) {
     Process::StopLocker stop_locker;
     if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock())) {
       Thread *thread = exe_ctx.GetThreadPtr();
if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock())) {
             success = true;
           }
           if (node->GetType() == eStructuredDataTypeNull) {
             strm.Printf("null");
             success = true;
           }
         }
       }
-    } else {
-      if (log)
-        log->Printf("SBThread(%p)::GetInfoItemByPathAsString() => error: "
-                    "process is running",
-                    static_cast<void *>(exe_ctx.GetThreadPtr()));
     }
   }
 
-  if (log)
-    log->Printf("SBThread(%p)::GetInfoItemByPathAsString (\"%s\") => \"%s\"",
-                static_cast<void *>(exe_ctx.GetThreadPtr()), path, strm.GetData());
-
   return success;
 }
 
 SBError SBThread::ResumeNewPlan(ExecutionContext &exe_ctx,
                                 ThreadPlan *new_plan) {
   SBError sb_error;
 
   Process *process = exe_ctx.GetProcessPtr();
void SBThread::StepOver(lldb::RunMode stop_other_threads) {
   SBError error; // Ignored
   StepOver(stop_other_threads, error);
 }
 
 void SBThread::StepOver(lldb::RunMode stop_other_threads, SBError &error) {
   LLDB_RECORD_METHOD(void, SBThread, StepOver, (lldb::RunMode, lldb::SBError &),
                      stop_other_threads, error);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
-  if (log)
-    log->Printf("SBThread(%p)::StepOver (stop_other_threads='%s')",
-                static_cast<void *>(exe_ctx.GetThreadPtr()),
-                Thread::RunModeAsCString(stop_other_threads));
-
   if (!exe_ctx.HasThreadScope()) {
     error.SetErrorString("this SBThread object is invalid");
     return;
   }
 
   Thread *thread = exe_ctx.GetThreadPtr();
   bool abort_other_plans = false;
   StackFrameSP frame_sp(thread->GetStackFrameAtIndex(0));

 }
 
 void SBThread::StepInto(const char *target_name, uint32_t end_line,
                         SBError &error, lldb::RunMode stop_other_threads) {
   LLDB_RECORD_METHOD(void, SBThread, StepInto,
                      (const char *, uint32_t, lldb::SBError &, lldb::RunMode),
                      target_name, end_line, error, stop_other_threads);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
-  if (log)
-    log->Printf(
-        "SBThread(%p)::StepInto (target_name='%s', stop_other_threads='%s')",
-        static_cast<void *>(exe_ctx.GetThreadPtr()),
-        target_name ? target_name : "<NULL>",
-        Thread::RunModeAsCString(stop_other_threads));
-
   if (!exe_ctx.HasThreadScope()) {
     error.SetErrorString("this SBThread object is invalid");
     return;
   }
 
   bool abort_other_plans = false;
 
   Thread *thread = exe_ctx.GetThreadPtr();
void SBThread::StepOut() {
 
   SBError error; // Ignored
   StepOut(error);
 }
 
 void SBThread::StepOut(SBError &error) {
   LLDB_RECORD_METHOD(void, SBThread, StepOut, (lldb::SBError &), error);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
-  if (log)
-    log->Printf("SBThread(%p)::StepOut ()",
-                static_cast<void *>(exe_ctx.GetThreadPtr()));
-
   if (!exe_ctx.HasThreadScope()) {
     error.SetErrorString("this SBThread object is invalid");
     return;
   }
 
   bool abort_other_plans = false;
   bool stop_other_threads = false;
 
void SBThread::StepOutOfFrame(SBFrame &sb_frame) {
   SBError error; // Ignored
   StepOutOfFrame(sb_frame, error);
 }
 
 void SBThread::StepOutOfFrame(SBFrame &sb_frame, SBError &error) {
   LLDB_RECORD_METHOD(void, SBThread, StepOutOfFrame,
                      (lldb::SBFrame &, lldb::SBError &), sb_frame, error);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
   if (!sb_frame.IsValid()) {
-    if (log)
-      log->Printf(
-          "SBThread(%p)::StepOutOfFrame passed an invalid frame, returning.",
-          static_cast<void *>(exe_ctx.GetThreadPtr()));
     error.SetErrorString("passed invalid SBFrame object");
     return;
   }
 
   StackFrameSP frame_sp(sb_frame.GetFrameSP());
-  if (log) {
-    SBStream frame_desc_strm;
-    sb_frame.GetDescription(frame_desc_strm);
-    log->Printf("SBThread(%p)::StepOutOfFrame (frame = SBFrame(%p): %s)",
-                static_cast<void *>(exe_ctx.GetThreadPtr()),
-                static_cast<void *>(frame_sp.get()), frame_desc_strm.GetData());
-  }
 
   if (!exe_ctx.HasThreadScope()) {
     error.SetErrorString("this SBThread object is invalid");
     return;
   }
 
   bool abort_other_plans = false;
   bool stop_other_threads = false;
   Thread *thread = exe_ctx.GetThreadPtr();
   if (sb_frame.GetThread().GetThreadID() != thread->GetID()) {
-    log->Printf("SBThread(%p)::StepOutOfFrame passed a frame from another "
-                "thread (0x%" PRIx64 " vrs. 0x%" PRIx64 ", returning.",
-                static_cast<void *>(exe_ctx.GetThreadPtr()),
-                sb_frame.GetThread().GetThreadID(), thread->GetID());
     error.SetErrorString("passed a frame from another thread");
     return;
   }
 
   Status new_plan_status;
   ThreadPlanSP new_plan_sp(thread->QueueThreadPlanForStepOut(
       abort_other_plans, NULL, false, stop_other_threads, eVoteYes,
       eVoteNoOpinion, frame_sp->GetFrameIndex(), new_plan_status));
void SBThread::StepInstruction(bool step_over) {
   SBError error; // Ignored
   StepInstruction(step_over, error);
 }
 
 void SBThread::StepInstruction(bool step_over, SBError &error) {
   LLDB_RECORD_METHOD(void, SBThread, StepInstruction, (bool, lldb::SBError &),
                      step_over, error);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
-  if (log)
-    log->Printf("SBThread(%p)::StepInstruction (step_over=%i)",
-                static_cast<void *>(exe_ctx.GetThreadPtr()), step_over);
-
   if (!exe_ctx.HasThreadScope()) {
     error.SetErrorString("this SBThread object is invalid");
     return;
   }
 
   Thread *thread = exe_ctx.GetThreadPtr();
   Status new_plan_status;
   ThreadPlanSP new_plan_sp(thread->QueueThreadPlanForStepSingleInstruction(
void SBThread::RunToAddress(lldb::addr_t addr) {
   SBError error; // Ignored
   RunToAddress(addr, error);
 }
 
 void SBThread::RunToAddress(lldb::addr_t addr, SBError &error) {
   LLDB_RECORD_METHOD(void, SBThread, RunToAddress,
                      (lldb::addr_t, lldb::SBError &), addr, error);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
-  if (log)
-    log->Printf("SBThread(%p)::RunToAddress (addr=0x%" PRIx64 ")",
-                static_cast<void *>(exe_ctx.GetThreadPtr()), addr);
-
   if (!exe_ctx.HasThreadScope()) {
     error.SetErrorString("this SBThread object is invalid");
     return;
   }
 
   bool abort_other_plans = false;
   bool stop_other_threads = true;
 

 
 SBError SBThread::StepOverUntil(lldb::SBFrame &sb_frame,
                                 lldb::SBFileSpec &sb_file_spec, uint32_t line) {
   LLDB_RECORD_METHOD(lldb::SBError, SBThread, StepOverUntil,
                      (lldb::SBFrame &, lldb::SBFileSpec &, uint32_t), sb_frame,
                      sb_file_spec, line);
 
   SBError sb_error;
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   char path[PATH_MAX];
 
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
   StackFrameSP frame_sp(sb_frame.GetFrameSP());
 
-  if (log) {
-    SBStream frame_desc_strm;
-    sb_frame.GetDescription(frame_desc_strm);
-    sb_file_spec->GetPath(path, sizeof(path));
-    log->Printf("SBThread(%p)::StepOverUntil (frame = SBFrame(%p): %s, "
-                "file+line = %s:%u)",
-                static_cast<void *>(exe_ctx.GetThreadPtr()),
-                static_cast<void *>(frame_sp.get()), frame_desc_strm.GetData(),
-                path, line);
-  }
-
   if (exe_ctx.HasThreadScope()) {
     Target *target = exe_ctx.GetTargetPtr();
     Thread *thread = exe_ctx.GetThreadPtr();
 
     if (line == 0) {
       sb_error.SetErrorString("invalid line argument");
       return LLDB_RECORD_RESULT(sb_error);
     }

 }
 
 SBError SBThread::StepUsingScriptedThreadPlan(const char *script_class_name,
                                               bool resume_immediately) {
   LLDB_RECORD_METHOD(lldb::SBError, SBThread, StepUsingScriptedThreadPlan,
                      (const char *, bool), script_class_name,
                      resume_immediately);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   SBError error;
 
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
-  if (log) {
-    log->Printf("SBThread(%p)::StepUsingScriptedThreadPlan: class name: %s",
-                static_cast<void *>(exe_ctx.GetThreadPtr()), script_class_name);
-  }
-
   if (!exe_ctx.HasThreadScope()) {
     error.SetErrorString("this SBThread object is invalid");
     return LLDB_RECORD_RESULT(error);
   }
 
   Thread *thread = exe_ctx.GetThreadPtr();
   Status new_plan_status;
   ThreadPlanSP new_plan_sp = thread->QueueThreadPlanForStepScripted(
SBError SBThread::StepUsingScriptedThreadPlan(const char *script_class_name,
 
   return LLDB_RECORD_RESULT(error);
 }
 
 SBError SBThread::JumpToLine(lldb::SBFileSpec &file_spec, uint32_t line) {
   LLDB_RECORD_METHOD(lldb::SBError, SBThread, JumpToLine,
                      (lldb::SBFileSpec &, uint32_t), file_spec, line);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   SBError sb_error;
 
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
-  if (log)
-    log->Printf("SBThread(%p)::JumpToLine (file+line = %s:%u)",
-                static_cast<void *>(exe_ctx.GetThreadPtr()),
-                file_spec->GetPath().c_str(), line);
-
   if (!exe_ctx.HasThreadScope()) {
     sb_error.SetErrorString("this SBThread object is invalid");
     return LLDB_RECORD_RESULT(sb_error);
   }
 
   Thread *thread = exe_ctx.GetThreadPtr();
 
   Status err = thread->JumpToLine(file_spec.get(), line, true);
   sb_error.SetError(err);
   return LLDB_RECORD_RESULT(sb_error);
 }
 
 SBError SBThread::ReturnFromFrame(SBFrame &frame, SBValue &return_value) {
   LLDB_RECORD_METHOD(lldb::SBError, SBThread, ReturnFromFrame,
                      (lldb::SBFrame &, lldb::SBValue &), frame, return_value);
 
   SBError sb_error;
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
-  if (log)
-    log->Printf("SBThread(%p)::ReturnFromFrame (frame=%d)",
-                static_cast<void *>(exe_ctx.GetThreadPtr()),
-                frame.GetFrameID());
-
   if (exe_ctx.HasThreadScope()) {
     Thread *thread = exe_ctx.GetThreadPtr();
     sb_error.SetError(
         thread->ReturnFromFrame(frame.GetFrameSP(), return_value.GetSP()));
   }
 
   return LLDB_RECORD_RESULT(sb_error);
 }
 
 SBError SBThread::UnwindInnermostExpression() {
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBThread,
                              UnwindInnermostExpression);
 
   SBError sb_error;
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
-  if (log)
-    log->Printf("SBThread(%p)::UnwindExpressionEvaluation",
-                static_cast<void *>(exe_ctx.GetThreadPtr()));
-
   if (exe_ctx.HasThreadScope()) {
     Thread *thread = exe_ctx.GetThreadPtr();
     sb_error.SetError(thread->UnwindInnermostExpression());
     if (sb_error.Success())
       thread->SetSelectedFrameByIndex(0, false);
   }
 
   return LLDB_RECORD_RESULT(sb_error);
 }
 
 bool SBThread::Suspend() {
   LLDB_RECORD_METHOD_NO_ARGS(bool, SBThread, Suspend);
 
   SBError error; // Ignored
   return Suspend(error);
 }
 
 bool SBThread::Suspend(SBError &error) {
   LLDB_RECORD_METHOD(bool, SBThread, Suspend, (lldb::SBError &), error);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
   bool result = false;
   if (exe_ctx.HasThreadScope()) {
     Process::StopLocker stop_locker;
     if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock())) {
       exe_ctx.GetThreadPtr()->SetResumeState(eStateSuspended);
       result = true;
     } else {
       error.SetErrorString("process is running");
-      if (log)
-        log->Printf("SBThread(%p)::Suspend() => error: process is running",
-                    static_cast<void *>(exe_ctx.GetThreadPtr()));
     }
   } else
     error.SetErrorString("this SBThread object is invalid");
-  if (log)
-    log->Printf("SBThread(%p)::Suspend() => %i",
-                static_cast<void *>(exe_ctx.GetThreadPtr()), result);
   return result;
 }
 
 bool SBThread::Resume() {
   LLDB_RECORD_METHOD_NO_ARGS(bool, SBThread, Resume);
 
   SBError error; // Ignored
   return Resume(error);
 }
 
 bool SBThread::Resume(SBError &error) {
   LLDB_RECORD_METHOD(bool, SBThread, Resume, (lldb::SBError &), error);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
   bool result = false;
   if (exe_ctx.HasThreadScope()) {
     Process::StopLocker stop_locker;
     if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock())) {
       const bool override_suspend = true;
       exe_ctx.GetThreadPtr()->SetResumeState(eStateRunning, override_suspend);
       result = true;
     } else {
       error.SetErrorString("process is running");
-      if (log)
-        log->Printf("SBThread(%p)::Resume() => error: process is running",
-                    static_cast<void *>(exe_ctx.GetThreadPtr()));
     }
   } else
     error.SetErrorString("this SBThread object is invalid");
-  if (log)
-    log->Printf("SBThread(%p)::Resume() => %i",
-                static_cast<void *>(exe_ctx.GetThreadPtr()), result);
   return result;
 }
 
 bool SBThread::IsSuspended() {
   LLDB_RECORD_METHOD_NO_ARGS(bool, SBThread, IsSuspended);
 
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
SBProcess SBThread::GetProcess() {
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
   if (exe_ctx.HasThreadScope()) {
     // Have to go up to the target so we can get a shared pointer to our
     // process...
     sb_process.SetSP(exe_ctx.GetProcessSP());
   }
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  if (log) {
-    SBStream frame_desc_strm;
-    sb_process.GetDescription(frame_desc_strm);
-    log->Printf("SBThread(%p)::GetProcess () => SBProcess(%p): %s",
-                static_cast<void *>(exe_ctx.GetThreadPtr()),
-                static_cast<void *>(sb_process.GetSP().get()),
-                frame_desc_strm.GetData());
-  }
-
   return LLDB_RECORD_RESULT(sb_process);
 }
 
 uint32_t SBThread::GetNumFrames() {
   LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBThread, GetNumFrames);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-
   uint32_t num_frames = 0;
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
   if (exe_ctx.HasThreadScope()) {
     Process::StopLocker stop_locker;
     if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock())) {
       num_frames = exe_ctx.GetThreadPtr()->GetStackFrameCount();
-    } else {
-      if (log)
-        log->Printf("SBThread(%p)::GetNumFrames() => error: process is running",
-                    static_cast<void *>(exe_ctx.GetThreadPtr()));
     }
   }
 
-  if (log)
-    log->Printf("SBThread(%p)::GetNumFrames () => %u",
-                static_cast<void *>(exe_ctx.GetThreadPtr()), num_frames);
-
   return num_frames;
 }
 
 SBFrame SBThread::GetFrameAtIndex(uint32_t idx) {
   LLDB_RECORD_METHOD(lldb::SBFrame, SBThread, GetFrameAtIndex, (uint32_t), idx);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-
   SBFrame sb_frame;
   StackFrameSP frame_sp;
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
   if (exe_ctx.HasThreadScope()) {
     Process::StopLocker stop_locker;
     if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock())) {
       frame_sp = exe_ctx.GetThreadPtr()->GetStackFrameAtIndex(idx);
       sb_frame.SetFrameSP(frame_sp);
-    } else {
-      if (log)
-        log->Printf(
-            "SBThread(%p)::GetFrameAtIndex() => error: process is running",
-            static_cast<void *>(exe_ctx.GetThreadPtr()));
     }
   }
 
-  if (log) {
-    SBStream frame_desc_strm;
-    sb_frame.GetDescription(frame_desc_strm);
-    log->Printf("SBThread(%p)::GetFrameAtIndex (idx=%d) => SBFrame(%p): %s",
-                static_cast<void *>(exe_ctx.GetThreadPtr()), idx,
-                static_cast<void *>(frame_sp.get()), frame_desc_strm.GetData());
-  }
-
   return LLDB_RECORD_RESULT(sb_frame);
 }
 
 lldb::SBFrame SBThread::GetSelectedFrame() {
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBFrame, SBThread, GetSelectedFrame);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-
   SBFrame sb_frame;
   StackFrameSP frame_sp;
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
   if (exe_ctx.HasThreadScope()) {
     Process::StopLocker stop_locker;
     if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock())) {
       frame_sp = exe_ctx.GetThreadPtr()->GetSelectedFrame();
       sb_frame.SetFrameSP(frame_sp);
-    } else {
-      if (log)
-        log->Printf(
-            "SBThread(%p)::GetSelectedFrame() => error: process is running",
-            static_cast<void *>(exe_ctx.GetThreadPtr()));
     }
   }
 
-  if (log) {
-    SBStream frame_desc_strm;
-    sb_frame.GetDescription(frame_desc_strm);
-    log->Printf("SBThread(%p)::GetSelectedFrame () => SBFrame(%p): %s",
-                static_cast<void *>(exe_ctx.GetThreadPtr()),
-                static_cast<void *>(frame_sp.get()), frame_desc_strm.GetData());
-  }
-
   return LLDB_RECORD_RESULT(sb_frame);
 }
 
 lldb::SBFrame SBThread::SetSelectedFrame(uint32_t idx) {
   LLDB_RECORD_METHOD(lldb::SBFrame, SBThread, SetSelectedFrame, (uint32_t),
                      idx);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-
   SBFrame sb_frame;
   StackFrameSP frame_sp;
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
   if (exe_ctx.HasThreadScope()) {
     Process::StopLocker stop_locker;
     if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock())) {
       Thread *thread = exe_ctx.GetThreadPtr();
       frame_sp = thread->GetStackFrameAtIndex(idx);
       if (frame_sp) {
         thread->SetSelectedFrame(frame_sp.get());
         sb_frame.SetFrameSP(frame_sp);
       }
-    } else {
-      if (log)
-        log->Printf(
-            "SBThread(%p)::SetSelectedFrame() => error: process is running",
-            static_cast<void *>(exe_ctx.GetThreadPtr()));
     }
   }
 
-  if (log) {
-    SBStream frame_desc_strm;
-    sb_frame.GetDescription(frame_desc_strm);
-    log->Printf("SBThread(%p)::SetSelectedFrame (idx=%u) => SBFrame(%p): %s",
-                static_cast<void *>(exe_ctx.GetThreadPtr()), idx,
-                static_cast<void *>(frame_sp.get()), frame_desc_strm.GetData());
-  }
   return LLDB_RECORD_RESULT(sb_frame);
 }
 
 bool SBThread::EventIsThreadEvent(const SBEvent &event) {
   LLDB_RECORD_STATIC_METHOD(bool, SBThread, EventIsThreadEvent,
                             (const lldb::SBEvent &), event);
 
   return Thread::ThreadEventData::GetEventDataFromEvent(event.get()) != NULL;
bool SBThread::GetDescription(SBStream &description, bool stop_format) const {
 
   return true;
 }
 
 SBThread SBThread::GetExtendedBacktraceThread(const char *type) {
   LLDB_RECORD_METHOD(lldb::SBThread, SBThread, GetExtendedBacktraceThread,
                      (const char *), type);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
   SBThread sb_origin_thread;
 
   if (exe_ctx.HasThreadScope()) {
     Process::StopLocker stop_locker;
     if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock())) {
       ThreadSP real_thread(exe_ctx.GetThreadSP());
       if (real_thread) {
         ConstString type_const(type);
         Process *process = exe_ctx.GetProcessPtr();
         if (process) {
           SystemRuntime *runtime = process->GetSystemRuntime();
           if (runtime) {
             ThreadSP new_thread_sp(
                 runtime->GetExtendedBacktraceThread(real_thread, type_const));
             if (new_thread_sp) {
               // Save this in the Process' ExtendedThreadList so a strong
               // pointer retains the object.
               process->GetExtendedThreadList().AddThread(new_thread_sp);
               sb_origin_thread.SetThread(new_thread_sp);
-              if (log) {
-                const char *queue_name = new_thread_sp->GetQueueName();
-                if (queue_name == NULL)
-                  queue_name = "";
-                log->Printf("SBThread(%p)::GetExtendedBacktraceThread() => new "
-                            "extended Thread "
-                            "created (%p) with queue_id 0x%" PRIx64
-                            " queue name '%s'",
-                            static_cast<void *>(exe_ctx.GetThreadPtr()),
-                            static_cast<void *>(new_thread_sp.get()),
-                            new_thread_sp->GetQueueID(), queue_name);
-              }
             }
           }
         }
       }
-    } else {
-      if (log)
-        log->Printf("SBThread(%p)::GetExtendedBacktraceThread() => error: "
-                    "process is running",
-                    static_cast<void *>(exe_ctx.GetThreadPtr()));
     }
   }
 
-  if (log && !sb_origin_thread.IsValid())
-    log->Printf("SBThread(%p)::GetExtendedBacktraceThread() is not returning a "
-                "Valid thread",
-                static_cast<void *>(exe_ctx.GetThreadPtr()));
   return LLDB_RECORD_RESULT(sb_origin_thread);
 }
 
 uint32_t SBThread::GetExtendedBacktraceOriginatingIndexID() {
   LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBThread,
                              GetExtendedBacktraceOriginatingIndexID);
 
   ThreadSP thread_sp(m_opaque_sp->GetThreadSP());

source/API/SBTrace.cpp

 //===-- SBTrace.cpp ---------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "SBReproducerPrivate.h"
 #include "lldb/Target/Process.h"
-#include "lldb/Utility/Log.h"
 
 #include "lldb/API/SBTrace.h"
 #include "lldb/API/SBTraceOptions.h"
 
 #include <memory>
 
 using namespace lldb;
 using namespace lldb_private;
 
 class TraceImpl {
 public:
   lldb::user_id_t uid;
 };
 
 lldb::ProcessSP SBTrace::GetSP() const { return m_opaque_wp.lock(); }
 
 size_t SBTrace::GetTraceData(SBError &error, void *buf, size_t size,
                              size_t offset, lldb::tid_t thread_id) {
   ProcessSP process_sp(GetSP());
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   llvm::MutableArrayRef<uint8_t> buffer(static_cast<uint8_t *>(buf), size);
   error.Clear();
 
   if (!process_sp) {
     error.SetErrorString("invalid process");
   } else {
     error.SetError(
         process_sp->GetData(GetTraceUID(), thread_id, buffer, offset));
-    LLDB_LOG(log, "SBTrace::bytes_read - {0}", buffer.size());
   }
   return buffer.size();
 }
 
 size_t SBTrace::GetMetaData(SBError &error, void *buf, size_t size,
                             size_t offset, lldb::tid_t thread_id) {
   ProcessSP process_sp(GetSP());
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   llvm::MutableArrayRef<uint8_t> buffer(static_cast<uint8_t *>(buf), size);
   error.Clear();
 
   if (!process_sp) {
     error.SetErrorString("invalid process");
   } else {
-
     error.SetError(
         process_sp->GetMetaData(GetTraceUID(), thread_id, buffer, offset));
-    LLDB_LOG(log, "SBTrace::bytes_read - {0}", buffer.size());
   }
   return buffer.size();
 }
 
 void SBTrace::StopTrace(SBError &error, lldb::tid_t thread_id) {
   LLDB_RECORD_METHOD(void, SBTrace, StopTrace, (lldb::SBError &, lldb::tid_t),
                      error, thread_id);
 

source/API/SBType.cpp

 #include "lldb/API/SBDefines.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/API/SBTypeEnumMember.h"
 #include "lldb/Core/Mangled.h"
 #include "lldb/Symbol/CompilerType.h"
 #include "lldb/Symbol/Type.h"
 #include "lldb/Symbol/TypeSystem.h"
 #include "lldb/Utility/ConstString.h"
-#include "lldb/Utility/Log.h"
 #include "lldb/Utility/Stream.h"
 
 #include "llvm/ADT/APSInt.h"
 
 #include <memory>
 
 using namespace lldb;
 using namespace lldb_private;

source/API/SBUnixSignals.cpp

 //===-- SBUnixSignals.cpp -------------------------------------------*- C++
 //-*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "SBReproducerPrivate.h"
 #include "lldb/Target/Platform.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/UnixSignals.h"
-#include "lldb/Utility/Log.h"
 #include "lldb/lldb-defines.h"
 
 #include "lldb/API/SBUnixSignals.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 SBUnixSignals::SBUnixSignals() {
bool SBUnixSignals::GetShouldSuppress(int32_t signo) const {
 
   return false;
 }
 
 bool SBUnixSignals::SetShouldSuppress(int32_t signo, bool value) {
   LLDB_RECORD_METHOD(bool, SBUnixSignals, SetShouldSuppress, (int32_t, bool),
                      signo, value);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   auto signals_sp = GetSP();
 
-  if (log) {
-    log->Printf("SBUnixSignals(%p)::SetShouldSuppress (signo=%d, value=%d)",
-                static_cast<void *>(signals_sp.get()), signo, value);
-  }
-
   if (signals_sp)
     return signals_sp->SetShouldSuppress(signo, value);
 
   return false;
 }
 
 bool SBUnixSignals::GetShouldStop(int32_t signo) const {
   LLDB_RECORD_METHOD_CONST(bool, SBUnixSignals, GetShouldStop, (int32_t),
                            signo);
 
   if (auto signals_sp = GetSP())
     return signals_sp->GetShouldStop(signo);
 
   return false;
 }
 
 bool SBUnixSignals::SetShouldStop(int32_t signo, bool value) {
   LLDB_RECORD_METHOD(bool, SBUnixSignals, SetShouldStop, (int32_t, bool), signo,
                      value);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   auto signals_sp = GetSP();
 
-  if (log) {
-    log->Printf("SBUnixSignals(%p)::SetShouldStop (signo=%d, value=%d)",
-                static_cast<void *>(signals_sp.get()), signo, value);
-  }
-
   if (signals_sp)
     return signals_sp->SetShouldStop(signo, value);
 
   return false;
 }
 
 bool SBUnixSignals::GetShouldNotify(int32_t signo) const {
   LLDB_RECORD_METHOD_CONST(bool, SBUnixSignals, GetShouldNotify, (int32_t),
                            signo);
 
   if (auto signals_sp = GetSP())
     return signals_sp->GetShouldNotify(signo);
 
   return false;
 }
 
 bool SBUnixSignals::SetShouldNotify(int32_t signo, bool value) {
   LLDB_RECORD_METHOD(bool, SBUnixSignals, SetShouldNotify, (int32_t, bool),
                      signo, value);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   auto signals_sp = GetSP();
 
-  if (log) {
-    log->Printf("SBUnixSignals(%p)::SetShouldNotify (signo=%d, value=%d)",
-                static_cast<void *>(signals_sp.get()), signo, value);
-  }
-
   if (signals_sp)
     return signals_sp->SetShouldNotify(signo, value);
 
   return false;
 }
 
 int32_t SBUnixSignals::GetNumSignals() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(int32_t, SBUnixSignals, GetNumSignals);

source/API/SBValue.cpp

 #include "lldb/Symbol/Variable.h"
 #include "lldb/Symbol/VariableList.h"
 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/StackFrame.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/DataExtractor.h"
-#include "lldb/Utility/Log.h"
 #include "lldb/Utility/Scalar.h"
 #include "lldb/Utility/Stream.h"
 
 #include "lldb/API/SBDebugger.h"
 #include "lldb/API/SBExpressionOptions.h"
 #include "lldb/API/SBFrame.h"
 #include "lldb/API/SBProcess.h"
 #include "lldb/API/SBTarget.h"
bool IsValid() {
     }
   }
 
   lldb::ValueObjectSP GetRootSP() { return m_valobj_sp; }
 
   lldb::ValueObjectSP GetSP(Process::StopLocker &stop_locker,
                             std::unique_lock<std::recursive_mutex> &lock,
                             Status &error) {
-    Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
     if (!m_valobj_sp) {
       error.SetErrorString("invalid value object");
       return m_valobj_sp;
     }
 
     lldb::ValueObjectSP value_sp = m_valobj_sp;
 
     Target *target = value_sp->GetTargetSP().get();
     if (!target)
       return ValueObjectSP();
 
     lock = std::unique_lock<std::recursive_mutex>(target->GetAPIMutex());
 
     ProcessSP process_sp(value_sp->GetProcessSP());
     if (process_sp && !stop_locker.TryLock(&process_sp->GetRunLock())) {
       // We don't allow people to play around with ValueObject if the process
       // is running. If you want to look at values, pause the process, then
       // look.
-      if (log)
-        log->Printf("SBValue(%p)::GetSP() => error: process is running",
-                    static_cast<void *>(value_sp.get()));
       error.SetErrorString("process must be stopped.");
       return ValueObjectSP();
     }
 
     if (m_use_dynamic != eNoDynamicValues) {
       ValueObjectSP dynamic_sp = value_sp->GetDynamicValue(m_use_dynamic);
       if (dynamic_sp)
         value_sp = dynamic_sp;
const char *SBValue::GetName() {
   LLDB_RECORD_METHOD_NO_ARGS(const char *, SBValue, GetName);
 
   const char *name = NULL;
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));
   if (value_sp)
     name = value_sp->GetName().GetCString();
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  if (log) {
-    if (name)
-      log->Printf("SBValue(%p)::GetName () => \"%s\"",
-                  static_cast<void *>(value_sp.get()), name);
-    else
-      log->Printf("SBValue(%p)::GetName () => NULL",
-                  static_cast<void *>(value_sp.get()));
-  }
-
   return name;
 }
 
 const char *SBValue::GetTypeName() {
   LLDB_RECORD_METHOD_NO_ARGS(const char *, SBValue, GetTypeName);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   const char *name = NULL;
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));
   if (value_sp) {
     name = value_sp->GetQualifiedTypeName().GetCString();
   }
 
-  if (log) {
-    if (name)
-      log->Printf("SBValue(%p)::GetTypeName () => \"%s\"",
-                  static_cast<void *>(value_sp.get()), name);
-    else
-      log->Printf("SBValue(%p)::GetTypeName () => NULL",
-                  static_cast<void *>(value_sp.get()));
-  }
-
   return name;
 }
 
 const char *SBValue::GetDisplayTypeName() {
   LLDB_RECORD_METHOD_NO_ARGS(const char *, SBValue, GetDisplayTypeName);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   const char *name = NULL;
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));
   if (value_sp) {
     name = value_sp->GetDisplayTypeName().GetCString();
   }
 
-  if (log) {
-    if (name)
-      log->Printf("SBValue(%p)::GetTypeName () => \"%s\"",
-                  static_cast<void *>(value_sp.get()), name);
-    else
-      log->Printf("SBValue(%p)::GetTypeName () => NULL",
-                  static_cast<void *>(value_sp.get()));
-  }
-
   return name;
 }
 
 size_t SBValue::GetByteSize() {
   LLDB_RECORD_METHOD_NO_ARGS(size_t, SBValue, GetByteSize);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   size_t result = 0;
 
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));
   if (value_sp) {
     result = value_sp->GetByteSize();
   }
 
-  if (log)
-    log->Printf("SBValue(%p)::GetByteSize () => %" PRIu64,
-                static_cast<void *>(value_sp.get()),
-                static_cast<uint64_t>(result));
-
   return result;
 }
 
 bool SBValue::IsInScope() {
   LLDB_RECORD_METHOD_NO_ARGS(bool, SBValue, IsInScope);
 
   bool result = false;
 
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));
   if (value_sp) {
     result = value_sp->IsInScope();
   }
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  if (log)
-    log->Printf("SBValue(%p)::IsInScope () => %i",
-                static_cast<void *>(value_sp.get()), result);
-
   return result;
 }
 
 const char *SBValue::GetValue() {
   LLDB_RECORD_METHOD_NO_ARGS(const char *, SBValue, GetValue);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-
   const char *cstr = NULL;
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));
   if (value_sp) {
     cstr = value_sp->GetValueAsCString();
   }
-  if (log) {
-    if (cstr)
-      log->Printf("SBValue(%p)::GetValue() => \"%s\"",
-                  static_cast<void *>(value_sp.get()), cstr);
-    else
-      log->Printf("SBValue(%p)::GetValue() => NULL",
-                  static_cast<void *>(value_sp.get()));
-  }
 
   return cstr;
 }
 
 ValueType SBValue::GetValueType() {
   LLDB_RECORD_METHOD_NO_ARGS(lldb::ValueType, SBValue, GetValueType);
 
   ValueType result = eValueTypeInvalid;
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));
   if (value_sp)
     result = value_sp->GetValueType();
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  if (log) {
-    switch (result) {
-    case eValueTypeInvalid:
-      log->Printf("SBValue(%p)::GetValueType () => eValueTypeInvalid",
-                  static_cast<void *>(value_sp.get()));
-      break;
-    case eValueTypeVariableGlobal:
-      log->Printf("SBValue(%p)::GetValueType () => eValueTypeVariableGlobal",
-                  static_cast<void *>(value_sp.get()));
-      break;
-    case eValueTypeVariableStatic:
-      log->Printf("SBValue(%p)::GetValueType () => eValueTypeVariableStatic",
-                  static_cast<void *>(value_sp.get()));
-      break;
-    case eValueTypeVariableArgument:
-      log->Printf("SBValue(%p)::GetValueType () => eValueTypeVariableArgument",
-                  static_cast<void *>(value_sp.get()));
-      break;
-    case eValueTypeVariableLocal:
-      log->Printf("SBValue(%p)::GetValueType () => eValueTypeVariableLocal",
-                  static_cast<void *>(value_sp.get()));
-      break;
-    case eValueTypeRegister:
-      log->Printf("SBValue(%p)::GetValueType () => eValueTypeRegister",
-                  static_cast<void *>(value_sp.get()));
-      break;
-    case eValueTypeRegisterSet:
-      log->Printf("SBValue(%p)::GetValueType () => eValueTypeRegisterSet",
-                  static_cast<void *>(value_sp.get()));
-      break;
-    case eValueTypeConstResult:
-      log->Printf("SBValue(%p)::GetValueType () => eValueTypeConstResult",
-                  static_cast<void *>(value_sp.get()));
-      break;
-    case eValueTypeVariableThreadLocal:
-      log->Printf(
-          "SBValue(%p)::GetValueType () => eValueTypeVariableThreadLocal",
-          static_cast<void *>(value_sp.get()));
-      break;
-    }
-  }
   return result;
 }
 
 const char *SBValue::GetObjectDescription() {
   LLDB_RECORD_METHOD_NO_ARGS(const char *, SBValue, GetObjectDescription);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   const char *cstr = NULL;
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));
   if (value_sp) {
     cstr = value_sp->GetObjectDescription();
   }
-  if (log) {
-    if (cstr)
-      log->Printf("SBValue(%p)::GetObjectDescription() => \"%s\"",
-                  static_cast<void *>(value_sp.get()), cstr);
-    else
-      log->Printf("SBValue(%p)::GetObjectDescription() => NULL",
-                  static_cast<void *>(value_sp.get()));
-  }
+
   return cstr;
 }
 
 const char *SBValue::GetTypeValidatorResult() {
   LLDB_RECORD_METHOD_NO_ARGS(const char *, SBValue, GetTypeValidatorResult);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   const char *cstr = NULL;
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));
   if (value_sp) {
     const auto &validation(value_sp->GetValidationStatus());
     if (TypeValidatorResult::Failure == validation.first) {
       if (validation.second.empty())
         cstr = "unknown error";
       else
         cstr = validation.second.c_str();
     }
   }
-  if (log) {
-    if (cstr)
-      log->Printf("SBValue(%p)::GetTypeValidatorResult() => \"%s\"",
-                  static_cast<void *>(value_sp.get()), cstr);
-    else
-      log->Printf("SBValue(%p)::GetTypeValidatorResult() => NULL",
-                  static_cast<void *>(value_sp.get()));
-  }
+
   return cstr;
 }
 
 SBType SBValue::GetType() {
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBValue, GetType);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   SBType sb_type;
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));
   TypeImplSP type_sp;
   if (value_sp) {
     type_sp = std::make_shared<TypeImpl>(value_sp->GetTypeImpl());
     sb_type.SetSP(type_sp);
   }
-  if (log) {
-    if (type_sp)
-      log->Printf("SBValue(%p)::GetType => SBType(%p)",
-                  static_cast<void *>(value_sp.get()),
-                  static_cast<void *>(type_sp.get()));
-    else
-      log->Printf("SBValue(%p)::GetType => NULL",
-                  static_cast<void *>(value_sp.get()));
-  }
+
   return LLDB_RECORD_RESULT(sb_type);
 }
 
 bool SBValue::GetValueDidChange() {
   LLDB_RECORD_METHOD_NO_ARGS(bool, SBValue, GetValueDidChange);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   bool result = false;
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));
   if (value_sp) {
     if (value_sp->UpdateValueIfNeeded(false))
       result = value_sp->GetValueDidChange();
   }
-  if (log)
-    log->Printf("SBValue(%p)::GetValueDidChange() => %i",
-                static_cast<void *>(value_sp.get()), result);
 
   return result;
 }
 
 const char *SBValue::GetSummary() {
   LLDB_RECORD_METHOD_NO_ARGS(const char *, SBValue, GetSummary);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   const char *cstr = NULL;
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));
   if (value_sp) {
     cstr = value_sp->GetSummaryAsCString();
   }
-  if (log) {
-    if (cstr)
-      log->Printf("SBValue(%p)::GetSummary() => \"%s\"",
-                  static_cast<void *>(value_sp.get()), cstr);
-    else
-      log->Printf("SBValue(%p)::GetSummary() => NULL",
-                  static_cast<void *>(value_sp.get()));
-  }
+
   return cstr;
 }
 
 const char *SBValue::GetSummary(lldb::SBStream &stream,
                                 lldb::SBTypeSummaryOptions &options) {
   LLDB_RECORD_METHOD(const char *, SBValue, GetSummary,
                      (lldb::SBStream &, lldb::SBTypeSummaryOptions &), stream,
                      options);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));
   if (value_sp) {
     std::string buffer;
     if (value_sp->GetSummaryAsCString(buffer, options.ref()) && !buffer.empty())
       stream.Printf("%s", buffer.c_str());
   }
   const char *cstr = stream.GetData();
-  if (log) {
-    if (cstr)
-      log->Printf("SBValue(%p)::GetSummary() => \"%s\"",
-                  static_cast<void *>(value_sp.get()), cstr);
-    else
-      log->Printf("SBValue(%p)::GetSummary() => NULL",
-                  static_cast<void *>(value_sp.get()));
-  }
   return cstr;
 }
 
 const char *SBValue::GetLocation() {
   LLDB_RECORD_METHOD_NO_ARGS(const char *, SBValue, GetLocation);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   const char *cstr = NULL;
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));
   if (value_sp) {
     cstr = value_sp->GetLocationAsCString();
   }
-  if (log) {
-    if (cstr)
-      log->Printf("SBValue(%p)::GetLocation() => \"%s\"",
-                  static_cast<void *>(value_sp.get()), cstr);
-    else
-      log->Printf("SBValue(%p)::GetLocation() => NULL",
-                  static_cast<void *>(value_sp.get()));
-  }
   return cstr;
 }
 
 // Deprecated - use the one that takes an lldb::SBError
 bool SBValue::SetValueFromCString(const char *value_str) {
   LLDB_RECORD_METHOD(bool, SBValue, SetValueFromCString, (const char *),
                      value_str);
 
   lldb::SBError dummy;
   return SetValueFromCString(value_str, dummy);
 }
 
 bool SBValue::SetValueFromCString(const char *value_str, lldb::SBError &error) {
   LLDB_RECORD_METHOD(bool, SBValue, SetValueFromCString,
                      (const char *, lldb::SBError &), value_str, error);
 
   bool success = false;
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   if (value_sp) {
     success = value_sp->SetValueFromCString(value_str, error.ref());
   } else
     error.SetErrorStringWithFormat("Could not get value: %s",
                                    locker.GetError().AsCString());
 
-  if (log)
-    log->Printf("SBValue(%p)::SetValueFromCString(\"%s\") => %i",
-                static_cast<void *>(value_sp.get()), value_str, success);
-
   return success;
 }
 
 lldb::SBTypeFormat SBValue::GetTypeFormat() {
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTypeFormat, SBValue, GetTypeFormat);
 
   lldb::SBTypeFormat format;
   ValueLocker locker;
lldb::SBValue SBValue::CreateChildAtOffset(const char *name, uint32_t offset,
   if (value_sp) {
     TypeImplSP type_sp(type.GetSP());
     if (type.IsValid()) {
       sb_value.SetSP(value_sp->GetSyntheticChildAtOffset(
                          offset, type_sp->GetCompilerType(false), true),
                      GetPreferDynamicValue(), GetPreferSyntheticValue(), name);
     }
   }
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  if (log) {
-    if (new_value_sp)
-      log->Printf("SBValue(%p)::CreateChildAtOffset => \"%s\"",
-                  static_cast<void *>(value_sp.get()),
-                  new_value_sp->GetName().AsCString());
-    else
-      log->Printf("SBValue(%p)::CreateChildAtOffset => NULL",
-                  static_cast<void *>(value_sp.get()));
-  }
   return LLDB_RECORD_RESULT(sb_value);
 }
 
 lldb::SBValue SBValue::Cast(SBType type) {
   LLDB_RECORD_METHOD(lldb::SBValue, SBValue, Cast, (lldb::SBType), type);
 
   lldb::SBValue sb_value;
   ValueLocker locker;

 
 lldb::SBValue SBValue::CreateValueFromExpression(const char *name,
                                                  const char *expression,
                                                  SBExpressionOptions &options) {
   LLDB_RECORD_METHOD(lldb::SBValue, SBValue, CreateValueFromExpression,
                      (const char *, const char *, lldb::SBExpressionOptions &),
                      name, expression, options);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   lldb::SBValue sb_value;
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));
   lldb::ValueObjectSP new_value_sp;
   if (value_sp) {
     ExecutionContext exe_ctx(value_sp->GetExecutionContextRef());
     new_value_sp = ValueObject::CreateValueObjectFromExpression(
         name, expression, exe_ctx, options.ref());
     if (new_value_sp)
       new_value_sp->SetName(ConstString(name));
   }
   sb_value.SetSP(new_value_sp);
-  if (log) {
-    if (new_value_sp)
-      log->Printf("SBValue(%p)::CreateValueFromExpression(name=\"%s\", "
-                  "expression=\"%s\") => SBValue (%p)",
-                  static_cast<void *>(value_sp.get()), name, expression,
-                  static_cast<void *>(new_value_sp.get()));
-    else
-      log->Printf("SBValue(%p)::CreateValueFromExpression(name=\"%s\", "
-                  "expression=\"%s\") => NULL",
-                  static_cast<void *>(value_sp.get()), name, expression);
-  }
   return LLDB_RECORD_RESULT(sb_value);
 }
 
 lldb::SBValue SBValue::CreateValueFromAddress(const char *name,
                                               lldb::addr_t address,
                                               SBType sb_type) {
   LLDB_RECORD_METHOD(lldb::SBValue, SBValue, CreateValueFromAddress,
                      (const char *, lldb::addr_t, lldb::SBType), name, address,
                      sb_type);
 
   lldb::SBValue sb_value;
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));
   lldb::ValueObjectSP new_value_sp;
   lldb::TypeImplSP type_impl_sp(sb_type.GetSP());
   if (value_sp && type_impl_sp) {
     CompilerType ast_type(type_impl_sp->GetCompilerType(true));
     ExecutionContext exe_ctx(value_sp->GetExecutionContextRef());
     new_value_sp = ValueObject::CreateValueObjectFromAddress(name, address,
                                                              exe_ctx, ast_type);
   }
   sb_value.SetSP(new_value_sp);
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  if (log) {
-    if (new_value_sp)
-      log->Printf("SBValue(%p)::CreateValueFromAddress => \"%s\"",
-                  static_cast<void *>(value_sp.get()),
-                  new_value_sp->GetName().AsCString());
-    else
-      log->Printf("SBValue(%p)::CreateValueFromAddress => NULL",
-                  static_cast<void *>(value_sp.get()));
-  }
   return LLDB_RECORD_RESULT(sb_value);
 }
 
 lldb::SBValue SBValue::CreateValueFromData(const char *name, SBData data,
                                            SBType sb_type) {
   LLDB_RECORD_METHOD(lldb::SBValue, SBValue, CreateValueFromData,
                      (const char *, lldb::SBData, lldb::SBType), name, data,
                      sb_type);
 
   lldb::SBValue sb_value;
   lldb::ValueObjectSP new_value_sp;
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));
   lldb::TypeImplSP type_impl_sp(sb_type.GetSP());
   if (value_sp && type_impl_sp) {
     ExecutionContext exe_ctx(value_sp->GetExecutionContextRef());
     new_value_sp = ValueObject::CreateValueObjectFromData(
         name, **data, exe_ctx, type_impl_sp->GetCompilerType(true));
     new_value_sp->SetAddressTypeOfChildren(eAddressTypeLoad);
   }
   sb_value.SetSP(new_value_sp);
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  if (log) {
-    if (new_value_sp)
-      log->Printf("SBValue(%p)::CreateValueFromData => \"%s\"",
-                  static_cast<void *>(value_sp.get()),
-                  new_value_sp->GetName().AsCString());
-    else
-      log->Printf("SBValue(%p)::CreateValueFromData => NULL",
-                  static_cast<void *>(value_sp.get()));
-  }
   return LLDB_RECORD_RESULT(sb_value);
 }
 
 SBValue SBValue::GetChildAtIndex(uint32_t idx) {
   LLDB_RECORD_METHOD(lldb::SBValue, SBValue, GetChildAtIndex, (uint32_t), idx);
 
   const bool can_create_synthetic = false;
   lldb::DynamicValueType use_dynamic = eNoDynamicValues;

 SBValue SBValue::GetChildAtIndex(uint32_t idx,
                                  lldb::DynamicValueType use_dynamic,
                                  bool can_create_synthetic) {
   LLDB_RECORD_METHOD(lldb::SBValue, SBValue, GetChildAtIndex,
                      (uint32_t, lldb::DynamicValueType, bool), idx, use_dynamic,
                      can_create_synthetic);
 
   lldb::ValueObjectSP child_sp;
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));
   if (value_sp) {
     const bool can_create = true;
     child_sp = value_sp->GetChildAtIndex(idx, can_create);
     if (can_create_synthetic && !child_sp) {
       child_sp = value_sp->GetSyntheticArrayMember(idx, can_create);
     }
   }
 
   SBValue sb_value;
   sb_value.SetSP(child_sp, use_dynamic, GetPreferSyntheticValue());
-  if (log)
-    log->Printf("SBValue(%p)::GetChildAtIndex (%u) => SBValue(%p)",
-                static_cast<void *>(value_sp.get()), idx,
-                static_cast<void *>(value_sp.get()));
 
   return LLDB_RECORD_RESULT(sb_value);
 }
 
 uint32_t SBValue::GetIndexOfChildWithName(const char *name) {
   LLDB_RECORD_METHOD(uint32_t, SBValue, GetIndexOfChildWithName, (const char *),
                      name);
 
   uint32_t idx = UINT32_MAX;
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));
   if (value_sp) {
     idx = value_sp->GetIndexOfChildWithName(ConstString(name));
   }
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  if (log) {
-    if (idx == UINT32_MAX)
-      log->Printf(
-          "SBValue(%p)::GetIndexOfChildWithName (name=\"%s\") => NOT FOUND",
-          static_cast<void *>(value_sp.get()), name);
-    else
-      log->Printf("SBValue(%p)::GetIndexOfChildWithName (name=\"%s\") => %u",
-                  static_cast<void *>(value_sp.get()), name, idx);
-  }
   return idx;
 }
 
 SBValue SBValue::GetChildMemberWithName(const char *name) {
   LLDB_RECORD_METHOD(lldb::SBValue, SBValue, GetChildMemberWithName,
                      (const char *), name);
 
   lldb::DynamicValueType use_dynamic_value = eNoDynamicValues;
SBValue::GetChildMemberWithName(const char *name,
                                 lldb::DynamicValueType use_dynamic_value) {
   LLDB_RECORD_METHOD(lldb::SBValue, SBValue, GetChildMemberWithName,
                      (const char *, lldb::DynamicValueType), name,
                      use_dynamic_value);
 
   lldb::ValueObjectSP child_sp;
   const ConstString str_name(name);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));
   if (value_sp) {
     child_sp = value_sp->GetChildMemberWithName(str_name, true);
   }
 
   SBValue sb_value;
   sb_value.SetSP(child_sp, use_dynamic_value, GetPreferSyntheticValue());
 
-  if (log)
-    log->Printf(
-        "SBValue(%p)::GetChildMemberWithName (name=\"%s\") => SBValue(%p)",
-        static_cast<void *>(value_sp.get()), name,
-        static_cast<void *>(value_sp.get()));
-
   return LLDB_RECORD_RESULT(sb_value);
 }
 
 lldb::SBValue SBValue::GetDynamicValue(lldb::DynamicValueType use_dynamic) {
   LLDB_RECORD_METHOD(lldb::SBValue, SBValue, GetDynamicValue,
                      (lldb::DynamicValueType), use_dynamic);
 
   SBValue value_sb;
void SBValue::SetSyntheticChildrenGenerated(bool is) {
   if (value_sp)
     return value_sp->SetSyntheticChildrenGenerated(is);
 }
 
 lldb::SBValue SBValue::GetValueForExpressionPath(const char *expr_path) {
   LLDB_RECORD_METHOD(lldb::SBValue, SBValue, GetValueForExpressionPath,
                      (const char *), expr_path);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   lldb::ValueObjectSP child_sp;
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));
   if (value_sp) {
     // using default values for all the fancy options, just do it if you can
     child_sp = value_sp->GetValueForExpressionPath(expr_path);
   }
 
   SBValue sb_value;
   sb_value.SetSP(child_sp, GetPreferDynamicValue(), GetPreferSyntheticValue());
 
-  if (log)
-    log->Printf("SBValue(%p)::GetValueForExpressionPath (expr_path=\"%s\") => "
-                "SBValue(%p)",
-                static_cast<void *>(value_sp.get()), expr_path,
-                static_cast<void *>(value_sp.get()));
-
   return LLDB_RECORD_RESULT(sb_value);
 }
 
 int64_t SBValue::GetValueAsSigned(SBError &error, int64_t fail_value) {
   LLDB_RECORD_METHOD(int64_t, SBValue, GetValueAsSigned,
                      (lldb::SBError &, int64_t), error, fail_value);
 
   error.Clear();
if (value_sp) {
     return value_sp->GetValueAsUnsigned(fail_value);
   }
   return fail_value;
 }
 
 bool SBValue::MightHaveChildren() {
   LLDB_RECORD_METHOD_NO_ARGS(bool, SBValue, MightHaveChildren);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   bool has_children = false;
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));
   if (value_sp)
     has_children = value_sp->MightHaveChildren();
 
-  if (log)
-    log->Printf("SBValue(%p)::MightHaveChildren() => %i",
-                static_cast<void *>(value_sp.get()), has_children);
   return has_children;
 }
 
 bool SBValue::IsRuntimeSupportValue() {
   LLDB_RECORD_METHOD_NO_ARGS(bool, SBValue, IsRuntimeSupportValue);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   bool is_support = false;
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));
   if (value_sp)
     is_support = value_sp->IsRuntimeSupportValue();
 
-  if (log)
-    log->Printf("SBValue(%p)::IsRuntimeSupportValue() => %i",
-                static_cast<void *>(value_sp.get()), is_support);
   return is_support;
 }
 
 uint32_t SBValue::GetNumChildren() {
   LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBValue, GetNumChildren);
 
   return GetNumChildren(UINT32_MAX);
 }
 
 uint32_t SBValue::GetNumChildren(uint32_t max) {
   LLDB_RECORD_METHOD(uint32_t, SBValue, GetNumChildren, (uint32_t), max);
 
   uint32_t num_children = 0;
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));
   if (value_sp)
     num_children = value_sp->GetNumChildren(max);
 
-  if (log)
-    log->Printf("SBValue(%p)::GetNumChildren (%u) => %u",
-                static_cast<void *>(value_sp.get()), max, num_children);
-
   return num_children;
 }
 
 SBValue SBValue::Dereference() {
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBValue, SBValue, Dereference);
 
   SBValue sb_value;
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));
   if (value_sp) {
     Status error;
     sb_value = value_sp->Dereference(error);
   }
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  if (log)
-    log->Printf("SBValue(%p)::Dereference () => SBValue(%p)",
-                static_cast<void *>(value_sp.get()),
-                static_cast<void *>(value_sp.get()));
 
   return LLDB_RECORD_RESULT(sb_value);
 }
 
 // Deprecated - please use GetType().IsPointerType() instead.
 bool SBValue::TypeIsPointerType() {
   LLDB_RECORD_METHOD_NO_ARGS(bool, SBValue, TypeIsPointerType);
 
lldb::SBTarget SBValue::GetTarget() {
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTarget, SBValue, GetTarget);
 
   SBTarget sb_target;
   TargetSP target_sp;
   if (m_opaque_sp) {
     target_sp = m_opaque_sp->GetTargetSP();
     sb_target.SetSP(target_sp);
   }
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  if (log) {
-    if (target_sp.get() == NULL)
-      log->Printf("SBValue(%p)::GetTarget () => NULL",
-                  static_cast<void *>(m_opaque_sp.get()));
-    else
-      log->Printf("SBValue(%p)::GetTarget () => %p",
-                  static_cast<void *>(m_opaque_sp.get()),
-                  static_cast<void *>(target_sp.get()));
-  }
+
   return LLDB_RECORD_RESULT(sb_target);
 }
 
 lldb::SBProcess SBValue::GetProcess() {
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBProcess, SBValue, GetProcess);
 
   SBProcess sb_process;
   ProcessSP process_sp;
   if (m_opaque_sp) {
     process_sp = m_opaque_sp->GetProcessSP();
     sb_process.SetSP(process_sp);
   }
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  if (log) {
-    if (process_sp.get() == NULL)
-      log->Printf("SBValue(%p)::GetProcess () => NULL",
-                  static_cast<void *>(m_opaque_sp.get()));
-    else
-      log->Printf("SBValue(%p)::GetProcess () => %p",
-                  static_cast<void *>(m_opaque_sp.get()),
-                  static_cast<void *>(process_sp.get()));
-  }
+
   return LLDB_RECORD_RESULT(sb_process);
 }
 
 lldb::SBThread SBValue::GetThread() {
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBThread, SBValue, GetThread);
 
   SBThread sb_thread;
   ThreadSP thread_sp;
   if (m_opaque_sp) {
     thread_sp = m_opaque_sp->GetThreadSP();
     sb_thread.SetThread(thread_sp);
   }
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  if (log) {
-    if (thread_sp.get() == NULL)
-      log->Printf("SBValue(%p)::GetThread () => NULL",
-                  static_cast<void *>(m_opaque_sp.get()));
-    else
-      log->Printf("SBValue(%p)::GetThread () => %p",
-                  static_cast<void *>(m_opaque_sp.get()),
-                  static_cast<void *>(thread_sp.get()));
-  }
+
   return LLDB_RECORD_RESULT(sb_thread);
 }
 
 lldb::SBFrame SBValue::GetFrame() {
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBFrame, SBValue, GetFrame);
 
   SBFrame sb_frame;
   StackFrameSP frame_sp;
   if (m_opaque_sp) {
     frame_sp = m_opaque_sp->GetFrameSP();
     sb_frame.SetFrameSP(frame_sp);
   }
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  if (log) {
-    if (frame_sp.get() == NULL)
-      log->Printf("SBValue(%p)::GetFrame () => NULL",
-                  static_cast<void *>(m_opaque_sp.get()));
-    else
-      log->Printf("SBValue(%p)::GetFrame () => %p",
-                  static_cast<void *>(m_opaque_sp.get()),
-                  static_cast<void *>(frame_sp.get()));
-  }
+
   return LLDB_RECORD_RESULT(sb_frame);
 }
 
 lldb::ValueObjectSP SBValue::GetSP(ValueLocker &locker) const {
   if (!m_opaque_sp || !m_opaque_sp->IsValid()) {
     locker.GetError().SetErrorString("No value");
     return ValueObjectSP();
   }

 lldb::SBValue SBValue::EvaluateExpression(const char *expr,
                                           const SBExpressionOptions &options,
                                           const char *name) const {
   LLDB_RECORD_METHOD_CONST(
       lldb::SBValue, SBValue, EvaluateExpression,
       (const char *, const lldb::SBExpressionOptions &, const char *), expr,
       options, name);
 
-  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   if (!expr || expr[0] == '\0') {
-    LLDB_LOG(log,
-             "SBValue::EvaluateExpression called with an empty expression");
     return LLDB_RECORD_RESULT(SBValue());
   }
 
-  LLDB_LOG(log, "SBValue()::EvaluateExpression (expr=\"{0}\")...", expr);
 
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));
   if (!value_sp) {
-    LLDB_LOG(log, "SBValue::EvaluateExpression () => error: could not "
-                  "reconstruct value object for this SBValue");
     return LLDB_RECORD_RESULT(SBValue());
   }
 
   lldb::TargetSP target_sp = value_sp->GetTargetSP();
   if (!target_sp) {
-    LLDB_LOG(
-        log,
-        "SBValue::EvaluateExpression () => error: could not retrieve target");
     return LLDB_RECORD_RESULT(SBValue());
   }
 
   std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
   ExecutionContext exe_ctx(target_sp.get());
 
   StackFrame *frame = exe_ctx.GetFramePtr();
   if (!frame) {
-    LLDB_LOG(log, "SBValue::EvaluateExpression () => error: could not retrieve "
-                  "current stack frame");
     return LLDB_RECORD_RESULT(SBValue());
   }
 
   ValueObjectSP res_val_sp;
-  ExpressionResults expr_res = target_sp->EvaluateExpression(
-      expr, frame, res_val_sp, options.ref(), nullptr, value_sp.get());
+  target_sp->EvaluateExpression(expr, frame, res_val_sp, options.ref(), nullptr,
+                                value_sp.get());
 
   if (name)
     res_val_sp->SetName(ConstString(name));
 
-  LLDB_LOG(log,
-           "SBValue(Name=\"{0}\")::EvaluateExpression (expr=\"{1}\") => "
-           "SBValue(Success={2}) (execution result={3})",
-           value_sp->GetName(), expr, res_val_sp->GetError().Success(),
-           expr_res);
-
   SBValue result;
   result.SetSP(res_val_sp, options.GetFetchDynamicValue());
   return LLDB_RECORD_RESULT(result);
 }
 
 bool SBValue::GetDescription(SBStream &description) {
   LLDB_RECORD_METHOD(bool, SBValue, GetDescription, (lldb::SBStream &),
                      description);
lldb::SBValue SBValue::AddressOf() {
   SBValue sb_value;
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));
   if (value_sp) {
     Status error;
     sb_value.SetSP(value_sp->AddressOf(error), GetPreferDynamicValue(),
                    GetPreferSyntheticValue());
   }
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  if (log)
-    log->Printf("SBValue(%p)::AddressOf () => SBValue(%p)",
-                static_cast<void *>(value_sp.get()),
-                static_cast<void *>(value_sp.get()));
 
   return LLDB_RECORD_RESULT(sb_value);
 }
 
 lldb::addr_t SBValue::GetLoadAddress() {
   LLDB_RECORD_METHOD_NO_ARGS(lldb::addr_t, SBValue, GetLoadAddress);
 
   lldb::addr_t value = LLDB_INVALID_ADDRESS;
if (target_sp) {
           module_sp->ResolveFileAddress(value, addr);
           value = addr.GetLoadAddress(target_sp.get());
         }
       } else if (addr_type == eAddressTypeHost ||
                  addr_type == eAddressTypeInvalid)
         value = LLDB_INVALID_ADDRESS;
     }
   }
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  if (log)
-    log->Printf("SBValue(%p)::GetLoadAddress () => (%" PRIu64 ")",
-                static_cast<void *>(value_sp.get()), value);
 
   return value;
 }
 
 lldb::SBAddress SBValue::GetAddress() {
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBAddress, SBValue, GetAddress);
 
   Address addr;
if (target_sp) {
       } else if (addr_type == eAddressTypeLoad) {
         // no need to check the return value on this.. if it can actually do
         // the resolve addr will be in the form (section,offset), otherwise it
         // will simply be returned as (NULL, value)
         addr.SetLoadAddress(value, target_sp.get());
       }
     }
   }
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  if (log)
-    log->Printf("SBValue(%p)::GetAddress () => (%s,%" PRIu64 ")",
-                static_cast<void *>(value_sp.get()),
-                (addr.GetSection() ? addr.GetSection()->GetName().GetCString()
-                                   : "NULL"),
-                addr.GetOffset());
+
   return LLDB_RECORD_RESULT(SBAddress(new Address(addr)));
 }
 
 lldb::SBData SBValue::GetPointeeData(uint32_t item_idx, uint32_t item_count) {
   LLDB_RECORD_METHOD(lldb::SBData, SBValue, GetPointeeData,
                      (uint32_t, uint32_t), item_idx, item_count);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   lldb::SBData sb_data;
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));
   if (value_sp) {
     TargetSP target_sp(value_sp->GetTargetSP());
     if (target_sp) {
       DataExtractorSP data_sp(new DataExtractor());
       value_sp->GetPointeeData(*data_sp, item_idx, item_count);
       if (data_sp->GetByteSize() > 0)
         *sb_data = data_sp;
     }
   }
-  if (log)
-    log->Printf("SBValue(%p)::GetPointeeData (%d, %d) => SBData(%p)",
-                static_cast<void *>(value_sp.get()), item_idx, item_count,
-                static_cast<void *>(sb_data.get()));
 
   return LLDB_RECORD_RESULT(sb_data);
 }
 
 lldb::SBData SBValue::GetData() {
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBData, SBValue, GetData);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   lldb::SBData sb_data;
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));
   if (value_sp) {
     DataExtractorSP data_sp(new DataExtractor());
     Status error;
     value_sp->GetData(*data_sp, error);
     if (error.Success())
       *sb_data = data_sp;
   }
-  if (log)
-    log->Printf("SBValue(%p)::GetData () => SBData(%p)",
-                static_cast<void *>(value_sp.get()),
-                static_cast<void *>(sb_data.get()));
 
   return LLDB_RECORD_RESULT(sb_data);
 }
 
 bool SBValue::SetData(lldb::SBData &data, SBError &error) {
   LLDB_RECORD_METHOD(bool, SBValue, SetData, (lldb::SBData &, lldb::SBError &),
                      data, error);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));
   bool ret = true;
 
   if (value_sp) {
     DataExtractor *data_extractor = data.get();
 
     if (!data_extractor) {
-      if (log)
-        log->Printf("SBValue(%p)::SetData() => error: no data to set",
-                    static_cast<void *>(value_sp.get()));
-
       error.SetErrorString("No data to set");
       ret = false;
     } else {
       Status set_error;
 
       value_sp->SetData(*data_extractor, set_error);
 
       if (!set_error.Success()) {
         error.SetErrorStringWithFormat("Couldn't set data: %s",
                                        set_error.AsCString());
         ret = false;
       }
     }
   } else {
     error.SetErrorStringWithFormat(
         "Couldn't set data: could not get SBValue: %s",
         locker.GetError().AsCString());
     ret = false;
   }
 
-  if (log)
-    log->Printf("SBValue(%p)::SetData (%p) => %s",
-                static_cast<void *>(value_sp.get()),
-                static_cast<void *>(data.get()), ret ? "true" : "false");
   return ret;
 }
 
 lldb::SBDeclaration SBValue::GetDeclaration() {
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBDeclaration, SBValue, GetDeclaration);
 
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));
if (watchpoint_sp) {
           StreamString ss;
           // True to show fullpath for declaration file.
           decl.DumpStopContext(&ss, true);
           watchpoint_sp->SetDeclInfo(ss.GetString());
         }
       }
     }
   } else if (target_sp) {
-    Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-    if (log)
-      log->Printf("SBValue(%p)::Watch() => error getting SBValue: %s",
-                  static_cast<void *>(value_sp.get()),
-                  locker.GetError().AsCString());
-
     error.SetErrorStringWithFormat("could not get SBValue: %s",
                                    locker.GetError().AsCString());
   } else {
-    Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-    if (log)
-      log->Printf("SBValue(%p)::Watch() => error getting SBValue: no target",
-                  static_cast<void *>(value_sp.get()));
     error.SetErrorString("could not set watchpoint, a target is required");
   }
 
   return LLDB_RECORD_RESULT(sb_watchpoint);
 }
 
 // FIXME: Remove this method impl (as well as the decl in .h) once it is no
 // longer needed.

source/API/SBValueList.cpp

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

 
 SBValueList::SBValueList() : m_opaque_up() {
   LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBValueList);
 }
 
 SBValueList::SBValueList(const SBValueList &rhs) : m_opaque_up() {
   LLDB_RECORD_CONSTRUCTOR(SBValueList, (const lldb::SBValueList &), rhs);
 
-  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-
   if (rhs.IsValid())
     m_opaque_up.reset(new ValueListImpl(*rhs));
-
-  if (log) {
-    log->Printf(
-        "SBValueList::SBValueList (rhs.ap=%p) => this.ap = %p",
-        static_cast<void *>(rhs.IsValid() ? rhs.m_opaque_up.get() : NULL),
-        static_cast<void *>(m_opaque_up.get()));
-  }
 }
 
 SBValueList::SBValueList(const ValueListImpl *lldb_object_ptr) : m_opaque_up() {
-  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-
   if (lldb_object_ptr)
     m_opaque_up.reset(new ValueListImpl(*lldb_object_ptr));
-
-  if (log) {
-    log->Printf("SBValueList::SBValueList (lldb_object_ptr=%p) => this.ap = %p",
-                static_cast<const void *>(lldb_object_ptr),
-                static_cast<void *>(m_opaque_up.get()));
-  }
 }
 
 SBValueList::~SBValueList() {}
 
 bool SBValueList::IsValid() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBValueList, IsValid);
 
   return (m_opaque_up != NULL);
if (value_list.IsValid()) {
     m_opaque_up->Append(*value_list);
   }
 }
 
 SBValue SBValueList::GetValueAtIndex(uint32_t idx) const {
   LLDB_RECORD_METHOD_CONST(lldb::SBValue, SBValueList, GetValueAtIndex,
                            (uint32_t), idx);
 
-  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-
-  // if (log)
-  //    log->Printf ("SBValueList::GetValueAtIndex (uint32_t idx) idx = %d",
-  //    idx);
 
   SBValue sb_value;
   if (m_opaque_up)
     sb_value = m_opaque_up->GetValueAtIndex(idx);
 
-  if (log) {
-    SBStream sstr;
-    sb_value.GetDescription(sstr);
-    log->Printf("SBValueList::GetValueAtIndex (this.ap=%p, idx=%d) => SBValue "
-                "(this.sp = %p, '%s')",
-                static_cast<void *>(m_opaque_up.get()), idx,
-                static_cast<void *>(sb_value.GetSP().get()), sstr.GetData());
-  }
-
   return LLDB_RECORD_RESULT(sb_value);
 }
 
 uint32_t SBValueList::GetSize() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBValueList, GetSize);
 
-  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-
-  // if (log)
-  //    log->Printf ("SBValueList::GetSize ()");
-
   uint32_t size = 0;
   if (m_opaque_up)
     size = m_opaque_up->GetSize();
 
-  if (log)
-    log->Printf("SBValueList::GetSize (this.ap=%p) => %d",
-                static_cast<void *>(m_opaque_up.get()), size);
-
   return size;
 }
 
 void SBValueList::CreateIfNeeded() {
   if (m_opaque_up == NULL)
     m_opaque_up.reset(new ValueListImpl());
 }
 

source/API/SBWatchpoint.cpp

 #include "lldb/API/SBEvent.h"
 #include "lldb/API/SBStream.h"
 
 #include "lldb/Breakpoint/Watchpoint.h"
 #include "lldb/Breakpoint/WatchpointList.h"
 #include "lldb/Core/StreamFile.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
-#include "lldb/Utility/Log.h"
 #include "lldb/Utility/Stream.h"
 #include "lldb/lldb-defines.h"
 #include "lldb/lldb-types.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 SBWatchpoint::SBWatchpoint() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBWatchpoint); }
 
 SBWatchpoint::SBWatchpoint(const lldb::WatchpointSP &wp_sp)
     : m_opaque_wp(wp_sp) {
   LLDB_RECORD_CONSTRUCTOR(SBWatchpoint, (const lldb::WatchpointSP &), wp_sp);
-
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-
-  if (log) {
-    SBStream sstr;
-    GetDescription(sstr, lldb::eDescriptionLevelBrief);
-    LLDB_LOG(log, "watchpoint = {0} ({1})", wp_sp.get(), sstr.GetData());
-  }
 }
 
 SBWatchpoint::SBWatchpoint(const SBWatchpoint &rhs)
     : m_opaque_wp(rhs.m_opaque_wp) {
   LLDB_RECORD_CONSTRUCTOR(SBWatchpoint, (const lldb::SBWatchpoint &), rhs);
 }
 
 const SBWatchpoint &SBWatchpoint::operator=(const SBWatchpoint &rhs) {
   LLDB_RECORD_METHOD(const lldb::SBWatchpoint &,
                      SBWatchpoint, operator=,(const lldb::SBWatchpoint &), rhs);
 
   m_opaque_wp = rhs.m_opaque_wp;
   return *this;
 }
 
 SBWatchpoint::~SBWatchpoint() {}
 
 watch_id_t SBWatchpoint::GetID() {
   LLDB_RECORD_METHOD_NO_ARGS(lldb::watch_id_t, SBWatchpoint, GetID);
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   watch_id_t watch_id = LLDB_INVALID_WATCH_ID;
   lldb::WatchpointSP watchpoint_sp(GetSP());
   if (watchpoint_sp)
     watch_id = watchpoint_sp->GetID();
 
-  if (log) {
-    if (watch_id == LLDB_INVALID_WATCH_ID)
-      log->Printf("SBWatchpoint(%p)::GetID () => LLDB_INVALID_WATCH_ID",
-                  static_cast<void *>(watchpoint_sp.get()));
-    else
-      log->Printf("SBWatchpoint(%p)::GetID () => %u",
-                  static_cast<void *>(watchpoint_sp.get()), watch_id);
-  }
-
   return watch_id;
 }
 
 bool SBWatchpoint::IsValid() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBWatchpoint, IsValid);
 
   return bool(m_opaque_wp.lock());
 }
uint32_t SBWatchpoint::GetHitCount() {
   uint32_t count = 0;
   lldb::WatchpointSP watchpoint_sp(GetSP());
   if (watchpoint_sp) {
     std::lock_guard<std::recursive_mutex> guard(
         watchpoint_sp->GetTarget().GetAPIMutex());
     count = watchpoint_sp->GetHitCount();
   }
 
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  if (log)
-    log->Printf("SBWatchpoint(%p)::GetHitCount () => %u",
-                static_cast<void *>(watchpoint_sp.get()), count);
-
   return count;
 }
 
 uint32_t SBWatchpoint::GetIgnoreCount() {
   LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBWatchpoint, GetIgnoreCount);
 
   lldb::WatchpointSP watchpoint_sp(GetSP());
   if (watchpoint_sp) {