aboutsummaryrefslogtreecommitdiffstats
path: root/source/Target/RegisterContext.cpp
diff options
context:
space:
mode:
authorDimitry Andric <dim@FreeBSD.org>2017-01-02 19:26:05 +0000
committerDimitry Andric <dim@FreeBSD.org>2017-01-02 19:26:05 +0000
commit14f1b3e8826ce43b978db93a62d1166055db5394 (patch)
tree0a00ad8d3498783fe0193f3b656bca17c4c8697d /source/Target/RegisterContext.cpp
parent4ee8c119c71a06dcad1e0fecc8c675e480e59337 (diff)
downloadsrc-14f1b3e8826ce43b978db93a62d1166055db5394.tar.gz
src-14f1b3e8826ce43b978db93a62d1166055db5394.zip
Vendor import of lldb trunk r290819:vendor/lldb/lldb-trunk-r290819
Notes
Notes: svn path=/vendor/lldb/dist/; revision=311128 svn path=/vendor/lldb/lldb-trunk-r290819/; revision=311129; tag=vendor/lldb/lldb-trunk-r290819
Diffstat (limited to 'source/Target/RegisterContext.cpp')
-rw-r--r--source/Target/RegisterContext.cpp818
1 files changed, 368 insertions, 450 deletions
diff --git a/source/Target/RegisterContext.cpp b/source/Target/RegisterContext.cpp
index ae3c43def275..4cce4dd6bccc 100644
--- a/source/Target/RegisterContext.cpp
+++ b/source/Target/RegisterContext.cpp
@@ -13,543 +13,454 @@
// Project includes
#include "lldb/Target/RegisterContext.h"
#include "lldb/Core/DataExtractor.h"
+#include "lldb/Core/Module.h"
#include "lldb/Core/RegisterValue.h"
#include "lldb/Core/Scalar.h"
+#include "lldb/Core/Value.h"
+#include "lldb/Expression/DWARFExpression.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"
+#include "lldb/Target/StackFrame.h"
#include "lldb/Target/Target.h"
-#include "lldb/Core/Module.h"
-#include "lldb/Expression/DWARFExpression.h"
-#include "lldb/Core/Value.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())
-{
-}
+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()) {}
RegisterContext::~RegisterContext() = default;
-void
-RegisterContext::InvalidateIfNeeded (bool force)
-{
- ProcessSP process_sp (m_thread.GetProcess());
- bool invalidate = force;
- uint32_t process_stop_id = UINT32_MAX;
+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);
- }
+ 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 != nullptr && ::strcasecmp (reg_info->name, reg_name) == 0) ||
- (reg_info->alt_name != nullptr && ::strcasecmp (reg_info->alt_name, reg_name) == 0))
- {
- return reg_info;
- }
- }
- }
+RegisterContext::GetRegisterInfoByName(llvm::StringRef reg_name,
+ uint32_t start_idx) {
+ if (reg_name.empty())
return nullptr;
+
+ const uint32_t num_registers = GetRegisterCount();
+ for (uint32_t reg = start_idx; reg < num_registers; ++reg) {
+ const RegisterInfo *reg_info = GetRegisterInfoAtIndex(reg);
+
+ if (reg_name.equals_lower(reg_info->name) ||
+ reg_name.equals_lower(reg_info->alt_name))
+ return reg_info;
+ }
+ return nullptr;
}
uint32_t
-RegisterContext::UpdateDynamicRegisterSize (const lldb_private::ArchSpec &arch,
- RegisterInfo* reg_info)
-{
- ExecutionContext exe_ctx (CalculateThread());
-
- // In MIPS, the floating point registers size is depends on FR bit of SR register.
- // if SR.FR == 1 then all floating point registers are 64 bits.
- // else they are all 32 bits.
-
- int expr_result;
- uint32_t addr_size = arch.GetAddressByteSize ();
- const uint8_t* dwarf_opcode_ptr = reg_info->dynamic_size_dwarf_expr_bytes;
- const size_t dwarf_opcode_len = reg_info->dynamic_size_dwarf_len;
-
- DataExtractor dwarf_data (dwarf_opcode_ptr, dwarf_opcode_len,
- arch.GetByteOrder (), addr_size);
- ModuleSP opcode_ctx;
- DWARFExpression dwarf_expr (opcode_ctx, dwarf_data, nullptr, 0, dwarf_opcode_len);
- Value result;
- Error error;
- const lldb::offset_t offset = 0;
- if (dwarf_expr.Evaluate (&exe_ctx, nullptr, nullptr, this, opcode_ctx, dwarf_data, nullptr,
- offset, dwarf_opcode_len, eRegisterKindDWARF, nullptr, nullptr, result, &error))
- {
- expr_result = result.GetScalar ().SInt (-1);
- switch (expr_result)
- {
- case 0: return 4;
- case 1: return 8;
- default: return reg_info->byte_size;
- }
- }
- else
- {
- printf ("Error executing DwarfExpression::Evaluate %s\n", error.AsCString());
- return reg_info->byte_size;
+RegisterContext::UpdateDynamicRegisterSize(const lldb_private::ArchSpec &arch,
+ RegisterInfo *reg_info) {
+ ExecutionContext exe_ctx(CalculateThread());
+
+ // In MIPS, the floating point registers size is depends on FR bit of SR
+ // register.
+ // if SR.FR == 1 then all floating point registers are 64 bits.
+ // else they are all 32 bits.
+
+ int expr_result;
+ uint32_t addr_size = arch.GetAddressByteSize();
+ const uint8_t *dwarf_opcode_ptr = reg_info->dynamic_size_dwarf_expr_bytes;
+ const size_t dwarf_opcode_len = reg_info->dynamic_size_dwarf_len;
+
+ DataExtractor dwarf_data(dwarf_opcode_ptr, dwarf_opcode_len,
+ arch.GetByteOrder(), addr_size);
+ ModuleSP opcode_ctx;
+ DWARFExpression dwarf_expr(opcode_ctx, dwarf_data, nullptr, 0,
+ dwarf_opcode_len);
+ Value result;
+ Error error;
+ const lldb::offset_t offset = 0;
+ if (dwarf_expr.Evaluate(&exe_ctx, nullptr, nullptr, this, opcode_ctx,
+ dwarf_data, nullptr, offset, dwarf_opcode_len,
+ eRegisterKindDWARF, nullptr, nullptr, result,
+ &error)) {
+ expr_result = result.GetScalar().SInt(-1);
+ switch (expr_result) {
+ case 0:
+ return 4;
+ case 1:
+ return 8;
+ default:
+ return reg_info->byte_size;
}
+ } else {
+ printf("Error executing DwarfExpression::Evaluate %s\n", error.AsCString());
+ return reg_info->byte_size;
+ }
}
-const RegisterInfo *
-RegisterContext::GetRegisterInfo (lldb::RegisterKind kind, uint32_t num)
-{
- const uint32_t reg_num = ConvertRegisterKindToRegisterNumber(kind, num);
- if (reg_num == LLDB_INVALID_REGNUM)
- return nullptr;
- return GetRegisterInfoAtIndex (reg_num);
-}
-
-const char *
-RegisterContext::GetRegisterName (uint32_t reg)
-{
- const RegisterInfo * reg_info = GetRegisterInfoAtIndex(reg);
- if (reg_info)
- return reg_info->name;
+const RegisterInfo *RegisterContext::GetRegisterInfo(lldb::RegisterKind kind,
+ uint32_t num) {
+ const uint32_t reg_num = ConvertRegisterKindToRegisterNumber(kind, num);
+ if (reg_num == LLDB_INVALID_REGNUM)
return nullptr;
+ return GetRegisterInfoAtIndex(reg_num);
}
-uint64_t
-RegisterContext::GetPC(uint64_t fail_value)
-{
- uint32_t reg = ConvertRegisterKindToRegisterNumber (eRegisterKindGeneric, LLDB_REGNUM_GENERIC_PC);
- uint64_t pc = ReadRegisterAsUnsigned (reg, fail_value);
-
- if (pc != fail_value)
- {
- TargetSP target_sp = m_thread.CalculateTarget();
- if (target_sp)
- {
- Target *target = target_sp.get();
- if (target)
- pc = target->GetOpcodeLoadAddress (pc, eAddressClassCode);
- }
- }
-
- return pc;
-}
-
-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;
+const char *RegisterContext::GetRegisterName(uint32_t reg) {
+ const RegisterInfo *reg_info = GetRegisterInfoAtIndex(reg);
+ if (reg_info)
+ return reg_info->name;
+ return nullptr;
}
-bool
-RegisterContext::SetPC(Address addr)
-{
- TargetSP target_sp = m_thread.CalculateTarget();
- Target *target = target_sp.get();
+uint64_t RegisterContext::GetPC(uint64_t fail_value) {
+ uint32_t reg = ConvertRegisterKindToRegisterNumber(eRegisterKindGeneric,
+ LLDB_REGNUM_GENERIC_PC);
+ uint64_t pc = ReadRegisterAsUnsigned(reg, fail_value);
- lldb::addr_t callAddr = addr.GetCallableLoadAddress (target);
- if (callAddr == LLDB_INVALID_ADDRESS)
- return false;
+ if (pc != fail_value) {
+ TargetSP target_sp = m_thread.CalculateTarget();
+ if (target_sp) {
+ Target *target = target_sp.get();
+ if (target)
+ pc = target->GetOpcodeLoadAddress(pc, eAddressClassCode);
+ }
+ }
- return SetPC (callAddr);
+ return pc;
}
-uint64_t
-RegisterContext::GetSP(uint64_t fail_value)
-{
- uint32_t reg = ConvertRegisterKindToRegisterNumber (eRegisterKindGeneric, LLDB_REGNUM_GENERIC_SP);
- 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;
}
-bool
-RegisterContext::SetSP(uint64_t sp)
-{
- uint32_t reg = ConvertRegisterKindToRegisterNumber (eRegisterKindGeneric, LLDB_REGNUM_GENERIC_SP);
- return WriteRegisterFromUnsigned (reg, sp);
-}
+bool RegisterContext::SetPC(Address addr) {
+ TargetSP target_sp = m_thread.CalculateTarget();
+ Target *target = target_sp.get();
-uint64_t
-RegisterContext::GetFP(uint64_t fail_value)
-{
- uint32_t reg = ConvertRegisterKindToRegisterNumber (eRegisterKindGeneric, LLDB_REGNUM_GENERIC_FP);
- return ReadRegisterAsUnsigned (reg, fail_value);
-}
+ lldb::addr_t callAddr = addr.GetCallableLoadAddress(target);
+ if (callAddr == LLDB_INVALID_ADDRESS)
+ return false;
-bool
-RegisterContext::SetFP(uint64_t fp)
-{
- uint32_t reg = ConvertRegisterKindToRegisterNumber (eRegisterKindGeneric, LLDB_REGNUM_GENERIC_FP);
- return WriteRegisterFromUnsigned (reg, fp);
+ return SetPC(callAddr);
}
-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::GetSP(uint64_t fail_value) {
+ uint32_t reg = ConvertRegisterKindToRegisterNumber(eRegisterKindGeneric,
+ LLDB_REGNUM_GENERIC_SP);
+ 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);
+bool RegisterContext::SetSP(uint64_t sp) {
+ uint32_t reg = ConvertRegisterKindToRegisterNumber(eRegisterKindGeneric,
+ LLDB_REGNUM_GENERIC_SP);
+ return WriteRegisterFromUnsigned(reg, sp);
}
-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::GetFP(uint64_t fail_value) {
+ uint32_t reg = ConvertRegisterKindToRegisterNumber(eRegisterKindGeneric,
+ LLDB_REGNUM_GENERIC_FP);
+ return ReadRegisterAsUnsigned(reg, 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::SetFP(uint64_t fp) {
+ uint32_t reg = ConvertRegisterKindToRegisterNumber(eRegisterKindGeneric,
+ LLDB_REGNUM_GENERIC_FP);
+ return WriteRegisterFromUnsigned(reg, fp);
}
-bool
-RegisterContext::WriteRegisterFromUnsigned (uint32_t reg, uint64_t uval)
-{
- if (reg == LLDB_INVALID_REGNUM)
- return false;
- return WriteRegisterFromUnsigned (GetRegisterInfoAtIndex (reg), uval);
+uint64_t RegisterContext::GetReturnAddress(uint64_t fail_value) {
+ uint32_t reg = ConvertRegisterKindToRegisterNumber(eRegisterKindGeneric,
+ LLDB_REGNUM_GENERIC_RA);
+ return ReadRegisterAsUnsigned(reg, fail_value);
}
-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;
+uint64_t RegisterContext::GetFlags(uint64_t fail_value) {
+ uint32_t reg = ConvertRegisterKindToRegisterNumber(eRegisterKindGeneric,
+ LLDB_REGNUM_GENERIC_FLAGS);
+ return ReadRegisterAsUnsigned(reg, fail_value);
}
-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;
+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;
}
-lldb::tid_t
-RegisterContext::GetThreadID() const
-{
- return m_thread.GetID();
+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;
}
-uint32_t
-RegisterContext::NumSupportedHardwareBreakpoints ()
-{
- return 0;
+bool RegisterContext::WriteRegisterFromUnsigned(uint32_t reg, uint64_t uval) {
+ if (reg == LLDB_INVALID_REGNUM)
+ return false;
+ return WriteRegisterFromUnsigned(GetRegisterInfoAtIndex(reg), uval);
}
-uint32_t
-RegisterContext::SetHardwareBreakpoint (lldb::addr_t addr, size_t size)
-{
- return LLDB_INVALID_INDEX32;
+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::ClearHardwareBreakpoint (uint32_t hw_idx)
-{
+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;
-}
-uint32_t
-RegisterContext::NumSupportedHardwareWatchpoints ()
-{
- return 0;
+ 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;
}
-uint32_t
-RegisterContext::SetHardwareWatchpoint (lldb::addr_t addr, size_t size, bool read, bool write)
-{
- return LLDB_INVALID_INDEX32;
+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::ClearHardwareWatchpoint (uint32_t hw_index)
-{
- return false;
+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::HardwareSingleStep (bool enable)
-{
- return false;
+bool RegisterContext::ClearHardwareWatchpoint(uint32_t hw_index) {
+ return false;
}
-Error
-RegisterContext::ReadRegisterValueFromMemory (const RegisterInfo *reg_info,
- lldb::addr_t src_addr,
- uint32_t src_len,
- RegisterValue &reg_value)
-{
- Error error;
- if (reg_info == nullptr)
- {
- error.SetErrorString ("invalid register info argument.");
- return error;
- }
+bool RegisterContext::HardwareSingleStep(bool enable) { return false; }
- // 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");
+Error RegisterContext::ReadRegisterValueFromMemory(const RegisterInfo *reg_info,
+ lldb::addr_t src_addr,
+ uint32_t src_len,
+ RegisterValue &reg_value) {
+ Error error;
+ if (reg_info == nullptr) {
+ 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;
+ }
-Error
-RegisterContext::WriteRegisterValueToMemory (const RegisterInfo *reg_info,
- lldb::addr_t dst_addr,
- uint32_t dst_len,
- const RegisterValue &reg_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);
- }
- }
- }
+ // 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 &reg_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");
+ } else
+ error.SetErrorString("invalid process");
- return error;
+ return error;
}
-bool
-RegisterContext::ReadAllRegisterValues (lldb_private::RegisterCheckpoint &reg_checkpoint)
-{
- return ReadAllRegisterValues(reg_checkpoint.GetData());
+bool RegisterContext::ReadAllRegisterValues(
+ lldb_private::RegisterCheckpoint &reg_checkpoint) {
+ return ReadAllRegisterValues(reg_checkpoint.GetData());
}
-bool
-RegisterContext::WriteAllRegisterValues (const lldb_private::RegisterCheckpoint &reg_checkpoint)
-{
- return WriteAllRegisterValues(reg_checkpoint.GetData());
+bool RegisterContext::WriteAllRegisterValues(
+ const lldb_private::RegisterCheckpoint &reg_checkpoint) {
+ return WriteAllRegisterValues(reg_checkpoint.GetData());
}
-TargetSP
-RegisterContext::CalculateTarget ()
-{
- return m_thread.CalculateTarget();
+TargetSP RegisterContext::CalculateTarget() {
+ return m_thread.CalculateTarget();
}
-ProcessSP
-RegisterContext::CalculateProcess ()
-{
- return m_thread.CalculateProcess ();
+ProcessSP RegisterContext::CalculateProcess() {
+ return m_thread.CalculateProcess();
}
-ThreadSP
-RegisterContext::CalculateThread ()
-{
- return m_thread.shared_from_this();
+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();
+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);
+void RegisterContext::CalculateExecutionContext(ExecutionContext &exe_ctx) {
+ m_thread.CalculateExecutionContext(exe_ctx);
}
-bool
-RegisterContext::ConvertBetweenRegisterKinds (lldb::RegisterKind source_rk, uint32_t source_regnum, lldb::RegisterKind 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);
+bool RegisterContext::ConvertBetweenRegisterKinds(lldb::RegisterKind source_rk,
+ uint32_t source_regnum,
+ lldb::RegisterKind 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];
- return (target_regnum != LLDB_INVALID_REGNUM);
- }
+ if (reg_info->kinds[source_rk] == source_regnum) {
+ target_regnum = reg_info->kinds[target_rk];
+ return (target_regnum != LLDB_INVALID_REGNUM);
}
- return false;
+ }
+ return false;
}
-//bool
-//RegisterContext::ReadRegisterValue (uint32_t reg, Scalar &value)
+// bool
+// RegisterContext::ReadRegisterValue (uint32_t reg, Scalar &value)
//{
// DataExtractor data;
// if (!ReadRegisterBytes (reg, data))
@@ -594,7 +505,8 @@ RegisterContext::ConvertBetweenRegisterKinds (lldb::RegisterKind source_rk, uint
// case 1:
// {
// int8_t v;
-// if (data.ExtractBytes (0, sizeof (int8_t), endian::InlHostByteOrder(), &v) != sizeof (int8_t))
+// if (data.ExtractBytes (0, sizeof (int8_t),
+// endian::InlHostByteOrder(), &v) != sizeof (int8_t))
// return false;
// value = v;
// return true;
@@ -602,7 +514,8 @@ RegisterContext::ConvertBetweenRegisterKinds (lldb::RegisterKind source_rk, uint
// case 2:
// {
// int16_t v;
-// if (data.ExtractBytes (0, sizeof (int16_t), endian::InlHostByteOrder(), &v) != sizeof (int16_t))
+// if (data.ExtractBytes (0, sizeof (int16_t),
+// endian::InlHostByteOrder(), &v) != sizeof (int16_t))
// return false;
// value = v;
// return true;
@@ -610,7 +523,8 @@ RegisterContext::ConvertBetweenRegisterKinds (lldb::RegisterKind source_rk, uint
// case 4:
// {
// int32_t v;
-// if (data.ExtractBytes (0, sizeof (int32_t), endian::InlHostByteOrder(), &v) != sizeof (int32_t))
+// if (data.ExtractBytes (0, sizeof (int32_t),
+// endian::InlHostByteOrder(), &v) != sizeof (int32_t))
// return false;
// value = v;
// return true;
@@ -618,7 +532,8 @@ RegisterContext::ConvertBetweenRegisterKinds (lldb::RegisterKind source_rk, uint
// case 8:
// {
// int64_t v;
-// if (data.ExtractBytes (0, sizeof (int64_t), endian::InlHostByteOrder(), &v) != sizeof (int64_t))
+// if (data.ExtractBytes (0, sizeof (int64_t),
+// endian::InlHostByteOrder(), &v) != sizeof (int64_t))
// return false;
// value = v;
// return true;
@@ -631,7 +546,8 @@ RegisterContext::ConvertBetweenRegisterKinds (lldb::RegisterKind source_rk, uint
// case sizeof (float):
// {
// float v;
-// if (data.ExtractBytes (0, sizeof (float), endian::InlHostByteOrder(), &v) != sizeof (float))
+// if (data.ExtractBytes (0, sizeof (float),
+// endian::InlHostByteOrder(), &v) != sizeof (float))
// return false;
// value = v;
// return true;
@@ -639,7 +555,8 @@ RegisterContext::ConvertBetweenRegisterKinds (lldb::RegisterKind source_rk, uint
// case sizeof (double):
// {
// double v;
-// if (data.ExtractBytes (0, sizeof (double), endian::InlHostByteOrder(), &v) != sizeof (double))
+// if (data.ExtractBytes (0, sizeof (double),
+// endian::InlHostByteOrder(), &v) != sizeof (double))
// return false;
// value = v;
// return true;
@@ -647,7 +564,8 @@ RegisterContext::ConvertBetweenRegisterKinds (lldb::RegisterKind source_rk, uint
// case sizeof (long double):
// {
// double v;
-// if (data.ExtractBytes (0, sizeof (long double), endian::InlHostByteOrder(), &v) != sizeof (long double))
+// if (data.ExtractBytes (0, sizeof (long double),
+// endian::InlHostByteOrder(), &v) != sizeof (long double))
// return false;
// value = v;
// return true;
@@ -658,8 +576,8 @@ RegisterContext::ConvertBetweenRegisterKinds (lldb::RegisterKind source_rk, uint
// return false;
//}
//
-//bool
-//RegisterContext::WriteRegisterValue (uint32_t reg, const Scalar &value)
+// bool
+// RegisterContext::WriteRegisterValue (uint32_t reg, const Scalar &value)
//{
// DataExtractor data;
// if (!value.IsValid())