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