Reorg code to allow Windows Process Plugins to share some common code.

Differential Revision: http://reviews.llvm.org/D12252

llvm-svn: 245850

30 files changed, 1409 insertions, 1409 deletions

diff --git a/lldb/source/API/SystemInitializerFull.cpp b/lldb/source/API/SystemInitializerFull.cpp
index dfe077e2005..4ba4a420b2a 100644
--- a/lldb/source/API/SystemInitializerFull.cpp
+++ b/lldb/source/API/SystemInitializerFull.cpp
@@ -70,8 +70,8 @@
 
 #if defined(_MSC_VER)
 #include "lldb/Host/windows/windows.h"
-#include "Plugins/Process/Windows/ProcessWindows.h"
-#include "Plugins/Process/win-minidump/ProcessWinMiniDump.h"
+#include "Plugins/Process/Windows/Live/ProcessWindows.h"
+#include "Plugins/Process/Windows/MiniDump/ProcessWinMiniDump.h"
 #endif
 
 #include "llvm/Support/TargetSelect.h"
diff --git a/lldb/source/Initialization/SystemInitializerCommon.cpp b/lldb/source/Initialization/SystemInitializerCommon.cpp
index dcf823e2dc7..aac325636fd 100644
--- a/lldb/source/Initialization/SystemInitializerCommon.cpp
+++ b/lldb/source/Initialization/SystemInitializerCommon.cpp
@@ -47,7 +47,7 @@
 
 #if defined(_MSC_VER)
 #include "lldb/Host/windows/windows.h"
-#include "Plugins/Process/Windows/ProcessWindowsLog.h"
+#include "Plugins/Process/Windows/Live/ProcessWindowsLog.h"
 #endif
 
 #include "llvm/Support/TargetSelect.h"
diff --git a/lldb/source/Plugins/Process/CMakeLists.txt b/lldb/source/Plugins/Process/CMakeLists.txt
index 2c1643432cc..4144471a42f 100644
--- a/lldb/source/Plugins/Process/CMakeLists.txt
+++ b/lldb/source/Plugins/Process/CMakeLists.txt
@@ -5,8 +5,8 @@ elseif (CMAKE_SYSTEM_NAME MATCHES "FreeBSD")
   add_subdirectory(FreeBSD)
   add_subdirectory(POSIX)
 elseif (CMAKE_SYSTEM_NAME MATCHES "Windows")
-  add_subdirectory(Windows)
-  add_subdirectory(win-minidump)
+  add_subdirectory(Windows/Live)
+  add_subdirectory(Windows/MiniDump)
 elseif (CMAKE_SYSTEM_NAME MATCHES "Darwin")
   add_subdirectory(MacOSX-Kernel)
 endif()
diff --git a/lldb/source/Plugins/Process/Windows/ExceptionRecord.h b/lldb/source/Plugins/Process/Windows/Common/ExceptionRecord.h
index 45a1b1c12e5..79dae3fca4e 100644
--- a/lldb/source/Plugins/Process/Windows/ExceptionRecord.h
+++ b/lldb/source/Plugins/Process/Windows/Common/ExceptionRecord.h
@@ -10,8 +10,6 @@
 #ifndef liblldb_Plugins_Process_Windows_ExceptionRecord_H_
 #define liblldb_Plugins_Process_Windows_ExceptionRecord_H_
 
-#include "ForwardDecl.h"
-
 #include "lldb/lldb-forward.h"
 #include "lldb/Host/windows/windows.h"
 #include <DbgHelp.h>
diff --git a/lldb/source/Plugins/Process/Windows/CMakeLists.txt b/lldb/source/Plugins/Process/Windows/Live/CMakeLists.txt
index 6d61fef7f38..bf7a17538b2 100644
--- a/lldb/source/Plugins/Process/Windows/CMakeLists.txt
+++ b/lldb/source/Plugins/Process/Windows/Live/CMakeLists.txt
@@ -1,7 +1,8 @@
 set(LLVM_NO_RTTI 1)
 
 include_directories(.)
-include_directories(../Utility)
+include_directories(../../Utility)
+include_directories(../Common)
 
 set(PROC_WINDOWS_SOURCES
   DebuggerThread.cpp
diff --git a/lldb/source/Plugins/Process/Windows/DebuggerThread.cpp b/lldb/source/Plugins/Process/Windows/Live/DebuggerThread.cpp
index 1e63aac2deb..e65310d1c8d 100644
--- a/lldb/source/Plugins/Process/Windows/DebuggerThread.cpp
+++ b/lldb/source/Plugins/Process/Windows/Live/DebuggerThread.cpp
@@ -24,7 +24,7 @@
 #include "lldb/Target/ProcessLaunchInfo.h"
 #include "lldb/Target/Process.h"
 
-#include "Plugins/Process/Windows/ProcessWindowsLog.h"
+#include "Plugins/Process/Windows/Live/ProcessWindowsLog.h"
 
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/Support/raw_ostream.h"
diff --git a/lldb/source/Plugins/Process/Windows/DebuggerThread.h b/lldb/source/Plugins/Process/Windows/Live/DebuggerThread.h
index 3646d86e5af..3646d86e5af 100644
--- a/lldb/source/Plugins/Process/Windows/DebuggerThread.h
+++ b/lldb/source/Plugins/Process/Windows/Live/DebuggerThread.h
diff --git a/lldb/source/Plugins/Process/Windows/ForwardDecl.h b/lldb/source/Plugins/Process/Windows/Live/ForwardDecl.h
index 5b35b9c662e..c2eb168f327 100644
--- a/lldb/source/Plugins/Process/Windows/ForwardDecl.h
+++ b/lldb/source/Plugins/Process/Windows/Live/ForwardDecl.h
@@ -1,41 +1,41 @@
-//===-- ForwardDecl.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_Plugins_Process_Windows_ForwardDecl_H_
-#define liblldb_Plugins_Process_Windows_ForwardDecl_H_
-
-class ProcessWindows;
-
-#include <memory>
-
-// ExceptionResult is returned by the debug delegate to specify how it processed
-// the exception.
-enum class ExceptionResult
-{
-    BreakInDebugger,  // Break in the debugger and give the user a chance to interact with
-                      // the program before continuing.
-    MaskException,    // Eat the exception and don't let the application know it occurred.
-    SendToApplication // Send the exception to the application to be handled as if there were
-                      // no debugger attached.
-};
-
-namespace lldb_private
-{
-
-class IDebugDelegate;
-class DebuggerThread;
-class ExceptionRecord;
-
-typedef std::shared_ptr<IDebugDelegate> DebugDelegateSP;
-typedef std::shared_ptr<DebuggerThread> DebuggerThreadSP;
-typedef std::shared_ptr<ExceptionRecord> ExceptionRecordSP;
-typedef std::unique_ptr<ExceptionRecord> ExceptionRecordUP;
-}
-
+//===-- ForwardDecl.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_Plugins_Process_Windows_ForwardDecl_H_

+#define liblldb_Plugins_Process_Windows_ForwardDecl_H_

+

+class ProcessWindows;

+

+#include <memory>

+

+// ExceptionResult is returned by the debug delegate to specify how it processed

+// the exception.

+enum class ExceptionResult

+{

+    BreakInDebugger,  // Break in the debugger and give the user a chance to interact with

+                      // the program before continuing.

+    MaskException,    // Eat the exception and don't let the application know it occurred.

+    SendToApplication // Send the exception to the application to be handled as if there were

+                      // no debugger attached.

+};

+

+namespace lldb_private

+{

+

+class IDebugDelegate;

+class DebuggerThread;

+class ExceptionRecord;

+

+typedef std::shared_ptr<IDebugDelegate> DebugDelegateSP;

+typedef std::shared_ptr<DebuggerThread> DebuggerThreadSP;

+typedef std::shared_ptr<ExceptionRecord> ExceptionRecordSP;

+typedef std::unique_ptr<ExceptionRecord> ExceptionRecordUP;

+}

+

 #endif
\ No newline at end of file
diff --git a/lldb/source/Plugins/Process/Windows/IDebugDelegate.h b/lldb/source/Plugins/Process/Windows/Live/IDebugDelegate.h
index 6d864de7ed4..0e7849bb8ff 100644
--- a/lldb/source/Plugins/Process/Windows/IDebugDelegate.h
+++ b/lldb/source/Plugins/Process/Windows/Live/IDebugDelegate.h
@@ -1,46 +1,46 @@
-//===-- IDebugDelegate.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_Plugins_Process_Windows_IDebugDelegate_H_
-#define liblldb_Plugins_Process_Windows_IDebugDelegate_H_
-
-#include "ForwardDecl.h"
-#include "lldb/lldb-forward.h"
-#include "lldb/lldb-types.h"
-#include <string>
-
-namespace lldb_private
-{
-class Error;
-class HostThread;
-
-//----------------------------------------------------------------------
-// IDebugDelegate
-//
-// IDebugDelegate defines an interface which allows implementors to receive
-// notification of events that happen in a debugged process.
-//----------------------------------------------------------------------
-class IDebugDelegate
-{
-  public:
-    virtual ~IDebugDelegate() {}
-
-    virtual void OnExitProcess(uint32_t exit_code) = 0;
-    virtual void OnDebuggerConnected(lldb::addr_t image_base) = 0;
-    virtual ExceptionResult OnDebugException(bool first_chance, const ExceptionRecord &record) = 0;
-    virtual void OnCreateThread(const HostThread &thread) = 0;
-    virtual void OnExitThread(lldb::tid_t thread_id, uint32_t exit_code) = 0;
-    virtual void OnLoadDll(const ModuleSpec &module_spec, lldb::addr_t module_addr) = 0;
-    virtual void OnUnloadDll(lldb::addr_t module_addr) = 0;
-    virtual void OnDebugString(const std::string &string) = 0;
-    virtual void OnDebuggerError(const Error &error, uint32_t type) = 0;
-};
-}
-
-#endif
+//===-- IDebugDelegate.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_Plugins_Process_Windows_IDebugDelegate_H_

+#define liblldb_Plugins_Process_Windows_IDebugDelegate_H_

+

+#include "ForwardDecl.h"

+#include "lldb/lldb-forward.h"

+#include "lldb/lldb-types.h"

+#include <string>

+

+namespace lldb_private

+{

+class Error;

+class HostThread;

+

+//----------------------------------------------------------------------

+// IDebugDelegate

+//

+// IDebugDelegate defines an interface which allows implementors to receive

+// notification of events that happen in a debugged process.

+//----------------------------------------------------------------------

+class IDebugDelegate

+{

+  public:

+    virtual ~IDebugDelegate() {}

+

+    virtual void OnExitProcess(uint32_t exit_code) = 0;

+    virtual void OnDebuggerConnected(lldb::addr_t image_base) = 0;

+    virtual ExceptionResult OnDebugException(bool first_chance, const ExceptionRecord &record) = 0;

+    virtual void OnCreateThread(const HostThread &thread) = 0;

+    virtual void OnExitThread(lldb::tid_t thread_id, uint32_t exit_code) = 0;

+    virtual void OnLoadDll(const ModuleSpec &module_spec, lldb::addr_t module_addr) = 0;

+    virtual void OnUnloadDll(lldb::addr_t module_addr) = 0;

+    virtual void OnDebugString(const std::string &string) = 0;

+    virtual void OnDebuggerError(const Error &error, uint32_t type) = 0;

+};

+}

+

+#endif

diff --git a/lldb/source/Plugins/Process/Windows/LocalDebugDelegate.cpp b/lldb/source/Plugins/Process/Windows/Live/LocalDebugDelegate.cpp
index d1fb51b3f08..07f2969d5a9 100644
--- a/lldb/source/Plugins/Process/Windows/LocalDebugDelegate.cpp
+++ b/lldb/source/Plugins/Process/Windows/Live/LocalDebugDelegate.cpp
@@ -1,73 +1,73 @@
-//===-- LocalDebugDelegate.cpp ----------------------------------*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#include "LocalDebugDelegate.h"
-#include "ProcessWindows.h"
-
-using namespace lldb;
-using namespace lldb_private;
-
-LocalDebugDelegate::LocalDebugDelegate(ProcessSP process)
-    : m_process(process)
-{
-}
-
-void
-LocalDebugDelegate::OnExitProcess(uint32_t exit_code)
-{
-    ((ProcessWindows &)*m_process).OnExitProcess(exit_code);
-}
-
-void
-LocalDebugDelegate::OnDebuggerConnected(lldb::addr_t image_base)
-{
-    ((ProcessWindows &)*m_process).OnDebuggerConnected(image_base);
-}
-
-ExceptionResult
-LocalDebugDelegate::OnDebugException(bool first_chance, const ExceptionRecord &record)
-{
-    return ((ProcessWindows &)*m_process).OnDebugException(first_chance, record);
-}
-
-void
-LocalDebugDelegate::OnCreateThread(const HostThread &thread)
-{
-    ((ProcessWindows &)*m_process).OnCreateThread(thread);
-}
-
-void
-LocalDebugDelegate::OnExitThread(lldb::tid_t thread_id, uint32_t exit_code)
-{
-    ((ProcessWindows &)*m_process).OnExitThread(thread_id, exit_code);
-}
-
-void
-LocalDebugDelegate::OnLoadDll(const lldb_private::ModuleSpec &module_spec, lldb::addr_t module_addr)
-{
-    ((ProcessWindows &)*m_process).OnLoadDll(module_spec, module_addr);
-}
-
-void
-LocalDebugDelegate::OnUnloadDll(lldb::addr_t module_addr)
-{
-    ((ProcessWindows &)*m_process).OnUnloadDll(module_addr);
-}
-
-void
-LocalDebugDelegate::OnDebugString(const std::string &string)
-{
-    ((ProcessWindows &)*m_process).OnDebugString(string);
-}
-
-void
-LocalDebugDelegate::OnDebuggerError(const Error &error, uint32_t type)
-{
-    ((ProcessWindows &)*m_process).OnDebuggerError(error, type);
-}
+//===-- LocalDebugDelegate.cpp ----------------------------------*- C++ -*-===//

+//

+//                     The LLVM Compiler Infrastructure

+//

+// This file is distributed under the University of Illinois Open Source

+// License. See LICENSE.TXT for details.

+//

+//===----------------------------------------------------------------------===//

+

+#include "LocalDebugDelegate.h"

+#include "ProcessWindows.h"

+

+using namespace lldb;

+using namespace lldb_private;

+

+LocalDebugDelegate::LocalDebugDelegate(ProcessSP process)

+    : m_process(process)

+{

+}

+

+void

+LocalDebugDelegate::OnExitProcess(uint32_t exit_code)

+{

+    ((ProcessWindows &)*m_process).OnExitProcess(exit_code);

+}

+

+void

+LocalDebugDelegate::OnDebuggerConnected(lldb::addr_t image_base)

+{

+    ((ProcessWindows &)*m_process).OnDebuggerConnected(image_base);

+}

+

+ExceptionResult

+LocalDebugDelegate::OnDebugException(bool first_chance, const ExceptionRecord &record)

+{

+    return ((ProcessWindows &)*m_process).OnDebugException(first_chance, record);

+}

+

+void

+LocalDebugDelegate::OnCreateThread(const HostThread &thread)

+{

+    ((ProcessWindows &)*m_process).OnCreateThread(thread);

+}

+

+void

+LocalDebugDelegate::OnExitThread(lldb::tid_t thread_id, uint32_t exit_code)

+{

+    ((ProcessWindows &)*m_process).OnExitThread(thread_id, exit_code);

+}

+

+void

+LocalDebugDelegate::OnLoadDll(const lldb_private::ModuleSpec &module_spec, lldb::addr_t module_addr)

+{

+    ((ProcessWindows &)*m_process).OnLoadDll(module_spec, module_addr);

+}

+

+void

+LocalDebugDelegate::OnUnloadDll(lldb::addr_t module_addr)

+{

+    ((ProcessWindows &)*m_process).OnUnloadDll(module_addr);

+}

+

+void

+LocalDebugDelegate::OnDebugString(const std::string &string)

+{

+    ((ProcessWindows &)*m_process).OnDebugString(string);

+}

+

+void

+LocalDebugDelegate::OnDebuggerError(const Error &error, uint32_t type)

+{

+    ((ProcessWindows &)*m_process).OnDebuggerError(error, type);

+}

diff --git a/lldb/source/Plugins/Process/Windows/LocalDebugDelegate.h b/lldb/source/Plugins/Process/Windows/Live/LocalDebugDelegate.h
index a14352d113a..5a1c29eaead 100644
--- a/lldb/source/Plugins/Process/Windows/LocalDebugDelegate.h
+++ b/lldb/source/Plugins/Process/Windows/Live/LocalDebugDelegate.h
@@ -1,60 +1,60 @@
-//===-- LocalDebugDelegate.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_Plugins_Process_Windows_LocalDebugDelegate_H_
-#define liblldb_Plugins_Process_Windows_LocalDebugDelegate_H_
-
-#include "IDebugDelegate.h"
-#include "lldb/lldb-forward.h"
-
-class ProcessWindows;
-
-namespace lldb_private
-{
-//----------------------------------------------------------------------
-// LocalDebugDelegate
-//
-// LocalDebugDelegate creates a connection between a ProcessWindows and the
-// debug driver.  This serves to decouple ProcessWindows from the debug driver.
-// It would be possible to get a similar decoupling by just having
-// ProcessWindows implement this interface directly.  There are two reasons why
-// we don't do this:
-//
-// 1) In the future when we add support for local debugging through LLGS, and we
-//    go through the Native*Protocol interface, it is likely we will need the
-//    additional flexibility provided by this sort of adapter pattern.
-// 2) LLDB holds a shared_ptr to the ProcessWindows, and our driver thread also
-//    also needs access to it as well.  To avoid a race condition, we want to
-//    make sure that we're also holding onto a shared_ptr.
-//    lldb_private::Process supports enable_shared_from_this, but that gives us
-//    a ProcessSP (which is exactly what we are trying to decouple from the
-//    driver), so this adapter serves as a way to transparently hold the
-//    ProcessSP while still keeping it decoupled from the driver.
-//----------------------------------------------------------------------
-class LocalDebugDelegate : public IDebugDelegate
-{
-  public:
-    explicit LocalDebugDelegate(lldb::ProcessSP process);
-
-    void OnExitProcess(uint32_t exit_code) override;
-    void OnDebuggerConnected(lldb::addr_t image_base) override;
-    ExceptionResult OnDebugException(bool first_chance, const ExceptionRecord &record) override;
-    void OnCreateThread(const HostThread &thread) override;
-    void OnExitThread(lldb::tid_t thread_id, uint32_t exit_code) override;
-    void OnLoadDll(const lldb_private::ModuleSpec &module_spec, lldb::addr_t module_addr) override;
-    void OnUnloadDll(lldb::addr_t module_addr) override;
-    void OnDebugString(const std::string &message) override;
-    void OnDebuggerError(const Error &error, uint32_t type) override;
-
-  private:
-    lldb::ProcessSP m_process;
-};
-}
-
-#endif
+//===-- LocalDebugDelegate.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_Plugins_Process_Windows_LocalDebugDelegate_H_

+#define liblldb_Plugins_Process_Windows_LocalDebugDelegate_H_

+

+#include "IDebugDelegate.h"

+#include "lldb/lldb-forward.h"

+

+class ProcessWindows;

+

+namespace lldb_private

+{

+//----------------------------------------------------------------------

+// LocalDebugDelegate

+//

+// LocalDebugDelegate creates a connection between a ProcessWindows and the

+// debug driver.  This serves to decouple ProcessWindows from the debug driver.

+// It would be possible to get a similar decoupling by just having

+// ProcessWindows implement this interface directly.  There are two reasons why

+// we don't do this:

+//

+// 1) In the future when we add support for local debugging through LLGS, and we

+//    go through the Native*Protocol interface, it is likely we will need the

+//    additional flexibility provided by this sort of adapter pattern.

+// 2) LLDB holds a shared_ptr to the ProcessWindows, and our driver thread also

+//    also needs access to it as well.  To avoid a race condition, we want to

+//    make sure that we're also holding onto a shared_ptr.

+//    lldb_private::Process supports enable_shared_from_this, but that gives us

+//    a ProcessSP (which is exactly what we are trying to decouple from the

+//    driver), so this adapter serves as a way to transparently hold the

+//    ProcessSP while still keeping it decoupled from the driver.

+//----------------------------------------------------------------------

+class LocalDebugDelegate : public IDebugDelegate

+{

+  public:

+    explicit LocalDebugDelegate(lldb::ProcessSP process);

+

+    void OnExitProcess(uint32_t exit_code) override;

+    void OnDebuggerConnected(lldb::addr_t image_base) override;

+    ExceptionResult OnDebugException(bool first_chance, const ExceptionRecord &record) override;

+    void OnCreateThread(const HostThread &thread) override;

+    void OnExitThread(lldb::tid_t thread_id, uint32_t exit_code) override;

+    void OnLoadDll(const lldb_private::ModuleSpec &module_spec, lldb::addr_t module_addr) override;

+    void OnUnloadDll(lldb::addr_t module_addr) override;

+    void OnDebugString(const std::string &message) override;

+    void OnDebuggerError(const Error &error, uint32_t type) override;

+

+  private:

+    lldb::ProcessSP m_process;

+};

+}

+

+#endif

diff --git a/lldb/source/Plugins/Process/Windows/ProcessWindows.cpp b/lldb/source/Plugins/Process/Windows/Live/ProcessWindows.cpp
index a11399057ef..7c13da8bb0b 100644
--- a/lldb/source/Plugins/Process/Windows/ProcessWindows.cpp
+++ b/lldb/source/Plugins/Process/Windows/Live/ProcessWindows.cpp
@@ -39,7 +39,7 @@
 #include "lldb/Target/StopInfo.h"
 #include "lldb/Target/Target.h"
 
-#include "Plugins/Process/Windows/ProcessWindowsLog.h"
+#include "Plugins/Process/Windows/live/ProcessWindowsLog.h"
 
 #include "DebuggerThread.h"
 #include "ExceptionRecord.h"
diff --git a/lldb/source/Plugins/Process/Windows/ProcessWindows.h b/lldb/source/Plugins/Process/Windows/Live/ProcessWindows.h
index 478819ecdbc..478819ecdbc 100644
--- a/lldb/source/Plugins/Process/Windows/ProcessWindows.h
+++ b/lldb/source/Plugins/Process/Windows/Live/ProcessWindows.h
diff --git a/lldb/source/Plugins/Process/Windows/ProcessWindowsLog.cpp b/lldb/source/Plugins/Process/Windows/Live/ProcessWindowsLog.cpp
index d641979b0b0..55c35bccbce 100644
--- a/lldb/source/Plugins/Process/Windows/ProcessWindowsLog.cpp
+++ b/lldb/source/Plugins/Process/Windows/Live/ProcessWindowsLog.cpp
@@ -1,190 +1,190 @@
-//===-- 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/Core/StreamFile.h"
-#include "lldb/Interpreter/Args.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 = nullptr;
-
-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);
-    });
-}
-
-void
-ProcessWindowsLog::Terminate()
-{
-}
-
-Log *
-ProcessWindowsLog::GetLog()
-{
-    return (g_log_enabled) ? g_log : nullptr;
-}
-
-bool
-ProcessWindowsLog::TestLogFlags(uint32_t mask, LogMaskReq req)
-{
-    Log *log = GetLog();
-    if (!log)
-        return false;
-
-    uint32_t log_mask = log->GetMask().Get();
-    if (req == LogMaskReq::All)
-        return ((log_mask & mask) == mask);
-    else
-        return (log_mask & mask);
-}
-
-static uint32_t
-GetFlagBits(const char *arg)
-{
-    if      (::strcasecmp(arg, "all") == 0 ) return WINDOWS_LOG_ALL;
-    else if (::strcasecmp(arg, "break") == 0 ) return WINDOWS_LOG_BREAKPOINTS;
-    else if (::strcasecmp(arg, "event") == 0 ) return WINDOWS_LOG_EVENT;
-    else if (::strcasecmp(arg, "exception") == 0 ) return WINDOWS_LOG_EXCEPTION;
-    else if (::strcasecmp(arg, "memory") == 0 ) return WINDOWS_LOG_MEMORY;
-    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_ALL;
-        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"
-                 "  break - log breakpoints\n"
-                 "  event - log low level debugger events\n"
-                 "  exception - log exception information\n"
-                 "  memory - log memory reads and writes\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);
-}
-
-const char *ProcessWindowsLog::m_pluginname = "";
+//===-- 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/Core/StreamFile.h"

