Refactor Windows process plugin to allow code sharing between live and mini dump debugging.

llvm-svn: 251540

lldb/cmake/LLDBDependencies.cmake

@@ -81,6 +81,7 @@ if ( CMAKE_SYSTEM_NAME MATCHES "Windows" )
   list(APPEND LLDB_USED_LIBS
     lldbPluginProcessWindows
     lldbPluginProcessWinMiniDump
+    lldbPluginProcessWindowsCommon
     Ws2_32
     Rpcrt4
     )

lldb/source/API/SystemInitializerFull.cpp

@@ -76,7 +76,7 @@
 
 #if defined(_MSC_VER)
 #include "lldb/Host/windows/windows.h"
-#include "Plugins/Process/Windows/Live/ProcessWindows.h"
+#include "Plugins/Process/Windows/Live/ProcessWindowsLive.h"
 #include "Plugins/Process/Windows/MiniDump/ProcessWinMiniDump.h"
 #endif
 
@@ -307,7 +307,7 @@ SystemInitializerFull::Initialize()
     ObjCPlusPlusLanguage::Initialize();
 
 #if defined(_MSC_VER)
-    ProcessWindows::Initialize();
+    ProcessWindowsLive::Initialize();
 #endif
 #if defined(__FreeBSD__)
     ProcessFreeBSD::Initialize();

lldb/source/Initialization/SystemInitializerCommon.cpp

@@ -49,7 +49,7 @@
 
 #if defined(_MSC_VER)
 #include "lldb/Host/windows/windows.h"
-#include "Plugins/Process/Windows/Live/ProcessWindowsLog.h"
+#include "Plugins/Process/Windows/Common/ProcessWindowsLog.h"
 #endif
 
 #include "llvm/Support/TargetSelect.h"

lldb/source/Plugins/Process/CMakeLists.txt

@@ -9,6 +9,7 @@ elseif (CMAKE_SYSTEM_NAME MATCHES "NetBSD")
 elseif (CMAKE_SYSTEM_NAME MATCHES "Windows")
   add_subdirectory(Windows/Live)
   add_subdirectory(Windows/MiniDump)
+  add_subdirectory(Windows/Common)
 elseif (CMAKE_SYSTEM_NAME MATCHES "Darwin")
   add_subdirectory(MacOSX-Kernel)
 endif()

lldb/source/Plugins/Process/Windows/Common/CMakeLists.txt

@@ -0,0 +1,23 @@
+include_directories(.)
+include_directories(../../Utility)
+
+set(PROC_WINDOWS_COMMON_SOURCES
+  RegisterContextWindows.cpp
+  ProcessWindows.cpp
+  ProcessWindowsLog.cpp
+  TargetThreadWindows.cpp
+  )
+
+if (CMAKE_SIZEOF_VOID_P EQUAL 4)
+  set(PROC_WINDOWS_COMMON_SOURCES ${PROC_WINDOWS_COMMON_SOURCES}
+    x86/RegisterContextWindows_x86.cpp
+    )
+elseif (CMAKE_SIZEOF_VOID_P EQUAL 8)
+  set(PROC_WINDOWS_COMMON_SOURCES ${PROC_WINDOWS_COMMON_SOURCES}
+    x64/RegisterContextWindows_x64.cpp
+    )
+endif()
+
+add_lldb_library(lldbPluginProcessWindowsCommon
+  ${PROC_WINDOWS_COMMON_SOURCES}
+  )

lldb/source/Plugins/Process/Windows/Common/ProcessWindows.cpp

@@ -0,0 +1,77 @@
+//===-- ProcessWindows.cpp --------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "ProcessWindows.h"
+
+// Other libraries and framework includes
+#include "lldb/Core/Module.h"
+#include "lldb/Core/ModuleSpec.h"
+#include "lldb/Core/PluginManager.h"
+#include "lldb/Core/Section.h"
+#include "lldb/Core/State.h"
+#include "lldb/Target/DynamicLoader.h"
+#include "lldb/Target/MemoryRegionInfo.h"
+#include "lldb/Target/Target.h"
+
+using namespace lldb;
+using namespace lldb_private;
+
+namespace lldb_private
+{
+
+//------------------------------------------------------------------------------
+// Constructors and destructors.
+
+ProcessWindows::ProcessWindows(lldb::TargetSP target_sp, Listener &listener)
+    : lldb_private::Process(target_sp, listener)
+{
+}
+
+ProcessWindows::~ProcessWindows()
+{
+}
+
+size_t
+ProcessWindows::GetSTDOUT(char *buf, size_t buf_size, Error &error)
+{
+    error.SetErrorString("GetSTDOUT unsupported on Windows");
+    return 0;
+}
+
+size_t
+ProcessWindows::GetSTDERR(char *buf, size_t buf_size, Error &error)
+{
+    error.SetErrorString("GetSTDERR unsupported on Windows");
+    return 0;
+}
+
+size_t
+ProcessWindows::PutSTDIN(const char *buf, size_t buf_size, Error &error)
+{
+    error.SetErrorString("PutSTDIN unsupported on Windows");
+    return 0;
+}
+
+//------------------------------------------------------------------------------
+// ProcessInterface protocol.
+
+
+lldb::addr_t
+ProcessWindows::GetImageInfoAddress()
+{
+    Target &target = GetTarget();
+    ObjectFile *obj_file = target.GetExecutableModule()->GetObjectFile();
+    Address addr = obj_file->GetImageInfoAddress(&target);
+    if (addr.IsValid())
+        return addr.GetLoadAddress(&target);
+    else
+        return LLDB_INVALID_ADDRESS;
+}
+
+}

lldb/source/Plugins/Process/Windows/Common/ProcessWindows.h

@@ -0,0 +1,41 @@
+//===-- ProcessWindows.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_Common_ProcessWindows_H_
+#define liblldb_Plugins_Process_Windows_Common_ProcessWindows_H_
+
+// Other libraries and framework includes
+#include "lldb/lldb-forward.h"
+#include "lldb/Core/Error.h"
+#include "lldb/Target/Process.h"
+
+namespace lldb_private
+{
+
+class ProcessWindows : public lldb_private::Process
+{
+public:
+    //------------------------------------------------------------------
+    // Constructors and destructors
+    //------------------------------------------------------------------
+    ProcessWindows(lldb::TargetSP target_sp,
+                   lldb_private::Listener &listener);
+
+    ~ProcessWindows();
+
+    size_t GetSTDOUT(char *buf, size_t buf_size, lldb_private::Error &error) override;
+    size_t GetSTDERR(char *buf, size_t buf_size, lldb_private::Error &error) override;
+    size_t PutSTDIN(const char *buf, size_t buf_size, lldb_private::Error &error) override;
+
+    lldb::addr_t GetImageInfoAddress() override;
+};
+
+}
+
+#endif  // liblldb_Plugins_Process_Windows_Common_ProcessWindows_H_

lldb/source/Plugins/Process/Windows/Common/ProcessWindowsLog.cpp

@@ -15,8 +15,6 @@
 #include "lldb/Interpreter/Args.h"
 #include "llvm/Support/ManagedStatic.h"
 
-#include "ProcessWindows.h"
-
 using namespace lldb;
 using namespace lldb_private;
 

lldb/source/Plugins/Process/Windows/Common/RegisterContextWindows.h

