motorhead/qemu
1
0
Fork 0
mirror of https://github.com/Motorhead1991/qemu.git synced 2025-08-08 18:23:57 -06:00
Code Issues Projects Releases Packages Wiki Activity Actions

i386: hvf: Move lazy_flags into CPUX86State

Browse source 
The lazy flags are still needed for instruction decoder.

Signed-off-by: Roman Bolshakov <r.bolshakov@yadro.com>
Message-Id: <20200528193758.51454-12-r.bolshakov@yadro.com>
[Move struct to target/i386/cpu.h - Paolo]
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
This commit is contained in:
Roman Bolshakov 2020-05-28 22:37:56 +03:00 • committed by Paolo Bonzini
parent 167c6aef67
commit 577f02b890
3 changed files with 34 additions and 35 deletions
Download patch file Download diff file Expand all files Collapse all files

6
target/i386/cpu.h
View file

@ -1366,6 +1366,11 @@ typedef struct CPUCaches {
CPUCacheInfo *l3_cache; CPUCacheInfo *l3_cache;
} CPUCaches; } CPUCaches;
typedef struct HVFX86LazyFlags {
target_ulong result;
target_ulong auxbits;
} HVFX86LazyFlags;
typedef struct CPUX86State { typedef struct CPUX86State {
/* standard registers */ /* standard registers */
target_ulong regs[CPU_NB_REGS]; target_ulong regs[CPU_NB_REGS];
@ -1597,6 +1602,7 @@ typedef struct CPUX86State {
struct kvm_nested_state *nested_state; struct kvm_nested_state *nested_state;
#endif #endif
#if defined(CONFIG_HVF) #if defined(CONFIG_HVF)
HVFX86LazyFlags hvf_lflags;
HVFX86EmulatorState *hvf_emul; HVFX86EmulatorState *hvf_emul;
#endif #endif

6
target/i386/hvf/x86.h
View file

@ -228,14 +228,8 @@ typedef struct x68_segment_selector {
}; };
} __attribute__ ((__packed__)) x68_segment_selector; } __attribute__ ((__packed__)) x68_segment_selector;
typedef struct lazy_flags {
target_ulong result;
target_ulong auxbits;
} lazy_flags;
/* Definition of hvf_x86_state is here */ /* Definition of hvf_x86_state is here */
struct HVFX86EmulatorState { struct HVFX86EmulatorState {
struct lazy_flags lflags;
uint8_t mmio_buf[4096]; uint8_t mmio_buf[4096];
}; };

57
target/i386/hvf/x86_flags.c
View file

