QVariant RegisterEditItem::data(int column, int role) const
{
switch (role) {
case Qt::DisplayRole:
case Qt::EditRole:
switch (column) {
case RegisterNameColumn: {
return QString("[%1]").arg(m_index);
}
case RegisterValueColumn: {
RegisterValue value = parent()->parent()->m_reg.value;
return value.subValue(m_subSize, m_index)
.toString(m_subKind, m_subSize, m_subFormat, role == Qt::EditRole);
}
}
break;
case Qt::ToolTipRole: {
RegisterItem *registerItem = parent()->parent();
return RegisterHandler::tr("Edit bits %1...%2 of register %3")
.arg(m_index * 8).arg(m_index * 8 + 7).arg(registerItem->m_reg.name);
}
default:
break;
}
return QVariant();
}
bool RegisterContextCorePOSIX_s390x::ReadRegister(const RegisterInfo *reg_info,
RegisterValue &value) {
const uint32_t reg = reg_info->kinds[lldb::eRegisterKindLLDB];
if (reg == LLDB_INVALID_REGNUM)
return false;
if (IsGPR(reg)) {
lldb::offset_t offset = reg_info->byte_offset;
uint64_t v = m_gpr.GetMaxU64(&offset, reg_info->byte_size);
if (offset == reg_info->byte_offset + reg_info->byte_size) {
value.SetUInt(v, reg_info->byte_size);
return true;
}
}
if (IsFPR(reg)) {
lldb::offset_t offset = reg_info->byte_offset;
uint64_t v = m_fpr.GetMaxU64(&offset, reg_info->byte_size);
if (offset == reg_info->byte_offset + reg_info->byte_size) {
value.SetUInt(v, reg_info->byte_size);
return true;
}
}
return false;
}
QVariant RegisterSubItem::data(int column, int role) const
{
switch (role) {
case RegisterChangedRole:
return m_changed;
case RegisterNumberBaseRole:
return 16;
case RegisterAsAddressRole:
return 0;
case Qt::DisplayRole:
switch (column) {
case 0:
return subTypeName(m_subKind, m_subSize);
case 1: {
QTC_ASSERT(parent(), return QVariant());
RegisterItem *registerItem = static_cast<RegisterItem *>(parent());
RegisterValue value = registerItem->m_reg.value;
QByteArray ba;
for (int i = 0; i != m_count; ++i) {
ba += value.subValue(m_subSize, i).toByteArray(16, m_subKind, m_subSize);
int tab = 5 * (i + 1) * m_subSize;
ba += QByteArray(tab - ba.size(), ' ');
}
return ba;
}
}
default:
break;
}
return QVariant();
}
bool
RegisterContextPOSIXProcessMonitor_x86_64::IsWatchpointVacant(uint32_t hw_index)
{
bool is_vacant = false;
RegisterValue value;
assert(hw_index < NumSupportedHardwareWatchpoints());
if (m_watchpoints_initialized == false)
{
// Reset the debug status and debug control registers
RegisterValue zero_bits = RegisterValue(uint64_t(0));
if (!WriteRegister(dr6, zero_bits) || !WriteRegister(dr7, zero_bits))
assert(false && "Could not initialize watchpoint registers");
m_watchpoints_initialized = true;
}
if (ReadRegister(dr7, value))
{
uint64_t val = value.GetAsUInt64();
is_vacant = (val & (3 << 2*hw_index)) == 0;
}
return is_vacant;
}
bool
RegisterContextPOSIXProcessMonitor_powerpc::ReadRegister(const RegisterInfo *reg_info, RegisterValue &value)
{
if (!reg_info)
return false;
const uint32_t reg = reg_info->kinds[eRegisterKindLLDB];
if (IsFPR(reg))
{
if (!ReadFPR())
return false;
uint8_t *src = (uint8_t *)&m_fpr_powerpc + reg_info->byte_offset;
value.SetUInt64(*(uint64_t*)src);
}
else if (IsGPR(reg))
{
bool success = ReadRegister(reg, value);
if (success)
{
// If our return byte size was greater than the return value reg size, then
// use the type specified by reg_info rather than the uint64_t default
if (value.GetByteSize() > reg_info->byte_size)
value.SetType(reg_info);
}
return success;
}
return false;
}
QVariant RegisterSubItem::data(int column, int role) const
{
switch (role) {
case RegisterChangedRole:
return m_changed;
case RegisterFormatRole: {
RegisterItem *registerItem = static_cast<RegisterItem *>(parent());
return int(registerItem->m_format);
}
case RegisterAsAddressRole:
return 0;
case Qt::DisplayRole:
switch (column) {
case RegisterNameColumn:
return subTypeName(m_subKind, m_subSize, m_subFormat);
case RegisterValueColumn: {
QTC_ASSERT(parent(), return QVariant());
RegisterItem *registerItem = static_cast<RegisterItem *>(parent());
RegisterValue value = registerItem->m_reg.value;
QString ba;
for (int i = 0; i != m_count; ++i) {
int tab = 5 * (i + 1) * m_subSize;
QString b = value.subValue(m_subSize, i).toString(m_subKind, m_subSize, m_subFormat);
ba += QString(tab - ba.size() - b.size(), ' ');
ba += b;
}
return ba;
}
}
case Qt::ToolTipRole:
if (m_subKind == IntegerRegister) {
if (m_subFormat == CharacterFormat)
return RegisterHandler::tr("Content as ASCII Characters");
if (m_subFormat == SignedDecimalFormat)
return RegisterHandler::tr("Content as %1-bit Signed Decimal Values").arg(8 * m_subSize);
if (m_subFormat == DecimalFormat)
return RegisterHandler::tr("Content as %1-bit Unsigned Decimal Values").arg(8 * m_subSize);
if (m_subFormat == HexadecimalFormat)
return RegisterHandler::tr("Content as %1-bit Hexadecimal Values").arg(8 * m_subSize);
if (m_subFormat == OctalFormat)
return RegisterHandler::tr("Content as %1-bit Octal Values").arg(8 * m_subSize);
if (m_subFormat == BinaryFormat)
return RegisterHandler::tr("Content as %1-bit Binary Values").arg(8 * m_subSize);
}
if (m_subKind == FloatRegister)
return RegisterHandler::tr("Content as %1-bit Floating Point Values").arg(8 * m_subSize);
default:
break;
}
return QVariant();
}
RegisterValue::Type RegisterValue::SetType(const RegisterInfo *reg_info) {
// To change the type, we simply copy the data in again, using the new format
RegisterValue copy;
DataExtractor copy_data;
if (copy.CopyValue(*this) && copy.GetData(copy_data))
SetValueFromData(reg_info, copy_data, 0, true);
return m_type;
}
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::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
RegisterContextWindows_x86::ReadRegister(const RegisterInfo *reg_info, RegisterValue ®_value)
{
if (!CacheAllRegisterValues())
return false;
uint32_t reg = reg_info->kinds[eRegisterKindLLDB];
switch (reg)
{
case lldb_eax_i386:
WINLOG_IFALL(WINDOWS_LOG_REGISTERS, "Read value 0x%x from EAX", m_context.Eax);
reg_value.SetUInt32(m_context.Eax);
break;
case lldb_ebx_i386:
WINLOG_IFALL(WINDOWS_LOG_REGISTERS, "Read value 0x%x from EBX", m_context.Ebx);
reg_value.SetUInt32(m_context.Ebx);
break;
case lldb_ecx_i386:
WINLOG_IFALL(WINDOWS_LOG_REGISTERS, "Read value 0x%x from ECX", m_context.Ecx);
reg_value.SetUInt32(m_context.Ecx);
break;
case lldb_edx_i386:
WINLOG_IFALL(WINDOWS_LOG_REGISTERS, "Read value 0x%x from EDX", m_context.Edx);
reg_value.SetUInt32(m_context.Edx);
break;
case lldb_edi_i386:
WINLOG_IFALL(WINDOWS_LOG_REGISTERS, "Read value 0x%x from EDI", m_context.Edi);
reg_value.SetUInt32(m_context.Edi);
break;
case lldb_esi_i386:
WINLOG_IFALL(WINDOWS_LOG_REGISTERS, "Read value 0x%x from ESI", m_context.Esi);
reg_value.SetUInt32(m_context.Esi);
break;
case lldb_ebp_i386:
WINLOG_IFALL(WINDOWS_LOG_REGISTERS, "Read value 0x%x from EBP", m_context.Ebp);
reg_value.SetUInt32(m_context.Ebp);
break;
case lldb_esp_i386:
WINLOG_IFALL(WINDOWS_LOG_REGISTERS, "Read value 0x%x from ESP", m_context.Esp);
reg_value.SetUInt32(m_context.Esp);
break;
case lldb_eip_i386:
WINLOG_IFALL(WINDOWS_LOG_REGISTERS, "Read value 0x%x from EIP", m_context.Eip);
reg_value.SetUInt32(m_context.Eip);
break;
case lldb_eflags_i386:
WINLOG_IFALL(WINDOWS_LOG_REGISTERS, "Read value 0x%x from EFLAGS", m_context.EFlags);
reg_value.SetUInt32(m_context.EFlags);
break;
default:
WINWARN_IFALL(WINDOWS_LOG_REGISTERS, "Requested unknown register %u", reg);
break;
}
return true;
}
bool RegisterEditItem::setData(int column, const QVariant &value, int role)
{
if (column == RegisterValueColumn && role == Qt::EditRole) {
QTC_ASSERT(parent(), return false);
QTC_ASSERT(parent()->parent(), return false);
RegisterItem *registerItem = parent()->parent();
Register ® = registerItem->m_reg;
RegisterValue vv;
vv.fromString(value.toString(), m_subFormat);
reg.value.setSubValue(m_subSize, m_index, vv);
registerItem->triggerChange();
return true;
}
bool EmulateInstruction::ReadRegisterDefault(EmulateInstruction *instruction,
void *baton,
const RegisterInfo *reg_info,
RegisterValue ®_value) {
StreamFile strm(stdout, false);
strm.Printf(" Read Register (%s)\n", reg_info->name);
lldb::RegisterKind reg_kind;
uint32_t reg_num;
if (GetBestRegisterKindAndNumber(reg_info, reg_kind, reg_num))
reg_value.SetUInt64((uint64_t)reg_kind << 24 | reg_num);
else
reg_value.SetUInt64(0);
return true;
}
bool RegisterContextCorePOSIX_powerpc::ReadRegister(
const RegisterInfo *reg_info, RegisterValue &value) {
lldb::offset_t offset = reg_info->byte_offset;
if (IsFPR(reg_info->kinds[lldb::eRegisterKindLLDB])) {
uint64_t v = m_fpr.GetMaxU64(&offset, reg_info->byte_size);
if (offset == reg_info->byte_offset + reg_info->byte_size) {
value = v;
return true;
}
} else if (IsVMX(reg_info->kinds[lldb::eRegisterKindLLDB])) {
uint32_t v[4];
offset = m_vec.CopyData(offset, reg_info->byte_size, &v);
if (offset == reg_info->byte_size) {
value.SetBytes(v, reg_info->byte_size, m_vec.GetByteOrder());
return true;
}
} else {
uint64_t v = m_gpr.GetMaxU64(&offset, reg_info->byte_size);
if (offset == reg_info->byte_offset + reg_info->byte_size) {
if (reg_info->byte_size < sizeof(v))
value = (uint32_t)v;
else
value = v;
return true;
}
}
return false;
}
bool
RegisterContextWindows_x86::WriteRegister(const RegisterInfo *reg_info, const RegisterValue ®_value)
{
// Since we cannot only write a single register value to the inferior, we need to make sure
// our cached copy of the register values are fresh. Otherwise when writing EAX, for example,
// we may also overwrite some other register with a stale value.
if (!CacheAllRegisterValues())
return false;
switch (reg_info->kinds[eRegisterKindLLDB])
{
case lldb_eax_i386:
m_context.Eax = reg_value.GetAsUInt32();
break;
case lldb_ebx_i386:
m_context.Ebx = reg_value.GetAsUInt32();
break;
case lldb_ecx_i386:
m_context.Ecx = reg_value.GetAsUInt32();
break;
case lldb_edx_i386:
m_context.Edx = reg_value.GetAsUInt32();
break;
case lldb_edi_i386:
m_context.Edi = reg_value.GetAsUInt32();
break;
case lldb_esi_i386:
m_context.Esi = reg_value.GetAsUInt32();
break;
case lldb_ebp_i386:
m_context.Ebp = reg_value.GetAsUInt32();
break;
case lldb_esp_i386:
m_context.Esp = reg_value.GetAsUInt32();
break;
case lldb_eip_i386:
m_context.Eip = reg_value.GetAsUInt32();
break;
case lldb_eflags_i386:
m_context.EFlags = reg_value.GetAsUInt32();
break;
}
// Physically update the registers in the target process.
TargetThreadWindows &wthread = static_cast<TargetThreadWindows &>(m_thread);
return ::SetThreadContext(wthread.GetHostThread().GetNativeThread().GetSystemHandle(), &m_context);
}
bool
RegisterContextPOSIXProcessMonitor_powerpc::WriteRegister(const unsigned reg,
const RegisterValue &value)
{
unsigned reg_to_write = reg;
RegisterValue value_to_write = value;
// Check if this is a subregister of a full register.
const RegisterInfo *reg_info = GetRegisterInfoAtIndex(reg);
if (reg_info->invalidate_regs && (reg_info->invalidate_regs[0] != LLDB_INVALID_REGNUM))
{
RegisterValue full_value;
uint32_t full_reg = reg_info->invalidate_regs[0];
const RegisterInfo *full_reg_info = GetRegisterInfoAtIndex(full_reg);
// Read the full register.
if (ReadRegister(full_reg_info, full_value))
{
Error error;
ByteOrder byte_order = GetByteOrder();
uint8_t dst[RegisterValue::kMaxRegisterByteSize];
// Get the bytes for the full register.
const uint32_t dest_size = full_value.GetAsMemoryData (full_reg_info,
dst,
sizeof(dst),
byte_order,
error);
if (error.Success() && dest_size)
{
uint8_t src[RegisterValue::kMaxRegisterByteSize];
// Get the bytes for the source data.
const uint32_t src_size = value.GetAsMemoryData (reg_info, src, sizeof(src), byte_order, error);
if (error.Success() && src_size && (src_size < dest_size))
{
// Copy the src bytes to the destination.
memcpy (dst + (reg_info->byte_offset & 0x1), src, src_size);
// Set this full register as the value to write.
value_to_write.SetBytes(dst, full_value.GetByteSize(), byte_order);
value_to_write.SetType(full_reg_info);
reg_to_write = full_reg;
}
}
}
}
ProcessMonitor &monitor = GetMonitor();
// Account for the fact that 32-bit targets on powerpc64 really use 64-bit
// registers in ptrace, but expose here 32-bit registers with a higher
// offset.
uint64_t offset = GetRegisterOffset(reg_to_write);
offset &= ~(sizeof(uintptr_t) - 1);
return monitor.WriteRegisterValue(m_thread.GetID(),
offset,
GetRegisterName(reg_to_write),
value_to_write);
}
addr_t
RegisterContextPOSIXProcessMonitor_x86_64::GetWatchpointAddress(uint32_t hw_index)
{
addr_t wp_monitor_addr = LLDB_INVALID_ADDRESS;
if (hw_index < NumSupportedHardwareWatchpoints())
{
if (!IsWatchpointVacant(hw_index))
{
RegisterValue value;
if (ReadRegister(dr0 + hw_index, value))
wp_monitor_addr = value.GetAsUInt64();
}
}
return wp_monitor_addr;
}
Error
NativeRegisterContextLinux::WriteRegisterRaw(uint32_t reg_index, const RegisterValue ®_value)
{
uint32_t reg_to_write = reg_index;
RegisterValue value_to_write = reg_value;
// Check if this is a subregister of a full register.
const RegisterInfo *reg_info = GetRegisterInfoAtIndex(reg_index);
if (reg_info->invalidate_regs && (reg_info->invalidate_regs[0] != LLDB_INVALID_REGNUM))
{
Error error;
RegisterValue full_value;
uint32_t full_reg = reg_info->invalidate_regs[0];
const RegisterInfo *full_reg_info = GetRegisterInfoAtIndex(full_reg);
// Read the full register.
error = ReadRegister(full_reg_info, full_value);
if (error.Fail ())
return error;
lldb::ByteOrder byte_order = GetByteOrder();
uint8_t dst[RegisterValue::kMaxRegisterByteSize];
// Get the bytes for the full register.
const uint32_t dest_size = full_value.GetAsMemoryData (full_reg_info,
dst,
sizeof(dst),
byte_order,
error);
if (error.Success() && dest_size)
{
uint8_t src[RegisterValue::kMaxRegisterByteSize];
// Get the bytes for the source data.
const uint32_t src_size = reg_value.GetAsMemoryData (reg_info, src, sizeof(src), byte_order, error);
if (error.Success() && src_size && (src_size < dest_size))
{
// Copy the src bytes to the destination.
memcpy (dst + (reg_info->byte_offset & 0x1), src, src_size);
// Set this full register as the value to write.
value_to_write.SetBytes(dst, full_value.GetByteSize(), byte_order);
value_to_write.SetType(full_reg_info);
reg_to_write = full_reg;
}
}
}
const RegisterInfo *const register_to_write_info_p = GetRegisterInfoAtIndex (reg_to_write);
assert (register_to_write_info_p && "register to write does not have valid RegisterInfo");
if (!register_to_write_info_p)
return Error("NativeRegisterContextLinux::%s failed to get RegisterInfo for write register index %" PRIu32, __FUNCTION__, reg_to_write);
return DoWriteRegisterValue(reg_info->byte_offset, reg_info->name, reg_value);
}
static bool WriteRegisterCallback(EmulateInstruction *instruction, void *baton,
const EmulateInstruction::Context &context,
const RegisterInfo *reg_info,
const RegisterValue ®_value) {
if (reg_info->kinds[lldb::eRegisterKindDWARF] == dwarf_bad_mips64) {
EmulatorBaton *emulator_baton = static_cast<EmulatorBaton *>(baton);
emulator_baton->m_watch_hit_addr = reg_value.GetAsUInt64();
}
return true;
}
bool
RegisterContextCorePOSIX_mips64::ReadRegister(const RegisterInfo *reg_info, RegisterValue &value)
{
const uint32_t reg = reg_info->kinds[lldb::eRegisterKindLLDB];
lldb::offset_t offset = reg_info->byte_offset;
if (reg == syn_pc_mips64)
{
// Synthetic PC is the sum of:
// (a) GP reg PC
assert(reg_info->kinds[lldb::eRegisterKindGeneric] == LLDB_REGNUM_GENERIC_PC);
const RegisterInfo *pc_reg_info = GetRegisterInfoAtIndex(gpr_pc_mips64);
RegisterValue reg_value;
if (!ReadRegister(pc_reg_info, reg_value))
return false;
uint64_t v = reg_value.GetAsUInt64();
// (b) Cap reg PCC base
const RegisterInfo *pcc_reg_info = GetRegisterInfoAtIndex(cap_pcc_mips64);
assert(pcc_reg_info->byte_size == 32);
offset = pcc_reg_info->byte_offset + 16;
uint64_t pcc_base = m_cr.GetMaxU64(&offset, 8);
if (offset == pcc_reg_info->byte_offset + 24)
v += pcc_base;
// (c) Offset if Cause indicates exception occurred in branch delay slot
if (m_in_bd == lldb_private::eLazyBoolCalculate)
m_in_bd = CauseBD() ? lldb_private::eLazyBoolYes : lldb_private::eLazyBoolNo;
if (m_in_bd == lldb_private::eLazyBoolYes)
v += 4;
value = v;
return true;
}
else if (reg <= gpr_dummy_mips64)
{
uint64_t v = m_gpr.GetMaxU64(&offset, reg_info->byte_size);
if (offset == reg_info->byte_offset + reg_info->byte_size)
{
value = v;
return true;
}
}
else
{
uint8_t buf[32];
assert(reg_info->byte_size == 32);
if (m_cr.CopyData(offset, 32, buf) == reg_info->byte_size)
{
value.SetBytes(buf, 32, m_cr.GetByteOrder());
return true;
}
}
return false;
}
bool
RegisterContextWindows_x86::ReadRegister(const RegisterInfo *reg_info, RegisterValue ®_value)
{
if (!CacheAllRegisterValues())
return false;
switch (reg_info->kinds[eRegisterKindLLDB])
{
case lldb_eax_i386:
reg_value.SetUInt32(m_context.Eax);
break;
case lldb_ebx_i386:
reg_value.SetUInt32(m_context.Ebx);
break;
case lldb_ecx_i386:
reg_value.SetUInt32(m_context.Ecx);
break;
case lldb_edx_i386:
reg_value.SetUInt32(m_context.Edx);
break;
case lldb_edi_i386:
reg_value.SetUInt32(m_context.Edi);
break;
case lldb_esi_i386:
reg_value.SetUInt32(m_context.Esi);
break;
case lldb_ebp_i386:
reg_value.SetUInt32(m_context.Ebp);
break;
case lldb_esp_i386:
reg_value.SetUInt32(m_context.Esp);
break;
case lldb_eip_i386:
reg_value.SetUInt32(m_context.Eip);
break;
case lldb_eflags_i386:
reg_value.SetUInt32(m_context.EFlags);
break;
}
return true;
}
bool
RegisterContextMemory::ReadRegister (const RegisterInfo *reg_info, RegisterValue ®_value)
{
const uint32_t reg_num = reg_info->kinds[eRegisterKindLLDB];
if (!m_reg_valid[reg_num])
{
if (!ReadAllRegisterValues(m_reg_data.GetSharedDataBuffer ()))
return false;
}
const bool partial_data_ok = false;
return reg_value.SetValueFromData(reg_info, m_reg_data, reg_info->byte_offset, partial_data_ok).Success();
}
Error
NativeRegisterContextLinux_mips64::DoReadRegisterValue(uint32_t offset,
const char* reg_name,
uint32_t size,
RegisterValue &value)
{
GPR_linux_mips regs;
::memset(®s, 0, sizeof(GPR_linux_mips));
// Clear all bits in RegisterValue before writing actual value read from ptrace to avoid garbage value in 32-bit MSB
value.SetBytes((void *)(((unsigned char *)®s) + offset), 8, GetByteOrder());
Error error = NativeProcessLinux::PtraceWrapper(PTRACE_GETREGS, m_thread.GetID(), NULL, ®s, sizeof regs);
if (error.Success())
{
lldb_private::ArchSpec arch;
if (m_thread.GetProcess()->GetArchitecture(arch))
value.SetBytes((void *)(((unsigned char *)®s) + offset + 4 * (arch.GetMachine() == llvm::Triple::mips)), arch.GetFlags() & lldb_private::ArchSpec::eMIPSABI_O32 ? 4 : 8, arch.GetByteOrder());
else
error.SetErrorString("failed to get architecture");
}
return error;
}
bool UnwindAssemblyInstEmulation::GetRegisterValue(const RegisterInfo ®_info,
RegisterValue ®_value) {
const uint64_t reg_id = MakeRegisterKindValuePair(reg_info);
RegisterValueMap::const_iterator pos = m_register_values.find(reg_id);
if (pos != m_register_values.end()) {
reg_value = pos->second;
return true; // We had a real value that comes from an opcode that wrote
// to it...
}
// We are making up a value that is recognizable...
reg_value.SetUInt(reg_id, reg_info.byte_size);
return false;
}
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;
}
Error
NativeRegisterContextLinux_mips64::DoWriteRegisterValue(uint32_t offset,
const char* reg_name,
const RegisterValue &value)
{
elf_gregset_t regs;
Error error = NativeProcessLinux::PtraceWrapper(PTRACE_GETREGS, m_thread.GetID(), NULL, ®s, sizeof regs);
if (error.Success())
{
::memcpy((void *)(((unsigned char *)(®s)) + offset), value.GetBytes(), 8);
error = NativeProcessLinux::PtraceWrapper(PTRACE_SETREGS, m_thread.GetID(), NULL, ®s, sizeof regs);
}
return error;
}
bool
RegisterContextPOSIXProcessMonitor_arm::ReadRegister(const RegisterInfo *reg_info, RegisterValue &value)
{
if (!reg_info)
return false;
const uint32_t reg = reg_info->kinds[eRegisterKindLLDB];
if (IsFPR(reg))
{
if (!ReadFPR())
return false;
}
else
{
return ReadRegister(reg, value);
}
// Get pointer to m_fpr variable and set the data from it.
assert (reg_info->byte_offset < sizeof m_fpr);
uint8_t *src = (uint8_t *)&m_fpr + reg_info->byte_offset;
switch (reg_info->byte_size)
{
case 2:
value.SetUInt16(*(uint16_t *)src);
return true;
case 4:
value.SetUInt32(*(uint32_t *)src);
return true;
case 8:
value.SetUInt64(*(uint64_t *)src);
return true;
default:
assert(false && "Unhandled data size.");
return false;
}
}
Error
NativeRegisterContextLinux::DoWriteRegisterValue(uint32_t offset,
const char* reg_name,
const RegisterValue &value)
{
Log *log (ProcessPOSIXLog::GetLogIfAllCategoriesSet (POSIX_LOG_REGISTERS));
void* buf = reinterpret_cast<void *>(value.GetAsUInt64());
if (log)
log->Printf ("NativeRegisterContextLinux::%s() reg %s: %p", __FUNCTION__, reg_name, buf);
return NativeProcessLinux::PtraceWrapper(
PTRACE_POKEUSER, m_thread.GetID(), reinterpret_cast<void *>(offset), buf);
}
bool
EmulateInstruction::WriteRegisterDefault (EmulateInstruction *instruction,
void *baton,
const Context &context,
const RegisterInfo *reg_info,
const RegisterValue ®_value)
{
StreamFile strm (stdout, false);
strm.Printf (" Write to Register (name = %s, value = " , reg_info->name);
reg_value.Dump(&strm, reg_info, false, false, eFormatDefault);
strm.PutCString (", context = ");
context.Dump (strm, instruction);
strm.EOL();
return true;
}
bool RegisterContextPOSIXProcessMonitor_powerpc::WriteRegister(
const RegisterInfo *reg_info, const RegisterValue &value) {
const uint32_t reg = reg_info->kinds[eRegisterKindLLDB];
if (IsGPR(reg)) {
return WriteRegister(reg, value);
} else if (IsFPR(reg)) {
assert(reg_info->byte_offset < sizeof(m_fpr_powerpc));
uint8_t *dst = (uint8_t *)&m_fpr_powerpc + reg_info->byte_offset;
*(uint64_t *)dst = value.GetAsUInt64();
return WriteFPR();
}
return false;
}
bool UnwindAssemblyInstEmulation::ReadRegister(EmulateInstruction *instruction,
const RegisterInfo *reg_info,
RegisterValue ®_value) {
bool synthetic = GetRegisterValue(*reg_info, reg_value);
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_UNWIND));
if (log && log->GetVerbose()) {
StreamString strm;
strm.Printf("UnwindAssemblyInstEmulation::ReadRegister (name = \"%s\") => "
"synthetic_value = %i, value = ",
reg_info->name, synthetic);
reg_value.Dump(&strm, reg_info, false, false, eFormatDefault);
log->PutString(strm.GetString());
}
return true;
}