This is an archive of the discontinued LLVM Phabricator instance.

Differential D6704

Fix compilation faliures for x64 visual studio 2013 build
ClosedPublic

Authored by ADodds on Dec 17 2014, 6:59 AM.

Details

Reviewers
emaste
zturner
domipheus
clayborg
Commits
rG7ae4b6de1d29: Only compile RegisterContextWindows_x86.cpp for x86 host architecture.
rLLDB224528: Only compile RegisterContextWindows_x86.cpp for x86 host architecture.
rL224528: Only compile RegisterContextWindows_x86.cpp for x86 host architecture.
Summary

The visual studio 2013 x64 build is failing due to some type differences between 32bit and 64bit builds.

The CONTEXT structure used in RegisterContextWindows_x86 changes its fields based on the build.
Currently I have used #ifdefs to alternate between the different registers for each build, is this an acceptable solution?

It seems however that HostThreadWindows is largely 32bit specific, so should there rather be a dedicated x64 version?

In HostThreadWindows its seems that ULONG_PTR also changes its size based on the machine type, however the argument for ExitThread() doesnt change in a simmilar way.
I have created a proxy function to wrap ExitThread() so it can again be used as a function pointer.

If these changes are acceptable, would someone be able to commit these fixes since I dont currently have commit access.

Thanks,
Aidan

Diff Detail

Repository
rL LLVM

Event Timeline

ADodds updated this revision to Diff 17392.Dec 17 2014, 6:59 AM
ADodds retitled this revision from to Fix compilation faliures for x64 visual studio 2013 build.
ADodds updated this object.
ADodds edited the test plan for this revision. (Show Details)
ADodds added reviewers: zturner, clayborg, emaste, domipheus.
ADodds added a subscriber: Unknown Object (MLST).
zturner edited edge metadata.Dec 17 2014, 7:18 AM

I'll take a look later today.

zturner added a comment.Dec 17 2014, 9:34 AM

I don't think this is the right fix. For x64 we should implement an entirely different RegisterContext class in a file called RegisterContext_x86_64. At some point we're going to want support debugging x86 targets with an x64 build of LLDB, but that has its own set of issues (notably that we will need to use Wow64GetThreadContext and a PWOW64_CONTEXT structure). So that will probably also require its own RegisterContext implementation. So the correct fix for this is to simply not compile this file on x64. You can do that at the CMake level by editing lldb\source\Plugins\Process\Windows\CMakeLists.txt and conditionally adding RegisterContext_x86.cpp only for builds where CMAKE_SIZEOF_VOID_P EQUAL 4.

Then, in ProcessWindows.cpp you'll need to wrap any lines that #include "RegisterContext_x86.h" or allocate a RegisterContext_x86 object in a similar #ifdef.

ADodds planned changes to this revision.Dec 17 2014, 9:59 AM

Thanks for taking a look at this.
I had an idea that the correct fix may be just what you have mentioned.
I will revise this patch to bypass this file for x64 builds as you advise.

ADodds added a comment.Dec 18 2014, 3:08 AM

Selectively including .cpp files in CMake may be harder then it first looks since the LLVM cmake automaticaly throw an error when it finds unincluded .cpp files.
When I tried to bypass RegisterContextWindows_x86.cpp for x64 targets I get the following error:

CMake Error at cmake/modules/LLVMProcessSources.cmake:70 (message):
  Found unknown source file
  D:/tiplldb/llvm/tools/lldb/source/Plugins/Process/Windows/RegisterContextWindows_x86.cpp


  Please update
  D:/tiplldb/llvm/tools/lldb/source/Plugins/Process/Windows/CMakeLists.txt

Call Stack (most recent call first):
  cmake/modules/LLVMProcessSources.cmake:44 (llvm_check_source_file_list)
  tools/lldb/CMakeLists.txt:230 (llvm_process_sources)
  tools/lldb/source/Plugins/Process/Windows/CMakeLists.txt:20 (add_lldb_library)

For reference, here was my modifications to lldb/source/plugins/process/windows/cmakelists.txt:

set(LLVM_NO_RTTI 1)

include_directories(.)
include_directories(../Utility)

set(lldbPluginProcessWindowsSources
  DebuggerThread.cpp
  DynamicLoaderWindows.cpp
  LocalDebugDelegate.cpp
  ProcessWindows.cpp
  TargetThreadWindows.cpp
  )

if (CMAKE_SIZEOF_VOID_P EQUAL 4)
  list(lldbPluginProcessWindowsSources APPEND
    RegisterContextWindows_x86.cpp
    )
endif()

add_lldb_library(lldbPluginProcessWindows
  ${lldbPluginProcessWindowsSources}
  )

