VirtualBox

Ignore:
Timestamp:
Apr 5, 2024 2:45:23 PM (11 months ago)
Author:
vboxsync
Message:

VMM/IEM: Refactoring assembly helpers to not pass eflags by reference but instead by value and return the updated value (via eax/w0) - first chunk: ADD,ADC,SUB,SBB,CMP,TEST,AND,OR,XOR. bugref:10376

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r104117 r104195  
    9191        IEM_MC_BEGIN(0, 0); \
    9292        IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX(); \
    93         IEM_MC_ARG(uint8_t,         u8Src,   1); \
     93        IEM_MC_ARG(uint8_t,         u8Src,   2); \
    9494        IEM_MC_FETCH_GREG_U8(u8Src, IEM_GET_MODRM_REG(pVCpu, a_bRm)); \
    9595        IEM_MC_NATIVE_IF(a_fRegRegNativeArchs) { \
    … …  
    101101            IEM_MC_COMMIT_EFLAGS_OPT(uEFlags); \
    102102        } IEM_MC_NATIVE_ELSE() { \
    103             IEM_MC_ARG(uint8_t *,   pu8Dst,  0); \
     103            IEM_MC_ARG(uint8_t *,   pu8Dst,  1); \
    104104            IEM_MC_REF_GREG_U8(pu8Dst, IEM_GET_MODRM_RM(pVCpu, a_bRm)); \
    105             IEM_MC_ARG(uint32_t *,  pEFlags, 2); \
    106             IEM_MC_REF_EFLAGS(pEFlags); \
    107             IEM_MC_CALL_VOID_AIMPL_3(RT_CONCAT3(iemAImpl_,a_InsNm,_u8), pu8Dst, u8Src, pEFlags); \
     105            IEM_MC_ARG_EFLAGS(      fEFlags, 0); \
     106            IEM_MC_CALL_AIMPL_3(uint32_t, fEFlagsRet, RT_CONCAT3(iemAImpl_,a_InsNm,_u8), fEFlags, pu8Dst, u8Src); \
     107            IEM_MC_COMMIT_EFLAGS_OPT(fEFlagsRet); \
    108108        } IEM_MC_NATIVE_ENDIF(); \
    109109        IEM_MC_ADVANCE_RIP_AND_FINISH(); \
    … …  
    114114        /* \
    115115         * We're accessing memory. \
    116          * Note! We're putting the eflags on the stack here so we can commit them \
    117          *       after the memory. \
    118116         */ \
    119117        if (!(pVCpu->iem.s.fPrefixes & IEM_OP_PRF_LOCK) || (pVCpu->iem.s.fExec & IEM_F_X86_DISREGARD_LOCK)) \
    120118        { \
    121119            IEM_MC_BEGIN(0, 0); \
    122             IEM_MC_ARG(uint8_t *,  pu8Dst,           0); \
    123             IEM_MC_ARG(uint8_t,    u8Src,            1); \
    124             IEM_MC_LOCAL(RTGCPTR, GCPtrEffDst); \
    125             IEM_MC_LOCAL(uint8_t, bUnmapInfo); \
    126             \
     120            IEM_MC_LOCAL(RTGCPTR,  GCPtrEffDst); \
    127121            IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, a_bRm, 0); \
    128122            IEMOP_HLP_DONE_DECODING(); \
     123            \
     124            IEM_MC_LOCAL(uint8_t,   bUnmapInfo); \
     125            IEM_MC_ARG(uint8_t *,   pu8Dst,         1); \
    129126            IEM_MC_MEM_MAP_U8_RW(pu8Dst, bUnmapInfo, pVCpu->iem.s.iEffSeg, GCPtrEffDst); \
     127            IEM_MC_ARG(uint8_t,     u8Src,          2); \
    130128            IEM_MC_FETCH_GREG_U8(u8Src, IEM_GET_MODRM_REG(pVCpu, a_bRm)); \
    131             IEM_MC_ARG_LOCAL_EFLAGS(pEFlags, EFlags, 2); \
    132             IEM_MC_CALL_VOID_AIMPL_3(RT_CONCAT3(iemAImpl_,a_InsNm,_u8), pu8Dst, u8Src, pEFlags); \
     129            IEM_MC_ARG_EFLAGS(      fEFlags,        0); \
     130            IEM_MC_CALL_AIMPL_3(uint32_t, fEFlagsRet, RT_CONCAT3(iemAImpl_,a_InsNm,_u8), fEFlags, pu8Dst, u8Src); \
    133131            \
    134132            IEM_MC_MEM_COMMIT_AND_UNMAP_RW(bUnmapInfo); \
    135             IEM_MC_COMMIT_EFLAGS(EFlags); \
     133            IEM_MC_COMMIT_EFLAGS(fEFlagsRet); \
    136134            IEM_MC_ADVANCE_RIP_AND_FINISH(); \
    137135            IEM_MC_END(); \
    … …  
    140138        { \
    141139            IEM_MC_BEGIN(0, 0); \
    142             IEM_MC_ARG(uint8_t *,  pu8Dst,           0); \
    143             IEM_MC_ARG(uint8_t,    u8Src,            1); \
    144140            IEM_MC_LOCAL(RTGCPTR, GCPtrEffDst); \
    145             IEM_MC_LOCAL(uint8_t, bMapInfoDst); \
    146             \
    147141            IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, a_bRm, 0); \
    148142            IEMOP_HLP_DONE_DECODING(); \
     143            \
     144            IEM_MC_LOCAL(uint8_t,   bMapInfoDst); \
     145            IEM_MC_ARG(uint8_t *,   pu8Dst,         1); \
    149146            IEM_MC_MEM_MAP_U8_ATOMIC(pu8Dst, bMapInfoDst, pVCpu->iem.s.iEffSeg, GCPtrEffDst); \
     147            IEM_MC_ARG(uint8_t,     u8Src,          2); \
    150148            IEM_MC_FETCH_GREG_U8(u8Src, IEM_GET_MODRM_REG(pVCpu, a_bRm)); \
    151             IEM_MC_ARG_LOCAL_EFLAGS(pEFlags, EFlags, 2); \
    152             IEM_MC_CALL_VOID_AIMPL_3(RT_CONCAT3(iemAImpl_,a_InsNm,_u8_locked), pu8Dst, u8Src, pEFlags); \
     149            IEM_MC_ARG_EFLAGS(      fEFlagsIn,      0); \
     150            IEM_MC_CALL_AIMPL_3(uint32_t, fEFlagsRet, RT_CONCAT3(iemAImpl_,a_InsNm,_u8_locked), fEFlagsIn, pu8Dst, u8Src); \
    153151            \
    154152            IEM_MC_MEM_COMMIT_AND_UNMAP_ATOMIC(bMapInfoDst); \
    155             IEM_MC_COMMIT_EFLAGS(EFlags); \
     153            IEM_MC_COMMIT_EFLAGS(fEFlagsRet); \
    156154            IEM_MC_ADVANCE_RIP_AND_FINISH(); \
    157155            IEM_MC_END(); \
    … …  
    172170        IEM_MC_BEGIN(0, 0); \
    173171        IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX(); \
    174         IEM_MC_ARG(uint8_t,         u8Src,   1); \
     172        IEM_MC_ARG(uint8_t,         u8Src,      2); \
    175173        IEM_MC_FETCH_GREG_U8(u8Src, IEM_GET_MODRM_REG(pVCpu, a_bRm)); \
    176174        IEM_MC_NATIVE_IF(a_fNativeArchs) { \
    … …  
    181179            IEM_MC_COMMIT_EFLAGS_OPT(uEFlags); \
    182180        } IEM_MC_NATIVE_ELSE() { \
    183             IEM_MC_ARG(uint8_t *,   pu8Dst,  0); \
     181            IEM_MC_ARG(uint8_t *,   pu8Dst,     1); \
    184182            IEM_MC_REF_GREG_U8(pu8Dst, IEM_GET_MODRM_RM(pVCpu, a_bRm)); \
    185             IEM_MC_ARG(uint32_t *,  pEFlags, 2); \
    186             IEM_MC_REF_EFLAGS(pEFlags); \
    187             IEM_MC_CALL_VOID_AIMPL_3(a_fnNormalU8, pu8Dst, u8Src, pEFlags); \
     183            IEM_MC_ARG_EFLAGS(      fEFlagsIn,  0); \
     184            IEM_MC_CALL_AIMPL_3(uint32_t, fEFlagsRet, a_fnNormalU8, fEFlagsIn, pu8Dst, u8Src); \
     185            IEM_MC_COMMIT_EFLAGS(fEFlagsRet); \
    188186        } IEM_MC_NATIVE_ENDIF(); \
    189187        IEM_MC_ADVANCE_RIP_AND_FINISH(); \
    … …  
    194192        /* \
    195193         * We're accessing memory. \
    196          * Note! We're putting the eflags on the stack here so we can commit them \
    197          *       after the memory. \
    198194         */ \
    199195        if (!(pVCpu->iem.s.fPrefixes & IEM_OP_PRF_LOCK)) \
    … …  
    213209            } IEM_MC_NATIVE_ELSE() { \
    214210                IEM_MC_LOCAL(uint8_t,       bUnmapInfo); \
    215                 IEM_MC_ARG(uint8_t const *, pu8Dst,          0); \
     211                IEM_MC_ARG(uint8_t const *, pu8Dst,     1); \
    216212                IEM_MC_MEM_MAP_U8_RO(pu8Dst, bUnmapInfo, pVCpu->iem.s.iEffSeg, GCPtrEffDst); \
    217                 IEM_MC_ARG(uint8_t,         u8Src,           1); \
     213                IEM_MC_ARG(uint8_t,         u8Src,      2); \
    218214                IEM_MC_FETCH_GREG_U8(u8Src, IEM_GET_MODRM_REG(pVCpu, a_bRm)); \
    219                 IEM_MC_ARG_LOCAL_EFLAGS(    pEFlags, EFlags, 2); \
    220                 IEM_MC_CALL_VOID_AIMPL_3(a_fnNormalU8, pu8Dst, u8Src, pEFlags); \
     215                IEM_MC_ARG_EFLAGS(          fEFlagsIn,  0); \
     216                IEM_MC_CALL_AIMPL_3(uint32_t, fEFlagsRet, a_fnNormalU8, fEFlagsIn, pu8Dst, u8Src); \
    221217                IEM_MC_MEM_COMMIT_AND_UNMAP_RO(bUnmapInfo); \
    222                 IEM_MC_COMMIT_EFLAGS(EFlags); \
     218                IEM_MC_COMMIT_EFLAGS(fEFlagsRet); \
    223219            } IEM_MC_NATIVE_ENDIF(); \
    224220            IEM_MC_ADVANCE_RIP_AND_FINISH(); \
    … …  
    246242        IEM_MC_BEGIN(0, 0); \
    247243        IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX(); \
    248         IEM_MC_ARG(uint8_t,         u8Src,   1); \
     244        IEM_MC_ARG(uint8_t,         u8Src,      2); \
    249245        IEM_MC_FETCH_GREG_U8(u8Src, IEM_GET_MODRM_RM(pVCpu, a_bRm)); \
    250246        IEM_MC_NATIVE_IF(a_fNativeArchs) { \
    … …  
    256252            IEM_MC_COMMIT_EFLAGS_OPT(uEFlags); \
    257253        } IEM_MC_NATIVE_ELSE() { \
    258             IEM_MC_ARG(uint8_t *,   pu8Dst,  0); \
     254            IEM_MC_ARG(uint8_t *,   pu8Dst,     1); \
    259255            IEM_MC_REF_GREG_U8(pu8Dst, IEM_GET_MODRM_REG(pVCpu, a_bRm)); \
    260             IEM_MC_ARG(uint32_t *,  pEFlags, 2); \
    261             IEM_MC_REF_EFLAGS(pEFlags); \
    262             IEM_MC_CALL_VOID_AIMPL_3(RT_CONCAT3(iemAImpl_,a_InsNm,_u8), pu8Dst, u8Src, pEFlags); \
     256            IEM_MC_ARG_EFLAGS(      fEFlagsIn,  0); \
     257            IEM_MC_CALL_AIMPL_3(uint32_t, fEFlagsRet, RT_CONCAT3(iemAImpl_,a_InsNm,_u8), fEFlagsIn, pu8Dst, u8Src); \
     258            IEM_MC_COMMIT_EFLAGS(fEFlagsRet); \
    263259        } IEM_MC_NATIVE_ENDIF(); \
    264260        IEM_MC_ADVANCE_RIP_AND_FINISH(); \
    … …  
    274270        IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, a_bRm, 0); \
    275271        IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX(); \
    276         IEM_MC_ARG(uint8_t,         u8Src,   1); \
     272        IEM_MC_ARG(uint8_t,         u8Src,      2); \
    277273        IEM_MC_FETCH_MEM_U8(u8Src, pVCpu->iem.s.iEffSeg, GCPtrEffDst); \
    278274        IEM_MC_NATIVE_IF(a_fNativeArchs) { \
    … …  
    284280            IEM_MC_COMMIT_EFLAGS_OPT(uEFlags); \
    285281        } IEM_MC_NATIVE_ELSE() { \
    286             IEM_MC_ARG(uint8_t *,   pu8Dst,  0); \
     282            IEM_MC_ARG(uint8_t *,   pu8Dst,     1); \
    287283            IEM_MC_REF_GREG_U8(pu8Dst, IEM_GET_MODRM_REG(pVCpu, a_bRm)); \
    288             IEM_MC_ARG(uint32_t *,  pEFlags, 2); \
    289             IEM_MC_REF_EFLAGS(pEFlags); \
    290             IEM_MC_CALL_VOID_AIMPL_3(RT_CONCAT3(iemAImpl_,a_InsNm,_u8), pu8Dst, u8Src, pEFlags); \
     284            IEM_MC_ARG_EFLAGS(      fEFlagsIn,  0); \
     285            IEM_MC_CALL_AIMPL_3(uint32_t, fEFlagsRet, RT_CONCAT3(iemAImpl_,a_InsNm,_u8), fEFlagsIn, pu8Dst, u8Src); \
     286            IEM_MC_COMMIT_EFLAGS(fEFlagsRet); \
    291287        } IEM_MC_NATIVE_ENDIF(); \
    292288        IEM_MC_ADVANCE_RIP_AND_FINISH(); \
    … …  
    306302        IEM_MC_BEGIN(0, 0); \
    307303        IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX(); \
    308         IEM_MC_ARG(uint8_t,         u8Src,   1); \
     304        IEM_MC_ARG(uint8_t,         u8Src,      2); \
    309305        IEM_MC_FETCH_GREG_U8(u8Src, IEM_GET_MODRM_RM(pVCpu, a_bRm)); \
    310306        IEM_MC_NATIVE_IF(a_fNativeArchs) { \
    … …  
    315311            IEM_MC_COMMIT_EFLAGS_OPT(uEFlags); \
    316312        } IEM_MC_NATIVE_ELSE() { \
    317             IEM_MC_ARG(uint8_t *,   pu8Dst,  0); \
     313            IEM_MC_ARG(uint8_t *,   pu8Dst,     1); \
    318314            IEM_MC_REF_GREG_U8(pu8Dst, IEM_GET_MODRM_REG(pVCpu, a_bRm)); \
    319             IEM_MC_ARG(uint32_t *,  pEFlags, 2); \
    320             IEM_MC_REF_EFLAGS(pEFlags); \
    321             IEM_MC_CALL_VOID_AIMPL_3(RT_CONCAT3(iemAImpl_,a_InsNm,_u8), pu8Dst, u8Src, pEFlags); \
     315            IEM_MC_ARG_EFLAGS(      fEFlagsIn,  0); \
     316            IEM_MC_CALL_AIMPL_3(uint32_t, fEFlagsRet, RT_CONCAT3(iemAImpl_,a_InsNm,_u8), fEFlagsIn, pu8Dst, u8Src); \
     317            IEM_MC_COMMIT_EFLAGS(fEFlagsRet); \
    322318        } IEM_MC_NATIVE_ENDIF(); \
    323319        IEM_MC_ADVANCE_RIP_AND_FINISH(); \
    … …  
    333329        IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, a_bRm, 0); \
    334330        IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX(); \
    335         IEM_MC_ARG(uint8_t,         u8Src,   1); \
     331        IEM_MC_ARG(uint8_t,         u8Src,      2); \
    336332        IEM_MC_FETCH_MEM_U8(u8Src, pVCpu->iem.s.iEffSeg, GCPtrEffDst); \
    337333        IEM_MC_NATIVE_IF(a_fNativeArchs) { \
    … …  
    342338            IEM_MC_COMMIT_EFLAGS_OPT(uEFlags); \
    343339        } IEM_MC_NATIVE_ELSE() { \
    344             IEM_MC_ARG(uint8_t *,   pu8Dst,  0); \
     340            IEM_MC_ARG(uint8_t *,   pu8Dst,     1); \
    345341            IEM_MC_REF_GREG_U8(pu8Dst, IEM_GET_MODRM_REG(pVCpu, a_bRm)); \
    346             IEM_MC_ARG(uint32_t *,  pEFlags, 2); \
    347             IEM_MC_REF_EFLAGS(pEFlags); \
    348             IEM_MC_CALL_VOID_AIMPL_3(RT_CONCAT3(iemAImpl_,a_InsNm,_u8), pu8Dst, u8Src, pEFlags); \
     342            IEM_MC_ARG_EFLAGS(      fEFlagsIn,  0); \
     343            IEM_MC_CALL_AIMPL_3(uint32_t, fEFlagsRet, RT_CONCAT3(iemAImpl_,a_InsNm,_u8), fEFlagsIn, pu8Dst, u8Src); \
     344            IEM_MC_COMMIT_EFLAGS(fEFlagsRet); \
    349345        } IEM_MC_NATIVE_ENDIF(); \
    350346        IEM_MC_ADVANCE_RIP_AND_FINISH(); \
    … …  
    369365                IEM_MC_BEGIN(0, 0); \
    370366                IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX(); \
    371                 IEM_MC_ARG(uint16_t,   u16Src,  1); \
     367                IEM_MC_ARG(uint16_t,        u16Src,     2); \
    372368                IEM_MC_FETCH_GREG_U16(u16Src, IEM_GET_MODRM_REG(pVCpu, a_bRm)); \
    373369                IEM_MC_NATIVE_IF(a_fRegRegNativeArchs) { \
    374                     IEM_MC_LOCAL(uint16_t,   u16Dst); \
     370                    IEM_MC_LOCAL(uint16_t,  u16Dst); \
    375371                    IEM_MC_FETCH_GREG_U16(u16Dst, IEM_GET_MODRM_RM(pVCpu, a_bRm)); \
    376372                    IEM_MC_LOCAL_EFLAGS(uEFlags); \
    … …  
    379375                    IEM_MC_COMMIT_EFLAGS_OPT(uEFlags); \
    380376                } IEM_MC_NATIVE_ELSE() { \
    381                     IEM_MC_ARG(uint16_t *, pu16Dst, 0); \
     377                    IEM_MC_ARG(uint16_t *,  pu16Dst,    1); \
    382378                    IEM_MC_REF_GREG_U16(pu16Dst, IEM_GET_MODRM_RM(pVCpu, a_bRm)); \
    383                     IEM_MC_ARG(uint32_t *, pEFlags, 2); \
    384                     IEM_MC_REF_EFLAGS(pEFlags); \
    385                     IEM_MC_CALL_VOID_AIMPL_3(RT_CONCAT3(iemAImpl_,a_InsNm,_u16), pu16Dst, u16Src, pEFlags); \
     379                    IEM_MC_ARG_EFLAGS(      fEFlagsIn,  0); \
     380                    IEM_MC_CALL_AIMPL_3(uint32_t, fEFlagsRet, RT_CONCAT3(iemAImpl_,a_InsNm,_u16), fEFlagsIn, pu16Dst, u16Src); \
     381                    IEM_MC_COMMIT_EFLAGS(fEFlagsRet); \
    386382                } IEM_MC_NATIVE_ENDIF(); \
    387383                IEM_MC_ADVANCE_RIP_AND_FINISH(); \
    … …  
    392388                IEM_MC_BEGIN(IEM_MC_F_MIN_386, 0); \
    393389                IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX(); \
    394                 IEM_MC_ARG(uint32_t,   u32Src,  1); \
     390                IEM_MC_ARG(uint32_t,        u32Src,  2); \
    395391                IEM_MC_FETCH_GREG_U32(u32Src, IEM_GET_MODRM_REG(pVCpu, a_bRm)); \
    396392                IEM_MC_NATIVE_IF(a_fRegRegNativeArchs) { \
    397                     IEM_MC_LOCAL(uint32_t,   u32Dst); \
     393                    IEM_MC_LOCAL(uint32_t,  u32Dst); \
    398394                    IEM_MC_FETCH_GREG_U32(u32Dst, IEM_GET_MODRM_RM(pVCpu, a_bRm)); \
    399395                    IEM_MC_LOCAL_EFLAGS(uEFlags); \
    … …  
    402398                    IEM_MC_COMMIT_EFLAGS_OPT(uEFlags); \
    403399                } IEM_MC_NATIVE_ELSE() { \
    404                     IEM_MC_ARG(uint32_t *, pu32Dst, 0); \
     400                    IEM_MC_ARG(uint32_t *,  pu32Dst,    1); \
    405401                    IEM_MC_REF_GREG_U32(pu32Dst, IEM_GET_MODRM_RM(pVCpu, a_bRm)); \
    406                     IEM_MC_ARG(uint32_t *, pEFlags, 2); \
    407                     IEM_MC_REF_EFLAGS(pEFlags); \
    408                     IEM_MC_CALL_VOID_AIMPL_3(RT_CONCAT3(iemAImpl_,a_InsNm,_u32), pu32Dst, u32Src, pEFlags); \
     402                    IEM_MC_ARG_EFLAGS(      fEFlagsIn,  0); \
     403                    IEM_MC_CALL_AIMPL_3(uint32_t, fEFlagsRet, RT_CONCAT3(iemAImpl_,a_InsNm,_u32), fEFlagsIn, pu32Dst, u32Src); \
    409404                    IEM_MC_CLEAR_HIGH_GREG_U64(IEM_GET_MODRM_RM(pVCpu, a_bRm)); \
     405                    IEM_MC_COMMIT_EFLAGS(fEFlagsRet); \
    410406                } IEM_MC_NATIVE_ENDIF(); \
    411407                IEM_MC_ADVANCE_RIP_AND_FINISH(); \
    … …  
    416412                IEM_MC_BEGIN(IEM_MC_F_64BIT, 0); \
    417413                IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX(); \
    418                 IEM_MC_ARG(uint64_t,        u64Src,  1); \
     414                IEM_MC_ARG(uint64_t,        u64Src,  2); \
    419415                IEM_MC_FETCH_GREG_U64(u64Src, IEM_GET_MODRM_REG(pVCpu, a_bRm)); \
    420416                IEM_MC_NATIVE_IF(a_fRegRegNativeArchs) { \
    … …  
    426422                    IEM_MC_COMMIT_EFLAGS_OPT(uEFlags); \
    427423                } IEM_MC_NATIVE_ELSE() { \
    428                     IEM_MC_ARG(uint64_t *,  pu64Dst, 0); \
     424                    IEM_MC_ARG(uint64_t *,  pu64Dst,    1); \
    429425                    IEM_MC_REF_GREG_U64(pu64Dst, IEM_GET_MODRM_RM(pVCpu, a_bRm)); \
    430                     IEM_MC_ARG(uint32_t *,  pEFlags, 2); \
    431                     IEM_MC_REF_EFLAGS(pEFlags); \
    432                     IEM_MC_CALL_VOID_AIMPL_3(RT_CONCAT3(iemAImpl_,a_InsNm,_u64), pu64Dst, u64Src, pEFlags); \
     426                    IEM_MC_ARG_EFLAGS(      fEFlagsIn,  0); \
     427                    IEM_MC_CALL_AIMPL_3(uint32_t, fEFlagsRet, RT_CONCAT3(iemAImpl_,a_InsNm,_u64), fEFlagsIn, pu64Dst, u64Src); \
     428                    IEM_MC_COMMIT_EFLAGS(fEFlagsRet); \
    433429                } IEM_MC_NATIVE_ENDIF(); \
    434430                IEM_MC_ADVANCE_RIP_AND_FINISH(); \
    … …  
    443439        /* \
    444440         * We're accessing memory. \
    445          * Note! We're putting the eflags on the stack here so we can commit them \
    446          *       after the memory. \
    447441         */ \
    448442        if (!(pVCpu->iem.s.fPrefixes & IEM_OP_PRF_LOCK) || (pVCpu->iem.s.fExec & IEM_F_X86_DISREGARD_LOCK)) \
    … …  
    452446                case IEMMODE_16BIT: \
    453447                    IEM_MC_BEGIN(0, 0); \
    454                     IEM_MC_ARG(uint16_t *, pu16Dst,          0); \
    455                     IEM_MC_ARG(uint16_t,   u16Src,           1); \
    456448                    IEM_MC_LOCAL(RTGCPTR, GCPtrEffDst); \
    457                     IEM_MC_LOCAL(uint8_t, bUnmapInfo); \
    458                     \
    459449                    IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, a_bRm, 0); \
    460450                    IEMOP_HLP_DONE_DECODING(); \
     451                    \
     452                    IEM_MC_LOCAL(uint8_t,   bUnmapInfo); \
     453                    IEM_MC_ARG(uint16_t *,  pu16Dst,    1); \
    461454                    IEM_MC_MEM_MAP_U16_RW(pu16Dst, bUnmapInfo, pVCpu->iem.s.iEffSeg, GCPtrEffDst); \
     455                    IEM_MC_ARG(uint16_t,    u16Src,     2); \
    462456                    IEM_MC_FETCH_GREG_U16(u16Src, IEM_GET_MODRM_REG(pVCpu, a_bRm)); \
    463                     IEM_MC_ARG_LOCAL_EFLAGS(pEFlags, EFlags, 2); \
    464                     IEM_MC_CALL_VOID_AIMPL_3(RT_CONCAT3(iemAImpl_,a_InsNm,_u16), pu16Dst, u16Src, pEFlags); \
     457                    IEM_MC_ARG_EFLAGS(      fEFlagsIn,  0); \
     458                    IEM_MC_CALL_AIMPL_3(uint32_t, fEFlagsRet, RT_CONCAT3(iemAImpl_,a_InsNm,_u16), fEFlagsIn, pu16Dst, u16Src); \
    465459                    \
    466460                    IEM_MC_MEM_COMMIT_AND_UNMAP_RW(bUnmapInfo); \
    467                     IEM_MC_COMMIT_EFLAGS(EFlags); \
     461                    IEM_MC_COMMIT_EFLAGS(fEFlagsRet); \
    468462                    IEM_MC_ADVANCE_RIP_AND_FINISH(); \
    469463                    IEM_MC_END(); \
    … …  
    472466                case IEMMODE_32BIT: \
    473467                    IEM_MC_BEGIN(IEM_MC_F_MIN_386, 0); \
    474                     IEM_MC_ARG(uint32_t *, pu32Dst,          0); \
    475                     IEM_MC_ARG(uint32_t,   u32Src,           1); \
    476468                    IEM_MC_LOCAL(RTGCPTR, GCPtrEffDst); \
    477                     IEM_MC_LOCAL(uint8_t, bUnmapInfo); \
    478                     \
    479469                    IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, a_bRm, 0); \
    480470                    IEMOP_HLP_DONE_DECODING(); \
     471                    \
     472                    IEM_MC_LOCAL(uint8_t,   bUnmapInfo); \
     473                    IEM_MC_ARG(uint32_t *,  pu32Dst,    1); \
    481474                    IEM_MC_MEM_MAP_U32_RW(pu32Dst, bUnmapInfo, pVCpu->iem.s.iEffSeg, GCPtrEffDst); \
     475                    IEM_MC_ARG(uint32_t,    u32Src,     2); \
    482476                    IEM_MC_FETCH_GREG_U32(u32Src, IEM_GET_MODRM_REG(pVCpu, a_bRm)); \
    483                     IEM_MC_ARG_LOCAL_EFLAGS(pEFlags, EFlags, 2); \
    484                     IEM_MC_CALL_VOID_AIMPL_3(RT_CONCAT3(iemAImpl_,a_InsNm,_u32), pu32Dst, u32Src, pEFlags); \
     477                    IEM_MC_ARG_EFLAGS(      fEFlagsIn,  0); \
     478                    IEM_MC_CALL_AIMPL_3(uint32_t, fEFlagsRet, RT_CONCAT3(iemAImpl_,a_InsNm,_u32), fEFlagsIn, pu32Dst, u32Src); \
    485479                    \
    486480                    IEM_MC_MEM_COMMIT_AND_UNMAP_RW(bUnmapInfo); \
    487                     IEM_MC_COMMIT_EFLAGS(EFlags); \
     481                    IEM_MC_COMMIT_EFLAGS(fEFlagsRet); \
    488482                    IEM_MC_ADVANCE_RIP_AND_FINISH(); \
    489483                    IEM_MC_END(); \
    … …  
    492486                case IEMMODE_64BIT: \
    493487                    IEM_MC_BEGIN(IEM_MC_F_64BIT, 0); \
    494                     IEM_MC_ARG(uint64_t *, pu64Dst,          0); \
    495                     IEM_MC_ARG(uint64_t,   u64Src,           1); \
    496488                    IEM_MC_LOCAL(RTGCPTR, GCPtrEffDst); \
    497                     IEM_MC_LOCAL(uint8_t, bUnmapInfo); \
    498                     \
    499489                    IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, a_bRm, 0); \
    500490                    IEMOP_HLP_DONE_DECODING(); \
     491                    \
     492                    IEM_MC_LOCAL(uint8_t,   bUnmapInfo); \
     493                    IEM_MC_ARG(uint64_t *,  pu64Dst,    1); \
    501494                    IEM_MC_MEM_MAP_U64_RW(pu64Dst, bUnmapInfo, pVCpu->iem.s.iEffSeg, GCPtrEffDst); \
     495                    IEM_MC_ARG(uint64_t,    u64Src,     2); \
    502496                    IEM_MC_FETCH_GREG_U64(u64Src, IEM_GET_MODRM_REG(pVCpu, a_bRm)); \
    503                     IEM_MC_ARG_LOCAL_EFLAGS(pEFlags, EFlags, 2); \
    504                     IEM_MC_CALL_VOID_AIMPL_3(RT_CONCAT3(iemAImpl_,a_InsNm,_u64), pu64Dst, u64Src, pEFlags); \
     497                    IEM_MC_ARG_EFLAGS(      fEFlagsIn,  0); \
     498                    IEM_MC_CALL_AIMPL_3(uint32_t, fEFlagsRet, RT_CONCAT3(iemAImpl_,a_InsNm,_u64), fEFlagsIn, pu64Dst, u64Src); \
    505499                    \
    506500                    IEM_MC_MEM_COMMIT_AND_UNMAP_RW(bUnmapInfo); \
    507                     IEM_MC_COMMIT_EFLAGS(EFlags); \
     501                    IEM_MC_COMMIT_EFLAGS(fEFlagsRet); \
    508502                    IEM_MC_ADVANCE_RIP_AND_FINISH(); \
    509503                    IEM_MC_END(); \
    … …  
    522516                case IEMMODE_16BIT: \
    523517                    IEM_MC_BEGIN(0, 0); \
    524                     IEM_MC_ARG(uint16_t *, pu16Dst,          0); \
    525                     IEM_MC_ARG(uint16_t,   u16Src,           1); \
    526518                    IEM_MC_LOCAL(RTGCPTR, GCPtrEffDst); \
    527                     IEM_MC_LOCAL(uint8_t, bUnmapInfo); \
    528                     \
    529519                    IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, a_bRm, 0); \
    530520                    IEMOP_HLP_DONE_DECODING(); \
     521                    \
     522                    IEM_MC_LOCAL(uint8_t, bUnmapInfo); \
     523                    IEM_MC_ARG(uint16_t *,  pu16Dst,    1); \
    531524                    IEM_MC_MEM_MAP_U16_ATOMIC(pu16Dst, bUnmapInfo, pVCpu->iem.s.iEffSeg, GCPtrEffDst); \
     525                    IEM_MC_ARG(uint16_t,    u16Src,     2); \
    532526                    IEM_MC_FETCH_GREG_U16(u16Src, IEM_GET_MODRM_REG(pVCpu, a_bRm)); \
    533                     IEM_MC_ARG_LOCAL_EFLAGS(pEFlags, EFlags, 2); \
    534                     IEM_MC_CALL_VOID_AIMPL_3(RT_CONCAT3(iemAImpl_,a_InsNm,_u16_locked), pu16Dst, u16Src, pEFlags); \
     527                    IEM_MC_ARG_EFLAGS(      fEFlagsIn,  0); \
     528                    IEM_MC_CALL_AIMPL_3(uint32_t, fEFlagsRet, RT_CONCAT3(iemAImpl_,a_InsNm,_u16_locked), fEFlagsIn, pu16Dst, u16Src); \
    535529                    \
    536530                    IEM_MC_MEM_COMMIT_AND_UNMAP_ATOMIC(bUnmapInfo); \
    537                     IEM_MC_COMMIT_EFLAGS(EFlags); \
     531                    IEM_MC_COMMIT_EFLAGS(fEFlagsRet); \
    538532                    IEM_MC_ADVANCE_RIP_AND_FINISH(); \
    539533                    IEM_MC_END(); \
    … …  
    542536                case IEMMODE_32BIT: \
    543537                    IEM_MC_BEGIN(IEM_MC_F_MIN_386, 0); \
    544                     IEM_MC_ARG(uint32_t *, pu32Dst,          0); \
    545                     IEM_MC_ARG(uint32_t,   u32Src,           1); \
    546538                    IEM_MC_LOCAL(RTGCPTR, GCPtrEffDst); \
    547                     IEM_MC_LOCAL(uint8_t, bUnmapInfo); \
    548                     \
    549539                    IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, a_bRm, 0); \
    550540                    IEMOP_HLP_DONE_DECODING(); \
     541                    \
     542                    IEM_MC_LOCAL(uint8_t,   bUnmapInfo); \
     543                    IEM_MC_ARG(uint32_t *,  pu32Dst,    1); \
    551544                    IEM_MC_MEM_MAP_U32_ATOMIC(pu32Dst, bUnmapInfo, pVCpu->iem.s.iEffSeg, GCPtrEffDst); \
     545                    IEM_MC_ARG(uint32_t,    u32Src,     2); \
    552546                    IEM_MC_FETCH_GREG_U32(u32Src, IEM_GET_MODRM_REG(pVCpu, a_bRm)); \
    553                     IEM_MC_ARG_LOCAL_EFLAGS(pEFlags, EFlags, 2); \
    554                     IEM_MC_CALL_VOID_AIMPL_3(RT_CONCAT3(iemAImpl_,a_InsNm,_u32_locked), pu32Dst, u32Src, pEFlags); \
     547                    IEM_MC_ARG_EFLAGS(      fEFlagsIn,  0); \
     548                    IEM_MC_CALL_AIMPL_3(uint32_t, fEFlagsRet, RT_CONCAT3(iemAImpl_,a_InsNm,_u32_locked), fEFlagsIn, pu32Dst, u32Src); \
    555549                    \
    556550                    IEM_MC_MEM_COMMIT_AND_UNMAP_ATOMIC(bUnmapInfo /* CMP,TEST */); \
    557                     IEM_MC_COMMIT_EFLAGS(EFlags); \
     551                    IEM_MC_COMMIT_EFLAGS(fEFlagsRet); \
    558552                    IEM_MC_ADVANCE_RIP_AND_FINISH(); \
    559553                    IEM_MC_END(); \
    … …  
    562556                case IEMMODE_64BIT: \
    563557                    IEM_MC_BEGIN(IEM_MC_F_64BIT, 0); \
    564                     IEM_MC_ARG(uint64_t *, pu64Dst,          0); \
    565                     IEM_MC_ARG(uint64_t,   u64Src,           1); \
    566558                    IEM_MC_LOCAL(RTGCPTR, GCPtrEffDst); \
    567                     IEM_MC_LOCAL(uint8_t, bUnmapInfo); \
    568                     \
    569559                    IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, a_bRm, 0); \
    570560                    IEMOP_HLP_DONE_DECODING(); \
     561                    \
     562                    IEM_MC_LOCAL(uint8_t,   bUnmapInfo); \
     563                    IEM_MC_ARG(uint64_t *,  pu64Dst,    1); \
    571564                    IEM_MC_MEM_MAP_U64_ATOMIC(pu64Dst, bUnmapInfo, pVCpu->iem.s.iEffSeg, GCPtrEffDst); \
     565                    IEM_MC_ARG(uint64_t,    u64Src,     2); \
    572566                    IEM_MC_FETCH_GREG_U64(u64Src, IEM_GET_MODRM_REG(pVCpu, a_bRm)); \
    573                     IEM_MC_ARG_LOCAL_EFLAGS(pEFlags, EFlags, 2); \
    574                     IEM_MC_CALL_VOID_AIMPL_3(RT_CONCAT3(iemAImpl_,a_InsNm,_u64_locked), pu64Dst, u64Src, pEFlags); \
     567                    IEM_MC_ARG_EFLAGS(      fEFlagsIn,  0); \
     568                    IEM_MC_CALL_AIMPL_3(uint32_t, fEFlagsRet, RT_CONCAT3(iemAImpl_,a_InsNm,_u64_locked), fEFlagsIn, pu64Dst, u64Src); \
    575569                    \
    576570                    IEM_MC_MEM_COMMIT_AND_UNMAP_ATOMIC(bUnmapInfo); \
    577                     IEM_MC_COMMIT_EFLAGS(EFlags); \
     571                    IEM_MC_COMMIT_EFLAGS(fEFlagsRet); \
    578572                    IEM_MC_ADVANCE_RIP_AND_FINISH(); \
    579573                    IEM_MC_END(); \
    … …  
    601595                IEM_MC_BEGIN(0, 0); \
    602596                IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX(); \
    603                 IEM_MC_ARG(uint16_t,   u16Src,  1); \
     597                IEM_MC_ARG(uint16_t,        u16Src,     2); \
    604598                IEM_MC_FETCH_GREG_U16(u16Src, IEM_GET_MODRM_REG(pVCpu, a_bRm)); \
    605599                IEM_MC_NATIVE_IF(a_fNativeArchs) { \
    606                     IEM_MC_LOCAL(uint16_t,   u16Dst); \
     600                    IEM_MC_LOCAL(uint16_t,  u16Dst); \
    607601                    IEM_MC_FETCH_GREG_U16(u16Dst, IEM_GET_MODRM_RM(pVCpu, a_bRm)); \
    608602                    IEM_MC_LOCAL_EFLAGS(uEFlags); \
    … …  
    610604                    IEM_MC_COMMIT_EFLAGS_OPT(uEFlags); \
    611605                } IEM_MC_NATIVE_ELSE() { \
    612                     IEM_MC_ARG(uint16_t *, pu16Dst, 0); \
     606                    IEM_MC_ARG(uint16_t *,  pu16Dst,    1); \
    613607                    IEM_MC_REF_GREG_U16(pu16Dst, IEM_GET_MODRM_RM(pVCpu, a_bRm)); \
    614                     IEM_MC_ARG(uint32_t *, pEFlags, 2); \
    615                     IEM_MC_REF_EFLAGS(pEFlags); \
    616                     IEM_MC_CALL_VOID_AIMPL_3(RT_CONCAT3(iemAImpl_,a_InsNm,_u16), pu16Dst, u16Src, pEFlags); \
     608                    IEM_MC_ARG_EFLAGS(      fEFlagsIn,  0); \
     609                    IEM_MC_CALL_AIMPL_3(uint32_t, fEFlagsRet, RT_CONCAT3(iemAImpl_,a_InsNm,_u16), fEFlagsIn, pu16Dst, u16Src); \
     610                    IEM_MC_COMMIT_EFLAGS(fEFlagsRet); \
    617611                } IEM_MC_NATIVE_ENDIF(); \
    618612                IEM_MC_ADVANCE_RIP_AND_FINISH(); \
    … …  
    623617                IEM_MC_BEGIN(IEM_MC_F_MIN_386, 0); \
    624618                IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX(); \
    625                 IEM_MC_ARG(uint32_t,   u32Src,  1); \
     619                IEM_MC_ARG(uint32_t,        u32Src,     2); \
    626620                IEM_MC_FETCH_GREG_U32(u32Src, IEM_GET_MODRM_REG(pVCpu, a_bRm)); \
    627621                IEM_MC_NATIVE_IF(a_fNativeArchs) { \
    628                     IEM_MC_LOCAL(uint32_t,   u32Dst); \
     622                    IEM_MC_LOCAL(uint32_t,  u32Dst); \
    629623                    IEM_MC_FETCH_GREG_U32(u32Dst, IEM_GET_MODRM_RM(pVCpu, a_bRm)); \
    630624                    IEM_MC_LOCAL_EFLAGS(uEFlags); \
    … …  
    632626                    IEM_MC_COMMIT_EFLAGS_OPT(uEFlags); \
    633627                } IEM_MC_NATIVE_ELSE() { \
    634                     IEM_MC_ARG(uint32_t *, pu32Dst, 0); \
     628                    IEM_MC_ARG(uint32_t *,  pu32Dst,    1); \
    635629                    IEM_MC_REF_GREG_U32(pu32Dst, IEM_GET_MODRM_RM(pVCpu, a_bRm)); \
    636                     IEM_MC_ARG(uint32_t *, pEFlags, 2); \
    637                     IEM_MC_REF_EFLAGS(pEFlags); \
    638                     IEM_MC_CALL_VOID_AIMPL_3(RT_CONCAT3(iemAImpl_,a_InsNm,_u32), pu32Dst, u32Src, pEFlags); \
     630                    IEM_MC_ARG_EFLAGS(      fEFlagsIn,  0); \
     631                    IEM_MC_CALL_AIMPL_3(uint32_t, fEFlagsRet, RT_CONCAT3(iemAImpl_,a_InsNm,_u32), fEFlagsIn, pu32Dst, u32Src); \
     632                    IEM_MC_COMMIT_EFLAGS(fEFlagsRet); \
    639633                } IEM_MC_NATIVE_ENDIF(); \
    640634                IEM_MC_ADVANCE_RIP_AND_FINISH(); \
    … …  
    645639                IEM_MC_BEGIN(IEM_MC_F_64BIT, 0); \
    646640                IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX(); \
    647                 IEM_MC_ARG(uint64_t,        u64Src,  1); \
     641                IEM_MC_ARG(uint64_t,        u64Src,     2); \
    648642                IEM_MC_FETCH_GREG_U64(u64Src, IEM_GET_MODRM_REG(pVCpu, a_bRm)); \
    649643                IEM_MC_NATIVE_IF(a_fNativeArchs) { \
    … …  
    654648                    IEM_MC_COMMIT_EFLAGS_OPT(uEFlags); \
    655649                } IEM_MC_NATIVE_ELSE() { \
    656                     IEM_MC_ARG(uint64_t *,  pu64Dst, 0); \
     650                    IEM_MC_ARG(uint64_t *,  pu64Dst,    1); \
    657651                    IEM_MC_REF_GREG_U64(pu64Dst, IEM_GET_MODRM_RM(pVCpu, a_bRm)); \
    658                     IEM_MC_ARG(uint32_t *,  pEFlags, 2); \
    659                     IEM_MC_REF_EFLAGS(pEFlags); \
    660                     IEM_MC_CALL_VOID_AIMPL_3(RT_CONCAT3(iemAImpl_,a_InsNm,_u64), pu64Dst, u64Src, pEFlags); \
     652                    IEM_MC_ARG_EFLAGS(      fEFlagsIn,  0); \
     653                    IEM_MC_CALL_AIMPL_3(uint32_t, fEFlagsRet, RT_CONCAT3(iemAImpl_,a_InsNm,_u64), fEFlagsIn, pu64Dst, u64Src); \
     654                    IEM_MC_COMMIT_EFLAGS(fEFlagsRet); \
    661655                } IEM_MC_NATIVE_ENDIF(); \
    662656                IEM_MC_ADVANCE_RIP_AND_FINISH(); \
    … …  
    671665        /* \
    672666         * We're accessing memory. \
    673          * Note! We're putting the eflags on the stack here so we can commit them \
    674          *       after the memory. \
    675667         */ \
    676668        if (!(pVCpu->iem.s.fPrefixes & IEM_OP_PRF_LOCK) || (pVCpu->iem.s.fExec & IEM_F_X86_DISREGARD_LOCK)) \
    … …  
    692684                        IEM_MC_COMMIT_EFLAGS_OPT(uEFlags); \
    693685                    } IEM_MC_NATIVE_ELSE() { \
    694                         IEM_MC_LOCAL(uint8_t,        bUnmapInfo); \
    695                         IEM_MC_ARG(uint16_t const *, pu16Dst,         0); \
     686                        IEM_MC_LOCAL(uint8_t,         bUnmapInfo); \
     687                        IEM_MC_ARG(uint16_t const *,  pu16Dst,      1); \
    696688                        IEM_MC_MEM_MAP_U16_RO(pu16Dst, bUnmapInfo, pVCpu->iem.s.iEffSeg, GCPtrEffDst); \
    697                         IEM_MC_ARG(uint16_t,         u16Src,          1); \
     689                        IEM_MC_ARG(uint16_t,          u16Src,       2); \
    698690                        IEM_MC_FETCH_GREG_U16(u16Src, IEM_GET_MODRM_REG(pVCpu, a_bRm)); \
    699                         IEM_MC_ARG_LOCAL_EFLAGS(     pEFlags, EFlags, 2); \
    700                         IEM_MC_CALL_VOID_AIMPL_3(RT_CONCAT3(iemAImpl_,a_InsNm,_u16), pu16Dst, u16Src, pEFlags); \
     691                        IEM_MC_ARG_EFLAGS(            fEFlagsIn,    0); \
     692                        IEM_MC_CALL_AIMPL_3(uint32_t, fEFlagsRet, RT_CONCAT3(iemAImpl_,a_InsNm,_u16), fEFlagsIn, pu16Dst, u16Src); \
    701693                        IEM_MC_MEM_COMMIT_AND_UNMAP_RO(bUnmapInfo); \
    702                         IEM_MC_COMMIT_EFLAGS(EFlags); \
     694                        IEM_MC_COMMIT_EFLAGS(fEFlagsRet); \
    703695                    } IEM_MC_NATIVE_ENDIF(); \
    704696                    IEM_MC_ADVANCE_RIP_AND_FINISH(); \
    … …  
    720712                        IEM_MC_COMMIT_EFLAGS_OPT(uEFlags); \
    721713                    } IEM_MC_NATIVE_ELSE() { \
    722                         IEM_MC_LOCAL(uint8_t,        bUnmapInfo); \
    723                         IEM_MC_ARG(uint32_t const *, pu32Dst,         0); \
     714                        IEM_MC_LOCAL(uint8_t,         bUnmapInfo); \
     715                        IEM_MC_ARG(uint32_t const *,  pu32Dst,      1); \
    724716                        IEM_MC_MEM_MAP_U32_RO(pu32Dst, bUnmapInfo, pVCpu->iem.s.iEffSeg, GCPtrEffDst); \
    725                         IEM_MC_ARG(uint32_t,         u32Src,          1); \
     717                        IEM_MC_ARG(uint32_t,          u32Src,       2); \
    726718                        IEM_MC_FETCH_GREG_U32(u32Src, IEM_GET_MODRM_REG(pVCpu, a_bRm)); \
    727                         IEM_MC_ARG_LOCAL_EFLAGS(     pEFlags, EFlags, 2); \
    728                         IEM_MC_CALL_VOID_AIMPL_3(RT_CONCAT3(iemAImpl_,a_InsNm,_u32), pu32Dst, u32Src, pEFlags); \
     719                        IEM_MC_ARG_EFLAGS(            fEFlagsIn,    0); \
     720                        IEM_MC_CALL_AIMPL_3(uint32_t, fEFlagsRet, RT_CONCAT3(iemAImpl_,a_InsNm,_u32), fEFlagsIn, pu32Dst, u32Src); \
    729721                        IEM_MC_MEM_COMMIT_AND_UNMAP_RO(bUnmapInfo); \
    730                         IEM_MC_COMMIT_EFLAGS(EFlags); \
     722                        IEM_MC_COMMIT_EFLAGS(fEFlagsRet); \
    731723                    } IEM_MC_NATIVE_ENDIF(); \
    732724                    IEM_MC_ADVANCE_RIP_AND_FINISH(); \
    … …  
    748740                        IEM_MC_COMMIT_EFLAGS_OPT(uEFlags); \
    749741                    } IEM_MC_NATIVE_ELSE() { \
    750                         IEM_MC_LOCAL(uint8_t,        bUnmapInfo); \
    751                         IEM_MC_ARG(uint64_t const *, pu64Dst,         0); \
     742                        IEM_MC_LOCAL(uint8_t,         bUnmapInfo); \
     743                        IEM_MC_ARG(uint64_t const *,  pu64Dst,      1); \
    752744                        IEM_MC_MEM_MAP_U64_RO(pu64Dst, bUnmapInfo, pVCpu->iem.s.iEffSeg, GCPtrEffDst); \
    753                         IEM_MC_ARG(uint64_t,         u64Src,          1); \
     745                        IEM_MC_ARG(uint64_t,          u64Src,       2); \
    754746                        IEM_MC_FETCH_GREG_U64(u64Src, IEM_GET_MODRM_REG(pVCpu, a_bRm)); \
    755                         IEM_MC_ARG_LOCAL_EFLAGS(     pEFlags, EFlags, 2); \
    756                         IEM_MC_CALL_VOID_AIMPL_3(RT_CONCAT3(iemAImpl_,a_InsNm,_u64), pu64Dst, u64Src, pEFlags); \
     747                        IEM_MC_ARG_EFLAGS(            fEFlagsIn,    0); \
     748                        IEM_MC_CALL_AIMPL_3(uint32_t, fEFlagsRet, RT_CONCAT3(iemAImpl_,a_InsNm,_u64), fEFlagsIn, pu64Dst, u64Src); \
    757749                        IEM_MC_MEM_COMMIT_AND_UNMAP_RO(bUnmapInfo); \
    758                         IEM_MC_COMMIT_EFLAGS(EFlags); \
     750                        IEM_MC_COMMIT_EFLAGS(fEFlagsRet); \
    759751                    } IEM_MC_NATIVE_ENDIF(); \
    760752                    IEM_MC_ADVANCE_RIP_AND_FINISH(); \
    … …  
    791783        IEM_MC_COMMIT_EFLAGS_OPT(uEFlags); \
    792784    } IEM_MC_NATIVE_ELSE() { \
    793         IEM_MC_ARG_CONST(uint8_t,   u8Src,/*=*/ u8Imm,  1); \
    794         IEM_MC_ARG(uint8_t *,       pu8Dst,             0); \
     785        IEM_MC_ARG(uint8_t *,       pu8Dst,             1); \
    795786        IEM_MC_REF_GREG_U8(pu8Dst, X86_GREG_xAX); \
    796         IEM_MC_ARG(uint32_t *,      pEFlags,            2); \
    797         IEM_MC_REF_EFLAGS(pEFlags); \
    798         IEM_MC_CALL_VOID_AIMPL_3(RT_CONCAT3(iemAImpl_,a_InsNm,_u8), pu8Dst, u8Src, pEFlags); \
     787        IEM_MC_ARG_EFLAGS(          fEFlagsIn,          0); \
     788        IEM_MC_ARG_CONST(uint8_t,   u8Src,/*=*/ u8Imm,  2); \
     789        IEM_MC_CALL_AIMPL_3(uint32_t, fEFlagsRet, RT_CONCAT3(iemAImpl_,a_InsNm,_u8), fEFlagsIn, pu8Dst, u8Src); \
     790        IEM_MC_COMMIT_EFLAGS(fEFlagsRet); \
    799791    } IEM_MC_NATIVE_ENDIF(); \
    800792    IEM_MC_ADVANCE_RIP_AND_FINISH();  \
    … …  
    822814                IEM_MC_COMMIT_EFLAGS_OPT(uEFlags); \
    823815            } IEM_MC_NATIVE_ELSE() { \
    824                 IEM_MC_ARG_CONST(uint16_t,  u16Src,/*=*/ u16Imm,    1); \
    825                 IEM_MC_ARG(uint16_t *,      pu16Dst,                0); \
     816                IEM_MC_ARG_CONST(uint16_t,  u16Src,/*=*/ u16Imm,    2); \
     817                IEM_MC_ARG(uint16_t *,      pu16Dst,                1); \
    826818                IEM_MC_REF_GREG_U16(pu16Dst, X86_GREG_xAX); \
    827                 IEM_MC_ARG(uint32_t *,      pEFlags,                2); \
    828                 IEM_MC_REF_EFLAGS(pEFlags); \
    829                 IEM_MC_CALL_VOID_AIMPL_3(RT_CONCAT3(iemAImpl_,a_InsNm,_u16), pu16Dst, u16Src, pEFlags); \
     819                IEM_MC_ARG_EFLAGS(          fEFlagsIn,              0); \
     820                IEM_MC_CALL_AIMPL_3(uint32_t, fEFlagsRet, RT_CONCAT3(iemAImpl_,a_InsNm,_u16), fEFlagsIn, pu16Dst, u16Src); \
     821                IEM_MC_COMMIT_EFLAGS(fEFlagsRet); \
    830822            } IEM_MC_NATIVE_ENDIF(); \
    831823            IEM_MC_ADVANCE_RIP_AND_FINISH(); \
    … …  
    847839                IEM_MC_COMMIT_EFLAGS_OPT(uEFlags); \
    848840            } IEM_MC_NATIVE_ELSE() { \
    849                 IEM_MC_ARG_CONST(uint32_t,  u32Src,/*=*/ u32Imm,    1); \
    850                 IEM_MC_ARG(uint32_t *,      pu32Dst,                0); \
     841                IEM_MC_ARG_CONST(uint32_t,  u32Src,/*=*/ u32Imm,    2); \
     842                IEM_MC_ARG(uint32_t *,      pu32Dst,                1); \
    851843                IEM_MC_REF_GREG_U32(pu32Dst, X86_GREG_xAX); \
    852                 IEM_MC_ARG(uint32_t *,      pEFlags,                2); \
    853                 IEM_MC_REF_EFLAGS(pEFlags); \
    854                 IEM_MC_CALL_VOID_AIMPL_3(RT_CONCAT3(iemAImpl_,a_InsNm,_u32), pu32Dst, u32Src, pEFlags); \
     844                IEM_MC_ARG_EFLAGS(          fEFlagsIn,              0); \
     845                IEM_MC_CALL_AIMPL_3(uint32_t, fEFlagsRet, RT_CONCAT3(iemAImpl_,a_InsNm,_u32), fEFlagsIn, pu32Dst, u32Src); \
    855846                IEM_MC_CLEAR_HIGH_GREG_U64(X86_GREG_xAX); \
     847                IEM_MC_COMMIT_EFLAGS(fEFlagsRet); \
    856848            } IEM_MC_NATIVE_ENDIF(); \
    857849            IEM_MC_ADVANCE_RIP_AND_FINISH(); \
    … …  
    873865                IEM_MC_COMMIT_EFLAGS_OPT(uEFlags); \
    874866            } IEM_MC_NATIVE_ELSE() { \
    875                 IEM_MC_ARG_CONST(uint64_t,  u64Src,/*=*/ u64Imm,    1); \
    876                 IEM_MC_ARG(uint64_t *,      pu64Dst,                0); \
     867                IEM_MC_ARG_CONST(uint64_t,  u64Src,/*=*/ u64Imm,    2); \
     868                IEM_MC_ARG(uint64_t *,      pu64Dst,                1); \
    877869                IEM_MC_REF_GREG_U64(pu64Dst, X86_GREG_xAX); \
    878                 IEM_MC_ARG(uint32_t *,      pEFlags,                2); \
    879                 IEM_MC_REF_EFLAGS(pEFlags); \
    880                 IEM_MC_CALL_VOID_AIMPL_3(RT_CONCAT3(iemAImpl_,a_InsNm,_u64), pu64Dst, u64Src, pEFlags); \
     870                IEM_MC_ARG_EFLAGS(          fEFlagsIn,              0); \
     871                IEM_MC_CALL_AIMPL_3(uint32_t, fEFlagsRet, RT_CONCAT3(iemAImpl_,a_InsNm,_u64), fEFlagsIn, pu64Dst, u64Src); \
     872                IEM_MC_COMMIT_EFLAGS(fEFlagsRet); \
    881873            } IEM_MC_NATIVE_ENDIF(); \
    882874            IEM_MC_ADVANCE_RIP_AND_FINISH(); \
    … …  
    908900                IEM_MC_COMMIT_EFLAGS_OPT(uEFlags); \
    909901            } IEM_MC_NATIVE_ELSE() { \
    910                 IEM_MC_ARG_CONST(uint16_t,  u16Src,/*=*/ u16Imm,    1); \
    911                 IEM_MC_ARG(uint16_t const *,pu16Dst,                0); \
     902                IEM_MC_ARG_CONST(uint16_t,  u16Src,/*=*/ u16Imm,    2); \
     903                IEM_MC_ARG(uint16_t const *,pu16Dst,                1); \
    912904                IEM_MC_REF_GREG_U16_CONST(pu16Dst, X86_GREG_xAX); \
    913                 IEM_MC_ARG(uint32_t *,      pEFlags,                2); \
    914                 IEM_MC_REF_EFLAGS(pEFlags); \
    915                 IEM_MC_CALL_VOID_AIMPL_3(RT_CONCAT3(iemAImpl_,a_InsNm,_u16), pu16Dst, u16Src, pEFlags); \
     905                IEM_MC_ARG_EFLAGS(          fEFlagsIn,              0); \
     906                IEM_MC_CALL_AIMPL_3(uint32_t, fEFlagsRet, RT_CONCAT3(iemAImpl_,a_InsNm,_u16), fEFlagsIn, pu16Dst, u16Src); \
     907                IEM_MC_COMMIT_EFLAGS(fEFlagsRet); \
    916908            } IEM_MC_NATIVE_ENDIF(); \
    917909            IEM_MC_ADVANCE_RIP_AND_FINISH(); \
    … …  
    932924                IEM_MC_COMMIT_EFLAGS_OPT(uEFlags); \
    933925            } IEM_MC_NATIVE_ELSE() { \
    934                 IEM_MC_ARG_CONST(uint32_t,  u32Src,/*=*/ u32Imm,    1); \
    935                 IEM_MC_ARG(uint32_t const *,pu32Dst,                0); \
     926                IEM_MC_ARG_CONST(uint32_t,  u32Src,/*=*/ u32Imm,    2); \
     927                IEM_MC_ARG(uint32_t const *,pu32Dst,                1); \
    936928                IEM_MC_REF_GREG_U32_CONST(pu32Dst, X86_GREG_xAX); \
    937                 IEM_MC_ARG(uint32_t *,      pEFlags,                2); \
    938                 IEM_MC_REF_EFLAGS(pEFlags); \
    939                 IEM_MC_CALL_VOID_AIMPL_3(RT_CONCAT3(iemAImpl_,a_InsNm,_u32), pu32Dst, u32Src, pEFlags); \
     929                IEM_MC_ARG_EFLAGS(          fEFlagsIn,              0); \
     930                IEM_MC_CALL_AIMPL_3(uint32_t, fEFlagsRet, RT_CONCAT3(iemAImpl_,a_InsNm,_u32), fEFlagsIn, pu32Dst, u32Src); \
     931                IEM_MC_COMMIT_EFLAGS(fEFlagsRet); \
    940932            } IEM_MC_NATIVE_ENDIF(); \
    941933            IEM_MC_ADVANCE_RIP_AND_FINISH(); \
    … …  
    956948                IEM_MC_COMMIT_EFLAGS_OPT(uEFlags); \
    957949            } IEM_MC_NATIVE_ELSE() { \
    958                 IEM_MC_ARG_CONST(uint64_t,  u64Src,/*=*/ u64Imm,    1); \
    959                 IEM_MC_ARG(uint64_t const *,pu64Dst,                0); \
     950                IEM_MC_ARG_CONST(uint64_t,  u64Src,/*=*/ u64Imm,    2); \
     951                IEM_MC_ARG(uint64_t const *,pu64Dst,                1); \
    960952                IEM_MC_REF_GREG_U64_CONST(pu64Dst, X86_GREG_xAX); \
    961                 IEM_MC_ARG(uint32_t *,      pEFlags,                2); \
    962                 IEM_MC_REF_EFLAGS(pEFlags); \
    963                 IEM_MC_CALL_VOID_AIMPL_3(RT_CONCAT3(iemAImpl_,a_InsNm,_u64), pu64Dst, u64Src, pEFlags); \
     953                IEM_MC_ARG_EFLAGS(          fEFlagsIn,              0); \
     954                IEM_MC_CALL_AIMPL_3(uint32_t, fEFlagsRet, RT_CONCAT3(iemAImpl_,a_InsNm,_u64), fEFlagsIn, pu64Dst, u64Src); \
     955                IEM_MC_COMMIT_EFLAGS(fEFlagsRet); \
    964956            } IEM_MC_NATIVE_ENDIF(); \
    965957            IEM_MC_ADVANCE_RIP_AND_FINISH(); \
    … …  
    16121604    IEM_MC_DEFER_TO_CIMPL_0_RET(IEM_CIMPL_F_STATUS_FLAGS, RT_BIT_64(kIemNativeGstReg_GprFirst + X86_GREG_xAX), iemCImpl_daa);
    16131605}
     1606
     1607
     1608/**
     1609 * Special case body for word/dword/qword instruction like SUB and XOR that can
     1610 * be used to zero a register.
     1611 *
     1612 * This can be used both for the rv_rm and rm_rv forms since it's working on the
     1613 * same register.
     1614 */
     1615#define IEMOP_BODY_BINARY_rv_SAME_REG_ZERO(a_bRm) \
     1616    if (   (a_bRm >> X86_MODRM_REG_SHIFT) == ((a_bRm & X86_MODRM_RM_MASK) | (X86_MOD_REG << X86_MODRM_REG_SHIFT)) \
     1617        && pVCpu->iem.s.uRexReg == pVCpu->iem.s.uRexB) \
     1618    { \
     1619        switch (pVCpu->iem.s.enmEffOpSize) \
     1620        { \
     1621            case IEMMODE_16BIT: \
     1622                IEM_MC_BEGIN(0, 0); \
     1623                IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX(); \
     1624                IEM_MC_STORE_GREG_U16_CONST(IEM_GET_MODRM_RM(pVCpu, a_bRm), 0); \
     1625                IEM_MC_LOCAL_EFLAGS(fEFlags); \
     1626                IEM_MC_AND_LOCAL_U32(fEFlags, ~(uint32_t)X86_EFL_STATUS_BITS); \
     1627                IEM_MC_OR_LOCAL_U32(fEFlags, X86_EFL_PF | X86_EFL_ZF); \
     1628                IEM_MC_COMMIT_EFLAGS(fEFlags); \
     1629                IEM_MC_ADVANCE_RIP_AND_FINISH(); \
     1630                IEM_MC_END(); \
     1631                break; \
     1632                \
     1633            case IEMMODE_32BIT: \
     1634                IEM_MC_BEGIN(IEM_MC_F_MIN_386, 0); \
     1635                IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX(); \
     1636                IEM_MC_STORE_GREG_U32_CONST(IEM_GET_MODRM_RM(pVCpu, a_bRm), 0); \
     1637                IEM_MC_LOCAL_EFLAGS(fEFlags); \
     1638                IEM_MC_AND_LOCAL_U32(fEFlags, ~(uint32_t)X86_EFL_STATUS_BITS); \
     1639                IEM_MC_OR_LOCAL_U32(fEFlags, X86_EFL_PF | X86_EFL_ZF); \
     1640                IEM_MC_COMMIT_EFLAGS(fEFlags); \
     1641                IEM_MC_ADVANCE_RIP_AND_FINISH(); \
     1642                IEM_MC_END(); \
     1643                break; \
     1644                \
     1645            case IEMMODE_64BIT: \
     1646                IEM_MC_BEGIN(IEM_MC_F_64BIT, 0); \
     1647                IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX(); \
     1648                IEM_MC_STORE_GREG_U64_CONST(IEM_GET_MODRM_RM(pVCpu, a_bRm), 0); \
     1649                IEM_MC_LOCAL_EFLAGS(fEFlags); \
     1650                IEM_MC_AND_LOCAL_U32(fEFlags, ~(uint32_t)X86_EFL_STATUS_BITS); \
     1651                IEM_MC_OR_LOCAL_U32(fEFlags, X86_EFL_PF | X86_EFL_ZF); \
     1652                IEM_MC_COMMIT_EFLAGS(fEFlags); \
     1653                IEM_MC_ADVANCE_RIP_AND_FINISH(); \
     1654                IEM_MC_END(); \
     1655                break; \
     1656                \
     1657            IEM_NOT_REACHED_DEFAULT_CASE_RET(); \
     1658        } \
     1659    } ((void)0)
    16141660
    16151661
    … …  
    18851931    IEM_MC_DEFER_TO_CIMPL_0_RET(IEM_CIMPL_F_STATUS_FLAGS, RT_BIT_64(kIemNativeGstReg_GprFirst + X86_GREG_xAX), iemCImpl_aaa);
    18861932}
     1933
     1934
     1935/**
     1936 * Body for word/dword/qword the instruction CMP, ++ with a register as the
     1937 * destination.
     1938 *
     1939 * @note Used both in OneByte and TwoByte0f.
     1940 */
     1941#define IEMOP_BODY_BINARY_rv_rm_RO(a_bRm, a_InsNm, a_fNativeArchs) \
     1942    /* \
     1943     * If rm is denoting a register, no more instruction bytes. \
     1944     */ \
     1945    if (IEM_IS_MODRM_REG_MODE(a_bRm)) \
     1946    { \
     1947        switch (pVCpu->iem.s.enmEffOpSize) \
     1948        { \
     1949            case IEMMODE_16BIT: \
     1950                IEM_MC_BEGIN(0, 0); \
     1951                IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX(); \
     1952                IEM_MC_ARG(uint16_t,        u16Src,     2); \
     1953                IEM_MC_FETCH_GREG_U16(u16Src, IEM_GET_MODRM_RM(pVCpu, a_bRm)); \
     1954                IEM_MC_NATIVE_IF(a_fNativeArchs) { \
     1955                    IEM_MC_LOCAL(uint16_t,  u16Dst); \
     1956                    IEM_MC_FETCH_GREG_U16(u16Dst, IEM_GET_MODRM_REG(pVCpu, bRm)); \
     1957                    IEM_MC_LOCAL_EFLAGS(uEFlags); \
     1958                    IEM_MC_NATIVE_EMIT_4(RT_CONCAT3(iemNativeEmit_,a_InsNm,_r_r_efl), u16Dst, u16Src, uEFlags, 16); \
     1959                    IEM_MC_COMMIT_EFLAGS_OPT(uEFlags); \
     1960                } IEM_MC_NATIVE_ELSE() { \
     1961                    IEM_MC_ARG(uint16_t *,  pu16Dst,    1); \
     1962                    IEM_MC_REF_GREG_U16(pu16Dst, IEM_GET_MODRM_REG(pVCpu, bRm)); \
     1963                    IEM_MC_ARG_EFLAGS(      fEFlagsIn,  0); \
     1964                    IEM_MC_CALL_AIMPL_3(uint32_t, fEFlagsRet, RT_CONCAT3(iemAImpl_,a_InsNm,_u16), fEFlagsIn, pu16Dst, u16Src); \
     1965                    IEM_MC_COMMIT_EFLAGS(fEFlagsRet); \
     1966                } IEM_MC_NATIVE_ENDIF(); \
     1967                IEM_MC_ADVANCE_RIP_AND_FINISH(); \
     1968                IEM_MC_END(); \
     1969                break; \
     1970            \
     1971            case IEMMODE_32BIT: \
     1972                IEM_MC_BEGIN(IEM_MC_F_MIN_386, 0); \
     1973                IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX(); \
     1974                IEM_MC_ARG(uint32_t,        u32Src,     2); \
     1975                IEM_MC_FETCH_GREG_U32(u32Src, IEM_GET_MODRM_RM(pVCpu, a_bRm)); \
     1976                IEM_MC_NATIVE_IF(a_fNativeArchs) { \
     1977                    IEM_MC_LOCAL(uint32_t,  u32Dst); \
     1978                    IEM_MC_FETCH_GREG_U32(u32Dst, IEM_GET_MODRM_REG(pVCpu, bRm)); \
     1979                    IEM_MC_LOCAL_EFLAGS(uEFlags); \
     1980                    IEM_MC_NATIVE_EMIT_4(RT_CONCAT3(iemNativeEmit_,a_InsNm,_r_r_efl), u32Dst, u32Src, uEFlags, 32); \
     1981                    IEM_MC_COMMIT_EFLAGS_OPT(uEFlags); \
     1982                } IEM_MC_NATIVE_ELSE() { \
     1983                    IEM_MC_ARG(uint32_t *,  pu32Dst,    1); \
     1984                    IEM_MC_REF_GREG_U32(pu32Dst, IEM_GET_MODRM_REG(pVCpu, bRm)); \
     1985                    IEM_MC_ARG_EFLAGS(      fEFlagsIn,  0); \
     1986                    IEM_MC_CALL_AIMPL_3(uint32_t, fEFlagsRet, RT_CONCAT3(iemAImpl_,a_InsNm,_u32), fEFlagsIn, pu32Dst, u32Src); \
     1987                    IEM_MC_COMMIT_EFLAGS(fEFlagsRet); \
     1988                } IEM_MC_NATIVE_ENDIF(); \
     1989                IEM_MC_ADVANCE_RIP_AND_FINISH(); \
     1990                IEM_MC_END(); \
     1991                break; \
     1992            \
     1993            case IEMMODE_64BIT: \
     1994                IEM_MC_BEGIN(IEM_MC_F_64BIT, 0); \
     1995                IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX(); \
     1996                IEM_MC_ARG(uint64_t,        u64Src,     2); \
     1997                IEM_MC_FETCH_GREG_U64(u64Src, IEM_GET_MODRM_RM(pVCpu, a_bRm)); \
     1998                IEM_MC_NATIVE_IF(a_fNativeArchs) { \
     1999                    IEM_MC_LOCAL(uint64_t,  u64Dst); \
     2000                    IEM_MC_FETCH_GREG_U64(u64Dst, IEM_GET_MODRM_REG(pVCpu, bRm)); \
     2001                    IEM_MC_LOCAL_EFLAGS(uEFlags); \
     2002                    IEM_MC_NATIVE_EMIT_4(RT_CONCAT3(iemNativeEmit_,a_InsNm,_r_r_efl), u64Dst, u64Src, uEFlags, 64); \
     2003                    IEM_MC_COMMIT_EFLAGS_OPT(uEFlags); \
     2004                } IEM_MC_NATIVE_ELSE() { \
     2005                    IEM_MC_ARG(uint64_t *,  pu64Dst,    1); \
     2006                    IEM_MC_REF_GREG_U64(pu64Dst, IEM_GET_MODRM_REG(pVCpu, bRm)); \
     2007                    IEM_MC_ARG_EFLAGS(      fEFlagsIn,  0); \
     2008                    IEM_MC_CALL_AIMPL_3(uint32_t, fEFlagsRet, RT_CONCAT3(iemAImpl_,a_InsNm,_u64), fEFlagsIn, pu64Dst, u64Src); \
     2009                    IEM_MC_COMMIT_EFLAGS(fEFlagsRet); \
     2010                } IEM_MC_NATIVE_ENDIF(); \
     2011                IEM_MC_ADVANCE_RIP_AND_FINISH(); \
     2012                IEM_MC_END(); \
     2013                break; \
     2014            \
     2015            IEM_NOT_REACHED_DEFAULT_CASE_RET(); \
     2016        } \
     2017    } \
     2018    else \
     2019    { \
     2020        /* \
     2021         * We're accessing memory. \
     2022         */ \
     2023        switch (pVCpu->iem.s.enmEffOpSize) \
     2024        { \
     2025            case IEMMODE_16BIT: \
     2026                IEM_MC_BEGIN(0, 0); \
     2027                IEM_MC_LOCAL(RTGCPTR,  GCPtrEffDst); \
     2028                IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, a_bRm, 0); \
     2029                IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX(); \
     2030                IEM_MC_ARG(uint16_t,        u16Src,     2); \
     2031                IEM_MC_FETCH_MEM_U16(u16Src, pVCpu->iem.s.iEffSeg, GCPtrEffDst); \
     2032                IEM_MC_NATIVE_IF(a_fNativeArchs) { \
     2033                    IEM_MC_LOCAL(uint16_t,  u16Dst); \
     2034                    IEM_MC_FETCH_GREG_U16(u16Dst, IEM_GET_MODRM_REG(pVCpu, bRm)); \
     2035                    IEM_MC_LOCAL_EFLAGS(uEFlags); \
     2036                    IEM_MC_NATIVE_EMIT_4(RT_CONCAT3(iemNativeEmit_,a_InsNm,_r_r_efl), u16Dst, u16Src, uEFlags, 16); \
     2037                    IEM_MC_COMMIT_EFLAGS_OPT(uEFlags); \
     2038                } IEM_MC_NATIVE_ELSE() { \
     2039                    IEM_MC_ARG(uint16_t *,  pu16Dst,    1); \
     2040                    IEM_MC_REF_GREG_U16(pu16Dst, IEM_GET_MODRM_REG(pVCpu, a_bRm)); \
     2041                    IEM_MC_ARG_EFLAGS(      fEFlagsIn,  0); \
     2042                    IEM_MC_CALL_AIMPL_3(uint32_t, fEFlagsRet, RT_CONCAT3(iemAImpl_,a_InsNm,_u16), fEFlagsIn, pu16Dst, u16Src); \
     2043                    IEM_MC_COMMIT_EFLAGS(fEFlagsRet); \
     2044                } IEM_MC_NATIVE_ENDIF(); \
     2045                IEM_MC_ADVANCE_RIP_AND_FINISH(); \
     2046                IEM_MC_END(); \
     2047                break; \
     2048            \
     2049            case IEMMODE_32BIT: \
     2050                IEM_MC_BEGIN(IEM_MC_F_MIN_386, 0); \
     2051                IEM_MC_LOCAL(RTGCPTR,  GCPtrEffDst); \
     2052                IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, a_bRm, 0); \
     2053                IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX(); \
     2054                IEM_MC_ARG(uint32_t,        u32Src,  2); \
     2055                IEM_MC_FETCH_MEM_U32(u32Src, pVCpu->iem.s.iEffSeg, GCPtrEffDst); \
     2056                IEM_MC_NATIVE_IF(a_fNativeArchs) { \
     2057                    IEM_MC_LOCAL(uint32_t,  u32Dst); \
     2058                    IEM_MC_FETCH_GREG_U32(u32Dst, IEM_GET_MODRM_REG(pVCpu, bRm)); \
     2059                    IEM_MC_LOCAL_EFLAGS(uEFlags); \
     2060                    IEM_MC_NATIVE_EMIT_4(RT_CONCAT3(iemNativeEmit_,a_InsNm,_r_r_efl), u32Dst, u32Src, uEFlags, 32); \
     2061                    IEM_MC_COMMIT_EFLAGS_OPT(uEFlags); \
     2062                } IEM_MC_NATIVE_ELSE() { \
     2063                    IEM_MC_ARG(uint32_t *,  pu32Dst,    1); \
     2064                    IEM_MC_REF_GREG_U32(pu32Dst, IEM_GET_MODRM_REG(pVCpu, a_bRm)); \
     2065                    IEM_MC_ARG_EFLAGS(      fEFlagsIn,  0); \
     2066                    IEM_MC_CALL_AIMPL_3(uint32_t, fEFlagsRet, RT_CONCAT3(iemAImpl_,a_InsNm,_u32), fEFlagsIn, pu32Dst, u32Src); \
     2067                    IEM_MC_COMMIT_EFLAGS(fEFlagsRet); \
     2068                } IEM_MC_NATIVE_ENDIF(); \
     2069                IEM_MC_ADVANCE_RIP_AND_FINISH(); \
     2070                IEM_MC_END(); \
     2071                break; \
     2072            \
     2073            case IEMMODE_64BIT: \
     2074                IEM_MC_BEGIN(IEM_MC_F_64BIT, 0); \
     2075                IEM_MC_LOCAL(RTGCPTR,  GCPtrEffDst); \
     2076                IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, a_bRm, 0); \
     2077                IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX(); \
     2078                IEM_MC_ARG(uint64_t,        u64Src,     2); \
     2079                IEM_MC_FETCH_MEM_U64(u64Src, pVCpu->iem.s.iEffSeg, GCPtrEffDst); \
     2080                IEM_MC_NATIVE_IF(a_fNativeArchs) { \
     2081                    IEM_MC_LOCAL(uint64_t,  u64Dst); \
     2082                    IEM_MC_FETCH_GREG_U64(u64Dst, IEM_GET_MODRM_REG(pVCpu, bRm)); \
     2083                    IEM_MC_LOCAL_EFLAGS(uEFlags); \
     2084                    IEM_MC_NATIVE_EMIT_4(RT_CONCAT3(iemNativeEmit_,a_InsNm,_r_r_efl), u64Dst, u64Src, uEFlags, 64); \
     2085                    IEM_MC_COMMIT_EFLAGS_OPT(uEFlags); \
     2086                } IEM_MC_NATIVE_ELSE() { \
     2087                    IEM_MC_ARG(uint64_t *,  pu64Dst,    1); \
     2088                    IEM_MC_REF_GREG_U64(pu64Dst, IEM_GET_MODRM_REG(pVCpu, a_bRm)); \
     2089                    IEM_MC_ARG_EFLAGS(      fEFlagsIn,  0); \
     2090                    IEM_MC_CALL_AIMPL_3(uint32_t, fEFlagsRet, RT_CONCAT3(iemAImpl_,a_InsNm,_u64), fEFlagsIn, pu64Dst, u64Src); \
     2091                    IEM_MC_COMMIT_EFLAGS(fEFlagsRet); \
     2092                } IEM_MC_NATIVE_ENDIF(); \
     2093                IEM_MC_ADVANCE_RIP_AND_FINISH(); \
     2094                IEM_MC_END(); \
     2095                break; \
     2096            \
     2097            IEM_NOT_REACHED_DEFAULT_CASE_RET(); \
     2098        } \
     2099    } \
     2100    (void)0
    18872101
    18882102
    … …  
    31723386        case IEMMODE_16BIT:
    31733387        {
    3174             PFNIEMAIMPLBINU16 const pfnAImplU16 = IEMTARGETCPU_EFL_BEHAVIOR_SELECT(g_iemAImpl_imul_two_u16_eflags);
     3388            PFNIEMAIMPLBINTODOU16 const pfnAImplU16 = IEMTARGETCPU_EFL_BEHAVIOR_SELECT(g_iemAImpl_imul_two_u16_eflags);
    31753389            if (IEM_IS_MODRM_REG_MODE(bRm))
    31763390            {
    … …  
    32193433        case IEMMODE_32BIT:
    32203434        {
    3221             PFNIEMAIMPLBINU32 const pfnAImplU32 = IEMTARGETCPU_EFL_BEHAVIOR_SELECT(g_iemAImpl_imul_two_u32_eflags);
     3435            PFNIEMAIMPLBINTODOU32 const pfnAImplU32 = IEMTARGETCPU_EFL_BEHAVIOR_SELECT(g_iemAImpl_imul_two_u32_eflags);
    32223436            if (IEM_IS_MODRM_REG_MODE(bRm))
    32233437            {
    … …  
    32673481        case IEMMODE_64BIT:
    32683482        {
    3269             PFNIEMAIMPLBINU64 const pfnAImplU64 = IEMTARGETCPU_EFL_BEHAVIOR_SELECT(g_iemAImpl_imul_two_u64_eflags);
     3483            PFNIEMAIMPLBINTODOU64 const pfnAImplU64 = IEMTARGETCPU_EFL_BEHAVIOR_SELECT(g_iemAImpl_imul_two_u64_eflags);
    32703484            if (IEM_IS_MODRM_REG_MODE(bRm))
    32713485            {
    … …  
    33743588        case IEMMODE_16BIT:
    33753589        {
    3376             PFNIEMAIMPLBINU16 const pfnAImplU16 = IEMTARGETCPU_EFL_BEHAVIOR_SELECT(g_iemAImpl_imul_two_u16_eflags);
     3590            PFNIEMAIMPLBINTODOU16 const pfnAImplU16 = IEMTARGETCPU_EFL_BEHAVIOR_SELECT(g_iemAImpl_imul_two_u16_eflags);
    33773591            if (IEM_IS_MODRM_REG_MODE(bRm))
    33783592            {
    … …  
    34243638        case IEMMODE_32BIT:
    34253639        {
    3426             PFNIEMAIMPLBINU32 const pfnAImplU32 = IEMTARGETCPU_EFL_BEHAVIOR_SELECT(g_iemAImpl_imul_two_u32_eflags);
     3640            PFNIEMAIMPLBINTODOU32 const pfnAImplU32 = IEMTARGETCPU_EFL_BEHAVIOR_SELECT(g_iemAImpl_imul_two_u32_eflags);
    34273641            if (IEM_IS_MODRM_REG_MODE(bRm))
    34283642            {
    … …  
    34723686        case IEMMODE_64BIT:
    34733687        {
    3474             PFNIEMAIMPLBINU64 const pfnAImplU64 = IEMTARGETCPU_EFL_BEHAVIOR_SELECT(g_iemAImpl_imul_two_u64_eflags);
     3688            PFNIEMAIMPLBINTODOU64 const pfnAImplU64 = IEMTARGETCPU_EFL_BEHAVIOR_SELECT(g_iemAImpl_imul_two_u64_eflags);
    34753689            if (IEM_IS_MODRM_REG_MODE(bRm))
    34763690            {
    … …  
    41994413            IEM_MC_COMMIT_EFLAGS_OPT(uEFlags); \
    42004414        } IEM_MC_NATIVE_ELSE() { \
    4201             IEM_MC_ARG_CONST(uint8_t,   u8Src, /*=*/ u8Imm,     1); \
    4202             IEM_MC_ARG(uint8_t *,       pu8Dst,                 0); \
     4415            IEM_MC_ARG(uint8_t *,       pu8Dst,                 1); \
    42034416            IEM_MC_REF_GREG_U8(pu8Dst, IEM_GET_MODRM_RM(pVCpu, bRm)); \
    4204             IEM_MC_ARG(uint32_t *,      pEFlags,                2); \
    4205             IEM_MC_REF_EFLAGS(pEFlags); \
    4206             IEM_MC_CALL_VOID_AIMPL_3(RT_CONCAT3(iemAImpl_,a_InsNm,_u8), pu8Dst, u8Src, pEFlags); \
     4417            IEM_MC_ARG_CONST(uint8_t,   u8Src, /*=*/ u8Imm,     2); \
     4418            IEM_MC_ARG_EFLAGS(          fEFlagsIn,              0); \
     4419            IEM_MC_CALL_AIMPL_3(uint32_t, fEFlagsRet, RT_CONCAT3(iemAImpl_,a_InsNm,_u8), fEFlagsIn, pu8Dst, u8Src); \
     4420            IEM_MC_COMMIT_EFLAGS(fEFlagsRet); \
    42074421        } IEM_MC_NATIVE_ENDIF(); \
    42084422        IEM_MC_ADVANCE_RIP_AND_FINISH(); \
    … …  
    42174431            IEM_MC_LOCAL(RTGCPTR, GCPtrEffDst); \
    42184432            IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 1); \
    4219             \
    42204433            uint8_t u8Imm; IEM_OPCODE_GET_NEXT_U8(&u8Imm); \
    4221             IEM_MC_ARG_CONST(uint8_t,   u8Src, /*=*/ u8Imm,     1); \
    42224434            IEMOP_HLP_DONE_DECODING(); \
    42234435            \
    42244436            IEM_MC_LOCAL(uint8_t,       bUnmapInfo); \
    4225             IEM_MC_ARG(uint8_t *,       pu8Dst,                 0); \
     4437            IEM_MC_ARG(uint8_t *,       pu8Dst,                 1); \
    42264438            IEM_MC_MEM_MAP_U8_RW(pu8Dst, bUnmapInfo, pVCpu->iem.s.iEffSeg, GCPtrEffDst); \
    4227             IEM_MC_ARG_LOCAL_EFLAGS(    pEFlags, EFlags,        2); \
    4228             IEM_MC_CALL_VOID_AIMPL_3(RT_CONCAT3(iemAImpl_,a_InsNm,_u8), pu8Dst, u8Src, pEFlags); \
     4439            IEM_MC_ARG_CONST(uint8_t,   u8Src, /*=*/ u8Imm,     2); \
     4440            IEM_MC_ARG_EFLAGS(          fEFlagsIn,              0); \
     4441            IEM_MC_CALL_AIMPL_3(uint32_t, fEFlagsRet, RT_CONCAT3(iemAImpl_,a_InsNm,_u8), fEFlagsIn, pu8Dst, u8Src); \
    42294442            \
    42304443            IEM_MC_MEM_COMMIT_AND_UNMAP_RW(bUnmapInfo); \
    4231             IEM_MC_COMMIT_EFLAGS(EFlags); \
     4444            IEM_MC_COMMIT_EFLAGS(fEFlagsRet); \
    42324445            IEM_MC_ADVANCE_RIP_AND_FINISH(); \
    42334446            IEM_MC_END(); \
    … …  
    42364449        { \
    42374450            IEM_MC_BEGIN(0, 0); \
    4238             IEM_MC_ARG(uint8_t *,       pu8Dst,                 0); \
    42394451            IEM_MC_LOCAL(RTGCPTR, GCPtrEffDst); \
    4240             IEM_MC_LOCAL(uint8_t, bUnmapInfo); \
    4241             \
    42424452            IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 1); \
    42434453            uint8_t u8Imm; IEM_OPCODE_GET_NEXT_U8(&u8Imm); \
    4244             IEM_MC_ARG_CONST(uint8_t,   u8Src, /*=*/ u8Imm,     1); \
    42454454            IEMOP_HLP_DONE_DECODING(); \
    42464455            \
     4456            IEM_MC_LOCAL(uint8_t,       bUnmapInfo); \
     4457            IEM_MC_ARG(uint8_t *,       pu8Dst,                 1); \
    42474458            IEM_MC_MEM_MAP_U8_ATOMIC(pu8Dst, bUnmapInfo, pVCpu->iem.s.iEffSeg, GCPtrEffDst); \
    4248             IEM_MC_ARG_LOCAL_EFLAGS(    pEFlags, EFlags,        2); \
    4249             IEM_MC_CALL_VOID_AIMPL_3(RT_CONCAT3(iemAImpl_,a_InsNm,_u8_locked), pu8Dst, u8Src, pEFlags); \
     4459            IEM_MC_ARG_CONST(uint8_t,   u8Src, /*=*/ u8Imm,     2); \
     4460            IEM_MC_ARG_EFLAGS(          fEFlagsIn,              0); \
     4461            IEM_MC_CALL_AIMPL_3(uint32_t, fEFlagsRet, RT_CONCAT3(iemAImpl_,a_InsNm,_u8_locked), fEFlagsIn, pu8Dst, u8Src); \
    42504462            \
    42514463            IEM_MC_MEM_COMMIT_AND_UNMAP_ATOMIC(bUnmapInfo); \
    4252             IEM_MC_COMMIT_EFLAGS(EFlags); \
     4464            IEM_MC_COMMIT_EFLAGS(fEFlagsRet); \
    42534465            IEM_MC_ADVANCE_RIP_AND_FINISH(); \
    42544466            IEM_MC_END(); \
    … …  
    42714483            IEM_MC_COMMIT_EFLAGS_OPT(uEFlags); \
    42724484        } IEM_MC_NATIVE_ELSE() { \
    4273             IEM_MC_ARG_CONST(uint8_t,   u8Src, /*=*/ u8Imm,     1); \
    4274             IEM_MC_ARG(uint8_t const *, pu8Dst,                 0); \
     4485            IEM_MC_ARG(uint8_t const *, pu8Dst,                 1); \
    42754486            IEM_MC_REF_GREG_U8_CONST(pu8Dst, IEM_GET_MODRM_RM(pVCpu, bRm)); \
    4276             IEM_MC_ARG(uint32_t *,      pEFlags,                2); \
    4277             IEM_MC_REF_EFLAGS(pEFlags); \
    4278             IEM_MC_CALL_VOID_AIMPL_3(RT_CONCAT3(iemAImpl_,a_InsNm,_u8), pu8Dst, u8Src, pEFlags); \
     4487            IEM_MC_ARG_EFLAGS(          fEFlagsIn,              0); \
     4488            IEM_MC_ARG_CONST(uint8_t,   u8Src, /*=*/ u8Imm,     2); \
     4489            IEM_MC_CALL_AIMPL_3(uint32_t, fEFlagsRet, RT_CONCAT3(iemAImpl_,a_InsNm,_u8), fEFlagsIn, pu8Dst, u8Src); \
     4490            IEM_MC_COMMIT_EFLAGS(fEFlagsRet); \
    42794491        } IEM_MC_NATIVE_ENDIF(); \
    42804492        IEM_MC_ADVANCE_RIP_AND_FINISH(); \
    … …  
    42994511            } IEM_MC_NATIVE_ELSE() { \
    43004512                IEM_MC_LOCAL(uint8_t,       bUnmapInfo); \
    4301                 IEM_MC_ARG(uint8_t const *, pu8Dst,                 0); \
     4513                IEM_MC_ARG(uint8_t const *, pu8Dst,                 1); \
    43024514                IEM_MC_MEM_MAP_U8_RO(pu8Dst, bUnmapInfo, pVCpu->iem.s.iEffSeg, GCPtrEffDst); \
    4303                 IEM_MC_ARG_LOCAL_EFLAGS(    pEFlags, EFlags,        2); \
    4304                 IEM_MC_ARG_CONST(uint8_t,   u8Src, /*=*/ u8Imm,     1); \
    4305                 IEM_MC_CALL_VOID_AIMPL_3(RT_CONCAT3(iemAImpl_,a_InsNm,_u8), pu8Dst, u8Src, pEFlags); \
     4515                IEM_MC_ARG_EFLAGS(          fEFlagsIn,              0); \
     4516                IEM_MC_ARG_CONST(uint8_t,   u8Src, /*=*/ u8Imm,     2); \
     4517                IEM_MC_CALL_AIMPL_3(uint32_t, fEFlagsRet, RT_CONCAT3(iemAImpl_,a_InsNm,_u8), fEFlagsIn, pu8Dst, u8Src); \
    43064518                IEM_MC_MEM_COMMIT_AND_UNMAP_RO(bUnmapInfo); \
    4307                 IEM_MC_COMMIT_EFLAGS(EFlags); \
     4519                IEM_MC_COMMIT_EFLAGS(fEFlagsRet); \
    43084520            } IEM_MC_NATIVE_ENDIF(); \
    43094521            IEM_MC_ADVANCE_RIP_AND_FINISH(); \
    … …  
    44604672                    IEM_MC_COMMIT_EFLAGS_OPT(uEFlags); \
    44614673                } IEM_MC_NATIVE_ELSE() { \
    4462                     IEM_MC_ARG(uint16_t *,      pu16Dst,                0); \
     4674                    IEM_MC_ARG(uint16_t *,      pu16Dst,                1); \
    44634675                    IEM_MC_REF_GREG_U16(pu16Dst, IEM_GET_MODRM_RM(pVCpu, bRm)); \
    4464                     IEM_MC_ARG(uint32_t *,      pEFlags,                2); \
    4465                     IEM_MC_REF_EFLAGS(pEFlags); \
    4466                     IEM_MC_ARG_CONST(uint16_t,  u16Src, /*=*/ u16Imm,   1); \
    4467                     IEM_MC_CALL_VOID_AIMPL_3(RT_CONCAT3(iemAImpl_,a_InsNm,_u16), pu16Dst, u16Src, pEFlags); \
     4676                    IEM_MC_ARG_EFLAGS(          fEFlagsIn,              0); \
     4677                    IEM_MC_ARG_CONST(uint16_t,  u16Src, /*=*/ u16Imm,   2); \
     4678                    IEM_MC_CALL_AIMPL_3(uint32_t, fEFlagsRet, RT_CONCAT3(iemAImpl_,a_InsNm,_u16), fEFlagsIn, pu16Dst, u16Src); \
     4679                    IEM_MC_COMMIT_EFLAGS(fEFlagsRet); \
    44684680                } IEM_MC_NATIVE_ENDIF(); \
    44694681                IEM_MC_ADVANCE_RIP_AND_FINISH(); \
    … …  
    44864698                    IEM_MC_COMMIT_EFLAGS_OPT(uEFlags); \
    44874699                } IEM_MC_NATIVE_ELSE() { \
    4488                     IEM_MC_ARG(uint32_t *,      pu32Dst,                0); \
     4700                    IEM_MC_ARG(uint32_t *,      pu32Dst,                1); \
    44894701                    IEM_MC_REF_GREG_U32(pu32Dst, IEM_GET_MODRM_RM(pVCpu, bRm)); \
    4490                     IEM_MC_ARG(uint32_t *,      pEFlags,                2); \
    4491                     IEM_MC_REF_EFLAGS(pEFlags); \
    4492                     IEM_MC_ARG_CONST(uint32_t,  u32Src, /*=*/ u32Imm,   1); \
    4493                     IEM_MC_CALL_VOID_AIMPL_3(RT_CONCAT3(iemAImpl_,a_InsNm,_u32), pu32Dst, u32Src, pEFlags); \
     4702                    IEM_MC_ARG_EFLAGS(          fEFlagsIn,              0); \
     4703                    IEM_MC_ARG_CONST(uint32_t,  u32Src, /*=*/ u32Imm,   2); \
     4704                    IEM_MC_CALL_AIMPL_3(uint32_t, fEFlagsRet, RT_CONCAT3(iemAImpl_,a_InsNm,_u32), fEFlagsIn, pu32Dst, u32Src); \
    44944705                    IEM_MC_CLEAR_HIGH_GREG_U64(IEM_GET_MODRM_RM(pVCpu, bRm)); \
     4706                    IEM_MC_COMMIT_EFLAGS(fEFlagsRet); \
    44954707                } IEM_MC_NATIVE_ENDIF(); \
    44964708                IEM_MC_ADVANCE_RIP_AND_FINISH(); \
    … …  
    45134725                    IEM_MC_COMMIT_EFLAGS_OPT(uEFlags); \
    45144726                } IEM_MC_NATIVE_ELSE() { \
    4515                     IEM_MC_ARG(uint64_t *,      pu64Dst,                0); \
     4727                    IEM_MC_ARG(uint64_t *,      pu64Dst,                1); \
    45164728                    IEM_MC_REF_GREG_U64(pu64Dst, IEM_GET_MODRM_RM(pVCpu, bRm)); \
    4517                     IEM_MC_ARG(uint32_t *,      pEFlags,                2); \
    4518                     IEM_MC_REF_EFLAGS(pEFlags); \
    4519                     IEM_MC_ARG_CONST(uint64_t,  u64Src, /*=*/ u64Imm,   1); \
    4520                     IEM_MC_CALL_VOID_AIMPL_3(RT_CONCAT3(iemAImpl_,a_InsNm,_u64), pu64Dst, u64Src, pEFlags); \
     4729                    IEM_MC_ARG_EFLAGS(          fEFlagsIn,              0); \
     4730                    IEM_MC_ARG_CONST(uint64_t,  u64Src, /*=*/ u64Imm,   2); \
     4731                    IEM_MC_CALL_AIMPL_3(uint32_t, fEFlagsRet, RT_CONCAT3(iemAImpl_,a_InsNm,_u64), fEFlagsIn, pu64Dst, u64Src); \
     4732                    IEM_MC_COMMIT_EFLAGS(fEFlagsRet); \
    45214733                } IEM_MC_NATIVE_ENDIF(); \
    45224734                IEM_MC_ADVANCE_RIP_AND_FINISH(); \
    … …  
    45454757                    \
    45464758                    IEM_MC_LOCAL(uint8_t,       bUnmapInfo); \
    4547                     IEM_MC_ARG(uint16_t *,      pu16Dst,                0); \
     4759                    IEM_MC_ARG(uint16_t *,      pu16Dst,                1); \
    45484760                    IEM_MC_MEM_MAP_U16_RW(pu16Dst, bUnmapInfo, pVCpu->iem.s.iEffSeg, GCPtrEffDst); \
    45494761                    \
    4550                     IEM_MC_ARG_CONST(uint16_t,  u16Src,  u16Imm,        1); \
    4551                     IEM_MC_ARG_LOCAL_EFLAGS(    pEFlags, EFlags,        2); \
    4552                     IEM_MC_CALL_VOID_AIMPL_3(RT_CONCAT3(iemAImpl_,a_InsNm,_u16), pu16Dst, u16Src, pEFlags); \
     4762                    IEM_MC_ARG_CONST(uint16_t,  u16Src,  u16Imm,        2); \
     4763                    IEM_MC_ARG_EFLAGS(          fEFlagsIn,              0); \
     4764                    IEM_MC_CALL_AIMPL_3(uint32_t, fEFlagsRet, RT_CONCAT3(iemAImpl_,a_InsNm,_u16), fEFlagsIn, pu16Dst, u16Src); \
    45534765                    \
    45544766                    IEM_MC_MEM_COMMIT_AND_UNMAP_RW(bUnmapInfo); \
    4555                     IEM_MC_COMMIT_EFLAGS(EFlags); \
     4767                    IEM_MC_COMMIT_EFLAGS(fEFlagsRet); \
    45564768                    IEM_MC_ADVANCE_RIP_AND_FINISH(); \
    45574769                    IEM_MC_END(); \
    … …  
    45694781                    \
    45704782                    IEM_MC_LOCAL(uint8_t,       bUnmapInfo); \
    4571                     IEM_MC_ARG(uint32_t *,      pu32Dst,                0); \
     4783                    IEM_MC_ARG(uint32_t *,      pu32Dst,                1); \
    45724784                    IEM_MC_MEM_MAP_U32_RW(pu32Dst, bUnmapInfo, pVCpu->iem.s.iEffSeg, GCPtrEffDst); \
    45734785                    \
    4574                     IEM_MC_ARG_CONST(uint32_t,  u32Src,     u32Imm,     1); \
    4575                     IEM_MC_ARG_LOCAL_EFLAGS(    pEFlags,    EFlags,     2); \
    4576                     IEM_MC_CALL_VOID_AIMPL_3(RT_CONCAT3(iemAImpl_,a_InsNm,_u32), pu32Dst, u32Src, pEFlags); \
     4786                    IEM_MC_ARG_CONST(uint32_t,  u32Src,     u32Imm,     2); \
     4787                    IEM_MC_ARG_EFLAGS(          fEFlagsIn,              0); \
     4788                    IEM_MC_CALL_AIMPL_3(uint32_t, fEFlagsRet, RT_CONCAT3(iemAImpl_,a_InsNm,_u32), fEFlagsIn, pu32Dst, u32Src); \
    45774789                    \
    45784790                    IEM_MC_MEM_COMMIT_AND_UNMAP_RW(bUnmapInfo); \
    4579                     IEM_MC_COMMIT_EFLAGS(EFlags); \
     4791                    IEM_MC_COMMIT_EFLAGS(fEFlagsRet); \
    45804792                    IEM_MC_ADVANCE_RIP_AND_FINISH(); \
    45814793                    IEM_MC_END(); \
    … …  
    45944806                    \
    45954807                    IEM_MC_LOCAL(uint8_t,       bUnmapInfo); \
    4596                     IEM_MC_ARG(uint64_t *,      pu64Dst,                0); \
     4808                    IEM_MC_ARG(uint64_t *,      pu64Dst,                1); \
    45974809                    IEM_MC_MEM_MAP_U64_RW(pu64Dst, bUnmapInfo, pVCpu->iem.s.iEffSeg, GCPtrEffDst); \
    45984810                    \
    4599                     IEM_MC_ARG_CONST(uint64_t,  u64Src,  u64Imm,        1); \
    4600                     IEM_MC_ARG_LOCAL_EFLAGS(    pEFlags, EFlags,        2); \
    4601                     IEM_MC_CALL_VOID_AIMPL_3(RT_CONCAT3(iemAImpl_,a_InsNm,_u64), pu64Dst, u64Src, pEFlags); \
     4811                    IEM_MC_ARG_CONST(uint64_t,  u64Src,  u64Imm,        2); \
     4812                    IEM_MC_ARG_EFLAGS(          fEFlagsIn,              0); \
     4813                    IEM_MC_CALL_AIMPL_3(uint32_t, fEFlagsRet, RT_CONCAT3(iemAImpl_,a_InsNm,_u64), fEFlagsIn, pu64Dst, u64Src); \
    46024814                    \
    46034815                    IEM_MC_MEM_COMMIT_AND_UNMAP_RW(bUnmapInfo); \
    4604                     IEM_MC_COMMIT_EFLAGS(EFlags); \
     4816                    IEM_MC_COMMIT_EFLAGS(fEFlagsRet); \
    46054817                    IEM_MC_ADVANCE_RIP_AND_FINISH(); \
    46064818                    IEM_MC_END(); \
    … …  
    46254837                    \
    46264838                    IEM_MC_LOCAL(uint8_t,       bUnmapInfo); \
    4627                     IEM_MC_ARG(uint16_t *,      pu16Dst,                0); \
     4839                    IEM_MC_ARG(uint16_t *,      pu16Dst,                1); \
    46284840                    IEM_MC_MEM_MAP_U16_ATOMIC(pu16Dst, bUnmapInfo, pVCpu->iem.s.iEffSeg, GCPtrEffDst); \
    46294841                    \
    4630                     IEM_MC_ARG_CONST(uint16_t,  u16Src,  u16Imm,        1); \
    4631                     IEM_MC_ARG_LOCAL_EFLAGS(    pEFlags, EFlags,        2); \
    4632                     IEM_MC_CALL_VOID_AIMPL_3(RT_CONCAT3(iemAImpl_,a_InsNm,_u16_locked), pu16Dst, u16Src, pEFlags); \
     4842                    IEM_MC_ARG_CONST(uint16_t,  u16Src,  u16Imm,        2); \
     4843                    IEM_MC_ARG_EFLAGS(          fEFlagsIn,              0); \
     4844                    IEM_MC_CALL_AIMPL_3(uint32_t, fEFlagsRet, RT_CONCAT3(iemAImpl_,a_InsNm,_u16_locked), fEFlagsIn, pu16Dst, u16Src); \
    46334845                    \
    46344846                    IEM_MC_MEM_COMMIT_AND_UNMAP_ATOMIC(bUnmapInfo); \
    4635                     IEM_MC_COMMIT_EFLAGS(EFlags); \
     4847                    IEM_MC_COMMIT_EFLAGS(fEFlagsRet); \
    46364848                    IEM_MC_ADVANCE_RIP_AND_FINISH(); \
    46374849                    IEM_MC_END(); \
    … …  
    46494861                    \
    46504862                    IEM_MC_LOCAL(uint8_t,       bUnmapInfo); \
    4651                     IEM_MC_ARG(uint32_t *,      pu32Dst,                0); \
     4863                    IEM_MC_ARG(uint32_t *,      pu32Dst,                1); \
    46524864                    IEM_MC_MEM_MAP_U32_ATOMIC(pu32Dst, bUnmapInfo, pVCpu->iem.s.iEffSeg, GCPtrEffDst); \
    46534865                    \
    4654                     IEM_MC_ARG_CONST(uint32_t,  u32Src,  u32Imm,        1); \
    4655                     IEM_MC_ARG_LOCAL_EFLAGS(    pEFlags, EFlags,        2); \
    4656                     IEM_MC_CALL_VOID_AIMPL_3(RT_CONCAT3(iemAImpl_,a_InsNm,_u32_locked), pu32Dst, u32Src, pEFlags); \
     4866                    IEM_MC_ARG_CONST(uint32_t,  u32Src,  u32Imm,        2); \
     4867                    IEM_MC_ARG_EFLAGS(          fEFlagsIn,              0); \
     4868                    IEM_MC_CALL_AIMPL_3(uint32_t, fEFlagsRet, RT_CONCAT3(iemAImpl_,a_InsNm,_u32_locked), fEFlagsIn, pu32Dst, u32Src); \
    46574869                    \
    46584870                    IEM_MC_MEM_COMMIT_AND_UNMAP_ATOMIC(bUnmapInfo); \
    4659                     IEM_MC_COMMIT_EFLAGS(EFlags); \
     4871                    IEM_MC_COMMIT_EFLAGS(fEFlagsRet); \
    46604872                    IEM_MC_ADVANCE_RIP_AND_FINISH(); \
    46614873                    IEM_MC_END(); \
    … …  
    46734885                    \
    46744886                    IEM_MC_LOCAL(uint8_t,       bUnmapInfo); \
    4675                     IEM_MC_ARG(uint64_t *,      pu64Dst,                0); \
     4887                    IEM_MC_ARG(uint64_t *,      pu64Dst,                1); \
    46764888                    IEM_MC_MEM_MAP_U64_ATOMIC(pu64Dst, bUnmapInfo, pVCpu->iem.s.iEffSeg, GCPtrEffDst); \
    46774889                    \
    4678                     IEM_MC_ARG_CONST(uint64_t,  u64Src,  u64Imm,        1); \
    4679                     IEM_MC_ARG_LOCAL_EFLAGS(    pEFlags, EFlags,        2); \
    4680                     IEM_MC_CALL_VOID_AIMPL_3(RT_CONCAT3(iemAImpl_,a_InsNm,_u64_locked), pu64Dst, u64Src, pEFlags); \
     4890                    IEM_MC_ARG_CONST(uint64_t,  u64Src,  u64Imm,        2); \
     4891                    IEM_MC_ARG_EFLAGS(          fEFlagsIn,              0); \
     4892                    IEM_MC_CALL_AIMPL_3(uint32_t, fEFlagsRet, RT_CONCAT3(iemAImpl_,a_InsNm,_u64_locked), fEFlagsIn, pu64Dst, u64Src); \
    46814893                    \
    46824894                    IEM_MC_MEM_COMMIT_AND_UNMAP_ATOMIC(bUnmapInfo); \
    4683                     IEM_MC_COMMIT_EFLAGS(EFlags); \
     4895                    IEM_MC_COMMIT_EFLAGS(fEFlagsRet); \
    46844896                    IEM_MC_ADVANCE_RIP_AND_FINISH(); \
    46854897                    IEM_MC_END(); \
    … …  
    47134925                    IEM_MC_COMMIT_EFLAGS_OPT(uEFlags); \
    47144926                } IEM_MC_NATIVE_ELSE() { \
    4715                     IEM_MC_ARG(uint16_t const *,pu16Dst,                0); \
     4927                    IEM_MC_ARG(uint16_t const *,pu16Dst,                1); \
    47164928                    IEM_MC_REF_GREG_U16_CONST(pu16Dst, IEM_GET_MODRM_RM(pVCpu, bRm)); \
    4717                     IEM_MC_ARG(uint32_t *,      pEFlags,                2); \
    4718                     IEM_MC_REF_EFLAGS(pEFlags); \
    4719                     IEM_MC_ARG_CONST(uint16_t,  u16Src, /*=*/ u16Imm,   1); \
    4720                     IEM_MC_CALL_VOID_AIMPL_3(RT_CONCAT3(iemAImpl_,a_InsNm,_u16), pu16Dst, u16Src, pEFlags); \
     4929                    IEM_MC_ARG_EFLAGS(          fEFlagsIn,              0); \
     4930                    IEM_MC_ARG_CONST(uint16_t,  u16Src, /*=*/ u16Imm,   2); \
     4931                    IEM_MC_CALL_AIMPL_3(uint32_t, fEFlagsRet, RT_CONCAT3(iemAImpl_,a_InsNm,_u16), fEFlagsIn, pu16Dst, u16Src); \
     4932                    IEM_MC_COMMIT_EFLAGS(fEFlagsRet); \
    47214933                } IEM_MC_NATIVE_ENDIF(); \
    47224934                IEM_MC_ADVANCE_RIP_AND_FINISH(); \
    … …  
    47384950                    IEM_MC_COMMIT_EFLAGS_OPT(uEFlags); \
    47394951                } IEM_MC_NATIVE_ELSE() { \
    4740                     IEM_MC_ARG(uint32_t const *,pu32Dst,                0); \
     4952                    IEM_MC_ARG(uint32_t const *,pu32Dst,                1); \
    47414953                    IEM_MC_REF_GREG_U32_CONST (pu32Dst, IEM_GET_MODRM_RM(pVCpu, bRm)); \
    4742                     IEM_MC_ARG(uint32_t *,      pEFlags,                2); \
    4743                     IEM_MC_REF_EFLAGS(pEFlags); \
    4744                     IEM_MC_ARG_CONST(uint32_t,  u32Src, /*=*/ u32Imm,   1); \
    4745                     IEM_MC_CALL_VOID_AIMPL_3(RT_CONCAT3(iemAImpl_,a_InsNm,_u32), pu32Dst, u32Src, pEFlags); \
     4954                    IEM_MC_ARG_EFLAGS(          fEFlagsIn,              0); \
     4955                    IEM_MC_ARG_CONST(uint32_t,  u32Src, /*=*/ u32Imm,   2); \
     4956                    IEM_MC_CALL_AIMPL_3(uint32_t, fEFlagsRet, RT_CONCAT3(iemAImpl_,a_InsNm,_u32), fEFlagsIn, pu32Dst, u32Src); \
     4957                    IEM_MC_COMMIT_EFLAGS(fEFlagsRet); \
    47464958                } IEM_MC_NATIVE_ENDIF(); \
    47474959                IEM_MC_ADVANCE_RIP_AND_FINISH(); \
    … …  
    47634975                    IEM_MC_COMMIT_EFLAGS_OPT(uEFlags); \
    47644976                } IEM_MC_NATIVE_ELSE() { \
    4765                     IEM_MC_ARG(uint64_t const *,pu64Dst,                0); \
     4977                    IEM_MC_ARG(uint64_t const *,pu64Dst,                1); \
    47664978                    IEM_MC_REF_GREG_U64_CONST(pu64Dst, IEM_GET_MODRM_RM(pVCpu, bRm)); \
    4767                     IEM_MC_ARG(uint32_t *,      pEFlags,                2); \
    4768                     IEM_MC_REF_EFLAGS(pEFlags); \
    4769                     IEM_MC_ARG_CONST(uint64_t,  u64Src, /*=*/ u64Imm,   1); \
    4770                     IEM_MC_CALL_VOID_AIMPL_3(RT_CONCAT3(iemAImpl_,a_InsNm,_u64), pu64Dst, u64Src, pEFlags); \
     4979                    IEM_MC_ARG_EFLAGS(          fEFlagsIn,              0); \
     4980                    IEM_MC_ARG_CONST(uint64_t,  u64Src, /*=*/ u64Imm,   2); \
     4981                    IEM_MC_CALL_AIMPL_3(uint32_t, fEFlagsRet, RT_CONCAT3(iemAImpl_,a_InsNm,_u64), fEFlagsIn, pu64Dst, u64Src); \
     4982                    IEM_MC_COMMIT_EFLAGS(fEFlagsRet); \
    47714983                } IEM_MC_NATIVE_ENDIF(); \
    47724984                IEM_MC_ADVANCE_RIP_AND_FINISH(); \
    … …  
    48005012                    } IEM_MC_NATIVE_ELSE() { \
    48015013                        IEM_MC_LOCAL(uint8_t,        bUnmapInfo); \
    4802                         IEM_MC_ARG(uint16_t const *, pu16Dst,               0); \
     5014                        IEM_MC_ARG(uint16_t const *, pu16Dst,               1); \
    48035015                        IEM_MC_MEM_MAP_U16_RO(pu16Dst, bUnmapInfo, pVCpu->iem.s.iEffSeg, GCPtrEffDst); \
    4804                         IEM_MC_ARG_LOCAL_EFLAGS(     pEFlags, EFlags,       2); \
    4805                         IEM_MC_ARG_CONST(uint16_t,   u16Src,  u16Imm,       1); \
    4806                         IEM_MC_CALL_VOID_AIMPL_3(RT_CONCAT3(iemAImpl_,a_InsNm,_u16), pu16Dst, u16Src, pEFlags); \
     5016                        IEM_MC_ARG_EFLAGS(           fEFlagsIn,             0); \
     5017                        IEM_MC_ARG_CONST(uint16_t,   u16Src,  u16Imm,       2); \
     5018                        IEM_MC_CALL_AIMPL_3(uint32_t, fEFlagsRet, RT_CONCAT3(iemAImpl_,a_InsNm,_u16), fEFlagsIn, pu16Dst, u16Src); \
    48075019                        IEM_MC_MEM_COMMIT_AND_UNMAP_RO(bUnmapInfo); \
    4808                         IEM_MC_COMMIT_EFLAGS(EFlags); \
     5020                        IEM_MC_COMMIT_EFLAGS(fEFlagsRet); \
    48095021                    } IEM_MC_NATIVE_ENDIF(); \
    48105022                    IEM_MC_ADVANCE_RIP_AND_FINISH(); \
    … …  
    48285040                    } IEM_MC_NATIVE_ELSE() { \
    48295041                        IEM_MC_LOCAL(uint8_t,        bUnmapInfo); \
    4830                         IEM_MC_ARG(uint32_t const *, pu32Dst,               0); \
     5042                        IEM_MC_ARG(uint32_t const *, pu32Dst,               1); \
    48315043                        IEM_MC_MEM_MAP_U32_RO(pu32Dst, bUnmapInfo, pVCpu->iem.s.iEffSeg, GCPtrEffDst); \
    4832                         IEM_MC_ARG_LOCAL_EFLAGS(     pEFlags, EFlags,       2); \
    4833                         IEM_MC_ARG_CONST(uint32_t,   u32Src,  u32Imm,       1); \
    4834                         IEM_MC_CALL_VOID_AIMPL_3(RT_CONCAT3(iemAImpl_,a_InsNm,_u32), pu32Dst, u32Src, pEFlags); \
     5044                        IEM_MC_ARG_EFLAGS(           fEFlagsIn,             0); \
     5045                        IEM_MC_ARG_CONST(uint32_t,   u32Src,  u32Imm,       2); \
     5046                        IEM_MC_CALL_AIMPL_3(uint32_t, fEFlagsRet, RT_CONCAT3(iemAImpl_,a_InsNm,_u32), fEFlagsIn, pu32Dst, u32Src); \
    48355047                        IEM_MC_MEM_COMMIT_AND_UNMAP_RO(bUnmapInfo); \
    4836                         IEM_MC_COMMIT_EFLAGS(EFlags); \
     5048                        IEM_MC_COMMIT_EFLAGS(fEFlagsRet); \
    48375049                    } IEM_MC_NATIVE_ENDIF(); \
    48385050                    IEM_MC_ADVANCE_RIP_AND_FINISH(); \
    … …  
    48565068                    } IEM_MC_NATIVE_ELSE() { \
    48575069                        IEM_MC_LOCAL(uint8_t,        bUnmapInfo); \
    4858                         IEM_MC_ARG(uint64_t const *, pu64Dst,               0); \
     5070                        IEM_MC_ARG(uint64_t const *, pu64Dst,               1); \
    48595071                        IEM_MC_MEM_MAP_U64_RO(pu64Dst, bUnmapInfo, pVCpu->iem.s.iEffSeg, GCPtrEffDst); \
    4860                         IEM_MC_ARG_LOCAL_EFLAGS(     pEFlags, EFlags,       2); \
    4861                         IEM_MC_ARG_CONST(uint64_t,   u64Src,  u64Imm,       1); \
    4862                         IEM_MC_CALL_VOID_AIMPL_3(RT_CONCAT3(iemAImpl_,a_InsNm,_u64), pu64Dst, u64Src, pEFlags); \
     5072                        IEM_MC_ARG_EFLAGS(           fEFlagsIn,             0); \
     5073                        IEM_MC_ARG_CONST(uint64_t,   u64Src,  u64Imm,       2); \
     5074                        IEM_MC_CALL_AIMPL_3(uint32_t, fEFlagsRet, RT_CONCAT3(iemAImpl_,a_InsNm,_u64), fEFlagsIn, pu64Dst, u64Src); \
    48635075                        IEM_MC_MEM_COMMIT_AND_UNMAP_RO(bUnmapInfo); \
    4864                         IEM_MC_COMMIT_EFLAGS(EFlags); \
     5076                        IEM_MC_COMMIT_EFLAGS(fEFlagsRet); \
    48655077                    } IEM_MC_NATIVE_ENDIF(); \
    48665078                    IEM_MC_ADVANCE_RIP_AND_FINISH(); \
    … …  
    50355247                    IEM_MC_COMMIT_EFLAGS_OPT(uEFlags); \
    50365248                } IEM_MC_NATIVE_ELSE() { \
    5037                     IEM_MC_ARG(uint16_t *,      pu16Dst,                                        0); \
     5249                    IEM_MC_ARG(uint16_t *,      pu16Dst,                                        1); \
    50385250                    IEM_MC_REF_GREG_U16(pu16Dst, IEM_GET_MODRM_RM(pVCpu, bRm)); \
    5039                     IEM_MC_ARG(uint32_t *,      pEFlags,                                        2); \
    5040                     IEM_MC_REF_EFLAGS(pEFlags); \
    5041                     IEM_MC_ARG_CONST(uint16_t,  u16Src, /*=*/ (uint16_t)(int16_t)(int8_t)u8Imm, 1); \
    5042                     IEM_MC_CALL_VOID_AIMPL_3(RT_CONCAT3(iemAImpl_,a_InsNm,_u16), pu16Dst, u16Src, pEFlags); \
     5251                    IEM_MC_ARG_EFLAGS(          fEFlagsIn,                                      0); \
     5252                    IEM_MC_ARG_CONST(uint16_t,  u16Src, /*=*/ (uint16_t)(int16_t)(int8_t)u8Imm, 2); \
     5253                    IEM_MC_CALL_AIMPL_3(uint32_t, fEFlagsRet, RT_CONCAT3(iemAImpl_,a_InsNm,_u16), fEFlagsIn, pu16Dst, u16Src); \
     5254                    IEM_MC_COMMIT_EFLAGS(fEFlagsRet); \
    50435255                } IEM_MC_NATIVE_ENDIF(); \
    50445256                IEM_MC_ADVANCE_RIP_AND_FINISH(); \
    … …  
    50585270                    IEM_MC_COMMIT_EFLAGS_OPT(uEFlags); \
    50595271                } IEM_MC_NATIVE_ELSE() { \
    5060                     IEM_MC_ARG(uint32_t *,      pu32Dst,                                        0); \
     5272                    IEM_MC_ARG(uint32_t *,      pu32Dst,                                        1); \
    50615273                    IEM_MC_REF_GREG_U32(pu32Dst, IEM_GET_MODRM_RM(pVCpu, bRm)); \
    5062                     IEM_MC_ARG(uint32_t *,      pEFlags,                                        2); \
    5063                     IEM_MC_REF_EFLAGS(pEFlags); \
    5064                     IEM_MC_ARG_CONST(uint32_t,  u32Src, /*=*/ (uint32_t)(int32_t)(int8_t)u8Imm, 1); \
    5065                     IEM_MC_CALL_VOID_AIMPL_3(RT_CONCAT3(iemAImpl_,a_InsNm,_u32), pu32Dst, u32Src, pEFlags); \
     5274                    IEM_MC_ARG_EFLAGS(          fEFlagsIn,                                      0); \
     5275                    IEM_MC_ARG_CONST(uint32_t,  u32Src, /*=*/ (uint32_t)(int32_t)(int8_t)u8Imm, 2); \
     5276                    IEM_MC_CALL_AIMPL_3(uint32_t, fEFlagsRet, RT_CONCAT3(iemAImpl_,a_InsNm,_u32), fEFlagsIn, pu32Dst, u32Src); \
    50665277                    IEM_MC_CLEAR_HIGH_GREG_U64(IEM_GET_MODRM_RM(pVCpu, bRm)); \
     5278                    IEM_MC_COMMIT_EFLAGS(fEFlagsRet); \
    50675279                } IEM_MC_NATIVE_ENDIF(); \
    50685280                IEM_MC_ADVANCE_RIP_AND_FINISH(); \
    … …  
    50825294                    IEM_MC_COMMIT_EFLAGS_OPT(uEFlags); \
    50835295                } IEM_MC_NATIVE_ELSE() { \
    5084                     IEM_MC_ARG(uint64_t *,      pu64Dst,                                        0); \
     5296                    IEM_MC_ARG(uint64_t *,      pu64Dst,                                        1); \
    50855297                    IEM_MC_REF_GREG_U64(pu64Dst, IEM_GET_MODRM_RM(pVCpu, bRm)); \
    5086                     IEM_MC_ARG(uint32_t *,      pEFlags,                                        2); \
    5087                     IEM_MC_REF_EFLAGS(pEFlags); \
    5088                     IEM_MC_ARG_CONST(uint64_t,  u64Src, /*=*/ (uint64_t)(int64_t)(int8_t)u8Imm, 1); \
    5089                     IEM_MC_CALL_VOID_AIMPL_3(RT_CONCAT3(iemAImpl_,a_InsNm,_u64), pu64Dst, u64Src, pEFlags); \
     5298                    IEM_MC_ARG_EFLAGS(          fEFlagsIn,                                      0); \
     5299                    IEM_MC_ARG_CONST(uint64_t,  u64Src, /*=*/ (uint64_t)(int64_t)(int8_t)u8Imm, 2); \
     5300                    IEM_MC_CALL_AIMPL_3(uint32_t, fEFlagsRet, RT_CONCAT3(iemAImpl_,a_InsNm,_u64), fEFlagsIn, pu64Dst, u64Src); \
     5301                    IEM_MC_COMMIT_EFLAGS(fEFlagsRet); \
    50905302                } IEM_MC_NATIVE_ENDIF(); \
    50915303                IEM_MC_ADVANCE_RIP_AND_FINISH(); \
    … …  
    51145326                    \
    51155327                    IEM_MC_LOCAL(uint8_t,       bUnmapInfo); \
    5116                     IEM_MC_ARG(uint16_t *,      pu16Dst,                                    0); \
     5328                    IEM_MC_ARG(uint16_t *,      pu16Dst,                                    1); \
    51175329                    IEM_MC_MEM_MAP_U16_RW(pu16Dst, bUnmapInfo, pVCpu->iem.s.iEffSeg, GCPtrEffDst); \
    51185330                    \
    5119                     IEM_MC_ARG_CONST(uint16_t,  u16Src,  (uint16_t)(int16_t)(int8_t)u8Imm,  1); \
    5120                     IEM_MC_ARG_LOCAL_EFLAGS(    pEFlags, EFlags,                            2); \
    5121                     IEM_MC_CALL_VOID_AIMPL_3(RT_CONCAT3(iemAImpl_,a_InsNm,_u16), pu16Dst, u16Src, pEFlags); \
     5331                    IEM_MC_ARG_EFLAGS(          fEFlagsIn,                                  0); \
     5332                    IEM_MC_ARG_CONST(uint16_t,  u16Src,  (uint16_t)(int16_t)(int8_t)u8Imm,  2); \
     5333                    IEM_MC_CALL_AIMPL_3(uint32_t, fEFlagsRet, RT_CONCAT3(iemAImpl_,a_InsNm,_u16), fEFlagsIn, pu16Dst, u16Src); \
    51225334                    \
    51235335                    IEM_MC_MEM_COMMIT_AND_UNMAP_RW(bUnmapInfo); \
    5124                     IEM_MC_COMMIT_EFLAGS(EFlags); \
     5336                    IEM_MC_COMMIT_EFLAGS(fEFlagsRet); \
    51255337                    IEM_MC_ADVANCE_RIP_AND_FINISH(); \
    51265338                    IEM_MC_END(); \
    … …  
    51365348                    \
    51375349                    IEM_MC_LOCAL(uint8_t,       bUnmapInfo); \
    5138                     IEM_MC_ARG(uint32_t *,      pu32Dst,                                    0); \
     5350                    IEM_MC_ARG(uint32_t *,      pu32Dst,                                    1); \
    51395351                    IEM_MC_MEM_MAP_U32_RW(pu32Dst, bUnmapInfo, pVCpu->iem.s.iEffSeg, GCPtrEffDst); \
    51405352                    \
    5141                     IEM_MC_ARG_CONST(uint32_t,  u32Src,  (uint32_t)(int32_t)(int8_t)u8Imm,  1); \
    5142                     IEM_MC_ARG_LOCAL_EFLAGS(    pEFlags, EFlags,                            2); \
    5143                     IEM_MC_CALL_VOID_AIMPL_3(RT_CONCAT3(iemAImpl_,a_InsNm,_u32), pu32Dst, u32Src, pEFlags); \
     5353                    IEM_MC_ARG_EFLAGS(          fEFlagsIn,                                  0); \
     5354                    IEM_MC_ARG_CONST(uint32_t,  u32Src,  (uint32_t)(int32_t)(int8_t)u8Imm,  2); \
     5355                    IEM_MC_CALL_AIMPL_3(uint32_t, fEFlagsRet, RT_CONCAT3(iemAImpl_,a_InsNm,_u32), fEFlagsIn, pu32Dst, u32Src); \
    51445356                    \
    51455357                    IEM_MC_MEM_COMMIT_AND_UNMAP_RW(bUnmapInfo); \
    5146                     IEM_MC_COMMIT_EFLAGS(EFlags); \
     5358                    IEM_MC_COMMIT_EFLAGS(fEFlagsRet); \
    51475359                    IEM_MC_ADVANCE_RIP_AND_FINISH(); \
    51485360                    IEM_MC_END(); \
    … …  
    51585370                    \
    51595371                    IEM_MC_LOCAL(uint8_t,       bUnmapInfo); \
    5160                     IEM_MC_ARG(uint64_t *,      pu64Dst,                                    0); \
     5372                    IEM_MC_ARG(uint64_t *,      pu64Dst,                                    1); \
    51615373                    IEM_MC_MEM_MAP_U64_RW(pu64Dst, bUnmapInfo, pVCpu->iem.s.iEffSeg, GCPtrEffDst); \
    51625374                    \
    5163                     IEM_MC_ARG_CONST(uint64_t,  u64Src,  (uint64_t)(int64_t)(int8_t)u8Imm,  1); \
    5164                     IEM_MC_ARG_LOCAL_EFLAGS(    pEFlags, EFlags,                            2); \
    5165                     IEM_MC_CALL_VOID_AIMPL_3(RT_CONCAT3(iemAImpl_,a_InsNm,_u64), pu64Dst, u64Src, pEFlags); \
     5375                    IEM_MC_ARG_EFLAGS(          fEFlagsIn,                                  0); \
     5376                    IEM_MC_ARG_CONST(uint64_t,  u64Src,  (uint64_t)(int64_t)(int8_t)u8Imm,  2); \
     5377                    IEM_MC_CALL_AIMPL_3(uint32_t, fEFlagsRet, RT_CONCAT3(iemAImpl_,a_InsNm,_u64), fEFlagsIn, pu64Dst, u64Src); \
    51665378                    \
    51675379                    IEM_MC_MEM_COMMIT_AND_UNMAP_RW(bUnmapInfo); \
    5168                     IEM_MC_COMMIT_EFLAGS(EFlags); \
     5380                    IEM_MC_COMMIT_EFLAGS(fEFlagsRet); \
    51695381                    IEM_MC_ADVANCE_RIP_AND_FINISH(); \
    51705382                    IEM_MC_END(); \
    … …  
    51875399                    \
    51885400                    IEM_MC_LOCAL(uint8_t,       bUnmapInfo); \
    5189                     IEM_MC_ARG(uint16_t *,      pu16Dst,                                    0); \
     5401                    IEM_MC_ARG(uint16_t *,      pu16Dst,                                    1); \
    51905402                    IEM_MC_MEM_MAP_U16_ATOMIC(pu16Dst, bUnmapInfo, pVCpu->iem.s.iEffSeg, GCPtrEffDst); \
    51915403                    \
    5192                     IEM_MC_ARG_CONST(uint16_t,  u16Src,  (uint16_t)(int16_t)(int8_t)u8Imm,  1); \
    5193                     IEM_MC_ARG_LOCAL_EFLAGS(    pEFlags, EFlags,                            2); \
    5194                     IEM_MC_CALL_VOID_AIMPL_3(RT_CONCAT3(iemAImpl_,a_InsNm,_u16_locked), pu16Dst, u16Src, pEFlags); \
     5404                    IEM_MC_ARG_EFLAGS(          fEFlagsIn,                                  0); \
     5405                    IEM_MC_ARG_CONST(uint16_t,  u16Src,  (uint16_t)(int16_t)(int8_t)u8Imm,  2); \
     5406                    IEM_MC_CALL_AIMPL_3(uint32_t, fEFlagsRet, RT_CONCAT3(iemAImpl_,a_InsNm,_u16_locked), fEFlagsIn, pu16Dst, u16Src); \
    51955407                    \
    51965408                    IEM_MC_MEM_COMMIT_AND_UNMAP_ATOMIC(bUnmapInfo); \
    5197                     IEM_MC_COMMIT_EFLAGS(EFlags); \
     5409                    IEM_MC_COMMIT_EFLAGS(fEFlagsRet); \
    51985410                    IEM_MC_ADVANCE_RIP_AND_FINISH(); \
    51995411                    IEM_MC_END(); \
    … …  
    52095421                    \
    52105422                    IEM_MC_LOCAL(uint8_t,       bUnmapInfo); \
    5211                     IEM_MC_ARG(uint32_t *,      pu32Dst,                                    0); \
     5423                    IEM_MC_ARG(uint32_t *,      pu32Dst,                                    1); \
    52125424                    IEM_MC_MEM_MAP_U32_ATOMIC(pu32Dst, bUnmapInfo, pVCpu->iem.s.iEffSeg, GCPtrEffDst); \
    52135425                    \
    5214                     IEM_MC_ARG_CONST(uint32_t,  u32Src,  (uint32_t)(int32_t)(int8_t)u8Imm,  1); \
    5215                     IEM_MC_ARG_LOCAL_EFLAGS(    pEFlags, EFlags,                            2); \
    5216                     IEM_MC_CALL_VOID_AIMPL_3(RT_CONCAT3(iemAImpl_,a_InsNm,_u32_locked), pu32Dst, u32Src, pEFlags); \
     5426                    IEM_MC_ARG_EFLAGS(          fEFlagsIn,                                  0); \
     5427                    IEM_MC_ARG_CONST(uint32_t,  u32Src,  (uint32_t)(int32_t)(int8_t)u8Imm,  2); \
     5428                    IEM_MC_CALL_AIMPL_3(uint32_t, fEFlagsRet, RT_CONCAT3(iemAImpl_,a_InsNm,_u32_locked), fEFlagsIn, pu32Dst, u32Src); \
    52175429                    \
    52185430                    IEM_MC_MEM_COMMIT_AND_UNMAP_ATOMIC(bUnmapInfo); \
    5219                     IEM_MC_COMMIT_EFLAGS(EFlags); \
     5431                    IEM_MC_COMMIT_EFLAGS(fEFlagsRet); \
    52205432                    IEM_MC_ADVANCE_RIP_AND_FINISH(); \
    52215433                    IEM_MC_END(); \
    … …  
    52315443                    \
    52325444                    IEM_MC_LOCAL(uint8_t,       bUnmapInfo); \
    5233                     IEM_MC_ARG(uint64_t *,      pu64Dst,                                    0); \
     5445                    IEM_MC_ARG(uint64_t *,      pu64Dst,                                    1); \
    52345446                    IEM_MC_MEM_MAP_U64_ATOMIC(pu64Dst, bUnmapInfo, pVCpu->iem.s.iEffSeg, GCPtrEffDst); \
    52355447                    \
    5236                     IEM_MC_ARG_CONST(uint64_t,  u64Src, (uint64_t)(int64_t)(int8_t)u8Imm,   1); \
    5237                     IEM_MC_ARG_LOCAL_EFLAGS(    pEFlags, EFlags,                            2); \
    5238                     IEM_MC_CALL_VOID_AIMPL_3(RT_CONCAT3(iemAImpl_,a_InsNm,_u64_locked), pu64Dst, u64Src, pEFlags); \
     5448                    IEM_MC_ARG_EFLAGS(          fEFlagsIn,                                  0); \
     5449                    IEM_MC_ARG_CONST(uint64_t,  u64Src, (uint64_t)(int64_t)(int8_t)u8Imm,   2); \
     5450                    IEM_MC_CALL_AIMPL_3(uint32_t, fEFlagsRet, RT_CONCAT3(iemAImpl_,a_InsNm,_u64_locked), fEFlagsIn, pu64Dst, u64Src); \
    52395451                    \
    52405452                    IEM_MC_MEM_COMMIT_AND_UNMAP_ATOMIC(bUnmapInfo); \
    5241                     IEM_MC_COMMIT_EFLAGS(EFlags); \
     5453                    IEM_MC_COMMIT_EFLAGS(fEFlagsRet); \
    52425454                    IEM_MC_ADVANCE_RIP_AND_FINISH(); \
    52435455                    IEM_MC_END(); \
    … …  
    52665478                    IEM_MC_LOCAL(uint16_t,      u16Dst); \
    52675479                    IEM_MC_FETCH_GREG_U16(u16Dst, IEM_GET_MODRM_RM(pVCpu, bRm)); \
    5268                     IEM_MC_LOCAL(uint32_t,      uEFlags); \
    5269                     IEM_MC_FETCH_EFLAGS(uEFlags); \
     5480                    IEM_MC_LOCAL_EFLAGS(        uEFlags); \
    52705481                    IEM_MC_NATIVE_EMIT_5(RT_CONCAT3(iemNativeEmit_,a_InsNm,_r_i_efl), u16Dst, (uint16_t)(int16_t)(int8_t)u8Imm, uEFlags, 16, 8); \
    52715482                    IEM_MC_COMMIT_EFLAGS_OPT(uEFlags); \
    52725483                } IEM_MC_NATIVE_ELSE() { \
    5273                     IEM_MC_ARG(uint16_t const *,    pu16Dst,                                        0); \
     5484                    IEM_MC_ARG(uint16_t const *,pu16Dst,                                        1); \
    52745485                    IEM_MC_REF_GREG_U16_CONST(pu16Dst, IEM_GET_MODRM_RM(pVCpu, bRm)); \
    5275                     IEM_MC_ARG(uint32_t *,          pEFlags,                                        2); \
    5276                     IEM_MC_ARG_CONST(uint16_t,      u16Src, /*=*/ (uint16_t)(int16_t)(int8_t)u8Imm, 1); \
    5277                     IEM_MC_REF_EFLAGS(pEFlags); \
    5278                     IEM_MC_CALL_VOID_AIMPL_3(RT_CONCAT3(iemAImpl_,a_InsNm,_u16), pu16Dst, u16Src, pEFlags); \
     5486                    IEM_MC_ARG_EFLAGS(          fEFlagsIn,                                      0); \
     5487                    IEM_MC_ARG_CONST(uint16_t,  u16Src, /*=*/ (uint16_t)(int16_t)(int8_t)u8Imm, 2); \
     5488                    IEM_MC_CALL_AIMPL_3(uint32_t, fEFlagsRet, RT_CONCAT3(iemAImpl_,a_InsNm,_u16), fEFlagsIn, pu16Dst, u16Src); \
     5489                    IEM_MC_COMMIT_EFLAGS(fEFlagsRet); \
    52795490                } IEM_MC_NATIVE_ENDIF(); \
    52805491                IEM_MC_ADVANCE_RIP_AND_FINISH(); \
    … …  
    52885499                    IEM_MC_LOCAL(uint32_t,      u32Dst); \
    52895500                    IEM_MC_FETCH_GREG_U32(u32Dst, IEM_GET_MODRM_RM(pVCpu, bRm)); \
    5290                     IEM_MC_LOCAL(uint32_t,      uEFlags); \
    5291                     IEM_MC_FETCH_EFLAGS(uEFlags); \
     5501                    IEM_MC_LOCAL_EFLAGS(        uEFlags); \
    52925502                    IEM_MC_NATIVE_EMIT_5(RT_CONCAT3(iemNativeEmit_,a_InsNm,_r_i_efl), u32Dst, (uint32_t)(int32_t)(int8_t)u8Imm, uEFlags, 32, 8); \
    52935503                    IEM_MC_COMMIT_EFLAGS_OPT(uEFlags); \
    52945504                } IEM_MC_NATIVE_ELSE() { \
    5295                     IEM_MC_ARG(uint32_t const *,    pu32Dst,                                        0); \
     5505                    IEM_MC_ARG(uint32_t const *,pu32Dst,                                        1); \
    52965506                    IEM_MC_REF_GREG_U32_CONST(pu32Dst, IEM_GET_MODRM_RM(pVCpu, bRm)); \
    5297                     IEM_MC_ARG(uint32_t *,          pEFlags,                                        2); \
    5298                     IEM_MC_REF_EFLAGS(pEFlags); \
    5299                     IEM_MC_ARG_CONST(uint32_t,      u32Src, /*=*/ (uint32_t)(int32_t)(int8_t)u8Imm, 1); \
    5300                     IEM_MC_CALL_VOID_AIMPL_3(RT_CONCAT3(iemAImpl_,a_InsNm,_u32), pu32Dst, u32Src, pEFlags); \
     5507                    IEM_MC_ARG_EFLAGS(          fEFlagsIn,                                      0); \
     5508                    IEM_MC_ARG_CONST(uint32_t,  u32Src, /*=*/ (uint32_t)(int32_t)(int8_t)u8Imm, 2); \
     5509                    IEM_MC_CALL_AIMPL_3(uint32_t, fEFlagsRet, RT_CONCAT3(iemAImpl_,a_InsNm,_u32), fEFlagsIn, pu32Dst, u32Src); \
     5510                    IEM_MC_COMMIT_EFLAGS(fEFlagsRet); \
    53015511                } IEM_MC_NATIVE_ENDIF(); \
    53025512                IEM_MC_ADVANCE_RIP_AND_FINISH(); \
    … …  
    53105520                    IEM_MC_LOCAL(uint64_t,      u64Dst); \
    53115521                    IEM_MC_FETCH_GREG_U64(u64Dst, IEM_GET_MODRM_RM(pVCpu, bRm)); \
    5312                     IEM_MC_LOCAL(uint32_t,      uEFlags); \
    5313                     IEM_MC_FETCH_EFLAGS(uEFlags); \
     5522                    IEM_MC_LOCAL_EFLAGS(        uEFlags); \
    53145523                    IEM_MC_NATIVE_EMIT_5(RT_CONCAT3(iemNativeEmit_,a_InsNm,_r_i_efl), u64Dst, (uint64_t)(int64_t)(int8_t)u8Imm, uEFlags, 64, 8); \
    53155524                    IEM_MC_COMMIT_EFLAGS_OPT(uEFlags); \
    53165525                } IEM_MC_NATIVE_ELSE() { \
    5317                     IEM_MC_ARG(uint64_t const *,    pu64Dst,                                        0); \
     5526                    IEM_MC_ARG(uint64_t const *,pu64Dst,                                        1); \
    53185527                    IEM_MC_REF_GREG_U64_CONST(pu64Dst, IEM_GET_MODRM_RM(pVCpu, bRm)); \
    5319                     IEM_MC_ARG(uint32_t *,          pEFlags,                                        2); \
    5320                     IEM_MC_REF_EFLAGS(pEFlags); \
    5321                     IEM_MC_ARG_CONST(uint64_t,      u64Src, /*=*/ (uint64_t)(int64_t)(int8_t)u8Imm, 1); \
    5322                     IEM_MC_CALL_VOID_AIMPL_3(RT_CONCAT3(iemAImpl_,a_InsNm,_u64), pu64Dst, u64Src, pEFlags); \
     5528                    IEM_MC_ARG_EFLAGS(          fEFlagsIn,                                      0); \
     5529                    IEM_MC_ARG_CONST(uint64_t,  u64Src, /*=*/ (uint64_t)(int64_t)(int8_t)u8Imm, 2); \
     5530                    IEM_MC_CALL_AIMPL_3(uint32_t, fEFlagsRet, RT_CONCAT3(iemAImpl_,a_InsNm,_u64), fEFlagsIn, pu64Dst, u64Src); \
     5531                    IEM_MC_COMMIT_EFLAGS(fEFlagsRet); \
    53235532                } IEM_MC_NATIVE_ENDIF(); \
    53245533                IEM_MC_ADVANCE_RIP_AND_FINISH(); \
    … …  
    53525561                    } IEM_MC_NATIVE_ELSE() { \
    53535562                        IEM_MC_LOCAL(uint8_t,        bUnmapInfo); \
    5354                         IEM_MC_ARG(uint16_t const *, pu16Dst,                                   0); \
     5563                        IEM_MC_ARG(uint16_t const *, pu16Dst,                                   1); \
    53555564                        IEM_MC_MEM_MAP_U16_RO(pu16Dst, bUnmapInfo, pVCpu->iem.s.iEffSeg, GCPtrEffDst); \
    5356                         IEM_MC_ARG_LOCAL_EFLAGS(     pEFlags, EFlags,                           2); \
    5357                         IEM_MC_ARG_CONST(uint16_t,   u16Src, (uint16_t)(int16_t)(int8_t)u8Imm,  1); \
    5358                         IEM_MC_CALL_VOID_AIMPL_3(RT_CONCAT3(iemAImpl_,a_InsNm,_u16), pu16Dst, u16Src, pEFlags); \
     5565                        IEM_MC_ARG_EFLAGS(           fEFlagsIn,                                 0); \
     5566                        IEM_MC_ARG_CONST(uint16_t,   u16Src, (uint16_t)(int16_t)(int8_t)u8Imm,  2); \
     5567                        IEM_MC_CALL_AIMPL_3(uint32_t, fEFlagsRet, RT_CONCAT3(iemAImpl_,a_InsNm,_u16), fEFlagsIn, pu16Dst, u16Src); \
    53595568                        IEM_MC_MEM_COMMIT_AND_UNMAP_RO(bUnmapInfo); \
    5360                         IEM_MC_COMMIT_EFLAGS(EFlags); \
     5569                        IEM_MC_COMMIT_EFLAGS(fEFlagsRet); \
    53615570                    } IEM_MC_NATIVE_ENDIF(); \
    53625571                    IEM_MC_ADVANCE_RIP_AND_FINISH(); \
    … …  
    53785587                    } IEM_MC_NATIVE_ELSE() { \
    53795588                        IEM_MC_LOCAL(uint8_t,        bUnmapInfo); \
    5380                         IEM_MC_ARG(uint32_t const *, pu32Dst,                                   0); \
     5589                        IEM_MC_ARG(uint32_t const *, pu32Dst,                                   1); \
    53815590                        IEM_MC_MEM_MAP_U32_RO(pu32Dst, bUnmapInfo, pVCpu->iem.s.iEffSeg, GCPtrEffDst); \
    5382                         IEM_MC_ARG_LOCAL_EFLAGS(     pEFlags, EFlags,                           2); \
    5383                         IEM_MC_ARG_CONST(uint32_t,   u32Src, (uint32_t)(int32_t)(int8_t)u8Imm,  1); \
    5384                         IEM_MC_CALL_VOID_AIMPL_3(RT_CONCAT3(iemAImpl_,a_InsNm,_u32), pu32Dst, u32Src, pEFlags); \
     5591                        IEM_MC_ARG_EFLAGS(           fEFlagsIn,                                 0); \
     5592                        IEM_MC_ARG_CONST(uint32_t,   u32Src, (uint32_t)(int32_t)(int8_t)u8Imm,  2); \
     5593                        IEM_MC_CALL_AIMPL_3(uint32_t, fEFlagsRet, RT_CONCAT3(iemAImpl_,a_InsNm,_u32), fEFlagsIn, pu32Dst, u32Src); \
    53855594                        IEM_MC_MEM_COMMIT_AND_UNMAP_RO(bUnmapInfo); \
    5386                         IEM_MC_COMMIT_EFLAGS(EFlags); \
     5595                        IEM_MC_COMMIT_EFLAGS(fEFlagsRet); \
    53875596                    } IEM_MC_NATIVE_ENDIF(); \
    53885597                    IEM_MC_ADVANCE_RIP_AND_FINISH(); \
    … …  
    54045613                    } IEM_MC_NATIVE_ELSE() { \
    54055614                        IEM_MC_LOCAL(uint8_t,        bUnmapInfo); \
    5406                         IEM_MC_ARG(uint64_t const *, pu64Dst,                                   0); \
     5615                        IEM_MC_ARG(uint64_t const *, pu64Dst,                                   1); \
    54075616                        IEM_MC_MEM_MAP_U64_RO(pu64Dst, bUnmapInfo, pVCpu->iem.s.iEffSeg, GCPtrEffDst); \
    5408                         IEM_MC_ARG_LOCAL_EFLAGS(     pEFlags, EFlags,                           2); \
    5409                         IEM_MC_ARG_CONST(uint64_t,  u64Src, (uint64_t)(int64_t)(int8_t)u8Imm,   1); \
    5410                         IEM_MC_CALL_VOID_AIMPL_3(RT_CONCAT3(iemAImpl_,a_InsNm,_u64), pu64Dst, u64Src, pEFlags); \
     5617                        IEM_MC_ARG_EFLAGS(           fEFlagsIn,                                 0); \
     5618                        IEM_MC_ARG_CONST(uint64_t,  u64Src, (uint64_t)(int64_t)(int8_t)u8Imm,   2); \
     5619                        IEM_MC_CALL_AIMPL_3(uint32_t, fEFlagsRet, RT_CONCAT3(iemAImpl_,a_InsNm,_u64), fEFlagsIn, pu64Dst, u64Src); \
    54115620                        IEM_MC_MEM_COMMIT_AND_UNMAP_RO(bUnmapInfo); \
    5412                         IEM_MC_COMMIT_EFLAGS(EFlags); \
     5621                        IEM_MC_COMMIT_EFLAGS(fEFlagsRet); \
    54135622                    } IEM_MC_NATIVE_ENDIF(); \
    54145623                    IEM_MC_ADVANCE_RIP_AND_FINISH(); \
    … …  
    55675776        IEM_MC_BEGIN(0, 0);
    55685777        IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
    5569         IEM_MC_ARG(uint8_t,         u8Src,   1);
     5778        IEM_MC_ARG(uint8_t,         u8Src,      2);
    55705779        IEM_MC_FETCH_GREG_U8(u8Src, IEM_GET_MODRM_REG(pVCpu, bRm));
    55715780        IEM_MC_NATIVE_IF(RT_ARCH_VAL_AMD64 | RT_ARCH_VAL_ARM64) {
    … …  
    55745783            IEM_MC_COMMIT_EFLAGS_OPT(uEFlags);
    55755784        } IEM_MC_NATIVE_ELSE() {
    5576             IEM_MC_ARG(uint8_t *,   pu8Dst,  0);
     5785            IEM_MC_ARG(uint8_t *,   pu8Dst,     1);
    55775786            IEM_MC_REF_GREG_U8(pu8Dst, IEM_GET_MODRM_REG(pVCpu, bRm)); /* == IEM_GET_MODRM_RM(pVCpu, bRm) */
    5578             IEM_MC_ARG(uint32_t *,  pEFlags, 2);
    5579             IEM_MC_REF_EFLAGS(pEFlags);
    5580             IEM_MC_CALL_VOID_AIMPL_3(iemAImpl_test_u8, pu8Dst, u8Src, pEFlags);
     5787            IEM_MC_ARG_EFLAGS(      fEFlagsIn,  0);
     5788            IEM_MC_CALL_AIMPL_3(uint32_t, fEFlagsRet, iemAImpl_test_u8, fEFlagsIn, pu8Dst, u8Src);
     5789            IEM_MC_COMMIT_EFLAGS(fEFlagsRet);
    55815790        } IEM_MC_NATIVE_ENDIF();
    55825791        IEM_MC_ADVANCE_RIP_AND_FINISH();
    … …  
    56115820                IEM_MC_BEGIN(0, 0);
    56125821                IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
    5613                 IEM_MC_ARG(uint16_t,   u16Src,  1);
     5822                IEM_MC_ARG(uint16_t,        u16Src,     2);
    56145823                IEM_MC_FETCH_GREG_U16(u16Src, IEM_GET_MODRM_REG(pVCpu, bRm));
    56155824                IEM_MC_NATIVE_IF(RT_ARCH_VAL_AMD64 | RT_ARCH_VAL_ARM64) {
    … …  
    56185827                    IEM_MC_COMMIT_EFLAGS_OPT(uEFlags);
    56195828                } IEM_MC_NATIVE_ELSE() {
    5620                     IEM_MC_ARG(uint16_t *, pu16Dst, 0);
     5829                    IEM_MC_ARG(uint16_t *,  pu16Dst,    1);
    56215830                    IEM_MC_REF_GREG_U16(pu16Dst, IEM_GET_MODRM_REG(pVCpu, bRm)); /* == IEM_GET_MODRM_RM(pVCpu, bRm) */
    5622                     IEM_MC_ARG(uint32_t *, pEFlags, 2);
    5623                     IEM_MC_REF_EFLAGS(pEFlags);
    5624                     IEM_MC_CALL_VOID_AIMPL_3(iemAImpl_test_u16, pu16Dst, u16Src, pEFlags);
     5831                    IEM_MC_ARG_EFLAGS(      fEFlagsIn,  0);
     5832                    IEM_MC_CALL_AIMPL_3(uint32_t, fEFlagsRet, iemAImpl_test_u16, fEFlagsIn, pu16Dst, u16Src);
     5833                    IEM_MC_COMMIT_EFLAGS(fEFlagsRet);
    56255834                } IEM_MC_NATIVE_ENDIF();
    56265835                IEM_MC_ADVANCE_RIP_AND_FINISH();
    … …  
    56315840                IEM_MC_BEGIN(IEM_MC_F_MIN_386, 0);
    56325841                IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
    5633                 IEM_MC_ARG(uint32_t,   u32Src,  1);
     5842                IEM_MC_ARG(uint32_t,        u32Src,     2);
    56345843                IEM_MC_FETCH_GREG_U32(u32Src, IEM_GET_MODRM_REG(pVCpu, bRm));
    56355844                IEM_MC_NATIVE_IF(RT_ARCH_VAL_AMD64 | RT_ARCH_VAL_ARM64) {
    … …  
    56385847                    IEM_MC_COMMIT_EFLAGS_OPT(uEFlags);
    56395848                } IEM_MC_NATIVE_ELSE() {
    5640                     IEM_MC_ARG(uint32_t *, pu32Dst, 0);
     5849                    IEM_MC_ARG(uint32_t *,  pu32Dst,    1);
    56415850                    IEM_MC_REF_GREG_U32(pu32Dst, IEM_GET_MODRM_REG(pVCpu, bRm)); /* == IEM_GET_MODRM_RM(pVCpu, bRm) */
    5642                     IEM_MC_ARG(uint32_t *, pEFlags, 2);
    5643                     IEM_MC_REF_EFLAGS(pEFlags);
    5644                     IEM_MC_CALL_VOID_AIMPL_3(iemAImpl_test_u32, pu32Dst, u32Src, pEFlags);
     5851                    IEM_MC_ARG_EFLAGS(      fEFlagsIn,  0);
     5852                    IEM_MC_CALL_AIMPL_3(uint32_t, fEFlagsRet, iemAImpl_test_u32, fEFlagsIn, pu32Dst, u32Src);
     5853                    IEM_MC_COMMIT_EFLAGS(fEFlagsRet);
    56455854                } IEM_MC_NATIVE_ENDIF();
    56465855                IEM_MC_ADVANCE_RIP_AND_FINISH();
    … …  
    56515860                IEM_MC_BEGIN(IEM_MC_F_64BIT, 0);
    56525861                IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
    5653                 IEM_MC_ARG(uint64_t,        u64Src,  1);
     5862                IEM_MC_ARG(uint64_t,        u64Src,     2);
    56545863                IEM_MC_FETCH_GREG_U64(u64Src, IEM_GET_MODRM_REG(pVCpu, bRm));
    56555864                IEM_MC_NATIVE_IF(RT_ARCH_VAL_AMD64 | RT_ARCH_VAL_ARM64) {
    … …  
    56585867                    IEM_MC_COMMIT_EFLAGS_OPT(uEFlags);
    56595868                } IEM_MC_NATIVE_ELSE() {
    5660                     IEM_MC_ARG(uint64_t *,  pu64Dst, 0);
     5869                    IEM_MC_ARG(uint64_t *,  pu64Dst,    1);
    56615870                    IEM_MC_REF_GREG_U64(pu64Dst, IEM_GET_MODRM_REG(pVCpu, bRm)); /* == IEM_GET_MODRM_RM(pVCpu, bRm) */
    5662                     IEM_MC_ARG(uint32_t *,  pEFlags, 2);
    5663                     IEM_MC_REF_EFLAGS(pEFlags);
    5664                     IEM_MC_CALL_VOID_AIMPL_3(iemAImpl_test_u64, pu64Dst, u64Src, pEFlags);
     5871                    IEM_MC_ARG_EFLAGS(      fEFlagsIn,  0);
     5872                    IEM_MC_CALL_AIMPL_3(uint32_t, fEFlagsRet, iemAImpl_test_u64, fEFlagsIn, pu64Dst, u64Src);
     5873                    IEM_MC_COMMIT_EFLAGS(fEFlagsRet);
    56655874                } IEM_MC_NATIVE_ENDIF();
    56665875                IEM_MC_ADVANCE_RIP_AND_FINISH();
    … …  
    73957604        IEM_MC_LOCAL(RTGCPTR,           uAddr2); \
    73967605        IEM_MC_FETCH_GREG_U##AddrBits##_ZX_U64(uAddr2, X86_GREG_xDI); \
    7397         IEM_MC_ARG(uint##ValBits##_t,               uValue2,            1); \
     7606        IEM_MC_ARG(uint##ValBits##_t,               uValue2,            2); \
    73987607        IEM_MC_FETCH_MEM_U##ValBits(uValue2, X86_SREG_ES, uAddr2); \
    73997608        \
    7400         IEM_MC_ARG(uint32_t *,                      pEFlags,            2); \
    7401         IEM_MC_REF_EFLAGS(pEFlags); \
    7402         IEM_MC_ARG_LOCAL_REF(uint##ValBits##_t *,   puValue1, uValue1,  0); \
    7403         IEM_MC_CALL_VOID_AIMPL_3(iemAImpl_cmp_u##ValBits, puValue1, uValue2, pEFlags); \
     7609        IEM_MC_ARG_LOCAL_REF(uint##ValBits##_t *,   puValue1, uValue1,  1); \
     7610        IEM_MC_ARG_EFLAGS(                          fEFlagsIn,          0); \
     7611        IEM_MC_CALL_AIMPL_3(uint32_t, fEFlagsRet, iemAImpl_cmp_u##ValBits, fEFlagsIn, puValue1, uValue2); \
    74047612        \
     7613        IEM_MC_COMMIT_EFLAGS(fEFlagsRet); \
    74057614        IEM_MC_IF_EFL_BIT_SET(X86_EFL_DF) { \
    74067615            IEM_MC_SUB_GREG_U##AddrBits(X86_GREG_xDI, ValBits / 8); \
    … …  
    80988307        IEM_MC_BEGIN(a_fMcFlags, 0); \
    80998308        IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX(); \
    8100         IEM_MC_ARG(uint##ValBits##_t *, puRax,   0); \
    8101         IEM_MC_ARG(uint##ValBits##_t,   uValue,  1); \
    8102         IEM_MC_ARG(uint32_t *,          pEFlags, 2); \
     8309        \
    81038310        IEM_MC_LOCAL(RTGCPTR,           uAddr); \
     8311        IEM_MC_FETCH_GREG_U##AddrBits##_ZX_U64(uAddr, X86_GREG_xDI); \
    81048312        \
    8105         IEM_MC_FETCH_GREG_U##AddrBits##_ZX_U64(uAddr, X86_GREG_xDI); \
     8313        IEM_MC_ARG(uint##ValBits##_t,   uValue,     2); \
    81068314        IEM_MC_FETCH_MEM_U##ValBits(uValue, X86_SREG_ES, uAddr); \
     8315        IEM_MC_ARG(uint##ValBits##_t *, puRax,      1); \
    81078316        IEM_MC_REF_GREG_U##ValBits(puRax, X86_GREG_xAX); \
    8108         IEM_MC_REF_EFLAGS(pEFlags); \
    8109         IEM_MC_CALL_VOID_AIMPL_3(iemAImpl_cmp_u##ValBits, puRax, uValue, pEFlags); \
     8317        IEM_MC_ARG_EFLAGS(              fEFlagsIn,  0); \
     8318        IEM_MC_CALL_AIMPL_3(uint32_t, fEFlagsRet, iemAImpl_cmp_u##ValBits, fEFlagsIn, puRax, uValue); \
    81108319        \
     8320        IEM_MC_COMMIT_EFLAGS(fEFlagsRet);\
    81118321        IEM_MC_IF_EFL_BIT_SET(X86_EFL_DF) { \
    81128322            IEM_MC_SUB_GREG_U##AddrBits(X86_GREG_xDI, ValBits / 8); \
    … …  
    1435814568        IEM_MC_ARG(uint8_t,         u8Value,    1); \
    1435914569        IEM_MC_ARG(uint32_t *,      pEFlags,    2); \
    14360         IEM_MC_LOCAL(int32_t,       rc); \
    1436114570        \
    1436214571        IEM_MC_FETCH_GREG_U8(u8Value, IEM_GET_MODRM_RM(pVCpu, bRm)); \
    1436314572        IEM_MC_REF_GREG_U16(pu16AX, X86_GREG_xAX); \
    1436414573        IEM_MC_REF_EFLAGS(pEFlags); \
    14365         IEM_MC_CALL_AIMPL_3(rc, pfnU8, pu16AX, u8Value, pEFlags); \
     14574        IEM_MC_CALL_AIMPL_3(int32_t, rc, pfnU8, pu16AX, u8Value, pEFlags); \
    1436614575        IEM_MC_IF_LOCAL_IS_Z(rc) { \
    1436714576            IEM_MC_ADVANCE_RIP_AND_FINISH(); \
    … …  
    1438014589        IEM_MC_ARG(uint32_t *,      pEFlags,    2); \
    1438114590        IEM_MC_LOCAL(RTGCPTR, GCPtrEffDst); \
    14382         IEM_MC_LOCAL(int32_t,       rc); \
    1438314591        \
    1438414592        IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 0); \
    … …  
    1438714595        IEM_MC_REF_GREG_U16(pu16AX, X86_GREG_xAX); \
    1438814596        IEM_MC_REF_EFLAGS(pEFlags); \
    14389         IEM_MC_CALL_AIMPL_3(rc, pfnU8, pu16AX, u8Value, pEFlags); \
     14597        IEM_MC_CALL_AIMPL_3(int32_t, rc, pfnU8, pu16AX, u8Value, pEFlags); \
    1439014598        IEM_MC_IF_LOCAL_IS_Z(rc) { \
    1439114599            IEM_MC_ADVANCE_RIP_AND_FINISH(); \
    … …  
    1441314621                IEM_MC_ARG(uint16_t,        u16Value,   2); \
    1441414622                IEM_MC_ARG(uint32_t *,      pEFlags,    3); \
    14415                 IEM_MC_LOCAL(int32_t,       rc); \
    1441614623                \
    1441714624                IEM_MC_FETCH_GREG_U16(u16Value, IEM_GET_MODRM_RM(pVCpu, bRm)); \
    … …  
    1441914626                IEM_MC_REF_GREG_U16(pu16DX, X86_GREG_xDX); \
    1442014627                IEM_MC_REF_EFLAGS(pEFlags); \
    14421                 IEM_MC_CALL_AIMPL_4(rc, pImpl->pfnU16, pu16AX, pu16DX, u16Value, pEFlags); \
     14628                IEM_MC_CALL_AIMPL_4(int32_t, rc, pImpl->pfnU16, pu16AX, pu16DX, u16Value, pEFlags); \
    1442214629                IEM_MC_IF_LOCAL_IS_Z(rc) { \
    1442314630                    IEM_MC_ADVANCE_RIP_AND_FINISH(); \
    … …  
    1443614643                IEM_MC_ARG(uint32_t,        u32Value,   2); \
    1443714644                IEM_MC_ARG(uint32_t *,      pEFlags,    3); \
    14438                 IEM_MC_LOCAL(int32_t,       rc); \
    1443914645                \
    1444014646                IEM_MC_FETCH_GREG_U32(u32Value, IEM_GET_MODRM_RM(pVCpu, bRm)); \
    … …  
    1444214648                IEM_MC_REF_GREG_U32(pu32DX, X86_GREG_xDX); \
    1444314649                IEM_MC_REF_EFLAGS(pEFlags); \
    14444                 IEM_MC_CALL_AIMPL_4(rc, pImpl->pfnU32, pu32AX, pu32DX, u32Value, pEFlags); \
     14650                IEM_MC_CALL_AIMPL_4(int32_t, rc, pImpl->pfnU32, pu32AX, pu32DX, u32Value, pEFlags); \
    1444514651                IEM_MC_IF_LOCAL_IS_Z(rc) { \
    1444614652                    IEM_MC_CLEAR_HIGH_GREG_U64(X86_GREG_xAX); \
    … …  
    1446114667                IEM_MC_ARG(uint64_t,        u64Value,   2); \
    1446214668                IEM_MC_ARG(uint32_t *,      pEFlags,    3); \
    14463                 IEM_MC_LOCAL(int32_t,       rc); \
    1446414669                \
    1446514670                IEM_MC_FETCH_GREG_U64(u64Value, IEM_GET_MODRM_RM(pVCpu, bRm)); \
    … …  
    1446714672                IEM_MC_REF_GREG_U64(pu64DX, X86_GREG_xDX); \
    1446814673                IEM_MC_REF_EFLAGS(pEFlags); \
    14469                 IEM_MC_CALL_AIMPL_4(rc, pImpl->pfnU64, pu64AX, pu64DX, u64Value, pEFlags); \
     14674                IEM_MC_CALL_AIMPL_4(int32_t, rc, pImpl->pfnU64, pu64AX, pu64DX, u64Value, pEFlags); \
    1447014675                IEM_MC_IF_LOCAL_IS_Z(rc) { \
    1447114676                    IEM_MC_ADVANCE_RIP_AND_FINISH(); \
    … …  
    1449214697                IEM_MC_ARG(uint32_t *,      pEFlags,    3); \
    1449314698                IEM_MC_LOCAL(RTGCPTR, GCPtrEffDst); \
    14494                 IEM_MC_LOCAL(int32_t,       rc); \
    1449514699                \
    1449614700                IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 0); \
    … …  
    1450014704                IEM_MC_REF_GREG_U16(pu16DX, X86_GREG_xDX); \
    1450114705                IEM_MC_REF_EFLAGS(pEFlags); \
    14502                 IEM_MC_CALL_AIMPL_4(rc, pImpl->pfnU16, pu16AX, pu16DX, u16Value, pEFlags); \
     14706                IEM_MC_CALL_AIMPL_4(int32_t, rc, pImpl->pfnU16, pu16AX, pu16DX, u16Value, pEFlags); \
    1450314707                IEM_MC_IF_LOCAL_IS_Z(rc) { \
    1450414708                    IEM_MC_ADVANCE_RIP_AND_FINISH(); \
    … …  
    1451714721                IEM_MC_ARG(uint32_t *,      pEFlags,    3); \
    1451814722                IEM_MC_LOCAL(RTGCPTR, GCPtrEffDst); \
    14519                 IEM_MC_LOCAL(int32_t,       rc); \
    1452014723                \
    1452114724                IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 0); \
    … …  
    1452514728                IEM_MC_REF_GREG_U32(pu32DX, X86_GREG_xDX); \
    1452614729                IEM_MC_REF_EFLAGS(pEFlags); \
    14527                 IEM_MC_CALL_AIMPL_4(rc, pImpl->pfnU32, pu32AX, pu32DX, u32Value, pEFlags); \
     14730                IEM_MC_CALL_AIMPL_4(int32_t, rc, pImpl->pfnU32, pu32AX, pu32DX, u32Value, pEFlags); \
    1452814731                IEM_MC_IF_LOCAL_IS_Z(rc) { \
    1452914732                    IEM_MC_CLEAR_HIGH_GREG_U64(X86_GREG_xAX); \
    … …  
    1454414747                IEM_MC_ARG(uint32_t *,      pEFlags,    3); \
    1454514748                IEM_MC_LOCAL(RTGCPTR, GCPtrEffDst); \
    14546                 IEM_MC_LOCAL(int32_t,       rc); \
    1454714749                \
    1454814750                IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 0); \
    … …  
    1455214754                IEM_MC_REF_GREG_U64(pu64DX, X86_GREG_xDX); \
    1455314755                IEM_MC_REF_EFLAGS(pEFlags); \
    14554                 IEM_MC_CALL_AIMPL_4(rc, pImpl->pfnU64, pu64AX, pu64DX, u64Value, pEFlags); \
     14756                IEM_MC_CALL_AIMPL_4(int32_t, rc, pImpl->pfnU64, pu64AX, pu64DX, u64Value, pEFlags); \
    1455514757                IEM_MC_IF_LOCAL_IS_Z(rc) { \
    1455614758                    IEM_MC_ADVANCE_RIP_AND_FINISH(); \
Note: See TracChangeset for help on using the changeset viewer.

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