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