VirtualBox

Changeset 100826 in vbox for trunk/src/VBox/VMM/VMMAll


Ignore:
Timestamp:
Aug 9, 2023 1:57:40 AM (18 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

Location:
trunk/src/VBox/VMM/VMMAll
Files:
6 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/VMM/VMMAll/IEMAllAImplC.cpp

    r100607 r100826  
    10341034
    10351035
    1036 IEM_DECL_IMPL_DEF(void, iemAImpl_cmp_u8,(uint8_t *puDst, uint8_t uSrc, uint32_t *pfEFlags))
     1036IEM_DECL_IMPL_DEF(void, iemAImpl_cmp_u8,(uint8_t const *puDst, uint8_t uSrc, uint32_t *pfEFlags))
    10371037{
    10381038    uint8_t uDstTmp = *puDst;
    … …  
    10681068
    10691069
    1070 IEM_DECL_IMPL_DEF(void, iemAImpl_test_u8,(uint8_t *puDst, uint8_t uSrc, uint32_t *pfEFlags))
     1070IEM_DECL_IMPL_DEF(void, iemAImpl_test_u8,(uint8_t const *puDst, uint8_t uSrc, uint32_t *pfEFlags))
    10711071{
    10721072    uint8_t uResult = *puDst & uSrc;

  • 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();

  • trunk/src/VBox/VMM/VMMAll/IEMAllInstPython.py

    r100753 r100826  
    28012801    'IEM_MC_MAYBE_RAISE_WAIT_DEVICE_NOT_AVAILABLE':              (McBlock.parseMcGeneric,           True),
    28022802    'IEM_MC_MEM_COMMIT_AND_UNMAP':                               (McBlock.parseMcGeneric,           True),
     2803    'IEM_MC_MEM_COMMIT_AND_UNMAP_RW':                            (McBlock.parseMcGeneric,           True),
     2804    'IEM_MC_MEM_COMMIT_AND_UNMAP_RO':                            (McBlock.parseMcGeneric,           True),
     2805    'IEM_MC_MEM_COMMIT_AND_UNMAP_WO':                            (McBlock.parseMcGeneric,           True),
    28032806    'IEM_MC_MEM_COMMIT_AND_UNMAP_FOR_FPU_STORE':                 (McBlock.parseMcGeneric,           True),
    28042807    'IEM_MC_MEM_MAP':                                            (McBlock.parseMcGeneric,           True),
    28052808    'IEM_MC_MEM_MAP_EX':                                         (McBlock.parseMcGeneric,           True),
     2809    'IEM_MC_MEM_MAP_U8_RW':                                      (McBlock.parseMcGeneric,           True),
     2810    'IEM_MC_MEM_MAP_U8_RO':                                      (McBlock.parseMcGeneric,           True),
     2811    'IEM_MC_MEM_MAP_U8_WO':                                      (McBlock.parseMcGeneric,           True),
     2812    'IEM_MC_MEM_MAP_U16_RW':                                     (McBlock.parseMcGeneric,           True),
     2813    'IEM_MC_MEM_MAP_U16_RO':                                     (McBlock.parseMcGeneric,           True),
     2814    'IEM_MC_MEM_MAP_U16_WO':                                     (McBlock.parseMcGeneric,           True),
     2815    'IEM_MC_MEM_MAP_U32_RW':                                     (McBlock.parseMcGeneric,           True),
     2816    'IEM_MC_MEM_MAP_U32_RO':                                     (McBlock.parseMcGeneric,           True),
     2817    'IEM_MC_MEM_MAP_U32_WO':                                     (McBlock.parseMcGeneric,           True),
     2818    'IEM_MC_MEM_MAP_U64_RW':                                     (McBlock.parseMcGeneric,           True),
     2819    'IEM_MC_MEM_MAP_U64_RO':                                     (McBlock.parseMcGeneric,           True),
     2820    'IEM_MC_MEM_MAP_U64_WO':                                     (McBlock.parseMcGeneric,           True),
    28062821    'IEM_MC_MERGE_YREG_U32_U96_ZX_VLMAX':                        (McBlock.parseMcGeneric,           True),
    28072822    'IEM_MC_MERGE_YREG_U64_U64_ZX_VLMAX':                        (McBlock.parseMcGeneric,           True),

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

    r100822 r100826  
    100100    /* The lazy approach for now... */
    101101    TMPL_MEM_TYPE *puDst;
    102     VBOXSTRICTRC rc = iemMemMap(pVCpu, (void **)&puDst, sizeof(*puDst), iSegReg, GCPtrMem, IEM_ACCESS_DATA_W, 0);
     102    VBOXSTRICTRC rc = iemMemMap(pVCpu, (void **)&puDst, sizeof(*puDst), iSegReg, GCPtrMem, IEM_ACCESS_DATA_W, TMPL_MEM_TYPE_ALIGN);
    103103    if (rc == VINF_SUCCESS)
    104104    {
    … …  
    128128# endif
    129129    Log8(("IEM WR " TMPL_MEM_FMT_DESC " %d|%RGv: " TMPL_MEM_FMT_TYPE "\n", iSegReg, GCPtrMem, uValue));
    130     TMPL_MEM_TYPE *puDst = (TMPL_MEM_TYPE *)iemMemMapJmp(pVCpu, sizeof(*puDst), iSegReg, GCPtrMem, IEM_ACCESS_DATA_W, 0);
     130    TMPL_MEM_TYPE *puDst = (TMPL_MEM_TYPE *)iemMemMapJmp(pVCpu, sizeof(*puDst), iSegReg, GCPtrMem,
     131                                                         IEM_ACCESS_DATA_W, TMPL_MEM_TYPE_ALIGN);
    131132    *puDst = uValue;
    132133    iemMemCommitAndUnmapJmp(pVCpu, puDst, IEM_ACCESS_DATA_W);
    133134}
     135#endif /* IEM_WITH_SETJMP */
     136
     137
     138#ifdef IEM_WITH_SETJMP
     139
     140/**
     141 * Maps a data buffer for read+write direct access (or via a bounce buffer),
     142 * longjmp on error.
     143 *
     144 * @param   pVCpu               The cross context virtual CPU structure of the calling thread.
     145 * @param   pbUnmapInfo         Pointer to unmap info variable.
     146 * @param   iSegReg             The index of the segment register to use for
     147 *                              this access.  The base and limits are checked.
     148 * @param   GCPtrMem            The address of the guest memory.
     149 */
     150TMPL_MEM_TYPE *
     151RT_CONCAT3(iemMemMapData,TMPL_MEM_FN_SUFF,RwSafeJmp)(PVMCPUCC pVCpu, uint8_t *pbUnmapInfo,
     152                                                     uint8_t iSegReg, RTGCPTR GCPtrMem) IEM_NOEXCEPT_MAY_LONGJMP
     153{
     154# if defined(IEM_WITH_DATA_TLB) && defined(IN_RING3)
     155    pVCpu->iem.s.DataTlb.cTlbSafeWritePath++;
     156# endif
     157    Log8(("IEM RW/map " TMPL_MEM_FMT_DESC " %d|%RGv\n", iSegReg, GCPtrMem));
     158    *pbUnmapInfo = 1 | ((IEM_ACCESS_TYPE_READ  | IEM_ACCESS_TYPE_WRITE) << 4); /* zero is for the TLB hit */
     159    return (TMPL_MEM_TYPE *)iemMemMapJmp(pVCpu, sizeof(TMPL_MEM_TYPE), iSegReg, GCPtrMem, IEM_ACCESS_DATA_RW, TMPL_MEM_TYPE_ALIGN);
     160}
     161
     162
     163/**
     164 * Maps a data buffer for writeonly direct access (or via a bounce buffer),
     165 * longjmp on error.
     166 *
     167 * @param   pVCpu               The cross context virtual CPU structure of the calling thread.
     168 * @param   pbUnmapInfo         Pointer to unmap info variable.
     169 * @param   iSegReg             The index of the segment register to use for
     170 *                              this access.  The base and limits are checked.
     171 * @param   GCPtrMem            The address of the guest memory.
     172 */
     173TMPL_MEM_TYPE *
     174RT_CONCAT3(iemMemMapData,TMPL_MEM_FN_SUFF,WoSafeJmp)(PVMCPUCC pVCpu, uint8_t *pbUnmapInfo,
     175                                                     uint8_t iSegReg, RTGCPTR GCPtrMem) IEM_NOEXCEPT_MAY_LONGJMP
     176{
     177# if defined(IEM_WITH_DATA_TLB) && defined(IN_RING3)
     178    pVCpu->iem.s.DataTlb.cTlbSafeWritePath++;
     179# endif
     180    Log8(("IEM WO/map " TMPL_MEM_FMT_DESC " %d|%RGv\n", iSegReg, GCPtrMem));
     181    *pbUnmapInfo = 1 | (IEM_ACCESS_TYPE_WRITE << 4); /* zero is for the TLB hit */
     182    return (TMPL_MEM_TYPE *)iemMemMapJmp(pVCpu, sizeof(TMPL_MEM_TYPE), iSegReg, GCPtrMem, IEM_ACCESS_DATA_W, TMPL_MEM_TYPE_ALIGN);
     183}
     184
     185
     186/**
     187 * Maps a data buffer for readonly direct access (or via a bounce buffer),
     188 * longjmp on error.
     189 *
     190 * @param   pVCpu               The cross context virtual CPU structure of the calling thread.
     191 * @param   pbUnmapInfo         Pointer to unmap info variable.
     192 * @param   iSegReg             The index of the segment register to use for
     193 *                              this access.  The base and limits are checked.
     194 * @param   GCPtrMem            The address of the guest memory.
     195 */
     196TMPL_MEM_TYPE const *
     197RT_CONCAT3(iemMemMapData,TMPL_MEM_FN_SUFF,RoSafeJmp)(PVMCPUCC pVCpu, uint8_t *pbUnmapInfo,
     198                                                     uint8_t iSegReg, RTGCPTR GCPtrMem) IEM_NOEXCEPT_MAY_LONGJMP
     199{
     200# if defined(IEM_WITH_DATA_TLB) && defined(IN_RING3)
     201    pVCpu->iem.s.DataTlb.cTlbSafeWritePath++;
     202# endif
     203    Log8(("IEM WO/map " TMPL_MEM_FMT_DESC " %d|%RGv\n", iSegReg, GCPtrMem));
     204    *pbUnmapInfo = 1 | (IEM_ACCESS_TYPE_READ << 4); /* zero is for the TLB hit */
     205    return (TMPL_MEM_TYPE *)iemMemMapJmp(pVCpu, sizeof(TMPL_MEM_TYPE), iSegReg, GCPtrMem, IEM_ACCESS_DATA_R, TMPL_MEM_TYPE_ALIGN);
     206}
     207
    134208#endif /* IEM_WITH_SETJMP */
    135209

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

    r100822 r100826  
    5050
    5151#ifdef IEM_WITH_SETJMP
     52
     53/*********************************************************************************************************************************
     54*   Fetches                                                                                                                      *
     55*********************************************************************************************************************************/
    5256
    5357/**
    … …  
    196200}
    197201
     202
     203/*********************************************************************************************************************************
     204*   Stores                                                                                                                       *
     205*********************************************************************************************************************************/
    198206# ifndef TMPL_MEM_NO_STORE
    199207
    … …  
    348356# endif /* !TMPL_MEM_NO_STORE */
    349357
     358
     359/*********************************************************************************************************************************
     360*   Mapping / Direct Memory Access                                                                                               *
     361*********************************************************************************************************************************/
     362# ifndef TMPL_MEM_NO_MAPPING
     363
     364/**
     365 * Inlined read-write memory mapping function that longjumps on error.
     366 */
     367DECL_INLINE_THROW(TMPL_MEM_TYPE *)
     368RT_CONCAT3(iemMemMapData,TMPL_MEM_FN_SUFF,RwJmp)(PVMCPUCC pVCpu, uint8_t *pbUnmapInfo,
     369                                                 uint8_t iSegReg, RTGCPTR GCPtrMem) IEM_NOEXCEPT_MAY_LONGJMP
     370{
     371    return RT_CONCAT3(iemMemMapData,TMPL_MEM_FN_SUFF,RwSafeJmp)(pVCpu, pbUnmapInfo, iSegReg, GCPtrMem);
     372}
     373
     374
     375/**
     376 * Inlined flat read-write memory mapping function that longjumps on error.
     377 */
     378DECL_INLINE_THROW(TMPL_MEM_TYPE *)
     379RT_CONCAT3(iemMemFlatMapData,TMPL_MEM_FN_SUFF,RwJmp)(PVMCPUCC pVCpu, uint8_t *pbUnmapInfo,
     380                                                     RTGCPTR GCPtrMem) IEM_NOEXCEPT_MAY_LONGJMP
     381{
     382    return RT_CONCAT3(iemMemMapData,TMPL_MEM_FN_SUFF,RwSafeJmp)(pVCpu, pbUnmapInfo, UINT8_MAX, GCPtrMem);
     383}
     384
     385
     386/**
     387 * Inlined write-only memory mapping function that longjumps on error.
     388 */
     389DECL_INLINE_THROW(TMPL_MEM_TYPE *)
     390RT_CONCAT3(iemMemMapData,TMPL_MEM_FN_SUFF,WoJmp)(PVMCPUCC pVCpu, uint8_t *pbUnmapInfo,
     391                                                 uint8_t iSegReg, RTGCPTR GCPtrMem) IEM_NOEXCEPT_MAY_LONGJMP
     392{
     393    return RT_CONCAT3(iemMemMapData,TMPL_MEM_FN_SUFF,WoSafeJmp)(pVCpu, pbUnmapInfo, iSegReg, GCPtrMem);
     394}
     395
     396
     397/**
     398 * Inlined flat write-only memory mapping function that longjumps on error.
     399 */
     400DECL_INLINE_THROW(TMPL_MEM_TYPE *)
     401RT_CONCAT3(iemMemFlatMapData,TMPL_MEM_FN_SUFF,WoJmp)(PVMCPUCC pVCpu, uint8_t *pbUnmapInfo,
     402                                                     RTGCPTR GCPtrMem) IEM_NOEXCEPT_MAY_LONGJMP
     403{
     404    return RT_CONCAT3(iemMemMapData,TMPL_MEM_FN_SUFF,WoSafeJmp)(pVCpu, pbUnmapInfo, UINT8_MAX, GCPtrMem);
     405}
     406
     407
     408/**
     409 * Inlined read-only memory mapping function that longjumps on error.
     410 */
     411DECL_INLINE_THROW(TMPL_MEM_TYPE const *)
     412RT_CONCAT3(iemMemMapData,TMPL_MEM_FN_SUFF,RoJmp)(PVMCPUCC pVCpu, uint8_t *pbUnmapInfo,
     413                                                 uint8_t iSegReg, RTGCPTR GCPtrMem) IEM_NOEXCEPT_MAY_LONGJMP
     414{
     415    return RT_CONCAT3(iemMemMapData,TMPL_MEM_FN_SUFF,RoSafeJmp)(pVCpu, pbUnmapInfo, iSegReg, GCPtrMem);
     416}
     417
     418
     419/**
     420 * Inlined read-only memory mapping function that longjumps on error.
     421 */
     422DECL_INLINE_THROW(TMPL_MEM_TYPE const *)
     423RT_CONCAT3(iemMemFlatMapData,TMPL_MEM_FN_SUFF,RoJmp)(PVMCPUCC pVCpu, uint8_t *pbUnmapInfo,
     424                                                     RTGCPTR GCPtrMem) IEM_NOEXCEPT_MAY_LONGJMP
     425{
     426    return RT_CONCAT3(iemMemMapData,TMPL_MEM_FN_SUFF,RoSafeJmp)(pVCpu, pbUnmapInfo, UINT8_MAX, GCPtrMem);
     427}
     428
     429# endif /* !TMPL_MEM_NO_MAPPING */
     430
     431
    350432#endif /* IEM_WITH_SETJMP */
    351433

  • trunk/src/VBox/VMM/VMMAll/IEMAllThrdPython.py

    r100811 r100826  
    489489        'IEM_MC_POP_EX_U64':                      ( -1, 'IEM_MC_FLAT_POP_EX_U64' ),
    490490        'IEM_MC_MEM_MAP':                         (  2, 'IEM_MC_MEM_FLAT_MAP' ),
     491        'IEM_MC_MEM_MAP_U8_RW':                   (  2, 'IEM_MC_MEM_FLAT_MAP_U8_RW' ),
     492        'IEM_MC_MEM_MAP_U8_RO':                   (  2, 'IEM_MC_MEM_FLAT_MAP_U8_RO' ),
     493        'IEM_MC_MEM_MAP_U8_WO':                   (  2, 'IEM_MC_MEM_FLAT_MAP_U8_WO' ),
     494        'IEM_MC_MEM_MAP_U16_RW':                  (  2, 'IEM_MC_MEM_FLAT_MAP_U16_RW' ),
     495        'IEM_MC_MEM_MAP_U16_RO':                  (  2, 'IEM_MC_MEM_FLAT_MAP_U16_RO' ),
     496        'IEM_MC_MEM_MAP_U16_WO':                  (  2, 'IEM_MC_MEM_FLAT_MAP_U16_WO' ),
     497        'IEM_MC_MEM_MAP_U32_RW':                  (  2, 'IEM_MC_MEM_FLAT_MAP_U32_RW' ),
     498        'IEM_MC_MEM_MAP_U32_RO':                  (  2, 'IEM_MC_MEM_FLAT_MAP_U32_RO' ),
     499        'IEM_MC_MEM_MAP_U32_WO':                  (  2, 'IEM_MC_MEM_FLAT_MAP_U32_WO' ),
     500        'IEM_MC_MEM_MAP_U64_RW':                  (  2, 'IEM_MC_MEM_FLAT_MAP_U64_RW' ),
     501        'IEM_MC_MEM_MAP_U64_RO':                  (  2, 'IEM_MC_MEM_FLAT_MAP_U64_RO' ),
     502        'IEM_MC_MEM_MAP_U64_WO':                  (  2, 'IEM_MC_MEM_FLAT_MAP_U64_WO' ),
    491503        'IEM_MC_MEM_MAP_EX':                      (  3, 'IEM_MC_MEM_FLAT_MAP_EX' ),
    492504    };
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