1 //===-- RegisterContext.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 // C Includes 11 // C++ Includes 12 // Other libraries and framework includes 13 // Project includes 14 #include "lldb/Target/RegisterContext.h" 15 #include "lldb/Core/DataExtractor.h" 16 #include "lldb/Core/RegisterValue.h" 17 #include "lldb/Core/Scalar.h" 18 #include "lldb/Host/Endian.h" 19 #include "lldb/Target/ExecutionContext.h" 20 #include "lldb/Target/StackFrame.h" 21 #include "lldb/Target/Process.h" 22 #include "lldb/Target/Thread.h" 23 #include "lldb/Target/Target.h" 24 25 using namespace lldb; 26 using namespace lldb_private; 27 28 RegisterContext::RegisterContext (Thread &thread, uint32_t concrete_frame_idx) : 29 m_thread (thread), 30 m_concrete_frame_idx (concrete_frame_idx), 31 m_stop_id (thread.GetProcess()->GetStopID()) 32 { 33 } 34 35 //---------------------------------------------------------------------- 36 // Destructor 37 //---------------------------------------------------------------------- 38 RegisterContext::~RegisterContext() 39 { 40 } 41 42 void 43 RegisterContext::InvalidateIfNeeded (bool force) 44 { 45 ProcessSP process_sp (m_thread.GetProcess()); 46 bool invalidate = force; 47 uint32_t process_stop_id = UINT32_MAX; 48 49 if (process_sp) 50 process_stop_id = process_sp->GetStopID(); 51 else 52 invalidate = true; 53 54 if (!invalidate) 55 invalidate = process_stop_id != GetStopID(); 56 57 if (invalidate) 58 { 59 InvalidateAllRegisters (); 60 SetStopID (process_stop_id); 61 } 62 } 63 64 65 const RegisterInfo * 66 RegisterContext::GetRegisterInfoByName (const char *reg_name, uint32_t start_idx) 67 { 68 if (reg_name && reg_name[0]) 69 { 70 const uint32_t num_registers = GetRegisterCount(); 71 for (uint32_t reg = start_idx; reg < num_registers; ++reg) 72 { 73 const RegisterInfo * reg_info = GetRegisterInfoAtIndex(reg); 74 75 if ((reg_info->name != NULL && ::strcasecmp (reg_info->name, reg_name) == 0) || 76 (reg_info->alt_name != NULL && ::strcasecmp (reg_info->alt_name, reg_name) == 0)) 77 { 78 return reg_info; 79 } 80 } 81 } 82 return NULL; 83 } 84 85 const RegisterInfo * 86 RegisterContext::GetRegisterInfo (lldb::RegisterKind kind, uint32_t num) 87 { 88 const uint32_t reg_num = ConvertRegisterKindToRegisterNumber(kind, num); 89 if (reg_num == LLDB_INVALID_REGNUM) 90 return NULL; 91 return GetRegisterInfoAtIndex (reg_num); 92 } 93 94 const char * 95 RegisterContext::GetRegisterName (uint32_t reg) 96 { 97 const RegisterInfo * reg_info = GetRegisterInfoAtIndex(reg); 98 if (reg_info) 99 return reg_info->name; 100 return NULL; 101 } 102 103 uint64_t 104 RegisterContext::GetPC(uint64_t fail_value) 105 { 106 uint32_t reg = ConvertRegisterKindToRegisterNumber (eRegisterKindGeneric, LLDB_REGNUM_GENERIC_PC); 107 uint64_t pc = ReadRegisterAsUnsigned (reg, fail_value); 108 109 if (pc != fail_value) 110 { 111 TargetSP target_sp = m_thread.CalculateTarget(); 112 if (target_sp) 113 { 114 Target *target = target_sp.get(); 115 if (target) 116 pc = target->GetOpcodeLoadAddress (pc, eAddressClassCode); 117 } 118 } 119 120 return pc; 121 } 122 123 bool 124 RegisterContext::SetPC(uint64_t pc) 125 { 126 uint32_t reg = ConvertRegisterKindToRegisterNumber (eRegisterKindGeneric, LLDB_REGNUM_GENERIC_PC); 127 bool success = WriteRegisterFromUnsigned (reg, pc); 128 if (success) 129 { 130 StackFrameSP frame_sp(m_thread.GetFrameWithConcreteFrameIndex (m_concrete_frame_idx)); 131 if (frame_sp) 132 frame_sp->ChangePC(pc); 133 else 134 m_thread.ClearStackFrames (); 135 } 136 return success; 137 } 138 139 bool 140 RegisterContext::SetPC(Address addr) 141 { 142 TargetSP target_sp = m_thread.CalculateTarget(); 143 Target *target = target_sp.get(); 144 145 lldb::addr_t callAddr = addr.GetCallableLoadAddress (target); 146 if (callAddr == LLDB_INVALID_ADDRESS) 147 return false; 148 149 return SetPC (callAddr); 150 } 151 152 uint64_t 153 RegisterContext::GetSP(uint64_t fail_value) 154 { 155 uint32_t reg = ConvertRegisterKindToRegisterNumber (eRegisterKindGeneric, LLDB_REGNUM_GENERIC_SP); 156 return ReadRegisterAsUnsigned (reg, fail_value); 157 } 158 159 bool 160 RegisterContext::SetSP(uint64_t sp) 161 { 162 uint32_t reg = ConvertRegisterKindToRegisterNumber (eRegisterKindGeneric, LLDB_REGNUM_GENERIC_SP); 163 return WriteRegisterFromUnsigned (reg, sp); 164 } 165 166 uint64_t 167 RegisterContext::GetFP(uint64_t fail_value) 168 { 169 uint32_t reg = ConvertRegisterKindToRegisterNumber (eRegisterKindGeneric, LLDB_REGNUM_GENERIC_FP); 170 return ReadRegisterAsUnsigned (reg, fail_value); 171 } 172 173 bool 174 RegisterContext::SetFP(uint64_t fp) 175 { 176 uint32_t reg = ConvertRegisterKindToRegisterNumber (eRegisterKindGeneric, LLDB_REGNUM_GENERIC_FP); 177 return WriteRegisterFromUnsigned (reg, fp); 178 } 179 180 uint64_t 181 RegisterContext::GetReturnAddress (uint64_t fail_value) 182 { 183 uint32_t reg = ConvertRegisterKindToRegisterNumber (eRegisterKindGeneric, LLDB_REGNUM_GENERIC_RA); 184 return ReadRegisterAsUnsigned (reg, fail_value); 185 } 186 187 uint64_t 188 RegisterContext::GetFlags (uint64_t fail_value) 189 { 190 uint32_t reg = ConvertRegisterKindToRegisterNumber (eRegisterKindGeneric, LLDB_REGNUM_GENERIC_FLAGS); 191 return ReadRegisterAsUnsigned (reg, fail_value); 192 } 193 194 195 uint64_t 196 RegisterContext::ReadRegisterAsUnsigned (uint32_t reg, uint64_t fail_value) 197 { 198 if (reg != LLDB_INVALID_REGNUM) 199 return ReadRegisterAsUnsigned (GetRegisterInfoAtIndex (reg), fail_value); 200 return fail_value; 201 } 202 203 uint64_t 204 RegisterContext::ReadRegisterAsUnsigned (const RegisterInfo *reg_info, uint64_t fail_value) 205 { 206 if (reg_info) 207 { 208 RegisterValue value; 209 if (ReadRegister (reg_info, value)) 210 return value.GetAsUInt64(); 211 } 212 return fail_value; 213 } 214 215 bool 216 RegisterContext::WriteRegisterFromUnsigned (uint32_t reg, uint64_t uval) 217 { 218 if (reg == LLDB_INVALID_REGNUM) 219 return false; 220 return WriteRegisterFromUnsigned (GetRegisterInfoAtIndex (reg), uval); 221 } 222 223 bool 224 RegisterContext::WriteRegisterFromUnsigned (const RegisterInfo *reg_info, uint64_t uval) 225 { 226 if (reg_info) 227 { 228 RegisterValue value; 229 if (value.SetUInt(uval, reg_info->byte_size)) 230 return WriteRegister (reg_info, value); 231 } 232 return false; 233 } 234 235 bool 236 RegisterContext::CopyFromRegisterContext (lldb::RegisterContextSP context) 237 { 238 uint32_t num_register_sets = context->GetRegisterSetCount(); 239 // We don't know that two threads have the same register context, so require the threads to be the same. 240 if (context->GetThreadID() != GetThreadID()) 241 return false; 242 243 if (num_register_sets != GetRegisterSetCount()) 244 return false; 245 246 RegisterContextSP frame_zero_context = m_thread.GetRegisterContext(); 247 248 for (uint32_t set_idx = 0; set_idx < num_register_sets; ++set_idx) 249 { 250 const RegisterSet * const reg_set = GetRegisterSet(set_idx); 251 252 const uint32_t num_registers = reg_set->num_registers; 253 for (uint32_t reg_idx = 0; reg_idx < num_registers; ++reg_idx) 254 { 255 const uint32_t reg = reg_set->registers[reg_idx]; 256 const RegisterInfo *reg_info = GetRegisterInfoAtIndex(reg); 257 if (!reg_info || reg_info->value_regs) 258 continue; 259 RegisterValue reg_value; 260 261 // If we can reconstruct the register from the frame we are copying from, then do so, otherwise 262 // use the value from frame 0. 263 if (context->ReadRegister(reg_info, reg_value)) 264 { 265 WriteRegister(reg_info, reg_value); 266 } 267 else if (frame_zero_context->ReadRegister(reg_info, reg_value)) 268 { 269 WriteRegister(reg_info, reg_value); 270 } 271 } 272 } 273 return true; 274 } 275 276 lldb::tid_t 277 RegisterContext::GetThreadID() const 278 { 279 return m_thread.GetID(); 280 } 281 282 uint32_t 283 RegisterContext::NumSupportedHardwareBreakpoints () 284 { 285 return 0; 286 } 287 288 uint32_t 289 RegisterContext::SetHardwareBreakpoint (lldb::addr_t addr, size_t size) 290 { 291 return LLDB_INVALID_INDEX32; 292 } 293 294 bool 295 RegisterContext::ClearHardwareBreakpoint (uint32_t hw_idx) 296 { 297 return false; 298 } 299 300 301 uint32_t 302 RegisterContext::NumSupportedHardwareWatchpoints () 303 { 304 return 0; 305 } 306 307 uint32_t 308 RegisterContext::SetHardwareWatchpoint (lldb::addr_t addr, size_t size, bool read, bool write) 309 { 310 return LLDB_INVALID_INDEX32; 311 } 312 313 bool 314 RegisterContext::ClearHardwareWatchpoint (uint32_t hw_index) 315 { 316 return false; 317 } 318 319 bool 320 RegisterContext::HardwareSingleStep (bool enable) 321 { 322 return false; 323 } 324 325 Error 326 RegisterContext::ReadRegisterValueFromMemory (const RegisterInfo *reg_info, 327 lldb::addr_t src_addr, 328 uint32_t src_len, 329 RegisterValue ®_value) 330 { 331 Error error; 332 if (reg_info == NULL) 333 { 334 error.SetErrorString ("invalid register info argument."); 335 return error; 336 } 337 338 339 // Moving from addr into a register 340 // 341 // Case 1: src_len == dst_len 342 // 343 // |AABBCCDD| Address contents 344 // |AABBCCDD| Register contents 345 // 346 // Case 2: src_len > dst_len 347 // 348 // Error! (The register should always be big enough to hold the data) 349 // 350 // Case 3: src_len < dst_len 351 // 352 // |AABB| Address contents 353 // |AABB0000| Register contents [on little-endian hardware] 354 // |0000AABB| Register contents [on big-endian hardware] 355 if (src_len > RegisterValue::kMaxRegisterByteSize) 356 { 357 error.SetErrorString ("register too small to receive memory data"); 358 return error; 359 } 360 361 const uint32_t dst_len = reg_info->byte_size; 362 363 if (src_len > dst_len) 364 { 365 error.SetErrorStringWithFormat("%u bytes is too big to store in register %s (%u bytes)", src_len, reg_info->name, dst_len); 366 return error; 367 } 368 369 ProcessSP process_sp (m_thread.GetProcess()); 370 if (process_sp) 371 { 372 uint8_t src[RegisterValue::kMaxRegisterByteSize]; 373 374 // Read the memory 375 const uint32_t bytes_read = process_sp->ReadMemory (src_addr, src, src_len, error); 376 377 // Make sure the memory read succeeded... 378 if (bytes_read != src_len) 379 { 380 if (error.Success()) 381 { 382 // This might happen if we read _some_ bytes but not all 383 error.SetErrorStringWithFormat("read %u of %u bytes", bytes_read, src_len); 384 } 385 return error; 386 } 387 388 // We now have a memory buffer that contains the part or all of the register 389 // value. Set the register value using this memory data. 390 // TODO: we might need to add a parameter to this function in case the byte 391 // order of the memory data doesn't match the process. For now we are assuming 392 // they are the same. 393 reg_value.SetFromMemoryData (reg_info, 394 src, 395 src_len, 396 process_sp->GetByteOrder(), 397 error); 398 } 399 else 400 error.SetErrorString("invalid process"); 401 402 return error; 403 } 404 405 Error 406 RegisterContext::WriteRegisterValueToMemory (const RegisterInfo *reg_info, 407 lldb::addr_t dst_addr, 408 uint32_t dst_len, 409 const RegisterValue ®_value) 410 { 411 412 uint8_t dst[RegisterValue::kMaxRegisterByteSize]; 413 414 Error error; 415 416 ProcessSP process_sp (m_thread.GetProcess()); 417 if (process_sp) 418 { 419 420 // TODO: we might need to add a parameter to this function in case the byte 421 // order of the memory data doesn't match the process. For now we are assuming 422 // they are the same. 423 424 const uint32_t bytes_copied = reg_value.GetAsMemoryData (reg_info, 425 dst, 426 dst_len, 427 process_sp->GetByteOrder(), 428 error); 429 430 if (error.Success()) 431 { 432 if (bytes_copied == 0) 433 { 434 error.SetErrorString("byte copy failed."); 435 } 436 else 437 { 438 const uint32_t bytes_written = process_sp->WriteMemory (dst_addr, dst, bytes_copied, error); 439 if (bytes_written != bytes_copied) 440 { 441 if (error.Success()) 442 { 443 // This might happen if we read _some_ bytes but not all 444 error.SetErrorStringWithFormat("only wrote %u of %u bytes", bytes_written, bytes_copied); 445 } 446 } 447 } 448 } 449 } 450 else 451 error.SetErrorString("invalid process"); 452 453 return error; 454 455 } 456 457 bool 458 RegisterContext::ReadAllRegisterValues (lldb_private::RegisterCheckpoint ®_checkpoint) 459 { 460 return ReadAllRegisterValues(reg_checkpoint.GetData()); 461 } 462 463 bool 464 RegisterContext::WriteAllRegisterValues (const lldb_private::RegisterCheckpoint ®_checkpoint) 465 { 466 return WriteAllRegisterValues(reg_checkpoint.GetData()); 467 } 468 469 TargetSP 470 RegisterContext::CalculateTarget () 471 { 472 return m_thread.CalculateTarget(); 473 } 474 475 476 ProcessSP 477 RegisterContext::CalculateProcess () 478 { 479 return m_thread.CalculateProcess (); 480 } 481 482 ThreadSP 483 RegisterContext::CalculateThread () 484 { 485 return m_thread.shared_from_this(); 486 } 487 488 StackFrameSP 489 RegisterContext::CalculateStackFrame () 490 { 491 // Register contexts might belong to many frames if we have inlined 492 // functions inside a frame since all inlined functions share the 493 // same registers, so we can't definitively say which frame we come from... 494 return StackFrameSP(); 495 } 496 497 void 498 RegisterContext::CalculateExecutionContext (ExecutionContext &exe_ctx) 499 { 500 m_thread.CalculateExecutionContext (exe_ctx); 501 } 502 503 504 bool 505 RegisterContext::ConvertBetweenRegisterKinds (lldb::RegisterKind source_rk, uint32_t source_regnum, lldb::RegisterKind target_rk, uint32_t& target_regnum) 506 { 507 const uint32_t num_registers = GetRegisterCount(); 508 for (uint32_t reg = 0; reg < num_registers; ++reg) 509 { 510 const RegisterInfo * reg_info = GetRegisterInfoAtIndex (reg); 511 512 if (reg_info->kinds[source_rk] == source_regnum) 513 { 514 target_regnum = reg_info->kinds[target_rk]; 515 if (target_regnum == LLDB_INVALID_REGNUM) 516 { 517 return false; 518 } 519 else 520 { 521 return true; 522 } 523 } 524 } 525 return false; 526 } 527 528 //bool 529 //RegisterContext::ReadRegisterValue (uint32_t reg, Scalar &value) 530 //{ 531 // DataExtractor data; 532 // if (!ReadRegisterBytes (reg, data)) 533 // return false; 534 // 535 // const RegisterInfo *reg_info = GetRegisterInfoAtIndex (reg); 536 // uint32_t offset = 0; 537 // switch (reg_info->encoding) 538 // { 539 // case eEncodingInvalid: 540 // case eEncodingVector: 541 // break; 542 // 543 // case eEncodingUint: 544 // switch (reg_info->byte_size) 545 // { 546 // case 1: 547 // { 548 // value = data.GetU8 (&offset); 549 // return true; 550 // } 551 // case 2: 552 // { 553 // value = data.GetU16 (&offset); 554 // return true; 555 // } 556 // case 4: 557 // { 558 // value = data.GetU32 (&offset); 559 // return true; 560 // } 561 // case 8: 562 // { 563 // value = data.GetU64 (&offset); 564 // return true; 565 // } 566 // } 567 // break; 568 // case eEncodingSint: 569 // switch (reg_info->byte_size) 570 // { 571 // case 1: 572 // { 573 // int8_t v; 574 // if (data.ExtractBytes (0, sizeof (int8_t), lldb::endian::InlHostByteOrder(), &v) != sizeof (int8_t)) 575 // return false; 576 // value = v; 577 // return true; 578 // } 579 // case 2: 580 // { 581 // int16_t v; 582 // if (data.ExtractBytes (0, sizeof (int16_t), lldb::endian::InlHostByteOrder(), &v) != sizeof (int16_t)) 583 // return false; 584 // value = v; 585 // return true; 586 // } 587 // case 4: 588 // { 589 // int32_t v; 590 // if (data.ExtractBytes (0, sizeof (int32_t), lldb::endian::InlHostByteOrder(), &v) != sizeof (int32_t)) 591 // return false; 592 // value = v; 593 // return true; 594 // } 595 // case 8: 596 // { 597 // int64_t v; 598 // if (data.ExtractBytes (0, sizeof (int64_t), lldb::endian::InlHostByteOrder(), &v) != sizeof (int64_t)) 599 // return false; 600 // value = v; 601 // return true; 602 // } 603 // } 604 // break; 605 // case eEncodingIEEE754: 606 // switch (reg_info->byte_size) 607 // { 608 // case sizeof (float): 609 // { 610 // float v; 611 // if (data.ExtractBytes (0, sizeof (float), lldb::endian::InlHostByteOrder(), &v) != sizeof (float)) 612 // return false; 613 // value = v; 614 // return true; 615 // } 616 // case sizeof (double): 617 // { 618 // double v; 619 // if (data.ExtractBytes (0, sizeof (double), lldb::endian::InlHostByteOrder(), &v) != sizeof (double)) 620 // return false; 621 // value = v; 622 // return true; 623 // } 624 // case sizeof (long double): 625 // { 626 // double v; 627 // if (data.ExtractBytes (0, sizeof (long double), lldb::endian::InlHostByteOrder(), &v) != sizeof (long double)) 628 // return false; 629 // value = v; 630 // return true; 631 // } 632 // } 633 // break; 634 // } 635 // return false; 636 //} 637 // 638 //bool 639 //RegisterContext::WriteRegisterValue (uint32_t reg, const Scalar &value) 640 //{ 641 // DataExtractor data; 642 // if (!value.IsValid()) 643 // return false; 644 // if (!value.GetData (data)) 645 // return false; 646 // 647 // return WriteRegisterBytes (reg, data); 648 //} 649