Index: source/Initialization/SystemInitializerCommon.cpp =================================================================== --- source/Initialization/SystemInitializerCommon.cpp +++ source/Initialization/SystemInitializerCommon.cpp @@ -45,6 +45,7 @@ #if defined(_MSC_VER) #include "lldb/Host/windows/windows.h" +#include "Plugins/Process/Windows/ProcessWindowsLog.h" #endif #include "llvm/Support/TargetSelect.h" @@ -128,6 +129,9 @@ static ConstString g_linux_log_name("linux"); ProcessPOSIXLog::Initialize(g_linux_log_name); #endif +#if defined(_MSC_VER) + ProcessWindowsLog::Initialize(); +#endif #ifndef LLDB_DISABLE_PYTHON ScriptInterpreterPython::InitializePrivate(); OperatingSystemPython::Initialize(); Index: source/Plugins/Process/Windows/CMakeLists.txt =================================================================== --- source/Plugins/Process/Windows/CMakeLists.txt +++ source/Plugins/Process/Windows/CMakeLists.txt @@ -13,6 +13,7 @@ DynamicLoaderWindows.cpp LocalDebugDelegate.cpp ProcessWindows.cpp + ProcessWindowsLog.cpp TargetThreadWindows.cpp ) Index: source/Plugins/Process/Windows/ProcessWindowsLog.h =================================================================== --- /dev/null +++ source/Plugins/Process/Windows/ProcessWindowsLog.h @@ -0,0 +1,73 @@ +//===-- ProcessWindowsLog.h -------------------------------------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#ifndef liblldb_ProcessWindowsLog_h_ +#define liblldb_ProcessWindowsLog_h_ + +#include "lldb/Core/Log.h" + +#define WINDOWS_LOG_VERBOSE (1u << 0) +#define WINDOWS_LOG_PROCESS (1u << 1) +#define WINDOWS_LOG_THREAD (1u << 2) +#define WINDOWS_LOG_MEMORY (1u << 3) // Log memory reads/writes calls +#define WINDOWS_LOG_MEMORY_DATA_SHORT (1u << 4) // Log short memory reads/writes bytes +#define WINDOWS_LOG_MEMORY_DATA_LONG (1u << 5) // Log all memory reads/writes bytes +#define WINDOWS_LOG_BREAKPOINTS (1u << 6) +#define WINDOWS_LOG_STEP (1u << 7) +#define WINDOWS_LOG_ASYNC (1u << 8) +#define WINDOWS_LOG_REGISTERS (1u << 9) +#define WINDOWS_LOG_ALL (UINT32_MAX) +#define WINDOWS_LOG_DEFAULT WINDOWS_LOG_ASYNC + +// The size which determines "short memory reads/writes". +#define WINDOWS_LOG_MEMORY_SHORT_BYTES (4 * sizeof(ptrdiff_t)) + +class ProcessWindowsLog +{ + static int m_nestinglevel; + static const char *m_pluginname; + +public: + // --------------------------------------------------------------------- + // Public Static Methods + // --------------------------------------------------------------------- + static void + Initialize(); + + static void + RegisterPluginName(const char *pluginName) + { + m_pluginname = pluginName; + } + + static void + RegisterPluginName(lldb_private::ConstString pluginName) + { + m_pluginname = pluginName.GetCString(); + } + + static lldb_private::Log * + GetLogIfAllCategoriesSet(uint32_t mask = 0); + + static void + DisableLog(const char **args, lldb_private::Stream *feedback_strm); + + static lldb_private::Log * + EnableLog(lldb::StreamSP &log_stream_sp, uint32_t log_options, + const char **args, lldb_private::Stream *feedback_strm); + + static void + ListLogCategories(lldb_private::Stream *strm); + + static void + LogIf(uint32_t mask, const char *format, ...); + +}; + +#endif // liblldb_ProcessWindowsLog_h_ Index: source/Plugins/Process/Windows/ProcessWindowsLog.cpp =================================================================== --- /dev/null +++ source/Plugins/Process/Windows/ProcessWindowsLog.cpp @@ -0,0 +1,204 @@ +//===-- ProcessWindowsLog.cpp -----------------------------------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#include "ProcessWindowsLog.h" + +#include + +#include "lldb/Interpreter/Args.h" +#include "lldb/Core/StreamFile.h" +#include "llvm/Support/ManagedStatic.h" + +#include "ProcessWindows.h" + +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_log_sp the first time this function is +// called. +static bool g_log_enabled = false; +static Log * g_log = NULL; +static Log * +GetLog() +{ + if (!g_log_enabled) + return NULL; + return g_log; +} + +static llvm::ManagedStatic g_once_flag; + +void +ProcessWindowsLog::Initialize() +{ + static ConstString g_name("windows"); + + std::call_once(*g_once_flag, [](){ + Log::Callbacks log_callbacks = { + DisableLog, + EnableLog, + ListLogCategories + }; + + Log::RegisterLogChannel(g_name, log_callbacks); + RegisterPluginName(g_name); + }); +} + +Log * +ProcessWindowsLog::GetLogIfAllCategoriesSet(uint32_t mask) +{ + Log *log(GetLog()); + if (log && mask) + { + uint32_t log_mask = log->GetMask().Get(); + if ((log_mask & mask) != mask) + return NULL; + } + return log; +} + +static uint32_t +GetFlagBits(const char *arg) +{ + if (::strcasecmp (arg, "all") == 0 ) return WINDOWS_LOG_ALL; + else if (::strcasecmp (arg, "async") == 0 ) return WINDOWS_LOG_ASYNC; + else if (::strncasecmp (arg, "break", 5) == 0 ) return WINDOWS_LOG_BREAKPOINTS; + else if (::strcasecmp (arg, "default") == 0 ) return WINDOWS_LOG_DEFAULT; + else if (::strcasecmp (arg, "memory") == 0 ) return WINDOWS_LOG_MEMORY; + else if (::strcasecmp (arg, "data-short") == 0 ) return WINDOWS_LOG_MEMORY_DATA_SHORT; + else if (::strcasecmp (arg, "data-long") == 0 ) return WINDOWS_LOG_MEMORY_DATA_LONG; + else if (::strcasecmp (arg, "process") == 0 ) return WINDOWS_LOG_PROCESS; + else if (::strcasecmp (arg, "registers") == 0 ) return WINDOWS_LOG_REGISTERS; + else if (::strcasecmp (arg, "step") == 0 ) return WINDOWS_LOG_STEP; + else if (::strcasecmp (arg, "thread") == 0 ) return WINDOWS_LOG_THREAD; + else if (::strcasecmp (arg, "verbose") == 0 ) return WINDOWS_LOG_VERBOSE; + return 0; +} + +void +ProcessWindowsLog::DisableLog(const char **args, Stream *feedback_strm) +{ + Log *log (GetLog()); + if (log) + { + uint32_t flag_bits = 0; + + flag_bits = log->GetMask().Get(); + for (; args[0]; args++) + { + const char *arg = args[0]; + uint32_t bits = GetFlagBits(arg); + + if (bits) + { + flag_bits &= ~bits; + } + else + { + feedback_strm->Printf("error: unrecognized log category '%s'\n", arg); + ListLogCategories(feedback_strm); + } + } + + log->GetMask().Reset(flag_bits); + if (flag_bits == 0) + g_log_enabled = false; + } + + return; +} + +Log * +ProcessWindowsLog::EnableLog(StreamSP &log_stream_sp, uint32_t log_options, const char **args, 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 = 0; + if (g_log) + flag_bits = g_log->GetMask().Get(); + + // Now make a new log with this stream if one was provided + if (log_stream_sp) + { + if (g_log) + g_log->SetStream(log_stream_sp); + else + g_log = new Log(log_stream_sp); + } + + if (g_log) + { + bool got_unknown_category = false; + for (; args[0]; args++) + { + const char *arg = args[0]; + uint32_t bits = GetFlagBits(arg); + + if (bits) + { + flag_bits |= bits; + } + else + { + feedback_strm->Printf("error: unrecognized log category '%s'\n", arg); + if (got_unknown_category == false) + { + got_unknown_category = true; + ListLogCategories (feedback_strm); + } + } + } + if (flag_bits == 0) + flag_bits = WINDOWS_LOG_DEFAULT; + g_log->GetMask().Reset(flag_bits); + g_log->GetOptions().Reset(log_options); + g_log_enabled = true; + } + return g_log; +} + +void +ProcessWindowsLog::ListLogCategories(Stream *strm) +{ + strm->Printf ("Logging categories for '%s':\n" + " all - turn on all available logging categories\n" + " async - log asynchronous activity\n" + " break - log breakpoints\n" + " default - enable the default set of logging categories for liblldb\n" + " memory - log memory reads and writes\n" + " data-short - log memory bytes for memory reads and writes for short transactions only\n" + " data-long - log memory bytes for memory reads and writes for all transactions\n" + " process - log process events and activities\n" + " registers - log register read/writes\n" + " thread - log thread events and activities\n" + " step - log step related activities\n" + " verbose - enable verbose logging\n", + ProcessWindowsLog::m_pluginname); +} + + +void +ProcessWindowsLog::LogIf(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); + } +} + +int ProcessWindowsLog::m_nestinglevel = 0; +const char *ProcessWindowsLog::m_pluginname = "";