@@ -57,7 +57,7 @@ class RegisterContextWindows : public lldb_private::RegisterContext
     bool HardwareSingleStep(bool enable) override;
 
   protected:
-    bool CacheAllRegisterValues();
+    virtual bool CacheAllRegisterValues();
 
     CONTEXT m_context;
 
@@ -66,4 +66,4 @@ class RegisterContextWindows : public lldb_private::RegisterContext
 };
 }
 
-#endif // #ifndef liblldb_RegisterContextPOSIX_x86_H_
+#endif // #ifndef liblldb_RegisterContextWindows_H_

lldb/source/Plugins/Process/Windows/Common/TargetThreadWindows.cpp

@@ -0,0 +1,98 @@
+//===-- TargetThreadWindows.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/Core/Log.h"
+#include "lldb/Core/Logging.h"
+#include "lldb/Core/State.h"
+#include "lldb/Host/HostInfo.h"
+#include "lldb/Host/HostNativeThreadBase.h"
+#include "lldb/Host/windows/HostThreadWindows.h"
+#include "lldb/Host/windows/windows.h"
+#include "lldb/Target/RegisterContext.h"
+
+#include "TargetThreadWindows.h"
+#include "ProcessWindows.h"
+#include "ProcessWindowsLog.h"
+#include "UnwindLLDB.h"
+
+using namespace lldb;
+using namespace lldb_private;
+
+TargetThreadWindows::TargetThreadWindows(ProcessWindows &process, const HostThread &thread)
+    : Thread(process, thread.GetNativeThread().GetThreadId())
+    , m_host_thread(thread)
+{
+}
+
+TargetThreadWindows::~TargetThreadWindows()
+{
+    DestroyThread();
+}
+
+void
+TargetThreadWindows::RefreshStateAfterStop()
+{
+    ::SuspendThread(m_host_thread.GetNativeThread().GetSystemHandle());
+    SetState(eStateStopped);
+    GetRegisterContext()->InvalidateIfNeeded(false);
+}
+
+void
+TargetThreadWindows::WillResume(lldb::StateType resume_state)
+{
+}
+
+void
+TargetThreadWindows::DidStop()
+{
+}
+
+bool
+TargetThreadWindows::CalculateStopInfo()
+{
+    SetStopInfo(m_stop_info_sp);
+    return true;
+}
+
+Unwind *
+TargetThreadWindows::GetUnwinder()
+{
+    // FIXME: Implement an unwinder based on the Windows unwinder exposed through DIA SDK.
+    if (m_unwinder_ap.get() == NULL)
+        m_unwinder_ap.reset(new UnwindLLDB(*this));
+    return m_unwinder_ap.get();
+}
+
+bool
+TargetThreadWindows::DoResume()
+{
+    StateType resume_state = GetTemporaryResumeState();
+    StateType current_state = GetState();
+    if (resume_state == current_state)
+        return true;
+
+    if (resume_state == eStateStepping)
+    {
+        uint32_t flags_index = GetRegisterContext()->ConvertRegisterKindToRegisterNumber(eRegisterKindGeneric, LLDB_REGNUM_GENERIC_FLAGS);
+        uint64_t flags_value = GetRegisterContext()->ReadRegisterAsUnsigned(flags_index, 0);
+        flags_value |= 0x100; // Set the trap flag on the CPU
+        GetRegisterContext()->WriteRegisterFromUnsigned(flags_index, flags_value);
+    }
+
+    if (resume_state == eStateStepping || resume_state == eStateRunning)
+    {
+        DWORD previous_suspend_count = 0;
+        HANDLE thread_handle = m_host_thread.GetNativeThread().GetSystemHandle();
+        do
+        {
+            previous_suspend_count = ::ResumeThread(thread_handle);
+        } while (previous_suspend_count > 0);
+    }
+    return true;
+}

lldb/source/Plugins/Process/Windows/Common/TargetThreadWindows.h

@@ -10,15 +10,14 @@
 #ifndef liblldb_Plugins_Process_Windows_TargetThreadWindows_H_
 #define liblldb_Plugins_Process_Windows_TargetThreadWindows_H_
 
-#include "ForwardDecl.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 ProcessWindows;
 class HostThread;
 class StackFrame;
 
@@ -32,8 +31,6 @@ class TargetThreadWindows : public lldb_private::Thread
     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;
 
@@ -46,8 +43,6 @@ class TargetThreadWindows : public lldb_private::Thread
     }
 
   private:
-    lldb::RegisterContextSP CreateRegisterContextForFrameIndex(uint32_t idx);
-
     HostThread m_host_thread;
 };
 }

lldb/source/Plugins/Process/Windows/Common/x86/RegisterContextWindows_x86.cpp

@@ -0,0 +1,123 @@
+//===-- RegisterContextWindows_x86.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 "ProcessWindowsLog.h"
+#include "RegisterContext_x86.h"
+#include "RegisterContextWindows_x86.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   eh_frame                DWARF                GENERIC                    GDB                   LLDB               VALUE REGS    INVALIDATE REGS
+//  ==============================  ======================= ===================  =========================  ===================   =================  ==========    ===============
+    { DEFINE_GPR(eax,    nullptr),  { ehframe_eax_i386,     dwarf_eax_i386,      LLDB_INVALID_REGNUM,       LLDB_INVALID_REGNUM,  lldb_eax_i386   },  nullptr,      nullptr},
+    { DEFINE_GPR(ebx,    nullptr),  { ehframe_ebx_i386,     dwarf_ebx_i386,      LLDB_INVALID_REGNUM,       LLDB_INVALID_REGNUM,  lldb_ebx_i386   },  nullptr,      nullptr},
+    { DEFINE_GPR(ecx,    nullptr),  { ehframe_ecx_i386,     dwarf_ecx_i386,      LLDB_INVALID_REGNUM,       LLDB_INVALID_REGNUM,  lldb_ecx_i386   },  nullptr,      nullptr},
+    { DEFINE_GPR(edx,    nullptr),  { ehframe_edx_i386,     dwarf_edx_i386,      LLDB_INVALID_REGNUM,       LLDB_INVALID_REGNUM,  lldb_edx_i386   },  nullptr,      nullptr},
+    { DEFINE_GPR(edi,    nullptr),  { ehframe_edi_i386,     dwarf_edi_i386,      LLDB_INVALID_REGNUM,       LLDB_INVALID_REGNUM,  lldb_edi_i386   },  nullptr,      nullptr},
+    { DEFINE_GPR(esi,    nullptr),  { ehframe_esi_i386,     dwarf_esi_i386,      LLDB_INVALID_REGNUM,       LLDB_INVALID_REGNUM,  lldb_esi_i386   },  nullptr,      nullptr},
+    { DEFINE_GPR(ebp,    "fp"),     { ehframe_ebp_i386,     dwarf_ebp_i386,      LLDB_REGNUM_GENERIC_FP,    LLDB_INVALID_REGNUM,  lldb_ebp_i386   },  nullptr,      nullptr},
+    { DEFINE_GPR(esp,    "sp"),     { ehframe_esp_i386,     dwarf_esp_i386,      LLDB_REGNUM_GENERIC_SP,    LLDB_INVALID_REGNUM,  lldb_esp_i386   },  nullptr,      nullptr},
+    { DEFINE_GPR(eip,    "pc"),     { ehframe_eip_i386,     dwarf_eip_i386,      LLDB_REGNUM_GENERIC_PC,    LLDB_INVALID_REGNUM,  lldb_eip_i386   },  nullptr,      nullptr},
+    { DEFINE_GPR_BIN(eflags, "flags"), { ehframe_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];
+}
+