+#include "lldb/Interpreter/Args.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 = nullptr;

+

+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);

+    });

+}

+

+void

+ProcessWindowsLog::Terminate()

+{

+}

+

+Log *

+ProcessWindowsLog::GetLog()

+{

+    return (g_log_enabled) ? g_log : nullptr;

+}

+

+bool

+ProcessWindowsLog::TestLogFlags(uint32_t mask, LogMaskReq req)

+{

+    Log *log = GetLog();

+    if (!log)

+        return false;

+

+    uint32_t log_mask = log->GetMask().Get();

+    if (req == LogMaskReq::All)

+        return ((log_mask & mask) == mask);

+    else

+        return (log_mask & mask);

+}

+

+static uint32_t

+GetFlagBits(const char *arg)

+{

+    if      (::strcasecmp(arg, "all") == 0 ) return WINDOWS_LOG_ALL;

+    else if (::strcasecmp(arg, "break") == 0 ) return WINDOWS_LOG_BREAKPOINTS;

+    else if (::strcasecmp(arg, "event") == 0 ) return WINDOWS_LOG_EVENT;

+    else if (::strcasecmp(arg, "exception") == 0 ) return WINDOWS_LOG_EXCEPTION;

+    else if (::strcasecmp(arg, "memory") == 0 ) return WINDOWS_LOG_MEMORY;

+    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_ALL;

+        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"

+                 "  break - log breakpoints\n"

+                 "  event - log low level debugger events\n"

+                 "  exception - log exception information\n"

+                 "  memory - log memory reads and writes\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);

+}

+

+const char *ProcessWindowsLog::m_pluginname = "";

diff --git a/lldb/source/Plugins/Process/Windows/ProcessWindowsLog.h b/lldb/source/Plugins/Process/Windows/Live/ProcessWindowsLog.h
index d798d131fae..4f021539624 100644
--- a/lldb/source/Plugins/Process/Windows/ProcessWindowsLog.h
+++ b/lldb/source/Plugins/Process/Windows/Live/ProcessWindowsLog.h
@@ -1,96 +1,96 @@
-//===-- 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)    // Log process operations
-#define WINDOWS_LOG_EXCEPTION   (1u << 1)    // Log exceptions
-#define WINDOWS_LOG_THREAD      (1u << 2)    // Log thread operations
-#define WINDOWS_LOG_MEMORY      (1u << 3)    // Log memory reads/writes calls
-#define WINDOWS_LOG_BREAKPOINTS (1u << 4)    // Log breakpoint operations
-#define WINDOWS_LOG_STEP        (1u << 5)    // Log step operations
-#define WINDOWS_LOG_REGISTERS   (1u << 6)    // Log register operations
-#define WINDOWS_LOG_EVENT       (1u << 7)    // Low level debug events
-#define WINDOWS_LOG_ALL         (UINT32_MAX)
-
-enum class LogMaskReq
-{
-    All,
-    Any
-};
-
-class ProcessWindowsLog
-{
-    static const char *m_pluginname;
-
-public:
-    // ---------------------------------------------------------------------
-    // Public Static Methods
-    // ---------------------------------------------------------------------
-    static void
-    Initialize();
-
-    static void
-    Terminate();
-
-    static void
-    RegisterPluginName(const char *pluginName)
-    {
-        m_pluginname = pluginName;
-    }
-
-    static void
-    RegisterPluginName(lldb_private::ConstString pluginName)
-    {
-        m_pluginname = pluginName.GetCString();
-    }
-
-    static bool
-    TestLogFlags(uint32_t mask, LogMaskReq req);
-
-    static lldb_private::Log *
-    GetLog();
-
-    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);
-};
-
-#define WINLOGF_IF(Flags, Req, Method, ...)              \
-    {                                                    \
-        if (ProcessWindowsLog::TestLogFlags(Flags, Req)) \
-        {                                                \
-            Log *log = ProcessWindowsLog::GetLog();      \
-            if (log)                                     \
-                log->Method(__VA_ARGS__);                \
-        }                                                \
-    }
-
-#define WINLOG_IFANY(Flags, ...) WINLOGF_IF(Flags, LogMaskReq::Any, Printf, __VA_ARGS__)
-#define WINLOG_IFALL(Flags, ...) WINLOGF_IF(Flags, LogMaskReq::All, Printf, __VA_ARGS__)
-#define WINLOGV_IFANY(Flags, ...) WINLOGF_IF(Flags, LogMaskReq::Any, Verbose, __VA_ARGS__)
-#define WINLOGV_IFALL(Flags, ...) WINLOGF_IF(Flags, LogMaskReq::All, Verbose, __VA_ARGS__)
-#define WINLOGD_IFANY(Flags, ...) WINLOGF_IF(Flags, LogMaskReq::Any, Debug, __VA_ARGS__)
-#define WINLOGD_IFALL(Flags, ...) WINLOGF_IF(Flags, LogMaskReq::All, Debug, __VA_ARGS__)
-#define WINERR_IFANY(Flags, ...) WINLOGF_IF(Flags, LogMaskReq::Any, Error, __VA_ARGS__)
-#define WINERR_IFALL(Flags, ...) WINLOGF_IF(Flags, LogMaskReq::All, Error, __VA_ARGS__)
-#define WINWARN_IFANY(Flags, ...) WINLOGF_IF(Flags, LogMaskReq::Any, Warning, __VA_ARGS__)
-#define WINWARN_IFALL(Flags, ...) WINLOGF_IF(Flags, LogMaskReq::All, Warning, __VA_ARGS__)
-
-#endif  // liblldb_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)    // Log process operations

