uint32_t dst_len, lldb::ByteOrder dst_byte_order,
Status &error) const;
- uint32_t SetFromMemoryData(const RegisterInfo *reg_info, const void *src,
+ uint32_t SetFromMemoryData(const RegisterInfo ®_info, const void *src,
uint32_t src_len, lldb::ByteOrder src_byte_order,
Status &error);
// 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.GetByteOrder(),
+ reg_value.SetFromMemoryData(*reg_info, src, src_len, process.GetByteOrder(),
error);
return error;
return false;
}
- if (data_Rt.SetFromMemoryData(&(*reg_info_Rt), buffer,
- reg_info_Rt->byte_size, eByteOrderLittle,
- error) == 0)
+ if (data_Rt.SetFromMemoryData(*reg_info_Rt, buffer, reg_info_Rt->byte_size,
+ eByteOrderLittle, error) == 0)
return false;
if (!vector && is_signed && !data_Rt.SignExtend(datasize))
return false;
}
- if (data_Rt2.SetFromMemoryData(&(*reg_info_Rt2), buffer,
+ if (data_Rt2.SetFromMemoryData(*reg_info_Rt2, buffer,
reg_info_Rt2->byte_size, eByteOrderLittle,
error) == 0)
return false;
if (!ReadMemory(context, address, buffer, reg_info_Rt->byte_size))
return false;
- if (data_Rt.SetFromMemoryData(&(*reg_info_Rt), buffer,
- reg_info_Rt->byte_size, eByteOrderLittle,
- error) == 0)
+ if (data_Rt.SetFromMemoryData(*reg_info_Rt, buffer, reg_info_Rt->byte_size,
+ eByteOrderLittle, error) == 0)
return false;
if (!WriteRegister(context, *reg_info_Rt, data_Rt))
return Status("failed - register wasn't recognized to be a GPR or an FPR, "
"write strategy unknown");
- reg_value.SetFromMemoryData(reg_info, src, reg_info->byte_size,
+ reg_value.SetFromMemoryData(*reg_info, src, reg_info->byte_size,
eByteOrderLittle, error);
return error;
// SVE is disabled take legacy route for FPU register access
offset -= GetGPRSize();
if (offset < m_fpr_data.GetByteSize()) {
- value.SetFromMemoryData(reg_info, m_fpr_data.GetDataStart() + offset,
+ value.SetFromMemoryData(*reg_info, m_fpr_data.GetDataStart() + offset,
reg_info->byte_size, lldb::eByteOrderLittle,
error);
return error.Success();
assert(sve_reg_num != LLDB_INVALID_REGNUM);
assert(offset < m_sve_data.GetByteSize());
- value.SetFromMemoryData(reg_info, GetSVEBuffer(offset),
+ value.SetFromMemoryData(*reg_info, GetSVEBuffer(offset),
reg_info->byte_size, lldb::eByteOrderLittle,
error);
}
assert(offset < m_sve_data.GetByteSize());
src = GetSVEBuffer(offset);
}
- value.SetFromMemoryData(reg_info, src, byte_size, lldb::eByteOrderLittle,
+ value.SetFromMemoryData(*reg_info, src, byte_size, lldb::eByteOrderLittle,
error);
} break;
case SVEState::Full:
offset = CalculateSVEOffset(reg_info);
assert(offset < m_sve_data.GetByteSize());
- value.SetFromMemoryData(reg_info, GetSVEBuffer(offset),
+ value.SetFromMemoryData(*reg_info, GetSVEBuffer(offset),
reg_info->byte_size, lldb::eByteOrderLittle,
error);
break;
} else if (IsPAuth(reg)) {
offset = reg_info->byte_offset - m_register_info_up->GetPAuthOffset();
assert(offset < m_pac_data.GetByteSize());
- value.SetFromMemoryData(reg_info, m_pac_data.GetDataStart() + offset,
+ value.SetFromMemoryData(*reg_info, m_pac_data.GetDataStart() + offset,
reg_info->byte_size, lldb::eByteOrderLittle, error);
} else
return false;
}
Status error;
- value.SetFromMemoryData(reg_info, src + offset, reg_info->byte_size,
+ value.SetFromMemoryData(*reg_info, src + offset, reg_info->byte_size,
lldb::eByteOrderLittle, error);
return error.Success();
Status error;
return value.SetFromMemoryData(
- reg_info, combined_data.data(), combined_data.size(),
+ *reg_info, combined_data.data(), combined_data.size(),
m_reg_data.GetByteOrder(), error) == combined_data.size();
} else {
const bool partial_data_ok = false;
RegisterValue ®_value) {
Status error;
reg_value.SetFromMemoryData(
- reg_info, (const uint8_t *)&m_regs + reg_info->byte_offset,
+ *reg_info, (const uint8_t *)&m_regs + reg_info->byte_offset,
reg_info->byte_size, lldb::eByteOrderLittle, error);
return error.Success();
}
RegisterValue ®_value) {
Status error;
reg_value.SetFromMemoryData(
- reg_info, (const uint8_t *)&m_regs + reg_info->byte_offset,
+ *reg_info, (const uint8_t *)&m_regs + reg_info->byte_offset,
reg_info->byte_size, lldb::eByteOrderLittle, error);
return error.Success();
}
// 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,
+ reg_value.SetFromMemoryData(*reg_info, src, src_len,
process_sp->GetByteOrder(), error);
} else
error.SetErrorString("invalid process");
return bytes_copied;
}
-uint32_t RegisterValue::SetFromMemoryData(const RegisterInfo *reg_info,
+uint32_t RegisterValue::SetFromMemoryData(const RegisterInfo ®_info,
const void *src, uint32_t src_len,
lldb::ByteOrder src_byte_order,
Status &error) {
- if (reg_info == nullptr) {
- error.SetErrorString("invalid register info argument.");
- return 0;
- }
-
// Moving from addr into a register
//
// Case 1: src_len == dst_len
return 0;
}
- const uint32_t dst_len = reg_info->byte_size;
+ 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);
+ reg_info.name, dst_len);
return 0;
}
// register value
DataExtractor src_data(src, src_len, src_byte_order, 4);
- error = SetValueFromData(reg_info, src_data, 0, true);
+ error = SetValueFromData(®_info, src_data, 0, true);
if (error.Fail())
return 0;
RegisterValue Value;
Status ST;
Value.SetFromMemoryData(
- &Info, Bytes.data(), Bytes.size(),
+ Info, Bytes.data(), Bytes.size(),
Endian == support::little ? eByteOrderLittle : eByteOrderBig, ST);
if (ST.Fail())
return ST.ToError();