Add logging plugin for Winodows

[amccarth]

Summary

Adds a ProcessWindowsLog, patterned off ProcessPosixLog and others. (Nothing uses it yet. I'll do that in a separate patch.

But it does initialize, and you can issue lldb commands like:

(lldb) log list windows
(lldb) log list enable windows all
(lldb) log disable windows memory

There's already a lot of code duplication among the logging classes, so this addition doesn't it make it much worse. It seems there's almost nothing POSIX-specific in ProcessPOSIXLog, so that class could be used as a base to reduce a bunch of the code duplication. If that seems reasonable, I'll go that route.

[zturner]

Mostly fine, but since this is duplicating a bunch of code, I'd like to keep the amount of duplication to only what we have an immediate need for.

source/Plugins/Process/Windows/ProcessWindowsLog.cpp

42

Can you make this an llvm::ManagedStatic<std::once_flag> once_flag on Windows is not linker-initialized, and Windows doesn't have thread-safe function local static initialization. This is probably benign in this case, as this is only called from SystemInitialzierCommon::Initialize(), but either way, as a general principle once_flags should be ManagedStatics.

source/Plugins/Process/Windows/ProcessWindowsLog.h

19

This flag doesn't make much sense currently, I think this must have to do with remote ddebugging.

24

Can delete this one too, as Windows doesn't support watchpoints yet.

26

Not sure what this one is, but check what they're using it for on the Linux side, and if it doesn't apply to Windows (yet / ever) then remove this one too

28

Another one that can go.

76–96

I don't think we need any of this nesting stuff. If it becomes useful later, we can always introduce it back.

[amccarth]

source/Plugins/Process/Windows/ProcessWindowsLog.cpp

42

Done, but I thought VC++2013 had finally added thread-safe initialization of function statics. Maybe I'm misreading the table: http://blogs.msdn.com/b/vcblog/archive/2013/11/18/announcing-the-visual-c-compiler-november-2013-ctp.aspx

source/Plugins/Process/Windows/ProcessWindowsLog.h

19

Done. I wasn't sure if it was important to keep the flag numbering consistent.

24

Done.

26

It's for "communication," but I'm not sure what that means in this context. Removed.

28

Done.

76–96

Removed.

[amccarth]

Addressed comments from previous round.

[zturner]

Looks good, thanks!

[Eugene.Zelenko]

Committed in r234607.

source/Initialization/SystemInitializerCommon.cpp

 
 #if defined(__linux__)
 #include "Plugins/Process/Linux/ProcessLinux.h"
 #include "Plugins/Process/POSIX/ProcessPOSIXLog.h"
 #endif
 
 #if defined(_MSC_VER)
 #include "lldb/Host/windows/windows.h"
+#include "Plugins/Process/Windows/ProcessWindowsLog.h"
 #endif
 
 #include "llvm/Support/TargetSelect.h"
 
 #include <string>
 
 using namespace lldb_private;
 
#if defined(__APPLE__)
     DynamicLoaderDarwinKernel::Initialize();
     PlatformDarwinKernel::Initialize();
     ObjectFileMachO::Initialize();
 #endif
 #if defined(__linux__)
     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();
 #endif
 }
 
 void
 SystemInitializerCommon::Terminate()

source/Plugins/Process/Windows/CMakeLists.txt

 set(LLVM_NO_RTTI 1)
 
 macro(add_process_windows_subdirectory group)
   list(APPEND PROC_WINDOWS_SOURCES ${ARGN})
   source_group(${group} FILES ${ARGN})
 endmacro()
 
 include_directories(.)
 include_directories(../Utility)
 
 add_process_windows_subdirectory(common
   DebuggerThread.cpp
   DynamicLoaderWindows.cpp
   LocalDebugDelegate.cpp
   ProcessWindows.cpp
+  ProcessWindowsLog.cpp
   TargetThreadWindows.cpp
   )
 
 if (CMAKE_SIZEOF_VOID_P EQUAL 4)
   add_process_windows_subdirectory(x86
   x86/RegisterContextWindows_x86.cpp
   )
 endif()
 
 add_lldb_library(lldbPluginProcessWindows
   ${PROC_WINDOWS_SOURCES}
   )

source/Plugins/Process/Windows/ProcessWindowsLog.h

+//===-- 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_

source/Plugins/Process/Windows/ProcessWindowsLog.cpp

+//===-- 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 <mutex>
+
+#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<std::once_flag> 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 = "";