1 //===-- NativeRegisterContext.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/Host/common/NativeRegisterContext.h" 10 #include "lldb/Utility/LLDBLog.h" 11 #include "lldb/Utility/RegisterValue.h" 12 13 #include "lldb/Host/PosixApi.h" 14 #include "lldb/Host/common/NativeProcessProtocol.h" 15 #include "lldb/Host/common/NativeThreadProtocol.h" 16 17 using namespace lldb; 18 using namespace lldb_private; 19 20 NativeRegisterContext::NativeRegisterContext(NativeThreadProtocol &thread) 21 : m_thread(thread) {} 22 23 // Destructor 24 NativeRegisterContext::~NativeRegisterContext() = default; 25 26 // FIXME revisit invalidation, process stop ids, etc. Right now we don't 27 // support caching in NativeRegisterContext. We can do this later by utilizing 28 // NativeProcessProtocol::GetStopID () and adding a stop id to 29 // NativeRegisterContext. 30 31 // void 32 // NativeRegisterContext::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 // { 47 // InvalidateAllRegisters (); 48 // SetStopID (process_stop_id); 49 // } 50 // } 51 52 const RegisterInfo * 53 NativeRegisterContext::GetRegisterInfoByName(llvm::StringRef reg_name, 54 uint32_t start_idx) { 55 if (reg_name.empty()) 56 return nullptr; 57 58 // Generic register names take precedence over specific register names. 59 // For example, on x86 we want "sp" to refer to the complete RSP/ESP register 60 // rather than the 16-bit SP pseudo-register. 61 uint32_t generic_reg = Args::StringToGenericRegister(reg_name); 62 if (generic_reg != LLDB_INVALID_REGNUM) { 63 const RegisterInfo *reg_info = 64 GetRegisterInfo(eRegisterKindGeneric, generic_reg); 65 if (reg_info) 66 return reg_info; 67 } 68 69 const uint32_t num_registers = GetRegisterCount(); 70 for (uint32_t reg = start_idx; reg < num_registers; ++reg) { 71 const RegisterInfo *reg_info = GetRegisterInfoAtIndex(reg); 72 73 if (reg_name.equals_insensitive(reg_info->name) || 74 reg_name.equals_insensitive(reg_info->alt_name)) 75 return reg_info; 76 } 77 78 return nullptr; 79 } 80 81 const RegisterInfo *NativeRegisterContext::GetRegisterInfo(uint32_t kind, 82 uint32_t num) { 83 const uint32_t reg_num = ConvertRegisterKindToRegisterNumber(kind, num); 84 if (reg_num == LLDB_INVALID_REGNUM) 85 return nullptr; 86 return GetRegisterInfoAtIndex(reg_num); 87 } 88 89 const char *NativeRegisterContext::GetRegisterName(uint32_t reg) { 90 const RegisterInfo *reg_info = GetRegisterInfoAtIndex(reg); 91 if (reg_info) 92 return reg_info->name; 93 return nullptr; 94 } 95 96 const char *NativeRegisterContext::GetRegisterSetNameForRegisterAtIndex( 97 uint32_t reg_index) const { 98 const RegisterInfo *const reg_info = GetRegisterInfoAtIndex(reg_index); 99 if (!reg_info) 100 return nullptr; 101 102 for (uint32_t set_index = 0; set_index < GetRegisterSetCount(); ++set_index) { 103 const RegisterSet *const reg_set = GetRegisterSet(set_index); 104 if (!reg_set) 105 continue; 106 107 for (uint32_t reg_num_index = 0; reg_num_index < reg_set->num_registers; 108 ++reg_num_index) { 109 const uint32_t reg_num = reg_set->registers[reg_num_index]; 110 // FIXME double check we're checking the right register kind here. 111 if (reg_info->kinds[RegisterKind::eRegisterKindLLDB] == reg_num) { 112 // The given register is a member of this register set. Return the 113 // register set name. 114 return reg_set->name; 115 } 116 } 117 } 118 119 // Didn't find it. 120 return nullptr; 121 } 122 123 lldb::addr_t NativeRegisterContext::GetPC(lldb::addr_t fail_value) { 124 Log *log = GetLog(LLDBLog::Thread); 125 126 uint32_t reg = ConvertRegisterKindToRegisterNumber(eRegisterKindGeneric, 127 LLDB_REGNUM_GENERIC_PC); 128 LLDB_LOGF(log, 129 "NativeRegisterContext::%s using reg index %" PRIu32 130 " (default %" PRIu64 ")", 131 __FUNCTION__, reg, fail_value); 132 133 const uint64_t retval = ReadRegisterAsUnsigned(reg, fail_value); 134 135 LLDB_LOGF(log, "NativeRegisterContext::%s " PRIu32 " retval %" PRIu64, 136 __FUNCTION__, retval); 137 138 return retval; 139 } 140 141 lldb::addr_t 142 NativeRegisterContext::GetPCfromBreakpointLocation(lldb::addr_t fail_value) { 143 return GetPC(fail_value); 144 } 145 146 Status NativeRegisterContext::SetPC(lldb::addr_t pc) { 147 uint32_t reg = ConvertRegisterKindToRegisterNumber(eRegisterKindGeneric, 148 LLDB_REGNUM_GENERIC_PC); 149 return WriteRegisterFromUnsigned(reg, pc); 150 } 151 152 lldb::addr_t NativeRegisterContext::GetSP(lldb::addr_t fail_value) { 153 uint32_t reg = ConvertRegisterKindToRegisterNumber(eRegisterKindGeneric, 154 LLDB_REGNUM_GENERIC_SP); 155 return ReadRegisterAsUnsigned(reg, fail_value); 156 } 157 158 Status NativeRegisterContext::SetSP(lldb::addr_t sp) { 159 uint32_t reg = ConvertRegisterKindToRegisterNumber(eRegisterKindGeneric, 160 LLDB_REGNUM_GENERIC_SP); 161 return WriteRegisterFromUnsigned(reg, sp); 162 } 163 164 lldb::addr_t NativeRegisterContext::GetFP(lldb::addr_t fail_value) { 165 uint32_t reg = ConvertRegisterKindToRegisterNumber(eRegisterKindGeneric, 166 LLDB_REGNUM_GENERIC_FP); 167 return ReadRegisterAsUnsigned(reg, fail_value); 168 } 169 170 Status NativeRegisterContext::SetFP(lldb::addr_t fp) { 171 uint32_t reg = ConvertRegisterKindToRegisterNumber(eRegisterKindGeneric, 172 LLDB_REGNUM_GENERIC_FP); 173 return WriteRegisterFromUnsigned(reg, fp); 174 } 175 176 lldb::addr_t NativeRegisterContext::GetReturnAddress(lldb::addr_t fail_value) { 177 uint32_t reg = ConvertRegisterKindToRegisterNumber(eRegisterKindGeneric, 178 LLDB_REGNUM_GENERIC_RA); 179 return ReadRegisterAsUnsigned(reg, fail_value); 180 } 181 182 lldb::addr_t NativeRegisterContext::GetFlags(lldb::addr_t fail_value) { 183 uint32_t reg = ConvertRegisterKindToRegisterNumber(eRegisterKindGeneric, 184 LLDB_REGNUM_GENERIC_FLAGS); 185 return ReadRegisterAsUnsigned(reg, fail_value); 186 } 187 188 lldb::addr_t 189 NativeRegisterContext::ReadRegisterAsUnsigned(uint32_t reg, 190 lldb::addr_t fail_value) { 191 if (reg != LLDB_INVALID_REGNUM) 192 return ReadRegisterAsUnsigned(GetRegisterInfoAtIndex(reg), fail_value); 193 return fail_value; 194 } 195 196 uint64_t 197 NativeRegisterContext::ReadRegisterAsUnsigned(const RegisterInfo *reg_info, 198 lldb::addr_t fail_value) { 199 Log *log = GetLog(LLDBLog::Thread); 200 201 if (reg_info) { 202 RegisterValue value; 203 Status error = ReadRegister(reg_info, value); 204 if (error.Success()) { 205 LLDB_LOGF(log, 206 "NativeRegisterContext::%s ReadRegister() succeeded, value " 207 "%" PRIu64, 208 __FUNCTION__, value.GetAsUInt64()); 209 return value.GetAsUInt64(); 210 } else { 211 LLDB_LOGF(log, 212 "NativeRegisterContext::%s ReadRegister() failed, error %s", 213 __FUNCTION__, error.AsCString()); 214 } 215 } else { 216 LLDB_LOGF(log, "NativeRegisterContext::%s ReadRegister() null reg_info", 217 __FUNCTION__); 218 } 219 return fail_value; 220 } 221 222 Status NativeRegisterContext::WriteRegisterFromUnsigned(uint32_t reg, 223 uint64_t uval) { 224 if (reg == LLDB_INVALID_REGNUM) 225 return Status("NativeRegisterContext::%s (): reg is invalid", __FUNCTION__); 226 return WriteRegisterFromUnsigned(GetRegisterInfoAtIndex(reg), uval); 227 } 228 229 Status 230 NativeRegisterContext::WriteRegisterFromUnsigned(const RegisterInfo *reg_info, 231 uint64_t uval) { 232 assert(reg_info); 233 if (!reg_info) 234 return Status("reg_info is nullptr"); 235 236 RegisterValue value; 237 if (!value.SetUInt(uval, reg_info->byte_size)) 238 return Status("RegisterValue::SetUInt () failed"); 239 240 return WriteRegister(reg_info, value); 241 } 242 243 lldb::tid_t NativeRegisterContext::GetThreadID() const { 244 return m_thread.GetID(); 245 } 246 247 uint32_t NativeRegisterContext::NumSupportedHardwareBreakpoints() { return 0; } 248 249 uint32_t NativeRegisterContext::SetHardwareBreakpoint(lldb::addr_t addr, 250 size_t size) { 251 return LLDB_INVALID_INDEX32; 252 } 253 254 Status NativeRegisterContext::ClearAllHardwareBreakpoints() { 255 return Status("not implemented"); 256 } 257 258 bool NativeRegisterContext::ClearHardwareBreakpoint(uint32_t hw_idx) { 259 return false; 260 } 261 262 Status NativeRegisterContext::GetHardwareBreakHitIndex(uint32_t &bp_index, 263 lldb::addr_t trap_addr) { 264 bp_index = LLDB_INVALID_INDEX32; 265 return Status("not implemented"); 266 } 267 268 uint32_t NativeRegisterContext::NumSupportedHardwareWatchpoints() { return 0; } 269 270 uint32_t NativeRegisterContext::SetHardwareWatchpoint(lldb::addr_t addr, 271 size_t size, 272 uint32_t watch_flags) { 273 return LLDB_INVALID_INDEX32; 274 } 275 276 bool NativeRegisterContext::ClearHardwareWatchpoint(uint32_t hw_index) { 277 return false; 278 } 279 280 Status NativeRegisterContext::ClearWatchpointHit(uint32_t hw_index) { 281 return Status("not implemented"); 282 } 283 284 Status NativeRegisterContext::ClearAllHardwareWatchpoints() { 285 return Status("not implemented"); 286 } 287 288 Status NativeRegisterContext::IsWatchpointHit(uint32_t wp_index, bool &is_hit) { 289 is_hit = false; 290 return Status("not implemented"); 291 } 292 293 Status NativeRegisterContext::GetWatchpointHitIndex(uint32_t &wp_index, 294 lldb::addr_t trap_addr) { 295 wp_index = LLDB_INVALID_INDEX32; 296 return Status("not implemented"); 297 } 298 299 Status NativeRegisterContext::IsWatchpointVacant(uint32_t wp_index, 300 bool &is_vacant) { 301 is_vacant = false; 302 return Status("not implemented"); 303 } 304 305 lldb::addr_t NativeRegisterContext::GetWatchpointAddress(uint32_t wp_index) { 306 return LLDB_INVALID_ADDRESS; 307 } 308 309 lldb::addr_t NativeRegisterContext::GetWatchpointHitAddress(uint32_t wp_index) { 310 return LLDB_INVALID_ADDRESS; 311 } 312 313 bool NativeRegisterContext::HardwareSingleStep(bool enable) { return false; } 314 315 Status NativeRegisterContext::ReadRegisterValueFromMemory( 316 const RegisterInfo *reg_info, lldb::addr_t src_addr, size_t src_len, 317 RegisterValue ®_value) { 318 Status error; 319 if (reg_info == nullptr) { 320 error.SetErrorString("invalid register info argument."); 321 return error; 322 } 323 324 // Moving from addr into a register 325 // 326 // Case 1: src_len == dst_len 327 // 328 // |AABBCCDD| Address contents 329 // |AABBCCDD| Register contents 330 // 331 // Case 2: src_len > dst_len 332 // 333 // Status! (The register should always be big enough to hold the data) 334 // 335 // Case 3: src_len < dst_len 336 // 337 // |AABB| Address contents 338 // |AABB0000| Register contents [on little-endian hardware] 339 // |0000AABB| Register contents [on big-endian hardware] 340 if (src_len > RegisterValue::kMaxRegisterByteSize) { 341 error.SetErrorString("register too small to receive memory data"); 342 return error; 343 } 344 345 const size_t dst_len = reg_info->byte_size; 346 347 if (src_len > dst_len) { 348 error.SetErrorStringWithFormat( 349 "%" PRIu64 " bytes is too big to store in register %s (%" PRIu64 350 " bytes)", 351 static_cast<uint64_t>(src_len), reg_info->name, 352 static_cast<uint64_t>(dst_len)); 353 return error; 354 } 355 356 NativeProcessProtocol &process = m_thread.GetProcess(); 357 uint8_t src[RegisterValue::kMaxRegisterByteSize]; 358 359 // Read the memory 360 size_t bytes_read; 361 error = process.ReadMemory(src_addr, src, src_len, bytes_read); 362 if (error.Fail()) 363 return error; 364 365 // Make sure the memory read succeeded... 366 if (bytes_read != src_len) { 367 // This might happen if we read _some_ bytes but not all 368 error.SetErrorStringWithFormat("read %" PRIu64 " of %" PRIu64 " bytes", 369 static_cast<uint64_t>(bytes_read), 370 static_cast<uint64_t>(src_len)); 371 return error; 372 } 373 374 // We now have a memory buffer that contains the part or all of the register 375 // value. Set the register value using this memory data. 376 // TODO: we might need to add a parameter to this function in case the byte 377 // order of the memory data doesn't match the process. For now we are 378 // assuming they are the same. 379 reg_value.SetFromMemoryData(*reg_info, src, src_len, process.GetByteOrder(), 380 error); 381 382 return error; 383 } 384 385 Status NativeRegisterContext::WriteRegisterValueToMemory( 386 const RegisterInfo *reg_info, lldb::addr_t dst_addr, size_t dst_len, 387 const RegisterValue ®_value) { 388 Status error; 389 if (reg_info == nullptr) { 390 error.SetErrorString("Invalid register info argument."); 391 return error; 392 } 393 394 uint8_t dst[RegisterValue::kMaxRegisterByteSize]; 395 NativeProcessProtocol &process = m_thread.GetProcess(); 396 397 // TODO: we might need to add a parameter to this function in case the byte 398 // order of the memory data doesn't match the process. For now we are 399 // assuming they are the same. 400 const size_t bytes_copied = reg_value.GetAsMemoryData( 401 *reg_info, dst, dst_len, process.GetByteOrder(), error); 402 403 if (error.Success()) { 404 if (bytes_copied == 0) { 405 error.SetErrorString("byte copy failed."); 406 } else { 407 size_t bytes_written; 408 error = process.WriteMemory(dst_addr, dst, bytes_copied, bytes_written); 409 if (error.Fail()) 410 return error; 411 412 if (bytes_written != bytes_copied) { 413 // This might happen if we read _some_ bytes but not all 414 error.SetErrorStringWithFormat("only wrote %" PRIu64 " of %" PRIu64 415 " bytes", 416 static_cast<uint64_t>(bytes_written), 417 static_cast<uint64_t>(bytes_copied)); 418 } 419 } 420 } 421 422 return error; 423 } 424 425 uint32_t 426 NativeRegisterContext::ConvertRegisterKindToRegisterNumber(uint32_t kind, 427 uint32_t num) const { 428 const uint32_t num_regs = GetRegisterCount(); 429 430 assert(kind < kNumRegisterKinds); 431 for (uint32_t reg_idx = 0; reg_idx < num_regs; ++reg_idx) { 432 const RegisterInfo *reg_info = GetRegisterInfoAtIndex(reg_idx); 433 434 if (reg_info->kinds[kind] == num) 435 return reg_idx; 436 } 437 438 return LLDB_INVALID_REGNUM; 439 } 440 441 std::vector<uint32_t> 442 NativeRegisterContext::GetExpeditedRegisters(ExpeditedRegs expType) const { 443 if (expType == ExpeditedRegs::Minimal) { 444 // Expedite only a minimum set of important generic registers. 445 static const uint32_t k_expedited_registers[] = { 446 LLDB_REGNUM_GENERIC_PC, LLDB_REGNUM_GENERIC_SP, LLDB_REGNUM_GENERIC_FP, 447 LLDB_REGNUM_GENERIC_RA}; 448 449 std::vector<uint32_t> expedited_reg_nums; 450 for (uint32_t gen_reg : k_expedited_registers) { 451 uint32_t reg_num = 452 ConvertRegisterKindToRegisterNumber(eRegisterKindGeneric, gen_reg); 453 if (reg_num == LLDB_INVALID_REGNUM) 454 continue; // Target does not support the given register. 455 else 456 expedited_reg_nums.push_back(reg_num); 457 } 458 459 return expedited_reg_nums; 460 } 461 462 if (GetRegisterSetCount() > 0 && expType == ExpeditedRegs::Full) 463 return std::vector<uint32_t>(GetRegisterSet(0)->registers, 464 GetRegisterSet(0)->registers + 465 GetRegisterSet(0)->num_registers); 466 467 return std::vector<uint32_t>(); 468 } 469