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