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