maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

Switch "lldb" log channel to the new registration mechanism 

llvm-svn: 295823
This commit is contained in:
Pavel Labath 2017-02-22 11:51:12 +00:00
parent a385d2c1b6
commit a2fc1e0cc8
5 changed files with 45 additions and 301 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
lldb/include/lldb/Core/Log.h
View File

@ -136,10 +136,6 @@ public:
static void ListAllLogChannels(Stream *strm);
static void Initialize();
static void Terminate();
//------------------------------------------------------------------
// Member functions
//------------------------------------------------------------------

13
lldb/include/lldb/Core/Logging.h
View File

@ -26,7 +26,6 @@
#define LIBLLDB_LOG_WATCHPOINTS (1u << 6)
#define LIBLLDB_LOG_STEP (1u << 7)
#define LIBLLDB_LOG_EXPRESSIONS (1u << 8)
#define LIBLLDB_LOG_TEMPORARY (1u << 9)
#define LIBLLDB_LOG_STATE (1u << 10)
#define LIBLLDB_LOG_OBJECT (1u << 11)
#define LIBLLDB_LOG_COMMUNICATION (1u << 12)
@ -57,23 +56,13 @@
namespace lldb_private {
void LogIfAllCategoriesSet(uint32_t mask, const char *format, ...);
void LogIfAnyCategoriesSet(uint32_t mask, const char *format, ...);
Log *GetLogIfAllCategoriesSet(uint32_t mask);
Log *GetLogIfAnyCategoriesSet(uint32_t mask);
uint32_t GetLogMask();
void DisableLog(const char **categories, Stream *feedback_strm);
Log *EnableLog(const std::shared_ptr<llvm::raw_ostream> &log_stream_sp,
uint32_t log_options, const char **categories,
Stream *feedback_strm);
void ListLogCategories(Stream *strm);
void InitializeLog();
} // namespace lldb_private

7
lldb/source/Core/Log.cpp
View File

@ -335,13 +335,6 @@ void Log::DisableAllLogChannels(Stream *feedback_strm) {
entry.second.channel.Disable(UINT32_MAX);
}
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();

318
lldb/source/Core/Logging.cpp
View File

