//===-- 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 ®_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 ®_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(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(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(m_thread); if (!::GetThreadContext(wthread.GetHostThread().GetNativeThread().GetSystemHandle(), m_context_ptr)) return false; m_context_stale = true; return true; }