yuzu/unicorn
1
0
Fork 0
mirror of https://github.com/yuzu-emu/unicorn.git synced 2025-07-09 12:40:44 +00:00
Code Issues Packages Projects Releases Wiki Activity

target-i386: Split fxsave/fxrstor implementation

Browse source 
We will be able to reuse these pieces for XSAVE/XRSTOR.

Backports commit 64dbaff09bb768dbbb13142862554f18ab642866 from qemu
This commit is contained in:
Richard Henderson 2018-02-20 11:56:33 -05:00 committed by Lioncash
parent a4bf026460
commit b490486028
No known key found for this signature in database
GPG key ID: 4E3C3CC1031BA9C7
3 changed files with 103 additions and 85 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

152
qemu/target-i386/fpu_helper.c
View file

@ -1144,90 +1144,89 @@ void cpu_x86_frstor(CPUX86State *env, target_ulong ptr, int data32)
} }
#endif #endif
static void do_fxsave(CPUX86State *env, target_ulong ptr, int data64, static void do_xsave_fpu(CPUX86State *env, target_ulong ptr, uintptr_t ra)
uintptr_t retaddr)
{ {
int fpus, fptag, i, nb_xmm_regs; int fpus, fptag, i;
floatx80 tmp;
target_ulong addr; target_ulong addr;
/* The operand must be 16 byte aligned */
if (ptr & 0xf) {
raise_exception_ra(env, EXCP0D_GPF, retaddr);
}
fpus = (env->fpus & ~0x3800) | (env->fpstt & 0x7) << 11; fpus = (env->fpus & ~0x3800) | (env->fpstt & 0x7) << 11;
fptag = 0; fptag = 0;
for (i = 0; i < 8; i++) { for (i = 0; i < 8; i++) {
fptag |= (env->fptags[i] << i); fptag |= (env->fptags[i] << i);
} }
cpu_stw_data_ra(env, ptr, env->fpuc, retaddr); cpu_stw_data_ra(env, ptr, env->fpuc, ra);
cpu_stw_data_ra(env, ptr + 2, fpus, retaddr); cpu_stw_data_ra(env, ptr + 2, fpus, ra);
cpu_stw_data_ra(env, ptr + 4, fptag ^ 0xff, retaddr); cpu_stw_data_ra(env, ptr + 4, fptag ^ 0xff, ra);
#ifdef TARGET_X86_64
if (data64) { /* In 32-bit mode this is eip, sel, dp, sel.
cpu_stq_data_ra(env, ptr + 0x08, 0, retaddr); /* rip */ In 64-bit mode this is rip, rdp.
cpu_stq_data_ra(env, ptr + 0x10, 0, retaddr); /* rdp */ But in either case we don't write actual data, just zeros. */
} else cpu_stq_data_ra(env, ptr + 0x08, 0, ra); /* eip+sel; rip */
#endif cpu_stq_data_ra(env, ptr + 0x10, 0, ra); /* edp+sel; rdp */
{
cpu_stl_data_ra(env, ptr + 0x08, 0, retaddr); /* eip */
cpu_stl_data_ra(env, ptr + 0x0c, 0, retaddr); /* sel */
cpu_stl_data_ra(env, ptr + 0x10, 0, retaddr); /* dp */
cpu_stl_data_ra(env, ptr + 0x14, 0, retaddr); /* sel */
}
addr = ptr + 0x20; addr = ptr + 0x20;
for (i = 0; i < 8; i++) { for (i = 0; i < 8; i++) {
tmp = ST(i); floatx80 tmp = ST(i);
helper_fstt(env, tmp, addr, retaddr); helper_fstt(env, tmp, addr, ra);
addr += 16; addr += 16;
} }
}
if (env->cr[4] & CR4_OSFXSR_MASK) { static void do_xsave_mxcsr(CPUX86State *env, target_ulong ptr, uintptr_t ra)
/* XXX: finish it */ {
cpu_stl_data_ra(env, ptr + 0x18, env->mxcsr, retaddr); /* mxcsr */ cpu_stl_data_ra(env, ptr + 0x18, env->mxcsr, ra); /* mxcsr */
cpu_stl_data_ra(env, ptr + 0x1c, 0x0000ffff, retaddr); /* mxcsr_mask */ cpu_stl_data_ra(env, ptr + 0x1c, 0x0000ffff, ra); /* mxcsr_mask */
}
static void do_xsave_sse(CPUX86State *env, target_ulong ptr, uintptr_t ra)
{
int i, nb_xmm_regs;
target_ulong addr;
if (env->hflags & HF_CS64_MASK) { if (env->hflags & HF_CS64_MASK) {
nb_xmm_regs = 16; nb_xmm_regs = 16;
} else { } else {
nb_xmm_regs = 8; nb_xmm_regs = 8;
} }
addr = ptr + 0xa0; addr = ptr + 0xa0;
for (i = 0; i < nb_xmm_regs; i++) {
cpu_stq_data_ra(env, addr, env->xmm_regs[i].ZMM_Q(0), ra);
cpu_stq_data_ra(env, addr + 8, env->xmm_regs[i].ZMM_Q(1), ra);
addr += 16;
}
}
void helper_fxsave(CPUX86State *env, target_ulong ptr)
{
uintptr_t ra = GETPC();
/* The operand must be 16 byte aligned */
if (ptr & 0xf) {
raise_exception_ra(env, EXCP0D_GPF, ra);
}
do_xsave_fpu(env, ptr, ra);
if (env->cr[4] & CR4_OSFXSR_MASK) {
do_xsave_mxcsr(env, ptr, ra);
/* Fast FXSAVE leaves out the XMM registers */ /* Fast FXSAVE leaves out the XMM registers */
if (!(env->efer & MSR_EFER_FFXSR) if (!(env->efer & MSR_EFER_FFXSR)
|| (env->hflags & HF_CPL_MASK) || (env->hflags & HF_CPL_MASK)
|| !(env->hflags & HF_LMA_MASK)) { || !(env->hflags & HF_LMA_MASK)) {
for (i = 0; i < nb_xmm_regs; i++) { do_xsave_sse(env, ptr, ra);
cpu_stq_data_ra(env, addr, env->xmm_regs[i].ZMM_Q(0), retaddr);
cpu_stq_data_ra(env, addr + 8, env->xmm_regs[i].ZMM_Q(1), retaddr);
addr += 16;
}
} }
} }
} }
void helper_fxsave(CPUX86State *env, target_ulong ptr, int data64) static void do_xrstor_fpu(CPUX86State *env, target_ulong ptr, uintptr_t ra)
{ {
do_fxsave(env, ptr, data64, GETPC()); int i, fpus, fptag;
}
static void do_fxrstor(CPUX86State *env, target_ulong ptr, int data64,
uintptr_t retaddr)
{
int i, fpus, fptag, nb_xmm_regs;
floatx80 tmp;
target_ulong addr; target_ulong addr;
/* The operand must be 16 byte aligned */ cpu_set_fpuc(env, cpu_lduw_data_ra(env, ptr, ra));
if (ptr & 0xf) { fpus = cpu_lduw_data_ra(env, ptr + 2, ra);
raise_exception_ra(env, EXCP0D_GPF, retaddr); fptag = cpu_lduw_data_ra(env, ptr + 4, ra);
}
cpu_set_fpuc(env, cpu_lduw_data_ra(env, ptr, retaddr));
fpus = cpu_lduw_data_ra(env, ptr + 2, retaddr);
fptag = cpu_lduw_data_ra(env, ptr + 4, retaddr);
env->fpstt = (fpus >> 11) & 7; env->fpstt = (fpus >> 11) & 7;
env->fpus = fpus & ~0x3800; env->fpus = fpus & ~0x3800;
fptag ^= 0xff; fptag ^= 0xff;
@ -1237,37 +1236,56 @@ static void do_fxrstor(CPUX86State *env, target_ulong ptr, int data64,
addr = ptr + 0x20; addr = ptr + 0x20;
for (i = 0; i < 8; i++) { for (i = 0; i < 8; i++) {
tmp = helper_fldt(env, addr, retaddr); floatx80 tmp = helper_fldt(env, addr, ra);
ST(i) = tmp; ST(i) = tmp;
addr += 16; addr += 16;
} }
}
static void do_xrstor_mxcsr(CPUX86State *env, target_ulong ptr, uintptr_t ra)
{
cpu_set_mxcsr(env, cpu_ldl_data_ra(env, ptr + 0x18, ra));
}
static void do_xrstor_sse(CPUX86State *env, target_ulong ptr, uintptr_t ra)
{
int i, nb_xmm_regs;
target_ulong addr;
if (env->cr[4] & CR4_OSFXSR_MASK) {
/* XXX: finish it */
cpu_set_mxcsr(env, cpu_ldl_data_ra(env, ptr + 0x18, retaddr));
/* cpu_ldl_data_ra(env, ptr + 0x1c, retaddr); */
if (env->hflags & HF_CS64_MASK) { if (env->hflags & HF_CS64_MASK) {
nb_xmm_regs = 16; nb_xmm_regs = 16;
} else { } else {
nb_xmm_regs = 8; nb_xmm_regs = 8;
} }
addr = ptr + 0xa0; addr = ptr + 0xa0;
/* Fast FXRESTORE leaves out the XMM registers */
if (!(env->efer & MSR_EFER_FFXSR)
|| (env->hflags & HF_CPL_MASK)
|| !(env->hflags & HF_LMA_MASK)) {
for (i = 0; i < nb_xmm_regs; i++) { for (i = 0; i < nb_xmm_regs; i++) {
env->xmm_regs[i].ZMM_Q(0) = cpu_ldq_data_ra(env, addr, retaddr); env->xmm_regs[i].ZMM_Q(0) = cpu_ldq_data_ra(env, addr, ra);
env->xmm_regs[i].ZMM_Q(1) = cpu_ldq_data_ra(env, addr + 8, retaddr); env->xmm_regs[i].ZMM_Q(1) = cpu_ldq_data_ra(env, addr + 8, ra);
addr += 16; addr += 16;
} }
} }
}
void helper_fxrstor(CPUX86State *env, target_ulong ptr)
{
uintptr_t ra = GETPC();
/* The operand must be 16 byte aligned */
if (ptr & 0xf) {
raise_exception_ra(env, EXCP0D_GPF, ra);
} }
void helper_fxrstor(CPUX86State *env, target_ulong ptr, int data64) do_xrstor_fpu(env, ptr, ra);
{
do_fxrstor(env, ptr, data64, GETPC()); if (env->cr[4] & CR4_OSFXSR_MASK) {
do_xrstor_mxcsr(env, ptr, ra);
/* Fast FXRSTOR leaves out the XMM registers */
if (!(env->efer & MSR_EFER_FFXSR)
|| (env->hflags & HF_CPL_MASK)
|| !(env->hflags & HF_LMA_MASK)) {
do_xrstor_sse(env, ptr, ra);
}
}
} }
void cpu_get_fp80(uint64_t *pmant, uint16_t *pexp, floatx80 f) void cpu_get_fp80(uint64_t *pmant, uint16_t *pexp, floatx80 f)

4
qemu/target-i386/helper.h
View file

@ -187,8 +187,8 @@ DEF_HELPER_3(fstenv, void, env, tl, int)
DEF_HELPER_3(fldenv, void, env, tl, int) DEF_HELPER_3(fldenv, void, env, tl, int)
DEF_HELPER_3(fsave, void, env, tl, int) DEF_HELPER_3(fsave, void, env, tl, int)
DEF_HELPER_3(frstor, void, env, tl, int) DEF_HELPER_3(frstor, void, env, tl, int)
DEF_HELPER_3(fxsave, void, env, tl, int) DEF_HELPER_FLAGS_2(fxsave, TCG_CALL_NO_WG, void, env, tl)
DEF_HELPER_3(fxrstor, void, env, tl, int) DEF_HELPER_FLAGS_2(fxrstor, TCG_CALL_NO_WG, void, env, tl)
DEF_HELPER_FLAGS_1(clz_x86, TCG_CALL_NO_RWG_SE, tl, tl) DEF_HELPER_FLAGS_1(clz_x86, TCG_CALL_NO_RWG_SE, tl, tl)

4
qemu/target-i386/translate.c
View file

@ -8160,7 +8160,7 @@ static target_ulong disas_insn(CPUX86State *env, DisasContext *s,
gen_lea_modrm(env, s, modrm); gen_lea_modrm(env, s, modrm);
gen_update_cc_op(s); gen_update_cc_op(s);
gen_jmp_im(s, pc_start - s->cs_base); gen_jmp_im(s, pc_start - s->cs_base);
gen_helper_fxsave(tcg_ctx, cpu_env, cpu_A0, tcg_const_i32(tcg_ctx, dflag == MO_64)); gen_helper_fxsave(tcg_ctx, cpu_env, cpu_A0);
break; break;
case 1: /* fxrstor */ case 1: /* fxrstor */
if (mod == 3 || !(s->cpuid_features & CPUID_FXSR) || if (mod == 3 || !(s->cpuid_features & CPUID_FXSR) ||
@ -8173,7 +8173,7 @@ static target_ulong disas_insn(CPUX86State *env, DisasContext *s,
gen_lea_modrm(env, s, modrm); gen_lea_modrm(env, s, modrm);
gen_update_cc_op(s); gen_update_cc_op(s);
gen_jmp_im(s, pc_start - s->cs_base); gen_jmp_im(s, pc_start - s->cs_base);
gen_helper_fxrstor(tcg_ctx, cpu_env, cpu_A0, tcg_const_i32(tcg_ctx, dflag == MO_64)); gen_helper_fxrstor(tcg_ctx, cpu_env, cpu_A0);
break; break;
case 2: /* ldmxcsr */ case 2: /* ldmxcsr */
case 3: /* stmxcsr */ case 3: /* stmxcsr */