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