@ -63,7 +63,7 @@
#define SET_FLAGS_OSZAPC_SIZE(size, lf_carries, lf_result) { \ #define SET_FLAGS_OSZAPC_SIZE(size, lf_carries, lf_result) { \
target_ulong temp = ((lf_carries) & (LF_MASK_AF)) | \ target_ulong temp = ((lf_carries) & (LF_MASK_AF)) | \
(((lf_carries) >> (size - 2)) << LF_BIT_PO); \ (((lf_carries) >> (size - 2)) << LF_BIT_PO); \
env->hvf_emul->lflags.result = (target_ulong)(int##size##_t)(lf_result); \ env->hvf_lflags.result = (target_ulong)(int##size##_t)(lf_result); \
if ((size) == 32) { \ if ((size) == 32) { \
temp = ((lf_carries) & ~(LF_MASK_PDB | LF_MASK_SD)); \ temp = ((lf_carries) & ~(LF_MASK_PDB | LF_MASK_SD)); \
} else if ((size) == 16) { \ } else if ((size) == 16) { \
@ -73,7 +73,7 @@
} else { \ } else { \
VM_PANIC("unimplemented"); \ VM_PANIC("unimplemented"); \
} \ } \
env->hvf_emul->lflags.auxbits = (target_ulong)(uint32_t)temp; \ env->hvf_lflags.auxbits = (target_ulong)(uint32_t)temp; \
} }
/* carries, result */ /* carries, result */
@ -100,10 +100,10 @@
} else { \ } else { \
VM_PANIC("unimplemented"); \ VM_PANIC("unimplemented"); \
} \ } \
env->hvf_emul->lflags.result = (target_ulong)(int##size##_t)(lf_result); \ env->hvf_lflags.result = (target_ulong)(int##size##_t)(lf_result); \
target_ulong delta_c = (env->hvf_emul->lflags.auxbits ^ temp) & LF_MASK_CF; \ target_ulong delta_c = (env->hvf_lflags.auxbits ^ temp) & LF_MASK_CF; \
delta_c ^= (delta_c >> 1); \ delta_c ^= (delta_c >> 1); \
env->hvf_emul->lflags.auxbits = (target_ulong)(uint32_t)(temp ^ delta_c); \ env->hvf_lflags.auxbits = (target_ulong)(uint32_t)(temp ^ delta_c); \
} }
/* carries, result */ /* carries, result */
@ -117,9 +117,8 @@
void SET_FLAGS_OxxxxC(CPUX86State *env, uint32_t new_of, uint32_t new_cf) void SET_FLAGS_OxxxxC(CPUX86State *env, uint32_t new_of, uint32_t new_cf)
{ {
uint32_t temp_po = new_of ^ new_cf; uint32_t temp_po = new_of ^ new_cf;
env->hvf_emul->lflags.auxbits &= ~(LF_MASK_PO | LF_MASK_CF); env->hvf_lflags.auxbits &= ~(LF_MASK_PO | LF_MASK_CF);
env->hvf_emul->lflags.auxbits |= (temp_po << LF_BIT_PO) | env->hvf_lflags.auxbits |= (temp_po << LF_BIT_PO) | (new_cf << LF_BIT_CF);
(new_cf << LF_BIT_CF);
} }
void SET_FLAGS_OSZAPC_SUB32(CPUX86State *env, uint32_t v1, uint32_t v2, void SET_FLAGS_OSZAPC_SUB32(CPUX86State *env, uint32_t v1, uint32_t v2,
@ -215,27 +214,27 @@ void SET_FLAGS_OSZAPC_LOGIC8(CPUX86State *env, uint8_t v1, uint8_t v2,
bool get_PF(CPUX86State *env) bool get_PF(CPUX86State *env)
{ {
uint32_t temp = (255 & env->hvf_emul->lflags.result); uint32_t temp = (255 & env->hvf_lflags.result);
temp = temp ^ (255 & (env->hvf_emul->lflags.auxbits >> LF_BIT_PDB)); temp = temp ^ (255 & (env->hvf_lflags.auxbits >> LF_BIT_PDB));
temp = (temp ^ (temp >> 4)) & 0x0F; temp = (temp ^ (temp >> 4)) & 0x0F;
return (0x9669U >> temp) & 1; return (0x9669U >> temp) & 1;
} }
void set_PF(CPUX86State *env, bool val) void set_PF(CPUX86State *env, bool val)
{ {
uint32_t temp = (255 & env->hvf_emul->lflags.result) ^ (!val); uint32_t temp = (255 & env->hvf_lflags.result) ^ (!val);
env->hvf_emul->lflags.auxbits &= ~(LF_MASK_PDB); env->hvf_lflags.auxbits &= ~(LF_MASK_PDB);
env->hvf_emul->lflags.auxbits |= (temp << LF_BIT_PDB); env->hvf_lflags.auxbits |= (temp << LF_BIT_PDB);
} }
bool get_OF(CPUX86State *env) bool get_OF(CPUX86State *env)
{ {
return ((env->hvf_emul->lflags.auxbits + (1U << LF_BIT_PO)) >> LF_BIT_CF) & 1; return ((env->hvf_lflags.auxbits + (1U << LF_BIT_PO)) >> LF_BIT_CF) & 1;
} }
bool get_CF(CPUX86State *env) bool get_CF(CPUX86State *env)
{ {
return (env->hvf_emul->lflags.auxbits >> LF_BIT_CF) & 1; return (env->hvf_lflags.auxbits >> LF_BIT_CF) & 1;
} }
void set_OF(CPUX86State *env, bool val) void set_OF(CPUX86State *env, bool val)
@ -252,45 +251,45 @@ void set_CF(CPUX86State *env, bool val)
bool get_AF(CPUX86State *env) bool get_AF(CPUX86State *env)
{ {
return (env->hvf_emul->lflags.auxbits >> LF_BIT_AF) & 1; return (env->hvf_lflags.auxbits >> LF_BIT_AF) & 1;
} }
void set_AF(CPUX86State *env, bool val) void set_AF(CPUX86State *env, bool val)
{ {
env->hvf_emul->lflags.auxbits &= ~(LF_MASK_AF); env->hvf_lflags.auxbits &= ~(LF_MASK_AF);
env->hvf_emul->lflags.auxbits |= val << LF_BIT_AF; env->hvf_lflags.auxbits |= val << LF_BIT_AF;
} }
bool get_ZF(CPUX86State *env) bool get_ZF(CPUX86State *env)
{ {
return !env->hvf_emul->lflags.result; return !env->hvf_lflags.result;
} }
void set_ZF(CPUX86State *env, bool val) void set_ZF(CPUX86State *env, bool val)
{ {
if (val) { if (val) {
env->hvf_emul->lflags.auxbits ^= env->hvf_lflags.auxbits ^=
(((env->hvf_emul->lflags.result >> LF_SIGN_BIT) & 1) << LF_BIT_SD); (((env->hvf_lflags.result >> LF_SIGN_BIT) & 1) << LF_BIT_SD);
/* merge the parity bits into the Parity Delta Byte */ /* merge the parity bits into the Parity Delta Byte */
uint32_t temp_pdb = (255 & env->hvf_emul->lflags.result); uint32_t temp_pdb = (255 & env->hvf_lflags.result);
env->hvf_emul->lflags.auxbits ^= (temp_pdb << LF_BIT_PDB); env->hvf_lflags.auxbits ^= (temp_pdb << LF_BIT_PDB);
/* now zero the .result value */ /* now zero the .result value */
env->hvf_emul->lflags.result = 0; env->hvf_lflags.result = 0;
} else { } else {
env->hvf_emul->lflags.result |= (1 << 8); env->hvf_lflags.result |= (1 << 8);
} }
} }
bool get_SF(CPUX86State *env) bool get_SF(CPUX86State *env)
{ {
return ((env->hvf_emul->lflags.result >> LF_SIGN_BIT) ^ return ((env->hvf_lflags.result >> LF_SIGN_BIT) ^
(env->hvf_emul->lflags.auxbits >> LF_BIT_SD)) & 1; (env->hvf_lflags.auxbits >> LF_BIT_SD)) & 1;
} }
void set_SF(CPUX86State *env, bool val) void set_SF(CPUX86State *env, bool val)
{ {
bool temp_sf = get_SF(env); bool temp_sf = get_SF(env);
env->hvf_emul->lflags.auxbits ^= (temp_sf ^ val) << LF_BIT_SD; env->hvf_lflags.auxbits ^= (temp_sf ^ val) << LF_BIT_SD;
} }
void lflags_to_rflags(CPUX86State *env) void lflags_to_rflags(CPUX86State *env)
@ -305,7 +304,7 @@ void lflags_to_rflags(CPUX86State *env)
void rflags_to_lflags(CPUX86State *env) void rflags_to_lflags(CPUX86State *env)
{ {
env->hvf_emul->lflags.auxbits = env->hvf_emul->lflags.result = 0; env->hvf_lflags.auxbits = env->hvf_lflags.result = 0;
set_OF(env, env->eflags & CC_O); set_OF(env, env->eflags & CC_O);
set_SF(env, env->eflags & CC_S); set_SF(env, env->eflags & CC_S);
set_ZF(env, env->eflags & CC_Z); set_ZF(env, env->eflags & CC_Z);