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