+#define WINDOWS_LOG_EXCEPTION   (1u << 1)    // Log exceptions

+#define WINDOWS_LOG_THREAD      (1u << 2)    // Log thread operations

+#define WINDOWS_LOG_MEMORY      (1u << 3)    // Log memory reads/writes calls

+#define WINDOWS_LOG_BREAKPOINTS (1u << 4)    // Log breakpoint operations

+#define WINDOWS_LOG_STEP        (1u << 5)    // Log step operations

+#define WINDOWS_LOG_REGISTERS   (1u << 6)    // Log register operations

+#define WINDOWS_LOG_EVENT       (1u << 7)    // Low level debug events

+#define WINDOWS_LOG_ALL         (UINT32_MAX)

+

+enum class LogMaskReq

+{

+    All,

+    Any

+};

+

+class ProcessWindowsLog

+{

+    static const char *m_pluginname;

+

+public:

+    // ---------------------------------------------------------------------

+    // Public Static Methods

+    // ---------------------------------------------------------------------

+    static void

+    Initialize();

+

+    static void

+    Terminate();

+

+    static void

+    RegisterPluginName(const char *pluginName)

+    {

+        m_pluginname = pluginName;

+    }

+

+    static void

+    RegisterPluginName(lldb_private::ConstString pluginName)

+    {

+        m_pluginname = pluginName.GetCString();

+    }

+

+    static bool

+    TestLogFlags(uint32_t mask, LogMaskReq req);

+

+    static lldb_private::Log *

+    GetLog();

+

+    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);

+};

+

+#define WINLOGF_IF(Flags, Req, Method, ...)              \

+    {                                                    \

+        if (ProcessWindowsLog::TestLogFlags(Flags, Req)) \

+        {                                                \

+            Log *log = ProcessWindowsLog::GetLog();      \

+            if (log)                                     \

+                log->Method(__VA_ARGS__);                \

+        }                                                \

+    }

+

+#define WINLOG_IFANY(Flags, ...) WINLOGF_IF(Flags, LogMaskReq::Any, Printf, __VA_ARGS__)

+#define WINLOG_IFALL(Flags, ...) WINLOGF_IF(Flags, LogMaskReq::All, Printf, __VA_ARGS__)

+#define WINLOGV_IFANY(Flags, ...) WINLOGF_IF(Flags, LogMaskReq::Any, Verbose, __VA_ARGS__)

+#define WINLOGV_IFALL(Flags, ...) WINLOGF_IF(Flags, LogMaskReq::All, Verbose, __VA_ARGS__)

+#define WINLOGD_IFANY(Flags, ...) WINLOGF_IF(Flags, LogMaskReq::Any, Debug, __VA_ARGS__)

+#define WINLOGD_IFALL(Flags, ...) WINLOGF_IF(Flags, LogMaskReq::All, Debug, __VA_ARGS__)

+#define WINERR_IFANY(Flags, ...) WINLOGF_IF(Flags, LogMaskReq::Any, Error, __VA_ARGS__)

+#define WINERR_IFALL(Flags, ...) WINLOGF_IF(Flags, LogMaskReq::All, Error, __VA_ARGS__)

+#define WINWARN_IFANY(Flags, ...) WINLOGF_IF(Flags, LogMaskReq::Any, Warning, __VA_ARGS__)

+#define WINWARN_IFALL(Flags, ...) WINLOGF_IF(Flags, LogMaskReq::All, Warning, __VA_ARGS__)

+

+#endif  // liblldb_ProcessWindowsLog_h_

diff --git a/lldb/source/Plugins/Process/Windows/RegisterContextWindows.cpp b/lldb/source/Plugins/Process/Windows/Live/RegisterContextWindows.cpp
index d61675f09b1..8552b463541 100644
--- a/lldb/source/Plugins/Process/Windows/RegisterContextWindows.cpp
+++ b/lldb/source/Plugins/Process/Windows/Live/RegisterContextWindows.cpp
@@ -1,155 +1,155 @@
-//===-- RegisterContextWindows.cpp ------------------------------*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#include "lldb/lldb-private-types.h"
-#include "lldb/Core/DataBufferHeap.h"
-#include "lldb/Core/Error.h"
-#include "lldb/Host/windows/HostThreadWindows.h"
-#include "lldb/Host/windows/windows.h"
-
-#include "ProcessWindowsLog.h"
-#include "RegisterContextWindows.h"
-#include "TargetThreadWindows.h"
-
-#include "llvm/ADT/STLExtras.h"
-
-using namespace lldb;
-using namespace lldb_private;
-
-const DWORD kWinContextFlags = CONTEXT_CONTROL | CONTEXT_INTEGER;
-
-//------------------------------------------------------------------
-// Constructors and Destructors
-//------------------------------------------------------------------
-RegisterContextWindows::RegisterContextWindows(Thread &thread, uint32_t concrete_frame_idx)
-    : RegisterContext(thread, concrete_frame_idx)
-    , m_context()
-    , m_context_stale(true)
-{
-}
-
-RegisterContextWindows::~RegisterContextWindows()
-{
-}
-
-void
-RegisterContextWindows::InvalidateAllRegisters()
-{
-    m_context_stale = true;
-}
-
-bool
-RegisterContextWindows::ReadAllRegisterValues(lldb::DataBufferSP &data_sp)
-{
-    if (!CacheAllRegisterValues())
-        return false;
-    if (data_sp->GetByteSize() < sizeof(m_context))
-    {
-        data_sp.reset(new DataBufferHeap(sizeof(CONTEXT), 0));
-    }
-    memcpy(data_sp->GetBytes(), &m_context, sizeof(m_context));
-    return true;
-}
-
-bool
-RegisterContextWindows::WriteAllRegisterValues(const lldb::DataBufferSP &data_sp)
-{
-    assert(data_sp->GetByteSize() >= sizeof(m_context));
-    memcpy(&m_context, data_sp->GetBytes(), sizeof(m_context));
-
-    TargetThreadWindows &wthread = static_cast<TargetThreadWindows &>(m_thread);
-    if (!::SetThreadContext(wthread.GetHostThread().GetNativeThread().GetSystemHandle(), &m_context))
-        return false;
-
-    return true;
-}
-
-uint32_t
-RegisterContextWindows::ConvertRegisterKindToRegisterNumber(lldb::RegisterKind kind, uint32_t num)
-{
-    const uint32_t num_regs = GetRegisterCount();
-
-    assert(kind < kNumRegisterKinds);
-    for (uint32_t reg_idx = 0; reg_idx < num_regs; ++reg_idx)
-    {
-        const RegisterInfo *reg_info = GetRegisterInfoAtIndex(reg_idx);
-
-        if (reg_info->kinds[kind] == num)
-            return reg_idx;
-    }
-
-    return LLDB_INVALID_REGNUM;
-}
-
-//------------------------------------------------------------------
-// Subclasses can these functions if desired
-//------------------------------------------------------------------
-uint32_t
-RegisterContextWindows::NumSupportedHardwareBreakpoints()
-{
-    // Support for hardware breakpoints not yet implemented.
-    return 0;
-}
-
-uint32_t
-RegisterContextWindows::SetHardwareBreakpoint(lldb::addr_t addr, size_t size)
-{
-    return 0;
-}
-
-bool
-RegisterContextWindows::ClearHardwareBreakpoint(uint32_t hw_idx)
-{
-    return false;
-}
-
-uint32_t
-RegisterContextWindows::NumSupportedHardwareWatchpoints()
-{
-    // Support for hardware watchpoints not yet implemented.
-    return 0;
-}
-
-uint32_t
-RegisterContextWindows::SetHardwareWatchpoint(lldb::addr_t addr, size_t size, bool read, bool write)
-{
-    return 0;
-}
-
-bool
-RegisterContextWindows::ClearHardwareWatchpoint(uint32_t hw_index)
-{
-    return false;
-}
-
-bool
-RegisterContextWindows::HardwareSingleStep(bool enable)
-{
-    return false;
-}
-
-bool
-RegisterContextWindows::CacheAllRegisterValues()
-{
-    if (!m_context_stale)
-        return true;
-
-    TargetThreadWindows &wthread = static_cast<TargetThreadWindows &>(m_thread);
-    memset(&m_context, 0, sizeof(m_context));
-    m_context.ContextFlags = kWinContextFlags;
-    if (!::GetThreadContext(wthread.GetHostThread().GetNativeThread().GetSystemHandle(), &m_context))
-    {
-        WINERR_IFALL(WINDOWS_LOG_REGISTERS, "GetThreadContext failed with error %u while caching register values.",
-                     ::GetLastError());
-        return false;
-    }
-    WINLOG_IFALL(WINDOWS_LOG_REGISTERS, "GetThreadContext successfully updated the register values.", ::GetLastError());
-    m_context_stale = false;
-    return true;
-}
+//===-- RegisterContextWindows.cpp ------------------------------*- C++ -*-===//

+//

+//                     The LLVM Compiler Infrastructure

+//

+// This file is distributed under the University of Illinois Open Source

+// License. See LICENSE.TXT for details.

+//

+//===----------------------------------------------------------------------===//

+

+#include "lldb/lldb-private-types.h"

+#include "lldb/Core/DataBufferHeap.h"

+#include "lldb/Core/Error.h"

+#include "lldb/Host/windows/HostThreadWindows.h"

+#include "lldb/Host/windows/windows.h"

+

+#include "ProcessWindowsLog.h"

+#include "RegisterContextWindows.h"

+#include "TargetThreadWindows.h"

+

+#include "llvm/ADT/STLExtras.h"

+

+using namespace lldb;

+using namespace lldb_private;

+

+const DWORD kWinContextFlags = CONTEXT_CONTROL | CONTEXT_INTEGER;

+

+//------------------------------------------------------------------

+// Constructors and Destructors

+//------------------------------------------------------------------

+RegisterContextWindows::RegisterContextWindows(Thread &thread, uint32_t concrete_frame_idx)

+    : RegisterContext(thread, concrete_frame_idx)

+    , m_context()

+    , m_context_stale(true)

+{

+}

+

+RegisterContextWindows::~RegisterContextWindows()

+{

+}

+

+void

+RegisterContextWindows::InvalidateAllRegisters()

+{

+    m_context_stale = true;

+}

+

+bool

+RegisterContextWindows::ReadAllRegisterValues(lldb::DataBufferSP &data_sp)

+{

+    if (!CacheAllRegisterValues())

+        return false;

+    if (data_sp->GetByteSize() < sizeof(m_context))

+    {

+        data_sp.reset(new DataBufferHeap(sizeof(CONTEXT), 0));

+    }

+    memcpy(data_sp->GetBytes(), &m_context, sizeof(m_context));

+    return true;

+}

+

+bool

+RegisterContextWindows::WriteAllRegisterValues(const lldb::DataBufferSP &data_sp)

+{

+    assert(data_sp->GetByteSize() >= sizeof(m_context));

+    memcpy(&m_context, data_sp->GetBytes(), sizeof(m_context));

+

+    TargetThreadWindows &wthread = static_cast<TargetThreadWindows &>(m_thread);

+    if (!::SetThreadContext(wthread.GetHostThread().GetNativeThread().GetSystemHandle(), &m_context))

+        return false;

+

+    return true;

+}

+

+uint32_t

+RegisterContextWindows::ConvertRegisterKindToRegisterNumber(lldb::RegisterKind kind, uint32_t num)

+{

+    const uint32_t num_regs = GetRegisterCount();

+

+    assert(kind < kNumRegisterKinds);

+    for (uint32_t reg_idx = 0; reg_idx < num_regs; ++reg_idx)

+    {

+        const RegisterInfo *reg_info = GetRegisterInfoAtIndex(reg_idx);

+

+        if (reg_info->kinds[kind] == num)

+            return reg_idx;

+    }

+

+    return LLDB_INVALID_REGNUM;

+}

+

+//------------------------------------------------------------------

+// Subclasses can these functions if desired

+//------------------------------------------------------------------

+uint32_t

+RegisterContextWindows::NumSupportedHardwareBreakpoints()

+{

+    // Support for hardware breakpoints not yet implemented.

+    return 0;

+}

+

+uint32_t

+RegisterContextWindows::SetHardwareBreakpoint(lldb::addr_t addr, size_t size)

+{

+    return 0;

+}

+

+bool

+RegisterContextWindows::ClearHardwareBreakpoint(uint32_t hw_idx)

+{

+    return false;

+}

+

+uint32_t

+RegisterContextWindows::NumSupportedHardwareWatchpoints()

+{

+    // Support for hardware watchpoints not yet implemented.

+    return 0;

+}

+

+uint32_t

+RegisterContextWindows::SetHardwareWatchpoint(lldb::addr_t addr, size_t size, bool read, bool write)

+{

+    return 0;

+}

+

+bool

+RegisterContextWindows::ClearHardwareWatchpoint(uint32_t hw_index)

+{

+    return false;

+}

+

+bool

+RegisterContextWindows::HardwareSingleStep(bool enable)

+{

+    return false;

+}

+

+bool

+RegisterContextWindows::CacheAllRegisterValues()