@ -23,292 +23,58 @@
using namespace lldb;
using namespace lldb_private;
// We want to avoid global constructors where code needs to be run so here we
// control access to our static g_log_sp by hiding it in a singleton function
// that will construct the static g_lob_sp the first time this function is
// called.
static constexpr Log::Category g_categories[] = {
{{"api"}, {"log API calls and return values"}, LIBLLDB_LOG_API},
{{"break"}, {"log breakpoints"}, LIBLLDB_LOG_BREAKPOINTS},
{{"commands"}, {"log command argument parsing"}, LIBLLDB_LOG_COMMANDS},
{{"comm"}, {"log communication activities"}, LIBLLDB_LOG_COMMUNICATION},
{{"conn"}, {"log connection details"}, LIBLLDB_LOG_CONNECTION},
{{"demangle"}, {"log mangled names to catch demangler crashes"}, LIBLLDB_LOG_DEMANGLE},
{{"dyld"}, {"log shared library related activities"}, LIBLLDB_LOG_DYNAMIC_LOADER},
{{"event"}, {"log broadcaster, listener and event queue activities"}, LIBLLDB_LOG_EVENTS},
{{"expr"}, {"log expressions"}, LIBLLDB_LOG_EXPRESSIONS},
{{"formatters"}, {"log data formatters related activities"}, LIBLLDB_LOG_DATAFORMATTERS},
{{"host"}, {"log host activities"}, LIBLLDB_LOG_HOST},
{{"jit"}, {"log JIT events in the target"}, LIBLLDB_LOG_JIT_LOADER},
{{"language"}, {"log language runtime events"}, LIBLLDB_LOG_LANGUAGE},
{{"mmap"}, {"log mmap related activities"}, LIBLLDB_LOG_MMAP},
{{"module"}, {"log module activities such as when modules are created, destroyed, replaced, and more"}, LIBLLDB_LOG_MODULES},
{{"object"}, {"log object construction/destruction for important objects"}, LIBLLDB_LOG_OBJECT},
{{"os"}, {"log OperatingSystem plugin related activities"}, LIBLLDB_LOG_OS},
{{"platform"}, {"log platform events and activities"}, LIBLLDB_LOG_PLATFORM},
{{"process"}, {"log process events and activities"}, LIBLLDB_LOG_PROCESS},
{{"script"}, {"log events about the script interpreter"}, LIBLLDB_LOG_SCRIPT},
{{"state"}, {"log private and public process state changes"}, LIBLLDB_LOG_STATE},
{{"step"}, {"log step related activities"}, LIBLLDB_LOG_STEP},
{{"symbol"}, {"log symbol related issues and warnings"}, LIBLLDB_LOG_SYMBOLS},
{{"system-runtime"}, {"log system runtime events"}, LIBLLDB_LOG_SYSTEM_RUNTIME},
{{"target"}, {"log target events and activities"}, LIBLLDB_LOG_TARGET},
{{"thread"}, {"log thread events and activities"}, LIBLLDB_LOG_THREAD},
{{"types"}, {"log type system related activities"}, LIBLLDB_LOG_TYPES},
{{"unwind"}, {"log stack unwind activities"}, LIBLLDB_LOG_UNWIND},
{{"watch"}, {"log watchpoint related activities"}, LIBLLDB_LOG_WATCHPOINTS},
};
static std::atomic<bool> g_log_enabled{false};
static Log *g_log = nullptr;
static Log::Channel g_log_channel(g_categories, LIBLLDB_LOG_DEFAULT);
static Log *GetLog() {
if (!g_log_enabled)
return nullptr;
return g_log;
}
uint32_t lldb_private::GetLogMask() {
Log *log(GetLog());
if (log)
return log->GetMask().Get();
return 0;
void lldb_private::InitializeLog() {
Log::Register("lldb", g_log_channel);
}
Log *lldb_private::GetLogIfAllCategoriesSet(uint32_t mask) {
Log *log(GetLog());
if (log && mask) {
uint32_t log_mask = log->GetMask().Get();
if ((log_mask & mask) != mask)
return nullptr;
}
return log;
}
void lldb_private::LogIfAllCategoriesSet(uint32_t mask, const char *format,
...) {
Log *log(GetLogIfAllCategoriesSet(mask));
if (log) {
va_list args;
va_start(args, format);
log->VAPrintf(format, args);
va_end(args);
}
}
void lldb_private::LogIfAnyCategoriesSet(uint32_t mask, const char *format,
...) {
Log *log(GetLogIfAnyCategoriesSet(mask));
if (log != nullptr) {
va_list args;
va_start(args, format);
log->VAPrintf(format, args);
va_end(args);
}
return g_log_channel.GetLogIfAll(mask);
}
Log *lldb_private::GetLogIfAnyCategoriesSet(uint32_t mask) {
Log *log(GetLog());
if (log != nullptr && mask && (mask & log->GetMask().Get()))
return log;
return nullptr;
return g_log_channel.GetLogIfAny(mask);
}
void lldb_private::DisableLog(const char **categories, Stream *feedback_strm) {
Log *log(GetLog());
if (log != nullptr) {
uint32_t flag_bits = 0;
if (categories && categories[0]) {
flag_bits = log->GetMask().Get();
for (size_t i = 0; categories[i] != nullptr; ++i) {
const char *arg = categories[i];
if (0 == ::strcasecmp(arg, "all"))
flag_bits &= ~LIBLLDB_LOG_ALL;
else if (0 == ::strcasecmp(arg, "api"))
flag_bits &= ~LIBLLDB_LOG_API;
else if (0 == ::strncasecmp(arg, "break", 5))
flag_bits &= ~LIBLLDB_LOG_BREAKPOINTS;
else if (0 == ::strcasecmp(arg, "commands"))
flag_bits &= ~LIBLLDB_LOG_COMMANDS;
else if (0 == ::strcasecmp(arg, "default"))
flag_bits &= ~LIBLLDB_LOG_DEFAULT;
else if (0 == ::strcasecmp(arg, "dyld"))
flag_bits &= ~LIBLLDB_LOG_DYNAMIC_LOADER;
else if (0 == ::strncasecmp(arg, "event", 5))
flag_bits &= ~LIBLLDB_LOG_EVENTS;
else if (0 == ::strncasecmp(arg, "expr", 4))
flag_bits &= ~LIBLLDB_LOG_EXPRESSIONS;
else if (0 == ::strncasecmp(arg, "object", 6))
flag_bits &= ~LIBLLDB_LOG_OBJECT;
else if (0 == ::strcasecmp(arg, "process"))
flag_bits &= ~LIBLLDB_LOG_PROCESS;
else if (0 == ::strcasecmp(arg, "platform"))
flag_bits &= ~LIBLLDB_LOG_PLATFORM;
else if (0 == ::strcasecmp(arg, "script"))
flag_bits &= ~LIBLLDB_LOG_SCRIPT;
else if (0 == ::strcasecmp(arg, "state"))
flag_bits &= ~LIBLLDB_LOG_STATE;
else if (0 == ::strcasecmp(arg, "step"))
flag_bits &= ~LIBLLDB_LOG_STEP;
else if (0 == ::strcasecmp(arg, "thread"))
flag_bits &= ~LIBLLDB_LOG_THREAD;
else if (0 == ::strcasecmp(arg, "target"))
flag_bits &= ~LIBLLDB_LOG_TARGET;
else if (0 == ::strncasecmp(arg, "watch", 5))
flag_bits &= ~LIBLLDB_LOG_WATCHPOINTS;
else if (0 == ::strncasecmp(arg, "temp", 4))
flag_bits &= ~LIBLLDB_LOG_TEMPORARY;
else if (0 == ::strncasecmp(arg, "comm", 4))
flag_bits &= ~LIBLLDB_LOG_COMMUNICATION;
else if (0 == ::strncasecmp(arg, "conn", 4))
flag_bits &= ~LIBLLDB_LOG_CONNECTION;
else if (0 == ::strncasecmp(arg, "host", 4))
flag_bits &= ~LIBLLDB_LOG_HOST;
else if (0 == ::strncasecmp(arg, "unwind", 6))
flag_bits &= ~LIBLLDB_LOG_UNWIND;
else if (0 == ::strncasecmp(arg, "types", 5))
flag_bits &= ~LIBLLDB_LOG_TYPES;
else if (0 == ::strncasecmp(arg, "symbol", 6))
flag_bits &= ~LIBLLDB_LOG_SYMBOLS;
else if (0 == ::strcasecmp(arg, "system-runtime"))
flag_bits &= ~LIBLLDB_LOG_SYSTEM_RUNTIME;
else if (0 == ::strncasecmp(arg, "module", 6))
flag_bits &= ~LIBLLDB_LOG_MODULES;
else if (0 == ::strncasecmp(arg, "mmap", 4))
flag_bits &= ~LIBLLDB_LOG_MMAP;
else if (0 == ::strcasecmp(arg, "os"))
flag_bits &= ~LIBLLDB_LOG_OS;
else if (0 == ::strcasecmp(arg, "jit"))
flag_bits &= ~LIBLLDB_LOG_JIT_LOADER;
else if (0 == ::strcasecmp(arg, "language"))
flag_bits &= ~LIBLLDB_LOG_LANGUAGE;
else if (0 == ::strncasecmp(arg, "formatters", 10))
flag_bits &= ~LIBLLDB_LOG_DATAFORMATTERS;
else if (0 == ::strncasecmp(arg, "demangle", 8))
flag_bits &= ~LIBLLDB_LOG_DEMANGLE;
else {
feedback_strm->Printf("error: unrecognized log category '%s'\n",
arg);
ListLogCategories(feedback_strm);
return;
}
}
}
log->GetMask().Reset(flag_bits);
if (flag_bits == 0) {
log->SetStream(nullptr);
g_log_enabled = false;
}
void lldb_private::LogIfAnyCategoriesSet(uint32_t mask, const char *format, ...) {
if (Log *log = GetLogIfAnyCategoriesSet(mask)) {
va_list args;
va_start(args, format);
log->VAPrintf(format, args);
va_end(args);
}
}
Log *lldb_private::EnableLog(
const std::shared_ptr<llvm::raw_ostream> &log_stream_sp,
uint32_t log_options, const char **categories, Stream *feedback_strm) {
// Try see if there already is a log - that way we can reuse its settings.
// We could reuse the log in toto, but we don't know that the stream is the
// same.
uint32_t flag_bits;
if (g_log != nullptr)
flag_bits = g_log->GetMask().Get();
else
flag_bits = 0;
// Now make a new log with this stream if one was provided
if (log_stream_sp) {
if (g_log != nullptr)
g_log->SetStream(log_stream_sp);
else
g_log = new Log(log_stream_sp);
}
if (g_log != nullptr) {
for (size_t i = 0; categories[i] != nullptr; ++i) {
const char *arg = categories[i];
if (0 == ::strcasecmp(arg, "all"))
flag_bits |= LIBLLDB_LOG_ALL;
else if (0 == ::strcasecmp(arg, "api"))
flag_bits |= LIBLLDB_LOG_API;
else if (0 == ::strncasecmp(arg, "break", 5))
flag_bits |= LIBLLDB_LOG_BREAKPOINTS;
else if (0 == ::strcasecmp(arg, "commands"))
flag_bits |= LIBLLDB_LOG_COMMANDS;
else if (0 == ::strncasecmp(arg, "commu", 5))
flag_bits |= LIBLLDB_LOG_COMMUNICATION;
else if (0 == ::strncasecmp(arg, "conn", 4))
flag_bits |= LIBLLDB_LOG_CONNECTION;
else if (0 == ::strcasecmp(arg, "default"))
flag_bits |= LIBLLDB_LOG_DEFAULT;
else if (0 == ::strcasecmp(arg, "dyld"))
flag_bits |= LIBLLDB_LOG_DYNAMIC_LOADER;
else if (0 == ::strncasecmp(arg, "event", 5))
flag_bits |= LIBLLDB_LOG_EVENTS;
else if (0 == ::strncasecmp(arg, "expr", 4))
flag_bits |= LIBLLDB_LOG_EXPRESSIONS;
else if (0 == ::strncasecmp(arg, "host", 4))
flag_bits |= LIBLLDB_LOG_HOST;
else if (0 == ::strncasecmp(arg, "mmap", 4))
flag_bits |= LIBLLDB_LOG_MMAP;
else if (0 == ::strncasecmp(arg, "module", 6))
flag_bits |= LIBLLDB_LOG_MODULES;
else if (0 == ::strncasecmp(arg, "object", 6))
flag_bits |= LIBLLDB_LOG_OBJECT;
else if (0 == ::strcasecmp(arg, "os"))
flag_bits |= LIBLLDB_LOG_OS;
else if (0 == ::strcasecmp(arg, "platform"))
flag_bits |= LIBLLDB_LOG_PLATFORM;
else if (0 == ::strcasecmp(arg, "process"))
flag_bits |= LIBLLDB_LOG_PROCESS;
else if (0 == ::strcasecmp(arg, "script"))
flag_bits |= LIBLLDB_LOG_SCRIPT;
else if (0 == ::strcasecmp(arg, "state"))
flag_bits |= LIBLLDB_LOG_STATE;
else if (0 == ::strcasecmp(arg, "step"))
flag_bits |= LIBLLDB_LOG_STEP;
else if (0 == ::strncasecmp(arg, "symbol", 6))
flag_bits |= LIBLLDB_LOG_SYMBOLS;
else if (0 == ::strcasecmp(arg, "system-runtime"))
flag_bits |= LIBLLDB_LOG_SYSTEM_RUNTIME;
else if (0 == ::strcasecmp(arg, "target"))
flag_bits |= LIBLLDB_LOG_TARGET;
else if (0 == ::strncasecmp(arg, "temp", 4))
flag_bits |= LIBLLDB_LOG_TEMPORARY;
else if (0 == ::strcasecmp(arg, "thread"))
flag_bits |= LIBLLDB_LOG_THREAD;
else if (0 == ::strncasecmp(arg, "types", 5))
flag_bits |= LIBLLDB_LOG_TYPES;
else if (0 == ::strncasecmp(arg, "unwind", 6))
flag_bits |= LIBLLDB_LOG_UNWIND;
else if (0 == ::strncasecmp(arg, "watch", 5))
flag_bits |= LIBLLDB_LOG_WATCHPOINTS;
else if (0 == ::strcasecmp(arg, "jit"))
flag_bits |= LIBLLDB_LOG_JIT_LOADER;
else if (0 == ::strcasecmp(arg, "language"))
flag_bits |= LIBLLDB_LOG_LANGUAGE;
else if (0 == ::strncasecmp(arg, "formatters", 10))
flag_bits |= LIBLLDB_LOG_DATAFORMATTERS;
else if (0 == ::strncasecmp(arg, "demangle", 8))
flag_bits |= LIBLLDB_LOG_DEMANGLE;
else {
feedback_strm->Printf("error: unrecognized log category '%s'\n", arg);
ListLogCategories(feedback_strm);
return g_log;
}
}
g_log->GetMask().Reset(flag_bits);
g_log->GetOptions().Reset(log_options);
}
g_log_enabled = true;
return g_log;
}
void lldb_private::ListLogCategories(Stream *strm) {
strm->Printf(
"Logging categories for 'lldb':\n"
" all - turn on all available logging categories\n"
" api - enable logging of API calls and return values\n"
" break - log breakpoints\n"
" commands - log command argument parsing\n"
" communication - log communication activities\n"
" connection - log connection details\n"
" default - enable the default set of logging categories for liblldb\n"
" demangle - log mangled names to catch demangler crashes\n"
" dyld - log shared library related activities\n"
" events - log broadcaster, listener and event queue activities\n"
" expr - log expressions\n"
" formatters - log data formatters related activities\n"
" host - log host activities\n"
" jit - log JIT events in the target\n"
" language - log language runtime events\n"
" mmap - log mmap related activities\n"
" module - log module activities such as when modules are created, "
"destroyed, replaced, and more\n"
" object - log object construction/destruction for important objects\n"
" os - log OperatingSystem plugin related activities\n"
" platform - log platform events and activities\n"
" process - log process events and activities\n"
" script - log events about the script interpreter\n"
" state - log private and public process state changes\n"
" step - log step related activities\n"
" symbol - log symbol related issues and warnings\n"
" system-runtime - log system runtime events\n"
" target - log target events and activities\n"
" thread - log thread events and activities\n"
" types - log type system related activities\n"
" unwind - log stack unwind activities\n"
" verbose - enable verbose logging\n"
" watch - log watchpoint related activities\n");
}

4
lldb/source/Initialization/SystemInitializerCommon.cpp
View File

@ -70,7 +70,7 @@ void SystemInitializerCommon::Initialize() {
#endif
llvm::EnablePrettyStackTrace();
Log::Initialize();
InitializeLog();
HostInfo::Initialize();
Timer scoped_timer(LLVM_PRETTY_FUNCTION, LLVM_PRETTY_FUNCTION);
@ -122,5 +122,5 @@ void SystemInitializerCommon::Terminate() {
#endif
HostInfo::Terminate();
Log::Terminate();
Log::DisableAllLogChannels(nullptr);
}