lldb/source/Plugins/Process/Windows/Common/x86/RegisterContextWindows_x86.h

@@ -38,11 +38,8 @@ class RegisterContextWindows_x86 : public RegisterContextWindows
     size_t GetRegisterSetCount() override;
 
     const RegisterSet *GetRegisterSet(size_t reg_set) override;
-
-    bool ReadRegister(const RegisterInfo *reg_info, RegisterValue &reg_value) override;
-
-    bool WriteRegister(const RegisterInfo *reg_info, const RegisterValue &reg_value) override;
 };
+
 }
 
-#endif // #ifndef liblldb_RegisterContextPOSIX_x86_H_
+#endif // #ifndef liblldb_RegisterContextWindows_x86_H_

lldb/source/Plugins/Process/Windows/Live/CMakeLists.txt

@@ -5,19 +5,17 @@ include_directories(../Common)
 set(PROC_WINDOWS_SOURCES
   DebuggerThread.cpp
   LocalDebugDelegate.cpp
-  ProcessWindows.cpp
-  ProcessWindowsLog.cpp
-  RegisterContextWindows.cpp
-  TargetThreadWindows.cpp
+  ProcessWindowsLive.cpp
+  TargetThreadWindowsLive.cpp
   )
 
 if (CMAKE_SIZEOF_VOID_P EQUAL 4)
   set(PROC_WINDOWS_SOURCES ${PROC_WINDOWS_SOURCES}
-    x86/RegisterContextWindows_x86.cpp
+    x86/RegisterContextWindowsLive_x86.cpp
     )
 elseif (CMAKE_SIZEOF_VOID_P EQUAL 8)
   set(PROC_WINDOWS_SOURCES ${PROC_WINDOWS_SOURCES}
-    x64/RegisterContextWindows_x64.cpp
+    x64/RegisterContextWindowsLive_x64.cpp
     )
 endif()
 

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/Live/ProcessWindowsLog.h"
+#include "Plugins/Process/Windows/Common/ProcessWindowsLog.h"
 
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/Support/raw_ostream.h"

lldb/source/Plugins/Process/Windows/Live/ForwardDecl.h

@@ -10,8 +10,6 @@
 #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
