source/Target/RegisterContext.cpp

   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 &reg_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 &reg_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 &reg_checkpoint)
 459 {
 460     return ReadAllRegisterValues(reg_checkpoint.GetData());
 461 }
 462
 463 bool
 464 RegisterContext::WriteAllRegisterValues (const lldb_private::RegisterCheckpoint &reg_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), 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), 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), 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), 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), 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), 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), 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 //}