+{

+    if (!m_context_stale)

+        return true;

+

+    TargetThreadWindows &wthread = static_cast<TargetThreadWindows &>(m_thread);

+    memset(&m_context, 0, sizeof(m_context));

+    m_context.ContextFlags = kWinContextFlags;

+    if (!::GetThreadContext(wthread.GetHostThread().GetNativeThread().GetSystemHandle(), &m_context))

+    {

+        WINERR_IFALL(WINDOWS_LOG_REGISTERS, "GetThreadContext failed with error %u while caching register values.",

+                     ::GetLastError());

+        return false;

+    }

+    WINLOG_IFALL(WINDOWS_LOG_REGISTERS, "GetThreadContext successfully updated the register values.", ::GetLastError());

+    m_context_stale = false;

+    return true;

+}

diff --git a/lldb/source/Plugins/Process/Windows/RegisterContextWindows.h b/lldb/source/Plugins/Process/Windows/Live/RegisterContextWindows.h
index e9eaf3bc34b..f742cd1151e 100644
--- a/lldb/source/Plugins/Process/Windows/RegisterContextWindows.h
+++ b/lldb/source/Plugins/Process/Windows/Live/RegisterContextWindows.h
@@ -1,69 +1,69 @@
-//===-- RegisterContextWindows.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_RegisterContextWindows_H_
-#define liblldb_RegisterContextWindows_H_
-
-#include "lldb/lldb-forward.h"
-#include "lldb/Target/RegisterContext.h"
-
-namespace lldb_private
-{
-
-class Thread;
-
-class RegisterContextWindows : public lldb_private::RegisterContext
-{
-  public:
-    //------------------------------------------------------------------
-    // Constructors and Destructors
-    //------------------------------------------------------------------
-    RegisterContextWindows(Thread &thread, uint32_t concrete_frame_idx);
-
-    virtual ~RegisterContextWindows();
-
-    //------------------------------------------------------------------
-    // Subclasses must override these functions
-    //------------------------------------------------------------------
-    void InvalidateAllRegisters() override;
-
-    bool ReadAllRegisterValues(lldb::DataBufferSP &data_sp) override;
-
-    bool WriteAllRegisterValues(const lldb::DataBufferSP &data_sp) override;
-
-    uint32_t ConvertRegisterKindToRegisterNumber(lldb::RegisterKind kind, uint32_t num) override;
-
-    //------------------------------------------------------------------
-    // Subclasses can override these functions if desired
-    //------------------------------------------------------------------
-    uint32_t NumSupportedHardwareBreakpoints() override;
-
-    uint32_t SetHardwareBreakpoint(lldb::addr_t addr, size_t size) override;
-
-    bool ClearHardwareBreakpoint(uint32_t hw_idx) override;
-
-    uint32_t NumSupportedHardwareWatchpoints() override;
-
-    uint32_t SetHardwareWatchpoint(lldb::addr_t addr, size_t size, bool read, bool write) override;
-
-    bool ClearHardwareWatchpoint(uint32_t hw_index) override;
-
-    bool HardwareSingleStep(bool enable) override;
-
-  protected:
-    bool CacheAllRegisterValues();
-
-    CONTEXT m_context;
-
-  private:
-    bool m_context_stale;
-};
-}
-
-#endif // #ifndef liblldb_RegisterContextPOSIX_x86_H_
+//===-- RegisterContextWindows.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_RegisterContextWindows_H_

+#define liblldb_RegisterContextWindows_H_

+

+#include "lldb/lldb-forward.h"

+#include "lldb/Target/RegisterContext.h"

+

+namespace lldb_private

+{

+

+class Thread;

+

+class RegisterContextWindows : public lldb_private::RegisterContext

+{

+  public:

+    //------------------------------------------------------------------

+    // Constructors and Destructors

+    //------------------------------------------------------------------

+    RegisterContextWindows(Thread &thread, uint32_t concrete_frame_idx);

+

+    virtual ~RegisterContextWindows();

+

+    //------------------------------------------------------------------

+    // Subclasses must override these functions

+    //------------------------------------------------------------------

+    void InvalidateAllRegisters() override;

+

+    bool ReadAllRegisterValues(lldb::DataBufferSP &data_sp) override;

+

+    bool WriteAllRegisterValues(const lldb::DataBufferSP &data_sp) override;

+

+    uint32_t ConvertRegisterKindToRegisterNumber(lldb::RegisterKind kind, uint32_t num) override;

+

+    //------------------------------------------------------------------

+    // Subclasses can override these functions if desired

+    //------------------------------------------------------------------

+    uint32_t NumSupportedHardwareBreakpoints() override;

+

+    uint32_t SetHardwareBreakpoint(lldb::addr_t addr, size_t size) override;

+

+    bool ClearHardwareBreakpoint(uint32_t hw_idx) override;

+

+    uint32_t NumSupportedHardwareWatchpoints() override;

+

+    uint32_t SetHardwareWatchpoint(lldb::addr_t addr, size_t size, bool read, bool write) override;

+

+    bool ClearHardwareWatchpoint(uint32_t hw_index) override;

+

+    bool HardwareSingleStep(bool enable) override;

+

+  protected:

+    bool CacheAllRegisterValues();

+

+    CONTEXT m_context;

+

+  private:

+    bool m_context_stale;

+};

+}

+

+#endif // #ifndef liblldb_RegisterContextPOSIX_x86_H_

diff --git a/lldb/source/Plugins/Process/Windows/TargetThreadWindows.cpp b/lldb/source/Plugins/Process/Windows/Live/TargetThreadWindows.cpp
index e849a920cd0..e849a920cd0 100644
--- a/lldb/source/Plugins/Process/Windows/TargetThreadWindows.cpp
+++ b/lldb/source/Plugins/Process/Windows/Live/TargetThreadWindows.cpp
diff --git a/lldb/source/Plugins/Process/Windows/TargetThreadWindows.h b/lldb/source/Plugins/Process/Windows/Live/TargetThreadWindows.h
index 8c46b3c93fe..025a199a905 100644
--- a/lldb/source/Plugins/Process/Windows/TargetThreadWindows.h
+++ b/lldb/source/Plugins/Process/Windows/Live/TargetThreadWindows.h
@@ -1,57 +1,57 @@
-//===-- TargetThreadWindows.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_Plugins_Process_Windows_TargetThreadWindows_H_
-#define liblldb_Plugins_Process_Windows_TargetThreadWindows_H_
-
-#include "ForwardDecl.h"
-#include "lldb/lldb-forward.h"
-#include "lldb/Host/HostThread.h"
-#include "lldb/Target/Thread.h"
-class ProcessWindows;
-
-namespace lldb_private
-{
-
-class HostThread;
-class StackFrame;
-
-class TargetThreadWindows : public lldb_private::Thread
-{
-  public:
-    TargetThreadWindows(ProcessWindows &process, const HostThread &thread);
-    virtual ~TargetThreadWindows();
-
-    // lldb_private::Thread overrides
-    void RefreshStateAfterStop() override;
-    void WillResume(lldb::StateType resume_state) override;
-    void DidStop() override;
-    lldb::RegisterContextSP GetRegisterContext() override;
-    lldb::RegisterContextSP CreateRegisterContextForFrame(StackFrame *frame) override;
-    bool CalculateStopInfo() override;
-    Unwind *GetUnwinder() override;
-
-    bool DoResume();
-
-    HostThread
-    GetHostThread() const
-    {
-        return m_host_thread;
-    }
-
-  private:
-    lldb::RegisterContextSP CreateRegisterContextForFrameIndex(uint32_t idx);
-
-    lldb::StackFrameUP m_stack_frame;
-
-    HostThread m_host_thread;
-};
-}
-
+//===-- TargetThreadWindows.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_Plugins_Process_Windows_TargetThreadWindows_H_

+#define liblldb_Plugins_Process_Windows_TargetThreadWindows_H_

+

+#include "ForwardDecl.h"

+#include "lldb/lldb-forward.h"

+#include "lldb/Host/HostThread.h"

+#include "lldb/Target/Thread.h"

+class ProcessWindows;

+

+namespace lldb_private

+{

+

+class HostThread;

+class StackFrame;

+

+class TargetThreadWindows : public lldb_private::Thread

+{

+  public:

+    TargetThreadWindows(ProcessWindows &process, const HostThread &thread);

+    virtual ~TargetThreadWindows();

+

+    // lldb_private::Thread overrides

+    void RefreshStateAfterStop() override;

+    void WillResume(lldb::StateType resume_state) override;

+    void DidStop() override;

+    lldb::RegisterContextSP GetRegisterContext() override;

+    lldb::RegisterContextSP CreateRegisterContextForFrame(StackFrame *frame) override;

+    bool CalculateStopInfo() override;

+    Unwind *GetUnwinder() override;

+

+    bool DoResume();

+

+    HostThread

+    GetHostThread() const

+    {

+        return m_host_thread;

+    }

+

+  private:

+    lldb::RegisterContextSP CreateRegisterContextForFrameIndex(uint32_t idx);

+

+    lldb::StackFrameUP m_stack_frame;

+

+    HostThread m_host_thread;

+};

+}

+

 #endif
