status_t
CpuStateX8664::UpdateDebugState(void* state, size_t size) const
{
if (size != sizeof(x86_64_debug_cpu_state))
return B_BAD_VALUE;
x86_64_debug_cpu_state* x64State = (x86_64_debug_cpu_state*)state;
x64State->rip = InstructionPointer();
x64State->rsp = StackPointer();
x64State->rbp = StackFramePointer();
x64State->rax = IntRegisterValue(X86_64_REGISTER_RAX);
x64State->rbx = IntRegisterValue(X86_64_REGISTER_RBX);
x64State->rcx = IntRegisterValue(X86_64_REGISTER_RCX);
x64State->rdx = IntRegisterValue(X86_64_REGISTER_RDX);
x64State->rsi = IntRegisterValue(X86_64_REGISTER_RSI);
x64State->rdi = IntRegisterValue(X86_64_REGISTER_RDI);
x64State->r8 = IntRegisterValue(X86_64_REGISTER_R8);
x64State->r9 = IntRegisterValue(X86_64_REGISTER_R9);
x64State->r10 = IntRegisterValue(X86_64_REGISTER_R10);
x64State->r11 = IntRegisterValue(X86_64_REGISTER_R11);
x64State->r12 = IntRegisterValue(X86_64_REGISTER_R12);
x64State->r13 = IntRegisterValue(X86_64_REGISTER_R13);
x64State->r14 = IntRegisterValue(X86_64_REGISTER_R14);
x64State->r15 = IntRegisterValue(X86_64_REGISTER_R15);
x64State->cs = IntRegisterValue(X86_64_REGISTER_CS);
x64State->ds = IntRegisterValue(X86_64_REGISTER_DS);
x64State->es = IntRegisterValue(X86_64_REGISTER_ES);
x64State->fs = IntRegisterValue(X86_64_REGISTER_FS);
x64State->gs = IntRegisterValue(X86_64_REGISTER_GS);
x64State->ss = IntRegisterValue(X86_64_REGISTER_SS);
for (int32 i = 0; i < 8; i++) {
*(long double*)(x64State->extended_registers.fp_registers[i].value)
= (long double)FloatRegisterValue(X86_64_REGISTER_ST0 + i);
if (IsRegisterSet(X86_64_REGISTER_MM0 + i)) {
memcpy(&x64State->extended_registers.mmx_registers[i],
&fMMXRegisters[i], sizeof(x86_64_fp_register));
}
}
for (int32 i = 0; i < 16; i++) {
if (IsRegisterSet(X86_64_REGISTER_XMM0 + i)) {
memcpy(&x64State->extended_registers.xmm_registers[i],
&fXMMRegisters[i], sizeof(x86_64_xmm_register));
} else {
memset(&x64State->extended_registers.xmm_registers[i],
0, sizeof(x86_64_xmm_register));
}
}
return B_OK;
}
bool
CpuStateX8664::GetRegisterValue(const Register* reg, BVariant& _value) const
{
int32 index = reg->Index();
if (!IsRegisterSet(index))
return false;
if (index >= X86_64_XMM_REGISTER_END)
return false;
if (BVariant::TypeIsInteger(reg->ValueType())) {
if (reg->BitSize() == 16)
_value.SetTo((uint16)fIntRegisters[index]);
else
_value.SetTo(fIntRegisters[index]);
} else if (BVariant::TypeIsFloat(reg->ValueType())) {
index -= X86_64_REGISTER_ST0;
if (reg->ValueType() == B_FLOAT_TYPE)
_value.SetTo((float)fFloatRegisters[index]);
else
_value.SetTo(fFloatRegisters[index]);
} else {
if (index >= X86_64_REGISTER_MM0 && index < X86_64_REGISTER_XMM0) {
index -= X86_64_REGISTER_MM0;
_value.SetTo(fMMXRegisters[index].value);
} else {
index -= X86_64_REGISTER_XMM0;
_value.SetTo(fXMMRegisters[index].value);
}
}
return true;
}
uint32
CpuStateX86::IntRegisterValue(int32 index) const
{
if (!IsRegisterSet(index) || index >= X86_INT_REGISTER_END)
return 0;
return fIntRegisters[index];
}
const void*
CpuStateX8664::XMMRegisterValue(int32 index) const
{
if (index < X86_64_REGISTER_XMM0 || index >= X86_64_XMM_REGISTER_END
|| !IsRegisterSet(index)) {
return NULL;
}
return fXMMRegisters[index - X86_64_REGISTER_XMM0].value;
}
const void*
CpuStateX8664::MMXRegisterValue(int32 index) const
{
if (index < X86_64_REGISTER_MM0 || index >= X86_64_MMX_REGISTER_END
|| !IsRegisterSet(index)) {
return 0;
}
return fMMXRegisters[index - X86_64_REGISTER_MM0].value;
}
double
CpuStateX8664::FloatRegisterValue(int32 index) const
{
if (index < X86_64_REGISTER_ST0 || index >= X86_64_FP_REGISTER_END
|| !IsRegisterSet(index)) {
return 0.0;
}
return fFloatRegisters[index - X86_64_REGISTER_ST0];
}
bool
CpuStateX86::GetRegisterValue(const Register* reg, BVariant& _value) const
{
int32 index = reg->Index();
if (!IsRegisterSet(index))
return false;
if (index >= X86_INT_REGISTER_END)
return false;
if (reg->BitSize() == 16)
_value.SetTo((uint16)fIntRegisters[index]);
else
_value.SetTo(fIntRegisters[index]);
return true;
}
target_addr_t
CpuStateX86::InstructionPointer() const
{
return IsRegisterSet(X86_REGISTER_EIP)
? IntRegisterValue(X86_REGISTER_EIP) : 0;
}
target_addr_t
CpuStateX8664::StackPointer() const
{
return IsRegisterSet(X86_64_REGISTER_RSP)
? IntRegisterValue(X86_64_REGISTER_RSP) : 0;
}
target_addr_t
CpuStateX86::StackFramePointer() const
{
return IsRegisterSet(X86_REGISTER_EBP)
? IntRegisterValue(X86_REGISTER_EBP) : 0;
}
