1 //===-- RegisterContextWindows_x86.cpp --------------------------*- C++ -*-===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 10 #include "lldb/Core/Error.h" 11 #include "lldb/Core/RegisterValue.h" 12 #include "lldb/Host/windows/HostThreadWindows.h" 13 #include "lldb/Host/windows/windows.h" 14 #include "lldb/lldb-private-types.h" 15 16 #include "ProcessWindowsLog.h" 17 #include "RegisterContextWindows_x86.h" 18 #include "RegisterContext_x86.h" 19 #include "TargetThreadWindows.h" 20 #include "lldb-x86-register-enums.h" 21 22 #include "llvm/ADT/STLExtras.h" 23 24 using namespace lldb; 25 using namespace lldb_private; 26 27 #define DEFINE_GPR(reg, alt) #reg, alt, 4, 0, eEncodingUint, eFormatHexUppercase 28 #define DEFINE_GPR_BIN(reg, alt) #reg, alt, 4, 0, eEncodingUint, eFormatBinary 29 30 namespace { 31 32 // This enum defines the layout of the global RegisterInfo array. This is 33 // necessary because 34 // lldb register sets are defined in terms of indices into the register array. 35 // As such, the 36 // order of RegisterInfos defined in global registers array must match the order 37 // defined here. 38 // When defining the register set layouts, these values can appear in an 39 // arbitrary order, and that 40 // determines the order that register values are displayed in a dump. 41 enum RegisterIndex { 42 eRegisterIndexEax, 43 eRegisterIndexEbx, 44 eRegisterIndexEcx, 45 eRegisterIndexEdx, 46 eRegisterIndexEdi, 47 eRegisterIndexEsi, 48 eRegisterIndexEbp, 49 eRegisterIndexEsp, 50 eRegisterIndexEip, 51 eRegisterIndexEflags 52 }; 53 54 // Array of all register information supported by Windows x86 55 RegisterInfo g_register_infos[] = { 56 // Macro auto defines most stuff eh_frame DWARF 57 // GENERIC GDB LLDB 58 // VALUE REGS INVALIDATE REGS 59 // ============================== ======================= 60 // =================== ========================= =================== 61 // ================= ========== =============== 62 {DEFINE_GPR(eax, nullptr), 63 {ehframe_eax_i386, dwarf_eax_i386, LLDB_INVALID_REGNUM, 64 LLDB_INVALID_REGNUM, lldb_eax_i386}, 65 nullptr, 66 nullptr, 67 nullptr, 68 0u}, 69 {DEFINE_GPR(ebx, nullptr), 70 {ehframe_ebx_i386, dwarf_ebx_i386, LLDB_INVALID_REGNUM, 71 LLDB_INVALID_REGNUM, lldb_ebx_i386}, 72 nullptr, 73 nullptr, 74 nullptr, 75 0u}, 76 {DEFINE_GPR(ecx, nullptr), 77 {ehframe_ecx_i386, dwarf_ecx_i386, LLDB_INVALID_REGNUM, 78 LLDB_INVALID_REGNUM, lldb_ecx_i386}, 79 nullptr, 80 nullptr, 81 nullptr, 82 0u}, 83 {DEFINE_GPR(edx, nullptr), 84 {ehframe_edx_i386, dwarf_edx_i386, LLDB_INVALID_REGNUM, 85 LLDB_INVALID_REGNUM, lldb_edx_i386}, 86 nullptr, 87 nullptr, 88 nullptr, 89 0u}, 90 {DEFINE_GPR(edi, nullptr), 91 {ehframe_edi_i386, dwarf_edi_i386, LLDB_INVALID_REGNUM, 92 LLDB_INVALID_REGNUM, lldb_edi_i386}, 93 nullptr, 94 nullptr, 95 nullptr, 96 0u}, 97 {DEFINE_GPR(esi, nullptr), 98 {ehframe_esi_i386, dwarf_esi_i386, LLDB_INVALID_REGNUM, 99 LLDB_INVALID_REGNUM, lldb_esi_i386}, 100 nullptr, 101 nullptr, 102 nullptr, 103 0u}, 104 {DEFINE_GPR(ebp, "fp"), 105 {ehframe_ebp_i386, dwarf_ebp_i386, LLDB_REGNUM_GENERIC_FP, 106 LLDB_INVALID_REGNUM, lldb_ebp_i386}, 107 nullptr, 108 nullptr, 109 nullptr, 110 0u}, 111 {DEFINE_GPR(esp, "sp"), 112 {ehframe_esp_i386, dwarf_esp_i386, LLDB_REGNUM_GENERIC_SP, 113 LLDB_INVALID_REGNUM, lldb_esp_i386}, 114 nullptr, 115 nullptr, 116 nullptr, 117 0u}, 118 {DEFINE_GPR(eip, "pc"), 119 {ehframe_eip_i386, dwarf_eip_i386, LLDB_REGNUM_GENERIC_PC, 120 LLDB_INVALID_REGNUM, lldb_eip_i386}, 121 nullptr, 122 nullptr, 123 nullptr, 124 0u}, 125 {DEFINE_GPR_BIN(eflags, "flags"), 126 {ehframe_eflags_i386, dwarf_eflags_i386, LLDB_REGNUM_GENERIC_FLAGS, 127 LLDB_INVALID_REGNUM, lldb_eflags_i386}, 128 nullptr, 129 nullptr, 130 nullptr, 131 0u}, 132 }; 133 static size_t k_num_register_infos = llvm::array_lengthof(g_register_infos); 134 135 // Array of lldb register numbers used to define the set of all General Purpose 136 // Registers 137 uint32_t g_gpr_reg_indices[] = {eRegisterIndexEax, eRegisterIndexEbx, 138 eRegisterIndexEcx, eRegisterIndexEdx, 139 eRegisterIndexEdi, eRegisterIndexEsi, 140 eRegisterIndexEbp, eRegisterIndexEsp, 141 eRegisterIndexEip, eRegisterIndexEflags}; 142 143 RegisterSet g_register_sets[] = { 144 {"General Purpose Registers", "gpr", 145 llvm::array_lengthof(g_gpr_reg_indices), g_gpr_reg_indices}, 146 }; 147 } 148 149 //------------------------------------------------------------------ 150 // Constructors and Destructors 151 //------------------------------------------------------------------ 152 RegisterContextWindows_x86::RegisterContextWindows_x86( 153 Thread &thread, uint32_t concrete_frame_idx) 154 : RegisterContextWindows(thread, concrete_frame_idx) {} 155 156 RegisterContextWindows_x86::~RegisterContextWindows_x86() {} 157 158 size_t RegisterContextWindows_x86::GetRegisterCount() { 159 return llvm::array_lengthof(g_register_infos); 160 } 161 162 const RegisterInfo * 163 RegisterContextWindows_x86::GetRegisterInfoAtIndex(size_t reg) { 164 if (reg < k_num_register_infos) 165 return &g_register_infos[reg]; 166 return NULL; 167 } 168 169 size_t RegisterContextWindows_x86::GetRegisterSetCount() { 170 return llvm::array_lengthof(g_register_sets); 171 } 172 173 const RegisterSet *RegisterContextWindows_x86::GetRegisterSet(size_t reg_set) { 174 return &g_register_sets[reg_set]; 175 } 176 177 bool RegisterContextWindows_x86::ReadRegister(const RegisterInfo *reg_info, 178 RegisterValue ®_value) { 179 if (!CacheAllRegisterValues()) 180 return false; 181 182 uint32_t reg = reg_info->kinds[eRegisterKindLLDB]; 183 switch (reg) { 184 case lldb_eax_i386: 185 return ReadRegisterHelper(CONTEXT_INTEGER, "EAX", m_context.Eax, reg_value); 186 case lldb_ebx_i386: 187 return ReadRegisterHelper(CONTEXT_INTEGER, "EBX", m_context.Ebx, reg_value); 188 case lldb_ecx_i386: 189 return ReadRegisterHelper(CONTEXT_INTEGER, "ECX", m_context.Ecx, reg_value); 190 case lldb_edx_i386: 191 return ReadRegisterHelper(CONTEXT_INTEGER, "EDX", m_context.Edx, reg_value); 192 case lldb_edi_i386: 193 return ReadRegisterHelper(CONTEXT_INTEGER, "EDI", m_context.Edi, reg_value); 194 case lldb_esi_i386: 195 return ReadRegisterHelper(CONTEXT_INTEGER, "ESI", m_context.Esi, reg_value); 196 case lldb_ebp_i386: 197 return ReadRegisterHelper(CONTEXT_CONTROL, "EBP", m_context.Ebp, reg_value); 198 case lldb_esp_i386: 199 return ReadRegisterHelper(CONTEXT_CONTROL, "ESP", m_context.Esp, reg_value); 200 case lldb_eip_i386: 201 return ReadRegisterHelper(CONTEXT_CONTROL, "EIP", m_context.Eip, reg_value); 202 case lldb_eflags_i386: 203 return ReadRegisterHelper(CONTEXT_CONTROL, "EFLAGS", m_context.EFlags, 204 reg_value); 205 default: 206 WINWARN_IFALL(WINDOWS_LOG_REGISTERS, "Requested unknown register %u", reg); 207 break; 208 } 209 return false; 210 } 211 212 bool RegisterContextWindows_x86::WriteRegister(const RegisterInfo *reg_info, 213 const RegisterValue ®_value) { 214 // Since we cannot only write a single register value to the inferior, we need 215 // to make sure 216 // our cached copy of the register values are fresh. Otherwise when writing 217 // EAX, for example, 218 // we may also overwrite some other register with a stale value. 219 if (!CacheAllRegisterValues()) 220 return false; 221 222 uint32_t reg = reg_info->kinds[eRegisterKindLLDB]; 223 switch (reg) { 224 case lldb_eax_i386: 225 WINLOG_IFALL(WINDOWS_LOG_REGISTERS, "Write value 0x%x to EAX", 226 reg_value.GetAsUInt32()); 227 m_context.Eax = reg_value.GetAsUInt32(); 228 break; 229 case lldb_ebx_i386: 230 WINLOG_IFALL(WINDOWS_LOG_REGISTERS, "Write value 0x%x to EBX", 231 reg_value.GetAsUInt32()); 232 m_context.Ebx = reg_value.GetAsUInt32(); 233 break; 234 case lldb_ecx_i386: 235 WINLOG_IFALL(WINDOWS_LOG_REGISTERS, "Write value 0x%x to ECX", 236 reg_value.GetAsUInt32()); 237 m_context.Ecx = reg_value.GetAsUInt32(); 238 break; 239 case lldb_edx_i386: 240 WINLOG_IFALL(WINDOWS_LOG_REGISTERS, "Write value 0x%x to EDX", 241 reg_value.GetAsUInt32()); 242 m_context.Edx = reg_value.GetAsUInt32(); 243 break; 244 case lldb_edi_i386: 245 WINLOG_IFALL(WINDOWS_LOG_REGISTERS, "Write value 0x%x to EDI", 246 reg_value.GetAsUInt32()); 247 m_context.Edi = reg_value.GetAsUInt32(); 248 break; 249 case lldb_esi_i386: 250 WINLOG_IFALL(WINDOWS_LOG_REGISTERS, "Write value 0x%x to ESI", 251 reg_value.GetAsUInt32()); 252 m_context.Esi = reg_value.GetAsUInt32(); 253 break; 254 case lldb_ebp_i386: 255 WINLOG_IFALL(WINDOWS_LOG_REGISTERS, "Write value 0x%x to EBP", 256 reg_value.GetAsUInt32()); 257 m_context.Ebp = reg_value.GetAsUInt32(); 258 break; 259 case lldb_esp_i386: 260 WINLOG_IFALL(WINDOWS_LOG_REGISTERS, "Write value 0x%x to ESP", 261 reg_value.GetAsUInt32()); 262 m_context.Esp = reg_value.GetAsUInt32(); 263 break; 264 case lldb_eip_i386: 265 WINLOG_IFALL(WINDOWS_LOG_REGISTERS, "Write value 0x%x to EIP", 266 reg_value.GetAsUInt32()); 267 m_context.Eip = reg_value.GetAsUInt32(); 268 break; 269 case lldb_eflags_i386: 270 WINLOG_IFALL(WINDOWS_LOG_REGISTERS, "Write value 0x%x to EFLAGS", 271 reg_value.GetAsUInt32()); 272 m_context.EFlags = reg_value.GetAsUInt32(); 273 break; 274 default: 275 WINWARN_IFALL(WINDOWS_LOG_REGISTERS, 276 "Write value 0x%x to unknown register %u", 277 reg_value.GetAsUInt32(), reg); 278 } 279 280 // Physically update the registers in the target process. 281 TargetThreadWindows &wthread = static_cast<TargetThreadWindows &>(m_thread); 282 return ::SetThreadContext( 283 wthread.GetHostThread().GetNativeThread().GetSystemHandle(), &m_context); 284 } 285 286 bool RegisterContextWindows_x86::ReadRegisterHelper( 287 DWORD flags_required, const char *reg_name, DWORD value, 288 RegisterValue ®_value) const { 289 if ((m_context.ContextFlags & flags_required) != flags_required) { 290 WINLOG_IFALL(WINDOWS_LOG_REGISTERS, "Thread context doesn't have %s", 291 reg_name); 292 return false; 293 } 294 WINLOG_IFALL(WINDOWS_LOG_REGISTERS, "Read value 0x%lx from %s", value, 295 reg_name); 296 reg_value.SetUInt32(value); 297 return true; 298 } 299