\ No newline at end of file
diff --git a/lldb/source/Plugins/Process/Windows/x64/RegisterContextWindows_x64.cpp b/lldb/source/Plugins/Process/Windows/Live/x64/RegisterContextWindows_x64.cpp
index 2ea7572d574..1782aa7a7c6 100644
--- a/lldb/source/Plugins/Process/Windows/x64/RegisterContextWindows_x64.cpp
+++ b/lldb/source/Plugins/Process/Windows/Live/x64/RegisterContextWindows_x64.cpp
@@ -1,323 +1,323 @@
-//===-- RegisterContextWindows_x64.cpp --------------------------*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#include "lldb/lldb-private-types.h"
-#include "lldb/Core/Error.h"
-#include "lldb/Core/RegisterValue.h"
-#include "lldb/Host/windows/HostThreadWindows.h"
-#include "lldb/Host/windows/windows.h"
-
-#include "lldb-x86-register-enums.h"
-#include "RegisterContext_x86.h"
-#include "RegisterContextWindows_x64.h"
-#include "TargetThreadWindows.h"
-
-#include "llvm/ADT/STLExtras.h"
-
-using namespace lldb;
-using namespace lldb_private;
-
-#define DEFINE_GPR(reg, alt) #reg, alt, 8, 0, eEncodingUint, eFormatHexUppercase
-#define DEFINE_GPR_BIN(reg, alt) #reg, alt, 8, 0, eEncodingUint, eFormatBinary
-
-namespace
-{
-
-// This enum defines the layout of the global RegisterInfo array.  This is necessary because
-// lldb register sets are defined in terms of indices into the register array.  As such, the
-// order of RegisterInfos defined in global registers array must match the order defined here.
-// When defining the register set layouts, these values can appear in an arbitrary order, and that
-// determines the order that register values are displayed in a dump.
-enum RegisterIndex
-{
-    eRegisterIndexRax,
-    eRegisterIndexRbx,
-    eRegisterIndexRcx,
-    eRegisterIndexRdx,
-    eRegisterIndexRdi,
-    eRegisterIndexRsi,
-    eRegisterIndexR8,
-    eRegisterIndexR9,
-    eRegisterIndexR10,
-    eRegisterIndexR11,
-    eRegisterIndexR12,
-    eRegisterIndexR13,
-    eRegisterIndexR14,
-    eRegisterIndexR15,
-    eRegisterIndexRbp,
-    eRegisterIndexRsp,
-    eRegisterIndexRip,
-    eRegisterIndexRflags
-};
-
-// Array of all register information supported by Windows x86
-RegisterInfo g_register_infos[] = {
-    //  Macro auto defines most stuff     GCC                       DWARF                   GENERIC
-    //  GDB                  LLDB                  VALUE REGS    INVALIDATE REGS
-    //  ================================  ========================= ======================  =========================
-    //  ===================  =================     ==========    ===============
-    {DEFINE_GPR(rax, nullptr),
-     {gcc_dwarf_rax_x86_64, gcc_dwarf_rax_x86_64, LLDB_INVALID_REGNUM, gdb_rax_x86_64, lldb_rax_x86_64},
-     nullptr,
-     nullptr},
-    {DEFINE_GPR(rbx, nullptr),
-     {gcc_dwarf_rbx_x86_64, gcc_dwarf_rbx_x86_64, LLDB_INVALID_REGNUM, gdb_rbx_x86_64, lldb_rbx_x86_64},
-     nullptr,
-     nullptr},
-    {DEFINE_GPR(rcx, nullptr),
-     {gcc_dwarf_rcx_x86_64, gcc_dwarf_rcx_x86_64, LLDB_INVALID_REGNUM, gdb_rcx_x86_64, lldb_rcx_x86_64},
-     nullptr,
-     nullptr},
-    {DEFINE_GPR(rdx, nullptr),
-     {gcc_dwarf_rdx_x86_64, gcc_dwarf_rdx_x86_64, LLDB_INVALID_REGNUM, gdb_rdx_x86_64, lldb_rdx_x86_64},
-     nullptr,
-     nullptr},
-    {DEFINE_GPR(rdi, nullptr),
-     {gcc_dwarf_rdi_x86_64, gcc_dwarf_rdi_x86_64, LLDB_INVALID_REGNUM, gdb_rdi_x86_64, lldb_rdi_x86_64},
-     nullptr,
-     nullptr},
-    {DEFINE_GPR(rsi, nullptr),
-     {gcc_dwarf_rsi_x86_64, gcc_dwarf_rsi_x86_64, LLDB_INVALID_REGNUM, gdb_rsi_x86_64, lldb_rsi_x86_64},
-     nullptr,
-     nullptr},
-    {DEFINE_GPR(r8, nullptr),
-     {gcc_dwarf_r8_x86_64, gcc_dwarf_r8_x86_64, LLDB_INVALID_REGNUM, gdb_r8_x86_64, lldb_r8_x86_64},
-     nullptr,
-     nullptr},
-    {DEFINE_GPR(r9, nullptr),
-     {gcc_dwarf_r9_x86_64, gcc_dwarf_r9_x86_64, LLDB_INVALID_REGNUM, gdb_r9_x86_64, lldb_r9_x86_64},
-     nullptr,
-     nullptr},
-    {DEFINE_GPR(r10, nullptr),
-     {gcc_dwarf_r10_x86_64, gcc_dwarf_r10_x86_64, LLDB_INVALID_REGNUM, gdb_r10_x86_64, lldb_r10_x86_64},
-     nullptr,
-     nullptr},
-    {DEFINE_GPR(r11, nullptr),
-     {gcc_dwarf_r11_x86_64, gcc_dwarf_r11_x86_64, LLDB_INVALID_REGNUM, gdb_r11_x86_64, lldb_r11_x86_64},
-     nullptr,
-     nullptr},
-    {DEFINE_GPR(r12, nullptr),
-     {gcc_dwarf_r12_x86_64, gcc_dwarf_r12_x86_64, LLDB_INVALID_REGNUM, gdb_r12_x86_64, lldb_r12_x86_64},
-     nullptr,
-     nullptr},
-    {DEFINE_GPR(r13, nullptr),
-     {gcc_dwarf_r13_x86_64, gcc_dwarf_r13_x86_64, LLDB_INVALID_REGNUM, gdb_r13_x86_64, lldb_r13_x86_64},
-     nullptr,
-     nullptr},
-    {DEFINE_GPR(r14, nullptr),
-     {gcc_dwarf_r14_x86_64, gcc_dwarf_r14_x86_64, LLDB_INVALID_REGNUM, gdb_r14_x86_64, lldb_r14_x86_64},
-     nullptr,
-     nullptr},
-    {DEFINE_GPR(r15, nullptr),
-     {gcc_dwarf_r15_x86_64, gcc_dwarf_r15_x86_64, LLDB_INVALID_REGNUM, gdb_r15_x86_64, lldb_r15_x86_64},
-     nullptr,
-     nullptr},
-    {DEFINE_GPR(rbp, "fp"),
-     {gcc_dwarf_rbp_x86_64, gcc_dwarf_rbp_x86_64, LLDB_REGNUM_GENERIC_FP, gdb_rbp_x86_64, lldb_rbp_x86_64},
-     nullptr,
-     nullptr},
-    {DEFINE_GPR(rsp, "sp"),
-     {gcc_dwarf_rsp_x86_64, gcc_dwarf_rsp_x86_64, LLDB_REGNUM_GENERIC_SP, gdb_rsp_x86_64, lldb_rsp_x86_64},
-     nullptr,
-     nullptr},
-    {DEFINE_GPR(rip, "pc"),
-     {gcc_dwarf_rip_x86_64, gcc_dwarf_rip_x86_64, LLDB_REGNUM_GENERIC_PC, gdb_rip_x86_64, lldb_rip_x86_64},
-     nullptr,
-     nullptr},
-    {DEFINE_GPR_BIN(eflags, "flags"),
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_REGNUM_GENERIC_FLAGS, gdb_rflags_x86_64, lldb_rflags_x86_64},
-     nullptr,
-     nullptr},
-};
-
-// Array of lldb register numbers used to define the set of all General Purpose Registers
-uint32_t g_gpr_reg_indices[] = {eRegisterIndexRax, eRegisterIndexRbx,   eRegisterIndexRcx, eRegisterIndexRdx,
-                                eRegisterIndexRdi, eRegisterIndexRsi,   eRegisterIndexR8,  eRegisterIndexR9,
-                                eRegisterIndexR10, eRegisterIndexR11,   eRegisterIndexR12, eRegisterIndexR13,
-                                eRegisterIndexR14, eRegisterIndexR15,   eRegisterIndexRbp, eRegisterIndexRsp,
-                                eRegisterIndexRip, eRegisterIndexRflags};
-
-RegisterSet g_register_sets[] = {
-    {"General Purpose Registers", "gpr", llvm::array_lengthof(g_gpr_reg_indices), g_gpr_reg_indices},
-};
-}
-
-//------------------------------------------------------------------
-// Constructors and Destructors
-//------------------------------------------------------------------
-RegisterContextWindows_x64::RegisterContextWindows_x64(Thread &thread, uint32_t concrete_frame_idx)
-    : RegisterContextWindows(thread, concrete_frame_idx)
-{
-}
-
-RegisterContextWindows_x64::~RegisterContextWindows_x64()
-{
-}
-
-size_t
-RegisterContextWindows_x64::GetRegisterCount()
-{
-    return llvm::array_lengthof(g_register_infos);
-}
-
-const RegisterInfo *
-RegisterContextWindows_x64::GetRegisterInfoAtIndex(size_t reg)
-{
-    return &g_register_infos[reg];
-}
-
-size_t
-RegisterContextWindows_x64::GetRegisterSetCount()
-{
-    return llvm::array_lengthof(g_register_sets);
-}
-
-const RegisterSet *
-RegisterContextWindows_x64::GetRegisterSet(size_t reg_set)
-{
-    return &g_register_sets[reg_set];
-}
-
-bool
-RegisterContextWindows_x64::ReadRegister(const RegisterInfo *reg_info, RegisterValue &reg_value)
-{
-    if (!CacheAllRegisterValues())
-        return false;
-
-    switch (reg_info->kinds[eRegisterKindLLDB])
-    {
-        case lldb_rax_x86_64:
-            reg_value.SetUInt64(m_context.Rax);
-            break;
-        case lldb_rbx_x86_64:
-            reg_value.SetUInt64(m_context.Rbx);
-            break;
-        case lldb_rcx_x86_64:
-            reg_value.SetUInt64(m_context.Rcx);
-            break;
-        case lldb_rdx_x86_64:
-            reg_value.SetUInt64(m_context.Rdx);
-            break;
-        case lldb_rdi_x86_64:
-            reg_value.SetUInt64(m_context.Rdi);
-            break;
-        case lldb_rsi_x86_64:
-            reg_value.SetUInt64(m_context.Rsi);
-            break;
-        case lldb_r8_x86_64:
-            reg_value.SetUInt64(m_context.R8);
-            break;
-        case lldb_r9_x86_64:
-            reg_value.SetUInt64(m_context.R9);
-            break;
-        case lldb_r10_x86_64:
-            reg_value.SetUInt64(m_context.R10);
-            break;
-        case lldb_r11_x86_64:
-            reg_value.SetUInt64(m_context.R11);
-            break;
-        case lldb_r12_x86_64:
-            reg_value.SetUInt64(m_context.R12);
-            break;
-        case lldb_r13_x86_64:
-            reg_value.SetUInt64(m_context.R13);
-            break;
-        case lldb_r14_x86_64:
-            reg_value.SetUInt64(m_context.R14);
-            break;
-        case lldb_r15_x86_64:
-            reg_value.SetUInt64(m_context.R15);
-            break;
-        case lldb_rbp_x86_64:
-            reg_value.SetUInt64(m_context.Rbp);
-            break;
-        case lldb_rsp_x86_64:
-            reg_value.SetUInt64(m_context.Rsp);
-            break;
-        case lldb_rip_x86_64:
-            reg_value.SetUInt64(m_context.Rip);
-            break;
-        case lldb_rflags_x86_64:
-            reg_value.SetUInt64(m_context.EFlags);
-            break;
-    }
-    return true;
-}
-
-bool
-RegisterContextWindows_x64::WriteRegister(const RegisterInfo *reg_info, const RegisterValue &reg_value)
-{
-    // Since we cannot only write a single register value to the inferior, we need to make sure
-    // our cached copy of the register values are fresh.  Otherwise when writing EAX, for example,
-    // we may also overwrite some other register with a stale value.
-    if (!CacheAllRegisterValues())
-        return false;
-
-    switch (reg_info->kinds[eRegisterKindLLDB])
-    {
-        case lldb_rax_x86_64:
-            m_context.Rax = reg_value.GetAsUInt64();
-            break;
-        case lldb_rbx_x86_64:
-            m_context.Rbx = reg_value.GetAsUInt64();
-            break;
-        case lldb_rcx_x86_64:
-            m_context.Rcx = reg_value.GetAsUInt64();
-            break;
-        case lldb_rdx_x86_64:
-            m_context.Rdx = reg_value.GetAsUInt64();
-            break;
-        case lldb_rdi_x86_64:
-            m_context.Rdi = reg_value.GetAsUInt64();
-            break;
-        case lldb_rsi_x86_64:
-            m_context.Rsi = reg_value.GetAsUInt64();
-            break;
-        case lldb_r8_x86_64:
-            m_context.R8 = reg_value.GetAsUInt64();
-            break;
-        case lldb_r9_x86_64:
-            m_context.R9 = reg_value.GetAsUInt64();
-            break;
-        case lldb_r10_x86_64:
-            m_context.R10 = reg_value.GetAsUInt64();
-            break;
-        case lldb_r11_x86_64:
-            m_context.R11 = reg_value.GetAsUInt64();
-            break;
-        case lldb_r12_x86_64:
-            m_context.R12 = reg_value.GetAsUInt64();
-            break;
-        case lldb_r13_x86_64:
-            m_context.R13 = reg_value.GetAsUInt64();
-            break;
-        case lldb_r14_x86_64:
-            m_context.R14 = reg_value.GetAsUInt64();
-            break;
-        case lldb_r15_x86_64:
-            m_context.R15 = reg_value.GetAsUInt64();
-            break;
-        case lldb_rbp_x86_64:
-            m_context.Rbp = reg_value.GetAsUInt64();
-            break;
-        case lldb_rsp_x86_64:
-            m_context.Rsp = reg_value.GetAsUInt64();
-            break;
-        case lldb_rip_x86_64:
-            m_context.Rip = reg_value.GetAsUInt64();
-            break;
-        case lldb_rflags_x86_64:
-            m_context.EFlags = reg_value.GetAsUInt64();
-            break;
-    }
-
-    // Physically update the registers in the target process.
-    TargetThreadWindows &wthread = static_cast<TargetThreadWindows &>(m_thread);
-    return ::SetThreadContext(wthread.GetHostThread().GetNativeThread().GetSystemHandle(), &m_context);
-}
+//===-- RegisterContextWindows_x64.cpp --------------------------*- C++ -*-===//

+//

+//                     The LLVM Compiler Infrastructure

+//

+// This file is distributed under the University of Illinois Open Source

+// License. See LICENSE.TXT for details.

+//

+//===----------------------------------------------------------------------===//

+

+#include "lldb/lldb-private-types.h"

+#include "lldb/Core/Error.h"

+#include "lldb/Core/RegisterValue.h"

+#include "lldb/Host/windows/HostThreadWindows.h"

+#include "lldb/Host/windows/windows.h"

+

+#include "lldb-x86-register-enums.h"

+#include "RegisterContext_x86.h"

+#include "RegisterContextWindows_x64.h"

+#include "TargetThreadWindows.h"

+

+#include "llvm/ADT/STLExtras.h"

+

+using namespace lldb;

+using namespace lldb_private;

+

+#define DEFINE_GPR(reg, alt) #reg, alt, 8, 0, eEncodingUint, eFormatHexUppercase

+#define DEFINE_GPR_BIN(reg, alt) #reg, alt, 8, 0, eEncodingUint, eFormatBinary

+

+namespace

+{

+

+// This enum defines the layout of the global RegisterInfo array.  This is necessary because

+// lldb register sets are defined in terms of indices into the register array.  As such, the

+// order of RegisterInfos defined in global registers array must match the order defined here.

+// When defining the register set layouts, these values can appear in an arbitrary order, and that

+// determines the order that register values are displayed in a dump.

+enum RegisterIndex

+{

+    eRegisterIndexRax,

+    eRegisterIndexRbx,

+    eRegisterIndexRcx,

+    eRegisterIndexRdx,

+    eRegisterIndexRdi,

+    eRegisterIndexRsi,

+    eRegisterIndexR8,

+    eRegisterIndexR9,

+    eRegisterIndexR10,

+    eRegisterIndexR11,

+    eRegisterIndexR12,

+    eRegisterIndexR13,

+    eRegisterIndexR14,

+    eRegisterIndexR15,

+    eRegisterIndexRbp,

+    eRegisterIndexRsp,

+    eRegisterIndexRip,

+    eRegisterIndexRflags

+};

+

+// Array of all register information supported by Windows x86

+RegisterInfo g_register_infos[] = {

+    //  Macro auto defines most stuff     GCC                       DWARF                   GENERIC

+    //  GDB                  LLDB                  VALUE REGS    INVALIDATE REGS

+    //  ================================  ========================= ======================  =========================

+    //  ===================  =================     ==========    ===============

+    {DEFINE_GPR(rax, nullptr),

+     {gcc_dwarf_rax_x86_64, gcc_dwarf_rax_x86_64, LLDB_INVALID_REGNUM, gdb_rax_x86_64, lldb_rax_x86_64},

+     nullptr,

+     nullptr},

+    {DEFINE_GPR(rbx, nullptr),

+     {gcc_dwarf_rbx_x86_64, gcc_dwarf_rbx_x86_64, LLDB_INVALID_REGNUM, gdb_rbx_x86_64, lldb_rbx_x86_64},

+     nullptr,

+     nullptr},

+    {DEFINE_GPR(rcx, nullptr),

+     {gcc_dwarf_rcx_x86_64, gcc_dwarf_rcx_x86_64, LLDB_INVALID_REGNUM, gdb_rcx_x86_64, lldb_rcx_x86_64},

+     nullptr,

+     nullptr},

+    {DEFINE_GPR(rdx, nullptr),

+     {gcc_dwarf_rdx_x86_64, gcc_dwarf_rdx_x86_64, LLDB_INVALID_REGNUM, gdb_rdx_x86_64, lldb_rdx_x86_64},

+     nullptr,

+     nullptr},

+    {DEFINE_GPR(rdi, nullptr),

+     {gcc_dwarf_rdi_x86_64, gcc_dwarf_rdi_x86_64, LLDB_INVALID_REGNUM, gdb_rdi_x86_64, lldb_rdi_x86_64},

+     nullptr,

+     nullptr},

+    {DEFINE_GPR(rsi, nullptr),

+     {gcc_dwarf_rsi_x86_64, gcc_dwarf_rsi_x86_64, LLDB_INVALID_REGNUM, gdb_rsi_x86_64, lldb_rsi_x86_64},

+     nullptr,

+     nullptr},

+    {DEFINE_GPR(r8, nullptr),

+     {gcc_dwarf_r8_x86_64, gcc_dwarf_r8_x86_64, LLDB_INVALID_REGNUM, gdb_r8_x86_64, lldb_r8_x86_64},

+     nullptr,

+     nullptr},

+    {DEFINE_GPR(r9, nullptr),

+     {gcc_dwarf_r9_x86_64, gcc_dwarf_r9_x86_64, LLDB_INVALID_REGNUM, gdb_r9_x86_64, lldb_r9_x86_64},

+     nullptr,

+     nullptr},

+    {DEFINE_GPR(r10, nullptr),

+     {gcc_dwarf_r10_x86_64, gcc_dwarf_r10_x86_64, LLDB_INVALID_REGNUM, gdb_r10_x86_64, lldb_r10_x86_64},

+     nullptr,

+     nullptr},

+    {DEFINE_GPR(r11, nullptr),

+     {gcc_dwarf_r11_x86_64, gcc_dwarf_r11_x86_64, LLDB_INVALID_REGNUM, gdb_r11_x86_64, lldb_r11_x86_64},

+     nullptr,

+     nullptr},

+    {DEFINE_GPR(r12, nullptr),

+     {gcc_dwarf_r12_x86_64, gcc_dwarf_r12_x86_64, LLDB_INVALID_REGNUM, gdb_r12_x86_64, lldb_r12_x86_64},

+     nullptr,

+     nullptr},

+    {DEFINE_GPR(r13, nullptr),

+     {gcc_dwarf_r13_x86_64, gcc_dwarf_r13_x86_64, LLDB_INVALID_REGNUM, gdb_r13_x86_64, lldb_r13_x86_64},

+     nullptr,

+     nullptr},

+    {DEFINE_GPR(r14, nullptr),

+     {gcc_dwarf_r14_x86_64, gcc_dwarf_r14_x86_64, LLDB_INVALID_REGNUM, gdb_r14_x86_64, lldb_r14_x86_64},

+     nullptr,

+     nullptr},

+    {DEFINE_GPR(r15, nullptr),

+     {gcc_dwarf_r15_x86_64, gcc_dwarf_r15_x86_64, LLDB_INVALID_REGNUM, gdb_r15_x86_64, lldb_r15_x86_64},

+     nullptr,

+     nullptr},

+    {DEFINE_GPR(rbp, "fp"),

+     {gcc_dwarf_rbp_x86_64, gcc_dwarf_rbp_x86_64, LLDB_REGNUM_GENERIC_FP, gdb_rbp_x86_64, lldb_rbp_x86_64},

+     nullptr,

+     nullptr},

+    {DEFINE_GPR(rsp, "sp"),

+     {gcc_dwarf_rsp_x86_64, gcc_dwarf_rsp_x86_64, LLDB_REGNUM_GENERIC_SP, gdb_rsp_x86_64, lldb_rsp_x86_64},

+     nullptr,

+     nullptr},

+    {DEFINE_GPR(rip, "pc"),

+     {gcc_dwarf_rip_x86_64, gcc_dwarf_rip_x86_64, LLDB_REGNUM_GENERIC_PC, gdb_rip_x86_64, lldb_rip_x86_64},

+     nullptr,

+     nullptr},

+    {DEFINE_GPR_BIN(eflags, "flags"),

+     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_REGNUM_GENERIC_FLAGS, gdb_rflags_x86_64, lldb_rflags_x86_64},

+     nullptr,

+     nullptr},

+};

