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

target/i386: Use env_cpu, env_archcpu

Browse source 
Cleanup in the boilerplate that each target must define.
Replace x86_env_get_cpu with env_archcpu. The combination
CPU(x86_env_get_cpu) should have used ENV_GET_CPU to begin;
use env_cpu now.

Backports commit 6aa9e42f27331be34e06d4d66f92f2272868f96a from qemu
This commit is contained in:
Richard Henderson 2019-06-12 11:44:00 -04:00 committed by Lioncash
parent b8bd543390
commit 187778c781
No known key found for this signature in database
GPG key ID: 4E3C3CC1031BA9C7
11 changed files with 45 additions and 55 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
qemu/hw/i386/pc.c
View file

@ -62,9 +62,9 @@ void cpu_smm_register(cpu_set_smm_t callback, void *arg)
void cpu_smm_update(CPUX86State *env) void cpu_smm_update(CPUX86State *env)
{ {
struct uc_struct *uc = x86_env_get_cpu(env)->parent_obj.uc; struct uc_struct *uc = env_archcpu(env)->parent_obj.uc;
if (smm_set && smm_arg && CPU(x86_env_get_cpu(env)) == uc->cpu) { if (smm_set && smm_arg && env_cpu(env) == uc->cpu) {
smm_set(!!(env->hflags & HF_SMM_MASK), smm_arg); smm_set(!!(env->hflags & HF_SMM_MASK), smm_arg);
} }
} }
@ -72,7 +72,7 @@ void cpu_smm_update(CPUX86State *env)
/* IRQ handling */ /* IRQ handling */
int cpu_get_pic_interrupt(CPUX86State *env) int cpu_get_pic_interrupt(CPUX86State *env)
{ {
X86CPU *cpu = x86_env_get_cpu(env); X86CPU *cpu = env_archcpu(env);
int intno; int intno;
intno = apic_get_interrupt(cpu->apic_state); intno = apic_get_interrupt(cpu->apic_state);

4
qemu/target/i386/bpt_helper.c
View file

@ -52,7 +52,7 @@ static inline int hw_breakpoint_len(unsigned long dr7, int index)
static int hw_breakpoint_insert(CPUX86State *env, int index) static int hw_breakpoint_insert(CPUX86State *env, int index)
{ {
CPUState *cs = CPU(x86_env_get_cpu(env)); CPUState *cs = env_cpu(env);
target_ulong dr7 = env->dr[7]; target_ulong dr7 = env->dr[7];
target_ulong drN = env->dr[index]; target_ulong drN = env->dr[index];
int err = 0; int err = 0;
@ -96,7 +96,7 @@ static int hw_breakpoint_insert(CPUX86State *env, int index)
static void hw_breakpoint_remove(CPUX86State *env, int index) static void hw_breakpoint_remove(CPUX86State *env, int index)
{ {
CPUState *cs = CPU(x86_env_get_cpu(env)); CPUState *cs = env_cpu(env);
switch (hw_breakpoint_type(env->dr[7], index)) { switch (hw_breakpoint_type(env->dr[7], index)) {
case DR7_TYPE_BP_INST: case DR7_TYPE_BP_INST:

4
qemu/target/i386/cpu.c
View file

@ -3743,8 +3743,8 @@ void cpu_x86_cpuid(CPUX86State *env, uint32_t index, uint32_t count,
uint32_t *eax, uint32_t *ebx, uint32_t *eax, uint32_t *ebx,
uint32_t *ecx, uint32_t *edx) uint32_t *ecx, uint32_t *edx)
{ {
X86CPU *cpu = x86_env_get_cpu(env); X86CPU *cpu = env_archcpu(env);
CPUState *cs = CPU(cpu); CPUState *cs = env_cpu(env);
uint32_t pkg_offset; uint32_t pkg_offset;
uint32_t limit; uint32_t limit;
uint32_t signature[3]; uint32_t signature[3];

5
qemu/target/i386/cpu.h
View file

@ -1398,11 +1398,6 @@ struct X86CPU {
bool cpu_globals_initialized; bool cpu_globals_initialized;
}; };
static inline X86CPU *x86_env_get_cpu(CPUX86State *env)
{
return container_of(env, X86CPU, env);
}
#define ENV_OFFSET offsetof(X86CPU, env) #define ENV_OFFSET offsetof(X86CPU, env)
#ifndef CONFIG_USER_ONLY #ifndef CONFIG_USER_ONLY

2
qemu/target/i386/excp_helper.c
View file

@ -92,7 +92,7 @@ static void QEMU_NORETURN raise_interrupt2(CPUX86State *env, int intno,
int next_eip_addend, int next_eip_addend,
uintptr_t retaddr) uintptr_t retaddr)
{ {
CPUState *cs = CPU(x86_env_get_cpu(env)); CPUState *cs = env_cpu(env);
if (!is_int) { if (!is_int) {
cpu_svm_check_intercept_param(env, SVM_EXIT_EXCP_BASE + intno, cpu_svm_check_intercept_param(env, SVM_EXIT_EXCP_BASE + intno,

2
qemu/target/i386/fpu_helper.c
View file

@ -1477,7 +1477,7 @@ void helper_xrstor(CPUX86State *env, target_ulong ptr, uint64_t rfbm)
env->pkru = 0; env->pkru = 0;
} }
if (env->pkru != old_pkru) { if (env->pkru != old_pkru) {
CPUState *cs = CPU(x86_env_get_cpu(env)); CPUState *cs = env_cpu(env);
tlb_flush(cs); tlb_flush(cs);
} }
} }

16
qemu/target/i386/helper.c
View file

@ -431,7 +431,7 @@ void x86_cpu_set_a20(X86CPU *cpu, int a20_state)
void cpu_x86_update_cr0(CPUX86State *env, uint32_t new_cr0) void cpu_x86_update_cr0(CPUX86State *env, uint32_t new_cr0)
{ {
X86CPU *cpu = x86_env_get_cpu(env); X86CPU *cpu = env_archcpu(env);
int pe_state; int pe_state;
#if defined(DEBUG_MMU) #if defined(DEBUG_MMU)
@ -475,20 +475,17 @@ void cpu_x86_update_cr0(CPUX86State *env, uint32_t new_cr0)
the PDPT */ the PDPT */
void cpu_x86_update_cr3(CPUX86State *env, target_ulong new_cr3) void cpu_x86_update_cr3(CPUX86State *env, target_ulong new_cr3)
{ {
X86CPU *cpu = x86_env_get_cpu(env);
env->cr[3] = new_cr3; env->cr[3] = new_cr3;
if (env->cr[0] & CR0_PG_MASK) { if (env->cr[0] & CR0_PG_MASK) {
#if defined(DEBUG_MMU) #if defined(DEBUG_MMU)
printf("CR3 update: CR3=" TARGET_FMT_lx "\n", new_cr3); printf("CR3 update: CR3=" TARGET_FMT_lx "\n", new_cr3);
#endif #endif
tlb_flush(CPU(cpu)); tlb_flush(env_cpu(env));
} }
} }
void cpu_x86_update_cr4(CPUX86State *env, uint32_t new_cr4) void cpu_x86_update_cr4(CPUX86State *env, uint32_t new_cr4)
{ {
X86CPU *cpu = x86_env_get_cpu(env);
uint32_t hflags; uint32_t hflags;
#if defined(DEBUG_MMU) #if defined(DEBUG_MMU)
@ -497,7 +494,7 @@ void cpu_x86_update_cr4(CPUX86State *env, uint32_t new_cr4)
if ((new_cr4 ^ env->cr[4]) & if ((new_cr4 ^ env->cr[4]) &
(CR4_PGE_MASK | CR4_PAE_MASK | CR4_PSE_MASK | (CR4_PGE_MASK | CR4_PAE_MASK | CR4_PSE_MASK |
CR4_SMEP_MASK | CR4_SMAP_MASK | CR4_LA57_MASK)) { CR4_SMEP_MASK | CR4_SMAP_MASK | CR4_LA57_MASK)) {
tlb_flush(CPU(cpu)); tlb_flush(env_cpu(env));
} }
/* Clear bits we're going to recompute. */ /* Clear bits we're going to recompute. */
@ -661,8 +658,8 @@ typedef struct MCEInjectionParams {
void cpu_report_tpr_access(CPUX86State *env, TPRAccess access) void cpu_report_tpr_access(CPUX86State *env, TPRAccess access)
{ {
X86CPU *cpu = x86_env_get_cpu(env); X86CPU *cpu = env_archcpu(env);
CPUState *cs = CPU(cpu); CPUState *cs = env_cpu(env);
if (tcg_enabled(env->uc)) { if (tcg_enabled(env->uc)) {
cpu_restore_state(cs, cs->mem_io_pc, false); cpu_restore_state(cs, cs->mem_io_pc, false);
@ -676,8 +673,7 @@ int cpu_x86_get_descr_debug(CPUX86State *env, unsigned int selector,
target_ulong *base, unsigned int *limit, target_ulong *base, unsigned int *limit,
unsigned int *flags) unsigned int *flags)
{ {
X86CPU *cpu = x86_env_get_cpu(env); CPUState *cs = env_cpu(env);
CPUState *cs = CPU(cpu);
SegmentCache *dt; SegmentCache *dt;
target_ulong ptr; target_ulong ptr;
uint32_t e1, e2; uint32_t e1, e2;

21
qemu/target/i386/misc_helper.c
View file

@ -134,7 +134,7 @@ target_ulong helper_read_crN(CPUX86State *env, int reg)
break; break;
case 8: case 8:
if (!(env->hflags2 & HF2_VINTR_MASK)) { if (!(env->hflags2 & HF2_VINTR_MASK)) {
val = cpu_get_apic_tpr(env->uc, x86_env_get_cpu(env)->apic_state); val = cpu_get_apic_tpr(env->uc, env_archcpu(env)->apic_state);
} else { } else {
val = env->v_tpr; val = env->v_tpr;
} }
@ -158,7 +158,7 @@ void helper_write_crN(CPUX86State *env, int reg, target_ulong t0)
break; break;
case 8: case 8:
if (!(env->hflags2 & HF2_VINTR_MASK)) { if (!(env->hflags2 & HF2_VINTR_MASK)) {
cpu_set_apic_tpr(env->uc, x86_env_get_cpu(env)->apic_state, (uint8_t)t0); cpu_set_apic_tpr(env->uc, env_archcpu(env)->apic_state, (uint8_t)t0);
} }
env->v_tpr = t0 & 0x0f; env->v_tpr = t0 & 0x0f;
break; break;
@ -179,7 +179,7 @@ void helper_lmsw(CPUX86State *env, target_ulong t0)
void helper_invlpg(CPUX86State *env, target_ulong addr) void helper_invlpg(CPUX86State *env, target_ulong addr)
{ {
X86CPU *cpu = x86_env_get_cpu(env); X86CPU *cpu = env_archcpu(env);
cpu_svm_check_intercept_param(env, SVM_EXIT_INVLPG, 0, GETPC()); cpu_svm_check_intercept_param(env, SVM_EXIT_INVLPG, 0, GETPC());
tlb_flush_page(CPU(cpu), addr); tlb_flush_page(CPU(cpu), addr);
@ -246,7 +246,7 @@ void helper_wrmsr(CPUX86State *env)
env->sysenter_eip = val; env->sysenter_eip = val;
break; break;
case MSR_IA32_APICBASE: case MSR_IA32_APICBASE:
cpu_set_apic_base(env->uc, x86_env_get_cpu(env)->apic_state, val); cpu_set_apic_base(env->uc, env_archcpu(env)->apic_state, val);
break; break;
case MSR_EFER: case MSR_EFER:
{ {
@ -403,7 +403,7 @@ void helper_rdmsr(CPUX86State *env)
val = env->sysenter_eip; val = env->sysenter_eip;
break; break;
case MSR_IA32_APICBASE: case MSR_IA32_APICBASE:
val = cpu_get_apic_base(env->uc, x86_env_get_cpu(env)->apic_state); val = cpu_get_apic_base(env->uc, env_archcpu(env)->apic_state);
break; break;
case MSR_EFER: case MSR_EFER:
val = env->efer; val = env->efer;
@ -560,7 +560,7 @@ static void do_hlt(X86CPU *cpu)
void helper_hlt(CPUX86State *env, int next_eip_addend) void helper_hlt(CPUX86State *env, int next_eip_addend)
{ {
X86CPU *cpu = x86_env_get_cpu(env); X86CPU *cpu = env_archcpu(env);
cpu_svm_check_intercept_param(env, SVM_EXIT_HLT, 0, GETPC()); cpu_svm_check_intercept_param(env, SVM_EXIT_HLT, 0, GETPC());
env->eip += next_eip_addend; env->eip += next_eip_addend;
@ -579,7 +579,7 @@ void helper_monitor(CPUX86State *env, target_ulong ptr)
void helper_mwait(CPUX86State *env, int next_eip_addend) void helper_mwait(CPUX86State *env, int next_eip_addend)
{ {
X86CPU *cpu; X86CPU *cpu = env_archcpu(env);
if ((uint32_t)env->regs[R_ECX] != 0) { if ((uint32_t)env->regs[R_ECX] != 0) {
raise_exception_ra(env, EXCP0D_GPF, GETPC()); raise_exception_ra(env, EXCP0D_GPF, GETPC());
@ -587,14 +587,13 @@ void helper_mwait(CPUX86State *env, int next_eip_addend)
cpu_svm_check_intercept_param(env, SVM_EXIT_MWAIT, 0, GETPC()); cpu_svm_check_intercept_param(env, SVM_EXIT_MWAIT, 0, GETPC());
env->eip += next_eip_addend; env->eip += next_eip_addend;
cpu = x86_env_get_cpu(env);
/* XXX: not complete but not completely erroneous */ /* XXX: not complete but not completely erroneous */
do_hlt(cpu); do_hlt(cpu);
} }
void helper_pause(CPUX86State *env, int next_eip_addend) void helper_pause(CPUX86State *env, int next_eip_addend)
{ {
X86CPU *cpu = x86_env_get_cpu(env); X86CPU *cpu = env_archcpu(env);
cpu_svm_check_intercept_param(env, SVM_EXIT_PAUSE, 0, GETPC()); cpu_svm_check_intercept_param(env, SVM_EXIT_PAUSE, 0, GETPC());
env->eip += next_eip_addend; env->eip += next_eip_addend;
@ -604,7 +603,7 @@ void helper_pause(CPUX86State *env, int next_eip_addend)
void helper_debug(CPUX86State *env) void helper_debug(CPUX86State *env)
{ {
CPUState *cs = CPU(x86_env_get_cpu(env)); CPUState *cs = env_cpu(env);
cs->exception_index = EXCP_DEBUG; cs->exception_index = EXCP_DEBUG;
cpu_loop_exit(cs); cpu_loop_exit(cs);
@ -624,7 +623,7 @@ uint64_t helper_rdpkru(CPUX86State *env, uint32_t ecx)
void helper_wrpkru(CPUX86State *env, uint32_t ecx, uint64_t val) void helper_wrpkru(CPUX86State *env, uint32_t ecx, uint64_t val)
{ {
CPUState *cs = CPU(x86_env_get_cpu(env)); CPUState *cs = env_cpu(env);
if ((env->cr[4] & CR4_PKE_MASK) == 0) { if ((env->cr[4] & CR4_PKE_MASK) == 0) {
raise_exception_err_ra(env, EXCP06_ILLOP, 0, GETPC()); raise_exception_err_ra(env, EXCP06_ILLOP, 0, GETPC());

14
qemu/target/i386/seg_helper.c
View file

@ -137,7 +137,7 @@ static inline void get_ss_esp_from_tss(CPUX86State *env, uint32_t *ss_ptr,
uint32_t *esp_ptr, int dpl, uint32_t *esp_ptr, int dpl,
uintptr_t retaddr) uintptr_t retaddr)
{ {
X86CPU *cpu = x86_env_get_cpu(env); X86CPU *cpu = env_archcpu(env);
int type, index, shift; int type, index, shift;
#if 0 #if 0
@ -830,7 +830,7 @@ static void do_interrupt_protected(CPUX86State *env, int intno, int is_int,
static inline target_ulong get_rsp_from_tss(CPUX86State *env, int level) static inline target_ulong get_rsp_from_tss(CPUX86State *env, int level)
{ {
X86CPU *cpu = x86_env_get_cpu(env); X86CPU *cpu = env_archcpu(env);
int index; int index;
#if 0 #if 0
@ -972,7 +972,7 @@ static void do_interrupt64(CPUX86State *env, int intno, int is_int,
#if defined(CONFIG_USER_ONLY) #if defined(CONFIG_USER_ONLY)
void helper_syscall(CPUX86State *env, int next_eip_addend) void helper_syscall(CPUX86State *env, int next_eip_addend)
{ {
CPUState *cs = CPU(x86_env_get_cpu(env)); CPUState *cs = env_cpu(env);
cs->exception_index = EXCP_SYSCALL; cs->exception_index = EXCP_SYSCALL;
env->exception_next_eip = env->eip + next_eip_addend; env->exception_next_eip = env->eip + next_eip_addend;
@ -1186,7 +1186,7 @@ static void do_interrupt_user(CPUX86State *env, int intno, int is_int,
static void handle_even_inj(CPUX86State *env, int intno, int is_int, static void handle_even_inj(CPUX86State *env, int intno, int is_int,
int error_code, int is_hw, int rm) int error_code, int is_hw, int rm)
{ {
CPUState *cs = CPU(x86_env_get_cpu(env)); CPUState *cs = env_cpu(env);
uint32_t event_inj = x86_ldl_phys(cs, env->vm_vmcb + offsetof(struct vmcb, uint32_t event_inj = x86_ldl_phys(cs, env->vm_vmcb + offsetof(struct vmcb,
control.event_inj)); control.event_inj));
@ -1326,7 +1326,7 @@ void x86_cpu_do_interrupt(CPUState *cs)
void do_interrupt_x86_hardirq(CPUX86State *env, int intno, int is_hw) void do_interrupt_x86_hardirq(CPUX86State *env, int intno, int is_hw)
{ {
do_interrupt_all(x86_env_get_cpu(env), intno, 0, 0, 0, is_hw); do_interrupt_all(env_archcpu(env), intno, 0, 0, 0, is_hw);
} }
bool x86_cpu_exec_interrupt(CPUState *cs, int interrupt_request) bool x86_cpu_exec_interrupt(CPUState *cs, int interrupt_request)
@ -1779,7 +1779,7 @@ void helper_lcall_protected(CPUX86State *env, int new_cs, target_ulong new_eip,
target_ulong ssp, old_ssp, offset, sp; target_ulong ssp, old_ssp, offset, sp;
LOG_PCALL("lcall %04x:" TARGET_FMT_lx " s=%d\n", new_cs, new_eip, shift); LOG_PCALL("lcall %04x:" TARGET_FMT_lx " s=%d\n", new_cs, new_eip, shift);
LOG_PCALL_STATE(CPU(x86_env_get_cpu(env))); LOG_PCALL_STATE(env_cpu(env));
if ((new_cs & 0xfffc) == 0) { if ((new_cs & 0xfffc) == 0) {
raise_exception_err_ra(env, EXCP0D_GPF, 0, GETPC()); raise_exception_err_ra(env, EXCP0D_GPF, 0, GETPC());
} }
@ -2184,7 +2184,7 @@ static inline void helper_ret_protected(CPUX86State *env, int shift,
} }
LOG_PCALL("lret new %04x:" TARGET_FMT_lx " s=%d addend=0x%x\n", LOG_PCALL("lret new %04x:" TARGET_FMT_lx " s=%d addend=0x%x\n",
new_cs, new_eip, shift, addend); new_cs, new_eip, shift, addend);
LOG_PCALL_STATE(CPU(x86_env_get_cpu(env))); LOG_PCALL_STATE(env_cpu(env));
if ((new_cs & 0xfffc) == 0) { if ((new_cs & 0xfffc) == 0) {
raise_exception_err_ra(env, EXCP0D_GPF, new_cs & 0xfffc, retaddr); raise_exception_err_ra(env, EXCP0D_GPF, new_cs & 0xfffc, retaddr);
} }

4
qemu/target/i386/smm_helper.c
View file

@ -203,8 +203,8 @@ void do_smm_enter(X86CPU *cpu)
void helper_rsm(CPUX86State *env) void helper_rsm(CPUX86State *env)
{ {
X86CPU *cpu = x86_env_get_cpu(env); X86CPU *cpu = env_archcpu(env);
CPUState *cs = CPU(cpu); CPUState *cs = env_cpu(env);
target_ulong sm_state; target_ulong sm_state;
int i, offset; int i, offset;
uint32_t val; uint32_t val;

22
qemu/target/i386/svm_helper.c
View file

@ -85,7 +85,7 @@ void helper_svm_check_io(CPUX86State *env, uint32_t port, uint32_t param,
static inline void svm_save_seg(CPUX86State *env, hwaddr addr, static inline void svm_save_seg(CPUX86State *env, hwaddr addr,
const SegmentCache *sc) const SegmentCache *sc)
{ {
CPUState *cs = CPU(x86_env_get_cpu(env)); CPUState *cs = env_cpu(env);
x86_stw_phys(cs, addr + offsetof(struct vmcb_seg, selector), x86_stw_phys(cs, addr + offsetof(struct vmcb_seg, selector),
sc->selector); sc->selector);
@ -100,7 +100,7 @@ static inline void svm_save_seg(CPUX86State *env, hwaddr addr,
static inline void svm_load_seg(CPUX86State *env, hwaddr addr, static inline void svm_load_seg(CPUX86State *env, hwaddr addr,
SegmentCache *sc) SegmentCache *sc)
{ {
CPUState *cs = CPU(x86_env_get_cpu(env)); CPUState *cs = env_cpu(env);
unsigned int flags; unsigned int flags;
sc->selector = x86_lduw_phys(cs, sc->selector = x86_lduw_phys(cs,
@ -123,7 +123,7 @@ static inline void svm_load_seg_cache(CPUX86State *env, hwaddr addr,
void helper_vmrun(CPUX86State *env, int aflag, int next_eip_addend) void helper_vmrun(CPUX86State *env, int aflag, int next_eip_addend)
{ {
CPUState *cs = CPU(x86_env_get_cpu(env)); CPUState *cs = env_cpu(env);
target_ulong addr; target_ulong addr;
uint64_t nested_ctl; uint64_t nested_ctl;
uint32_t event_inj; uint32_t event_inj;
@ -315,7 +315,7 @@ void helper_vmrun(CPUX86State *env, int aflag, int next_eip_addend)
env->hflags2 |= HF2_GIF_MASK; env->hflags2 |= HF2_GIF_MASK;
if (int_ctl & V_IRQ_MASK) { if (int_ctl & V_IRQ_MASK) {
CPUState *cs = CPU(x86_env_get_cpu(env)); CPUState *cs = env_cpu(env);
cs->interrupt_request |= CPU_INTERRUPT_VIRQ; cs->interrupt_request |= CPU_INTERRUPT_VIRQ;
} }
@ -380,7 +380,7 @@ void helper_vmmcall(CPUX86State *env)
void helper_vmload(CPUX86State *env, int aflag) void helper_vmload(CPUX86State *env, int aflag)
{ {
CPUState *cs = CPU(x86_env_get_cpu(env)); CPUState *cs = env_cpu(env);
target_ulong addr; target_ulong addr;
cpu_svm_check_intercept_param(env, SVM_EXIT_VMLOAD, 0, GETPC()); cpu_svm_check_intercept_param(env, SVM_EXIT_VMLOAD, 0, GETPC());
@ -420,7 +420,7 @@ void helper_vmload(CPUX86State *env, int aflag)
void helper_vmsave(CPUX86State *env, int aflag) void helper_vmsave(CPUX86State *env, int aflag)
{ {
CPUState *cs = CPU(x86_env_get_cpu(env)); CPUState *cs = env_cpu(env);
target_ulong addr; target_ulong addr;
cpu_svm_check_intercept_param(env, SVM_EXIT_VMSAVE, 0, GETPC()); cpu_svm_check_intercept_param(env, SVM_EXIT_VMSAVE, 0, GETPC());
@ -483,7 +483,7 @@ void helper_skinit(CPUX86State *env)
void helper_invlpga(CPUX86State *env, int aflag) void helper_invlpga(CPUX86State *env, int aflag)
{ {
X86CPU *cpu = x86_env_get_cpu(env); X86CPU *cpu = env_archcpu(env);
target_ulong addr; target_ulong addr;
cpu_svm_check_intercept_param(env, SVM_EXIT_INVLPGA, 0, GETPC()); cpu_svm_check_intercept_param(env, SVM_EXIT_INVLPGA, 0, GETPC());
@ -502,7 +502,7 @@ void helper_invlpga(CPUX86State *env, int aflag)
void cpu_svm_check_intercept_param(CPUX86State *env, uint32_t type, void cpu_svm_check_intercept_param(CPUX86State *env, uint32_t type,
uint64_t param, uintptr_t retaddr) uint64_t param, uintptr_t retaddr)
{ {
CPUState *cs = CPU(x86_env_get_cpu(env)); CPUState *cs = env_cpu(env);
if (likely(!(env->hflags & HF_GUEST_MASK))) { if (likely(!(env->hflags & HF_GUEST_MASK))) {
return; return;
@ -572,7 +572,7 @@ void helper_svm_check_intercept_param(CPUX86State *env, uint32_t type,
void helper_svm_check_io(CPUX86State *env, uint32_t port, uint32_t param, void helper_svm_check_io(CPUX86State *env, uint32_t port, uint32_t param,
uint32_t next_eip_addend) uint32_t next_eip_addend)
{ {
CPUState *cs = CPU(x86_env_get_cpu(env)); CPUState *cs = env_cpu(env);
if (env->intercept & (1ULL << (SVM_EXIT_IOIO - SVM_EXIT_INTR))) { if (env->intercept & (1ULL << (SVM_EXIT_IOIO - SVM_EXIT_INTR))) {
/* FIXME: this should be read in at vmrun (faster this way?) */ /* FIXME: this should be read in at vmrun (faster this way?) */
@ -593,7 +593,7 @@ void helper_svm_check_io(CPUX86State *env, uint32_t port, uint32_t param,
void cpu_vmexit(CPUX86State *env, uint32_t exit_code, uint64_t exit_info_1, void cpu_vmexit(CPUX86State *env, uint32_t exit_code, uint64_t exit_info_1,
uintptr_t retaddr) uintptr_t retaddr)
{ {
CPUState *cs = CPU(x86_env_get_cpu(env)); CPUState *cs = env_cpu(env);
cpu_restore_state(cs, retaddr, true); cpu_restore_state(cs, retaddr, true);
@ -614,7 +614,7 @@ void cpu_vmexit(CPUX86State *env, uint32_t exit_code, uint64_t exit_info_1,
void do_vmexit(CPUX86State *env, uint32_t exit_code, uint64_t exit_info_1) void do_vmexit(CPUX86State *env, uint32_t exit_code, uint64_t exit_info_1)
{ {
CPUState *cs = CPU(x86_env_get_cpu(env)); CPUState *cs = env_cpu(env);
uint32_t int_ctl; uint32_t int_ctl;
if (env->hflags & HF_INHIBIT_IRQ_MASK) { if (env->hflags & HF_INHIBIT_IRQ_MASK) {