caio/clang-p2996
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

[Windows] Add a RegisterContextWindows_x64.

Browse Source 
With this patch, LLDB can debug x64 executables on Windows with
the same level of functionality as for x86 executables.

llvm-svn: 235935
This commit is contained in:
Zachary Turner
2015-04-27 22:58:57 +00:00
parent 675e539f54
commit 7cc3494dea
8 changed files with 605 additions and 161 deletions
Download Patch File Download Diff File Expand all files Collapse all files

18
lldb/source/Plugins/Process/Windows/CMakeLists.txt
View File

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

149
lldb/source/Plugins/Process/Windows/RegisterContextWindows.cpp Normal file
View File

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

69
lldb/source/Plugins/Process/Windows/RegisterContextWindows.h Normal file
View File

@@ -0,0 +1,69 @@
//===-- RegisterContextWindows.h --------------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef liblldb_RegisterContextWindows_H_
#define liblldb_RegisterContextWindows_H_
#include "lldb/lldb-forward.h"
#include "lldb/Target/RegisterContext.h"
namespace lldb_private
{
class Thread;
class RegisterContextWindows : public lldb_private::RegisterContext
{
public:
//------------------------------------------------------------------
// Constructors and Destructors
//------------------------------------------------------------------
RegisterContextWindows(Thread &thread, uint32_t concrete_frame_idx);
virtual ~RegisterContextWindows();
//------------------------------------------------------------------
// Subclasses must override these functions
//------------------------------------------------------------------
void InvalidateAllRegisters() override;
bool ReadAllRegisterValues(lldb::DataBufferSP &data_sp) override;
bool WriteAllRegisterValues(const lldb::DataBufferSP &data_sp) override;
uint32_t ConvertRegisterKindToRegisterNumber(lldb::RegisterKind kind, uint32_t num) override;
//------------------------------------------------------------------
// Subclasses can override these functions if desired
//------------------------------------------------------------------
uint32_t NumSupportedHardwareBreakpoints() override;
uint32_t SetHardwareBreakpoint(lldb::addr_t addr, size_t size) override;
bool ClearHardwareBreakpoint(uint32_t hw_idx) override;
uint32_t NumSupportedHardwareWatchpoints() override;
uint32_t SetHardwareWatchpoint(lldb::addr_t addr, size_t size, bool read, bool write) override;
bool ClearHardwareWatchpoint(uint32_t hw_index) override;
bool HardwareSingleStep(bool enable) override;
protected:
bool CacheAllRegisterValues();
CONTEXT m_context;
private:
bool m_context_stale;
};
}
#endif // #ifndef liblldb_RegisterContextPOSIX_x86_H_

6
lldb/source/Plugins/Process/Windows/TargetThreadWindows.cpp
View File

@@ -17,7 +17,9 @@
#include "ProcessWindows.h"
#include "UnwindLLDB.h"
#if !defined(_WIN64)
#if defined(_WIN64)
#include "x64/RegisterContextWindows_x64.h"
#else
#include "x86/RegisterContextWindows_x86.h"
#endif
@@ -86,7 +88,7 @@ TargetThreadWindows::CreateRegisterContextForFrameIndex(uint32_t idx)
break;
case llvm::Triple::x86_64:
#if defined(_WIN64)
// FIXME: This is a 64-bit process, create a RegisterContextWindows_x86_64
m_reg_context_sp.reset(new RegisterContextWindows_x64(*this, idx));
#else
// LLDB is 32-bit, but the target process is 64-bit. We probably can't debug this.
#endif

323
lldb/source/Plugins/Process/Windows/x64/RegisterContextWindows_x64.cpp Normal file
View File

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

48
lldb/source/Plugins/Process/Windows/x64/RegisterContextWindows_x64.h Normal file
View File

