VirtualBox

Changeset 100826 in vbox


Ignore:
Timestamp:
Aug 9, 2023 1:57:40 AM (19 months ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
158725
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
Files:
11 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    };

  • trunk/src/VBox/VMM/include/IEMInline.h

    r100822 r100826  
    34453445
    34463446#define TMPL_MEM_NO_STORE
     3447#define TMPL_MEM_NO_MAPPING
    34473448#define TMPL_MEM_TYPE       uint64_t
    34483449#define TMPL_MEM_TYPE_ALIGN 15

  • trunk/src/VBox/VMM/include/IEMInternal.h

    r100822 r100826  
    18091809/** @}  */
    18101810
     1811typedef IEM_DECL_IMPL_TYPE(void, FNIEMAIMPLBINROU8,(uint8_t const *pu8Dst, uint8_t u8Src, uint32_t *pEFlags));
     1812typedef FNIEMAIMPLBINROU8 *PFNIEMAIMPLBINROU8;
     1813typedef IEM_DECL_IMPL_TYPE(void, FNIEMAIMPLBINROU16,(uint16_t const *pu16Dst, uint16_t u16Src, uint32_t *pEFlags));
     1814typedef FNIEMAIMPLBINROU16 *PFNIEMAIMPLBINROU16;
     1815typedef IEM_DECL_IMPL_TYPE(void, FNIEMAIMPLBINROU32,(uint32_t const *pu32Dst, uint32_t u32Src, uint32_t *pEFlags));
     1816typedef FNIEMAIMPLBINROU32 *PFNIEMAIMPLBINROU32;
     1817typedef IEM_DECL_IMPL_TYPE(void, FNIEMAIMPLBINROU64,(uint64_t const *pu64Dst, uint64_t u64Src, uint32_t *pEFlags));
     1818typedef FNIEMAIMPLBINROU64 *PFNIEMAIMPLBINROU64;
     1819
    18111820/** @name Compare operations (thrown in with the binary ops).
    18121821 * @{ */
    1813 FNIEMAIMPLBINU8  iemAImpl_cmp_u8;
     1822FNIEMAIMPLBINROU8  iemAImpl_cmp_u8;
    18141823FNIEMAIMPLBINU16 iemAImpl_cmp_u16;
    18151824FNIEMAIMPLBINU32 iemAImpl_cmp_u32;
    … …  
    18191828/** @name Test operations (thrown in with the binary ops).
    18201829 * @{ */
    1821 FNIEMAIMPLBINU8  iemAImpl_test_u8;
     1830FNIEMAIMPLBINROU8  iemAImpl_test_u8;
    18221831FNIEMAIMPLBINU16 iemAImpl_test_u16;
    18231832FNIEMAIMPLBINU32 iemAImpl_test_u32;
    … …  
    46514660void            iemMemStoreDataU256Jmp(PVMCPUCC pVCpu, uint8_t iSegReg, RTGCPTR GCPtrMem, PCRTUINT256U pu256Value) IEM_NOEXCEPT_MAY_LONGJMP;
    46524661void            iemMemStoreDataU256AlignedAvxJmp(PVMCPUCC pVCpu, uint8_t iSegReg, RTGCPTR GCPtrMem, PCRTUINT256U pu256Value) IEM_NOEXCEPT_MAY_LONGJMP;
     4662#endif
     4663
     4664#ifdef IEM_WITH_SETJMP
     4665uint8_t        *iemMemMapDataU8RwSafeJmp(PVMCPUCC pVCpu, uint8_t *pbUnmapInfo, uint8_t iSegReg, RTGCPTR GCPtrMem) IEM_NOEXCEPT_MAY_LONGJMP;
     4666uint8_t        *iemMemMapDataU8WoSafeJmp(PVMCPUCC pVCpu, uint8_t *pbUnmapInfo, uint8_t iSegReg, RTGCPTR GCPtrMem) IEM_NOEXCEPT_MAY_LONGJMP;
     4667uint8_t const  *iemMemMapDataU8RoSafeJmp(PVMCPUCC pVCpu, uint8_t *pbUnmapInfo, uint8_t iSegReg, RTGCPTR GCPtrMem) IEM_NOEXCEPT_MAY_LONGJMP;
     4668uint16_t       *iemMemMapDataU16RwSafeJmp(PVMCPUCC pVCpu, uint8_t *pbUnmapInfo, uint8_t iSegReg, RTGCPTR GCPtrMem) IEM_NOEXCEPT_MAY_LONGJMP;
     4669uint16_t       *iemMemMapDataU16WoSafeJmp(PVMCPUCC pVCpu, uint8_t *pbUnmapInfo, uint8_t iSegReg, RTGCPTR GCPtrMem) IEM_NOEXCEPT_MAY_LONGJMP;
     4670uint16_t const *iemMemMapDataU16RoSafeJmp(PVMCPUCC pVCpu, uint8_t *pbUnmapInfo, uint8_t iSegReg, RTGCPTR GCPtrMem) IEM_NOEXCEPT_MAY_LONGJMP;
     4671uint32_t       *iemMemMapDataU32RwSafeJmp(PVMCPUCC pVCpu, uint8_t *pbUnmapInfo, uint8_t iSegReg, RTGCPTR GCPtrMem) IEM_NOEXCEPT_MAY_LONGJMP;
     4672uint32_t       *iemMemMapDataU32WoSafeJmp(PVMCPUCC pVCpu, uint8_t *pbUnmapInfo, uint8_t iSegReg, RTGCPTR GCPtrMem) IEM_NOEXCEPT_MAY_LONGJMP;
     4673uint32_t const *iemMemMapDataU32RoSafeJmp(PVMCPUCC pVCpu, uint8_t *pbUnmapInfo, uint8_t iSegReg, RTGCPTR GCPtrMem) IEM_NOEXCEPT_MAY_LONGJMP;
     4674uint64_t       *iemMemMapDataU64RwSafeJmp(PVMCPUCC pVCpu, uint8_t *pbUnmapInfo, uint8_t iSegReg, RTGCPTR GCPtrMem) IEM_NOEXCEPT_MAY_LONGJMP;
     4675uint64_t       *iemMemMapDataU64WoSafeJmp(PVMCPUCC pVCpu, uint8_t *pbUnmapInfo, uint8_t iSegReg, RTGCPTR GCPtrMem) IEM_NOEXCEPT_MAY_LONGJMP;
     4676uint64_t const *iemMemMapDataU64RoSafeJmp(PVMCPUCC pVCpu, uint8_t *pbUnmapInfo, uint8_t iSegReg, RTGCPTR GCPtrMem) IEM_NOEXCEPT_MAY_LONGJMP;
    46534677#endif
    46544678

  • trunk/src/VBox/VMM/include/IEMMc.h

    r100820 r100826  
    13251325 * The purpose is to pass it to an operand implementation, thus the a_iArg.
    13261326 * @remarks     May return.
     1327 * @deprecated
    13271328 */
    13281329#define IEM_MC_MEM_MAP(a_pMem, a_fAccess, a_iSeg, a_GCPtrMem, a_iArg) \
    … …  
    13301331                                       (a_GCPtrMem), (a_fAccess), sizeof(*(a_pMem)) - 1))
    13311332
    1332 /** Flat variant of IEM_MC_MEM_MAP. */
     1333/** Flat variant of IEM_MC_MEM_MAP.
     1334 * @deprecated
     1335 */
    13331336#define IEM_MC_MEM_FLAT_MAP(a_pMem, a_fAccess, a_GCPtrMem, a_iArg) \
    13341337    IEM_MC_RETURN_ON_FAILURE(iemMemMap(pVCpu, (void **)&(a_pMem), sizeof(*(a_pMem)), UINT8_MAX, \
    … …  
    13381341 * The purpose is to pass it to an operand implementation, thus the a_iArg.
    13391342 * @remarks     May return.
     1343 * @deprecated
    13401344 */
    13411345#define IEM_MC_MEM_MAP_EX(a_pvMem, a_fAccess, a_cbMem, a_iSeg, a_GCPtrMem, a_cbAlign, a_iArg) \
    … …  
    13431347                                       (a_GCPtrMem), (a_fAccess), (a_cbAlign)))
    13441348
    1345 /** Flat variant of IEM_MC_MEM_MAP_EX. */
     1349/** Flat variant of IEM_MC_MEM_MAP_EX.
     1350 * @deprecated
     1351 */
    13461352#define IEM_MC_MEM_FLAT_MAP_EX(a_pvMem, a_fAccess, a_cbMem, a_GCPtrMem, a_cbAlign, a_iArg) \
    13471353    IEM_MC_RETURN_ON_FAILURE(iemMemMap(pVCpu, (void **)&(a_pvMem), (a_cbMem), UINT8_MAX, \
    … …  
    13501356/** Commits the memory and unmaps the guest memory.
    13511357 * @remarks     May return.
     1358 * @deprecated
    13521359 */
    13531360#define IEM_MC_MEM_COMMIT_AND_UNMAP(a_pvMem, a_fAccess) \
    13541361    IEM_MC_RETURN_ON_FAILURE(iemMemCommitAndUnmap(pVCpu, (a_pvMem), (a_fAccess)))
     1362
     1363
     1364/**
     1365 * Maps guest memory for byte read+write direct (or bounce) buffer acccess.
     1366 *
     1367 * @param[out] a_pu8Mem     Where to return the pointer to the mapping.
     1368 * @param[out] a_bUnmapInfo Where to return umapping instructions. uint8_t.
     1369 * @param[in]  a_iSeg       The segment register to access via. No UINT8_MAX!
     1370 * @param[in]  a_GCPtrMem   The memory address.
     1371 * @remarks Will return/long jump on errors.
     1372 * @see     IEM_MC_MEM_COMMIT_AND_UNMAP_RW
     1373 */
     1374#ifndef IEM_WITH_SETJMP
     1375# define IEM_MC_MEM_MAP_U8_RW(a_pu8Mem, a_bUnmapInfo, a_iSeg, a_GCPtrMem) do { \
     1376        IEM_MC_RETURN_ON_FAILURE(iemMemMap(pVCpu, (void **)&(a_pu8Mem), sizeof(uint8_t), (a_iSeg), \
     1377                                           (a_GCPtrMem), IEM_ACCESS_DATA_RW, 0)); \
     1378        a_bUnmapInfo = 1 | ((IEM_ACCESS_TYPE_READ | IEM_ACCESS_TYPE_WRITE) << 4); \
     1379    } while (0)
     1380#else
     1381# define IEM_MC_MEM_MAP_U8_RW(a_pu8Mem, a_bUnmapInfo, a_iSeg, a_GCPtrMem) \
     1382    (a_pu8Mem) = iemMemMapDataU8RwJmp(pVCpu, &(a_bUnmapInfo), (a_iSeg), (a_GCPtrMem))
     1383#endif
     1384
     1385/**
     1386 * Maps guest memory for byte writeonly direct (or bounce) buffer acccess.
     1387 *
     1388 * @param[out] a_pu8Mem     Where to return the pointer to the mapping.
     1389 * @param[out] a_bUnmapInfo Where to return umapping instructions. uint8_t.
     1390 * @param[in]  a_iSeg       The segment register to access via. No UINT8_MAX!
     1391 * @param[in]  a_GCPtrMem   The memory address.
     1392 * @remarks Will return/long jump on errors.
     1393 * @see     IEM_MC_MEM_COMMIT_AND_UNMAP_WO
     1394 */
     1395#ifndef IEM_WITH_SETJMP
     1396# define IEM_MC_MEM_MAP_U8_WO(a_pu8Mem, a_bUnmapInfo, a_iSeg, a_GCPtrMem) do { \
     1397        IEM_MC_RETURN_ON_FAILURE(iemMemMap(pVCpu, (void **)&(a_pu8Mem), sizeof(uint8_t), (a_iSeg), \
     1398                                           (a_GCPtrMem), IEM_ACCESS_DATA_W, 0)); \
     1399        a_bUnmapInfo = 1 | (IEM_ACCESS_TYPE_WRITE << 4); \
     1400    } while (0)
     1401#else
     1402# define IEM_MC_MEM_MAP_U8_WO(a_pu8Mem, a_bUnmapInfo, a_iSeg, a_GCPtrMem) \
     1403    (a_pu8Mem) = iemMemMapDataU8WoJmp(pVCpu, &(a_bUnmapInfo), (a_iSeg), (a_GCPtrMem))
     1404#endif
     1405
     1406/**
     1407 * Maps guest memory for byte readonly direct (or bounce) buffer acccess.
     1408 *
     1409 * @param[out] a_pu8Mem     Where to return the pointer to the mapping.
     1410 * @param[out] a_bUnmapInfo Where to return umapping instructions. uint8_t.
     1411 * @param[in]  a_iSeg       The segment register to access via. No UINT8_MAX!
     1412 * @param[in]  a_GCPtrMem   The memory address.
     1413 * @remarks Will return/long jump on errors.
     1414 * @see     IEM_MC_MEM_COMMIT_AND_UNMAP_RO
     1415 */
     1416#ifndef IEM_WITH_SETJMP
     1417# define IEM_MC_MEM_MAP_U8_RO(a_pu8Mem, a_bUnmapInfo, a_iSeg, a_GCPtrMem) do { \
     1418        IEM_MC_RETURN_ON_FAILURE(iemMemMap(pVCpu, (void **)&(a_pu8Mem), sizeof(uint8_t), (a_iSeg), \
     1419                                           (a_GCPtrMem), IEM_ACCESS_DATA_R, 0)); \
     1420        a_bUnmapInfo = 1 | (IEM_ACCESS_TYPE_READ << 4); \
     1421    } while (0)
     1422#else
     1423# define IEM_MC_MEM_MAP_U8_RO(a_pu8Mem, a_bUnmapInfo, a_iSeg, a_GCPtrMem) \
     1424    (a_pu8Mem) = iemMemMapDataU8RoJmp(pVCpu, &(a_bUnmapInfo), (a_iSeg), (a_GCPtrMem))
     1425#endif
     1426
     1427/**
     1428 * Maps guest memory for byte read+write direct (or bounce) buffer acccess, flat
     1429 * address variant.
     1430 *
     1431 * @param[out] a_pu8Mem     Where to return the pointer to the mapping.
     1432 * @param[out] a_bUnmapInfo Where to return umapping instructions. uint8_t.
     1433 * @param[in]  a_GCPtrMem   The memory address.
     1434 * @remarks Will return/long jump on errors.
     1435 * @see     IEM_MC_MEM_COMMIT_AND_UNMAP_RW
     1436 */
     1437#ifndef IEM_WITH_SETJMP
     1438# define IEM_MC_MEM_FLAT_MAP_U8_RW(a_pu8Mem, a_bUnmapInfo, a_GCPtrMem) do { \
     1439        IEM_MC_RETURN_ON_FAILURE(iemMemMap(pVCpu, (void **)&(a_pu8Mem), sizeof(uint8_t), UINT8_MAX, \
     1440                                           (a_GCPtrMem), IEM_ACCESS_DATA_RW, 0)); \
     1441        a_bUnmapInfo = 1 | ((IEM_ACCESS_TYPE_READ | IEM_ACCESS_TYPE_WRITE) << 4); \
     1442    } while (0)
     1443#else
     1444# define IEM_MC_MEM_FLAT_MAP_U8_RW(a_pu8Mem, a_bUnmapInfo, a_GCPtrMem) \
     1445    (a_pu8Mem) = iemMemFlatMapDataU8RwJmp(pVCpu, &(a_bUnmapInfo), (a_GCPtrMem))
     1446#endif
     1447
     1448/**
     1449 * Maps guest memory for byte writeonly direct (or bounce) buffer acccess, flat
     1450 * address variant.
     1451 *
     1452 * @param[out] a_pu8Mem     Where to return the pointer to the mapping.
     1453 * @param[out] a_bUnmapInfo Where to return umapping instructions. uint8_t.
     1454 * @param[in]  a_GCPtrMem   The memory address.
     1455 * @remarks Will return/long jump on errors.
     1456 * @see     IEM_MC_MEM_COMMIT_AND_UNMAP_WO
     1457 */
     1458#ifndef IEM_WITH_SETJMP
     1459# define IEM_MC_MEM_FLAT_MAP_U8_WO(a_pu8Mem, a_bUnmapInfo, a_GCPtrMem) do { \
     1460        IEM_MC_RETURN_ON_FAILURE(iemMemMap(pVCpu, (void **)&(a_pu8Mem), sizeof(uint8_t), UINT8_MAX, \
     1461                                           (a_GCPtrMem), IEM_ACCESS_DATA_W, 0)); \
     1462        a_bUnmapInfo = 1 | (IEM_ACCESS_TYPE_WRITE << 4); \
     1463    } while (0)
     1464#else
     1465# define IEM_MC_MEM_FLAT_MAP_U8_WO(a_pu8Mem, a_bUnmapInfo, a_GCPtrMem) \
     1466    (a_pu8Mem) = iemMemFlatMapDataU8WoJmp(pVCpu, &(a_bUnmapInfo), (a_GCPtrMem))
     1467#endif
     1468
     1469/**
     1470 * Maps guest memory for byte readonly direct (or bounce) buffer acccess, flat
     1471 * address variant.
     1472 *
     1473 * @param[out] a_pu8Mem     Where to return the pointer to the mapping.
     1474 * @param[out] a_bUnmapInfo Where to return umapping instructions. uint8_t.
     1475 * @param[in]  a_GCPtrMem   The memory address.
     1476 * @remarks Will return/long jump on errors.
     1477 * @see     IEM_MC_MEM_COMMIT_AND_UNMAP_RO
     1478 */
     1479#ifndef IEM_WITH_SETJMP
     1480# define IEM_MC_MEM_FLAT_MAP_U8_RO(a_pu8Mem, a_bUnmapInfo, a_GCPtrMem) do { \
     1481        IEM_MC_RETURN_ON_FAILURE(iemMemMap(pVCpu, (void **)&(a_pu8Mem), sizeof(uint8_t), UINT8_MAX, \
     1482                                           (a_GCPtrMem), IEM_ACCESS_DATA_R, 0)); \
     1483        a_bUnmapInfo = 1 | (IEM_ACCESS_TYPE_READ << 4); \
     1484    } while (0)
     1485#else
     1486# define IEM_MC_MEM_FLAT_MAP_U8_RO(a_pu8Mem, a_bUnmapInfo, a_GCPtrMem) \
     1487    (a_pu8Mem) = iemMemFlatMapDataU8RoJmp(pVCpu, &(a_bUnmapInfo), (a_GCPtrMem))
     1488#endif
     1489
     1490
     1491/** Commits the memory and unmaps guest memory previously mapped RW.
     1492 * @remarks     May return.
     1493 */
     1494#define IEM_MC_MEM_COMMIT_AND_UNMAP_RW(a_pvMem, a_bMapInfo) do { \
     1495        RT_NOREF_PV(a_bMapInfo); Assert(a_bMapInfo == (1 | ((IEM_ACCESS_TYPE_READ | IEM_ACCESS_TYPE_WRITE) << 4)) ); \
     1496        IEM_MC_RETURN_ON_FAILURE(iemMemCommitAndUnmap(pVCpu, (a_pvMem), IEM_ACCESS_DATA_RW)); \
     1497    } while (0)
     1498
     1499/** Commits the memory and unmaps guest memory previously mapped W.
     1500 * @remarks     May return.
     1501 */
     1502#define IEM_MC_MEM_COMMIT_AND_UNMAP_WO(a_pvMem, a_bMapInfo) do { \
     1503        RT_NOREF_PV(a_bMapInfo); Assert(a_bMapInfo == (1 | (IEM_ACCESS_TYPE_WRITE << 4)) ); \
     1504        IEM_MC_RETURN_ON_FAILURE(iemMemCommitAndUnmap(pVCpu, (a_pvMem), IEM_ACCESS_DATA_W)); \
     1505    } while (0)
     1506
     1507/** Commits the memory and unmaps guest memory previously mapped R.
     1508 * @remarks     May return.
     1509 */
     1510#define IEM_MC_MEM_COMMIT_AND_UNMAP_RO(a_pvMem, a_bMapInfo) do { \
     1511        RT_NOREF_PV(a_bMapInfo); Assert(a_bMapInfo == (1 | (IEM_ACCESS_TYPE_READ << 4)) ); \
     1512        IEM_MC_RETURN_ON_FAILURE(iemMemCommitAndUnmap(pVCpu, (void *)(a_pvMem), IEM_ACCESS_DATA_R)); \
     1513    } while (0)
     1514
    13551515
    13561516/** Commits the memory and unmaps the guest memory unless the FPU status word
    … …  
    13701530            IEM_MC_RETURN_ON_FAILURE(iemMemCommitAndUnmap(pVCpu, (a_pvMem), (a_fAccess))); \
    13711531    } while (0)
     1532
     1533
    13721534
    13731535/** Calculate efficient address from R/M. */

  • trunk/src/VBox/VMM/testcase/tstIEMAImpl.cpp

    r99775 r100826  
    5555#define ENTRY_EX(a_Name, a_uExtra) \
    5656    { RT_XSTR(a_Name), iemAImpl_ ## a_Name, NULL, \
     57      g_aTests_ ## a_Name, &g_cTests_ ## a_Name, \
     58      a_uExtra, IEMTARGETCPU_EFL_BEHAVIOR_NATIVE /* means same for all here */ }
     59
     60#define ENTRY_PFN_CAST(a_Name, a_pfnType)  ENTRY_PFN_CAST_EX(a_Name, a_pfnType, 0)
     61#define ENTRY_PFN_CAST_EX(a_Name, a_pfnType, a_uExtra) \
     62    { RT_XSTR(a_Name), (a_pfnType)iemAImpl_ ## a_Name, NULL, \
    5763      g_aTests_ ## a_Name, &g_cTests_ ## a_Name, \
    5864      a_uExtra, IEMTARGETCPU_EFL_BEHAVIOR_NATIVE /* means same for all here */ }
    … …  
    14091415    ENTRY(and_u8),
    14101416    ENTRY(and_u8_locked),
    1411     ENTRY(cmp_u8),
    1412     ENTRY(test_u8),
     1417    ENTRY_PFN_CAST(cmp_u8, PFNIEMAIMPLBINU8),
     1418    ENTRY_PFN_CAST(test_u8, PFNIEMAIMPLBINU8),
    14131419};
    14141420TEST_BINARY_OPS(8, uint8_t, "%#04x", BINU8_TEST_T, g_aBinU8)

  • trunk/src/VBox/VMM/testcase/tstIEMCheckMc.cpp

    r100740 r100826  
    891891#define IEM_MC_POP_U32(a_pu32Value)                                     do { (void)fMcBegin; } while (0)
    892892#define IEM_MC_POP_U64(a_pu64Value)                                     do { (void)fMcBegin; } while (0)
     893
     894#define IEM_MC_MEM_MAP_U8_RW(a_pu8Mem, a_bUnmapInfo, a_iSeg, a_GCPtrMem)   do { (a_pu8Mem)  = NULL; CHK_PTYPE(uint8_t *,        a_pu8Mem);  CHK_TYPE(uint8_t, a_bUnmapInfo); a_bUnmapInfo = 1; CHK_SEG_IDX(a_iSeg); (void)fMcBegin; } while (0)
     895#define IEM_MC_MEM_MAP_U8_RO(a_pu8Mem, a_bUnmapInfo, a_iSeg, a_GCPtrMem)   do { (a_pu8Mem)  = NULL; CHK_PTYPE(uint8_t const *,  a_pu8Mem);  CHK_TYPE(uint8_t, a_bUnmapInfo); a_bUnmapInfo = 1; CHK_SEG_IDX(a_iSeg); (void)fMcBegin; } while (0)
     896#define IEM_MC_MEM_MAP_U8_WO(a_pu8Mem, a_bUnmapInfo, a_iSeg, a_GCPtrMem)   do { (a_pu8Mem)  = NULL; CHK_PTYPE(uint8_t *,        a_pu8Mem);  CHK_TYPE(uint8_t, a_bUnmapInfo); a_bUnmapInfo = 1; CHK_SEG_IDX(a_iSeg); (void)fMcBegin; } while (0)
     897#define IEM_MC_MEM_MAP_U16_RW(a_pu16Mem, a_bUnmapInfo, a_iSeg, a_GCPtrMem) do { (a_pu16Mem) = NULL; CHK_PTYPE(uint16_t *,       a_pu16Mem); CHK_TYPE(uint8_t, a_bUnmapInfo); a_bUnmapInfo = 1; CHK_SEG_IDX(a_iSeg); (void)fMcBegin; } while (0)
     898#define IEM_MC_MEM_MAP_U16_RO(a_pu16Mem, a_bUnmapInfo, a_iSeg, a_GCPtrMem) do { (a_pu16Mem) = NULL; CHK_PTYPE(uint16_t const *, a_pu16Mem); CHK_TYPE(uint8_t, a_bUnmapInfo); a_bUnmapInfo = 1; CHK_SEG_IDX(a_iSeg); (void)fMcBegin; } while (0)
     899#define IEM_MC_MEM_MAP_U16_WO(a_pu16Mem, a_bUnmapInfo, a_iSeg, a_GCPtrMem) do { (a_pu16Mem) = NULL; CHK_PTYPE(uint16_t *,       a_pu16Mem); CHK_TYPE(uint8_t, a_bUnmapInfo); a_bUnmapInfo = 1; CHK_SEG_IDX(a_iSeg); (void)fMcBegin; } while (0)
     900#define IEM_MC_MEM_MAP_U32_RW(a_pu32Mem, a_bUnmapInfo, a_iSeg, a_GCPtrMem) do { (a_pu32Mem) = NULL; CHK_PTYPE(uint32_t *,       a_pu32Mem); CHK_TYPE(uint8_t, a_bUnmapInfo); a_bUnmapInfo = 1; CHK_SEG_IDX(a_iSeg); (void)fMcBegin; } while (0)
     901#define IEM_MC_MEM_MAP_U32_RO(a_pu32Mem, a_bUnmapInfo, a_iSeg, a_GCPtrMem) do { (a_pu32Mem) = NULL; CHK_PTYPE(uint32_t const *, a_pu32Mem); CHK_TYPE(uint8_t, a_bUnmapInfo); a_bUnmapInfo = 1; CHK_SEG_IDX(a_iSeg); (void)fMcBegin; } while (0)
     902#define IEM_MC_MEM_MAP_U32_WO(a_pu32Mem, a_bUnmapInfo, a_iSeg, a_GCPtrMem) do { (a_pu32Mem) = NULL; CHK_PTYPE(uint32_t *,       a_pu32Mem); CHK_TYPE(uint8_t, a_bUnmapInfo); a_bUnmapInfo = 1; CHK_SEG_IDX(a_iSeg); (void)fMcBegin; } while (0)
     903#define IEM_MC_MEM_MAP_U64_RW(a_pu64Mem, a_bUnmapInfo, a_iSeg, a_GCPtrMem) do { (a_pu64Mem) = NULL; CHK_PTYPE(uint64_t *,       a_pu64Mem); CHK_TYPE(uint8_t, a_bUnmapInfo); a_bUnmapInfo = 1; CHK_SEG_IDX(a_iSeg); (void)fMcBegin; } while (0)
     904#define IEM_MC_MEM_MAP_U64_RO(a_pu64Mem, a_bUnmapInfo, a_iSeg, a_GCPtrMem) do { (a_pu64Mem) = NULL; CHK_PTYPE(uint64_t const *, a_pu64Mem); CHK_TYPE(uint8_t, a_bUnmapInfo); a_bUnmapInfo = 1; CHK_SEG_IDX(a_iSeg); (void)fMcBegin; } while (0)
     905#define IEM_MC_MEM_MAP_U64_WO(a_pu64Mem, a_bUnmapInfo, a_iSeg, a_GCPtrMem) do { (a_pu64Mem) = NULL; CHK_PTYPE(uint64_t *,       a_pu64Mem); CHK_TYPE(uint8_t, a_bUnmapInfo); a_bUnmapInfo = 1; CHK_SEG_IDX(a_iSeg); (void)fMcBegin; } while (0)
     906
     907#define IEM_MC_MEM_COMMIT_AND_UNMAP_RW(a_pvMem, a_bMapInfo)             do { CHK_TYPE(uint8_t, a_bMapInfo); (void)fMcBegin; } while (0)
     908#define IEM_MC_MEM_COMMIT_AND_UNMAP_RO(a_pvMem, a_bMapInfo)             do { CHK_TYPE(uint8_t, a_bMapInfo); (void)fMcBegin; } while (0)
     909#define IEM_MC_MEM_COMMIT_AND_UNMAP_WO(a_pvMem, a_bMapInfo)             do { CHK_TYPE(uint8_t, a_bMapInfo); (void)fMcBegin; } while (0)
     910
    893911#define IEM_MC_MEM_MAP(a_pMem, a_fAccess, a_iSeg, a_GCPtrMem, a_iArg)   do { CHK_SEG_IDX(a_iSeg); (void)fMcBegin; } while (0)
    894912#define IEM_MC_MEM_MAP_EX(a_pvMem, a_fAccess, a_cbMem, a_iSeg, a_GCPtrMem, a_cbAlign, a_iArg)  do { CHK_SEG_IDX(a_iSeg); (void)fMcBegin; AssertCompile((a_cbAlign) <= (a_cbMem)); } while (0)
Note: See TracChangeset for help on using the changeset viewer.

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