+

+// Array of lldb register numbers used to define the set of all General Purpose Registers

+uint32_t g_gpr_reg_indices[] = {eRegisterIndexRax, eRegisterIndexRbx,   eRegisterIndexRcx, eRegisterIndexRdx,

+                                eRegisterIndexRdi, eRegisterIndexRsi,   eRegisterIndexR8,  eRegisterIndexR9,

+                                eRegisterIndexR10, eRegisterIndexR11,   eRegisterIndexR12, eRegisterIndexR13,

+                                eRegisterIndexR14, eRegisterIndexR15,   eRegisterIndexRbp, eRegisterIndexRsp,

+                                eRegisterIndexRip, eRegisterIndexRflags};

+

+RegisterSet g_register_sets[] = {

+    {"General Purpose Registers", "gpr", llvm::array_lengthof(g_gpr_reg_indices), g_gpr_reg_indices},

+};

+}

+

+//------------------------------------------------------------------

+// Constructors and Destructors

+//------------------------------------------------------------------

+RegisterContextWindows_x64::RegisterContextWindows_x64(Thread &thread, uint32_t concrete_frame_idx)

+    : RegisterContextWindows(thread, concrete_frame_idx)

+{

+}

+

+RegisterContextWindows_x64::~RegisterContextWindows_x64()

+{

+}

+

+size_t

+RegisterContextWindows_x64::GetRegisterCount()

+{

+    return llvm::array_lengthof(g_register_infos);

+}

+

+const RegisterInfo *

+RegisterContextWindows_x64::GetRegisterInfoAtIndex(size_t reg)

+{

+    return &g_register_infos[reg];

+}

+

+size_t

+RegisterContextWindows_x64::GetRegisterSetCount()

+{

+    return llvm::array_lengthof(g_register_sets);

+}

+

+const RegisterSet *

+RegisterContextWindows_x64::GetRegisterSet(size_t reg_set)

+{

+    return &g_register_sets[reg_set];

+}

+

+bool

+RegisterContextWindows_x64::ReadRegister(const RegisterInfo *reg_info, RegisterValue &reg_value)

+{

+    if (!CacheAllRegisterValues())

+        return false;

+

+    switch (reg_info->kinds[eRegisterKindLLDB])

+    {

+        case lldb_rax_x86_64:

+            reg_value.SetUInt64(m_context.Rax);

+            break;

+        case lldb_rbx_x86_64:

+            reg_value.SetUInt64(m_context.Rbx);

+            break;

+        case lldb_rcx_x86_64:

+            reg_value.SetUInt64(m_context.Rcx);

+            break;

+        case lldb_rdx_x86_64:

+            reg_value.SetUInt64(m_context.Rdx);

+            break;

+        case lldb_rdi_x86_64:

+            reg_value.SetUInt64(m_context.Rdi);

+            break;

+        case lldb_rsi_x86_64:

+            reg_value.SetUInt64(m_context.Rsi);

+            break;

+        case lldb_r8_x86_64:

+            reg_value.SetUInt64(m_context.R8);

+            break;

+        case lldb_r9_x86_64:

+            reg_value.SetUInt64(m_context.R9);

+            break;

+        case lldb_r10_x86_64:

+            reg_value.SetUInt64(m_context.R10);

+            break;

+        case lldb_r11_x86_64:

+            reg_value.SetUInt64(m_context.R11);

+            break;

+        case lldb_r12_x86_64:

+            reg_value.SetUInt64(m_context.R12);

+            break;

+        case lldb_r13_x86_64:

+            reg_value.SetUInt64(m_context.R13);

+            break;

+        case lldb_r14_x86_64:

+            reg_value.SetUInt64(m_context.R14);

+            break;

+        case lldb_r15_x86_64:

+            reg_value.SetUInt64(m_context.R15);

+            break;

+        case lldb_rbp_x86_64:

+            reg_value.SetUInt64(m_context.Rbp);

+            break;

+        case lldb_rsp_x86_64:

+            reg_value.SetUInt64(m_context.Rsp);

+            break;

+        case lldb_rip_x86_64:

+            reg_value.SetUInt64(m_context.Rip);

+            break;

+        case lldb_rflags_x86_64:

+            reg_value.SetUInt64(m_context.EFlags);

+            break;

+    }

+    return true;

+}

+

+bool

+RegisterContextWindows_x64::WriteRegister(const RegisterInfo *reg_info, const RegisterValue &reg_value)

+{

+    // Since we cannot only write a single register value to the inferior, we need to make sure

+    // our cached copy of the register values are fresh.  Otherwise when writing EAX, for example,

+    // we may also overwrite some other register with a stale value.

+    if (!CacheAllRegisterValues())

+        return false;

+

+    switch (reg_info->kinds[eRegisterKindLLDB])

+    {

+        case lldb_rax_x86_64:

+            m_context.Rax = reg_value.GetAsUInt64();

+            break;

+        case lldb_rbx_x86_64:

+            m_context.Rbx = reg_value.GetAsUInt64();

+            break;

+        case lldb_rcx_x86_64:

+            m_context.Rcx = reg_value.GetAsUInt64();

+            break;

+        case lldb_rdx_x86_64:

+            m_context.Rdx = reg_value.GetAsUInt64();

+            break;

+        case lldb_rdi_x86_64:

+            m_context.Rdi = reg_value.GetAsUInt64();

+            break;

+        case lldb_rsi_x86_64:

+            m_context.Rsi = reg_value.GetAsUInt64();

+            break;

+        case lldb_r8_x86_64:

+            m_context.R8 = reg_value.GetAsUInt64();

+            break;

+        case lldb_r9_x86_64:

+            m_context.R9 = reg_value.GetAsUInt64();

+            break;

+        case lldb_r10_x86_64:

+            m_context.R10 = reg_value.GetAsUInt64();

+            break;

+        case lldb_r11_x86_64:

+            m_context.R11 = reg_value.GetAsUInt64();

+            break;

+        case lldb_r12_x86_64:

+            m_context.R12 = reg_value.GetAsUInt64();

+            break;

+        case lldb_r13_x86_64:

+            m_context.R13 = reg_value.GetAsUInt64();

+            break;

+        case lldb_r14_x86_64:

+            m_context.R14 = reg_value.GetAsUInt64();

+            break;

+        case lldb_r15_x86_64:

+            m_context.R15 = reg_value.GetAsUInt64();

+            break;

+        case lldb_rbp_x86_64:

+            m_context.Rbp = reg_value.GetAsUInt64();

+            break;

+        case lldb_rsp_x86_64:

+            m_context.Rsp = reg_value.GetAsUInt64();

+            break;

+        case lldb_rip_x86_64:

+            m_context.Rip = reg_value.GetAsUInt64();

+            break;

+        case lldb_rflags_x86_64:

+            m_context.EFlags = reg_value.GetAsUInt64();

+            break;

+    }

+

+    // Physically update the registers in the target process.

+    TargetThreadWindows &wthread = static_cast<TargetThreadWindows &>(m_thread);

+    return ::SetThreadContext(wthread.GetHostThread().GetNativeThread().GetSystemHandle(), &m_context);

+}

diff --git a/lldb/source/Plugins/Process/Windows/x64/RegisterContextWindows_x64.h b/lldb/source/Plugins/Process/Windows/Live/x64/RegisterContextWindows_x64.h
index 15e803f6a71..b369d1a7861 100644
--- a/lldb/source/Plugins/Process/Windows/x64/RegisterContextWindows_x64.h
+++ b/lldb/source/Plugins/Process/Windows/Live/x64/RegisterContextWindows_x64.h
@@ -1,48 +1,48 @@
-//===-- RegisterContextWindows_x64.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_RegisterContextWindows_x64_H_
-#define liblldb_RegisterContextWindows_x64_H_
-
-#include "lldb/lldb-forward.h"
-#include "RegisterContextWindows.h"
-
-namespace lldb_private
-{
-
-class Thread;
-
-class RegisterContextWindows_x64 : public RegisterContextWindows
-{
-  public:
-    //------------------------------------------------------------------
-    // Constructors and Destructors
-    //------------------------------------------------------------------
-    RegisterContextWindows_x64(Thread &thread, uint32_t concrete_frame_idx);
-
-    virtual ~RegisterContextWindows_x64();
-
-    //------------------------------------------------------------------
-    // Subclasses must override these functions
-    //------------------------------------------------------------------
-    size_t GetRegisterCount() override;
-
-    const RegisterInfo *GetRegisterInfoAtIndex(size_t reg) override;
-
-    size_t GetRegisterSetCount() override;
-
-    const RegisterSet *GetRegisterSet(size_t reg_set) override;
-
-    bool ReadRegister(const RegisterInfo *reg_info, RegisterValue &reg_value) override;
-
-    bool WriteRegister(const RegisterInfo *reg_info, const RegisterValue &reg_value) override;
-};
-}
-
-#endif // #ifndef liblldb_RegisterContextPOSIX_x64_H_
+//===-- RegisterContextWindows_x64.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_RegisterContextWindows_x64_H_

+#define liblldb_RegisterContextWindows_x64_H_

+

+#include "lldb/lldb-forward.h"

+#include "RegisterContextWindows.h"

+

+namespace lldb_private

+{

+

+class Thread;

+

+class RegisterContextWindows_x64 : public RegisterContextWindows

+{

+  public:

+    //------------------------------------------------------------------

+    // Constructors and Destructors

+    //------------------------------------------------------------------

+    RegisterContextWindows_x64(Thread &thread, uint32_t concrete_frame_idx);

+

+    virtual ~RegisterContextWindows_x64();

+

+    //------------------------------------------------------------------

+    // Subclasses must override these functions

+    //------------------------------------------------------------------

+    size_t GetRegisterCount() override;

+

+    const RegisterInfo *GetRegisterInfoAtIndex(size_t reg) override;

+

+    size_t GetRegisterSetCount() override;

+

+    const RegisterSet *GetRegisterSet(size_t reg_set) override;

+

+    bool ReadRegister(const RegisterInfo *reg_info, RegisterValue &reg_value) override;

+

+    bool WriteRegister(const RegisterInfo *reg_info, const RegisterValue &reg_value) override;

+};

+}

+

+#endif // #ifndef liblldb_RegisterContextPOSIX_x64_H_

