Commit 577f02b8 authored by Roman Bolshakov's avatar Roman Bolshakov Committed by Paolo Bonzini
Browse files

i386: hvf: Move lazy_flags into CPUX86State 



The lazy flags are still needed for instruction decoder.

Signed-off-by: default avatarRoman 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: default avatarPaolo Bonzini <pbonzini@redhat.com>
parent 167c6aef

target/i386/cpu.h

+6 −0
Original line number Diff line number Diff line
@@ -1366,6 +1366,11 @@ typedef struct CPUCaches { 
        CPUCacheInfo *l3_cache;

} CPUCaches;



typedef struct HVFX86LazyFlags {

    target_ulong result;

    target_ulong auxbits;

} HVFX86LazyFlags;



typedef struct CPUX86State {

    /* standard registers */

    target_ulong regs[CPU_NB_REGS];
@@ -1597,6 +1602,7 @@ typedef struct CPUX86State { 
    struct kvm_nested_state *nested_state;

#endif

#if defined(CONFIG_HVF)

    HVFX86LazyFlags hvf_lflags;

    HVFX86EmulatorState *hvf_emul;

#endif

target/i386/hvf/x86.h

+0 −6
Original line number Diff line number Diff line
@@ -228,14 +228,8 @@ typedef struct 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 */

struct HVFX86EmulatorState {

    struct lazy_flags   lflags;

    uint8_t mmio_buf[4096];

};

target/i386/hvf/x86_flags.c

+28 −29
Original line number Diff line number Diff line
@@ -63,7 +63,7 @@ 
#define SET_FLAGS_OSZAPC_SIZE(size, lf_carries, lf_result) { \

    target_ulong temp = ((lf_carries) & (LF_MASK_AF)) | \

    (((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) { \

        temp = ((lf_carries) & ~(LF_MASK_PDB | LF_MASK_SD)); \

    } else if ((size) == 16) { \
@@ -73,7 +73,7 @@ 
    } else { \

        VM_PANIC("unimplemented");  \

    } \

    env->hvf_emul->lflags.auxbits = (target_ulong)(uint32_t)temp; \

    env->hvf_lflags.auxbits = (target_ulong)(uint32_t)temp; \

}



/* carries, result */
@@ -100,10 +100,10 @@ 
    } else { \

        VM_PANIC("unimplemented");      \

    } \

    env->hvf_emul->lflags.result = (target_ulong)(int##size##_t)(lf_result); \

    target_ulong delta_c = (env->hvf_emul->lflags.auxbits ^ temp) & LF_MASK_CF; \

    env->hvf_lflags.result = (target_ulong)(int##size##_t)(lf_result); \

    target_ulong delta_c = (env->hvf_lflags.auxbits ^ temp) & LF_MASK_CF; \

    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 */
@@ -117,9 +117,8 @@ 
void SET_FLAGS_OxxxxC(CPUX86State *env, uint32_t new_of, uint32_t new_cf)

{

    uint32_t temp_po = new_of ^ new_cf;

    env->hvf_emul->lflags.auxbits &= ~(LF_MASK_PO | LF_MASK_CF);

    env->hvf_emul->lflags.auxbits |= (temp_po << LF_BIT_PO) |

                                     (new_cf << LF_BIT_CF);

    env->hvf_lflags.auxbits &= ~(LF_MASK_PO | LF_MASK_CF);

    env->hvf_lflags.auxbits |= (temp_po << LF_BIT_PO) | (new_cf << LF_BIT_CF);

}



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)

{

    uint32_t temp = (255 & env->hvf_emul->lflags.result);

    temp = temp ^ (255 & (env->hvf_emul->lflags.auxbits >> LF_BIT_PDB));

    uint32_t temp = (255 & env->hvf_lflags.result);

    temp = temp ^ (255 & (env->hvf_lflags.auxbits >> LF_BIT_PDB));

    temp = (temp ^ (temp >> 4)) & 0x0F;

    return (0x9669U >> temp) & 1;

}



void set_PF(CPUX86State *env, bool val)

{

    uint32_t temp = (255 & env->hvf_emul->lflags.result) ^ (!val);

    env->hvf_emul->lflags.auxbits &= ~(LF_MASK_PDB);

    env->hvf_emul->lflags.auxbits |= (temp << LF_BIT_PDB);

    uint32_t temp = (255 & env->hvf_lflags.result) ^ (!val);

    env->hvf_lflags.auxbits &= ~(LF_MASK_PDB);

    env->hvf_lflags.auxbits |= (temp << LF_BIT_PDB);

}



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)

{

    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)
@@ -252,45 +251,45 @@ void set_CF(CPUX86State *env, bool val) 


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)

{

    env->hvf_emul->lflags.auxbits &= ~(LF_MASK_AF);

    env->hvf_emul->lflags.auxbits |= val << LF_BIT_AF;

    env->hvf_lflags.auxbits &= ~(LF_MASK_AF);

    env->hvf_lflags.auxbits |= val << LF_BIT_AF;

}



bool get_ZF(CPUX86State *env)

{

    return !env->hvf_emul->lflags.result;

    return !env->hvf_lflags.result;

}



void set_ZF(CPUX86State *env, bool val)

{

    if (val) {

        env->hvf_emul->lflags.auxbits ^=

         (((env->hvf_emul->lflags.result >> LF_SIGN_BIT) & 1) << LF_BIT_SD);

        env->hvf_lflags.auxbits ^=

         (((env->hvf_lflags.result >> LF_SIGN_BIT) & 1) << LF_BIT_SD);

        /* merge the parity bits into the Parity Delta Byte */

        uint32_t temp_pdb = (255 & env->hvf_emul->lflags.result);

        env->hvf_emul->lflags.auxbits ^= (temp_pdb << LF_BIT_PDB);

        uint32_t temp_pdb = (255 & env->hvf_lflags.result);

        env->hvf_lflags.auxbits ^= (temp_pdb << LF_BIT_PDB);

        /* now zero the .result value */

        env->hvf_emul->lflags.result = 0;

        env->hvf_lflags.result = 0;

    } else {

        env->hvf_emul->lflags.result |= (1 << 8);

        env->hvf_lflags.result |= (1 << 8);

    }

}



bool get_SF(CPUX86State *env)

{

    return ((env->hvf_emul->lflags.result >> LF_SIGN_BIT) ^

            (env->hvf_emul->lflags.auxbits >> LF_BIT_SD)) & 1;

    return ((env->hvf_lflags.result >> LF_SIGN_BIT) ^

            (env->hvf_lflags.auxbits >> LF_BIT_SD)) & 1;

}



void set_SF(CPUX86State *env, bool val)

{

    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)
@@ -305,7 +304,7 @@ void lflags_to_rflags(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_SF(env, env->eflags & CC_S);

    set_ZF(env, env->eflags & CC_Z);