Do you know any way to work around this?
Or do you have any suggestions how we can fix the build for x64 targets in the short term?

Thanks

zturner added a comment.Dec 18 2014, 7:30 AM

Easiest way is to Make a subfolder called x86 and move the files there.
Then selectively include them from the subfolder. Host does something
similar if you want an example

ADodds updated this revision to Diff 17447.Dec 18 2014, 9:05 AM
ADodds edited edge metadata.

I have reworked my initial patch with the feedback from Zachary.
I have tested this patch on both x86 and x64 windows builds and successfully build lldb on both.

Both RegisterContextWindows_x86.cpp and .h were not modified only modev, however the diff is a little verbose in this respect.

Thanks

zturner added a comment.Dec 18 2014, 9:55 AM

Looks good after addressing these comments.

source/Plugins/Process/Windows/CMakeLists.txt
11 ↗(On Diff #17447)

Change "lldbPluginProcessWindows" to "common". This controls how it will show up in Solution Explorer but otherwise doesn't mean anything, so it should be descriptive of the category.

20 ↗(On Diff #17447)

Change "lldbPluginProcessWindows" to "x86".

source/Plugins/Process/Windows/TargetThreadWindows.cpp
20 ↗(On Diff #17447)

I don't think we will ever build for itanium, and a better check for 64-bitness is to use _WIN64. So to be consistent with other places in the Windows codepath where we will need to check for 64-bitness, I would change this to

#if !defined(_WIN64)

78 ↗(On Diff #17447)

Same here, change to

#if defined(_WIN64)

zturner added a comment.Dec 18 2014, 9:57 AM

Actually since you don't have commit access, I will go ahead and make these fixes and then commit.

zturner added inline comments.Dec 18 2014, 10:05 AM
source/Plugins/Process/Windows/TargetThreadWindows.cpp
79–82 ↗(On Diff #17447)

Also, just as a heads up, I made one more change to the comment here. if the triple is x86 and the host architecture is x64, that's a Wow64 process, not an x86_64 process. That would occur if both the triple and the host architecture were x64. So I added an empty case to the switch to handle llvm::Triple::x64 and moved your comment there, and changed this comment to refer to a RegisterContextWindows_Wow64.

ADodds added a comment.Dec 18 2014, 10:08 AM

Thanks for the insightful feedback and for commiting this change Zachary.

Closed by commit rL224528: Only compile RegisterContextWindows_x86.cpp for x86 host architecture. (authored by zturner). · Explain WhyDec 18 2014, 10:22 AM
This revision was automatically updated to reflect the committed changes.

Revision Contents

PathSize
lldb/
trunk/
source/
Host/
windows/
10 lines
Plugins/
Process/
Windows/
17 lines
86 lines
354 lines
16 lines
x86/
86 lines
354 lines

Diff 17450

lldb/trunk/source/Host/windows/HostThreadWindows.cpp

Show All 11 Lines
#include "lldb/Host/windows/windows.h" #include "lldb/Host/windows/windows.h"
#include "lldb/Host/windows/HostThreadWindows.h" #include "lldb/Host/windows/HostThreadWindows.h"
#include "llvm/ADT/STLExtras.h" #include "llvm/ADT/STLExtras.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
namespace
{
void __stdcall ExitThreadProxy(ULONG_PTR dwExitCode)
{
::ExitThread(dwExitCode);
}
}
HostThreadWindows::HostThreadWindows() HostThreadWindows::HostThreadWindows()
: HostNativeThreadBase() : HostNativeThreadBase()
, m_owns_handle(true) , m_owns_handle(true)
{ {
} }
HostThreadWindows::HostThreadWindows(lldb::thread_t thread) HostThreadWindows::HostThreadWindows(lldb::thread_t thread)
: HostNativeThreadBase(thread) : HostNativeThreadBase(thread)
Show All 36 LinesHostThreadWindows::Join(lldb::thread_result_t *result)
return error; return error;
} }
Error Error
HostThreadWindows::Cancel() HostThreadWindows::Cancel()
{ {
Error error; Error error;
DWORD result = ::QueueUserAPC(::ExitThread, m_thread, 0); DWORD result = ::QueueUserAPC(::ExitThreadProxy, m_thread, 0);
error.SetError(result, eErrorTypeWin32); error.SetError(result, eErrorTypeWin32);
return error; return error;
} }
lldb::tid_t lldb::tid_t
HostThreadWindows::GetThreadId() const HostThreadWindows::GetThreadId() const
{ {
return ::GetThreadId(m_thread); return ::GetThreadId(m_thread);
Show All 10 Lines

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

set(LLVM_NO_RTTI 1) 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(.)
include_directories(../Utility) include_directories(../Utility)
add_lldb_library(lldbPluginProcessWindows add_process_windows_subdirectory(common
DebuggerThread.cpp DebuggerThread.cpp
DynamicLoaderWindows.cpp DynamicLoaderWindows.cpp
LocalDebugDelegate.cpp LocalDebugDelegate.cpp
ProcessWindows.cpp ProcessWindows.cpp
RegisterContextWindows_x86.cpp
TargetThreadWindows.cpp TargetThreadWindows.cpp
) )
if (CMAKE_SIZEOF_VOID_P EQUAL 4)
add_process_windows_subdirectory(x86
x86/RegisterContextWindows_x86.cpp
)
endif()
add_lldb_library(lldbPluginProcessWindows
${PROC_WINDOWS_SOURCES}
)

lldb/trunk/source/Plugins/Process/Windows/RegisterContextWindows_x86.h

//===-- RegisterContextWindows_x86.h ----------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef liblldb_RegisterContextWindows_x86_H_
#define liblldb_RegisterContextWindows_x86_H_
#include "lldb/lldb-forward.h"
#include "lldb/Target/RegisterContext.h"
namespace lldb_private
{
class Thread;
class RegisterContextWindows_x86 : public lldb_private::RegisterContext
{
public:
//------------------------------------------------------------------
// Constructors and Destructors
//------------------------------------------------------------------
RegisterContextWindows_x86(Thread &thread, uint32_t concrete_frame_idx);
virtual ~RegisterContextWindows_x86();
//------------------------------------------------------------------
// Subclasses must override these functions
//------------------------------------------------------------------
void InvalidateAllRegisters() override;
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;
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 InitializeContextDataBuffer(lldb::DataBufferSP &buffer, CONTEXT **context_ptr);
bool CacheAllRegisterValues();
// The system CONTEXT structure. m_context_ptr is backed by m_cached_context, but
// m_context_ptr may not point to the beginning of the buffer allocated in m_cached_context,
// due to alignment requirements of CONTEXT structures.
lldb::DataBufferSP m_cached_context;
CONTEXT *m_context_ptr;
bool m_context_stale;
};
}
#endif // #ifndef liblldb_RegisterContextPOSIX_x86_H_

lldb/trunk/source/Plugins/Process/Windows/RegisterContextWindows_x86.cpp

//===-- RegisterContextWindows_x86.h ----------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include "lldb/lldb-private-types.h"
#include "lldb/Core/DataBufferHeap.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_x86.h"
#include "TargetThreadWindows.h"
#include "llvm/ADT/STLExtras.h"
using namespace lldb;
using namespace lldb_private;
#define DEFINE_GPR(reg, alt) #reg, alt, 4, 0, eEncodingUint, eFormatHexUppercase
#define DEFINE_GPR_BIN(reg, alt) #reg, alt, 4, 0, eEncodingUint, eFormatBinary
namespace
{
// This enum defines the layout of the global RegisterInfo array. This is necessary because
// lldb register sets are defined in terms of indices into the register array. As such, the
// order of RegisterInfos defined in global registers array must match the order defined here.
// When defining the register set layouts, these values can appear in an arbitrary order, and that
// determines the order that register values are displayed in a dump.
enum RegisterIndex
{
eRegisterIndexEax,
eRegisterIndexEbx,
eRegisterIndexEcx,
eRegisterIndexEdx,
eRegisterIndexEdi,
eRegisterIndexEsi,
eRegisterIndexEbp,
eRegisterIndexEsp,
eRegisterIndexEip,
eRegisterIndexEflags
};
const DWORD kWinContextFlags = CONTEXT_CONTROL | CONTEXT_INTEGER;
// Array of all register information supported by Windows x86
RegisterInfo g_register_infos[] =
{
// Macro auto defines most stuff GCC DWARF GENERIC GDB LLDB VALUE REGS INVALIDATE REGS
// ============================== ======================= =================== ========================= =================== ================= ========== ===============
{ DEFINE_GPR(eax, nullptr), { gcc_eax_i386, dwarf_eax_i386, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, lldb_eax_i386 }, nullptr, nullptr},
{ DEFINE_GPR(ebx, nullptr), { gcc_ebx_i386, dwarf_ebx_i386, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, lldb_ebx_i386 }, nullptr, nullptr},
{ DEFINE_GPR(ecx, nullptr), { gcc_ecx_i386, dwarf_ecx_i386, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, lldb_ecx_i386 }, nullptr, nullptr},
{ DEFINE_GPR(edx, nullptr), { gcc_edx_i386, dwarf_edx_i386, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, lldb_edx_i386 }, nullptr, nullptr},
{ DEFINE_GPR(edi, nullptr), { gcc_edi_i386, dwarf_edi_i386, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, lldb_edi_i386 }, nullptr, nullptr},
{ DEFINE_GPR(esi, nullptr), { gcc_esi_i386, dwarf_esi_i386, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, lldb_esi_i386 }, nullptr, nullptr},
{ DEFINE_GPR(ebp, "fp"), { gcc_ebp_i386, dwarf_ebp_i386, LLDB_REGNUM_GENERIC_FP, LLDB_INVALID_REGNUM, lldb_ebp_i386 }, nullptr, nullptr},
{ DEFINE_GPR(esp, "sp"), { gcc_esp_i386, dwarf_esp_i386, LLDB_REGNUM_GENERIC_SP, LLDB_INVALID_REGNUM, lldb_esp_i386 }, nullptr, nullptr},
{ DEFINE_GPR(eip, "pc"), { gcc_eip_i386, dwarf_eip_i386, LLDB_REGNUM_GENERIC_PC, LLDB_INVALID_REGNUM, lldb_eip_i386 }, nullptr, nullptr},
{ DEFINE_GPR_BIN(eflags, "flags"), { gcc_eflags_i386, dwarf_eflags_i386, LLDB_REGNUM_GENERIC_FLAGS, LLDB_INVALID_REGNUM, lldb_eflags_i386}, nullptr, nullptr},
};
// Array of lldb register numbers used to define the set of all General Purpose Registers
uint32_t g_gpr_reg_indices[] =
{
eRegisterIndexEax,
eRegisterIndexEbx,
eRegisterIndexEcx,
eRegisterIndexEdx,
eRegisterIndexEdi,
eRegisterIndexEsi,
eRegisterIndexEbp,
eRegisterIndexEsp,
eRegisterIndexEip,
eRegisterIndexEflags
};
RegisterSet g_register_sets[] = {
{"General Purpose Registers", "gpr", llvm::array_lengthof(g_gpr_reg_indices), g_gpr_reg_indices},
};
}
//------------------------------------------------------------------
// Constructors and Destructors
//------------------------------------------------------------------
RegisterContextWindows_x86::RegisterContextWindows_x86(Thread &thread, uint32_t concrete_frame_idx)
: RegisterContext(thread, concrete_frame_idx)
, m_context_stale(true)
, m_context_ptr(nullptr)
{
}
RegisterContextWindows_x86::~RegisterContextWindows_x86()
{
}
void
RegisterContextWindows_x86::InvalidateAllRegisters()
{
m_context_stale = true;
}
size_t
RegisterContextWindows_x86::GetRegisterCount()
{
return llvm::array_lengthof(g_register_infos);
}
const RegisterInfo *
RegisterContextWindows_x86::GetRegisterInfoAtIndex(size_t reg)
{
return &g_register_infos[reg];
}
size_t
RegisterContextWindows_x86::GetRegisterSetCount()
{
return llvm::array_lengthof(g_register_sets);
}
const RegisterSet *
RegisterContextWindows_x86::GetRegisterSet(size_t reg_set)
{
return &g_register_sets[reg_set];
}
bool
RegisterContextWindows_x86::ReadRegister(const RegisterInfo *reg_info, RegisterValue &reg_value)
{
if (!CacheAllRegisterValues())
return false;
switch (reg_info->kinds[eRegisterKindLLDB])
{
case lldb_eax_i386:
reg_value.SetUInt32(m_context_ptr->Eax);
break;
case lldb_ebx_i386:
reg_value.SetUInt32(m_context_ptr->Ebx);
break;
case lldb_ecx_i386:
reg_value.SetUInt32(m_context_ptr->Ecx);
break;
case lldb_edx_i386:
reg_value.SetUInt32(m_context_ptr->Edx);
break;
case lldb_edi_i386:
reg_value.SetUInt32(m_context_ptr->Edi);
break;
case lldb_esi_i386:
reg_value.SetUInt32(m_context_ptr->Esi);
break;
case lldb_ebp_i386:
reg_value.SetUInt32(m_context_ptr->Ebp);
break;
case lldb_esp_i386:
reg_value.SetUInt32(m_context_ptr->Esp);
break;
case lldb_eip_i386:
reg_value.SetUInt32(m_context_ptr->Eip);
break;
case lldb_eflags_i386:
reg_value.SetUInt32(m_context_ptr->EFlags);
break;
}
return true;
}
bool
RegisterContextWindows_x86::WriteRegister(const RegisterInfo *reg_info, const RegisterValue &reg_value)
{
// Since we cannot only write a single register value to the inferior, we need to make sure
// our cached copy of the register values are fresh. Otherwise when writing EAX, for example,
// we may also overwrite some other register with a stale value.
if (!CacheAllRegisterValues())
return false;
switch (reg_info->kinds[eRegisterKindLLDB])
{
case lldb_eax_i386:
m_context_ptr->Eax = reg_value.GetAsUInt32();
break;
case lldb_ebx_i386:
m_context_ptr->Ebx = reg_value.GetAsUInt32();
break;
case lldb_ecx_i386:
m_context_ptr->Ecx = reg_value.GetAsUInt32();
break;
case lldb_edx_i386:
m_context_ptr->Edx = reg_value.GetAsUInt32();
break;
case lldb_edi_i386:
m_context_ptr->Edi = reg_value.GetAsUInt32();
break;
case lldb_esi_i386:
m_context_ptr->Esi = reg_value.GetAsUInt32();
break;
case lldb_ebp_i386:
m_context_ptr->Ebp = reg_value.GetAsUInt32();
break;
case lldb_esp_i386:
m_context_ptr->Esp = reg_value.GetAsUInt32();
break;
case lldb_eip_i386:
m_context_ptr->Eip = reg_value.GetAsUInt32();
break;
case lldb_eflags_i386:
m_context_ptr->EFlags = reg_value.GetAsUInt32();
break;
}
// Physically update the registers in the target process.
TargetThreadWindows &wthread = static_cast<TargetThreadWindows &>(m_thread);
return ::SetThreadContext(wthread.GetHostThread().GetNativeThread().GetSystemHandle(), m_context_ptr);
}
bool
RegisterContextWindows_x86::ReadAllRegisterValues(lldb::DataBufferSP &data_sp)
{
if (!CacheAllRegisterValues())
return false;
CONTEXT *dest_context = nullptr;
if (!InitializeContextDataBuffer(data_sp, &dest_context))
return false;
// Write the OS's internal CONTEXT structure into the buffer.
if (!CopyContext(dest_context, kWinContextFlags, m_context_ptr))
return false;
return true;
}
bool
RegisterContextWindows_x86::WriteAllRegisterValues(const lldb::DataBufferSP &data_sp)
{
// data_sp could only ever have been generated by a call to ReadAllRegisterValues(), so
// m_cached_context should already have the correct size and alignment properties.
assert(m_cached_context->GetByteSize() == data_sp->GetByteSize());
// As a result, we can simply memcpy the entire buffer and assume that the alignment remains
// the same.
memcpy(m_cached_context->GetBytes(), data_sp->GetBytes(), data_sp->GetByteSize());
// m_context_ptr still points to the beginning of the CONTEXT structure, so use that for
// updating the thread state.
TargetThreadWindows &wthread = static_cast<TargetThreadWindows &>(m_thread);
if (!::SetThreadContext(wthread.GetHostThread().GetNativeThread().GetSystemHandle(), m_context_ptr))
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::InitializeContextDataBuffer(DataBufferSP &buffer, CONTEXT **context_ptr)
{
DWORD length = 0;
if (!::InitializeContext(nullptr, kWinContextFlags, nullptr, &length) && GetLastError() != ERROR_INSUFFICIENT_BUFFER)
return false;
buffer.reset(new DataBufferHeap(length, 0));
if (!::InitializeContext(buffer->GetBytes(), kWinContextFlags, context_ptr, &length))
{
buffer.reset();
return false;
}
return true;
}
bool
RegisterContextWindows_x86::CacheAllRegisterValues()
{
if (!m_context_stale)
return true;
if (!m_cached_context && !InitializeContextDataBuffer(m_cached_context, &m_context_ptr))
return false;
TargetThreadWindows &wthread = static_cast<TargetThreadWindows &>(m_thread);
if (!::GetThreadContext(wthread.GetHostThread().GetNativeThread().GetSystemHandle(), m_context_ptr))
return false;
m_context_stale = true;
return true;
}

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

Show All 9 Lines
#include "lldb/Host/HostInfo.h" #include "lldb/Host/HostInfo.h"
#include "lldb/Host/HostNativeThreadBase.h" #include "lldb/Host/HostNativeThreadBase.h"
#include "lldb/Host/windows/HostThreadWindows.h" #include "lldb/Host/windows/HostThreadWindows.h"
#include "lldb/Host/windows/windows.h" #include "lldb/Host/windows/windows.h"
#include "lldb/Target/RegisterContext.h" #include "lldb/Target/RegisterContext.h"
#include "TargetThreadWindows.h" #include "TargetThreadWindows.h"
#include "ProcessWindows.h" #include "ProcessWindows.h"
#include "RegisterContextWindows_x86.h"
#include "UnwindLLDB.h" #include "UnwindLLDB.h"
#if !defined(_WIN64)
#include "x86/RegisterContextWindows_x86.h"
#endif
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
TargetThreadWindows::TargetThreadWindows(ProcessWindows &process, const HostThread &thread) TargetThreadWindows::TargetThreadWindows(ProcessWindows &process, const HostThread &thread)
: Thread(process, thread.GetNativeThread().GetThreadId()) : Thread(process, thread.GetNativeThread().GetThreadId())
, m_host_thread(thread) , m_host_thread(thread)
{ {
} }
Show All 38 Lines
TargetThreadWindows::CreateRegisterContextForFrameIndex(uint32_t idx) TargetThreadWindows::CreateRegisterContextForFrameIndex(uint32_t idx)
{ {
if (!m_reg_context_sp) if (!m_reg_context_sp)
{ {
ArchSpec arch = HostInfo::GetArchitecture(); ArchSpec arch = HostInfo::GetArchitecture();
switch (arch.GetMachine()) switch (arch.GetMachine())
{ {
case llvm::Triple::x86: case llvm::Triple::x86:
#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 RegisterContextWindows_x86(*this, idx));
#endif
break; break;
case llvm::Triple::x86_64:
#if defined(_WIN64)
// FIXME: This is a 64-bit process, create a RegisterContextWindows_x86_64
#else
// LLDB is 32-bit, but the target process is 64-bit. We probably can't debug this.
#endif
default: default:
// FIXME: Support x64 by creating a RegisterContextWindows_x86_64
break; break;
} }
} }
return m_reg_context_sp; return m_reg_context_sp;
} }
bool bool
TargetThreadWindows::CalculateStopInfo() TargetThreadWindows::CalculateStopInfo()
▲ Show 20 Lines • Show All 47 Lines • Show Last 20 Lines

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

//===-- RegisterContextWindows_x86.h ----------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef liblldb_RegisterContextWindows_x86_H_
#define liblldb_RegisterContextWindows_x86_H_
#include "lldb/lldb-forward.h"
#include "lldb/Target/RegisterContext.h"
namespace lldb_private
{
class Thread;
class RegisterContextWindows_x86 : public lldb_private::RegisterContext
{
public:
//------------------------------------------------------------------
// Constructors and Destructors
//------------------------------------------------------------------
RegisterContextWindows_x86(Thread &thread, uint32_t concrete_frame_idx);
virtual ~RegisterContextWindows_x86();
//------------------------------------------------------------------
// Subclasses must override these functions
//------------------------------------------------------------------
void InvalidateAllRegisters() override;
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;
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 InitializeContextDataBuffer(lldb::DataBufferSP &buffer, CONTEXT **context_ptr);
bool CacheAllRegisterValues();
// The system CONTEXT structure. m_context_ptr is backed by m_cached_context, but
// m_context_ptr may not point to the beginning of the buffer allocated in m_cached_context,
// due to alignment requirements of CONTEXT structures.
lldb::DataBufferSP m_cached_context;
CONTEXT *m_context_ptr;
bool m_context_stale;
};
}
#endif // #ifndef liblldb_RegisterContextPOSIX_x86_H_

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

//===-- RegisterContextWindows_x86.h ----------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include "lldb/lldb-private-types.h"
#include "lldb/Core/DataBufferHeap.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_x86.h"
#include "TargetThreadWindows.h"
#include "llvm/ADT/STLExtras.h"
using namespace lldb;
using namespace lldb_private;
#define DEFINE_GPR(reg, alt) #reg, alt, 4, 0, eEncodingUint, eFormatHexUppercase
#define DEFINE_GPR_BIN(reg, alt) #reg, alt, 4, 0, eEncodingUint, eFormatBinary
namespace
{
// This enum defines the layout of the global RegisterInfo array. This is necessary because
// lldb register sets are defined in terms of indices into the register array. As such, the
// order of RegisterInfos defined in global registers array must match the order defined here.
// When defining the register set layouts, these values can appear in an arbitrary order, and that
// determines the order that register values are displayed in a dump.
enum RegisterIndex
{
eRegisterIndexEax,
eRegisterIndexEbx,
eRegisterIndexEcx,
eRegisterIndexEdx,
eRegisterIndexEdi,
eRegisterIndexEsi,
eRegisterIndexEbp,
eRegisterIndexEsp,
eRegisterIndexEip,
eRegisterIndexEflags
};
const DWORD kWinContextFlags = CONTEXT_CONTROL | CONTEXT_INTEGER;
// Array of all register information supported by Windows x86
RegisterInfo g_register_infos[] =
{
// Macro auto defines most stuff GCC DWARF GENERIC GDB LLDB VALUE REGS INVALIDATE REGS
// ============================== ======================= =================== ========================= =================== ================= ========== ===============
{ DEFINE_GPR(eax, nullptr), { gcc_eax_i386, dwarf_eax_i386, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, lldb_eax_i386 }, nullptr, nullptr},
{ DEFINE_GPR(ebx, nullptr), { gcc_ebx_i386, dwarf_ebx_i386, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, lldb_ebx_i386 }, nullptr, nullptr},
{ DEFINE_GPR(ecx, nullptr), { gcc_ecx_i386, dwarf_ecx_i386, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, lldb_ecx_i386 }, nullptr, nullptr},
{ DEFINE_GPR(edx, nullptr), { gcc_edx_i386, dwarf_edx_i386, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, lldb_edx_i386 }, nullptr, nullptr},
{ DEFINE_GPR(edi, nullptr), { gcc_edi_i386, dwarf_edi_i386, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, lldb_edi_i386 }, nullptr, nullptr},
{ DEFINE_GPR(esi, nullptr), { gcc_esi_i386, dwarf_esi_i386, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, lldb_esi_i386 }, nullptr, nullptr},
{ DEFINE_GPR(ebp, "fp"), { gcc_ebp_i386, dwarf_ebp_i386, LLDB_REGNUM_GENERIC_FP, LLDB_INVALID_REGNUM, lldb_ebp_i386 }, nullptr, nullptr},
{ DEFINE_GPR(esp, "sp"), { gcc_esp_i386, dwarf_esp_i386, LLDB_REGNUM_GENERIC_SP, LLDB_INVALID_REGNUM, lldb_esp_i386 }, nullptr, nullptr},
{ DEFINE_GPR(eip, "pc"), { gcc_eip_i386, dwarf_eip_i386, LLDB_REGNUM_GENERIC_PC, LLDB_INVALID_REGNUM, lldb_eip_i386 }, nullptr, nullptr},
{ DEFINE_GPR_BIN(eflags, "flags"), { gcc_eflags_i386, dwarf_eflags_i386, LLDB_REGNUM_GENERIC_FLAGS, LLDB_INVALID_REGNUM, lldb_eflags_i386}, nullptr, nullptr},
};
// Array of lldb register numbers used to define the set of all General Purpose Registers
uint32_t g_gpr_reg_indices[] =
{
eRegisterIndexEax,
eRegisterIndexEbx,
eRegisterIndexEcx,
eRegisterIndexEdx,
eRegisterIndexEdi,
eRegisterIndexEsi,
eRegisterIndexEbp,
eRegisterIndexEsp,
eRegisterIndexEip,
eRegisterIndexEflags
};
RegisterSet g_register_sets[] = {
{"General Purpose Registers", "gpr", llvm::array_lengthof(g_gpr_reg_indices), g_gpr_reg_indices},
};
}
//------------------------------------------------------------------
// Constructors and Destructors
//------------------------------------------------------------------
RegisterContextWindows_x86::RegisterContextWindows_x86(Thread &thread, uint32_t concrete_frame_idx)
: RegisterContext(thread, concrete_frame_idx)
, m_context_stale(true)
, m_context_ptr(nullptr)
{
}
RegisterContextWindows_x86::~RegisterContextWindows_x86()
{
}
void
RegisterContextWindows_x86::InvalidateAllRegisters()
{
m_context_stale = true;
}
size_t
RegisterContextWindows_x86::GetRegisterCount()
{
return llvm::array_lengthof(g_register_infos);
}
const RegisterInfo *
RegisterContextWindows_x86::GetRegisterInfoAtIndex(size_t reg)
{
return &g_register_infos[reg];
}
size_t
RegisterContextWindows_x86::GetRegisterSetCount()
{
return llvm::array_lengthof(g_register_sets);
}
const RegisterSet *
RegisterContextWindows_x86::GetRegisterSet(size_t reg_set)
{
return &g_register_sets[reg_set];
}
bool
RegisterContextWindows_x86::ReadRegister(const RegisterInfo *reg_info, RegisterValue &reg_value)
{
if (!CacheAllRegisterValues())
return false;
switch (reg_info->kinds[eRegisterKindLLDB])
{
case lldb_eax_i386:
reg_value.SetUInt32(m_context_ptr->Eax);
break;
case lldb_ebx_i386:
reg_value.SetUInt32(m_context_ptr->Ebx);
break;
case lldb_ecx_i386:
reg_value.SetUInt32(m_context_ptr->Ecx);
break;
case lldb_edx_i386:
reg_value.SetUInt32(m_context_ptr->Edx);
break;
case lldb_edi_i386:
reg_value.SetUInt32(m_context_ptr->Edi);
break;
case lldb_esi_i386:
reg_value.SetUInt32(m_context_ptr->Esi);
break;
case lldb_ebp_i386:
reg_value.SetUInt32(m_context_ptr->Ebp);
break;
case lldb_esp_i386:
reg_value.SetUInt32(m_context_ptr->Esp);
break;
case lldb_eip_i386:
reg_value.SetUInt32(m_context_ptr->Eip);
break;
case lldb_eflags_i386:
reg_value.SetUInt32(m_context_ptr->EFlags);
break;
}
return true;
}
bool
RegisterContextWindows_x86::WriteRegister(const RegisterInfo *reg_info, const RegisterValue &reg_value)
{
// Since we cannot only write a single register value to the inferior, we need to make sure
// our cached copy of the register values are fresh. Otherwise when writing EAX, for example,
// we may also overwrite some other register with a stale value.
if (!CacheAllRegisterValues())
return false;
switch (reg_info->kinds[eRegisterKindLLDB])
{
case lldb_eax_i386:
m_context_ptr->Eax = reg_value.GetAsUInt32();
break;
case lldb_ebx_i386:
m_context_ptr->Ebx = reg_value.GetAsUInt32();
break;
case lldb_ecx_i386:
m_context_ptr->Ecx = reg_value.GetAsUInt32();
break;
case lldb_edx_i386:
m_context_ptr->Edx = reg_value.GetAsUInt32();
break;
case lldb_edi_i386:
m_context_ptr->Edi = reg_value.GetAsUInt32();
break;
case lldb_esi_i386:
m_context_ptr->Esi = reg_value.GetAsUInt32();
break;
case lldb_ebp_i386:
m_context_ptr->Ebp = reg_value.GetAsUInt32();
break;
case lldb_esp_i386:
m_context_ptr->Esp = reg_value.GetAsUInt32();
break;
case lldb_eip_i386:
m_context_ptr->Eip = reg_value.GetAsUInt32();
break;
case lldb_eflags_i386:
m_context_ptr->EFlags = reg_value.GetAsUInt32();
break;
}
// Physically update the registers in the target process.
TargetThreadWindows &wthread = static_cast<TargetThreadWindows &>(m_thread);
return ::SetThreadContext(wthread.GetHostThread().GetNativeThread().GetSystemHandle(), m_context_ptr);
}
bool
RegisterContextWindows_x86::ReadAllRegisterValues(lldb::DataBufferSP &data_sp)
{
if (!CacheAllRegisterValues())
return false;
CONTEXT *dest_context = nullptr;
if (!InitializeContextDataBuffer(data_sp, &dest_context))
return false;
// Write the OS's internal CONTEXT structure into the buffer.
if (!CopyContext(dest_context, kWinContextFlags, m_context_ptr))
return false;
return true;
}
bool
RegisterContextWindows_x86::WriteAllRegisterValues(const lldb::DataBufferSP &data_sp)
{
// data_sp could only ever have been generated by a call to ReadAllRegisterValues(), so
// m_cached_context should already have the correct size and alignment properties.
assert(m_cached_context->GetByteSize() == data_sp->GetByteSize());
// As a result, we can simply memcpy the entire buffer and assume that the alignment remains
// the same.
memcpy(m_cached_context->GetBytes(), data_sp->GetBytes(), data_sp->GetByteSize());
// m_context_ptr still points to the beginning of the CONTEXT structure, so use that for
// updating the thread state.
TargetThreadWindows &wthread = static_cast<TargetThreadWindows &>(m_thread);
if (!::SetThreadContext(wthread.GetHostThread().GetNativeThread().GetSystemHandle(), m_context_ptr))
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::InitializeContextDataBuffer(DataBufferSP &buffer, CONTEXT **context_ptr)
{
DWORD length = 0;
if (!::InitializeContext(nullptr, kWinContextFlags, nullptr, &length) && GetLastError() != ERROR_INSUFFICIENT_BUFFER)
return false;
buffer.reset(new DataBufferHeap(length, 0));
if (!::InitializeContext(buffer->GetBytes(), kWinContextFlags, context_ptr, &length))
{
buffer.reset();
return false;
}
return true;
}
bool
RegisterContextWindows_x86::CacheAllRegisterValues()
{
if (!m_context_stale)
return true;
if (!m_cached_context && !InitializeContextDataBuffer(m_cached_context, &m_context_ptr))
return false;
TargetThreadWindows &wthread = static_cast<TargetThreadWindows &>(m_thread);
if (!::GetThreadContext(wthread.GetHostThread().GetNativeThread().GetSystemHandle(), m_context_ptr))
return false;
m_context_stale = true;
return true;
}
lldb/trunk/source/Plugins/Process/Windows/CMakeLists.txt