diff --git a/lldb/source/Plugins/Process/Windows/x86/RegisterContextWindows_x86.cpp b/lldb/source/Plugins/Process/Windows/Live/x86/RegisterContextWindows_x86.cpp
index 688143e6663..5fdb95c32f5 100644
--- a/lldb/source/Plugins/Process/Windows/x86/RegisterContextWindows_x86.cpp
+++ b/lldb/source/Plugins/Process/Windows/Live/x86/RegisterContextWindows_x86.cpp
@@ -1,241 +1,241 @@
-//===-- RegisterContextWindows_x86.h ----------------------------*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#include "lldb/lldb-private-types.h"
-#include "lldb/Core/Error.h"
-#include "lldb/Core/RegisterValue.h"
-#include "lldb/Host/windows/HostThreadWindows.h"
-#include "lldb/Host/windows/windows.h"
-
-#include "lldb-x86-register-enums.h"
-#include "ProcessWindowsLog.h"
-#include "RegisterContext_x86.h"
-#include "RegisterContextWindows_x86.h"
-#include "TargetThreadWindows.h"
-
-#include "llvm/ADT/STLExtras.h"
-
-using namespace lldb;
-using namespace lldb_private;
-
-#define DEFINE_GPR(reg, alt) #reg, alt, 4, 0, eEncodingUint, eFormatHexUppercase
-#define DEFINE_GPR_BIN(reg, alt) #reg, alt, 4, 0, eEncodingUint, eFormatBinary
-
-namespace
-{
-
-// This enum defines the layout of the global RegisterInfo array.  This is necessary because
-// lldb register sets are defined in terms of indices into the register array.  As such, the
-// order of RegisterInfos defined in global registers array must match the order defined here.
-// When defining the register set layouts, these values can appear in an arbitrary order, and that
-// determines the order that register values are displayed in a dump.
-enum RegisterIndex
-{
-    eRegisterIndexEax,
-    eRegisterIndexEbx,
-    eRegisterIndexEcx,
-    eRegisterIndexEdx,
-    eRegisterIndexEdi,
-    eRegisterIndexEsi,
-    eRegisterIndexEbp,
-    eRegisterIndexEsp,
-    eRegisterIndexEip,
-    eRegisterIndexEflags
-};
-
-// Array of all register information supported by Windows x86
-RegisterInfo g_register_infos[] =
-{
-//  Macro auto defines most stuff   GCC                     DWARF                GENERIC                    GDB                   LLDB               VALUE REGS    INVALIDATE REGS
-//  ==============================  ======================= ===================  =========================  ===================   =================  ==========    ===============
-    { DEFINE_GPR(eax,    nullptr),  { gcc_eax_i386,         dwarf_eax_i386,      LLDB_INVALID_REGNUM,       LLDB_INVALID_REGNUM,  lldb_eax_i386   },  nullptr,      nullptr},
-    { DEFINE_GPR(ebx,    nullptr),  { gcc_ebx_i386,         dwarf_ebx_i386,      LLDB_INVALID_REGNUM,       LLDB_INVALID_REGNUM,  lldb_ebx_i386   },  nullptr,      nullptr},
-    { DEFINE_GPR(ecx,    nullptr),  { gcc_ecx_i386,         dwarf_ecx_i386,      LLDB_INVALID_REGNUM,       LLDB_INVALID_REGNUM,  lldb_ecx_i386   },  nullptr,      nullptr},
-    { DEFINE_GPR(edx,    nullptr),  { gcc_edx_i386,         dwarf_edx_i386,      LLDB_INVALID_REGNUM,       LLDB_INVALID_REGNUM,  lldb_edx_i386   },  nullptr,      nullptr},
-    { DEFINE_GPR(edi,    nullptr),  { gcc_edi_i386,         dwarf_edi_i386,      LLDB_INVALID_REGNUM,       LLDB_INVALID_REGNUM,  lldb_edi_i386   },  nullptr,      nullptr},
-    { DEFINE_GPR(esi,    nullptr),  { gcc_esi_i386,         dwarf_esi_i386,      LLDB_INVALID_REGNUM,       LLDB_INVALID_REGNUM,  lldb_esi_i386   },  nullptr,      nullptr},
-    { DEFINE_GPR(ebp,    "fp"),     { gcc_ebp_i386,         dwarf_ebp_i386,      LLDB_REGNUM_GENERIC_FP,    LLDB_INVALID_REGNUM,  lldb_ebp_i386   },  nullptr,      nullptr},
-    { DEFINE_GPR(esp,    "sp"),     { gcc_esp_i386,         dwarf_esp_i386,      LLDB_REGNUM_GENERIC_SP,    LLDB_INVALID_REGNUM,  lldb_esp_i386   },  nullptr,      nullptr},
-    { DEFINE_GPR(eip,    "pc"),     { gcc_eip_i386,         dwarf_eip_i386,      LLDB_REGNUM_GENERIC_PC,    LLDB_INVALID_REGNUM,  lldb_eip_i386   },  nullptr,      nullptr},
-    { DEFINE_GPR_BIN(eflags, "flags"), { gcc_eflags_i386,   dwarf_eflags_i386,   LLDB_REGNUM_GENERIC_FLAGS, LLDB_INVALID_REGNUM,  lldb_eflags_i386},  nullptr,      nullptr},
-};
-
-// Array of lldb register numbers used to define the set of all General Purpose Registers
-uint32_t g_gpr_reg_indices[] =
-{
-    eRegisterIndexEax,
-    eRegisterIndexEbx,
-    eRegisterIndexEcx,
-    eRegisterIndexEdx,
-    eRegisterIndexEdi,
-    eRegisterIndexEsi,
-    eRegisterIndexEbp,
-    eRegisterIndexEsp,
-    eRegisterIndexEip,
-    eRegisterIndexEflags
-};
-
-RegisterSet g_register_sets[] = {
-    {"General Purpose Registers", "gpr", llvm::array_lengthof(g_gpr_reg_indices), g_gpr_reg_indices},
-};
-}
-
-//------------------------------------------------------------------
-// Constructors and Destructors
-//------------------------------------------------------------------
-RegisterContextWindows_x86::RegisterContextWindows_x86(Thread &thread, uint32_t concrete_frame_idx)
-    : RegisterContextWindows(thread, concrete_frame_idx)
-{
-}
-
-RegisterContextWindows_x86::~RegisterContextWindows_x86()
-{
-}
-
-size_t
-RegisterContextWindows_x86::GetRegisterCount()
-{
-    return llvm::array_lengthof(g_register_infos);
-}
-
-const RegisterInfo *
-RegisterContextWindows_x86::GetRegisterInfoAtIndex(size_t reg)
-{
-    return &g_register_infos[reg];
-}
-
-size_t
-RegisterContextWindows_x86::GetRegisterSetCount()
-{
-    return llvm::array_lengthof(g_register_sets);
-}
-
-const RegisterSet *
-RegisterContextWindows_x86::GetRegisterSet(size_t reg_set)
-{
-    return &g_register_sets[reg_set];
-}
-
-bool
-RegisterContextWindows_x86::ReadRegister(const RegisterInfo *reg_info, RegisterValue &reg_value)
-{
-    if (!CacheAllRegisterValues())
-        return false;
-
-    uint32_t reg = reg_info->kinds[eRegisterKindLLDB];
-    switch (reg)
-    {
-        case lldb_eax_i386:
-            WINLOG_IFALL(WINDOWS_LOG_REGISTERS, "Read value 0x%x from EAX", m_context.Eax);
-            reg_value.SetUInt32(m_context.Eax);
-            break;
-        case lldb_ebx_i386:
-            WINLOG_IFALL(WINDOWS_LOG_REGISTERS, "Read value 0x%x from EBX", m_context.Ebx);
-            reg_value.SetUInt32(m_context.Ebx);
-            break;
-        case lldb_ecx_i386:
-            WINLOG_IFALL(WINDOWS_LOG_REGISTERS, "Read value 0x%x from ECX", m_context.Ecx);
-            reg_value.SetUInt32(m_context.Ecx);
-            break;
-        case lldb_edx_i386:
-            WINLOG_IFALL(WINDOWS_LOG_REGISTERS, "Read value 0x%x from EDX", m_context.Edx);
-            reg_value.SetUInt32(m_context.Edx);
-            break;
-        case lldb_edi_i386:
-            WINLOG_IFALL(WINDOWS_LOG_REGISTERS, "Read value 0x%x from EDI", m_context.Edi);
-            reg_value.SetUInt32(m_context.Edi);
-            break;
-        case lldb_esi_i386:
-            WINLOG_IFALL(WINDOWS_LOG_REGISTERS, "Read value 0x%x from ESI", m_context.Esi);
-            reg_value.SetUInt32(m_context.Esi);
-            break;
-        case lldb_ebp_i386:
-            WINLOG_IFALL(WINDOWS_LOG_REGISTERS, "Read value 0x%x from EBP", m_context.Ebp);
-            reg_value.SetUInt32(m_context.Ebp);
-            break;
-        case lldb_esp_i386:
-            WINLOG_IFALL(WINDOWS_LOG_REGISTERS, "Read value 0x%x from ESP", m_context.Esp);
-            reg_value.SetUInt32(m_context.Esp);
-            break;
-        case lldb_eip_i386:
-            WINLOG_IFALL(WINDOWS_LOG_REGISTERS, "Read value 0x%x from EIP", m_context.Eip);
-            reg_value.SetUInt32(m_context.Eip);
-            break;
-        case lldb_eflags_i386:
-            WINLOG_IFALL(WINDOWS_LOG_REGISTERS, "Read value 0x%x from EFLAGS", m_context.EFlags);
-            reg_value.SetUInt32(m_context.EFlags);
-            break;
-        default:
-            WINWARN_IFALL(WINDOWS_LOG_REGISTERS, "Requested unknown register %u", reg);
-            break;
-    }
-    return true;
-}
-
-bool
-RegisterContextWindows_x86::WriteRegister(const RegisterInfo *reg_info, const RegisterValue &reg_value)
-{
-    // Since we cannot only write a single register value to the inferior, we need to make sure
-    // our cached copy of the register values are fresh.  Otherwise when writing EAX, for example,
-    // we may also overwrite some other register with a stale value.
-    if (!CacheAllRegisterValues())
-        return false;
-
-    uint32_t reg = reg_info->kinds[eRegisterKindLLDB];
-    switch (reg)
-    {
-        case lldb_eax_i386:
-            WINLOG_IFALL(WINDOWS_LOG_REGISTERS, "Write value 0x%x to EAX", reg_value.GetAsUInt32());
-            m_context.Eax = reg_value.GetAsUInt32();
-            break;
-        case lldb_ebx_i386:
-            WINLOG_IFALL(WINDOWS_LOG_REGISTERS, "Write value 0x%x to EBX", reg_value.GetAsUInt32());
-            m_context.Ebx = reg_value.GetAsUInt32();
-            break;
-        case lldb_ecx_i386:
-            WINLOG_IFALL(WINDOWS_LOG_REGISTERS, "Write value 0x%x to ECX", reg_value.GetAsUInt32());
-            m_context.Ecx = reg_value.GetAsUInt32();
-            break;
-        case lldb_edx_i386:
-            WINLOG_IFALL(WINDOWS_LOG_REGISTERS, "Write value 0x%x to EDX", reg_value.GetAsUInt32());
-            m_context.Edx = reg_value.GetAsUInt32();
-            break;
-        case lldb_edi_i386:
-            WINLOG_IFALL(WINDOWS_LOG_REGISTERS, "Write value 0x%x to EDI", reg_value.GetAsUInt32());
-            m_context.Edi = reg_value.GetAsUInt32();
-            break;
-        case lldb_esi_i386:
-            WINLOG_IFALL(WINDOWS_LOG_REGISTERS, "Write value 0x%x to ESI", reg_value.GetAsUInt32());
-            m_context.Esi = reg_value.GetAsUInt32();
-            break;
-        case lldb_ebp_i386:
-            WINLOG_IFALL(WINDOWS_LOG_REGISTERS, "Write value 0x%x to EBP", reg_value.GetAsUInt32());
-            m_context.Ebp = reg_value.GetAsUInt32();
-            break;
-        case lldb_esp_i386:
-            WINLOG_IFALL(WINDOWS_LOG_REGISTERS, "Write value 0x%x to ESP", reg_value.GetAsUInt32());
-            m_context.Esp = reg_value.GetAsUInt32();
-            break;
-        case lldb_eip_i386:
-            WINLOG_IFALL(WINDOWS_LOG_REGISTERS, "Write value 0x%x to EIP", reg_value.GetAsUInt32());
-            m_context.Eip = reg_value.GetAsUInt32();
-            break;
-        case lldb_eflags_i386:
-            WINLOG_IFALL(WINDOWS_LOG_REGISTERS, "Write value 0x%x to EFLAGS", reg_value.GetAsUInt32());
-            m_context.EFlags = reg_value.GetAsUInt32();
-            break;
-        default:
-            WINWARN_IFALL(WINDOWS_LOG_REGISTERS, "Write value 0x%x to unknown register %u", reg_value.GetAsUInt32(),
-                          reg);
-    }
-
-    // Physically update the registers in the target process.
-    TargetThreadWindows &wthread = static_cast<TargetThreadWindows &>(m_thread);
-    return ::SetThreadContext(wthread.GetHostThread().GetNativeThread().GetSystemHandle(), &m_context);
-}
+//===-- RegisterContextWindows_x86.h ----------------------------*- C++ -*-===//

+//

+//                     The LLVM Compiler Infrastructure

+//

+// This file is distributed under the University of Illinois Open Source

+// License. See LICENSE.TXT for details.

+//

+//===----------------------------------------------------------------------===//

+

+#include "lldb/lldb-private-types.h"

+#include "lldb/Core/Error.h"

+#include "lldb/Core/RegisterValue.h"

+#include "lldb/Host/windows/HostThreadWindows.h"

+#include "lldb/Host/windows/windows.h"

+

+#include "lldb-x86-register-enums.h"

+#include "ProcessWindowsLog.h"

+#include "RegisterContext_x86.h"

+#include "RegisterContextWindows_x86.h"

+#include "TargetThreadWindows.h"

+

+#include "llvm/ADT/STLExtras.h"

+

+using namespace lldb;

+using namespace lldb_private;

+

+#define DEFINE_GPR(reg, alt) #reg, alt, 4, 0, eEncodingUint, eFormatHexUppercase

+#define DEFINE_GPR_BIN(reg, alt) #reg, alt, 4, 0, eEncodingUint, eFormatBinary

+

+namespace