@@ -0,0 +1,48 @@
//===-- RegisterContextWindows_x64.h ----------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef liblldb_RegisterContextWindows_x64_H_
#define liblldb_RegisterContextWindows_x64_H_
#include "lldb/lldb-forward.h"
#include "RegisterContextWindows.h"
namespace lldb_private
{
class Thread;
class RegisterContextWindows_x64 : public RegisterContextWindows
{
public:
//------------------------------------------------------------------
// Constructors and Destructors
//------------------------------------------------------------------
RegisterContextWindows_x64(Thread &thread, uint32_t concrete_frame_idx);
virtual ~RegisterContextWindows_x64();
//------------------------------------------------------------------
// Subclasses must override these functions
//------------------------------------------------------------------
size_t GetRegisterCount() override;
const RegisterInfo *GetRegisterInfoAtIndex(size_t reg) override;
size_t GetRegisterSetCount() override;
const RegisterSet *GetRegisterSet(size_t reg_set) override;
bool ReadRegister(const RegisterInfo *reg_info, RegisterValue &reg_value) override;
bool WriteRegister(const RegisterInfo *reg_info, const RegisterValue &reg_value) override;
};
}
#endif // #ifndef liblldb_RegisterContextPOSIX_x64_H_

118
lldb/source/Plugins/Process/Windows/x86/RegisterContextWindows_x86.cpp
View File

