Reorg code to allow Windows Process Plugins to share some common code.
Differential Revision: http://reviews.llvm.org/D12252
llvm-svn: 245850
diff --git a/lldb/source/Plugins/Process/CMakeLists.txt b/lldb/source/Plugins/Process/CMakeLists.txt
index 2c16434..4144471 100644
--- a/lldb/source/Plugins/Process/CMakeLists.txt
+++ b/lldb/source/Plugins/Process/CMakeLists.txt
@@ -5,8 +5,8 @@
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
similarity index 98%
rename from lldb/source/Plugins/Process/Windows/ExceptionRecord.h
rename to lldb/source/Plugins/Process/Windows/Common/ExceptionRecord.h
index 45a1b1c..79dae3f 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
similarity index 89%
rename from lldb/source/Plugins/Process/Windows/CMakeLists.txt
rename to lldb/source/Plugins/Process/Windows/Live/CMakeLists.txt
index 6d61fef..bf7a175 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
similarity index 99%
rename from lldb/source/Plugins/Process/Windows/DebuggerThread.cpp
rename to lldb/source/Plugins/Process/Windows/Live/DebuggerThread.cpp
index 1e63aac..e65310d 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
similarity index 100%
rename from lldb/source/Plugins/Process/Windows/DebuggerThread.h
rename to 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
similarity index 99%
rename from lldb/source/Plugins/Process/Windows/ForwardDecl.h
rename to lldb/source/Plugins/Process/Windows/Live/ForwardDecl.h
index 5b35b9c..c2eb168 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
similarity index 99%
rename from lldb/source/Plugins/Process/Windows/IDebugDelegate.h
rename to lldb/source/Plugins/Process/Windows/Live/IDebugDelegate.h
index 6d864de..0e7849b 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
similarity index 99%
rename from lldb/source/Plugins/Process/Windows/LocalDebugDelegate.cpp
rename to lldb/source/Plugins/Process/Windows/Live/LocalDebugDelegate.cpp
index d1fb51b..07f2969 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
similarity index 99%
rename from lldb/source/Plugins/Process/Windows/LocalDebugDelegate.h
rename to lldb/source/Plugins/Process/Windows/Live/LocalDebugDelegate.h
index a14352d..5a1c29e 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
similarity index 99%
rename from lldb/source/Plugins/Process/Windows/ProcessWindows.cpp
rename to lldb/source/Plugins/Process/Windows/Live/ProcessWindows.cpp
index a113990..7c13da8 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
similarity index 100%
rename from lldb/source/Plugins/Process/Windows/ProcessWindows.h
rename to 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
similarity index 99%
rename from lldb/source/Plugins/Process/Windows/ProcessWindowsLog.cpp
rename to lldb/source/Plugins/Process/Windows/Live/ProcessWindowsLog.cpp
index d641979..55c35bc 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
similarity index 99%
rename from lldb/source/Plugins/Process/Windows/ProcessWindowsLog.h
rename to lldb/source/Plugins/Process/Windows/Live/ProcessWindowsLog.h
index d798d13..4f02153 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
similarity index 99%
rename from lldb/source/Plugins/Process/Windows/RegisterContextWindows.cpp
rename to lldb/source/Plugins/Process/Windows/Live/RegisterContextWindows.cpp
index d61675f..8552b46 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
similarity index 99%
rename from lldb/source/Plugins/Process/Windows/RegisterContextWindows.h
rename to lldb/source/Plugins/Process/Windows/Live/RegisterContextWindows.h
index e9eaf3b..f742cd1 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
similarity index 100%
rename from lldb/source/Plugins/Process/Windows/TargetThreadWindows.cpp
rename to 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
similarity index 99%
rename from lldb/source/Plugins/Process/Windows/TargetThreadWindows.h
rename to lldb/source/Plugins/Process/Windows/Live/TargetThreadWindows.h
index 8c46b3c..025a199 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
similarity index 99%
rename from lldb/source/Plugins/Process/Windows/x64/RegisterContextWindows_x64.cpp
rename to lldb/source/Plugins/Process/Windows/Live/x64/RegisterContextWindows_x64.cpp
index 2ea7572..1782aa7 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 ®_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 ®_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 ®_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 ®_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
similarity index 99%
rename from lldb/source/Plugins/Process/Windows/x64/RegisterContextWindows_x64.h
rename to lldb/source/Plugins/Process/Windows/Live/x64/RegisterContextWindows_x64.h
index 15e803f..b369d1a 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 ®_value) override;
-
- bool WriteRegister(const RegisterInfo *reg_info, const RegisterValue ®_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 ®_value) override;
+
+ bool WriteRegister(const RegisterInfo *reg_info, const RegisterValue ®_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
similarity index 99%
rename from lldb/source/Plugins/Process/Windows/x86/RegisterContextWindows_x86.cpp
rename to lldb/source/Plugins/Process/Windows/Live/x86/RegisterContextWindows_x86.cpp
index 688143e..5fdb95c 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 ®_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 ®_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 ®_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 ®_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
similarity index 100%
rename from lldb/source/Plugins/Process/Windows/x86/RegisterContextWindows_x86.h
rename to 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
similarity index 67%
rename from lldb/source/Plugins/Process/win-minidump/CMakeLists.txt
rename to lldb/source/Plugins/Process/Windows/MiniDump/CMakeLists.txt
index e8e275b..14b039d 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
similarity index 98%
rename from lldb/source/Plugins/Process/win-minidump/ProcessWinMiniDump.cpp
rename to lldb/source/Plugins/Process/Windows/MiniDump/ProcessWinMiniDump.cpp
index 9303b44..9ff5157 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
similarity index 100%
rename from lldb/source/Plugins/Process/win-minidump/ProcessWinMiniDump.h
rename to 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
similarity index 100%
rename from lldb/source/Plugins/Process/win-minidump/RegisterContextWindowsMiniDump.cpp
rename to 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
similarity index 100%
rename from lldb/source/Plugins/Process/win-minidump/RegisterContextWindowsMiniDump.h
rename to 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
similarity index 100%
rename from lldb/source/Plugins/Process/win-minidump/ThreadWinMiniDump.cpp
rename to 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
similarity index 100%
rename from lldb/source/Plugins/Process/win-minidump/ThreadWinMiniDump.h
rename to lldb/source/Plugins/Process/Windows/MiniDump/ThreadWinMiniDump.h