+{

+

+// This enum defines the layout of the global RegisterInfo array.  This is necessary because

+// lldb register sets are defined in terms of indices into the register array.  As such, the

+// order of RegisterInfos defined in global registers array must match the order defined here.

+// When defining the register set layouts, these values can appear in an arbitrary order, and that

+// determines the order that register values are displayed in a dump.

+enum RegisterIndex

+{

+    eRegisterIndexEax,

+    eRegisterIndexEbx,

+    eRegisterIndexEcx,

+    eRegisterIndexEdx,

+    eRegisterIndexEdi,

+    eRegisterIndexEsi,

+    eRegisterIndexEbp,

+    eRegisterIndexEsp,

+    eRegisterIndexEip,

+    eRegisterIndexEflags

+};

+

+// Array of all register information supported by Windows x86

+RegisterInfo g_register_infos[] =

+{

+//  Macro auto defines most stuff   GCC                     DWARF                GENERIC                    GDB                   LLDB               VALUE REGS    INVALIDATE REGS

+//  ==============================  ======================= ===================  =========================  ===================   =================  ==========    ===============

+    { DEFINE_GPR(eax,    nullptr),  { gcc_eax_i386,         dwarf_eax_i386,      LLDB_INVALID_REGNUM,       LLDB_INVALID_REGNUM,  lldb_eax_i386   },  nullptr,      nullptr},

+    { DEFINE_GPR(ebx,    nullptr),  { gcc_ebx_i386,         dwarf_ebx_i386,      LLDB_INVALID_REGNUM,       LLDB_INVALID_REGNUM,  lldb_ebx_i386   },  nullptr,      nullptr},

+    { DEFINE_GPR(ecx,    nullptr),  { gcc_ecx_i386,         dwarf_ecx_i386,      LLDB_INVALID_REGNUM,       LLDB_INVALID_REGNUM,  lldb_ecx_i386   },  nullptr,      nullptr},

+    { DEFINE_GPR(edx,    nullptr),  { gcc_edx_i386,         dwarf_edx_i386,      LLDB_INVALID_REGNUM,       LLDB_INVALID_REGNUM,  lldb_edx_i386   },  nullptr,      nullptr},

+    { DEFINE_GPR(edi,    nullptr),  { gcc_edi_i386,         dwarf_edi_i386,      LLDB_INVALID_REGNUM,       LLDB_INVALID_REGNUM,  lldb_edi_i386   },  nullptr,      nullptr},

+    { DEFINE_GPR(esi,    nullptr),  { gcc_esi_i386,         dwarf_esi_i386,      LLDB_INVALID_REGNUM,       LLDB_INVALID_REGNUM,  lldb_esi_i386   },  nullptr,      nullptr},

+    { DEFINE_GPR(ebp,    "fp"),     { gcc_ebp_i386,         dwarf_ebp_i386,      LLDB_REGNUM_GENERIC_FP,    LLDB_INVALID_REGNUM,  lldb_ebp_i386   },  nullptr,      nullptr},

+    { DEFINE_GPR(esp,    "sp"),     { gcc_esp_i386,         dwarf_esp_i386,      LLDB_REGNUM_GENERIC_SP,    LLDB_INVALID_REGNUM,  lldb_esp_i386   },  nullptr,      nullptr},

+    { DEFINE_GPR(eip,    "pc"),     { gcc_eip_i386,         dwarf_eip_i386,      LLDB_REGNUM_GENERIC_PC,    LLDB_INVALID_REGNUM,  lldb_eip_i386   },  nullptr,      nullptr},

+    { DEFINE_GPR_BIN(eflags, "flags"), { gcc_eflags_i386,   dwarf_eflags_i386,   LLDB_REGNUM_GENERIC_FLAGS, LLDB_INVALID_REGNUM,  lldb_eflags_i386},  nullptr,      nullptr},

+};

+

+// Array of lldb register numbers used to define the set of all General Purpose Registers

+uint32_t g_gpr_reg_indices[] =

+{

+    eRegisterIndexEax,

+    eRegisterIndexEbx,

+    eRegisterIndexEcx,

+    eRegisterIndexEdx,

+    eRegisterIndexEdi,

+    eRegisterIndexEsi,

+    eRegisterIndexEbp,

+    eRegisterIndexEsp,

+    eRegisterIndexEip,

+    eRegisterIndexEflags

+};

+

+RegisterSet g_register_sets[] = {

+    {"General Purpose Registers", "gpr", llvm::array_lengthof(g_gpr_reg_indices), g_gpr_reg_indices},

+};

+}

+

+//------------------------------------------------------------------

+// Constructors and Destructors

+//------------------------------------------------------------------

+RegisterContextWindows_x86::RegisterContextWindows_x86(Thread &thread, uint32_t concrete_frame_idx)

+    : RegisterContextWindows(thread, concrete_frame_idx)

+{

+}

+

+RegisterContextWindows_x86::~RegisterContextWindows_x86()

+{

+}

+

+size_t

+RegisterContextWindows_x86::GetRegisterCount()

+{

+    return llvm::array_lengthof(g_register_infos);

+}

+

+const RegisterInfo *

+RegisterContextWindows_x86::GetRegisterInfoAtIndex(size_t reg)

+{

+    return &g_register_infos[reg];

+}

+

+size_t

+RegisterContextWindows_x86::GetRegisterSetCount()

+{

+    return llvm::array_lengthof(g_register_sets);

+}

+

+const RegisterSet *

+RegisterContextWindows_x86::GetRegisterSet(size_t reg_set)

+{

+    return &g_register_sets[reg_set];

+}

+

+bool

+RegisterContextWindows_x86::ReadRegister(const RegisterInfo *reg_info, RegisterValue &reg_value)

+{

+    if (!CacheAllRegisterValues())

+        return false;

+

+    uint32_t reg = reg_info->kinds[eRegisterKindLLDB];

+    switch (reg)

+    {

+        case lldb_eax_i386:

+            WINLOG_IFALL(WINDOWS_LOG_REGISTERS, "Read value 0x%x from EAX", m_context.Eax);

+            reg_value.SetUInt32(m_context.Eax);

+            break;

+        case lldb_ebx_i386:

+            WINLOG_IFALL(WINDOWS_LOG_REGISTERS, "Read value 0x%x from EBX", m_context.Ebx);

+            reg_value.SetUInt32(m_context.Ebx);

+            break;

+        case lldb_ecx_i386:

+            WINLOG_IFALL(WINDOWS_LOG_REGISTERS, "Read value 0x%x from ECX", m_context.Ecx);

+            reg_value.SetUInt32(m_context.Ecx);

+            break;

+        case lldb_edx_i386:

+            WINLOG_IFALL(WINDOWS_LOG_REGISTERS, "Read value 0x%x from EDX", m_context.Edx);

+            reg_value.SetUInt32(m_context.Edx);

+            break;

+        case lldb_edi_i386:

+            WINLOG_IFALL(WINDOWS_LOG_REGISTERS, "Read value 0x%x from EDI", m_context.Edi);

+            reg_value.SetUInt32(m_context.Edi);

+            break;

+        case lldb_esi_i386:

+            WINLOG_IFALL(WINDOWS_LOG_REGISTERS, "Read value 0x%x from ESI", m_context.Esi);

+            reg_value.SetUInt32(m_context.Esi);

+            break;

+        case lldb_ebp_i386:

+            WINLOG_IFALL(WINDOWS_LOG_REGISTERS, "Read value 0x%x from EBP", m_context.Ebp);

+            reg_value.SetUInt32(m_context.Ebp);

+            break;

+        case lldb_esp_i386:

+            WINLOG_IFALL(WINDOWS_LOG_REGISTERS, "Read value 0x%x from ESP", m_context.Esp);

+            reg_value.SetUInt32(m_context.Esp);

+            break;

+        case lldb_eip_i386:

+            WINLOG_IFALL(WINDOWS_LOG_REGISTERS, "Read value 0x%x from EIP", m_context.Eip);

+            reg_value.SetUInt32(m_context.Eip);

+            break;

+        case lldb_eflags_i386:

+            WINLOG_IFALL(WINDOWS_LOG_REGISTERS, "Read value 0x%x from EFLAGS", m_context.EFlags);

+            reg_value.SetUInt32(m_context.EFlags);

+            break;

+        default:

+            WINWARN_IFALL(WINDOWS_LOG_REGISTERS, "Requested unknown register %u", reg);

+            break;

+    }

+    return true;

+}

+

+bool

+RegisterContextWindows_x86::WriteRegister(const RegisterInfo *reg_info, const RegisterValue &reg_value)

+{

+    // Since we cannot only write a single register value to the inferior, we need to make sure

+    // our cached copy of the register values are fresh.  Otherwise when writing EAX, for example,

+    // we may also overwrite some other register with a stale value.

+    if (!CacheAllRegisterValues())

+        return false;

+

+    uint32_t reg = reg_info->kinds[eRegisterKindLLDB];

+    switch (reg)

+    {

+        case lldb_eax_i386:

+            WINLOG_IFALL(WINDOWS_LOG_REGISTERS, "Write value 0x%x to EAX", reg_value.GetAsUInt32());

+            m_context.Eax = reg_value.GetAsUInt32();

+            break;

+        case lldb_ebx_i386:

+            WINLOG_IFALL(WINDOWS_LOG_REGISTERS, "Write value 0x%x to EBX", reg_value.GetAsUInt32());

+            m_context.Ebx = reg_value.GetAsUInt32();

+            break;

+        case lldb_ecx_i386:

+            WINLOG_IFALL(WINDOWS_LOG_REGISTERS, "Write value 0x%x to ECX", reg_value.GetAsUInt32());

+            m_context.Ecx = reg_value.GetAsUInt32();

+            break;

+        case lldb_edx_i386:

+            WINLOG_IFALL(WINDOWS_LOG_REGISTERS, "Write value 0x%x to EDX", reg_value.GetAsUInt32());

+            m_context.Edx = reg_value.GetAsUInt32();

+            break;

+        case lldb_edi_i386:

+            WINLOG_IFALL(WINDOWS_LOG_REGISTERS, "Write value 0x%x to EDI", reg_value.GetAsUInt32());

+            m_context.Edi = reg_value.GetAsUInt32();

+            break;

+        case lldb_esi_i386:

+            WINLOG_IFALL(WINDOWS_LOG_REGISTERS, "Write value 0x%x to ESI", reg_value.GetAsUInt32());

+            m_context.Esi = reg_value.GetAsUInt32();

+            break;

+        case lldb_ebp_i386:

+            WINLOG_IFALL(WINDOWS_LOG_REGISTERS, "Write value 0x%x to EBP", reg_value.GetAsUInt32());

+            m_context.Ebp = reg_value.GetAsUInt32();

+            break;

+        case lldb_esp_i386:

+            WINLOG_IFALL(WINDOWS_LOG_REGISTERS, "Write value 0x%x to ESP", reg_value.GetAsUInt32());

+            m_context.Esp = reg_value.GetAsUInt32();

+            break;

+        case lldb_eip_i386:

+            WINLOG_IFALL(WINDOWS_LOG_REGISTERS, "Write value 0x%x to EIP", reg_value.GetAsUInt32());

+            m_context.Eip = reg_value.GetAsUInt32();

+            break;

+        case lldb_eflags_i386:

+            WINLOG_IFALL(WINDOWS_LOG_REGISTERS, "Write value 0x%x to EFLAGS", reg_value.GetAsUInt32());

+            m_context.EFlags = reg_value.GetAsUInt32();

+            break;

+        default:

+            WINWARN_IFALL(WINDOWS_LOG_REGISTERS, "Write value 0x%x to unknown register %u", reg_value.GetAsUInt32(),

+                          reg);

+    }

+

+    // Physically update the registers in the target process.

+    TargetThreadWindows &wthread = static_cast<TargetThreadWindows &>(m_thread);

+    return ::SetThreadContext(wthread.GetHostThread().GetNativeThread().GetSystemHandle(), &m_context);

+}

diff --git a/lldb/source/Plugins/Process/Windows/x86/RegisterContextWindows_x86.h b/lldb/source/Plugins/Process/Windows/Live/x86/RegisterContextWindows_x86.h
index 20a1e88d07b..20a1e88d07b 100644
--- a/lldb/source/Plugins/Process/Windows/x86/RegisterContextWindows_x86.h
+++ b/lldb/source/Plugins/Process/Windows/Live/x86/RegisterContextWindows_x86.h
diff --git a/lldb/source/Plugins/Process/win-minidump/CMakeLists.txt b/lldb/source/Plugins/Process/Windows/MiniDump/CMakeLists.txt
index e8e275b177f..14b039dd163 100644
--- a/lldb/source/Plugins/Process/win-minidump/CMakeLists.txt
+++ b/lldb/source/Plugins/Process/Windows/MiniDump/CMakeLists.txt
@@ -1,4 +1,5 @@
-include_directories(../Utility)
+include_directories(../../Utility)
+include_directories(../Common)
 
 add_lldb_library(lldbPluginProcessWinMiniDump
   ProcessWinMiniDump.cpp
diff --git a/lldb/source/Plugins/Process/win-minidump/ProcessWinMiniDump.cpp b/lldb/source/Plugins/Process/Windows/MiniDump/ProcessWinMiniDump.cpp
index 9303b443a8b..9ff5157d27d 100644
--- a/lldb/source/Plugins/Process/win-minidump/ProcessWinMiniDump.cpp
+++ b/lldb/source/Plugins/Process/Windows/MiniDump/ProcessWinMiniDump.cpp
@@ -32,7 +32,7 @@
 #include "llvm/Support/raw_ostream.h"
 #include "Plugins/DynamicLoader/Windows-DYLD/DynamicLoaderWindowsDYLD.h"
 
-#include "../windows/ExceptionRecord.h"  // TODO(amccarth):  move this file to a common location
+#include "ExceptionRecord.h"
 #include "ThreadWinMiniDump.h"
 
 using namespace lldb_private;
diff --git a/lldb/source/Plugins/Process/win-minidump/ProcessWinMiniDump.h b/lldb/source/Plugins/Process/Windows/MiniDump/ProcessWinMiniDump.h
index de9273274a2..de9273274a2 100644
--- a/lldb/source/Plugins/Process/win-minidump/ProcessWinMiniDump.h
+++ b/lldb/source/Plugins/Process/Windows/MiniDump/ProcessWinMiniDump.h
diff --git a/lldb/source/Plugins/Process/win-minidump/RegisterContextWindowsMiniDump.cpp b/lldb/source/Plugins/Process/Windows/MiniDump/RegisterContextWindowsMiniDump.cpp
index 8b07c1120a9..8b07c1120a9 100644
--- a/lldb/source/Plugins/Process/win-minidump/RegisterContextWindowsMiniDump.cpp
+++ b/lldb/source/Plugins/Process/Windows/MiniDump/RegisterContextWindowsMiniDump.cpp
diff --git a/lldb/source/Plugins/Process/win-minidump/RegisterContextWindowsMiniDump.h b/lldb/source/Plugins/Process/Windows/MiniDump/RegisterContextWindowsMiniDump.h
index 5c6e2408bf1..5c6e2408bf1 100644
--- a/lldb/source/Plugins/Process/win-minidump/RegisterContextWindowsMiniDump.h
+++ b/lldb/source/Plugins/Process/Windows/MiniDump/RegisterContextWindowsMiniDump.h
diff --git a/lldb/source/Plugins/Process/win-minidump/ThreadWinMiniDump.cpp b/lldb/source/Plugins/Process/Windows/MiniDump/ThreadWinMiniDump.cpp
index 37edddabbf0..37edddabbf0 100644
--- a/lldb/source/Plugins/Process/win-minidump/ThreadWinMiniDump.cpp
+++ b/lldb/source/Plugins/Process/Windows/MiniDump/ThreadWinMiniDump.cpp
diff --git a/lldb/source/Plugins/Process/win-minidump/ThreadWinMiniDump.h b/lldb/source/Plugins/Process/Windows/MiniDump/ThreadWinMiniDump.h
index b4e8cb57023..b4e8cb57023 100644
--- a/lldb/source/Plugins/Process/win-minidump/ThreadWinMiniDump.h
+++ b/lldb/source/Plugins/Process/Windows/MiniDump/ThreadWinMiniDump.h