lldb/source/Core/Log.cpp - toolchain/llvm-project - Gitiles

 //===-- Log.cpp -------------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//

 // Project includes
 #include "lldb/Core/Log.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/StreamFile.h"
 #include "lldb/Core/StreamString.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Host/ThisThread.h"
 #include "lldb/Interpreter/Args.h"
 #include "lldb/Utility/NameMatches.h"

 // Other libraries and framework includes
 #include "llvm/ADT/SmallString.h"
 #include "llvm/Support/Chrono.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/Signals.h"
 #include "llvm/Support/raw_ostream.h"

 // C Includes
 // C++ Includes
 #include <cstdarg>
 #include <cstdio>
 #include <cstdlib>
 #include <map>
 #include <mutex>
 #include <string>

 using namespace lldb;
 using namespace lldb_private;

 Log::Log() : m_stream_sp(), m_options(0), m_mask_bits(0) {}

 Log::Log(const StreamSP &stream_sp)
     : m_stream_sp(stream_sp), m_options(0), m_mask_bits(0) {}

 Log::~Log() = default;

 Flags &Log::GetOptions() { return m_options; }

 const Flags &Log::GetOptions() const { return m_options; }

 Flags &Log::GetMask() { return m_mask_bits; }

 const Flags &Log::GetMask() const { return m_mask_bits; }

 void Log::PutCString(const char *cstr) { Printf("%s", cstr); }
 void Log::PutString(llvm::StringRef str) { PutCString(str.str().c_str()); }

 //----------------------------------------------------------------------
 // Simple variable argument logging with flags.
 //----------------------------------------------------------------------
 void Log::Printf(const char *format, ...) {
   va_list args;
   va_start(args, format);
   VAPrintf(format, args);
   va_end(args);
 }

 //----------------------------------------------------------------------
 // All logging eventually boils down to this function call. If we have
 // a callback registered, then we call the logging callback. If we have
 // a valid file handle, we also log to the file.
 //----------------------------------------------------------------------
 void Log::VAPrintf(const char *format, va_list args) {
   std::string message_string;
   llvm::raw_string_ostream message(message_string);
   WriteHeader(message, "", "");

   char *text;
   vasprintf(&text, format, args);
   message << text;
   free(text);

   message << "\n";

   WriteMessage(message.str());
 }

 //----------------------------------------------------------------------
 // Print debug strings if and only if the global debug option is set to
 // a non-zero value.
 //----------------------------------------------------------------------
 void Log::Debug(const char *format, ...) {
   if (!GetOptions().Test(LLDB_LOG_OPTION_DEBUG))
     return;

   va_list args;
   va_start(args, format);
   VAPrintf(format, args);
   va_end(args);
 }

 //----------------------------------------------------------------------
 // Log only if all of the bits are set
 //----------------------------------------------------------------------
 void Log::LogIf(uint32_t bits, const char *format, ...) {
   if (!m_options.AllSet(bits))
     return;

   va_list args;
   va_start(args, format);
   VAPrintf(format, args);
   va_end(args);
 }

 //----------------------------------------------------------------------
 // Printing of errors that are not fatal.
 //----------------------------------------------------------------------
 void Log::Error(const char *format, ...) {
   va_list args;
   va_start(args, format);
   VAError(format, args);
   va_end(args);
 }

 void Log::VAError(const char *format, va_list args) {
   char *arg_msg = nullptr;
   ::vasprintf(&arg_msg, format, args);

   if (arg_msg == nullptr)
     return;

   Printf("error: %s", arg_msg);
   free(arg_msg);
 }

 //----------------------------------------------------------------------
 // Printing of warnings that are not fatal only if verbose mode is
 // enabled.
 //----------------------------------------------------------------------
 void Log::Verbose(const char *format, ...) {
   if (!m_options.Test(LLDB_LOG_OPTION_VERBOSE))
     return;

   va_list args;
   va_start(args, format);
   VAPrintf(format, args);
   va_end(args);
 }

 //----------------------------------------------------------------------
 // Printing of warnings that are not fatal.
 //----------------------------------------------------------------------
 void Log::Warning(const char *format, ...) {
   char *arg_msg = nullptr;
   va_list args;
   va_start(args, format);
   ::vasprintf(&arg_msg, format, args);
   va_end(args);

   if (arg_msg == nullptr)
     return;

   Printf("warning: %s", arg_msg);
   free(arg_msg);
 }

 typedef std::map<ConstString, Log::Callbacks> CallbackMap;
 typedef CallbackMap::iterator CallbackMapIter;

 typedef std::map<ConstString, LogChannelSP> LogChannelMap;
 typedef LogChannelMap::iterator LogChannelMapIter;

 // Surround our callback map with a singleton function so we don't have any
 // global initializers.
 static CallbackMap &GetCallbackMap() {
   static CallbackMap g_callback_map;
   return g_callback_map;
 }

 static LogChannelMap &GetChannelMap() {
   static LogChannelMap g_channel_map;
   return g_channel_map;
 }

 void Log::RegisterLogChannel(const ConstString &channel,
                              const Log::Callbacks &log_callbacks) {
   GetCallbackMap().insert(std::make_pair(channel, log_callbacks));
 }

 bool Log::UnregisterLogChannel(const ConstString &channel) {
   return GetCallbackMap().erase(channel) != 0;
 }

 bool Log::GetLogChannelCallbacks(const ConstString &channel,
                                  Log::Callbacks &log_callbacks) {
   CallbackMap &callback_map = GetCallbackMap();
   CallbackMapIter pos = callback_map.find(channel);
   if (pos != callback_map.end()) {
     log_callbacks = pos->second;
     return true;
   }
   ::memset(&log_callbacks, 0, sizeof(log_callbacks));
   return false;
 }

 bool Log::EnableLogChannel(lldb::StreamSP &log_stream_sp, uint32_t log_options,
                            const char *channel, const char **categories,
                            Stream &error_stream) {
   Log::Callbacks log_callbacks;
   if (Log::GetLogChannelCallbacks(ConstString(channel), log_callbacks)) {
     log_callbacks.enable(log_stream_sp, log_options, categories, &error_stream);
     return true;
   }

   LogChannelSP log_channel_sp(LogChannel::FindPlugin(channel));
   if (log_channel_sp) {
     if (log_channel_sp->Enable(log_stream_sp, log_options, &error_stream,
                                categories)) {
       return true;
     } else {
       error_stream.Printf("Invalid log channel '%s'.\n", channel);
       return false;
     }
   } else {
     error_stream.Printf("Invalid log channel '%s'.\n", channel);
     return false;
   }
 }

 void Log::EnableAllLogChannels(StreamSP &log_stream_sp, uint32_t log_options,
                                const char **categories, Stream *feedback_strm) {
   CallbackMap &callback_map = GetCallbackMap();
   CallbackMapIter pos, end = callback_map.end();

   for (pos = callback_map.begin(); pos != end; ++pos)
     pos->second.enable(log_stream_sp, log_options, categories, feedback_strm);

   LogChannelMap &channel_map = GetChannelMap();
   LogChannelMapIter channel_pos, channel_end = channel_map.end();
   for (channel_pos = channel_map.begin(); channel_pos != channel_end;
        ++channel_pos) {
     channel_pos->second->Enable(log_stream_sp, log_options, feedback_strm,
                                 categories);
   }
 }

 void Log::AutoCompleteChannelName(const char *channel_name,
                                   StringList &matches) {
   LogChannelMap &map = GetChannelMap();
   LogChannelMapIter pos, end = map.end();
   for (pos = map.begin(); pos != end; ++pos) {
     const char *pos_channel_name = pos->first.GetCString();
     if (channel_name && channel_name[0]) {
       if (NameMatches(channel_name, eNameMatchStartsWith, pos_channel_name)) {
         matches.AppendString(pos_channel_name);
       }
     } else
       matches.AppendString(pos_channel_name);
   }
 }

 void Log::DisableAllLogChannels(Stream *feedback_strm) {
   CallbackMap &callback_map = GetCallbackMap();
   CallbackMapIter pos, end = callback_map.end();
   const char *categories[] = {"all", nullptr};

   for (pos = callback_map.begin(); pos != end; ++pos)
     pos->second.disable(categories, feedback_strm);

   LogChannelMap &channel_map = GetChannelMap();
   LogChannelMapIter channel_pos, channel_end = channel_map.end();
   for (channel_pos = channel_map.begin(); channel_pos != channel_end;
        ++channel_pos)
     channel_pos->second->Disable(categories, feedback_strm);
 }

 void Log::Initialize() {
   Log::Callbacks log_callbacks = {DisableLog, EnableLog, ListLogCategories};
   Log::RegisterLogChannel(ConstString("lldb"), log_callbacks);
 }

 void Log::Terminate() { DisableAllLogChannels(nullptr); }

 void Log::ListAllLogChannels(Stream *strm) {
   CallbackMap &callback_map = GetCallbackMap();
   LogChannelMap &channel_map = GetChannelMap();

   if (callback_map.empty() && channel_map.empty()) {
     strm->PutCString("No logging channels are currently registered.\n");
     return;
   }

   CallbackMapIter pos, end = callback_map.end();
   for (pos = callback_map.begin(); pos != end; ++pos)
     pos->second.list_categories(strm);

   uint32_t idx = 0;
   const char *name;
   for (idx = 0;
        (name = PluginManager::GetLogChannelCreateNameAtIndex(idx)) != nullptr;
        ++idx) {
     LogChannelSP log_channel_sp(LogChannel::FindPlugin(name));
     if (log_channel_sp)
       log_channel_sp->ListCategories(strm);
   }
 }

 bool Log::GetVerbose() const { return m_options.Test(LLDB_LOG_OPTION_VERBOSE); }

 //------------------------------------------------------------------
 // Returns true if the debug flag bit is set in this stream.
 //------------------------------------------------------------------
 bool Log::GetDebug() const {
   // TODO: remove and clean up callers
   return false;
 }

 void Log::WriteHeader(llvm::raw_ostream &OS, llvm::StringRef file,
                       llvm::StringRef function) {
   static uint32_t g_sequence_id = 0;
   // Add a sequence ID if requested
   if (m_options.Test(LLDB_LOG_OPTION_PREPEND_SEQUENCE))
     OS << ++g_sequence_id << " ";

   // Timestamp if requested
   if (m_options.Test(LLDB_LOG_OPTION_PREPEND_TIMESTAMP)) {
     auto now = std::chrono::duration<double>(
         std::chrono::system_clock::now().time_since_epoch());
     OS << llvm::formatv("{0:f9} ", now.count());
   }

   // Add the process and thread if requested
   if (m_options.Test(LLDB_LOG_OPTION_PREPEND_PROC_AND_THREAD))
     OS << llvm::formatv("[{0,0+4}/{1,0+4}] ", getpid(),
                         Host::GetCurrentThreadID());

   // Add the thread name if requested
   if (m_options.Test(LLDB_LOG_OPTION_PREPEND_THREAD_NAME)) {
     llvm::SmallString<32> thread_name;
     ThisThread::GetName(thread_name);
     if (!thread_name.empty())
       OS << thread_name;
   }

   if (m_options.Test(LLDB_LOG_OPTION_BACKTRACE))
     llvm::sys::PrintStackTrace(OS);

   if (m_options.Test(LLDB_LOG_OPTION_PREPEND_FILE_FUNCTION) &&
       (!file.empty() || !function.empty())) {
     file = llvm::sys::path::filename(file).take_front(40);
     function = function.take_front(40);
     OS << llvm::formatv("{0,-60:60} ", (file + ":" + function).str());
   }
 }

 void Log::WriteMessage(const std::string &message) {
   // Make a copy of our stream shared pointer in case someone disables our
   // log while we are logging and releases the stream
   StreamSP stream_sp(m_stream_sp);
   if (!stream_sp)
     return;

   if (m_options.Test(LLDB_LOG_OPTION_THREADSAFE)) {
     static std::recursive_mutex g_LogThreadedMutex;
     std::lock_guard<std::recursive_mutex> guard(g_LogThreadedMutex);
     stream_sp->PutCString(message.c_str());
     stream_sp->Flush();
   } else {
     stream_sp->PutCString(message.c_str());
     stream_sp->Flush();
   }
 }

 void Log::Format(llvm::StringRef file, llvm::StringRef function,
                  const llvm::formatv_object_base &payload) {
   std::string message_string;
   llvm::raw_string_ostream message(message_string);
   WriteHeader(message, file, function);
   message << payload << "\n";
   WriteMessage(message.str());
 }

 LogChannelSP LogChannel::FindPlugin(const char *plugin_name) {
   LogChannelSP log_channel_sp;
   LogChannelMap &channel_map = GetChannelMap();
   ConstString log_channel_name(plugin_name);
   LogChannelMapIter pos = channel_map.find(log_channel_name);
   if (pos == channel_map.end()) {
     ConstString const_plugin_name(plugin_name);
     LogChannelCreateInstance create_callback =
         PluginManager::GetLogChannelCreateCallbackForPluginName(
             const_plugin_name);
     if (create_callback) {
       log_channel_sp.reset(create_callback());
       if (log_channel_sp) {
         // Cache the one and only loaded instance of each log channel
         // plug-in after it has been loaded once.
         channel_map[log_channel_name] = log_channel_sp;
       }
     }
   } else {
     // We have already loaded an instance of this log channel class,
     // so just return the cached instance.
     log_channel_sp = pos->second;
   }
   return log_channel_sp;
 }

 LogChannel::LogChannel() : m_log_ap() {}

 LogChannel::~LogChannel() = default;
	//===-- Log.cpp -------------------------------------------------- C++ --===//
	//
	// The LLVM Compiler Infrastructure
	//
	// This file is distributed under the University of Illinois Open Source
	// License. See LICENSE.TXT for details.
	//
	//===----------------------------------------------------------------------===//

	// Project includes
	#include "lldb/Core/Log.h"
	#include "lldb/Core/PluginManager.h"
	#include "lldb/Core/StreamFile.h"
	#include "lldb/Core/StreamString.h"
	#include "lldb/Host/Host.h"
	#include "lldb/Host/ThisThread.h"
	#include "lldb/Interpreter/Args.h"
	#include "lldb/Utility/NameMatches.h"

	// Other libraries and framework includes
	#include "llvm/ADT/SmallString.h"
	#include "llvm/Support/Chrono.h"
	#include "llvm/Support/Path.h"
	#include "llvm/Support/Signals.h"
	#include "llvm/Support/raw_ostream.h"

	// C Includes
	// C++ Includes
	#include <cstdarg>
	#include <cstdio>
	#include <cstdlib>
	#include <map>
	#include <mutex>
	#include <string>

	using namespace lldb;
	using namespace lldb_private;

	Log::Log() : m_stream_sp(), m_options(0), m_mask_bits(0) {}

	Log::Log(const StreamSP &stream_sp)
	: m_stream_sp(stream_sp), m_options(0), m_mask_bits(0) {}

	Log::~Log() = default;

	Flags &Log::GetOptions() { return m_options; }

	const Flags &Log::GetOptions() const { return m_options; }

	Flags &Log::GetMask() { return m_mask_bits; }

	const Flags &Log::GetMask() const { return m_mask_bits; }

	void Log::PutCString(const char *cstr) { Printf("%s", cstr); }
	void Log::PutString(llvm::StringRef str) { PutCString(str.str().c_str()); }

	//----------------------------------------------------------------------
	// Simple variable argument logging with flags.
	//----------------------------------------------------------------------
	void Log::Printf(const char *format, ...) {
	va_list args;
	va_start(args, format);
	VAPrintf(format, args);
	va_end(args);
	}

	//----------------------------------------------------------------------
	// All logging eventually boils down to this function call. If we have
	// a callback registered, then we call the logging callback. If we have
	// a valid file handle, we also log to the file.
	//----------------------------------------------------------------------
	void Log::VAPrintf(const char *format, va_list args) {
	std::string message_string;
	llvm::raw_string_ostream message(message_string);
	WriteHeader(message, "", "");

	char *text;
	vasprintf(&text, format, args);
	message << text;
	free(text);

	message << "\n";

	WriteMessage(message.str());
	}

	//----------------------------------------------------------------------
	// Print debug strings if and only if the global debug option is set to
	// a non-zero value.
	//----------------------------------------------------------------------
	void Log::Debug(const char *format, ...) {
	if (!GetOptions().Test(LLDB_LOG_OPTION_DEBUG))
	return;

	va_list args;
	va_start(args, format);
	VAPrintf(format, args);
	va_end(args);
	}

	//----------------------------------------------------------------------
	// Log only if all of the bits are set
	//----------------------------------------------------------------------
	void Log::LogIf(uint32_t bits, const char *format, ...) {
	if (!m_options.AllSet(bits))
	return;

	va_list args;
	va_start(args, format);
	VAPrintf(format, args);
	va_end(args);
	}

	//----------------------------------------------------------------------
	// Printing of errors that are not fatal.
	//----------------------------------------------------------------------
	void Log::Error(const char *format, ...) {
	va_list args;
	va_start(args, format);
	VAError(format, args);
	va_end(args);
	}

	void Log::VAError(const char *format, va_list args) {
	char *arg_msg = nullptr;
	::vasprintf(&arg_msg, format, args);

	if (arg_msg == nullptr)
	return;

	Printf("error: %s", arg_msg);
	free(arg_msg);
	}

	//----------------------------------------------------------------------
	// Printing of warnings that are not fatal only if verbose mode is
	// enabled.
	//----------------------------------------------------------------------
	void Log::Verbose(const char *format, ...) {
	if (!m_options.Test(LLDB_LOG_OPTION_VERBOSE))
	return;

	va_list args;
	va_start(args, format);
	VAPrintf(format, args);
	va_end(args);
	}

	//----------------------------------------------------------------------
	// Printing of warnings that are not fatal.
	//----------------------------------------------------------------------
	void Log::Warning(const char *format, ...) {
	char *arg_msg = nullptr;
	va_list args;
	va_start(args, format);
	::vasprintf(&arg_msg, format, args);
	va_end(args);

	if (arg_msg == nullptr)
	return;

	Printf("warning: %s", arg_msg);
	free(arg_msg);
	}

	typedef std::map<ConstString, Log::Callbacks> CallbackMap;
	typedef CallbackMap::iterator CallbackMapIter;

	typedef std::map<ConstString, LogChannelSP> LogChannelMap;
	typedef LogChannelMap::iterator LogChannelMapIter;

	// Surround our callback map with a singleton function so we don't have any
	// global initializers.
	static CallbackMap &GetCallbackMap() {
	static CallbackMap g_callback_map;
	return g_callback_map;
	}

	static LogChannelMap &GetChannelMap() {
	static LogChannelMap g_channel_map;
	return g_channel_map;
	}

	void Log::RegisterLogChannel(const ConstString &channel,
	const Log::Callbacks &log_callbacks) {
	GetCallbackMap().insert(std::make_pair(channel, log_callbacks));
	}

	bool Log::UnregisterLogChannel(const ConstString &channel) {
	return GetCallbackMap().erase(channel) != 0;
	}

	bool Log::GetLogChannelCallbacks(const ConstString &channel,
	Log::Callbacks &log_callbacks) {
	CallbackMap &callback_map = GetCallbackMap();
	CallbackMapIter pos = callback_map.find(channel);
	if (pos != callback_map.end()) {
	log_callbacks = pos->second;
	return true;
	}
	::memset(&log_callbacks, 0, sizeof(log_callbacks));
	return false;
	}

	bool Log::EnableLogChannel(lldb::StreamSP &log_stream_sp, uint32_t log_options,
	const char channel, const char *categories,
	Stream &error_stream) {
	Log::Callbacks log_callbacks;
	if (Log::GetLogChannelCallbacks(ConstString(channel), log_callbacks)) {
	log_callbacks.enable(log_stream_sp, log_options, categories, &error_stream);
	return true;
	}

	LogChannelSP log_channel_sp(LogChannel::FindPlugin(channel));
	if (log_channel_sp) {
	if (log_channel_sp->Enable(log_stream_sp, log_options, &error_stream,
	categories)) {
	return true;
	} else {
	error_stream.Printf("Invalid log channel '%s'.\n", channel);
	return false;
	}
	} else {
	error_stream.Printf("Invalid log channel '%s'.\n", channel);
	return false;
	}
	}

	void Log::EnableAllLogChannels(StreamSP &log_stream_sp, uint32_t log_options,
	const char *categories, Stream feedback_strm) {
	CallbackMap &callback_map = GetCallbackMap();
	CallbackMapIter pos, end = callback_map.end();

	for (pos = callback_map.begin(); pos != end; ++pos)
	pos->second.enable(log_stream_sp, log_options, categories, feedback_strm);

	LogChannelMap &channel_map = GetChannelMap();
	LogChannelMapIter channel_pos, channel_end = channel_map.end();
	for (channel_pos = channel_map.begin(); channel_pos != channel_end;
	++channel_pos) {
	channel_pos->second->Enable(log_stream_sp, log_options, feedback_strm,
	categories);
	}
	}

	void Log::AutoCompleteChannelName(const char *channel_name,
	StringList &matches) {
	LogChannelMap &map = GetChannelMap();
	LogChannelMapIter pos, end = map.end();
	for (pos = map.begin(); pos != end; ++pos) {
	const char *pos_channel_name = pos->first.GetCString();
	if (channel_name && channel_name[0]) {
	if (NameMatches(channel_name, eNameMatchStartsWith, pos_channel_name)) {
	matches.AppendString(pos_channel_name);
	}
	} else
	matches.AppendString(pos_channel_name);
	}
	}

	void Log::DisableAllLogChannels(Stream *feedback_strm) {
	CallbackMap &callback_map = GetCallbackMap();
	CallbackMapIter pos, end = callback_map.end();
	const char *categories[] = {"all", nullptr};

	for (pos = callback_map.begin(); pos != end; ++pos)
	pos->second.disable(categories, feedback_strm);

	LogChannelMap &channel_map = GetChannelMap();
	LogChannelMapIter channel_pos, channel_end = channel_map.end();
	for (channel_pos = channel_map.begin(); channel_pos != channel_end;
	++channel_pos)
	channel_pos->second->Disable(categories, feedback_strm);
	}

	void Log::Initialize() {
	Log::Callbacks log_callbacks = {DisableLog, EnableLog, ListLogCategories};
	Log::RegisterLogChannel(ConstString("lldb"), log_callbacks);
	}

	void Log::Terminate() { DisableAllLogChannels(nullptr); }

	void Log::ListAllLogChannels(Stream *strm) {
	CallbackMap &callback_map = GetCallbackMap();
	LogChannelMap &channel_map = GetChannelMap();

	if (callback_map.empty() && channel_map.empty()) {
	strm->PutCString("No logging channels are currently registered.\n");
	return;
	}

	CallbackMapIter pos, end = callback_map.end();
	for (pos = callback_map.begin(); pos != end; ++pos)
	pos->second.list_categories(strm);

	uint32_t idx = 0;
	const char *name;
	for (idx = 0;
	(name = PluginManager::GetLogChannelCreateNameAtIndex(idx)) != nullptr;
	++idx) {
	LogChannelSP log_channel_sp(LogChannel::FindPlugin(name));
	if (log_channel_sp)
	log_channel_sp->ListCategories(strm);
	}
	}

	bool Log::GetVerbose() const { return m_options.Test(LLDB_LOG_OPTION_VERBOSE); }

	//------------------------------------------------------------------
	// Returns true if the debug flag bit is set in this stream.
	//------------------------------------------------------------------
	bool Log::GetDebug() const {
	// TODO: remove and clean up callers
	return false;
	}

	void Log::WriteHeader(llvm::raw_ostream &OS, llvm::StringRef file,
	llvm::StringRef function) {
	static uint32_t g_sequence_id = 0;
	// Add a sequence ID if requested
	if (m_options.Test(LLDB_LOG_OPTION_PREPEND_SEQUENCE))
	OS << ++g_sequence_id << " ";

	// Timestamp if requested
	if (m_options.Test(LLDB_LOG_OPTION_PREPEND_TIMESTAMP)) {
	auto now = std::chrono::duration<double>(
	std::chrono::system_clock::now().time_since_epoch());
	OS << llvm::formatv("{0:f9} ", now.count());
	}

	// Add the process and thread if requested
	if (m_options.Test(LLDB_LOG_OPTION_PREPEND_PROC_AND_THREAD))
	OS << llvm::formatv("[{0,0+4}/{1,0+4}] ", getpid(),
	Host::GetCurrentThreadID());

	// Add the thread name if requested
	if (m_options.Test(LLDB_LOG_OPTION_PREPEND_THREAD_NAME)) {
	llvm::SmallString<32> thread_name;
	ThisThread::GetName(thread_name);
	if (!thread_name.empty())
	OS << thread_name;
	}

	if (m_options.Test(LLDB_LOG_OPTION_BACKTRACE))
	llvm::sys::PrintStackTrace(OS);

	if (m_options.Test(LLDB_LOG_OPTION_PREPEND_FILE_FUNCTION) &&
	(!file.empty() \|\| !function.empty())) {
	file = llvm::sys::path::filename(file).take_front(40);
	function = function.take_front(40);
	OS << llvm::formatv("{0,-60:60} ", (file + ":" + function).str());
	}
	}

	void Log::WriteMessage(const std::string &message) {
	// Make a copy of our stream shared pointer in case someone disables our
	// log while we are logging and releases the stream
	StreamSP stream_sp(m_stream_sp);
	if (!stream_sp)
	return;

	if (m_options.Test(LLDB_LOG_OPTION_THREADSAFE)) {
	static std::recursive_mutex g_LogThreadedMutex;
	std::lock_guard<std::recursive_mutex> guard(g_LogThreadedMutex);
	stream_sp->PutCString(message.c_str());
	stream_sp->Flush();
	} else {
	stream_sp->PutCString(message.c_str());
	stream_sp->Flush();
	}
	}

	void Log::Format(llvm::StringRef file, llvm::StringRef function,
	const llvm::formatv_object_base &payload) {
	std::string message_string;
	llvm::raw_string_ostream message(message_string);
	WriteHeader(message, file, function);
	message << payload << "\n";
	WriteMessage(message.str());
	}

	LogChannelSP LogChannel::FindPlugin(const char *plugin_name) {
	LogChannelSP log_channel_sp;
	LogChannelMap &channel_map = GetChannelMap();
	ConstString log_channel_name(plugin_name);
	LogChannelMapIter pos = channel_map.find(log_channel_name);
	if (pos == channel_map.end()) {
	ConstString const_plugin_name(plugin_name);
	LogChannelCreateInstance create_callback =
	PluginManager::GetLogChannelCreateCallbackForPluginName(
	const_plugin_name);
	if (create_callback) {
	log_channel_sp.reset(create_callback());
	if (log_channel_sp) {
	// Cache the one and only loaded instance of each log channel
	// plug-in after it has been loaded once.
	channel_map[log_channel_name] = log_channel_sp;
	}
	}
	} else {
	// We have already loaded an instance of this log channel class,
	// so just return the cached instance.
	log_channel_sp = pos->second;
	}
	return log_channel_sp;
	}

	LogChannel::LogChannel() : m_log_ap() {}

	LogChannel::~LogChannel() = default;