VirtualBox

Ignore:
Timestamp:
Aug 9, 2023 1:57:40 AM (16 months ago)
Author:
vboxsync
Message:

VMM/IEM: Started refactoring IEM_MC_MEM_MAP into type and access specific variant so we can more efficiently apply inlined code using the TLB. Converted a bunch of 8-bit accesses in the one-byte opcode map. bugref:10369

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/VMM/VMMAll/IEMAllInstOneByte.cpp.h

    r100804 r100826  
    6363 * Used with IEMOP_BODY_BINARY_rm_r8_NO_LOCK or IEMOP_BODY_BINARY_rm_r8_LOCKED.
    6464 */
    65 #define IEMOP_BODY_BINARY_rm_r8(a_fnNormalU8, a_fRW) \
     65#define IEMOP_BODY_BINARY_rm_r8_RW(a_fnNormalU8) \
    6666    uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm); \
    6767    \
    … …  
    9494        if (!(pVCpu->iem.s.fPrefixes & IEM_OP_PRF_LOCK)) \
    9595        { \
    96             IEM_MC_BEGIN(3, 2); \
     96            IEM_MC_BEGIN(3, 3); \
    9797            IEM_MC_ARG(uint8_t *,  pu8Dst,           0); \
    9898            IEM_MC_ARG(uint8_t,    u8Src,            1); \
    9999            IEM_MC_ARG_LOCAL_EFLAGS(pEFlags, EFlags, 2); \
    100100            IEM_MC_LOCAL(RTGCPTR, GCPtrEffDst); \
     101            IEM_MC_LOCAL(uint8_t, bUnmapInfo); \
    101102            \
    102103            IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 0); \
    103104            IEMOP_HLP_DONE_DECODING(); \
    104             IEM_MC_MEM_MAP(pu8Dst, a_fRW, pVCpu->iem.s.iEffSeg, GCPtrEffDst, 0 /*arg*/); \
     105            IEM_MC_MEM_MAP_U8_RW(pu8Dst, bUnmapInfo, pVCpu->iem.s.iEffSeg, GCPtrEffDst); \
    105106            IEM_MC_FETCH_GREG_U8(u8Src, IEM_GET_MODRM_REG(pVCpu, bRm)); \
    106107            IEM_MC_FETCH_EFLAGS(EFlags); \
    107108            IEM_MC_CALL_VOID_AIMPL_3(a_fnNormalU8, pu8Dst, u8Src, pEFlags); \
    108109            \
    109             IEM_MC_MEM_COMMIT_AND_UNMAP(pu8Dst, a_fRW); \
     110            IEM_MC_MEM_COMMIT_AND_UNMAP_RW(pu8Dst, bUnmapInfo); \
    110111            IEM_MC_COMMIT_EFLAGS(EFlags); \
    111112            IEM_MC_ADVANCE_RIP_AND_FINISH(); \
    … …  
    116117            (void)0
    117118
     119/**
     120 * Body for instructions like TEST & CMP, ++ with a byte memory/registers as
     121 * operands.
     122 *
     123 * Used with IEMOP_BODY_BINARY_rm_r8_NO_LOCK or IEMOP_BODY_BINARY_rm_r8_LOCKED.
     124 */
     125#define IEMOP_BODY_BINARY_rm_r8_RO(a_fnNormalU8) \
     126    uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm); \
     127    \
     128    /* \
     129     * If rm is denoting a register, no more instruction bytes. \
     130     */ \
     131    if (IEM_IS_MODRM_REG_MODE(bRm)) \
     132    { \
     133        IEM_MC_BEGIN(3, 0); \
     134        IEM_MC_ARG(uint8_t *,  pu8Dst,  0); \
     135        IEM_MC_ARG(uint8_t,    u8Src,   1); \
     136        IEM_MC_ARG(uint32_t *, pEFlags, 2); \
     137         \
     138        IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX(); \
     139        IEM_MC_FETCH_GREG_U8(u8Src, IEM_GET_MODRM_REG(pVCpu, bRm)); \
     140        IEM_MC_REF_GREG_U8(pu8Dst, IEM_GET_MODRM_RM(pVCpu, bRm)); \
     141        IEM_MC_REF_EFLAGS(pEFlags); \
     142        IEM_MC_CALL_VOID_AIMPL_3(a_fnNormalU8, pu8Dst, u8Src, pEFlags); \
     143         \
     144        IEM_MC_ADVANCE_RIP_AND_FINISH(); \
     145        IEM_MC_END(); \
     146    } \
     147    else \
     148    { \
     149        /* \
     150         * We're accessing memory. \
     151         * Note! We're putting the eflags on the stack here so we can commit them \
     152         *       after the memory. \
     153         */ \
     154        if (!(pVCpu->iem.s.fPrefixes & IEM_OP_PRF_LOCK)) \
     155        { \
     156            IEM_MC_BEGIN(3, 3); \
     157            IEM_MC_ARG(uint8_t const *, pu8Dst,          0); \
     158            IEM_MC_ARG(uint8_t,         u8Src,           1); \
     159            IEM_MC_ARG_LOCAL_EFLAGS(    pEFlags, EFlags, 2); \
     160            IEM_MC_LOCAL(RTGCPTR, GCPtrEffDst); \
     161            IEM_MC_LOCAL(uint8_t, bUnmapInfo); \
     162            \
     163            IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 0); \
     164            IEMOP_HLP_DONE_DECODING(); \
     165            IEM_MC_MEM_MAP_U8_RO(pu8Dst, bUnmapInfo, pVCpu->iem.s.iEffSeg, GCPtrEffDst); \
     166            IEM_MC_FETCH_GREG_U8(u8Src, IEM_GET_MODRM_REG(pVCpu, bRm)); \
     167            IEM_MC_FETCH_EFLAGS(EFlags); \
     168            IEM_MC_CALL_VOID_AIMPL_3(a_fnNormalU8, pu8Dst, u8Src, pEFlags); \
     169            \
     170            IEM_MC_MEM_COMMIT_AND_UNMAP_RO(pu8Dst, bUnmapInfo); \
     171            IEM_MC_COMMIT_EFLAGS(EFlags); \
     172            IEM_MC_ADVANCE_RIP_AND_FINISH(); \
     173            IEM_MC_END(); \
     174        } \
     175        else \
     176        { \
     177            (void)0
     178
    118179#define IEMOP_BODY_BINARY_rm_r8_NO_LOCK() \
    119180            IEMOP_HLP_DONE_DECODING(); \
    … …  
    124185
    125186#define IEMOP_BODY_BINARY_rm_r8_LOCKED(a_fnLockedU8) \
    126             IEM_MC_BEGIN(3, 2); \
     187            IEM_MC_BEGIN(3, 3); \
    127188            IEM_MC_ARG(uint8_t *,  pu8Dst,           0); \
    128189            IEM_MC_ARG(uint8_t,    u8Src,            1); \
    129190            IEM_MC_ARG_LOCAL_EFLAGS(pEFlags, EFlags, 2); \
    130191            IEM_MC_LOCAL(RTGCPTR, GCPtrEffDst); \
     192            IEM_MC_LOCAL(uint8_t, bMapInfoDst); \
    131193            \
    132194            IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 0); \
    133195            IEMOP_HLP_DONE_DECODING(); \
    134             IEM_MC_MEM_MAP(pu8Dst, IEM_ACCESS_DATA_RW, pVCpu->iem.s.iEffSeg, GCPtrEffDst, 0 /*arg*/); \
     196            IEM_MC_MEM_MAP_U8_RW(pu8Dst, bMapInfoDst, pVCpu->iem.s.iEffSeg, GCPtrEffDst); \
    135197            IEM_MC_FETCH_GREG_U8(u8Src, IEM_GET_MODRM_REG(pVCpu, bRm)); \
    136198            IEM_MC_FETCH_EFLAGS(EFlags); \
    137199            IEM_MC_CALL_VOID_AIMPL_3(a_fnLockedU8, pu8Dst, u8Src, pEFlags); \
    138200            \
    139             IEM_MC_MEM_COMMIT_AND_UNMAP(pu8Dst, IEM_ACCESS_DATA_RW); \
     201            IEM_MC_MEM_COMMIT_AND_UNMAP_RW(pu8Dst, bMapInfoDst); \
    140202            IEM_MC_COMMIT_EFLAGS(EFlags); \
    141203            IEM_MC_ADVANCE_RIP_AND_FINISH(); \
    … …  
    527589{
    528590    IEMOP_MNEMONIC2(MR, ADD, add, Eb, Gb, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES | IEMOPHINT_LOCK_ALLOWED);
    529     IEMOP_BODY_BINARY_rm_r8(       iemAImpl_add_u8, IEM_ACCESS_DATA_RW);
     591    IEMOP_BODY_BINARY_rm_r8_RW(    iemAImpl_add_u8);
    530592    IEMOP_BODY_BINARY_rm_r8_LOCKED(iemAImpl_add_u8_locked);
    531593}
    … …  
    644706    IEMOP_MNEMONIC2(MR, OR, or, Eb, Gb, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES | IEMOPHINT_LOCK_ALLOWED);
    645707    IEMOP_VERIFICATION_UNDEFINED_EFLAGS(X86_EFL_AF);
    646     IEMOP_BODY_BINARY_rm_r8(       iemAImpl_or_u8, IEM_ACCESS_DATA_RW);
     708    IEMOP_BODY_BINARY_rm_r8_RW(    iemAImpl_or_u8);
    647709    IEMOP_BODY_BINARY_rm_r8_LOCKED(iemAImpl_or_u8_locked);
    648710}
    … …  
    811873{
    812874    IEMOP_MNEMONIC2(MR, ADC, adc, Eb, Gb, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES | IEMOPHINT_LOCK_ALLOWED);
    813     IEMOP_BODY_BINARY_rm_r8(       iemAImpl_adc_u8, IEM_ACCESS_DATA_RW);
     875    IEMOP_BODY_BINARY_rm_r8_RW(    iemAImpl_adc_u8);
    814876    IEMOP_BODY_BINARY_rm_r8_LOCKED(iemAImpl_adc_u8_locked);
    815877}
    … …  
    926988{
    927989    IEMOP_MNEMONIC2(MR, SBB, sbb, Eb, Gb, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES | IEMOPHINT_LOCK_ALLOWED);
    928     IEMOP_BODY_BINARY_rm_r8(       iemAImpl_sbb_u8, IEM_ACCESS_DATA_RW);
     990    IEMOP_BODY_BINARY_rm_r8_RW(    iemAImpl_sbb_u8);
    929991    IEMOP_BODY_BINARY_rm_r8_LOCKED(iemAImpl_sbb_u8_locked);
    930992}
    … …  
    10331095    IEMOP_MNEMONIC2(MR, AND, and, Eb, Gb, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES | IEMOPHINT_LOCK_ALLOWED);
    10341096    IEMOP_VERIFICATION_UNDEFINED_EFLAGS(X86_EFL_AF);
    1035     IEMOP_BODY_BINARY_rm_r8(       iemAImpl_and_u8, IEM_ACCESS_DATA_RW);
     1097    IEMOP_BODY_BINARY_rm_r8_RW(    iemAImpl_and_u8);
    10361098    IEMOP_BODY_BINARY_rm_r8_LOCKED(iemAImpl_and_u8_locked);
    10371099}
    … …  
    11581220{
    11591221    IEMOP_MNEMONIC2(MR, SUB, sub, Eb, Gb, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES | IEMOPHINT_LOCK_ALLOWED);
    1160     IEMOP_BODY_BINARY_rm_r8(       iemAImpl_sub_u8, IEM_ACCESS_DATA_RW);
     1222    IEMOP_BODY_BINARY_rm_r8_RW(    iemAImpl_sub_u8);
    11611223    IEMOP_BODY_BINARY_rm_r8_LOCKED(iemAImpl_sub_u8_locked);
    11621224}
    … …  
    12711333    IEMOP_MNEMONIC2(MR, XOR, xor, Eb, Gb, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES | IEMOPHINT_LOCK_ALLOWED);
    12721334    IEMOP_VERIFICATION_UNDEFINED_EFLAGS(X86_EFL_AF);
    1273     IEMOP_BODY_BINARY_rm_r8(       iemAImpl_xor_u8, IEM_ACCESS_DATA_RW);
     1335    IEMOP_BODY_BINARY_rm_r8_RW(    iemAImpl_xor_u8);
    12741336    IEMOP_BODY_BINARY_rm_r8_LOCKED(iemAImpl_xor_u8_locked);
    12751337}
    … …  
    14271489{
    14281490    IEMOP_MNEMONIC(cmp_Eb_Gb, "cmp Eb,Gb");
    1429     IEMOP_BODY_BINARY_rm_r8(iemAImpl_cmp_u8, IEM_ACCESS_DATA_R);
     1491    IEMOP_BODY_BINARY_rm_r8_RO(iemAImpl_cmp_u8);
    14301492    IEMOP_BODY_BINARY_rm_r8_NO_LOCK();
    14311493}
    … …  
    36413703 * iemOp_Grp1_Eb_Ib_80.
    36423704 */
    3643 #define IEMOP_BODY_BINARY_Eb_Ib(a_fnNormalU8, a_fRW) \
     3705#define IEMOP_BODY_BINARY_Eb_Ib_RW(a_fnNormalU8) \
    36443706    if (IEM_IS_MODRM_REG_MODE(bRm)) \
    36453707    { \
    … …  
    36643726        if (!(pVCpu->iem.s.fPrefixes & IEM_OP_PRF_LOCK)) \
    36653727        { \
    3666             IEM_MC_BEGIN(3, 2); \
     3728            IEM_MC_BEGIN(3, 3); \
    36673729            IEM_MC_ARG(uint8_t *,       pu8Dst,                 0); \
    36683730            IEM_MC_ARG_LOCAL_EFLAGS(    pEFlags, EFlags,        2); \
    36693731            IEM_MC_LOCAL(RTGCPTR, GCPtrEffDst); \
     3732            IEM_MC_LOCAL(uint8_t, bUnmapInfo); \
    36703733            \
    36713734            IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 1); \
    … …  
    36743737            IEMOP_HLP_DONE_DECODING(); \
    36753738            \
    3676             IEM_MC_MEM_MAP(pu8Dst, a_fRW, pVCpu->iem.s.iEffSeg, GCPtrEffDst, 0 /*arg*/); \
     3739            IEM_MC_MEM_MAP_U8_RW(pu8Dst, bUnmapInfo, pVCpu->iem.s.iEffSeg, GCPtrEffDst); \
    36773740            IEM_MC_FETCH_EFLAGS(EFlags); \
    36783741            IEM_MC_CALL_VOID_AIMPL_3(a_fnNormalU8, pu8Dst, u8Src, pEFlags); \
    36793742            \
    3680             IEM_MC_MEM_COMMIT_AND_UNMAP(pu8Dst, a_fRW); \
     3743            IEM_MC_MEM_COMMIT_AND_UNMAP_RW(pu8Dst, bUnmapInfo); \
    36813744            IEM_MC_COMMIT_EFLAGS(EFlags); \
    36823745            IEM_MC_ADVANCE_RIP_AND_FINISH(); \
    … …  
    36873750            (void)0
    36883751
     3752#define IEMOP_BODY_BINARY_Eb_Ib_LOCKED(a_fnLockedU8) \
     3753            IEM_MC_BEGIN(3, 3); \
     3754            IEM_MC_ARG(uint8_t *,       pu8Dst,                 0); \
     3755            IEM_MC_ARG_LOCAL_EFLAGS(    pEFlags, EFlags,        2); \
     3756            IEM_MC_LOCAL(RTGCPTR, GCPtrEffDst); \
     3757            IEM_MC_LOCAL(uint8_t, bUnmapInfo); \
     3758            \
     3759            IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 1); \
     3760            uint8_t u8Imm; IEM_OPCODE_GET_NEXT_U8(&u8Imm); \
     3761            IEM_MC_ARG_CONST(uint8_t,   u8Src, /*=*/ u8Imm,     1); \
     3762            IEMOP_HLP_DONE_DECODING(); \
     3763            \
     3764            IEM_MC_MEM_MAP_U8_RW(pu8Dst, bUnmapInfo, pVCpu->iem.s.iEffSeg, GCPtrEffDst); \
     3765            IEM_MC_FETCH_EFLAGS(EFlags); \
     3766            IEM_MC_CALL_VOID_AIMPL_3(a_fnLockedU8, pu8Dst, u8Src, pEFlags); \
     3767            \
     3768            IEM_MC_MEM_COMMIT_AND_UNMAP_RW(pu8Dst, bUnmapInfo); \
     3769            IEM_MC_COMMIT_EFLAGS(EFlags); \
     3770            IEM_MC_ADVANCE_RIP_AND_FINISH(); \
     3771            IEM_MC_END(); \
     3772        } \
     3773    } \
     3774    (void)0
     3775
     3776#define IEMOP_BODY_BINARY_Eb_Ib_RO(a_fnNormalU8) \
     3777    if (IEM_IS_MODRM_REG_MODE(bRm)) \
     3778    { \
     3779        /* register target */ \
     3780        uint8_t u8Imm; IEM_OPCODE_GET_NEXT_U8(&u8Imm); \
     3781        IEM_MC_BEGIN(3, 0); \
     3782        IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX(); \
     3783        IEM_MC_ARG(uint8_t *,       pu8Dst,                 0); \
     3784        IEM_MC_ARG_CONST(uint8_t,   u8Src, /*=*/ u8Imm,     1); \
     3785        IEM_MC_ARG(uint32_t *,      pEFlags,                2); \
     3786        \
     3787        IEM_MC_REF_GREG_U8(pu8Dst, IEM_GET_MODRM_RM(pVCpu, bRm)); \
     3788        IEM_MC_REF_EFLAGS(pEFlags); \
     3789        IEM_MC_CALL_VOID_AIMPL_3(a_fnNormalU8, pu8Dst, u8Src, pEFlags); \
     3790        \
     3791        IEM_MC_ADVANCE_RIP_AND_FINISH(); \
     3792        IEM_MC_END(); \
     3793    } \
     3794    else \
     3795    { \
     3796        /* memory target */ \
     3797        if (!(pVCpu->iem.s.fPrefixes & IEM_OP_PRF_LOCK)) \
     3798        { \
     3799            IEM_MC_BEGIN(3, 3); \
     3800            IEM_MC_ARG(uint8_t const *, pu8Dst,                 0); \
     3801            IEM_MC_ARG_LOCAL_EFLAGS(    pEFlags, EFlags,        2); \
     3802            IEM_MC_LOCAL(RTGCPTR, GCPtrEffDst); \
     3803            IEM_MC_LOCAL(uint8_t, bUnmapInfo); \
     3804            \
     3805            IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 1); \
     3806            uint8_t u8Imm; IEM_OPCODE_GET_NEXT_U8(&u8Imm); \
     3807            IEM_MC_ARG_CONST(uint8_t,   u8Src, /*=*/ u8Imm,     1); \
     3808            IEMOP_HLP_DONE_DECODING(); \
     3809            \
     3810            IEM_MC_MEM_MAP_U8_RO(pu8Dst, bUnmapInfo, pVCpu->iem.s.iEffSeg, GCPtrEffDst); \
     3811            IEM_MC_FETCH_EFLAGS(EFlags); \
     3812            IEM_MC_CALL_VOID_AIMPL_3(a_fnNormalU8, pu8Dst, u8Src, pEFlags); \
     3813            \
     3814            IEM_MC_MEM_COMMIT_AND_UNMAP_RO(pu8Dst, bUnmapInfo); \
     3815            IEM_MC_COMMIT_EFLAGS(EFlags); \
     3816            IEM_MC_ADVANCE_RIP_AND_FINISH(); \
     3817            IEM_MC_END(); \
     3818        } \
     3819        else \
     3820        { \
     3821            (void)0
     3822
    36893823#define IEMOP_BODY_BINARY_Eb_Ib_NO_LOCK() \
    36903824            IEMOP_HLP_DONE_DECODING(); \
    … …  
    36943828    (void)0
    36953829
    3696 #define IEMOP_BODY_BINARY_Eb_Ib_LOCKED(a_fnLockedU8) \
    3697             IEM_MC_BEGIN(3, 2); \
    3698             IEM_MC_ARG(uint8_t *,       pu8Dst,                 0); \
    3699             IEM_MC_ARG_LOCAL_EFLAGS(    pEFlags, EFlags,        2); \
    3700             IEM_MC_LOCAL(RTGCPTR, GCPtrEffDst); \
    3701             \
    3702             IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 1); \
    3703             uint8_t u8Imm; IEM_OPCODE_GET_NEXT_U8(&u8Imm); \
    3704             IEM_MC_ARG_CONST(uint8_t,   u8Src, /*=*/ u8Imm,     1); \
    3705             IEMOP_HLP_DONE_DECODING(); \
    3706             \
    3707             IEM_MC_MEM_MAP(pu8Dst, IEM_ACCESS_DATA_RW, pVCpu->iem.s.iEffSeg, GCPtrEffDst, 0 /*arg*/); \
    3708             IEM_MC_FETCH_EFLAGS(EFlags); \
    3709             IEM_MC_CALL_VOID_AIMPL_3(a_fnLockedU8, pu8Dst, u8Src, pEFlags); \
    3710             \
    3711             IEM_MC_MEM_COMMIT_AND_UNMAP(pu8Dst, IEM_ACCESS_DATA_RW); \
    3712             IEM_MC_COMMIT_EFLAGS(EFlags); \
    3713             IEM_MC_ADVANCE_RIP_AND_FINISH(); \
    3714             IEM_MC_END(); \
    3715         } \
    3716     } \
    3717     (void)0
    37183830
    37193831
    … …  
    37253837{
    37263838    IEMOP_MNEMONIC(add_Eb_Ib, "add Eb,Ib");
    3727     IEMOP_BODY_BINARY_Eb_Ib(       iemAImpl_add_u8, IEM_ACCESS_DATA_RW);
     3839    IEMOP_BODY_BINARY_Eb_Ib_RW(    iemAImpl_add_u8);
    37283840    IEMOP_BODY_BINARY_Eb_Ib_LOCKED(iemAImpl_add_u8_locked);
    37293841}
    … …  
    37373849{
    37383850    IEMOP_MNEMONIC(or_Eb_Ib, "or Eb,Ib");
    3739     IEMOP_BODY_BINARY_Eb_Ib(       iemAImpl_or_u8, IEM_ACCESS_DATA_RW);
     3851    IEMOP_BODY_BINARY_Eb_Ib_RW(    iemAImpl_or_u8);
    37403852    IEMOP_BODY_BINARY_Eb_Ib_LOCKED(iemAImpl_or_u8_locked);
    37413853}
    … …  
    37493861{
    37503862    IEMOP_MNEMONIC(adc_Eb_Ib, "adc Eb,Ib");
    3751     IEMOP_BODY_BINARY_Eb_Ib(       iemAImpl_adc_u8, IEM_ACCESS_DATA_RW);
     3863    IEMOP_BODY_BINARY_Eb_Ib_RW(    iemAImpl_adc_u8);
    37523864    IEMOP_BODY_BINARY_Eb_Ib_LOCKED(iemAImpl_adc_u8_locked);
    37533865}
    … …  
    37613873{
    37623874    IEMOP_MNEMONIC(sbb_Eb_Ib, "sbb Eb,Ib");
    3763     IEMOP_BODY_BINARY_Eb_Ib(       iemAImpl_sbb_u8, IEM_ACCESS_DATA_RW);
     3875    IEMOP_BODY_BINARY_Eb_Ib_RW(    iemAImpl_sbb_u8);
    37643876    IEMOP_BODY_BINARY_Eb_Ib_LOCKED(iemAImpl_sbb_u8_locked);
    37653877}
    … …  
    37733885{
    37743886    IEMOP_MNEMONIC(and_Eb_Ib, "and Eb,Ib");
    3775     IEMOP_BODY_BINARY_Eb_Ib(       iemAImpl_and_u8, IEM_ACCESS_DATA_RW);
     3887    IEMOP_BODY_BINARY_Eb_Ib_RW(    iemAImpl_and_u8);
    37763888    IEMOP_BODY_BINARY_Eb_Ib_LOCKED(iemAImpl_and_u8_locked);
    37773889}
    … …  
    37853897{
    37863898    IEMOP_MNEMONIC(sub_Eb_Ib, "sub Eb,Ib");
    3787     IEMOP_BODY_BINARY_Eb_Ib(       iemAImpl_sub_u8, IEM_ACCESS_DATA_RW);
     3899    IEMOP_BODY_BINARY_Eb_Ib_RW(    iemAImpl_sub_u8);
    37883900    IEMOP_BODY_BINARY_Eb_Ib_LOCKED(iemAImpl_sub_u8_locked);
    37893901}
    … …  
    37973909{
    37983910    IEMOP_MNEMONIC(xor_Eb_Ib, "xor Eb,Ib");
    3799     IEMOP_BODY_BINARY_Eb_Ib(       iemAImpl_xor_u8, IEM_ACCESS_DATA_RW);
     3911    IEMOP_BODY_BINARY_Eb_Ib_RW(    iemAImpl_xor_u8);
    38003912    IEMOP_BODY_BINARY_Eb_Ib_LOCKED(iemAImpl_xor_u8_locked);
    38013913}
    … …  
    38093921{
    38103922    IEMOP_MNEMONIC(cmp_Eb_Ib, "cmp Eb,Ib");
    3811     IEMOP_BODY_BINARY_Eb_Ib(iemAImpl_cmp_u8, IEM_ACCESS_DATA_R);
     3923    IEMOP_BODY_BINARY_Eb_Ib_RO(iemAImpl_cmp_u8);
    38123924    IEMOP_BODY_BINARY_Eb_Ib_NO_LOCK();
    38133925}
    … …  
    45674679    IEMOP_MNEMONIC(test_Eb_Gb, "test Eb,Gb");
    45684680    IEMOP_VERIFICATION_UNDEFINED_EFLAGS(X86_EFL_AF);
    4569     IEMOP_BODY_BINARY_rm_r8(iemAImpl_test_u8, IEM_ACCESS_DATA_R);
     4681    IEMOP_BODY_BINARY_rm_r8_RO(iemAImpl_test_u8);
    45704682    IEMOP_BODY_BINARY_rm_r8_NO_LOCK();
    45714683}
    … …  
    46154727         * We're accessing memory.
    46164728         */
    4617 /** @todo the register must be committed separately! */
    4618         IEM_MC_BEGIN(2, 2);
    4619         IEM_MC_ARG(uint8_t *,  pu8Mem,           0);
    4620         IEM_MC_ARG(uint8_t *,  pu8Reg,           1);
     4729        IEM_MC_BEGIN(2, 4);
    46214730        IEM_MC_LOCAL(RTGCPTR, GCPtrEffDst);
     4731        IEM_MC_LOCAL(uint8_t, bUnmapInfo);
     4732        IEM_MC_LOCAL(uint8_t, uTmpReg);
     4733        IEM_MC_ARG(uint8_t *,           pu8Mem,          0);
     4734        IEM_MC_ARG_LOCAL_REF(uint8_t *, pu8Reg, uTmpReg, 1);
    46224735
    46234736        IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 0);
    46244737        IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
    4625         IEM_MC_MEM_MAP(pu8Mem, IEM_ACCESS_DATA_RW, pVCpu->iem.s.iEffSeg, GCPtrEffDst, 0 /*arg*/);
    4626         IEM_MC_REF_GREG_U8(pu8Reg, IEM_GET_MODRM_REG(pVCpu, bRm));
     4738        IEM_MC_MEM_MAP_U8_RW(pu8Mem, bUnmapInfo, pVCpu->iem.s.iEffSeg, GCPtrEffDst);
     4739        IEM_MC_FETCH_GREG_U8(uTmpReg, IEM_GET_MODRM_REG(pVCpu, bRm));
    46274740        if (!(pVCpu->iem.s.fExec & IEM_F_X86_DISREGARD_LOCK))
    46284741            IEM_MC_CALL_VOID_AIMPL_2(iemAImpl_xchg_u8_locked, pu8Mem, pu8Reg);
    46294742        else
    46304743            IEM_MC_CALL_VOID_AIMPL_2(iemAImpl_xchg_u8_unlocked, pu8Mem, pu8Reg);
    4631         IEM_MC_MEM_COMMIT_AND_UNMAP(pu8Mem, IEM_ACCESS_DATA_RW);
     4744        IEM_MC_MEM_COMMIT_AND_UNMAP_RW(pu8Mem, bUnmapInfo);
     4745        IEM_MC_STORE_GREG_U8(IEM_GET_MODRM_REG(pVCpu, bRm), uTmpReg);
    46324746
    46334747        IEM_MC_ADVANCE_RIP_AND_FINISH();
    … …  
    70927206    {
    70937207        /* memory */
    7094         IEM_MC_BEGIN(3, 2);
     7208        IEM_MC_BEGIN(3, 3);
    70957209        IEM_MC_ARG(uint8_t *,   pu8Dst,    0);
    70967210        IEM_MC_ARG(uint8_t,     cShiftArg,  1);
    70977211        IEM_MC_ARG_LOCAL_EFLAGS(pEFlags, EFlags, 2);
    70987212        IEM_MC_LOCAL(RTGCPTR, GCPtrEffDst);
     7213        IEM_MC_LOCAL(uint8_t, bUnmapInfo);
    70997214
    71007215        IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 1);
    … …  
    71027217        IEM_MC_ASSIGN(cShiftArg, cShift);
    71037218        IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
    7104         IEM_MC_MEM_MAP(pu8Dst, IEM_ACCESS_DATA_RW, pVCpu->iem.s.iEffSeg, GCPtrEffDst, 0 /*arg*/);
     7219        IEM_MC_MEM_MAP_U8_RW(pu8Dst, bUnmapInfo, pVCpu->iem.s.iEffSeg, GCPtrEffDst);
    71057220        IEM_MC_FETCH_EFLAGS(EFlags);
    71067221        IEM_MC_CALL_VOID_AIMPL_3(pImpl->pfnNormalU8, pu8Dst, cShiftArg, pEFlags);
    71077222
    7108         IEM_MC_MEM_COMMIT_AND_UNMAP(pu8Dst, IEM_ACCESS_DATA_RW);
     7223        IEM_MC_MEM_COMMIT_AND_UNMAP_RW(pu8Dst, bUnmapInfo);
    71097224        IEM_MC_COMMIT_EFLAGS(EFlags);
    71107225        IEM_MC_ADVANCE_RIP_AND_FINISH();
    … …  
    76887803    {
    76897804        /* memory */
    7690         IEM_MC_BEGIN(3, 2);
     7805        IEM_MC_BEGIN(3, 3);
    76917806        IEM_MC_ARG(uint8_t *,       pu8Dst,             0);
    76927807        IEM_MC_ARG_CONST(uint8_t,   cShiftArg,/*=*/1,   1);
    76937808        IEM_MC_ARG_LOCAL_EFLAGS(pEFlags, EFlags,        2);
    76947809        IEM_MC_LOCAL(RTGCPTR, GCPtrEffDst);
     7810        IEM_MC_LOCAL(uint8_t, bUnmapInfo);
    76957811
    76967812        IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 0);
    76977813        IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
    7698         IEM_MC_MEM_MAP(pu8Dst, IEM_ACCESS_DATA_RW, pVCpu->iem.s.iEffSeg, GCPtrEffDst, 0 /*arg*/);
     7814        IEM_MC_MEM_MAP_U8_RW(pu8Dst, bUnmapInfo, pVCpu->iem.s.iEffSeg, GCPtrEffDst);
    76997815        IEM_MC_FETCH_EFLAGS(EFlags);
    77007816        IEM_MC_CALL_VOID_AIMPL_3(pImpl->pfnNormalU8, pu8Dst, cShiftArg, pEFlags);
    77017817
    7702         IEM_MC_MEM_COMMIT_AND_UNMAP(pu8Dst, IEM_ACCESS_DATA_RW);
     7818        IEM_MC_MEM_COMMIT_AND_UNMAP_RW(pu8Dst, bUnmapInfo);
    77037819        IEM_MC_COMMIT_EFLAGS(EFlags);
    77047820        IEM_MC_ADVANCE_RIP_AND_FINISH();
    … …  
    78858001    {
    78868002        /* memory */
    7887         IEM_MC_BEGIN(3, 2);
     8003        IEM_MC_BEGIN(3, 3);
    78888004        IEM_MC_ARG(uint8_t *,   pu8Dst,          0);
    78898005        IEM_MC_ARG(uint8_t,     cShiftArg,       1);
    78908006        IEM_MC_ARG_LOCAL_EFLAGS(pEFlags, EFlags, 2);
    78918007        IEM_MC_LOCAL(RTGCPTR, GCPtrEffDst);
     8008        IEM_MC_LOCAL(uint8_t, bUnmapInfo);
    78928009
    78938010        IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 0);
    78948011        IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
    78958012        IEM_MC_FETCH_GREG_U8(cShiftArg, X86_GREG_xCX);
    7896         IEM_MC_MEM_MAP(pu8Dst, IEM_ACCESS_DATA_RW, pVCpu->iem.s.iEffSeg, GCPtrEffDst, 0 /*arg*/);
     8013        IEM_MC_MEM_MAP_U8_RW(pu8Dst, bUnmapInfo, pVCpu->iem.s.iEffSeg, GCPtrEffDst);
    78978014        IEM_MC_FETCH_EFLAGS(EFlags);
    78988015        IEM_MC_CALL_VOID_AIMPL_3(pImpl->pfnNormalU8, pu8Dst, cShiftArg, pEFlags);
    78998016
    7900         IEM_MC_MEM_COMMIT_AND_UNMAP(pu8Dst, IEM_ACCESS_DATA_RW);
     8017        IEM_MC_MEM_COMMIT_AND_UNMAP_RW(pu8Dst, bUnmapInfo);
    79018018        IEM_MC_COMMIT_EFLAGS(EFlags);
    79028019        IEM_MC_ADVANCE_RIP_AND_FINISH();
    … …  
    1181311930            IEM_MC_ARG_LOCAL_EFLAGS(    pEFlags, EFlags, 1); \
    1181411931            IEM_MC_LOCAL(RTGCPTR, GCPtrEffDst); \
     11932            IEM_MC_LOCAL(uint8_t, bUnmapInfo); \
    1181511933            \
    1181611934            IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, a_bRm, 0); \
    1181711935            IEMOP_HLP_DONE_DECODING(); \
    11818             IEM_MC_MEM_MAP(pu8Dst, IEM_ACCESS_DATA_RW, pVCpu->iem.s.iEffSeg, GCPtrEffDst, 0 /*arg*/); \
     11936            IEM_MC_MEM_MAP_U8_RW(pu8Dst, bUnmapInfo, pVCpu->iem.s.iEffSeg, GCPtrEffDst); \
    1181911937            IEM_MC_FETCH_EFLAGS(EFlags); \
    1182011938            IEM_MC_CALL_VOID_AIMPL_2(a_fnNormalU8, pu8Dst, pEFlags); \
    1182111939            \
    11822             IEM_MC_MEM_COMMIT_AND_UNMAP(pu8Dst, IEM_ACCESS_DATA_RW); \
     11940            IEM_MC_MEM_COMMIT_AND_UNMAP_RW(pu8Dst, bUnmapInfo); \
    1182311941            IEM_MC_COMMIT_EFLAGS(EFlags); \
    1182411942            IEM_MC_ADVANCE_RIP_AND_FINISH(); \
    … …  
    1183111949            IEM_MC_ARG_LOCAL_EFLAGS(    pEFlags, EFlags, 1); \
    1183211950            IEM_MC_LOCAL(RTGCPTR, GCPtrEffDst); \
     11951            IEM_MC_LOCAL(uint8_t, bUnmapInfo); \
    1183311952            \
    1183411953            IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, a_bRm, 0); \
    1183511954            IEMOP_HLP_DONE_DECODING(); \
    11836             IEM_MC_MEM_MAP(pu8Dst, IEM_ACCESS_DATA_RW, pVCpu->iem.s.iEffSeg, GCPtrEffDst, 0 /*arg*/); \
     11955            IEM_MC_MEM_MAP_U8_RW(pu8Dst, bUnmapInfo, pVCpu->iem.s.iEffSeg, GCPtrEffDst); \
    1183711956            IEM_MC_FETCH_EFLAGS(EFlags); \
    1183811957            IEM_MC_CALL_VOID_AIMPL_2(a_fnLockedU8, pu8Dst, pEFlags); \
    1183911958            \
    11840             IEM_MC_MEM_COMMIT_AND_UNMAP(pu8Dst, IEM_ACCESS_DATA_RW); \
     11959            IEM_MC_MEM_COMMIT_AND_UNMAP_RW(pu8Dst, bUnmapInfo); \
    1184111960            IEM_MC_COMMIT_EFLAGS(EFlags); \
    1184211961            IEM_MC_ADVANCE_RIP_AND_FINISH(); \
    … …  
    1206012179    {
    1206112180        /* memory access. */
    12062         IEM_MC_BEGIN(3, 2);
    12063         IEM_MC_ARG(uint8_t *,      pu8Dst,             0);
     12181        IEM_MC_BEGIN(3, 3);
     12182        IEM_MC_ARG(uint8_t const *, pu8Dst,             0);
    1206412183        IEM_MC_ARG(uint8_t,         u8Src,              1);
    1206512184        IEM_MC_ARG_LOCAL_EFLAGS(    pEFlags, EFlags,    2);
    1206612185        IEM_MC_LOCAL(RTGCPTR, GCPtrEffDst);
     12186        IEM_MC_LOCAL(uint8_t, bUnmapInfo);
    1206712187
    1206812188        IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 1);
    … …  
    1207012190        IEM_MC_ASSIGN(u8Src, u8Imm);
    1207112191        IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
    12072         IEM_MC_MEM_MAP(pu8Dst, IEM_ACCESS_DATA_R, pVCpu->iem.s.iEffSeg, GCPtrEffDst, 0 /*arg*/);
     12192        IEM_MC_MEM_MAP_U8_RO(pu8Dst, bUnmapInfo, pVCpu->iem.s.iEffSeg, GCPtrEffDst);
    1207312193        IEM_MC_FETCH_EFLAGS(EFlags);
    1207412194        IEM_MC_CALL_VOID_AIMPL_3(iemAImpl_test_u8, pu8Dst, u8Src, pEFlags);
    1207512195
    12076         IEM_MC_MEM_COMMIT_AND_UNMAP(pu8Dst, IEM_ACCESS_DATA_R);
     12196        IEM_MC_MEM_COMMIT_AND_UNMAP_RO(pu8Dst, bUnmapInfo);
    1207712197        IEM_MC_COMMIT_EFLAGS(EFlags);
    1207812198        IEM_MC_ADVANCE_RIP_AND_FINISH();
Note: See TracChangeset for help on using the changeset viewer.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette