1 //===-- RegisterContext.cpp -----------------------------------------------===// 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/Target/RegisterContext.h" 10 #include "lldb/Core/Module.h" 11 #include "lldb/Core/Value.h" 12 #include "lldb/Expression/DWARFExpression.h" 13 #include "lldb/Target/ExecutionContext.h" 14 #include "lldb/Target/Process.h" 15 #include "lldb/Target/StackFrame.h" 16 #include "lldb/Target/Target.h" 17 #include "lldb/Target/Thread.h" 18 #include "lldb/Utility/DataExtractor.h" 19 #include "lldb/Utility/Endian.h" 20 #include "lldb/Utility/RegisterValue.h" 21 #include "lldb/Utility/Scalar.h" 22 23 using namespace lldb; 24 using namespace lldb_private; 25 26 RegisterContext::RegisterContext(Thread &thread, uint32_t concrete_frame_idx) 27 : m_thread(thread), m_concrete_frame_idx(concrete_frame_idx), 28 m_stop_id(thread.GetProcess()->GetStopID()) {} 29 30 RegisterContext::~RegisterContext() = default; 31 32 void RegisterContext::InvalidateIfNeeded(bool force) { 33 ProcessSP process_sp(m_thread.GetProcess()); 34 bool invalidate = force; 35 uint32_t process_stop_id = UINT32_MAX; 36 37 if (process_sp) 38 process_stop_id = process_sp->GetStopID(); 39 else 40 invalidate = true; 41 42 if (!invalidate) 43 invalidate = process_stop_id != GetStopID(); 44 45 if (invalidate) { 46 InvalidateAllRegisters(); 47 SetStopID(process_stop_id); 48 } 49 } 50 51 const RegisterInfo * 52 RegisterContext::GetRegisterInfoByName(llvm::StringRef reg_name, 53 uint32_t start_idx) { 54 if (reg_name.empty()) 55 return nullptr; 56 57 // Generic register names take precedence over specific register names. 58 // For example, on x86 we want "sp" to refer to the complete RSP/ESP register 59 // rather than the 16-bit SP pseudo-register. 60 uint32_t generic_reg = Args::StringToGenericRegister(reg_name); 61 if (generic_reg != LLDB_INVALID_REGNUM) { 62 const RegisterInfo *reg_info = 63 GetRegisterInfo(eRegisterKindGeneric, generic_reg); 64 if (reg_info) 65 return reg_info; 66 } 67 68 const uint32_t num_registers = GetRegisterCount(); 69 for (uint32_t reg = start_idx; reg < num_registers; ++reg) { 70 const RegisterInfo *reg_info = GetRegisterInfoAtIndex(reg); 71 72 if (reg_name.equals_insensitive(reg_info->name) || 73 reg_name.equals_insensitive(reg_info->alt_name)) 74 return reg_info; 75 } 76 77 return nullptr; 78 } 79 80 const RegisterInfo *RegisterContext::GetRegisterInfo(lldb::RegisterKind kind, 81 uint32_t num) { 82 const uint32_t reg_num = ConvertRegisterKindToRegisterNumber(kind, num); 83 if (reg_num == LLDB_INVALID_REGNUM) 84 return nullptr; 85 return GetRegisterInfoAtIndex(reg_num); 86 } 87 88 const char *RegisterContext::GetRegisterName(uint32_t reg) { 89 const RegisterInfo *reg_info = GetRegisterInfoAtIndex(reg); 90 if (reg_info) 91 return reg_info->name; 92 return nullptr; 93 } 94 95 uint64_t RegisterContext::GetPC(uint64_t fail_value) { 96 uint32_t reg = ConvertRegisterKindToRegisterNumber(eRegisterKindGeneric, 97 LLDB_REGNUM_GENERIC_PC); 98 uint64_t pc = ReadRegisterAsUnsigned(reg, fail_value); 99 100 if (pc != fail_value) { 101 TargetSP target_sp = m_thread.CalculateTarget(); 102 if (target_sp) { 103 Target *target = target_sp.get(); 104 if (target) 105 pc = target->GetOpcodeLoadAddress(pc, AddressClass::eCode); 106 } 107 } 108 109 return pc; 110 } 111 112 uint64_t RegisterContext::GetThreadPointer(uint64_t fail_value) { 113 uint32_t reg = ConvertRegisterKindToRegisterNumber(eRegisterKindGeneric, 114 LLDB_REGNUM_GENERIC_TP); 115 return ReadRegisterAsUnsigned(reg, fail_value); 116 } 117 118 bool RegisterContext::SetPC(uint64_t pc) { 119 uint32_t reg = ConvertRegisterKindToRegisterNumber(eRegisterKindGeneric, 120 LLDB_REGNUM_GENERIC_PC); 121 bool success = WriteRegisterFromUnsigned(reg, pc); 122 if (success) { 123 StackFrameSP frame_sp( 124 m_thread.GetFrameWithConcreteFrameIndex(m_concrete_frame_idx)); 125 if (frame_sp) 126 frame_sp->ChangePC(pc); 127 else 128 m_thread.ClearStackFrames(); 129 } 130 return success; 131 } 132 133 bool RegisterContext::GetPCForSymbolication(Address &address) { 134 addr_t pc = GetPC(LLDB_INVALID_ADDRESS); 135 if (pc == LLDB_INVALID_ADDRESS) 136 return false; 137 TargetSP target_sp = m_thread.CalculateTarget(); 138 if (!target_sp.get()) 139 return false; 140 141 if (!BehavesLikeZerothFrame() && pc != 0) 142 pc--; 143 address.SetLoadAddress(pc, target_sp.get()); 144 return true; 145 } 146 147 bool RegisterContext::SetPC(Address addr) { 148 TargetSP target_sp = m_thread.CalculateTarget(); 149 Target *target = target_sp.get(); 150 151 lldb::addr_t callAddr = addr.GetCallableLoadAddress(target); 152 if (callAddr == LLDB_INVALID_ADDRESS) 153 return false; 154 155 return SetPC(callAddr); 156 } 157 158 uint64_t RegisterContext::GetSP(uint64_t fail_value) { 159 uint32_t reg = ConvertRegisterKindToRegisterNumber(eRegisterKindGeneric, 160 LLDB_REGNUM_GENERIC_SP); 161 return ReadRegisterAsUnsigned(reg, fail_value); 162 } 163 164 bool RegisterContext::SetSP(uint64_t sp) { 165 uint32_t reg = ConvertRegisterKindToRegisterNumber(eRegisterKindGeneric, 166 LLDB_REGNUM_GENERIC_SP); 167 return WriteRegisterFromUnsigned(reg, sp); 168 } 169 170 uint64_t RegisterContext::GetFP(uint64_t fail_value) { 171 uint32_t reg = ConvertRegisterKindToRegisterNumber(eRegisterKindGeneric, 172 LLDB_REGNUM_GENERIC_FP); 173 return ReadRegisterAsUnsigned(reg, fail_value); 174 } 175 176 bool RegisterContext::SetFP(uint64_t fp) { 177 uint32_t reg = ConvertRegisterKindToRegisterNumber(eRegisterKindGeneric, 178 LLDB_REGNUM_GENERIC_FP); 179 return WriteRegisterFromUnsigned(reg, fp); 180 } 181 182 uint64_t RegisterContext::GetReturnAddress(uint64_t fail_value) { 183 uint32_t reg = ConvertRegisterKindToRegisterNumber(eRegisterKindGeneric, 184 LLDB_REGNUM_GENERIC_RA); 185 return ReadRegisterAsUnsigned(reg, fail_value); 186 } 187 188 uint64_t RegisterContext::GetFlags(uint64_t fail_value) { 189 uint32_t reg = ConvertRegisterKindToRegisterNumber(eRegisterKindGeneric, 190 LLDB_REGNUM_GENERIC_FLAGS); 191 return ReadRegisterAsUnsigned(reg, fail_value); 192 } 193 194 uint64_t RegisterContext::ReadRegisterAsUnsigned(uint32_t reg, 195 uint64_t fail_value) { 196 if (reg != LLDB_INVALID_REGNUM) 197 return ReadRegisterAsUnsigned(GetRegisterInfoAtIndex(reg), fail_value); 198 return fail_value; 199 } 200 201 uint64_t RegisterContext::ReadRegisterAsUnsigned(const RegisterInfo *reg_info, 202 uint64_t fail_value) { 203 if (reg_info) { 204 RegisterValue value; 205 if (ReadRegister(reg_info, value)) 206 return value.GetAsUInt64(); 207 } 208 return fail_value; 209 } 210 211 bool RegisterContext::WriteRegisterFromUnsigned(uint32_t reg, uint64_t uval) { 212 if (reg == LLDB_INVALID_REGNUM) 213 return false; 214 return WriteRegisterFromUnsigned(GetRegisterInfoAtIndex(reg), uval); 215 } 216 217 bool RegisterContext::WriteRegisterFromUnsigned(const RegisterInfo *reg_info, 218 uint64_t uval) { 219 if (reg_info) { 220 RegisterValue value; 221 if (value.SetUInt(uval, reg_info->byte_size)) 222 return WriteRegister(reg_info, value); 223 } 224 return false; 225 } 226 227 bool RegisterContext::CopyFromRegisterContext(lldb::RegisterContextSP context) { 228 uint32_t num_register_sets = context->GetRegisterSetCount(); 229 // We don't know that two threads have the same register context, so require 230 // the threads to be the same. 231 if (context->GetThreadID() != GetThreadID()) 232 return false; 233 234 if (num_register_sets != GetRegisterSetCount()) 235 return false; 236 237 RegisterContextSP frame_zero_context = m_thread.GetRegisterContext(); 238 239 for (uint32_t set_idx = 0; set_idx < num_register_sets; ++set_idx) { 240 const RegisterSet *const reg_set = GetRegisterSet(set_idx); 241 242 const uint32_t num_registers = reg_set->num_registers; 243 for (uint32_t reg_idx = 0; reg_idx < num_registers; ++reg_idx) { 244 const uint32_t reg = reg_set->registers[reg_idx]; 245 const RegisterInfo *reg_info = GetRegisterInfoAtIndex(reg); 246 if (!reg_info || reg_info->value_regs) 247 continue; 248 RegisterValue reg_value; 249 250 // If we can reconstruct the register from the frame we are copying from, 251 // then do so, otherwise use the value from frame 0. 252 if (context->ReadRegister(reg_info, reg_value)) { 253 WriteRegister(reg_info, reg_value); 254 } else if (frame_zero_context->ReadRegister(reg_info, reg_value)) { 255 WriteRegister(reg_info, reg_value); 256 } 257 } 258 } 259 return true; 260 } 261 262 lldb::tid_t RegisterContext::GetThreadID() const { return m_thread.GetID(); } 263 264 uint32_t RegisterContext::NumSupportedHardwareBreakpoints() { return 0; } 265 266 uint32_t RegisterContext::SetHardwareBreakpoint(lldb::addr_t addr, 267 size_t size) { 268 return LLDB_INVALID_INDEX32; 269 } 270 271 // Used when parsing DWARF and EH frame information and any other object file 272 // sections that contain register numbers in them. 273 uint32_t 274 RegisterContext::ConvertRegisterKindToRegisterNumber(lldb::RegisterKind kind, 275 uint32_t num) { 276 const uint32_t num_regs = GetRegisterCount(); 277 278 assert(kind < kNumRegisterKinds); 279 for (uint32_t reg_idx = 0; reg_idx < num_regs; ++reg_idx) { 280 const RegisterInfo *reg_info = GetRegisterInfoAtIndex(reg_idx); 281 282 if (reg_info->kinds[kind] == num) 283 return reg_idx; 284 } 285 286 return LLDB_INVALID_REGNUM; 287 } 288 289 bool RegisterContext::ClearHardwareBreakpoint(uint32_t hw_idx) { return false; } 290 291 uint32_t RegisterContext::NumSupportedHardwareWatchpoints() { return 0; } 292 293 uint32_t RegisterContext::SetHardwareWatchpoint(lldb::addr_t addr, size_t size, 294 bool read, bool write) { 295 return LLDB_INVALID_INDEX32; 296 } 297 298 bool RegisterContext::ClearHardwareWatchpoint(uint32_t hw_index) { 299 return false; 300 } 301 302 bool RegisterContext::HardwareSingleStep(bool enable) { return false; } 303 304 Status RegisterContext::ReadRegisterValueFromMemory( 305 const RegisterInfo *reg_info, lldb::addr_t src_addr, uint32_t src_len, 306 RegisterValue ®_value) { 307 Status error; 308 if (reg_info == nullptr) { 309 error.SetErrorString("invalid register info argument."); 310 return error; 311 } 312 313 // Moving from addr into a register 314 // 315 // Case 1: src_len == dst_len 316 // 317 // |AABBCCDD| Address contents 318 // |AABBCCDD| Register contents 319 // 320 // Case 2: src_len > dst_len 321 // 322 // Status! (The register should always be big enough to hold the data) 323 // 324 // Case 3: src_len < dst_len 325 // 326 // |AABB| Address contents 327 // |AABB0000| Register contents [on little-endian hardware] 328 // |0000AABB| Register contents [on big-endian hardware] 329 const uint32_t dst_len = reg_info->byte_size; 330 331 if (src_len > dst_len) { 332 error.SetErrorStringWithFormat( 333 "%u bytes is too big to store in register %s (%u bytes)", src_len, 334 reg_info->name, dst_len); 335 return error; 336 } 337 338 ProcessSP process_sp(m_thread.GetProcess()); 339 if (process_sp) { 340 RegisterValue::BytesContainer src(src_len); 341 342 // Read the memory 343 const uint32_t bytes_read = 344 process_sp->ReadMemory(src_addr, src.data(), src_len, error); 345 346 // Make sure the memory read succeeded... 347 if (bytes_read != src_len) { 348 if (error.Success()) { 349 // This might happen if we read _some_ bytes but not all 350 error.SetErrorStringWithFormat("read %u of %u bytes", bytes_read, 351 src_len); 352 } 353 return error; 354 } 355 356 // We now have a memory buffer that contains the part or all of the 357 // register value. Set the register value using this memory data. 358 // TODO: we might need to add a parameter to this function in case the byte 359 // order of the memory data doesn't match the process. For now we are 360 // assuming they are the same. 361 reg_value.SetFromMemoryData(*reg_info, src.data(), src_len, 362 process_sp->GetByteOrder(), error); 363 } else 364 error.SetErrorString("invalid process"); 365 366 return error; 367 } 368 369 Status RegisterContext::WriteRegisterValueToMemory( 370 const RegisterInfo *reg_info, lldb::addr_t dst_addr, uint32_t dst_len, 371 const RegisterValue ®_value) { 372 Status error; 373 ProcessSP process_sp(m_thread.GetProcess()); 374 375 if (!process_sp) { 376 error.SetErrorString("invalid process"); 377 return error; 378 } 379 380 if (reg_info == nullptr) { 381 error.SetErrorString("Invalid register info argument."); 382 return error; 383 } 384 385 // TODO: we might need to add a parameter to this function in case the byte 386 // order of the memory data doesn't match the process. For now we are 387 // assuming they are the same. 388 RegisterValue::BytesContainer dst(dst_len); 389 const uint32_t bytes_copied = reg_value.GetAsMemoryData( 390 *reg_info, dst.data(), dst_len, process_sp->GetByteOrder(), error); 391 392 if (error.Success()) { 393 if (bytes_copied == 0) { 394 error.SetErrorString("byte copy failed."); 395 } else { 396 const uint32_t bytes_written = 397 process_sp->WriteMemory(dst_addr, dst.data(), bytes_copied, error); 398 if (bytes_written != bytes_copied) { 399 if (error.Success()) { 400 // This might happen if we read _some_ bytes but not all 401 error.SetErrorStringWithFormat("only wrote %u of %u bytes", 402 bytes_written, bytes_copied); 403 } 404 } 405 } 406 } 407 408 return error; 409 } 410 411 lldb::ByteOrder RegisterContext::GetByteOrder() { 412 // Get the target process whose privileged thread was used for the register 413 // read. 414 lldb::ByteOrder byte_order = lldb::eByteOrderInvalid; 415 lldb_private::Process *process = CalculateProcess().get(); 416 417 if (process) 418 byte_order = process->GetByteOrder(); 419 return byte_order; 420 } 421 422 bool RegisterContext::ReadAllRegisterValues( 423 lldb_private::RegisterCheckpoint ®_checkpoint) { 424 return ReadAllRegisterValues(reg_checkpoint.GetData()); 425 } 426 427 bool RegisterContext::WriteAllRegisterValues( 428 const lldb_private::RegisterCheckpoint ®_checkpoint) { 429 return WriteAllRegisterValues(reg_checkpoint.GetData()); 430 } 431 432 TargetSP RegisterContext::CalculateTarget() { 433 return m_thread.CalculateTarget(); 434 } 435 436 ProcessSP RegisterContext::CalculateProcess() { 437 return m_thread.CalculateProcess(); 438 } 439 440 ThreadSP RegisterContext::CalculateThread() { 441 return m_thread.shared_from_this(); 442 } 443 444 StackFrameSP RegisterContext::CalculateStackFrame() { 445 // Register contexts might belong to many frames if we have inlined functions 446 // inside a frame since all inlined functions share the same registers, so we 447 // can't definitively say which frame we come from... 448 return StackFrameSP(); 449 } 450 451 void RegisterContext::CalculateExecutionContext(ExecutionContext &exe_ctx) { 452 m_thread.CalculateExecutionContext(exe_ctx); 453 } 454 455 bool RegisterContext::ConvertBetweenRegisterKinds(lldb::RegisterKind source_rk, 456 uint32_t source_regnum, 457 lldb::RegisterKind target_rk, 458 uint32_t &target_regnum) { 459 const uint32_t num_registers = GetRegisterCount(); 460 for (uint32_t reg = 0; reg < num_registers; ++reg) { 461 const RegisterInfo *reg_info = GetRegisterInfoAtIndex(reg); 462 463 if (reg_info->kinds[source_rk] == source_regnum) { 464 target_regnum = reg_info->kinds[target_rk]; 465 return (target_regnum != LLDB_INVALID_REGNUM); 466 } 467 } 468 return false; 469 } 470