@@ -28,6 +26,8 @@ enum class ExceptionResult
 namespace lldb_private
 {
 
+class ProcessWindows;
+
 class IDebugDelegate;
 class DebuggerThread;
 class ExceptionRecord;

lldb/source/Plugins/Process/Windows/Live/LocalDebugDelegate.cpp

@@ -8,7 +8,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "LocalDebugDelegate.h"
-#include "ProcessWindows.h"
+#include "ProcessWindowsLive.h"
 
 using namespace lldb;
 using namespace lldb_private;
@@ -21,21 +21,21 @@ LocalDebugDelegate::LocalDebugDelegate(ProcessWP process)
 void
 LocalDebugDelegate::OnExitProcess(uint32_t exit_code)
 {
-    if (ProcessWindowsSP process = GetProcessPointer())
+    if (ProcessWindowsLiveSP process = GetProcessPointer())
         process->OnExitProcess(exit_code);
 }
 
 void
 LocalDebugDelegate::OnDebuggerConnected(lldb::addr_t image_base)
 {
-    if (ProcessWindowsSP process = GetProcessPointer())
+    if (ProcessWindowsLiveSP process = GetProcessPointer())
         process->OnDebuggerConnected(image_base);
 }
 
 ExceptionResult
 LocalDebugDelegate::OnDebugException(bool first_chance, const ExceptionRecord &record)
 {
-    if (ProcessWindowsSP process = GetProcessPointer())
+    if (ProcessWindowsLiveSP process = GetProcessPointer())
         return process->OnDebugException(first_chance, record);
     else
         return ExceptionResult::MaskException;
@@ -44,48 +44,48 @@ LocalDebugDelegate::OnDebugException(bool first_chance, const ExceptionRecord &r
 void
 LocalDebugDelegate::OnCreateThread(const HostThread &thread)
 {
-    if (ProcessWindowsSP process = GetProcessPointer())
+    if (ProcessWindowsLiveSP process = GetProcessPointer())
         process->OnCreateThread(thread);
 }
 
 void
 LocalDebugDelegate::OnExitThread(lldb::tid_t thread_id, uint32_t exit_code)
 {
-    if (ProcessWindowsSP process = GetProcessPointer())
+    if (ProcessWindowsLiveSP process = GetProcessPointer())
         process->OnExitThread(thread_id, exit_code);
 }
 
 void
 LocalDebugDelegate::OnLoadDll(const lldb_private::ModuleSpec &module_spec, lldb::addr_t module_addr)
 {
-    if (ProcessWindowsSP process = GetProcessPointer())
+    if (ProcessWindowsLiveSP process = GetProcessPointer())
         process->OnLoadDll(module_spec, module_addr);
 }
 
 void
 LocalDebugDelegate::OnUnloadDll(lldb::addr_t module_addr)
 {
-    if (ProcessWindowsSP process = GetProcessPointer())
+    if (ProcessWindowsLiveSP process = GetProcessPointer())
         process->OnUnloadDll(module_addr);
 }
 
 void
 LocalDebugDelegate::OnDebugString(const std::string &string)
 {
-    if (ProcessWindowsSP process = GetProcessPointer())
+    if (ProcessWindowsLiveSP process = GetProcessPointer())
         process->OnDebugString(string);
 }
 
 void
 LocalDebugDelegate::OnDebuggerError(const Error &error, uint32_t type)
 {
-    if (ProcessWindowsSP process = GetProcessPointer())
+    if (ProcessWindowsLiveSP process = GetProcessPointer())
         process->OnDebuggerError(error, type);
 }
 
-ProcessWindowsSP
+ProcessWindowsLiveSP
 LocalDebugDelegate::GetProcessPointer()
 {
     ProcessSP process = m_process.lock();
-    return std::static_pointer_cast<ProcessWindows>(process);
+    return std::static_pointer_cast<ProcessWindowsLive>(process);
 }

lldb/source/Plugins/Process/Windows/Live/LocalDebugDelegate.h

@@ -10,22 +10,25 @@
 #ifndef liblldb_Plugins_Process_Windows_LocalDebugDelegate_H_
 #define liblldb_Plugins_Process_Windows_LocalDebugDelegate_H_
 
+#include <memory>
+
 #include "IDebugDelegate.h"
-#include "ProcessWindowsForward.h"
 
 #include "lldb/lldb-forward.h"
 
-class ProcessWindows;
-
 namespace lldb_private
 {
+
+class ProcessWindowsLive;
+typedef std::shared_ptr<ProcessWindowsLive> ProcessWindowsLiveSP;
+
 //----------------------------------------------------------------------
 // LocalDebugDelegate
 //
-// LocalDebugDelegate creates a connection between a ProcessWindows and the
-// debug driver.  This serves to decouple ProcessWindows from the debug driver.
+// LocalDebugDelegate creates a connection between a ProcessWindowsLive and the
+// debug driver.  This serves to decouple ProcessWindowsLive 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
+// ProcessWindowsLive 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
@@ -55,7 +58,7 @@ class LocalDebugDelegate : public IDebugDelegate
     void OnDebuggerError(const Error &error, uint32_t type) override;
 
   private:
-    ProcessWindowsSP
+    ProcessWindowsLiveSP
     GetProcessPointer();
 
     lldb::ProcessWP m_process;

lldb/source/Plugins/Process/Windows/Live/ProcessWindowsForward.h

@@ -1,19 +0,0 @@
-//===-- ProcessWindows.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_ProcessWindowsForward_H_
-#define liblldb_Plugins_Process_Windows_ProcessWindowsForward_H_
-
-#include <memory>
-
-class ProcessWindows;
-
-typedef std::shared_ptr<ProcessWindows> ProcessWindowsSP;
-
-#endif

lldb/source/Plugins/Process/Windows/Live/ProcessWindowsLive.cpp

@@ -1,4 +1,4 @@
-//===-- ProcessWindows.cpp --------------------------------------*- C++ -*-===//
+//===-- ProcessWindowsLive.cpp ----------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
@@ -39,14 +39,13 @@
 #include "lldb/Target/StopInfo.h"
 #include "lldb/Target/Target.h"
 
-#include "Plugins/Process/Windows/Live/ProcessWindowsForward.h"
-#include "Plugins/Process/Windows/live/ProcessWindowsLog.h"
+#include "Plugins/Process/Windows/Common/ProcessWindowsLog.h"
 
 #include "DebuggerThread.h"
 #include "ExceptionRecord.h"
 #include "LocalDebugDelegate.h"
-#include "ProcessWindows.h"
-#include "TargetThreadWindows.h"
+#include "ProcessWindowsLive.h"
+#include "TargetThreadWindowsLive.h"
 
 #include "llvm/Support/Format.h"
 #include "llvm/Support/raw_ostream.h"
@@ -122,13 +121,13 @@ class ProcessWindowsData
 // Static functions.
 
 ProcessSP
-ProcessWindows::CreateInstance(lldb::TargetSP target_sp, Listener &listener, const FileSpec *)
+ProcessWindowsLive::CreateInstance(lldb::TargetSP target_sp, Listener &listener, const FileSpec *)
 {
-    return ProcessSP(new ProcessWindows(target_sp, listener));
+    return ProcessSP(new ProcessWindowsLive(target_sp, listener));
 }
 
 void
-ProcessWindows::Initialize()
+ProcessWindowsLive::Initialize()
 {
     static std::once_flag g_once_flag;
 
@@ -143,56 +142,35 @@ ProcessWindows::Initialize()
 //------------------------------------------------------------------------------
 // Constructors and destructors.
 
-ProcessWindows::ProcessWindows(lldb::TargetSP target_sp, Listener &listener)
-    : lldb_private::Process(target_sp, listener)
+ProcessWindowsLive::ProcessWindowsLive(lldb::TargetSP target_sp, Listener &listener)
+    : lldb_private::ProcessWindows(target_sp, listener)
 {
 }
 
-ProcessWindows::~ProcessWindows()
+ProcessWindowsLive::~ProcessWindowsLive()
 {
 }
 
 void
-ProcessWindows::Terminate()
+ProcessWindowsLive::Terminate()
 {
 }
 
 lldb_private::ConstString
-ProcessWindows::GetPluginNameStatic()
+ProcessWindowsLive::GetPluginNameStatic()
 {
     static ConstString g_name("windows");
     return g_name;
 }
 
 const char *
-ProcessWindows::GetPluginDescriptionStatic()
+ProcessWindowsLive::GetPluginDescriptionStatic()
 {
     return "Process plugin for Windows";
 }
 
-size_t
-ProcessWindows::GetSTDOUT(char *buf, size_t buf_size, Error &error)
-{
-    error.SetErrorString("GetSTDOUT unsupported on Windows");
-    return 0;
-}
-
-size_t
-ProcessWindows::GetSTDERR(char *buf, size_t buf_size, Error &error)
-{
-    error.SetErrorString("GetSTDERR unsupported on Windows");
-    return 0;
-}
-
-size_t
-ProcessWindows::PutSTDIN(const char *buf, size_t buf_size, Error &error)
-{
-    error.SetErrorString("PutSTDIN unsupported on Windows");
-    return 0;
-}
-
 Error
-ProcessWindows::EnableBreakpointSite(BreakpointSite *bp_site)
+ProcessWindowsLive::EnableBreakpointSite(BreakpointSite *bp_site)
 {
     WINLOG_IFALL(WINDOWS_LOG_BREAKPOINTS, "EnableBreakpointSite called with bp_site 0x%p "
                                           "(id=%d, addr=0x%x)",
@@ -207,7 +185,7 @@ ProcessWindows::EnableBreakpointSite(BreakpointSite *bp_site)
 }
 
 Error
-ProcessWindows::DisableBreakpointSite(BreakpointSite *bp_site)
+ProcessWindowsLive::DisableBreakpointSite(BreakpointSite *bp_site)
 {
     WINLOG_IFALL(WINDOWS_LOG_BREAKPOINTS, "DisableBreakpointSite called with bp_site 0x%p "
                                           "(id=%d, addr=0x%x)",
@@ -223,7 +201,7 @@ ProcessWindows::DisableBreakpointSite(BreakpointSite *bp_site)
 }
 
 bool
-ProcessWindows::UpdateThreadList(ThreadList &old_thread_list, ThreadList &new_thread_list)
+ProcessWindowsLive::UpdateThreadList(ThreadList &old_thread_list, ThreadList &new_thread_list)
 {
     // Add all the threads that were previously running and for which we did not detect a thread
     // exited event.
@@ -255,7 +233,7 @@ ProcessWindows::UpdateThreadList(ThreadList &old_thread_list, ThreadList &new_th
     // Also add all the threads that are new since the last time we broke into the debugger.
     for (const auto &thread_info : m_session_data->m_new_threads)
     {
-        ThreadSP thread(new TargetThreadWindows(*this, thread_info.second));
+        ThreadSP thread(new TargetThreadWindowsLive(*this, thread_info.second));
         thread->SetID(thread_info.first);
         new_thread_list.AddThread(thread);
         ++new_size;
@@ -273,8 +251,8 @@ ProcessWindows::UpdateThreadList(ThreadList &old_thread_list, ThreadList &new_th
 }
 
 Error
-ProcessWindows::DoLaunch(Module *exe_module,
-                         ProcessLaunchInfo &launch_info)
+ProcessWindowsLive::DoLaunch(Module *exe_module,
+                             ProcessLaunchInfo &launch_info)
 {
     // Even though m_session_data is accessed here, it is before a debugger thread has been
     // kicked off.  So there's no race conditions, and it shouldn't be necessary to acquire
@@ -333,7 +311,7 @@ ProcessWindows::DoLaunch(Module *exe_module,
 }
 
 Error
-ProcessWindows::DoAttachToProcessWithID(lldb::pid_t pid, const ProcessAttachInfo &attach_info)
+ProcessWindowsLive::DoAttachToProcessWithID(lldb::pid_t pid, const ProcessAttachInfo &attach_info)
 {
     m_session_data.reset(new ProcessWindowsData(!attach_info.GetContinueOnceAttached()));
 
@@ -374,7 +352,7 @@ ProcessWindows::DoAttachToProcessWithID(lldb::pid_t pid, const ProcessAttachInfo
 }
 
 Error
-ProcessWindows::WaitForDebuggerConnection(DebuggerThreadSP debugger, HostProcess &process)
+ProcessWindowsLive::WaitForDebuggerConnection(DebuggerThreadSP debugger, HostProcess &process)
 {
     Error result;
     WINLOG_IFANY(WINDOWS_LOG_PROCESS|WINDOWS_LOG_BREAKPOINTS, "WaitForDebuggerConnection Waiting for loader breakpoint.");
@@ -392,7 +370,7 @@ ProcessWindows::WaitForDebuggerConnection(DebuggerThreadSP debugger, HostProcess
 }
 
 Error
-ProcessWindows::DoResume()
+ProcessWindowsLive::DoResume()
 {
     llvm::sys::ScopedLock lock(m_mutex);
     Error error;
@@ -419,7 +397,7 @@ ProcessWindows::DoResume()
 
         for (int i = 0; i < m_thread_list.GetSize(); ++i)
         {
-            auto thread = std::static_pointer_cast<TargetThreadWindows>(
+            auto thread = std::static_pointer_cast<TargetThreadWindowsLive>(
                 m_thread_list.GetThreadAtIndex(i));
             thread->DoResume();
         }
@@ -439,19 +417,19 @@ ProcessWindows::DoResume()
 // ProcessInterface protocol.
 
 lldb_private::ConstString
-ProcessWindows::GetPluginName()
+ProcessWindowsLive::GetPluginName()
 {
     return GetPluginNameStatic();
 }
 
 uint32_t
-ProcessWindows::GetPluginVersion()
+ProcessWindowsLive::GetPluginVersion()
 {
     return 1;
 }
 
 Error
-ProcessWindows::DoDetach(bool keep_stopped)
+ProcessWindowsLive::DoDetach(bool keep_stopped)
 {
     DebuggerThreadSP debugger_thread;
     StateType private_state;
@@ -500,7 +478,7 @@ ProcessWindows::DoDetach(bool keep_stopped)
 }
 
 Error
-ProcessWindows::DoDestroy()
+ProcessWindowsLive::DoDestroy()
 {
     DebuggerThreadSP debugger_thread;
     StateType private_state;
@@ -544,7 +522,7 @@ ProcessWindows::DoDestroy()
 }
 
 void
-ProcessWindows::RefreshStateAfterStop()
+ProcessWindowsLive::RefreshStateAfterStop()
 {
     llvm::sys::ScopedLock lock(m_mutex);
 
@@ -626,7 +604,7 @@ ProcessWindows::RefreshStateAfterStop()
 }
 
 bool
-ProcessWindows::IsAlive()
+ProcessWindowsLive::IsAlive()
 {
     StateType state = GetPrivateState();
     switch (state)
@@ -643,7 +621,7 @@ ProcessWindows::IsAlive()
 }
 
 Error
-ProcessWindows::DoHalt(bool &caused_stop)
+ProcessWindowsLive::DoHalt(bool &caused_stop)
 {
     Error error;
     StateType state = GetPrivateState();
@@ -663,14 +641,15 @@ ProcessWindows::DoHalt(bool &caused_stop)
     return error;
 }
 
-void ProcessWindows::DidLaunch()
+void
+ProcessWindowsLive::DidLaunch()
 {
     ArchSpec arch_spec;
     DidAttach(arch_spec);
 }
 
 void
-ProcessWindows::DidAttach(ArchSpec &arch_spec)
+ProcessWindowsLive::DidAttach(ArchSpec &arch_spec)
 {
     llvm::sys::ScopedLock lock(m_mutex);
 
@@ -680,10 +659,10 @@ ProcessWindows::DidAttach(ArchSpec &arch_spec)
 }
 
 size_t
-ProcessWindows::DoReadMemory(lldb::addr_t vm_addr,
-                             void *buf,
-                             size_t size,
-                             Error &error)
+ProcessWindowsLive::DoReadMemory(lldb::addr_t vm_addr,
+                                 void *buf,
+                                 size_t size,
+                                 Error &error)
 {
     llvm::sys::ScopedLock lock(m_mutex);
 
@@ -704,7 +683,7 @@ ProcessWindows::DoReadMemory(lldb::addr_t vm_addr,
 }
 
 size_t
-ProcessWindows::DoWriteMemory(lldb::addr_t vm_addr, const void *buf, size_t size, Error &error)
+ProcessWindowsLive::DoWriteMemory(lldb::addr_t vm_addr, const void *buf, size_t size, Error &error)
 {
     llvm::sys::ScopedLock lock(m_mutex);
     WINLOG_IFALL(WINDOWS_LOG_MEMORY, "DoWriteMemory attempting to write %u bytes into address 0x%I64x", size, vm_addr);
@@ -730,7 +709,7 @@ ProcessWindows::DoWriteMemory(lldb::addr_t vm_addr, const void *buf, size_t size
 }
 
 Error
-ProcessWindows::GetMemoryRegionInfo(lldb::addr_t vm_addr, MemoryRegionInfo &info)
+ProcessWindowsLive::GetMemoryRegionInfo(lldb::addr_t vm_addr, MemoryRegionInfo &info)
 {
     Error error;
     llvm::sys::ScopedLock lock(m_mutex);
@@ -776,20 +755,8 @@ ProcessWindows::GetMemoryRegionInfo(lldb::addr_t vm_addr, MemoryRegionInfo &info
     return error;
 }
 
-lldb::addr_t
-ProcessWindows::GetImageInfoAddress()
-{
-    Target &target = GetTarget();
-    ObjectFile *obj_file = target.GetExecutableModule()->GetObjectFile();
-    Address addr = obj_file->GetImageInfoAddress(&target);
-    if (addr.IsValid())
-        return addr.GetLoadAddress(&target);
-    else
-        return LLDB_INVALID_ADDRESS;
-}
-
 bool
-ProcessWindows::CanDebug(lldb::TargetSP target_sp, bool plugin_specified_by_name)
+ProcessWindowsLive::CanDebug(lldb::TargetSP target_sp, bool plugin_specified_by_name)
 {
     if (plugin_specified_by_name)
         return true;
@@ -803,7 +770,7 @@ ProcessWindows::CanDebug(lldb::TargetSP target_sp, bool plugin_specified_by_name
 }
 
 void
-ProcessWindows::OnExitProcess(uint32_t exit_code)
+ProcessWindowsLive::OnExitProcess(uint32_t exit_code)
 {
     // No need to acquire the lock since m_session_data isn't accessed.
     WINLOG_IFALL(WINDOWS_LOG_PROCESS, "Process %u exited with code %u", GetID(), exit_code);
@@ -822,7 +789,7 @@ ProcessWindows::OnExitProcess(uint32_t exit_code)
 }
 
 void
-ProcessWindows::OnDebuggerConnected(lldb::addr_t image_base)
+ProcessWindowsLive::OnDebuggerConnected(lldb::addr_t image_base)
 {
     DebuggerThreadSP debugger = m_session_data->m_debugger;
 
@@ -868,7 +835,7 @@ ProcessWindows::OnDebuggerConnected(lldb::addr_t image_base)
 }
 
 ExceptionResult
-ProcessWindows::OnDebugException(bool first_chance, const ExceptionRecord &record)
+ProcessWindowsLive::OnDebugException(bool first_chance, const ExceptionRecord &record)
 {
     llvm::sys::ScopedLock lock(m_mutex);
 
@@ -933,7 +900,7 @@ ProcessWindows::OnDebugException(bool first_chance, const ExceptionRecord &recor
 }
 
 void
-ProcessWindows::OnCreateThread(const HostThread &new_thread)
+ProcessWindowsLive::OnCreateThread(const HostThread &new_thread)
 {
     llvm::sys::ScopedLock lock(m_mutex);
     const HostThreadWindows &wnew_thread = new_thread.GetNativeThread();
@@ -941,7 +908,7 @@ ProcessWindows::OnCreateThread(const HostThread &new_thread)
 }
 
 void
-ProcessWindows::OnExitThread(lldb::tid_t thread_id, uint32_t exit_code)
+ProcessWindowsLive::OnExitThread(lldb::tid_t thread_id, uint32_t exit_code)
 {
     llvm::sys::ScopedLock lock(m_mutex);
 
@@ -960,7 +927,7 @@ ProcessWindows::OnExitThread(lldb::tid_t thread_id, uint32_t exit_code)
 }
 
 void
-ProcessWindows::OnLoadDll(const ModuleSpec &module_spec, lldb::addr_t module_addr)
+ProcessWindowsLive::OnLoadDll(const ModuleSpec &module_spec, lldb::addr_t module_addr)
 {
     // Confusingly, there is no Target::AddSharedModule.  Instead, calling GetSharedModule() with
     // a new module will add it to the module list and return a corresponding ModuleSP.
@@ -975,7 +942,7 @@ ProcessWindows::OnLoadDll(const ModuleSpec &module_spec, lldb::addr_t module_add
 }
 
 void
-ProcessWindows::OnUnloadDll(lldb::addr_t module_addr)
+ProcessWindowsLive::OnUnloadDll(lldb::addr_t module_addr)
 {
     Address resolved_addr;
     if (GetTarget().ResolveLoadAddress(module_addr, resolved_addr))
@@ -991,12 +958,12 @@ ProcessWindows::OnUnloadDll(lldb::addr_t module_addr)
 }
 
 void
-ProcessWindows::OnDebugString(const std::string &string)
+ProcessWindowsLive::OnDebugString(const std::string &string)
 {
 }
 
 void
-ProcessWindows::OnDebuggerError(const Error &error, uint32_t type)
+ProcessWindowsLive::OnDebuggerError(const Error &error, uint32_t type)
 {
     llvm::sys::ScopedLock lock(m_mutex);
 

lldb/source/Plugins/Process/Windows/Live/ProcessWindowsLive.h

@@ -1,4 +1,4 @@
-//===-- ProcessWindows.h ----------------------------------------*- C++ -*-===//
+//===-- ProcessWindowsLive.h ------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
@@ -7,8 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef liblldb_Plugins_Process_Windows_ProcessWindows_H_
-#define liblldb_Plugins_Process_Windows_ProcessWindows_H_
+#ifndef liblldb_Plugins_Process_Windows_Live_ProcessWindowsLive_H_
+#define liblldb_Plugins_Process_Windows_Live_ProcessWindowsLive_H_
 
 // C Includes
 
@@ -26,15 +26,16 @@
 
 #include "llvm/Support/Mutex.h"
 
+#include "plugins/Process/Windows/Common/ProcessWindows.h"
+
 class ProcessMonitor;
 
 namespace lldb_private
 {
 class HostProcess;
 class ProcessWindowsData;
-}
 
-class ProcessWindows : public lldb_private::Process, public lldb_private::IDebugDelegate
+class ProcessWindowsLive : public lldb_private::ProcessWindows, public lldb_private::IDebugDelegate
 {
 public:
     //------------------------------------------------------------------
@@ -60,19 +61,15 @@ public:
     //------------------------------------------------------------------
     // Constructors and destructors
     //------------------------------------------------------------------
-    ProcessWindows(lldb::TargetSP target_sp,
-                   lldb_private::Listener &listener);
+    ProcessWindowsLive(lldb::TargetSP target_sp,
+                       lldb_private::Listener &listener);
 
-    ~ProcessWindows();
+    ~ProcessWindowsLive();
 
     // lldb_private::Process overrides
     lldb_private::ConstString GetPluginName() override;
     uint32_t GetPluginVersion() override;
 
-    size_t GetSTDOUT(char *buf, size_t buf_size, lldb_private::Error &error) override;
-    size_t GetSTDERR(char *buf, size_t buf_size, lldb_private::Error &error) override;
-    size_t PutSTDIN(const char *buf, size_t buf_size, lldb_private::Error &error) override;
-
     lldb_private::Error EnableBreakpointSite(lldb_private::BreakpointSite *bp_site) override;
     lldb_private::Error DisableBreakpointSite(lldb_private::BreakpointSite *bp_site) override;
 
@@ -88,7 +85,6 @@ public:
     void DidAttach(lldb_private::ArchSpec &arch_spec) override;
 
     void RefreshStateAfterStop() override;
-    lldb::addr_t GetImageInfoAddress() override;
 
     bool CanDebug(lldb::TargetSP target_sp, bool plugin_specified_by_name) override;
     bool
@@ -124,4 +120,6 @@ public:
     std::unique_ptr<lldb_private::ProcessWindowsData> m_session_data;
 };
 
-#endif  // liblldb_Plugins_Process_Windows_ProcessWindows_H_
+}
+
+#endif  // liblldb_Plugins_Process_Windows_Live_ProcessWindowsLive_H_

lldb/source/Plugins/Process/Windows/Live/TargetThreadWindowsLive.cpp

@@ -1,4 +1,4 @@
-//===-- TargetThreadWindows.cpp----------------------------------*- C++ -*-===//
+//===-- TargetThreadWindowsLive.cpp------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
@@ -16,33 +16,33 @@
 #include "lldb/Host/windows/windows.h"
 #include "lldb/Target/RegisterContext.h"
 
-#include "TargetThreadWindows.h"
+#include "TargetThreadWindowsLive.h"
 #include "ProcessWindows.h"
 #include "ProcessWindowsLog.h"
 #include "UnwindLLDB.h"
 
 #if defined(_WIN64)
-#include "x64/RegisterContextWindows_x64.h"
+#include "x64/RegisterContextWindowsLive_x64.h"
 #else
-#include "x86/RegisterContextWindows_x86.h"
+#include "x86/RegisterContextWindowsLive_x86.h"
 #endif
 
 using namespace lldb;
 using namespace lldb_private;
 
-TargetThreadWindows::TargetThreadWindows(ProcessWindows &process, const HostThread &thread)
-    : Thread(process, thread.GetNativeThread().GetThreadId())
+TargetThreadWindowsLive::TargetThreadWindowsLive(ProcessWindows &process, const HostThread &thread)
+    : TargetThreadWindows(process, thread)
     , m_host_thread(thread)
 {
 }
 
-TargetThreadWindows::~TargetThreadWindows()
+TargetThreadWindowsLive::~TargetThreadWindowsLive()
 {
     DestroyThread();
 }
 
 void
-TargetThreadWindows::RefreshStateAfterStop()
+TargetThreadWindowsLive::RefreshStateAfterStop()
 {
     ::SuspendThread(m_host_thread.GetNativeThread().GetSystemHandle());
     SetState(eStateStopped);
@@ -50,17 +50,17 @@ TargetThreadWindows::RefreshStateAfterStop()
 }
 
 void
-TargetThreadWindows::WillResume(lldb::StateType resume_state)
+TargetThreadWindowsLive::WillResume(lldb::StateType resume_state)
 {
 }
 
 void
-TargetThreadWindows::DidStop()
+TargetThreadWindowsLive::DidStop()
 {
 }
 
 RegisterContextSP
-TargetThreadWindows::GetRegisterContext()
+TargetThreadWindowsLive::GetRegisterContext()
 {
     if (!m_reg_context_sp)
         m_reg_context_sp = CreateRegisterContextForFrameIndex(0);
@@ -69,13 +69,13 @@ TargetThreadWindows::GetRegisterContext()
 }
 
 RegisterContextSP
-TargetThreadWindows::CreateRegisterContextForFrame(StackFrame *frame)
+TargetThreadWindowsLive::CreateRegisterContextForFrame(StackFrame *frame)
 {
     return CreateRegisterContextForFrameIndex(frame->GetConcreteFrameIndex());
 }
 
 RegisterContextSP
-TargetThreadWindows::CreateRegisterContextForFrameIndex(uint32_t idx)
+TargetThreadWindowsLive::CreateRegisterContextForFrameIndex(uint32_t idx)
 {
     if (!m_reg_context_sp)
     {
@@ -86,12 +86,12 @@ TargetThreadWindows::CreateRegisterContextForFrameIndex(uint32_t idx)
 #if defined(_WIN64)
                 // FIXME: This is a Wow64 process, create a RegisterContextWindows_Wow64
 #else
-                m_reg_context_sp.reset(new RegisterContextWindows_x86(*this, idx));
+                m_reg_context_sp.reset(new RegisterContextWindowsLive_x86(*this, idx));
 #endif
                 break;
             case llvm::Triple::x86_64:
 #if defined(_WIN64)
-                m_reg_context_sp.reset(new RegisterContextWindows_x64(*this, idx));
+                m_reg_context_sp.reset(new RegisterContextWindowsLive_x64(*this, idx));
 #else
                 // LLDB is 32-bit, but the target process is 64-bit.  We probably can't debug this.
 #endif
@@ -103,14 +103,14 @@ TargetThreadWindows::CreateRegisterContextForFrameIndex(uint32_t idx)
 }
 
 bool
-TargetThreadWindows::CalculateStopInfo()
+TargetThreadWindowsLive::CalculateStopInfo()
 {
     SetStopInfo(m_stop_info_sp);
     return true;
 }
 
 Unwind *
-TargetThreadWindows::GetUnwinder()
+TargetThreadWindowsLive::GetUnwinder()
 {
     // FIXME: Implement an unwinder based on the Windows unwinder exposed through DIA SDK.
     if (m_unwinder_ap.get() == NULL)
@@ -119,7 +119,7 @@ TargetThreadWindows::GetUnwinder()
 }
 
 bool
-TargetThreadWindows::DoResume()
+TargetThreadWindowsLive::DoResume()
 {
     StateType resume_state = GetTemporaryResumeState();
     StateType current_state = GetState();

lldb/source/Plugins/Process/Windows/Live/TargetThreadWindowsLive.h

@@ -0,0 +1,55 @@
+//===-- TargetThreadWindowsLive.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_TargetThreadWindowsLive_H_
+#define liblldb_Plugins_Process_Windows_TargetThreadWindowsLive_H_
+
+#include "lldb/lldb-forward.h"
+#include "lldb/Host/HostThread.h"
+#include "lldb/Target/Thread.h"
+
+#include "Plugins/Process/Windows/Common/TargetThreadWindows.h"
+
+namespace lldb_private
+{
+class ProcessWindows;
+class HostThread;
+class StackFrame;
+
+class TargetThreadWindowsLive : public lldb_private::TargetThreadWindows
+{
+  public:
+    TargetThreadWindowsLive(ProcessWindows &process, const HostThread &thread);
+    virtual ~TargetThreadWindowsLive();
+
+    // 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);
+
+    HostThread m_host_thread;
+};
+}
+
+#endif

lldb/source/Plugins/Process/Windows/Live/x86/RegisterContextWindowsLive_x86.cpp

@@ -1,4 +1,4 @@
-//===-- RegisterContextWindows_x86.h ----------------------------*- C++ -*-===//
+//===-- RegisterContextWindowsLive_x86.cpp ------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
@@ -15,115 +15,28 @@
 
 #include "lldb-x86-register-enums.h"
 #include "ProcessWindowsLog.h"
-#include "RegisterContext_x86.h"
-#include "RegisterContextWindows_x86.h"
+#include "RegisterContextWindowsLive_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
+namespace lldb_private
 {
 
-// 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   eh_frame                DWARF                GENERIC                    GDB                   LLDB               VALUE REGS    INVALIDATE REGS
-//  ==============================  ======================= ===================  =========================  ===================   =================  ==========    ===============
-    { DEFINE_GPR(eax,    nullptr),  { ehframe_eax_i386,     dwarf_eax_i386,      LLDB_INVALID_REGNUM,       LLDB_INVALID_REGNUM,  lldb_eax_i386   },  nullptr,      nullptr},
-    { DEFINE_GPR(ebx,    nullptr),  { ehframe_ebx_i386,     dwarf_ebx_i386,      LLDB_INVALID_REGNUM,       LLDB_INVALID_REGNUM,  lldb_ebx_i386   },  nullptr,      nullptr},
-    { DEFINE_GPR(ecx,    nullptr),  { ehframe_ecx_i386,     dwarf_ecx_i386,      LLDB_INVALID_REGNUM,       LLDB_INVALID_REGNUM,  lldb_ecx_i386   },  nullptr,      nullptr},
-    { DEFINE_GPR(edx,    nullptr),  { ehframe_edx_i386,     dwarf_edx_i386,      LLDB_INVALID_REGNUM,       LLDB_INVALID_REGNUM,  lldb_edx_i386   },  nullptr,      nullptr},
-    { DEFINE_GPR(edi,    nullptr),  { ehframe_edi_i386,     dwarf_edi_i386,      LLDB_INVALID_REGNUM,       LLDB_INVALID_REGNUM,  lldb_edi_i386   },  nullptr,      nullptr},
-    { DEFINE_GPR(esi,    nullptr),  { ehframe_esi_i386,     dwarf_esi_i386,      LLDB_INVALID_REGNUM,       LLDB_INVALID_REGNUM,  lldb_esi_i386   },  nullptr,      nullptr},
-    { DEFINE_GPR(ebp,    "fp"),     { ehframe_ebp_i386,     dwarf_ebp_i386,      LLDB_REGNUM_GENERIC_FP,    LLDB_INVALID_REGNUM,  lldb_ebp_i386   },  nullptr,      nullptr},
-    { DEFINE_GPR(esp,    "sp"),     { ehframe_esp_i386,     dwarf_esp_i386,      LLDB_REGNUM_GENERIC_SP,    LLDB_INVALID_REGNUM,  lldb_esp_i386   },  nullptr,      nullptr},
-    { DEFINE_GPR(eip,    "pc"),     { ehframe_eip_i386,     dwarf_eip_i386,      LLDB_REGNUM_GENERIC_PC,    LLDB_INVALID_REGNUM,  lldb_eip_i386   },  nullptr,      nullptr},
-    { DEFINE_GPR_BIN(eflags, "flags"), { ehframe_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)
+RegisterContextWindowsLive_x86::RegisterContextWindowsLive_x86(Thread &thread, uint32_t concrete_frame_idx)
+    : RegisterContextWindows_x86(thread, concrete_frame_idx)
 {
 }
 
-RegisterContextWindows_x86::~RegisterContextWindows_x86()
+RegisterContextWindowsLive_x86::~RegisterContextWindowsLive_x86()
 {
 }
 
-size_t
-RegisterContextWindows_x86::GetRegisterCount()
-{
-    return llvm::array_lengthof(g_register_infos);
-}
-
-const RegisterInfo *
-RegisterContextWindows_x86::GetRegisterInfoAtIndex(size_t reg)
-{
-    return &g_register_infos[reg];
-}
-
-size_t
-RegisterContextWindows_x86::GetRegisterSetCount()
-{
-    return llvm::array_lengthof(g_register_sets);
-}
-
-const RegisterSet *
-RegisterContextWindows_x86::GetRegisterSet(size_t reg_set)
-{
-    return &g_register_sets[reg_set];
-}
 
 bool
-RegisterContextWindows_x86::ReadRegister(const RegisterInfo *reg_info, RegisterValue &reg_value)
+RegisterContextWindowsLive_x86::ReadRegister(const RegisterInfo *reg_info, RegisterValue &reg_value)
 {
     if (!CacheAllRegisterValues())
         return false;
@@ -178,8 +91,9 @@ RegisterContextWindows_x86::ReadRegister(const RegisterInfo *reg_info, RegisterV
     return true;
 }
 
+
 bool
-RegisterContextWindows_x86::WriteRegister(const RegisterInfo *reg_info, const RegisterValue &reg_value)
+RegisterContextWindowsLive_x86::WriteRegister(const RegisterInfo *reg_info, const RegisterValue &reg_value)
 {
     // Since we cannot only write a single register value to the inferior, we need to make sure
     // our cached copy of the register values are fresh.  Otherwise when writing EAX, for example,
@@ -239,3 +153,5 @@ RegisterContextWindows_x86::WriteRegister(const RegisterInfo *reg_info, const Re
     TargetThreadWindows &wthread = static_cast<TargetThreadWindows &>(m_thread);
     return ::SetThreadContext(wthread.GetHostThread().GetNativeThread().GetSystemHandle(), &m_context);
 }
+
+}  // namespace lldb_private

lldb/source/Plugins/Process/Windows/Live/x86/RegisterContextWindowsLive_x86.h

@@ -0,0 +1,38 @@
+//===-- RegisterContextWindowsLive_x86.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_RegisterContextWindowsLive_x86_H_
+#define liblldb_RegisterContextWindowsLive_x86_H_
+
+#include "lldb/lldb-forward.h"
+#include "../../Common/x86/RegisterContextWindows_x86.h"
+
+namespace lldb_private
+{
+
+class Thread;
+
+class RegisterContextWindowsLive_x86 : public RegisterContextWindows_x86
+{
+  public:
+    //------------------------------------------------------------------
+    // Constructors and Destructors
+    //------------------------------------------------------------------
+    RegisterContextWindowsLive_x86(Thread &thread, uint32_t concrete_frame_idx);
+
+    virtual ~RegisterContextWindowsLive_x86();
+
+    bool ReadRegister(const RegisterInfo *reg_info, RegisterValue &reg_value) override;
+
+    bool WriteRegister(const RegisterInfo *reg_info, const RegisterValue &reg_value) override;
+};
+
+}
+
+#endif // #ifndef liblldb_RegisterContextWindowsLive_x86_H_

lldb/source/Plugins/Process/Windows/MiniDump/ProcessWinMiniDump.cpp

@@ -123,7 +123,7 @@ ProcessWinMiniDump::CanDebug(lldb::TargetSP target_sp, bool plugin_specified_by_
 
 ProcessWinMiniDump::ProcessWinMiniDump(lldb::TargetSP target_sp, Listener &listener,
                                        const FileSpec &core_file) :
-    Process(target_sp, listener),
+    ProcessWindows(target_sp, listener),
     m_data_up(new Data)
 {
     m_data_up->m_core_file = core_file;
@@ -285,18 +285,6 @@ ProcessWinMiniDump::Initialize()
     });
 }
 
-lldb::addr_t
-ProcessWinMiniDump::GetImageInfoAddress()
-{
-    Target *target = &GetTarget();
-    ObjectFile *obj_file = target->GetExecutableModule()->GetObjectFile();
-    Address addr = obj_file->GetImageInfoAddress(target);
-
-    if (addr.IsValid())
-        return addr.GetLoadAddress(target);
-    return LLDB_INVALID_ADDRESS;
-}
-
 ArchSpec
 ProcessWinMiniDump::GetArchitecture()
 {

lldb/source/Plugins/Process/Windows/MiniDump/ProcessWinMiniDump.h

@@ -17,9 +17,11 @@
 #include "lldb/Core/Error.h"
 #include "lldb/Target/Process.h"
 
+#include "Plugins/Process/Windows/Common/ProcessWindows.h"
+
 struct ThreadData;
 
-class ProcessWinMiniDump : public lldb_private::Process
+class ProcessWinMiniDump : public lldb_private::ProcessWindows
 {
 public:
     static lldb::ProcessSP
@@ -79,9 +81,6 @@ public:
     size_t
     DoReadMemory(lldb::addr_t addr, void *buf, size_t size, lldb_private::Error &error) override;
 
-    lldb::addr_t
-    GetImageInfoAddress() override;
-
     lldb_private::ArchSpec
     GetArchitecture();
 

lldb/source/Plugins/Process/Windows/MiniDump/RegisterContextWindowsMiniDump.cpp

@@ -23,7 +23,7 @@ using namespace lldb_private;
 // This is a do-nothing stub implementation for now.
 
 RegisterContextWindowsMiniDump::RegisterContextWindowsMiniDump(Thread &thread, uint32_t concrete_frame_idx)
-    : RegisterContext(thread, concrete_frame_idx)
+    : RegisterContextWindows(thread, concrete_frame_idx)
 {
 }
 

lldb/source/Plugins/Process/Windows/MiniDump/RegisterContextWindowsMiniDump.h

@@ -13,13 +13,15 @@
 #include "lldb/lldb-forward.h"
 #include "lldb/Target/RegisterContext.h"
 
+#include "Plugins/Process/Windows/Common/RegisterContextWindows.h"
+
 
 namespace lldb_private
 {
 
 class Thread;
 
-class RegisterContextWindowsMiniDump : public lldb_private::RegisterContext
+class RegisterContextWindowsMiniDump : public lldb_private::RegisterContextWindows
 {
   public:
     RegisterContextWindowsMiniDump(Thread &thread, uint32_t concrete_frame_idx);