VirtualBox

Changeset 103678 in vbox


Ignore:
Timestamp:
Mar 5, 2024 9:56:20 AM (13 months ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
162040
Message:

VMM/IEM: Optimization all 'sub same,same' and 'xor same,same' register zeroing variants. Simplifies the associated macros. bugref:10376

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

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/VMM/VMMAll/IEMAllInstCommonBodyMacros.h

    r103642 r103678  
    3232 */
    3333
     34
     35/**
     36 * Special case body for word/dword/qword instruction like SUB and XOR that can
     37 * be used to zero a register.
     38 *
     39 * This can be used both for the rv_rm and rm_rv forms since it's working on the
     40 * same register.
     41 */
     42#define IEMOP_BODY_BINARY_rv_SAME_REG_ZERO(a_bRm) \
     43    if (   (a_bRm >> X86_MODRM_REG_SHIFT) == ((a_bRm & X86_MODRM_RM_MASK) | (X86_MOD_REG << X86_MODRM_REG_SHIFT)) \
     44        && pVCpu->iem.s.uRexReg == pVCpu->iem.s.uRexB) \
     45    { \
     46        switch (pVCpu->iem.s.enmEffOpSize) \
     47        { \
     48            case IEMMODE_16BIT: \
     49                IEM_MC_BEGIN(1, 0, 0, 0); \
     50                IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX(); \
     51                IEM_MC_STORE_GREG_U16_CONST(IEM_GET_MODRM_RM(pVCpu, a_bRm), 0); \
     52                IEM_MC_LOCAL(uint32_t, fEFlags); \
     53                IEM_MC_FETCH_EFLAGS(fEFlags); \
     54                IEM_MC_AND_LOCAL_U32(fEFlags, ~(uint32_t)X86_EFL_STATUS_BITS); \
     55                IEM_MC_OR_LOCAL_U32(fEFlags, X86_EFL_PF | X86_EFL_ZF); \
     56                IEM_MC_COMMIT_EFLAGS(fEFlags); \
     57                IEM_MC_ADVANCE_RIP_AND_FINISH(); \
     58                IEM_MC_END(); \
     59                break; \
     60                \
     61            case IEMMODE_32BIT: \
     62                IEM_MC_BEGIN(1, 0, IEM_MC_F_MIN_386, 0); \
     63                IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX(); \
     64                IEM_MC_STORE_GREG_U32_CONST(IEM_GET_MODRM_RM(pVCpu, a_bRm), 0); \
     65                IEM_MC_LOCAL(uint32_t, fEFlags); \
     66                IEM_MC_FETCH_EFLAGS(fEFlags); \
     67                IEM_MC_AND_LOCAL_U32(fEFlags, ~(uint32_t)X86_EFL_STATUS_BITS); \
     68                IEM_MC_OR_LOCAL_U32(fEFlags, X86_EFL_PF | X86_EFL_ZF); \
     69                IEM_MC_COMMIT_EFLAGS(fEFlags); \
     70                IEM_MC_ADVANCE_RIP_AND_FINISH(); \
     71                IEM_MC_END(); \
     72                break; \
     73                \
     74            case IEMMODE_64BIT: \
     75                IEM_MC_BEGIN(1, 0, IEM_MC_F_64BIT, 0); \
     76                IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX(); \
     77                IEM_MC_STORE_GREG_U64_CONST(IEM_GET_MODRM_RM(pVCpu, a_bRm), 0); \
     78                IEM_MC_LOCAL(uint32_t, fEFlags); \
     79                IEM_MC_FETCH_EFLAGS(fEFlags); \
     80                IEM_MC_AND_LOCAL_U32(fEFlags, ~(uint32_t)X86_EFL_STATUS_BITS); \
     81                IEM_MC_OR_LOCAL_U32(fEFlags, X86_EFL_PF | X86_EFL_ZF); \
     82                IEM_MC_COMMIT_EFLAGS(fEFlags); \
     83                IEM_MC_ADVANCE_RIP_AND_FINISH(); \
     84                IEM_MC_END(); \
     85                break; \
     86                \
     87            IEM_NOT_REACHED_DEFAULT_CASE_RET(); \
     88        } \
     89    } ((void)0)
    3490
    3591/**

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

    r103677 r103678  
    5858
    5959/**
     60 * Special case body for bytes instruction like SUB and XOR that can be used
     61 * to zero a register.
     62 *
     63 * This can be used both for the r8_rm and rm_r8 forms since it's working on the
     64 * same register.
     65 */
     66#define IEMOP_BODY_BINARY_r8_SAME_REG_ZERO(a_bRm) \
     67    if (   (a_bRm >> X86_MODRM_REG_SHIFT) == ((bRm & X86_MODRM_RM_MASK) | (X86_MOD_REG << X86_MODRM_REG_SHIFT)) \
     68        && pVCpu->iem.s.uRexReg == pVCpu->iem.s.uRexB) \
     69    { \
     70        IEM_MC_BEGIN(0, 1, 0, 0); \
     71        IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX(); \
     72        IEM_MC_STORE_GREG_U8_CONST(IEM_GET_MODRM_REG(pVCpu, a_bRm), 0); \
     73        IEM_MC_LOCAL(uint32_t, fEFlags); \
     74        IEM_MC_FETCH_EFLAGS(fEFlags); \
     75        IEM_MC_AND_LOCAL_U32(fEFlags, ~(uint32_t)X86_EFL_STATUS_BITS); \
     76        IEM_MC_OR_LOCAL_U32(fEFlags, X86_EFL_PF | X86_EFL_ZF); \
     77        IEM_MC_COMMIT_EFLAGS(fEFlags); \
     78        IEM_MC_ADVANCE_RIP_AND_FINISH(); \
     79        IEM_MC_END(); \
     80    } ((void)0)
     81
     82/**
    6083 * Body for instructions like ADD, AND, OR, TEST, CMP, ++ with a byte
    6184 * memory/register as the destination.
    6285 */
    63 #define IEMOP_BODY_BINARY_rm_r8_RW(a_fnNormalU8, a_fnLockedU8, a_EmitterBasename, a_fRegRegNativeArchs, a_fMemRegNativeArchs) \
    64     uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm); \
    65     \
     86#define IEMOP_BODY_BINARY_rm_r8_RW(a_bRm, a_InsNm, a_fRegRegNativeArchs, a_fMemRegNativeArchs) \
    6687    /* \
    6788     * If rm is denoting a register, no more instruction bytes. \
    6889     */ \
    69     if (IEM_IS_MODRM_REG_MODE(bRm)) \
     90    if (IEM_IS_MODRM_REG_MODE(a_bRm)) \
    7091    { \
    7192        IEM_MC_BEGIN(3, 0, 0, 0); \
    7293        IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX(); \
    7394        IEM_MC_ARG(uint8_t,         u8Src,   1); \
    74         IEM_MC_FETCH_GREG_U8(u8Src, IEM_GET_MODRM_REG(pVCpu, bRm)); \
     95        IEM_MC_FETCH_GREG_U8(u8Src, IEM_GET_MODRM_REG(pVCpu, a_bRm)); \
    7596        IEM_MC_NATIVE_IF(a_fRegRegNativeArchs) { \
    7697            IEM_MC_LOCAL(uint8_t,   u8Dst); \
    77             IEM_MC_FETCH_GREG_U8(u8Dst, IEM_GET_MODRM_RM(pVCpu, bRm)); \
     98            IEM_MC_FETCH_GREG_U8(u8Dst, IEM_GET_MODRM_RM(pVCpu, a_bRm)); \
    7899            /** @todo IEM_MC_LOCAL_EFLAGS(uEFlags); */ \
    79100            IEM_MC_LOCAL(uint32_t,  uEFlags); \
    80101            IEM_MC_FETCH_EFLAGS(uEFlags); \
    81             IEM_MC_NATIVE_EMIT_4(RT_CONCAT3(iemNativeEmit_,a_EmitterBasename,_r_r_efl), u8Dst, u8Src, uEFlags, 8); \
    82             IEM_MC_STORE_GREG_U8(IEM_GET_MODRM_RM(pVCpu, bRm), u8Dst); \
     102            IEM_MC_NATIVE_EMIT_4(RT_CONCAT3(iemNativeEmit_,a_InsNm,_r_r_efl), u8Dst, u8Src, uEFlags, 8); \
     103            IEM_MC_STORE_GREG_U8(IEM_GET_MODRM_RM(pVCpu, a_bRm), u8Dst); \
    83104            IEM_MC_COMMIT_EFLAGS(uEFlags); \
    84105        } IEM_MC_NATIVE_ELSE() { \
    85106            IEM_MC_ARG(uint8_t *,   pu8Dst,  0); \
    86             IEM_MC_REF_GREG_U8(pu8Dst, IEM_GET_MODRM_RM(pVCpu, bRm)); \
     107            IEM_MC_REF_GREG_U8(pu8Dst, IEM_GET_MODRM_RM(pVCpu, a_bRm)); \
    87108            IEM_MC_ARG(uint32_t *,  pEFlags, 2); \
    88109            IEM_MC_REF_EFLAGS(pEFlags); \
    89             IEM_MC_CALL_VOID_AIMPL_3(a_fnNormalU8, pu8Dst, u8Src, pEFlags); \
     110            IEM_MC_CALL_VOID_AIMPL_3(RT_CONCAT3(iemAImpl_,a_InsNm,_u8), pu8Dst, u8Src, pEFlags); \
    90111        } IEM_MC_NATIVE_ENDIF(); \
    91112        IEM_MC_ADVANCE_RIP_AND_FINISH(); \
    … …  
    108129            IEM_MC_LOCAL(uint8_t, bUnmapInfo); \
    109130            \
    110             IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 0); \
     131            IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, a_bRm, 0); \
    111132            IEMOP_HLP_DONE_DECODING(); \
    112133            IEM_MC_MEM_MAP_U8_RW(pu8Dst, bUnmapInfo, pVCpu->iem.s.iEffSeg, GCPtrEffDst); \
    113             IEM_MC_FETCH_GREG_U8(u8Src, IEM_GET_MODRM_REG(pVCpu, bRm)); \
     134            IEM_MC_FETCH_GREG_U8(u8Src, IEM_GET_MODRM_REG(pVCpu, a_bRm)); \
    114135            IEM_MC_FETCH_EFLAGS(EFlags); \
    115             IEM_MC_CALL_VOID_AIMPL_3(a_fnNormalU8, pu8Dst, u8Src, pEFlags); \
     136            IEM_MC_CALL_VOID_AIMPL_3(RT_CONCAT3(iemAImpl_,a_InsNm,_u8), pu8Dst, u8Src, pEFlags); \
    116137            \
    117138            IEM_MC_MEM_COMMIT_AND_UNMAP_RW(bUnmapInfo); \
    … …  
    129150            IEM_MC_LOCAL(uint8_t, bMapInfoDst); \
    130151            \
    131             IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 0); \
     152            IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, a_bRm, 0); \
    132153            IEMOP_HLP_DONE_DECODING(); \
    133154            IEM_MC_MEM_MAP_U8_ATOMIC(pu8Dst, bMapInfoDst, pVCpu->iem.s.iEffSeg, GCPtrEffDst); \
    134             IEM_MC_FETCH_GREG_U8(u8Src, IEM_GET_MODRM_REG(pVCpu, bRm)); \
     155            IEM_MC_FETCH_GREG_U8(u8Src, IEM_GET_MODRM_REG(pVCpu, a_bRm)); \
    135156            IEM_MC_FETCH_EFLAGS(EFlags); \
    136             IEM_MC_CALL_VOID_AIMPL_3(a_fnLockedU8, pu8Dst, u8Src, pEFlags); \
     157            IEM_MC_CALL_VOID_AIMPL_3(RT_CONCAT3(iemAImpl_,a_InsNm,_u8_locked), pu8Dst, u8Src, pEFlags); \
    137158            \
    138159            IEM_MC_MEM_COMMIT_AND_UNMAP_ATOMIC(bMapInfoDst); \
    … …  
    227248 * destination.
    228249 */
    229 #define IEMOP_BODY_BINARY_r8_rm(a_fnNormalU8, a_EmitterBasename, a_fNativeArchs) \
    230     uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm); \
    231     \
     250#define IEMOP_BODY_BINARY_r8_rm(a_bRm, a_InsNm, a_fNativeArchs) \
    232251    /* \
    233252     * If rm is denoting a register, no more instruction bytes. \
    234253     */ \
    235     if (IEM_IS_MODRM_REG_MODE(bRm)) \
     254    if (IEM_IS_MODRM_REG_MODE(a_bRm)) \
    236255    { \
    237256        IEM_MC_BEGIN(3, 0, 0, 0); \
    238257        IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX(); \
    239258        IEM_MC_ARG(uint8_t,         u8Src,   1); \
    240         IEM_MC_FETCH_GREG_U8(u8Src, IEM_GET_MODRM_RM(pVCpu, bRm)); \
     259        IEM_MC_FETCH_GREG_U8(u8Src, IEM_GET_MODRM_RM(pVCpu, a_bRm)); \
    241260        IEM_MC_NATIVE_IF(a_fNativeArchs) { \
    242261            IEM_MC_LOCAL(uint8_t,   u8Dst); \
    243             IEM_MC_FETCH_GREG_U8(u8Dst, IEM_GET_MODRM_REG(pVCpu, bRm)); \
     262            IEM_MC_FETCH_GREG_U8(u8Dst, IEM_GET_MODRM_REG(pVCpu, a_bRm)); \
    244263            /** @todo IEM_MC_LOCAL_EFLAGS(uEFlags); */ \
    245264            IEM_MC_LOCAL(uint32_t,  uEFlags); \
    246265            IEM_MC_FETCH_EFLAGS(uEFlags); \
    247             IEM_MC_NATIVE_EMIT_4(RT_CONCAT3(iemNativeEmit_,a_EmitterBasename,_r_r_efl), u8Dst, u8Src, uEFlags, 8); \
    248             IEM_MC_STORE_GREG_U8(IEM_GET_MODRM_REG(pVCpu, bRm), u8Dst); \
     266            IEM_MC_NATIVE_EMIT_4(RT_CONCAT3(iemNativeEmit_,a_InsNm,_r_r_efl), u8Dst, u8Src, uEFlags, 8); \
     267            IEM_MC_STORE_GREG_U8(IEM_GET_MODRM_REG(pVCpu, a_bRm), u8Dst); \
    249268            IEM_MC_COMMIT_EFLAGS(uEFlags); \
    250269        } IEM_MC_NATIVE_ELSE() { \
    251270            IEM_MC_ARG(uint8_t *,   pu8Dst,  0); \
    252             IEM_MC_REF_GREG_U8(pu8Dst, IEM_GET_MODRM_REG(pVCpu, bRm)); \
     271            IEM_MC_REF_GREG_U8(pu8Dst, IEM_GET_MODRM_REG(pVCpu, a_bRm)); \
    253272            IEM_MC_ARG(uint32_t *,  pEFlags, 2); \
    254273            IEM_MC_REF_EFLAGS(pEFlags); \
    255             IEM_MC_CALL_VOID_AIMPL_3(a_fnNormalU8, pu8Dst, u8Src, pEFlags); \
     274            IEM_MC_CALL_VOID_AIMPL_3(RT_CONCAT3(iemAImpl_,a_InsNm,_u8), pu8Dst, u8Src, pEFlags); \
    256275        } IEM_MC_NATIVE_ENDIF(); \
    257276        IEM_MC_ADVANCE_RIP_AND_FINISH(); \
    … …  
    265284        IEM_MC_BEGIN(3, 1, 0, 0); \
    266285        IEM_MC_LOCAL(RTGCPTR,  GCPtrEffDst); \
    267         IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 0); \
     286        IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, a_bRm, 0); \
    268287        IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX(); \
    269288        IEM_MC_ARG(uint8_t,         u8Src,   1); \
    … …  
    271290        IEM_MC_NATIVE_IF(a_fNativeArchs) { \
    272291            IEM_MC_LOCAL(uint8_t,   u8Dst); \
    273             IEM_MC_FETCH_GREG_U8(u8Dst, IEM_GET_MODRM_REG(pVCpu, bRm)); \
     292            IEM_MC_FETCH_GREG_U8(u8Dst, IEM_GET_MODRM_REG(pVCpu, a_bRm)); \
    274293            /** @todo IEM_MC_LOCAL_EFLAGS(uEFlags); */ \
    275294            IEM_MC_LOCAL(uint32_t,  uEFlags); \
    276295            IEM_MC_FETCH_EFLAGS(uEFlags); \
    277             IEM_MC_NATIVE_EMIT_4(RT_CONCAT3(iemNativeEmit_,a_EmitterBasename,_r_r_efl), u8Dst, u8Src, uEFlags, 8); \
    278             IEM_MC_STORE_GREG_U8(IEM_GET_MODRM_REG(pVCpu, bRm), u8Dst); \
     296            IEM_MC_NATIVE_EMIT_4(RT_CONCAT3(iemNativeEmit_,a_InsNm,_r_r_efl), u8Dst, u8Src, uEFlags, 8); \
     297            IEM_MC_STORE_GREG_U8(IEM_GET_MODRM_REG(pVCpu, a_bRm), u8Dst); \
    279298            IEM_MC_COMMIT_EFLAGS(uEFlags); \
    280299        } IEM_MC_NATIVE_ELSE() { \
    281300            IEM_MC_ARG(uint8_t *,   pu8Dst,  0); \
    282             IEM_MC_REF_GREG_U8(pu8Dst, IEM_GET_MODRM_REG(pVCpu, bRm)); \
     301            IEM_MC_REF_GREG_U8(pu8Dst, IEM_GET_MODRM_REG(pVCpu, a_bRm)); \
    283302            IEM_MC_ARG(uint32_t *,  pEFlags, 2); \
    284303            IEM_MC_REF_EFLAGS(pEFlags); \
    285             IEM_MC_CALL_VOID_AIMPL_3(a_fnNormalU8, pu8Dst, u8Src, pEFlags); \
     304            IEM_MC_CALL_VOID_AIMPL_3(RT_CONCAT3(iemAImpl_,a_InsNm,_u8), pu8Dst, u8Src, pEFlags); \
    286305        } IEM_MC_NATIVE_ENDIF(); \
    287306        IEM_MC_ADVANCE_RIP_AND_FINISH(); \
    … …  
    295314 * memory/register as the destination.
    296315 */
    297 #define IEMOP_BODY_BINARY_rm_rv_RW(a_fnNormalU16, a_fnNormalU32, a_fnNormalU64, a_EmitterBasename, a_fRegRegNativeArchs, a_fMemRegNativeArchs) \
    298     uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm); \
    299     \
     316#define IEMOP_BODY_BINARY_rm_rv_RW(a_bRm, a_InsNm, a_fRegRegNativeArchs, a_fMemRegNativeArchs) \
    300317    /* \
    301318     * If rm is denoting a register, no more instruction bytes. \
    302319     */ \
    303     if (IEM_IS_MODRM_REG_MODE(bRm)) \
     320    if (IEM_IS_MODRM_REG_MODE(a_bRm)) \
    304321    { \
    305322        switch (pVCpu->iem.s.enmEffOpSize) \
    … …  
    309326                IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX(); \
    310327                IEM_MC_ARG(uint16_t,   u16Src,  1); \
    311                 IEM_MC_FETCH_GREG_U16(u16Src, IEM_GET_MODRM_REG(pVCpu, bRm)); \
     328                IEM_MC_FETCH_GREG_U16(u16Src, IEM_GET_MODRM_REG(pVCpu, a_bRm)); \
    312329                IEM_MC_NATIVE_IF(a_fRegRegNativeArchs) { \
    313330                    IEM_MC_LOCAL(uint16_t,   u16Dst); \
    314                     IEM_MC_FETCH_GREG_U16(u16Dst, IEM_GET_MODRM_RM(pVCpu, bRm)); \
     331                    IEM_MC_FETCH_GREG_U16(u16Dst, IEM_GET_MODRM_RM(pVCpu, a_bRm)); \
    315332                    /** @todo IEM_MC_LOCAL_EFLAGS(uEFlags); */ \
    316333                    IEM_MC_LOCAL(uint32_t,  uEFlags); \
    317334                    IEM_MC_FETCH_EFLAGS(uEFlags); \
    318                     IEM_MC_NATIVE_EMIT_4(RT_CONCAT3(iemNativeEmit_,a_EmitterBasename,_r_r_efl), u16Dst, u16Src, uEFlags, 16); \
    319                     IEM_MC_STORE_GREG_U16(IEM_GET_MODRM_RM(pVCpu, bRm), u16Dst); \
     335                    IEM_MC_NATIVE_EMIT_4(RT_CONCAT3(iemNativeEmit_,a_InsNm,_r_r_efl), u16Dst, u16Src, uEFlags, 16); \
     336                    IEM_MC_STORE_GREG_U16(IEM_GET_MODRM_RM(pVCpu, a_bRm), u16Dst); \
    320337                    IEM_MC_COMMIT_EFLAGS(uEFlags); \
    321338                } IEM_MC_NATIVE_ELSE() { \
    322339                    IEM_MC_ARG(uint16_t *, pu16Dst, 0); \
    323                     IEM_MC_REF_GREG_U16(pu16Dst, IEM_GET_MODRM_RM(pVCpu, bRm)); \
     340                    IEM_MC_REF_GREG_U16(pu16Dst, IEM_GET_MODRM_RM(pVCpu, a_bRm)); \
    324341                    IEM_MC_ARG(uint32_t *, pEFlags, 2); \
    325342                    IEM_MC_REF_EFLAGS(pEFlags); \
    326                     IEM_MC_CALL_VOID_AIMPL_3(a_fnNormalU16, pu16Dst, u16Src, pEFlags); \
     343                    IEM_MC_CALL_VOID_AIMPL_3(RT_CONCAT3(iemAImpl_,a_InsNm,_u16), pu16Dst, u16Src, pEFlags); \
    327344                } IEM_MC_NATIVE_ENDIF(); \
    328345                IEM_MC_ADVANCE_RIP_AND_FINISH(); \
    … …  
    334351                IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX(); \
    335352                IEM_MC_ARG(uint32_t,   u32Src,  1); \
    336                 IEM_MC_FETCH_GREG_U32(u32Src, IEM_GET_MODRM_REG(pVCpu, bRm)); \
     353                IEM_MC_FETCH_GREG_U32(u32Src, IEM_GET_MODRM_REG(pVCpu, a_bRm)); \
    337354                IEM_MC_NATIVE_IF(a_fRegRegNativeArchs) { \
    338355                    IEM_MC_LOCAL(uint32_t,   u32Dst); \
    339                     IEM_MC_FETCH_GREG_U32(u32Dst, IEM_GET_MODRM_RM(pVCpu, bRm)); \
     356                    IEM_MC_FETCH_GREG_U32(u32Dst, IEM_GET_MODRM_RM(pVCpu, a_bRm)); \
    340357                    /** @todo IEM_MC_LOCAL_EFLAGS(uEFlags); */ \
    341358                    IEM_MC_LOCAL(uint32_t,  uEFlags); \
    342359                    IEM_MC_FETCH_EFLAGS(uEFlags); \
    343                     IEM_MC_NATIVE_EMIT_4(RT_CONCAT3(iemNativeEmit_,a_EmitterBasename,_r_r_efl), u32Dst, u32Src, uEFlags, 32); \
    344                     IEM_MC_STORE_GREG_U32(IEM_GET_MODRM_RM(pVCpu, bRm), u32Dst); \
     360                    IEM_MC_NATIVE_EMIT_4(RT_CONCAT3(iemNativeEmit_,a_InsNm,_r_r_efl), u32Dst, u32Src, uEFlags, 32); \
     361                    IEM_MC_STORE_GREG_U32(IEM_GET_MODRM_RM(pVCpu, a_bRm), u32Dst); \
    345362                    IEM_MC_COMMIT_EFLAGS(uEFlags); \
    346363                } IEM_MC_NATIVE_ELSE() { \
    347364                    IEM_MC_ARG(uint32_t *, pu32Dst, 0); \
    348                     IEM_MC_REF_GREG_U32(pu32Dst, IEM_GET_MODRM_RM(pVCpu, bRm)); \
     365                    IEM_MC_REF_GREG_U32(pu32Dst, IEM_GET_MODRM_RM(pVCpu, a_bRm)); \
    349366                    IEM_MC_ARG(uint32_t *, pEFlags, 2); \
    350367                    IEM_MC_REF_EFLAGS(pEFlags); \
    351                     IEM_MC_CALL_VOID_AIMPL_3(a_fnNormalU32, pu32Dst, u32Src, pEFlags); \
    352                     IEM_MC_CLEAR_HIGH_GREG_U64(IEM_GET_MODRM_RM(pVCpu, bRm)); \
     368                    IEM_MC_CALL_VOID_AIMPL_3(RT_CONCAT3(iemAImpl_,a_InsNm,_u32), pu32Dst, u32Src, pEFlags); \
     369                    IEM_MC_CLEAR_HIGH_GREG_U64(IEM_GET_MODRM_RM(pVCpu, a_bRm)); \
    353370                } IEM_MC_NATIVE_ENDIF(); \
    354371                IEM_MC_ADVANCE_RIP_AND_FINISH(); \
    … …  
    360377                IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX(); \
    361378                IEM_MC_ARG(uint64_t,        u64Src,  1); \
    362                 IEM_MC_FETCH_GREG_U64(u64Src, IEM_GET_MODRM_REG(pVCpu, bRm)); \
     379                IEM_MC_FETCH_GREG_U64(u64Src, IEM_GET_MODRM_REG(pVCpu, a_bRm)); \
    363380                IEM_MC_NATIVE_IF(a_fRegRegNativeArchs) { \
    364381                    IEM_MC_LOCAL(uint64_t,  u64Dst); \
    365                     IEM_MC_FETCH_GREG_U64(u64Dst, IEM_GET_MODRM_RM(pVCpu, bRm)); \
     382                    IEM_MC_FETCH_GREG_U64(u64Dst, IEM_GET_MODRM_RM(pVCpu, a_bRm)); \
    366383                    /** @todo IEM_MC_LOCAL_EFLAGS(uEFlags); */ \
    367384                    IEM_MC_LOCAL(uint32_t,  uEFlags); \
    368385                    IEM_MC_FETCH_EFLAGS(uEFlags); \
    369                     IEM_MC_NATIVE_EMIT_4(RT_CONCAT3(iemNativeEmit_,a_EmitterBasename,_r_r_efl), u64Dst, u64Src, uEFlags, 64); \
    370                     IEM_MC_STORE_GREG_U64(IEM_GET_MODRM_RM(pVCpu, bRm), u64Dst); \
     386                    IEM_MC_NATIVE_EMIT_4(RT_CONCAT3(iemNativeEmit_,a_InsNm,_r_r_efl), u64Dst, u64Src, uEFlags, 64); \
     387                    IEM_MC_STORE_GREG_U64(IEM_GET_MODRM_RM(pVCpu, a_bRm), u64Dst); \
    371388                    IEM_MC_COMMIT_EFLAGS(uEFlags); \
    372389                } IEM_MC_NATIVE_ELSE() { \
    373390                    IEM_MC_ARG(uint64_t *,  pu64Dst, 0); \
    374                     IEM_MC_REF_GREG_U64(pu64Dst, IEM_GET_MODRM_RM(pVCpu, bRm)); \
     391                    IEM_MC_REF_GREG_U64(pu64Dst, IEM_GET_MODRM_RM(pVCpu, a_bRm)); \
    375392                    IEM_MC_ARG(uint32_t *,  pEFlags, 2); \
    376393                    IEM_MC_REF_EFLAGS(pEFlags); \
    377                     IEM_MC_CALL_VOID_AIMPL_3(a_fnNormalU64, pu64Dst, u64Src, pEFlags); \
     394                    IEM_MC_CALL_VOID_AIMPL_3(RT_CONCAT3(iemAImpl_,a_InsNm,_u64), pu64Dst, u64Src, pEFlags); \
    378395                } IEM_MC_NATIVE_ENDIF(); \
    379396                IEM_MC_ADVANCE_RIP_AND_FINISH(); \
    … …  
    403420                    IEM_MC_LOCAL(uint8_t, bUnmapInfo); \
    404421                    \
    405                     IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 0); \
     422                    IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, a_bRm, 0); \
    406423                    IEMOP_HLP_DONE_DECODING(); \
    407424                    IEM_MC_MEM_MAP_U16_RW(pu16Dst, bUnmapInfo, pVCpu->iem.s.iEffSeg, GCPtrEffDst); \
    408                     IEM_MC_FETCH_GREG_U16(u16Src, IEM_GET_MODRM_REG(pVCpu, bRm)); \
     425                    IEM_MC_FETCH_GREG_U16(u16Src, IEM_GET_MODRM_REG(pVCpu, a_bRm)); \
    409426                    IEM_MC_FETCH_EFLAGS(EFlags); \
    410                     IEM_MC_CALL_VOID_AIMPL_3(a_fnNormalU16, pu16Dst, u16Src, pEFlags); \
     427                    IEM_MC_CALL_VOID_AIMPL_3(RT_CONCAT3(iemAImpl_,a_InsNm,_u16), pu16Dst, u16Src, pEFlags); \
    411428                    \
    412429                    IEM_MC_MEM_COMMIT_AND_UNMAP_RW(bUnmapInfo); \
    … …  
    424441                    IEM_MC_LOCAL(uint8_t, bUnmapInfo); \
    425442                    \
    426                     IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 0); \
     443                    IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, a_bRm, 0); \
    427444                    IEMOP_HLP_DONE_DECODING(); \
    428445                    IEM_MC_MEM_MAP_U32_RW(pu32Dst, bUnmapInfo, pVCpu->iem.s.iEffSeg, GCPtrEffDst); \
    429                     IEM_MC_FETCH_GREG_U32(u32Src, IEM_GET_MODRM_REG(pVCpu, bRm)); \
     446                    IEM_MC_FETCH_GREG_U32(u32Src, IEM_GET_MODRM_REG(pVCpu, a_bRm)); \
    430447                    IEM_MC_FETCH_EFLAGS(EFlags); \
    431                     IEM_MC_CALL_VOID_AIMPL_3(a_fnNormalU32, pu32Dst, u32Src, pEFlags); \
     448                    IEM_MC_CALL_VOID_AIMPL_3(RT_CONCAT3(iemAImpl_,a_InsNm,_u32), pu32Dst, u32Src, pEFlags); \
    432449                    \
    433450                    IEM_MC_MEM_COMMIT_AND_UNMAP_RW(bUnmapInfo); \
    … …  
    445462                    IEM_MC_LOCAL(uint8_t, bUnmapInfo); \
    446463                    \
    447                     IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 0); \
     464                    IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, a_bRm, 0); \
    448465                    IEMOP_HLP_DONE_DECODING(); \
    449466                    IEM_MC_MEM_MAP_U64_RW(pu64Dst, bUnmapInfo, pVCpu->iem.s.iEffSeg, GCPtrEffDst); \
    450                     IEM_MC_FETCH_GREG_U64(u64Src, IEM_GET_MODRM_REG(pVCpu, bRm)); \
     467                    IEM_MC_FETCH_GREG_U64(u64Src, IEM_GET_MODRM_REG(pVCpu, a_bRm)); \
    451468                    IEM_MC_FETCH_EFLAGS(EFlags); \
    452                     IEM_MC_CALL_VOID_AIMPL_3(a_fnNormalU64, pu64Dst, u64Src, pEFlags); \
     469                    IEM_MC_CALL_VOID_AIMPL_3(RT_CONCAT3(iemAImpl_,a_InsNm,_u64), pu64Dst, u64Src, pEFlags); \
    453470                    \
    454471                    IEM_MC_MEM_COMMIT_AND_UNMAP_RW(bUnmapInfo); \
    … …  
    465482            (void)0
    466483/* Separate macro to work around parsing issue in IEMAllInstPython.py */
    467 #define IEMOP_BODY_BINARY_rm_rv_LOCKED(a_fnLockedU16, a_fnLockedU32, a_fnLockedU64) \
     484#define IEMOP_BODY_BINARY_rm_rv_LOCKED(a_bRm, a_InsNm) \
    468485            switch (pVCpu->iem.s.enmEffOpSize) \
    469486            { \
    … …  
    476493                    IEM_MC_LOCAL(uint8_t, bUnmapInfo); \
    477494                    \
    478                     IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 0); \
     495                    IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, a_bRm, 0); \
    479496                    IEMOP_HLP_DONE_DECODING(); \
    480497                    IEM_MC_MEM_MAP_U16_ATOMIC(pu16Dst, bUnmapInfo, pVCpu->iem.s.iEffSeg, GCPtrEffDst); \
    481                     IEM_MC_FETCH_GREG_U16(u16Src, IEM_GET_MODRM_REG(pVCpu, bRm)); \
     498                    IEM_MC_FETCH_GREG_U16(u16Src, IEM_GET_MODRM_REG(pVCpu, a_bRm)); \
    482499                    IEM_MC_FETCH_EFLAGS(EFlags); \
    483                     IEM_MC_CALL_VOID_AIMPL_3(a_fnLockedU16, pu16Dst, u16Src, pEFlags); \
     500                    IEM_MC_CALL_VOID_AIMPL_3(RT_CONCAT3(iemAImpl_,a_InsNm,_u16_locked), pu16Dst, u16Src, pEFlags); \
    484501                    \
    485502                    IEM_MC_MEM_COMMIT_AND_UNMAP_ATOMIC(bUnmapInfo); \
    … …  
    497514                    IEM_MC_LOCAL(uint8_t, bUnmapInfo); \
    498515                    \
    499                     IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 0); \
     516                    IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, a_bRm, 0); \
    500517                    IEMOP_HLP_DONE_DECODING(); \
    501518                    IEM_MC_MEM_MAP_U32_ATOMIC(pu32Dst, bUnmapInfo, pVCpu->iem.s.iEffSeg, GCPtrEffDst); \
    502                     IEM_MC_FETCH_GREG_U32(u32Src, IEM_GET_MODRM_REG(pVCpu, bRm)); \
     519                    IEM_MC_FETCH_GREG_U32(u32Src, IEM_GET_MODRM_REG(pVCpu, a_bRm)); \
    503520                    IEM_MC_FETCH_EFLAGS(EFlags); \
    504                     IEM_MC_CALL_VOID_AIMPL_3(a_fnLockedU32, pu32Dst, u32Src, pEFlags); \
     521                    IEM_MC_CALL_VOID_AIMPL_3(RT_CONCAT3(iemAImpl_,a_InsNm,_u32_locked), pu32Dst, u32Src, pEFlags); \
    505522                    \
    506523                    IEM_MC_MEM_COMMIT_AND_UNMAP_ATOMIC(bUnmapInfo /* CMP,TEST */); \
    … …  
    518535                    IEM_MC_LOCAL(uint8_t, bUnmapInfo); \
    519536                    \
    520                     IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 0); \
     537                    IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, a_bRm, 0); \
    521538                    IEMOP_HLP_DONE_DECODING(); \
    522539                    IEM_MC_MEM_MAP_U64_ATOMIC(pu64Dst, bUnmapInfo, pVCpu->iem.s.iEffSeg, GCPtrEffDst); \
    523                     IEM_MC_FETCH_GREG_U64(u64Src, IEM_GET_MODRM_REG(pVCpu, bRm)); \
     540                    IEM_MC_FETCH_GREG_U64(u64Src, IEM_GET_MODRM_REG(pVCpu, a_bRm)); \
    524541                    IEM_MC_FETCH_EFLAGS(EFlags); \
    525                     IEM_MC_CALL_VOID_AIMPL_3(a_fnLockedU64, pu64Dst, u64Src, pEFlags); \
     542                    IEM_MC_CALL_VOID_AIMPL_3(RT_CONCAT3(iemAImpl_,a_InsNm,_u64_locked), pu64Dst, u64Src, pEFlags); \
    526543                    \
    527544                    IEM_MC_MEM_COMMIT_AND_UNMAP_ATOMIC(bUnmapInfo); \
    … …  
    850867{
    851868    IEMOP_MNEMONIC2(MR, ADD, add, Eb, Gb, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES | IEMOPHINT_LOCK_ALLOWED);
    852     IEMOP_BODY_BINARY_rm_r8_RW(iemAImpl_add_u8, iemAImpl_add_u8_locked, add, 0, 0);
     869    uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
     870    IEMOP_BODY_BINARY_rm_r8_RW(bRm, add, 0, 0);
    853871}
    854872
    … …  
    866884{
    867885    IEMOP_MNEMONIC2(MR, ADD, add, Ev, Gv, DISOPTYPE_HARMLESS, IEMOPHINT_LOCK_ALLOWED);
    868     IEMOP_BODY_BINARY_rm_rv_RW(    iemAImpl_add_u16,        iemAImpl_add_u32,        iemAImpl_add_u64,       add, 0, 0);
    869     IEMOP_BODY_BINARY_rm_rv_LOCKED(iemAImpl_add_u16_locked, iemAImpl_add_u32_locked, iemAImpl_add_u64_locked);
     886    uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
     887    IEMOP_BODY_BINARY_rm_rv_RW(    bRm, add, 0, 0);
     888    IEMOP_BODY_BINARY_rm_rv_LOCKED(bRm, add);
    870889}
    871890
    … …  
    880899{
    881900    IEMOP_MNEMONIC2(RM, ADD, add, Gb, Eb, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES);
    882     IEMOP_BODY_BINARY_r8_rm(iemAImpl_add_u8, add, 0);
     901    uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
     902    IEMOP_BODY_BINARY_r8_rm(bRm, add, 0);
    883903}
    884904
    … …  
    971991    IEMOP_MNEMONIC2(MR, OR, or, Eb, Gb, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES | IEMOPHINT_LOCK_ALLOWED);
    972992    IEMOP_VERIFICATION_UNDEFINED_EFLAGS(X86_EFL_AF);
    973     IEMOP_BODY_BINARY_rm_r8_RW(iemAImpl_or_u8, iemAImpl_or_u8_locked, or, RT_ARCH_VAL_AMD64 | RT_ARCH_VAL_ARM64, 0);
     993    uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
     994    IEMOP_BODY_BINARY_rm_r8_RW(bRm, or, RT_ARCH_VAL_AMD64 | RT_ARCH_VAL_ARM64, 0);
    974995}
    975996
    … …  
    9911012    IEMOP_MNEMONIC2(MR, OR, or, Ev, Gv, DISOPTYPE_HARMLESS, IEMOPHINT_LOCK_ALLOWED);
    9921013    IEMOP_VERIFICATION_UNDEFINED_EFLAGS(X86_EFL_AF);
    993     IEMOP_BODY_BINARY_rm_rv_RW(    iemAImpl_or_u16,        iemAImpl_or_u32,        iemAImpl_or_u64,       or, RT_ARCH_VAL_AMD64 | RT_ARCH_VAL_ARM64, 0);
    994     IEMOP_BODY_BINARY_rm_rv_LOCKED(iemAImpl_or_u16_locked, iemAImpl_or_u32_locked, iemAImpl_or_u64_locked);
     1014    uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
     1015    IEMOP_BODY_BINARY_rm_rv_RW(    bRm, or, RT_ARCH_VAL_AMD64 | RT_ARCH_VAL_ARM64, 0);
     1016    IEMOP_BODY_BINARY_rm_rv_LOCKED(bRm, or);
    9951017}
    9961018
    … …  
    10061028    IEMOP_MNEMONIC2(RM, OR, or, Gb, Eb, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES | IEMOPHINT_LOCK_ALLOWED);
    10071029    IEMOP_VERIFICATION_UNDEFINED_EFLAGS(X86_EFL_AF);
    1008     IEMOP_BODY_BINARY_r8_rm(iemAImpl_or_u8, or, RT_ARCH_VAL_AMD64 | RT_ARCH_VAL_ARM64);
     1030    uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
     1031    IEMOP_BODY_BINARY_r8_rm(bRm, or, RT_ARCH_VAL_AMD64 | RT_ARCH_VAL_ARM64);
    10091032}
    10101033
    … …  
    11301153{
    11311154    IEMOP_MNEMONIC2(MR, ADC, adc, Eb, Gb, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES | IEMOPHINT_LOCK_ALLOWED);
    1132     IEMOP_BODY_BINARY_rm_r8_RW(iemAImpl_adc_u8, iemAImpl_adc_u8_locked, adc, 0, 0);
     1155    uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
     1156    IEMOP_BODY_BINARY_rm_r8_RW(bRm, adc, 0, 0);
    11331157}
    11341158
    … …  
    11471171{
    11481172    IEMOP_MNEMONIC2(MR, ADC, adc, Ev, Gv, DISOPTYPE_HARMLESS, IEMOPHINT_LOCK_ALLOWED);
    1149     IEMOP_BODY_BINARY_rm_rv_RW(    iemAImpl_adc_u16,        iemAImpl_adc_u32,        iemAImpl_adc_u64,       adc, 0, 0);
    1150     IEMOP_BODY_BINARY_rm_rv_LOCKED(iemAImpl_adc_u16_locked, iemAImpl_adc_u32_locked, iemAImpl_adc_u64_locked);
     1173    uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
     1174    IEMOP_BODY_BINARY_rm_rv_RW(    bRm, adc, 0, 0);
     1175    IEMOP_BODY_BINARY_rm_rv_LOCKED(bRm, adc);
    11511176}
    11521177
    … …  
    11611186{
    11621187    IEMOP_MNEMONIC2(RM, ADC, adc, Gb, Eb, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES);
    1163     IEMOP_BODY_BINARY_r8_rm(iemAImpl_adc_u8, adc, 0);
     1188    uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
     1189    IEMOP_BODY_BINARY_r8_rm(bRm, adc, 0);
    11641190}
    11651191
    … …  
    12421268{
    12431269    IEMOP_MNEMONIC2(MR, SBB, sbb, Eb, Gb, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES | IEMOPHINT_LOCK_ALLOWED);
    1244     IEMOP_BODY_BINARY_rm_r8_RW(iemAImpl_sbb_u8, iemAImpl_sbb_u8_locked, sbb, 0, 0);
     1270    uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
     1271    IEMOP_BODY_BINARY_rm_r8_RW(bRm, sbb, 0, 0);
    12451272}
    12461273
    … …  
    12541281{
    12551282    IEMOP_MNEMONIC2(MR, SBB, sbb, Ev, Gv, DISOPTYPE_HARMLESS, IEMOPHINT_LOCK_ALLOWED);
    1256     IEMOP_BODY_BINARY_rm_rv_RW(    iemAImpl_sbb_u16,        iemAImpl_sbb_u32,        iemAImpl_sbb_u64,       sbb, 0, 0);
    1257     IEMOP_BODY_BINARY_rm_rv_LOCKED(iemAImpl_sbb_u16_locked, iemAImpl_sbb_u32_locked, iemAImpl_sbb_u64_locked);
     1283    uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
     1284    IEMOP_BODY_BINARY_rm_rv_RW(    bRm, sbb, 0, 0);
     1285    IEMOP_BODY_BINARY_rm_rv_LOCKED(bRm, sbb);
    12581286}
    12591287
    … …  
    12671295{
    12681296    IEMOP_MNEMONIC2(RM, SBB, sbb, Gb, Eb, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES);
    1269     IEMOP_BODY_BINARY_r8_rm(iemAImpl_sbb_u8, sbb, 0);
     1297    uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
     1298    IEMOP_BODY_BINARY_r8_rm(bRm, sbb, 0);
    12701299}
    12711300
    … …  
    13481377    IEMOP_MNEMONIC2(MR, AND, and, Eb, Gb, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES | IEMOPHINT_LOCK_ALLOWED);
    13491378    IEMOP_VERIFICATION_UNDEFINED_EFLAGS(X86_EFL_AF);
    1350     IEMOP_BODY_BINARY_rm_r8_RW(iemAImpl_and_u8, iemAImpl_and_u8_locked, and, RT_ARCH_VAL_AMD64 | RT_ARCH_VAL_ARM64, 0);
     1379    uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
     1380    IEMOP_BODY_BINARY_rm_r8_RW(bRm, and, RT_ARCH_VAL_AMD64 | RT_ARCH_VAL_ARM64, 0);
    13511381}
    13521382
    … …  
    13611391    IEMOP_MNEMONIC2(MR, AND, and, Ev, Gv, DISOPTYPE_HARMLESS, IEMOPHINT_LOCK_ALLOWED);
    13621392    IEMOP_VERIFICATION_UNDEFINED_EFLAGS(X86_EFL_AF);
    1363     IEMOP_BODY_BINARY_rm_rv_RW(    iemAImpl_and_u16,        iemAImpl_and_u32,        iemAImpl_and_u64,       and, RT_ARCH_VAL_AMD64 | RT_ARCH_VAL_ARM64, 0);
    1364     IEMOP_BODY_BINARY_rm_rv_LOCKED(iemAImpl_and_u16_locked, iemAImpl_and_u32_locked, iemAImpl_and_u64_locked);
     1393    uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
     1394    IEMOP_BODY_BINARY_rm_rv_RW(    bRm, and, RT_ARCH_VAL_AMD64 | RT_ARCH_VAL_ARM64, 0);
     1395    IEMOP_BODY_BINARY_rm_rv_LOCKED(bRm, and);
    13651396}
    13661397
    … …  
    13751406    IEMOP_MNEMONIC2(RM, AND, and, Gb, Eb, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES);
    13761407    IEMOP_VERIFICATION_UNDEFINED_EFLAGS(X86_EFL_AF);
    1377     IEMOP_BODY_BINARY_r8_rm(iemAImpl_and_u8, and, RT_ARCH_VAL_AMD64 | RT_ARCH_VAL_ARM64);
     1408    uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
     1409    IEMOP_BODY_BINARY_r8_rm(bRm, and, RT_ARCH_VAL_AMD64 | RT_ARCH_VAL_ARM64);
    13781410}
    13791411
    … …  
    14631495{
    14641496    IEMOP_MNEMONIC2(MR, SUB, sub, Eb, Gb, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES | IEMOPHINT_LOCK_ALLOWED);
    1465     IEMOP_BODY_BINARY_rm_r8_RW(iemAImpl_sub_u8, iemAImpl_sub_u8_locked, sub, RT_ARCH_VAL_AMD64 | RT_ARCH_VAL_ARM64, 0);
     1497    uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
     1498    IEMOP_BODY_BINARY_r8_SAME_REG_ZERO(bRm); /* Special case: sub samereg, samereg - zeros samereg and sets EFLAGS to know value */
     1499    IEMOP_BODY_BINARY_rm_r8_RW(bRm, sub, RT_ARCH_VAL_AMD64 | RT_ARCH_VAL_ARM64, 0);
    14661500}
    14671501
    … …  
    14751509{
    14761510    IEMOP_MNEMONIC2(MR, SUB, sub, Ev, Gv, DISOPTYPE_HARMLESS, IEMOPHINT_LOCK_ALLOWED);
    1477     IEMOP_BODY_BINARY_rm_rv_RW(    iemAImpl_sub_u16,        iemAImpl_sub_u32,        iemAImpl_sub_u64,       sub, RT_ARCH_VAL_AMD64 | RT_ARCH_VAL_ARM64, 0);
    1478     IEMOP_BODY_BINARY_rm_rv_LOCKED(iemAImpl_sub_u16_locked, iemAImpl_sub_u32_locked, iemAImpl_sub_u64_locked);
     1511    uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
     1512    IEMOP_BODY_BINARY_rv_SAME_REG_ZERO(bRm); /* Special case: sub samereg, samereg - zeros samereg and sets EFLAGS to know value */
     1513    IEMOP_BODY_BINARY_rm_rv_RW(    bRm, sub, RT_ARCH_VAL_AMD64 | RT_ARCH_VAL_ARM64, 0);
     1514    IEMOP_BODY_BINARY_rm_rv_LOCKED(bRm, sub);
    14791515}
    14801516
    … …  
    14871523FNIEMOP_DEF(iemOp_sub_Gb_Eb)
    14881524{
    1489     /** @todo sub reg,samreg   */
    14901525    IEMOP_MNEMONIC2(RM, SUB, sub, Gb, Eb, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES);
    1491     IEMOP_BODY_BINARY_r8_rm(iemAImpl_sub_u8, sub, RT_ARCH_VAL_AMD64 | RT_ARCH_VAL_ARM64);
     1526    uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
     1527    IEMOP_BODY_BINARY_r8_SAME_REG_ZERO(bRm); /* Special case: sub samereg, samereg - zeros samereg and sets EFLAGS to know value */
     1528    IEMOP_BODY_BINARY_r8_rm(bRm, sub, RT_ARCH_VAL_AMD64 | RT_ARCH_VAL_ARM64);
    14921529}
    14931530
    … …  
    15021539    IEMOP_MNEMONIC2(RM, SUB, sub, Gv, Ev, DISOPTYPE_HARMLESS, 0);
    15031540    uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
     1541    IEMOP_BODY_BINARY_rv_SAME_REG_ZERO(bRm); /* Special case: sub samereg, samereg - zeros samereg and sets EFLAGS to know value */
    15041542    IEMOP_BODY_BINARY_rv_rm(bRm, iemAImpl_sub_u16, iemAImpl_sub_u32, iemAImpl_sub_u64, 1, 0, sub, RT_ARCH_VAL_AMD64 | RT_ARCH_VAL_ARM64);
    15051543}
    … …  
    15751613    IEMOP_MNEMONIC2(MR, XOR, xor, Eb, Gb, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES | IEMOPHINT_LOCK_ALLOWED);
    15761614    IEMOP_VERIFICATION_UNDEFINED_EFLAGS(X86_EFL_AF);
    1577     IEMOP_BODY_BINARY_rm_r8_RW(iemAImpl_xor_u8, iemAImpl_xor_u8_locked, xor, RT_ARCH_VAL_AMD64 | RT_ARCH_VAL_ARM64, 0);
     1615    uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
     1616    IEMOP_BODY_BINARY_r8_SAME_REG_ZERO(bRm); /* Special case: xor samereg, samereg - zeros samereg and sets EFLAGS to know value */
     1617    IEMOP_BODY_BINARY_rm_r8_RW(bRm, xor, RT_ARCH_VAL_AMD64 | RT_ARCH_VAL_ARM64, 0);
    15781618}
    15791619
    … …  
    15881628    IEMOP_MNEMONIC2(MR, XOR, xor, Ev, Gv, DISOPTYPE_HARMLESS, IEMOPHINT_LOCK_ALLOWED);
    15891629    IEMOP_VERIFICATION_UNDEFINED_EFLAGS(X86_EFL_AF);
    1590     IEMOP_BODY_BINARY_rm_rv_RW(    iemAImpl_xor_u16,        iemAImpl_xor_u32,        iemAImpl_xor_u64,       xor, RT_ARCH_VAL_AMD64 | RT_ARCH_VAL_ARM64, 0);
    1591     IEMOP_BODY_BINARY_rm_rv_LOCKED(iemAImpl_xor_u16_locked, iemAImpl_xor_u32_locked, iemAImpl_xor_u64_locked);
     1630    uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
     1631    IEMOP_BODY_BINARY_rm_rv_RW(        bRm, xor, RT_ARCH_VAL_AMD64 | RT_ARCH_VAL_ARM64, 0);
     1632    IEMOP_BODY_BINARY_rv_SAME_REG_ZERO(bRm); /* Special case: xor samereg, samereg - zeros samereg and sets EFLAGS to know value */
     1633    IEMOP_BODY_BINARY_rm_rv_LOCKED(    bRm, xor);
    15921634}
    15931635
    … …  
    16021644    IEMOP_MNEMONIC2(RM, XOR, xor, Gb, Eb, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES);
    16031645    IEMOP_VERIFICATION_UNDEFINED_EFLAGS(X86_EFL_AF);
    1604     /** @todo xor al,al optimization   */
    1605     IEMOP_BODY_BINARY_r8_rm(iemAImpl_xor_u8, xor, RT_ARCH_VAL_AMD64 | RT_ARCH_VAL_ARM64);
     1646    uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
     1647    IEMOP_BODY_BINARY_r8_SAME_REG_ZERO(bRm); /* Special case: xor samereg, samereg - zeros samereg and sets EFLAGS to know value */
     1648    IEMOP_BODY_BINARY_r8_rm(bRm, xor, RT_ARCH_VAL_AMD64 | RT_ARCH_VAL_ARM64);
    16061649}
    16071650
    … …  
    16161659    IEMOP_MNEMONIC2(RM, XOR, xor, Gv, Ev, DISOPTYPE_HARMLESS, 0);
    16171660    IEMOP_VERIFICATION_UNDEFINED_EFLAGS(X86_EFL_AF);
    1618 
    16191661    uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
    1620 
    1621     /*
    1622      * Deal with special case of 'xor rN, rN' which sets rN to zero and has a known EFLAGS outcome.
    1623      */
    1624     if (   (bRm >> X86_MODRM_REG_SHIFT) == ((bRm & X86_MODRM_RM_MASK) | (X86_MOD_REG << X86_MODRM_REG_SHIFT))
    1625         && pVCpu->iem.s.uRexReg == pVCpu->iem.s.uRexB)
    1626     {
    1627         switch (pVCpu->iem.s.enmEffOpSize)
    1628         {
    1629             case IEMMODE_16BIT:
    1630                 IEM_MC_BEGIN(1, 0, 0, 0);
    1631                 IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
    1632                 IEM_MC_STORE_GREG_U16_CONST(IEM_GET_MODRM_RM(pVCpu, bRm), 0);
    1633                 IEM_MC_LOCAL(uint32_t, fEFlags);
    1634                 IEM_MC_FETCH_EFLAGS(fEFlags);
    1635                 IEM_MC_AND_LOCAL_U32(fEFlags, ~(uint32_t)X86_EFL_STATUS_BITS);
    1636                 IEM_MC_OR_LOCAL_U32(fEFlags, X86_EFL_PF | X86_EFL_ZF);
    1637                 IEM_MC_COMMIT_EFLAGS(fEFlags);
    1638                 IEM_MC_ADVANCE_RIP_AND_FINISH();
    1639                 IEM_MC_END();
    1640                 break;
    1641 
    1642             case IEMMODE_32BIT:
    1643                 IEM_MC_BEGIN(1, 0, IEM_MC_F_MIN_386, 0);
    1644                 IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
    1645                 IEM_MC_STORE_GREG_U32_CONST(IEM_GET_MODRM_RM(pVCpu, bRm), 0);
    1646                 IEM_MC_LOCAL(uint32_t, fEFlags);
    1647                 IEM_MC_FETCH_EFLAGS(fEFlags);
    1648                 IEM_MC_AND_LOCAL_U32(fEFlags, ~(uint32_t)X86_EFL_STATUS_BITS);
    1649                 IEM_MC_OR_LOCAL_U32(fEFlags, X86_EFL_PF | X86_EFL_ZF);
    1650                 IEM_MC_COMMIT_EFLAGS(fEFlags);
    1651                 IEM_MC_ADVANCE_RIP_AND_FINISH();
    1652                 IEM_MC_END();
    1653                 break;
    1654 
    1655             case IEMMODE_64BIT:
    1656                 IEM_MC_BEGIN(1, 0, IEM_MC_F_64BIT, 0);
    1657                 IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
    1658                 IEM_MC_STORE_GREG_U64_CONST(IEM_GET_MODRM_RM(pVCpu, bRm), 0);
    1659                 IEM_MC_LOCAL(uint32_t, fEFlags);
    1660                 IEM_MC_FETCH_EFLAGS(fEFlags);
    1661                 IEM_MC_AND_LOCAL_U32(fEFlags, ~(uint32_t)X86_EFL_STATUS_BITS);
    1662                 IEM_MC_OR_LOCAL_U32(fEFlags, X86_EFL_PF | X86_EFL_ZF);
    1663                 IEM_MC_COMMIT_EFLAGS(fEFlags);
    1664                 IEM_MC_ADVANCE_RIP_AND_FINISH();
    1665                 IEM_MC_END();
    1666                 break;
    1667 
    1668             IEM_NOT_REACHED_DEFAULT_CASE_RET();
    1669         }
    1670     }
    1671 
     1662    IEMOP_BODY_BINARY_rv_SAME_REG_ZERO(bRm); /* Special case: xor samereg, samereg - zeros samereg and sets EFLAGS to know value */
    16721663    IEMOP_BODY_BINARY_rv_rm(bRm, iemAImpl_xor_u16, iemAImpl_xor_u32, iemAImpl_xor_u64, 1, 0, xor, RT_ARCH_VAL_AMD64 | RT_ARCH_VAL_ARM64);
    16731664}
    … …  
    18001791{
    18011792    IEMOP_MNEMONIC(cmp_Gb_Eb, "cmp Gb,Eb");
    1802     IEMOP_BODY_BINARY_r8_rm(iemAImpl_cmp_u8, cmp, RT_ARCH_VAL_AMD64 | RT_ARCH_VAL_ARM64);
     1793    uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
     1794    IEMOP_BODY_BINARY_r8_rm(bRm, cmp, RT_ARCH_VAL_AMD64 | RT_ARCH_VAL_ARM64);
    18031795}
    18041796

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

    r103613 r103678  
    12881288                    self.aoParamRefs.append(ThreadedParamRef(oStmt.sFn, self.analyzeCallToType(oStmt.sFn), oStmt, oStmt.idxFn));
    12891289                elif (    oStmt.sFn[0] != 'i'
     1290                      and not oStmt.sFn.startswith('RT_CONCAT3')
    12901291                      and not oStmt.sFn.startswith('IEMTARGETCPU_EFL_BEHAVIOR_SELECT')
    12911292                      and not oStmt.sFn.startswith('IEM_SELECT_HOST_OR_FALLBACK') ):
Note: See TracChangeset for help on using the changeset viewer.

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