Status NativeRegisterContextLinux_mips64::WriteAllRegisterValues(
const lldb::DataBufferSP &data_sp) {
Status error;
if (!data_sp) {
error.SetErrorStringWithFormat(
"NativeRegisterContextLinux_mips64::%s invalid data_sp provided",
__FUNCTION__);
return error;
}
if (data_sp->GetByteSize() != REG_CONTEXT_SIZE) {
error.SetErrorStringWithFormat(
"NativeRegisterContextLinux_mips64::%s data_sp contained mismatched "
"data size, expected %" PRIu64 ", actual %" PRIu64,
__FUNCTION__, REG_CONTEXT_SIZE, data_sp->GetByteSize());
return error;
}
uint8_t *src = data_sp->GetBytes();
if (src == nullptr) {
error.SetErrorStringWithFormat("NativeRegisterContextLinux_mips64::%s "
"DataBuffer::GetBytes() returned a null "
"pointer",
__FUNCTION__);
return error;
}
::memcpy(&m_gpr, src, GetRegisterInfoInterface().GetGPRSize());
src += GetRegisterInfoInterface().GetGPRSize();
::memcpy(&m_fpr, src, GetFPRSize());
src += GetFPRSize();
::memcpy(&m_msa, src, sizeof(MSA_linux_mips));
error = WriteGPR();
if (!error.Success()) {
error.SetErrorStringWithFormat(
"NativeRegisterContextLinux_mips64::%s WriteGPR() failed",
__FUNCTION__);
return error;
}
error = WriteCP1();
if (!error.Success()) {
error.SetErrorStringWithFormat(
"NativeRegisterContextLinux_mips64::%s WriteCP1() failed",
__FUNCTION__);
return error;
}
return error;
}
bool
RegisterContextWindows_x86::WriteAllRegisterValues(const lldb::DataBufferSP &data_sp)
{
assert(data_sp->GetByteSize() >= sizeof(m_context));
memcpy(&m_context, data_sp->GetBytes(), sizeof(m_context));
TargetThreadWindows &wthread = static_cast<TargetThreadWindows &>(m_thread);
if (!::SetThreadContext(wthread.GetHostThread().GetNativeThread().GetSystemHandle(), &m_context))
return false;
return true;
}
bool
RegisterContextWindows_x86::ReadAllRegisterValues(lldb::DataBufferSP &data_sp)
{
if (!CacheAllRegisterValues())
return false;
if (data_sp->GetByteSize() < sizeof(m_context))
{
data_sp.reset(new DataBufferHeap(sizeof(CONTEXT), 0));
}
memcpy(data_sp->GetBytes(), &m_context, sizeof(m_context));
return true;
}
bool RegisterContextPOSIXProcessMonitor_arm64::WriteAllRegisterValues(
const lldb::DataBufferSP &data_sp) {
bool success = false;
if (data_sp && data_sp->GetByteSize() == REG_CONTEXT_SIZE) {
uint8_t *src = data_sp->GetBytes();
if (src) {
::memcpy(&m_gpr_arm64, src, GetGPRSize());
if (WriteGPR()) {
src += GetGPRSize();
::memcpy(&m_fpr, src, sizeof m_fpr);
success = WriteFPR();
}
}
}
return success;
}
bool RegisterContextPOSIXProcessMonitor_arm64::ReadAllRegisterValues(
lldb::DataBufferSP &data_sp) {
bool success = false;
data_sp.reset(new lldb_private::DataBufferHeap(REG_CONTEXT_SIZE, 0));
if (data_sp && ReadGPR() && ReadFPR()) {
uint8_t *dst = data_sp->GetBytes();
success = dst != 0;
if (success) {
::memcpy(dst, &m_gpr_arm64, GetGPRSize());
dst += GetGPRSize();
::memcpy(dst, &m_fpr, sizeof m_fpr);
}
}
return success;
}
ValueObjectConstResult::ValueObjectConstResult
(
ExecutionContextScope *exe_scope,
clang::ASTContext *clang_ast,
void *clang_type,
const ConstString &name,
const lldb::DataBufferSP &data_sp,
lldb::ByteOrder data_byte_order,
uint8_t data_addr_size,
lldb::addr_t address
) :
ValueObject (exe_scope),
m_clang_ast (clang_ast),
m_type_name (),
m_byte_size (0),
m_impl(this, address)
{
m_data.SetByteOrder(data_byte_order);
m_data.SetAddressByteSize(data_addr_size);
m_data.SetData(data_sp);
m_value.GetScalar() = (uintptr_t)data_sp->GetBytes();
m_value.SetValueType(Value::eValueTypeHostAddress);
m_value.SetContext(Value::eContextTypeClangType, clang_type);
m_name = name;
SetIsConstant ();
SetValueIsValid(true);
SetAddressTypeOfChildren(eAddressTypeLoad);
}
bool RegisterContextDarwin_arm64::ReadAllRegisterValues(
lldb::DataBufferSP &data_sp) {
data_sp.reset(new DataBufferHeap(REG_CONTEXT_SIZE, 0));
if (data_sp && ReadGPR(false) == KERN_SUCCESS &&
ReadFPU(false) == KERN_SUCCESS && ReadEXC(false) == KERN_SUCCESS) {
uint8_t *dst = data_sp->GetBytes();
::memcpy(dst, &gpr, sizeof(gpr));
dst += sizeof(gpr);
::memcpy(dst, &fpu, sizeof(fpu));
dst += sizeof(gpr);
::memcpy(dst, &exc, sizeof(exc));
return true;
}
return false;
}
Status NativeRegisterContextLinux_s390x::WriteAllRegisterValues(
const lldb::DataBufferSP &data_sp) {
Status error;
if (!data_sp) {
error.SetErrorStringWithFormat(
"NativeRegisterContextLinux_s390x::%s invalid data_sp provided",
__FUNCTION__);
return error;
}
if (data_sp->GetByteSize() != REG_CONTEXT_SIZE) {
error.SetErrorStringWithFormat(
"NativeRegisterContextLinux_s390x::%s data_sp contained mismatched "
"data size, expected %" PRIu64 ", actual %" PRIu64,
__FUNCTION__, REG_CONTEXT_SIZE, data_sp->GetByteSize());
return error;
}
uint8_t *src = data_sp->GetBytes();
if (src == nullptr) {
error.SetErrorStringWithFormat("NativeRegisterContextLinux_s390x::%s "
"DataBuffer::GetBytes() returned a null "
"pointer",
__FUNCTION__);
return error;
}
error = DoWriteGPR(src, sizeof(s390_regs));
src += sizeof(s390_regs);
if (error.Fail())
return error;
error = DoWriteFPR(src, sizeof(s390_fp_regs));
src += sizeof(s390_fp_regs);
if (error.Fail())
return error;
// Ignore errors if the regset is unsupported (happens on older kernels).
DoWriteRegisterSet(NT_S390_SYSTEM_CALL, src, 4);
src += 4;
return error;
}
Status NativeRegisterContextLinux_s390x::ReadAllRegisterValues(
lldb::DataBufferSP &data_sp) {
Status error;
data_sp.reset(new DataBufferHeap(REG_CONTEXT_SIZE, 0));
if (!data_sp) {
error.SetErrorStringWithFormat(
"failed to allocate DataBufferHeap instance of size %" PRIu64,
REG_CONTEXT_SIZE);
return error;
}
uint8_t *dst = data_sp->GetBytes();
if (dst == nullptr) {
error.SetErrorStringWithFormat("DataBufferHeap instance of size %" PRIu64
" returned a null pointer",
REG_CONTEXT_SIZE);
return error;
}
error = DoReadGPR(dst, sizeof(s390_regs));
dst += sizeof(s390_regs);
if (error.Fail())
return error;
error = DoReadFPR(dst, sizeof(s390_fp_regs));
dst += sizeof(s390_fp_regs);
if (error.Fail())
return error;
// Ignore errors if the regset is unsupported (happens on older kernels).
DoReadRegisterSet(NT_S390_SYSTEM_CALL, dst, 4);
dst += 4;
// To enable inferior function calls while the process is stopped in
// an interrupted system call, we need to clear the system call flag.
// It will be restored to its original value by WriteAllRegisterValues.
// Again we ignore error if the regset is unsupported.
uint32_t system_call = 0;
DoWriteRegisterSet(NT_S390_SYSTEM_CALL, &system_call, 4);
return error;
}
Error
NativeRegisterContextLinux_mips64::ReadAllRegisterValues (lldb::DataBufferSP &data_sp)
{
Error error;
data_sp.reset (new DataBufferHeap (REG_CONTEXT_SIZE, 0));
if (!data_sp)
{
error.SetErrorStringWithFormat ("failed to allocate DataBufferHeap instance of size %" PRIu64, REG_CONTEXT_SIZE);
return error;
}
error = ReadGPR();
if (!error.Success())
{
error.SetErrorString ("ReadGPR() failed");
return error;
}
error = ReadCP1();
if (!error.Success())
{
error.SetErrorString ("ReadCP1() failed");
return error;
}
uint8_t *dst = data_sp->GetBytes ();
if (dst == nullptr)
{
error.SetErrorStringWithFormat ("DataBufferHeap instance of size %" PRIu64 " returned a null pointer", REG_CONTEXT_SIZE);
return error;
}
::memcpy (dst, &m_gpr, GetRegisterInfoInterface ().GetGPRSize ());
dst += GetRegisterInfoInterface ().GetGPRSize ();
::memcpy (dst, &m_fpr, GetFPRSize ());
dst += GetFPRSize ();
::memcpy (dst, &m_msa, sizeof(MSA_linux_mips));
return error;
}
bool RegisterContextDarwin_arm64::WriteAllRegisterValues(
const lldb::DataBufferSP &data_sp) {
if (data_sp && data_sp->GetByteSize() == REG_CONTEXT_SIZE) {
const uint8_t *src = data_sp->GetBytes();
::memcpy(&gpr, src, sizeof(gpr));
src += sizeof(gpr);
::memcpy(&fpu, src, sizeof(fpu));
src += sizeof(gpr);
::memcpy(&exc, src, sizeof(exc));
uint32_t success_count = 0;
if (WriteGPR() == KERN_SUCCESS)
++success_count;
if (WriteFPU() == KERN_SUCCESS)
++success_count;
if (WriteEXC() == KERN_SUCCESS)
++success_count;
return success_count == 3;
}
return false;
}
size_t ObjectContainerUniversalMachO::GetModuleSpecifications(
const lldb_private::FileSpec &file, lldb::DataBufferSP &data_sp,
lldb::offset_t data_offset, lldb::offset_t file_offset,
lldb::offset_t file_size, lldb_private::ModuleSpecList &specs) {
const size_t initial_count = specs.GetSize();
DataExtractor data;
data.SetData(data_sp, data_offset, data_sp->GetByteSize());
if (ObjectContainerUniversalMachO::MagicBytesMatch(data)) {
llvm::MachO::fat_header header;
std::vector<llvm::MachO::fat_arch> fat_archs;
if (ParseHeader(data, header, fat_archs)) {
for (const llvm::MachO::fat_arch &fat_arch : fat_archs) {
const lldb::offset_t slice_file_offset = fat_arch.offset + file_offset;
if (fat_arch.offset < file_size && file_size > slice_file_offset) {
ObjectFile::GetModuleSpecifications(
file, slice_file_offset, file_size - slice_file_offset, specs);
}
}
}
}
return specs.GetSize() - initial_count;
}
