diff options
Diffstat (limited to 'source/Target/RegisterContext.cpp')
| -rw-r--r-- | source/Target/RegisterContext.cpp | 600 |
1 files changed, 600 insertions, 0 deletions
diff --git a/source/Target/RegisterContext.cpp b/source/Target/RegisterContext.cpp new file mode 100644 index 000000000000..0d89db724ab4 --- /dev/null +++ b/source/Target/RegisterContext.cpp @@ -0,0 +1,600 @@ +//===-- RegisterContext.cpp -------------------------------------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// C Includes +// C++ Includes +// Other libraries and framework includes +// Project includes +#include "lldb/Target/RegisterContext.h" +#include "lldb/Core/DataExtractor.h" +#include "lldb/Core/RegisterValue.h" +#include "lldb/Core/Scalar.h" +#include "lldb/Host/Endian.h" +#include "lldb/Target/ExecutionContext.h" +#include "lldb/Target/StackFrame.h" +#include "lldb/Target/Process.h" +#include "lldb/Target/Thread.h" + +using namespace lldb; +using namespace lldb_private; + +RegisterContext::RegisterContext (Thread &thread, uint32_t concrete_frame_idx) : + m_thread (thread), + m_concrete_frame_idx (concrete_frame_idx), + m_stop_id (thread.GetProcess()->GetStopID()) +{ +} + +//---------------------------------------------------------------------- +// Destructor +//---------------------------------------------------------------------- +RegisterContext::~RegisterContext() +{ +} + +void +RegisterContext::InvalidateIfNeeded (bool force) +{ + ProcessSP process_sp (m_thread.GetProcess()); + bool invalidate = force; + uint32_t process_stop_id = UINT32_MAX; + + if (process_sp) + process_stop_id = process_sp->GetStopID(); + else + invalidate = true; + + if (!invalidate) + invalidate = process_stop_id != GetStopID(); + + if (invalidate) + { + InvalidateAllRegisters (); + SetStopID (process_stop_id); + } +} + + +const RegisterInfo * +RegisterContext::GetRegisterInfoByName (const char *reg_name, uint32_t start_idx) +{ + if (reg_name && reg_name[0]) + { + const uint32_t num_registers = GetRegisterCount(); + for (uint32_t reg = start_idx; reg < num_registers; ++reg) + { + const RegisterInfo * reg_info = GetRegisterInfoAtIndex(reg); + + if ((reg_info->name != NULL && ::strcasecmp (reg_info->name, reg_name) == 0) || + (reg_info->alt_name != NULL && ::strcasecmp (reg_info->alt_name, reg_name) == 0)) + { + return reg_info; + } + } + } + return NULL; +} + +const char * +RegisterContext::GetRegisterName (uint32_t reg) +{ + const RegisterInfo * reg_info = GetRegisterInfoAtIndex(reg); + if (reg_info) + return reg_info->name; + return NULL; +} + +uint64_t +RegisterContext::GetPC(uint64_t fail_value) +{ + uint32_t reg = ConvertRegisterKindToRegisterNumber (eRegisterKindGeneric, LLDB_REGNUM_GENERIC_PC); + return ReadRegisterAsUnsigned (reg, fail_value); +} + +bool +RegisterContext::SetPC(uint64_t pc) +{ + uint32_t reg = ConvertRegisterKindToRegisterNumber (eRegisterKindGeneric, LLDB_REGNUM_GENERIC_PC); + bool success = WriteRegisterFromUnsigned (reg, pc); + if (success) + { + StackFrameSP frame_sp(m_thread.GetFrameWithConcreteFrameIndex (m_concrete_frame_idx)); + if (frame_sp) + frame_sp->ChangePC(pc); + else + m_thread.ClearStackFrames (); + } + return success; +} + +uint64_t +RegisterContext::GetSP(uint64_t fail_value) +{ + uint32_t reg = ConvertRegisterKindToRegisterNumber (eRegisterKindGeneric, LLDB_REGNUM_GENERIC_SP); + return ReadRegisterAsUnsigned (reg, fail_value); +} + +bool +RegisterContext::SetSP(uint64_t sp) +{ + uint32_t reg = ConvertRegisterKindToRegisterNumber (eRegisterKindGeneric, LLDB_REGNUM_GENERIC_SP); + return WriteRegisterFromUnsigned (reg, sp); +} + +uint64_t +RegisterContext::GetFP(uint64_t fail_value) +{ + uint32_t reg = ConvertRegisterKindToRegisterNumber (eRegisterKindGeneric, LLDB_REGNUM_GENERIC_FP); + return ReadRegisterAsUnsigned (reg, fail_value); +} + +bool +RegisterContext::SetFP(uint64_t fp) +{ + uint32_t reg = ConvertRegisterKindToRegisterNumber (eRegisterKindGeneric, LLDB_REGNUM_GENERIC_FP); + return WriteRegisterFromUnsigned (reg, fp); +} + +uint64_t +RegisterContext::GetReturnAddress (uint64_t fail_value) +{ + uint32_t reg = ConvertRegisterKindToRegisterNumber (eRegisterKindGeneric, LLDB_REGNUM_GENERIC_RA); + return ReadRegisterAsUnsigned (reg, fail_value); +} + +uint64_t +RegisterContext::GetFlags (uint64_t fail_value) +{ + uint32_t reg = ConvertRegisterKindToRegisterNumber (eRegisterKindGeneric, LLDB_REGNUM_GENERIC_FLAGS); + return ReadRegisterAsUnsigned (reg, fail_value); +} + + +uint64_t +RegisterContext::ReadRegisterAsUnsigned (uint32_t reg, uint64_t fail_value) +{ + if (reg != LLDB_INVALID_REGNUM) + return ReadRegisterAsUnsigned (GetRegisterInfoAtIndex (reg), fail_value); + return fail_value; +} + +uint64_t +RegisterContext::ReadRegisterAsUnsigned (const RegisterInfo *reg_info, uint64_t fail_value) +{ + if (reg_info) + { + RegisterValue value; + if (ReadRegister (reg_info, value)) + return value.GetAsUInt64(); + } + return fail_value; +} + +bool +RegisterContext::WriteRegisterFromUnsigned (uint32_t reg, uint64_t uval) +{ + if (reg == LLDB_INVALID_REGNUM) + return false; + return WriteRegisterFromUnsigned (GetRegisterInfoAtIndex (reg), uval); +} + +bool +RegisterContext::WriteRegisterFromUnsigned (const RegisterInfo *reg_info, uint64_t uval) +{ + if (reg_info) + { + RegisterValue value; + if (value.SetUInt(uval, reg_info->byte_size)) + return WriteRegister (reg_info, value); + } + return false; +} + +bool +RegisterContext::CopyFromRegisterContext (lldb::RegisterContextSP context) +{ + uint32_t num_register_sets = context->GetRegisterSetCount(); + // We don't know that two threads have the same register context, so require the threads to be the same. + if (context->GetThreadID() != GetThreadID()) + return false; + + if (num_register_sets != GetRegisterSetCount()) + return false; + + RegisterContextSP frame_zero_context = m_thread.GetRegisterContext(); + + for (uint32_t set_idx = 0; set_idx < num_register_sets; ++set_idx) + { + const RegisterSet * const reg_set = GetRegisterSet(set_idx); + + const uint32_t num_registers = reg_set->num_registers; + for (uint32_t reg_idx = 0; reg_idx < num_registers; ++reg_idx) + { + const uint32_t reg = reg_set->registers[reg_idx]; + const RegisterInfo *reg_info = GetRegisterInfoAtIndex(reg); + if (!reg_info || reg_info->value_regs) + continue; + RegisterValue reg_value; + + // If we can reconstruct the register from the frame we are copying from, then do so, otherwise + // use the value from frame 0. + if (context->ReadRegister(reg_info, reg_value)) + { + WriteRegister(reg_info, reg_value); + } + else if (frame_zero_context->ReadRegister(reg_info, reg_value)) + { + WriteRegister(reg_info, reg_value); + } + } + } + return true; +} + +lldb::tid_t +RegisterContext::GetThreadID() const +{ + return m_thread.GetID(); +} + +uint32_t +RegisterContext::NumSupportedHardwareBreakpoints () +{ + return 0; +} + +uint32_t +RegisterContext::SetHardwareBreakpoint (lldb::addr_t addr, size_t size) +{ + return LLDB_INVALID_INDEX32; +} + +bool +RegisterContext::ClearHardwareBreakpoint (uint32_t hw_idx) +{ + return false; +} + + +uint32_t +RegisterContext::NumSupportedHardwareWatchpoints () +{ + return 0; +} + +uint32_t +RegisterContext::SetHardwareWatchpoint (lldb::addr_t addr, size_t size, bool read, bool write) +{ + return LLDB_INVALID_INDEX32; +} + +bool +RegisterContext::ClearHardwareWatchpoint (uint32_t hw_index) +{ + return false; +} + +bool +RegisterContext::HardwareSingleStep (bool enable) +{ + return false; +} + +Error +RegisterContext::ReadRegisterValueFromMemory (const RegisterInfo *reg_info, + lldb::addr_t src_addr, + uint32_t src_len, + RegisterValue ®_value) +{ + Error error; + if (reg_info == NULL) + { + error.SetErrorString ("invalid register info argument."); + return error; + } + + + // Moving from addr into a register + // + // Case 1: src_len == dst_len + // + // |AABBCCDD| Address contents + // |AABBCCDD| Register contents + // + // Case 2: src_len > dst_len + // + // Error! (The register should always be big enough to hold the data) + // + // Case 3: src_len < dst_len + // + // |AABB| Address contents + // |AABB0000| Register contents [on little-endian hardware] + // |0000AABB| Register contents [on big-endian hardware] + if (src_len > RegisterValue::kMaxRegisterByteSize) + { + error.SetErrorString ("register too small to receive memory data"); + return error; + } + + const uint32_t dst_len = reg_info->byte_size; + + if (src_len > dst_len) + { + error.SetErrorStringWithFormat("%u bytes is too big to store in register %s (%u bytes)", src_len, reg_info->name, dst_len); + return error; + } + + ProcessSP process_sp (m_thread.GetProcess()); + if (process_sp) + { + uint8_t src[RegisterValue::kMaxRegisterByteSize]; + + // Read the memory + const uint32_t bytes_read = process_sp->ReadMemory (src_addr, src, src_len, error); + + // Make sure the memory read succeeded... + if (bytes_read != src_len) + { + if (error.Success()) + { + // This might happen if we read _some_ bytes but not all + error.SetErrorStringWithFormat("read %u of %u bytes", bytes_read, src_len); + } + return error; + } + + // We now have a memory buffer that contains the part or all of the register + // value. Set the register value using this memory data. + // TODO: we might need to add a parameter to this function in case the byte + // order of the memory data doesn't match the process. For now we are assuming + // they are the same. + reg_value.SetFromMemoryData (reg_info, + src, + src_len, + process_sp->GetByteOrder(), + error); + } + else + error.SetErrorString("invalid process"); + + return error; +} + +Error +RegisterContext::WriteRegisterValueToMemory (const RegisterInfo *reg_info, + lldb::addr_t dst_addr, + uint32_t dst_len, + const RegisterValue ®_value) +{ + + uint8_t dst[RegisterValue::kMaxRegisterByteSize]; + + Error error; + + ProcessSP process_sp (m_thread.GetProcess()); + if (process_sp) + { + + // TODO: we might need to add a parameter to this function in case the byte + // order of the memory data doesn't match the process. For now we are assuming + // they are the same. + + const uint32_t bytes_copied = reg_value.GetAsMemoryData (reg_info, + dst, + dst_len, + process_sp->GetByteOrder(), + error); + + if (error.Success()) + { + if (bytes_copied == 0) + { + error.SetErrorString("byte copy failed."); + } + else + { + const uint32_t bytes_written = process_sp->WriteMemory (dst_addr, dst, bytes_copied, error); + if (bytes_written != bytes_copied) + { + if (error.Success()) + { + // This might happen if we read _some_ bytes but not all + error.SetErrorStringWithFormat("only wrote %u of %u bytes", bytes_written, bytes_copied); + } + } + } + } + } + else + error.SetErrorString("invalid process"); + + return error; + +} + +TargetSP +RegisterContext::CalculateTarget () +{ + return m_thread.CalculateTarget(); +} + + +ProcessSP +RegisterContext::CalculateProcess () +{ + return m_thread.CalculateProcess (); +} + +ThreadSP +RegisterContext::CalculateThread () +{ + return m_thread.shared_from_this(); +} + +StackFrameSP +RegisterContext::CalculateStackFrame () +{ + // Register contexts might belong to many frames if we have inlined + // functions inside a frame since all inlined functions share the + // same registers, so we can't definitively say which frame we come from... + return StackFrameSP(); +} + +void +RegisterContext::CalculateExecutionContext (ExecutionContext &exe_ctx) +{ + m_thread.CalculateExecutionContext (exe_ctx); +} + + +bool +RegisterContext::ConvertBetweenRegisterKinds (int source_rk, uint32_t source_regnum, int target_rk, uint32_t& target_regnum) +{ + const uint32_t num_registers = GetRegisterCount(); + for (uint32_t reg = 0; reg < num_registers; ++reg) + { + const RegisterInfo * reg_info = GetRegisterInfoAtIndex (reg); + + if (reg_info->kinds[source_rk] == source_regnum) + { + target_regnum = reg_info->kinds[target_rk]; + if (target_regnum == LLDB_INVALID_REGNUM) + { + return false; + } + else + { + return true; + } + } + } + return false; +} + +//bool +//RegisterContext::ReadRegisterValue (uint32_t reg, Scalar &value) +//{ +// DataExtractor data; +// if (!ReadRegisterBytes (reg, data)) +// return false; +// +// const RegisterInfo *reg_info = GetRegisterInfoAtIndex (reg); +// uint32_t offset = 0; +// switch (reg_info->encoding) +// { +// case eEncodingInvalid: +// case eEncodingVector: +// break; +// +// case eEncodingUint: +// switch (reg_info->byte_size) +// { +// case 1: +// { +// value = data.GetU8 (&offset); +// return true; +// } +// case 2: +// { +// value = data.GetU16 (&offset); +// return true; +// } +// case 4: +// { +// value = data.GetU32 (&offset); +// return true; +// } +// case 8: +// { +// value = data.GetU64 (&offset); +// return true; +// } +// } +// break; +// case eEncodingSint: +// switch (reg_info->byte_size) +// { +// case 1: +// { +// int8_t v; +// if (data.ExtractBytes (0, sizeof (int8_t), lldb::endian::InlHostByteOrder(), &v) != sizeof (int8_t)) +// return false; +// value = v; +// return true; +// } +// case 2: +// { +// int16_t v; +// if (data.ExtractBytes (0, sizeof (int16_t), lldb::endian::InlHostByteOrder(), &v) != sizeof (int16_t)) +// return false; +// value = v; +// return true; +// } +// case 4: +// { +// int32_t v; +// if (data.ExtractBytes (0, sizeof (int32_t), lldb::endian::InlHostByteOrder(), &v) != sizeof (int32_t)) +// return false; +// value = v; +// return true; +// } +// case 8: +// { +// int64_t v; +// if (data.ExtractBytes (0, sizeof (int64_t), lldb::endian::InlHostByteOrder(), &v) != sizeof (int64_t)) +// return false; +// value = v; +// return true; +// } +// } +// break; +// case eEncodingIEEE754: +// switch (reg_info->byte_size) +// { +// case sizeof (float): +// { +// float v; +// if (data.ExtractBytes (0, sizeof (float), lldb::endian::InlHostByteOrder(), &v) != sizeof (float)) +// return false; +// value = v; +// return true; +// } +// case sizeof (double): +// { +// double v; +// if (data.ExtractBytes (0, sizeof (double), lldb::endian::InlHostByteOrder(), &v) != sizeof (double)) +// return false; +// value = v; +// return true; +// } +// case sizeof (long double): +// { +// double v; +// if (data.ExtractBytes (0, sizeof (long double), lldb::endian::InlHostByteOrder(), &v) != sizeof (long double)) +// return false; +// value = v; +// return true; +// } +// } +// break; +// } +// return false; +//} +// +//bool +//RegisterContext::WriteRegisterValue (uint32_t reg, const Scalar &value) +//{ +// DataExtractor data; +// if (!value.IsValid()) +// return false; +// if (!value.GetData (data)) +// return false; +// +// return WriteRegisterBytes (reg, data); +//} |