@@ -8,7 +8,6 @@
//===----------------------------------------------------------------------===//
#include "lldb/lldb-private-types.h"
#include "lldb/Core/DataBufferHeap.h"
#include "lldb/Core/Error.h"
#include "lldb/Core/RegisterValue.h"
#include "lldb/Host/windows/HostThreadWindows.h"
@@ -49,8 +48,6 @@ enum RegisterIndex
eRegisterIndexEflags
};
const DWORD kWinContextFlags = CONTEXT_CONTROL | CONTEXT_INTEGER;
// Array of all register information supported by Windows x86
RegisterInfo g_register_infos[] =
{
@@ -92,9 +89,7 @@ RegisterSet g_register_sets[] = {
// Constructors and Destructors
//------------------------------------------------------------------
RegisterContextWindows_x86::RegisterContextWindows_x86(Thread &thread, uint32_t concrete_frame_idx)
: RegisterContext(thread, concrete_frame_idx)
, m_context()
, m_context_stale(true)
: RegisterContextWindows(thread, concrete_frame_idx)
{
}
@@ -102,12 +97,6 @@ RegisterContextWindows_x86::~RegisterContextWindows_x86()
{
}
void
RegisterContextWindows_x86::InvalidateAllRegisters()
{
m_context_stale = true;
}
size_t
RegisterContextWindows_x86::GetRegisterCount()
{
@@ -221,108 +210,3 @@ RegisterContextWindows_x86::WriteRegister(const RegisterInfo *reg_info, const Re
TargetThreadWindows &wthread = static_cast<TargetThreadWindows &>(m_thread);
return ::SetThreadContext(wthread.GetHostThread().GetNativeThread().GetSystemHandle(), &m_context);
}
bool
RegisterContextWindows_x86::ReadAllRegisterValues(lldb::DataBufferSP &data_sp)
{
if (!CacheAllRegisterValues())
return false;
if (data_sp->GetByteSize() < sizeof(m_context))
{
data_sp.reset(new DataBufferHeap(sizeof(CONTEXT), 0));
}
memcpy(data_sp->GetBytes(), &m_context, sizeof(m_context));
return true;
}
bool
RegisterContextWindows_x86::WriteAllRegisterValues(const lldb::DataBufferSP &data_sp)
{
assert(data_sp->GetByteSize() >= sizeof(m_context));
memcpy(&m_context, data_sp->GetBytes(), sizeof(m_context));
TargetThreadWindows &wthread = static_cast<TargetThreadWindows &>(m_thread);
if (!::SetThreadContext(wthread.GetHostThread().GetNativeThread().GetSystemHandle(), &m_context))
return false;
return true;
}
uint32_t
RegisterContextWindows_x86::ConvertRegisterKindToRegisterNumber(lldb::RegisterKind kind, uint32_t num)
{
const uint32_t num_regs = GetRegisterCount();
assert(kind < kNumRegisterKinds);
for (uint32_t reg_idx = 0; reg_idx < num_regs; ++reg_idx)
{
const RegisterInfo *reg_info = GetRegisterInfoAtIndex(reg_idx);
if (reg_info->kinds[kind] == num)
return reg_idx;
}
return LLDB_INVALID_REGNUM;
}
//------------------------------------------------------------------
// Subclasses can these functions if desired
//------------------------------------------------------------------
uint32_t
RegisterContextWindows_x86::NumSupportedHardwareBreakpoints()
{
// Support for hardware breakpoints not yet implemented.
return 0;
}
uint32_t
RegisterContextWindows_x86::SetHardwareBreakpoint(lldb::addr_t addr, size_t size)
{
return 0;
}
bool
RegisterContextWindows_x86::ClearHardwareBreakpoint(uint32_t hw_idx)
{
return false;
}
uint32_t
RegisterContextWindows_x86::NumSupportedHardwareWatchpoints()
{
// Support for hardware watchpoints not yet implemented.
return 0;
}
uint32_t
RegisterContextWindows_x86::SetHardwareWatchpoint(lldb::addr_t addr, size_t size, bool read, bool write)
{
return 0;
}
bool
RegisterContextWindows_x86::ClearHardwareWatchpoint(uint32_t hw_index)
{
return false;
}
bool
RegisterContextWindows_x86::HardwareSingleStep(bool enable)
{
return false;
}
bool
RegisterContextWindows_x86::CacheAllRegisterValues()
{
if (!m_context_stale)
return true;
TargetThreadWindows &wthread = static_cast<TargetThreadWindows &>(m_thread);
memset(&m_context, 0, sizeof(m_context));
m_context.ContextFlags = kWinContextFlags;
if (!::GetThreadContext(wthread.GetHostThread().GetNativeThread().GetSystemHandle(), &m_context))
return false;
m_context_stale = false;
return true;
}

35
lldb/source/Plugins/Process/Windows/x86/RegisterContextWindows_x86.h
View File

@@ -11,14 +11,14 @@
#define liblldb_RegisterContextWindows_x86_H_
#include "lldb/lldb-forward.h"
#include "lldb/Target/RegisterContext.h"
#include "RegisterContextWindows.h"
namespace lldb_private
{
class Thread;
class RegisterContextWindows_x86 : public lldb_private::RegisterContext
class RegisterContextWindows_x86 : public RegisterContextWindows
{
public:
//------------------------------------------------------------------
@@ -31,8 +31,6 @@ class RegisterContextWindows_x86 : public lldb_private::RegisterContext
//------------------------------------------------------------------
// Subclasses must override these functions
//------------------------------------------------------------------
void InvalidateAllRegisters() override;
size_t GetRegisterCount() override;
const RegisterInfo *GetRegisterInfoAtIndex(size_t reg) override;
@@ -44,35 +42,6 @@ class RegisterContextWindows_x86 : public lldb_private::RegisterContext
bool ReadRegister(const RegisterInfo *reg_info, RegisterValue &reg_value) override;
bool WriteRegister(const RegisterInfo *reg_info, const RegisterValue &reg_value) override;
bool ReadAllRegisterValues(lldb::DataBufferSP &data_sp) override;
bool WriteAllRegisterValues(const lldb::DataBufferSP &data_sp) override;
uint32_t ConvertRegisterKindToRegisterNumber(lldb::RegisterKind kind, uint32_t num) override;
//------------------------------------------------------------------
// Subclasses can override these functions if desired
//------------------------------------------------------------------
uint32_t NumSupportedHardwareBreakpoints() override;
uint32_t SetHardwareBreakpoint(lldb::addr_t addr, size_t size) override;
bool ClearHardwareBreakpoint(uint32_t hw_idx) override;
uint32_t NumSupportedHardwareWatchpoints() override;
uint32_t SetHardwareWatchpoint(lldb::addr_t addr, size_t size, bool read, bool write) override;
bool ClearHardwareWatchpoint(uint32_t hw_index) override;
bool HardwareSingleStep(bool enable) override;
private:
bool CacheAllRegisterValues();
CONTEXT m_context;
bool m_context_stale;
};
}