maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

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

llvm-svn: 251540
This commit is contained in:
Adrian McCarthy 2015-10-28 18:21:45 +00:00
parent 9413fa26af
commit 18a9135d56
33 changed files with 2063 additions and 1764 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
lldb/cmake/LLDBDependencies.cmake
View File

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

4
lldb/source/API/SystemInitializerFull.cpp
View File

@ -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();

2
lldb/source/Initialization/SystemInitializerCommon.cpp
View File

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

1
lldb/source/Plugins/Process/CMakeLists.txt
View File

@ -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()

23
lldb/source/Plugins/Process/Windows/Common/CMakeLists.txt Normal file
View File

@ -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}
)

77
lldb/source/Plugins/Process/Windows/Common/ProcessWindows.cpp Normal file
View File

@ -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;
}
}

41
lldb/source/Plugins/Process/Windows/Common/ProcessWindows.h Normal file
View File

@ -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_

2
lldb/source/Plugins/Process/Windows/Live/ProcessWindowsLog.cpp → lldb/source/Plugins/Process/Windows/Common/ProcessWindowsLog.cpp
View File

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

0
lldb/source/Plugins/Process/Windows/Live/ProcessWindowsLog.h → lldb/source/Plugins/Process/Windows/Common/ProcessWindowsLog.h
View File

0
lldb/source/Plugins/Process/Windows/Live/RegisterContextWindows.cpp → lldb/source/Plugins/Process/Windows/Common/RegisterContextWindows.cpp
View File

4
lldb/source/Plugins/Process/Windows/Live/RegisterContextWindows.h → lldb/source/Plugins/Process/Windows/Common/RegisterContextWindows.h
View File

@ -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_

98
lldb/source/Plugins/Process/Windows/Common/TargetThreadWindows.cpp Normal file
View File

@ -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;
}

9
lldb/source/Plugins/Process/Windows/Live/TargetThreadWindows.h → lldb/source/Plugins/Process/Windows/Common/TargetThreadWindows.h
View File

@ -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;
};
}

0
lldb/source/Plugins/Process/Windows/Live/x64/RegisterContextWindows_x64.cpp → lldb/source/Plugins/Process/Windows/Common/x64/RegisterContextWindows_x64.cpp
View File

0
lldb/source/Plugins/Process/Windows/Live/x64/RegisterContextWindows_x64.h → lldb/source/Plugins/Process/Windows/Common/x64/RegisterContextWindows_x64.h
View File

123
lldb/source/Plugins/Process/Windows/Common/x86/RegisterContextWindows_x86.cpp Normal file
View File

@ -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];
}

7
lldb/source/Plugins/Process/Windows/Live/x86/RegisterContextWindows_x86.h → lldb/source/Plugins/Process/Windows/Common/x86/RegisterContextWindows_x86.h
View File

@ -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_

10
lldb/source/Plugins/Process/Windows/Live/CMakeLists.txt
View File

@ -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()

2
lldb/source/Plugins/Process/Windows/Live/DebuggerThread.cpp
View File

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

4
lldb/source/Plugins/Process/Windows/Live/ForwardDecl.h
View File

@ -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;

24
lldb/source/Plugins/Process/Windows/Live/LocalDebugDelegate.cpp
View File

@ -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);
}

17
lldb/source/Plugins/Process/Windows/Live/LocalDebugDelegate.h
View File

@ -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;

19
lldb/source/Plugins/Process/Windows/Live/ProcessWindowsForward.h
View File

@ -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

131
lldb/source/Plugins/Process/Windows/Live/ProcessWindows.cpp → lldb/source/Plugins/Process/Windows/Live/ProcessWindowsLive.cpp
View File

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

26
lldb/source/Plugins/Process/Windows/Live/ProcessWindows.h → lldb/source/Plugins/Process/Windows/Live/ProcessWindowsLive.h
View File

@ -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_

36
lldb/source/Plugins/Process/Windows/Live/TargetThreadWindows.cpp → lldb/source/Plugins/Process/Windows/Live/TargetThreadWindowsLive.cpp
View File

@ -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();

55
lldb/source/Plugins/Process/Windows/Live/TargetThreadWindowsLive.h Normal file
View File

@ -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

106
lldb/source/Plugins/Process/Windows/Live/x86/RegisterContextWindows_x86.cpp → lldb/source/Plugins/Process/Windows/Live/x86/RegisterContextWindowsLive_x86.cpp
View File

@ -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

38
lldb/source/Plugins/Process/Windows/Live/x86/RegisterContextWindowsLive_x86.h Normal file
View File

@ -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_

14
lldb/source/Plugins/Process/Windows/MiniDump/ProcessWinMiniDump.cpp
View File

@ -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()
{

7
lldb/source/Plugins/Process/Windows/MiniDump/ProcessWinMiniDump.h
View File

@ -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();

2
lldb/source/Plugins/Process/Windows/MiniDump/RegisterContextWindowsMiniDump.cpp
View File

@ -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)
{
}

4
lldb/source/Plugins/Process/Windows/MiniDump/RegisterContextWindowsMiniDump.h
View File

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