VirtualBox

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


Ignore:
Timestamp:
Aug 9, 2023 2:17:40 PM (19 months ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
158731
Message:

VMM/IEM: Added the U16, U32 and U64 IEM_MC_MEM_MAP_XXX variants and started converting the code to use them. bugref:10369

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

Legend:

Unmodified
Added
Removed

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

    r100826 r100831  
    10121012 */
    10131013
    1014 IEM_DECL_IMPL_DEF(void, iemAImpl_cmp_u64,(uint64_t *puDst, uint64_t uSrc, uint32_t *pfEFlags))
     1014IEM_DECL_IMPL_DEF(void, iemAImpl_cmp_u64,(uint64_t const *puDst, uint64_t uSrc, uint32_t *pfEFlags))
    10151015{
    10161016    uint64_t uDstTmp = *puDst;
    … …  
    10201020# if !defined(RT_ARCH_X86) || defined(IEM_WITHOUT_ASSEMBLY)
    10211021
    1022 IEM_DECL_IMPL_DEF(void, iemAImpl_cmp_u32,(uint32_t *puDst, uint32_t uSrc, uint32_t *pfEFlags))
     1022IEM_DECL_IMPL_DEF(void, iemAImpl_cmp_u32,(uint32_t const *puDst, uint32_t uSrc, uint32_t *pfEFlags))
    10231023{
    10241024    uint32_t uDstTmp = *puDst;
    … …  
    10271027
    10281028
    1029 IEM_DECL_IMPL_DEF(void, iemAImpl_cmp_u16,(uint16_t *puDst, uint16_t uSrc, uint32_t *pfEFlags))
     1029IEM_DECL_IMPL_DEF(void, iemAImpl_cmp_u16,(uint16_t const *puDst, uint16_t uSrc, uint32_t *pfEFlags))
    10301030{
    10311031    uint16_t uDstTmp = *puDst;
    … …  
    10461046 */
    10471047
    1048 IEM_DECL_IMPL_DEF(void, iemAImpl_test_u64,(uint64_t *puDst, uint64_t uSrc, uint32_t *pfEFlags))
     1048IEM_DECL_IMPL_DEF(void, iemAImpl_test_u64,(uint64_t const *puDst, uint64_t uSrc, uint32_t *pfEFlags))
    10491049{
    10501050    uint64_t uResult = *puDst & uSrc;
    … …  
    10541054# if !defined(RT_ARCH_X86) || defined(IEM_WITHOUT_ASSEMBLY)
    10551055
    1056 IEM_DECL_IMPL_DEF(void, iemAImpl_test_u32,(uint32_t *puDst, uint32_t uSrc, uint32_t *pfEFlags))
     1056IEM_DECL_IMPL_DEF(void, iemAImpl_test_u32,(uint32_t const *puDst, uint32_t uSrc, uint32_t *pfEFlags))
    10571057{
    10581058    uint32_t uResult = *puDst & uSrc;
    … …  
    10611061
    10621062
    1063 IEM_DECL_IMPL_DEF(void, iemAImpl_test_u16,(uint16_t *puDst, uint16_t uSrc, uint32_t *pfEFlags))
     1063IEM_DECL_IMPL_DEF(void, iemAImpl_test_u16,(uint16_t const *puDst, uint16_t uSrc, uint32_t *pfEFlags))
    10641064{
    10651065    uint16_t uResult = *puDst & uSrc;

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

    r100826 r100831  
    261261 * memory/register as the destination.
    262262 */
    263 #define IEMOP_BODY_BINARY_rm_rv(a_fnNormalU16, a_fnNormalU32, a_fnNormalU64, a_fRW) \
     263#define IEMOP_BODY_BINARY_rm_rv_RW(a_fnNormalU16, a_fnNormalU32, a_fnNormalU64) \
    264264    uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm); \
    265265    \
    … …  
    299299                IEM_MC_CALL_VOID_AIMPL_3(a_fnNormalU32, pu32Dst, u32Src, pEFlags); \
    300300                \
    301                 if ((a_fRW) == IEM_ACCESS_DATA_RW) /* not TEST and CMP */ \
    302                     IEM_MC_CLEAR_HIGH_GREG_U64_BY_REF(pu32Dst); \
     301                IEM_MC_CLEAR_HIGH_GREG_U64_BY_REF(pu32Dst); \
    303302                IEM_MC_ADVANCE_RIP_AND_FINISH(); \
    304303                IEM_MC_END(); \
    … …  
    336335            { \
    337336                case IEMMODE_16BIT: \
    338                     IEM_MC_BEGIN(3, 2); \
     337                    IEM_MC_BEGIN(3, 3); \
    339338                    IEM_MC_ARG(uint16_t *, pu16Dst,          0); \
    340339                    IEM_MC_ARG(uint16_t,   u16Src,           1); \
    341340                    IEM_MC_ARG_LOCAL_EFLAGS(pEFlags, EFlags, 2); \
    342341                    IEM_MC_LOCAL(RTGCPTR, GCPtrEffDst); \
     342                    IEM_MC_LOCAL(uint8_t, bUnmapInfo); \
    343343                    \
    344344                    IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 0); \
    345345                    IEMOP_HLP_DONE_DECODING(); \
    346                     IEM_MC_MEM_MAP(pu16Dst, a_fRW, pVCpu->iem.s.iEffSeg, GCPtrEffDst, 0 /*arg*/); \
     346                    IEM_MC_MEM_MAP_U16_RW(pu16Dst, bUnmapInfo, pVCpu->iem.s.iEffSeg, GCPtrEffDst); \
    347347                    IEM_MC_FETCH_GREG_U16(u16Src, IEM_GET_MODRM_REG(pVCpu, bRm)); \
    348348                    IEM_MC_FETCH_EFLAGS(EFlags); \
    349349                    IEM_MC_CALL_VOID_AIMPL_3(a_fnNormalU16, pu16Dst, u16Src, pEFlags); \
    350350                    \
    351                     IEM_MC_MEM_COMMIT_AND_UNMAP(pu16Dst, a_fRW); \
     351                    IEM_MC_MEM_COMMIT_AND_UNMAP_RW(pu16Dst, bUnmapInfo); \
    352352                    IEM_MC_COMMIT_EFLAGS(EFlags); \
    353353                    IEM_MC_ADVANCE_RIP_AND_FINISH(); \
    … …  
    356356                \
    357357                case IEMMODE_32BIT: \
    358                     IEM_MC_BEGIN(3, 2); \
     358                    IEM_MC_BEGIN(3, 3); \
    359359                    IEM_MC_ARG(uint32_t *, pu32Dst,          0); \
    360360                    IEM_MC_ARG(uint32_t,   u32Src,           1); \
    361361                    IEM_MC_ARG_LOCAL_EFLAGS(pEFlags, EFlags, 2); \
    362362                    IEM_MC_LOCAL(RTGCPTR, GCPtrEffDst); \
     363                    IEM_MC_LOCAL(uint8_t, bUnmapInfo); \
    363364                    \
    364365                    IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 0); \
    365366                    IEMOP_HLP_DONE_DECODING(); \
    366                     IEM_MC_MEM_MAP(pu32Dst, a_fRW, pVCpu->iem.s.iEffSeg, GCPtrEffDst, 0 /*arg*/); \
     367                    IEM_MC_MEM_MAP_U32_RW(pu32Dst, bUnmapInfo, pVCpu->iem.s.iEffSeg, GCPtrEffDst); \
    367368                    IEM_MC_FETCH_GREG_U32(u32Src, IEM_GET_MODRM_REG(pVCpu, bRm)); \
    368369                    IEM_MC_FETCH_EFLAGS(EFlags); \
    369370                    IEM_MC_CALL_VOID_AIMPL_3(a_fnNormalU32, pu32Dst, u32Src, pEFlags); \
    370371                    \
    371                     IEM_MC_MEM_COMMIT_AND_UNMAP(pu32Dst, a_fRW); \
     372                    IEM_MC_MEM_COMMIT_AND_UNMAP_RW(pu32Dst, bUnmapInfo); \
    372373                    IEM_MC_COMMIT_EFLAGS(EFlags); \
    373374                    IEM_MC_ADVANCE_RIP_AND_FINISH(); \
    … …  
    376377                \
    377378                case IEMMODE_64BIT: \
    378                     IEM_MC_BEGIN(3, 2); \
     379                    IEM_MC_BEGIN(3, 3); \
    379380                    IEM_MC_ARG(uint64_t *, pu64Dst,          0); \
    380381                    IEM_MC_ARG(uint64_t,   u64Src,           1); \
    381382                    IEM_MC_ARG_LOCAL_EFLAGS(pEFlags, EFlags, 2); \
    382383                    IEM_MC_LOCAL(RTGCPTR, GCPtrEffDst); \
     384                    IEM_MC_LOCAL(uint8_t, bUnmapInfo); \
    383385                    \
    384386                    IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 0); \
    385387                    IEMOP_HLP_DONE_DECODING(); \
    386                     IEM_MC_MEM_MAP(pu64Dst, a_fRW, pVCpu->iem.s.iEffSeg, GCPtrEffDst, 0 /*arg*/); \
     388                    IEM_MC_MEM_MAP_U64_RW(pu64Dst, bUnmapInfo, pVCpu->iem.s.iEffSeg, GCPtrEffDst); \
    387389                    IEM_MC_FETCH_GREG_U64(u64Src, IEM_GET_MODRM_REG(pVCpu, bRm)); \
    388390                    IEM_MC_FETCH_EFLAGS(EFlags); \
    389391                    IEM_MC_CALL_VOID_AIMPL_3(a_fnNormalU64, pu64Dst, u64Src, pEFlags); \
    390392                    \
    391                     IEM_MC_MEM_COMMIT_AND_UNMAP(pu64Dst, a_fRW); \
     393                    IEM_MC_MEM_COMMIT_AND_UNMAP_RW(pu64Dst, bUnmapInfo); \
    392394                    IEM_MC_COMMIT_EFLAGS(EFlags); \
    393395                    IEM_MC_ADVANCE_RIP_AND_FINISH(); \
    … …  
    401403        { \
    402404            (void)0
    403 
    404 #define IEMOP_BODY_BINARY_rm_rv_NO_LOCK() \
    405             IEMOP_HLP_DONE_DECODING(); \
    406             IEMOP_RAISE_INVALID_LOCK_PREFIX_RET(); \
    407         } \
    408     } \
    409     (void)0
    410 
     405/* Separate macro to work around parsing issue in IEMAllInstPython.py */
    411406#define IEMOP_BODY_BINARY_rm_rv_LOCKED(a_fnLockedU16, a_fnLockedU32, a_fnLockedU64) \
    412407            switch (pVCpu->iem.s.enmEffOpSize) \
    413408            { \
    414409                case IEMMODE_16BIT: \
    415                     IEM_MC_BEGIN(3, 2); \
     410                    IEM_MC_BEGIN(3, 3); \
    416411                    IEM_MC_ARG(uint16_t *, pu16Dst,          0); \
    417412                    IEM_MC_ARG(uint16_t,   u16Src,           1); \
    418413                    IEM_MC_ARG_LOCAL_EFLAGS(pEFlags, EFlags, 2); \
    419414                    IEM_MC_LOCAL(RTGCPTR, GCPtrEffDst); \
     415                    IEM_MC_LOCAL(uint8_t, bUnmapInfo); \
    420416                    \
    421417                    IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 0); \
    422418                    IEMOP_HLP_DONE_DECODING(); \
    423                     IEM_MC_MEM_MAP(pu16Dst, IEM_ACCESS_DATA_RW, pVCpu->iem.s.iEffSeg, GCPtrEffDst, 0 /*arg*/); \
     419                    IEM_MC_MEM_MAP_U16_RW(pu16Dst, bUnmapInfo, pVCpu->iem.s.iEffSeg, GCPtrEffDst); \
    424420                    IEM_MC_FETCH_GREG_U16(u16Src, IEM_GET_MODRM_REG(pVCpu, bRm)); \
    425421                    IEM_MC_FETCH_EFLAGS(EFlags); \
    426422                    IEM_MC_CALL_VOID_AIMPL_3(a_fnLockedU16, pu16Dst, u16Src, pEFlags); \
    427423                    \
    428                     IEM_MC_MEM_COMMIT_AND_UNMAP(pu16Dst, IEM_ACCESS_DATA_RW); \
     424                    IEM_MC_MEM_COMMIT_AND_UNMAP_RW(pu16Dst, bUnmapInfo); \
    429425                    IEM_MC_COMMIT_EFLAGS(EFlags); \
    430426                    IEM_MC_ADVANCE_RIP_AND_FINISH(); \
    … …  
    433429                \
    434430                case IEMMODE_32BIT: \
    435                     IEM_MC_BEGIN(3, 2); \
     431                    IEM_MC_BEGIN(3, 3); \
    436432                    IEM_MC_ARG(uint32_t *, pu32Dst,          0); \
    437433                    IEM_MC_ARG(uint32_t,   u32Src,           1); \
    438434                    IEM_MC_ARG_LOCAL_EFLAGS(pEFlags, EFlags, 2); \
    439435                    IEM_MC_LOCAL(RTGCPTR, GCPtrEffDst); \
     436                    IEM_MC_LOCAL(uint8_t, bUnmapInfo); \
    440437                    \
    441438                    IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 0); \
    442439                    IEMOP_HLP_DONE_DECODING(); \
    443                     IEM_MC_MEM_MAP(pu32Dst, IEM_ACCESS_DATA_RW, pVCpu->iem.s.iEffSeg, GCPtrEffDst, 0 /*arg*/); \
     440                    IEM_MC_MEM_MAP_U32_RW(pu32Dst, bUnmapInfo, pVCpu->iem.s.iEffSeg, GCPtrEffDst); \
    444441                    IEM_MC_FETCH_GREG_U32(u32Src, IEM_GET_MODRM_REG(pVCpu, bRm)); \
    445442                    IEM_MC_FETCH_EFLAGS(EFlags); \
    446443                    IEM_MC_CALL_VOID_AIMPL_3(a_fnLockedU32, pu32Dst, u32Src, pEFlags); \
    447444                    \
    448                     IEM_MC_MEM_COMMIT_AND_UNMAP(pu32Dst, IEM_ACCESS_DATA_RW /* CMP,TEST */); \
     445                    IEM_MC_MEM_COMMIT_AND_UNMAP_RW(pu32Dst, bUnmapInfo /* CMP,TEST */); \
    449446                    IEM_MC_COMMIT_EFLAGS(EFlags); \
    450447                    IEM_MC_ADVANCE_RIP_AND_FINISH(); \
    … …  
    453450                \
    454451                case IEMMODE_64BIT: \
    455                     IEM_MC_BEGIN(3, 2); \
     452                    IEM_MC_BEGIN(3, 3); \
    456453                    IEM_MC_ARG(uint64_t *, pu64Dst,          0); \
    457454                    IEM_MC_ARG(uint64_t,   u64Src,           1); \
    458455                    IEM_MC_ARG_LOCAL_EFLAGS(pEFlags, EFlags, 2); \
    459456                    IEM_MC_LOCAL(RTGCPTR, GCPtrEffDst); \
     457                    IEM_MC_LOCAL(uint8_t, bUnmapInfo); \
    460458                    \
    461459                    IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 0); \
    462460                    IEMOP_HLP_DONE_DECODING(); \
    463                     IEM_MC_MEM_MAP(pu64Dst, IEM_ACCESS_DATA_RW, pVCpu->iem.s.iEffSeg, GCPtrEffDst, 0 /*arg*/); \
     461                    IEM_MC_MEM_MAP_U64_RW(pu64Dst, bUnmapInfo, pVCpu->iem.s.iEffSeg, GCPtrEffDst); \
    464462                    IEM_MC_FETCH_GREG_U64(u64Src, IEM_GET_MODRM_REG(pVCpu, bRm)); \
    465463                    IEM_MC_FETCH_EFLAGS(EFlags); \
    466464                    IEM_MC_CALL_VOID_AIMPL_3(a_fnLockedU64, pu64Dst, u64Src, pEFlags); \
    467465                    \
    468                     IEM_MC_MEM_COMMIT_AND_UNMAP(pu64Dst, IEM_ACCESS_DATA_RW); \
     466                    IEM_MC_MEM_COMMIT_AND_UNMAP_RW(pu64Dst, bUnmapInfo); \
    469467                    IEM_MC_COMMIT_EFLAGS(EFlags); \
    470468                    IEM_MC_ADVANCE_RIP_AND_FINISH(); \
    … …  
    474472                IEM_NOT_REACHED_DEFAULT_CASE_RET(); \
    475473            } \
     474        } \
     475    } \
     476    (void)0
     477
     478/**
     479 * Body for read-only word/dword/qword instructions like TEST and CMP with
     480 * memory/register as the destination.
     481 */
     482#define IEMOP_BODY_BINARY_rm_rv_RO(a_fnNormalU16, a_fnNormalU32, a_fnNormalU64) \
     483    uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm); \
     484    \
     485    /* \
     486     * If rm is denoting a register, no more instruction bytes. \
     487     */ \
     488    if (IEM_IS_MODRM_REG_MODE(bRm)) \
     489    { \
     490        switch (pVCpu->iem.s.enmEffOpSize) \
     491        { \
     492            case IEMMODE_16BIT: \
     493                IEM_MC_BEGIN(3, 0); \
     494                IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX(); \
     495                IEM_MC_ARG(uint16_t *, pu16Dst, 0); \
     496                IEM_MC_ARG(uint16_t,   u16Src,  1); \
     497                IEM_MC_ARG(uint32_t *, pEFlags, 2); \
     498                \
     499                IEM_MC_FETCH_GREG_U16(u16Src, IEM_GET_MODRM_REG(pVCpu, bRm)); \
     500                IEM_MC_REF_GREG_U16(pu16Dst, IEM_GET_MODRM_RM(pVCpu, bRm)); \
     501                IEM_MC_REF_EFLAGS(pEFlags); \
     502                IEM_MC_CALL_VOID_AIMPL_3(a_fnNormalU16, pu16Dst, u16Src, pEFlags); \
     503                \
     504                IEM_MC_ADVANCE_RIP_AND_FINISH(); \
     505                IEM_MC_END(); \
     506                break; \
     507            \
     508            case IEMMODE_32BIT: \
     509                IEM_MC_BEGIN(3, 0); \
     510                IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX(); \
     511                IEM_MC_ARG(uint32_t *, pu32Dst, 0); \
     512                IEM_MC_ARG(uint32_t,   u32Src,  1); \
     513                IEM_MC_ARG(uint32_t *, pEFlags, 2); \
     514                \
     515                IEM_MC_FETCH_GREG_U32(u32Src, IEM_GET_MODRM_REG(pVCpu, bRm)); \
     516                IEM_MC_REF_GREG_U32(pu32Dst, IEM_GET_MODRM_RM(pVCpu, bRm)); \
     517                IEM_MC_REF_EFLAGS(pEFlags); \
     518                IEM_MC_CALL_VOID_AIMPL_3(a_fnNormalU32, pu32Dst, u32Src, pEFlags); \
     519                \
     520                IEM_MC_ADVANCE_RIP_AND_FINISH(); \
     521                IEM_MC_END(); \
     522                break; \
     523            \
     524            case IEMMODE_64BIT: \
     525                IEM_MC_BEGIN(3, 0); \
     526                IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX(); \
     527                IEM_MC_ARG(uint64_t *, pu64Dst, 0); \
     528                IEM_MC_ARG(uint64_t,   u64Src,  1); \
     529                IEM_MC_ARG(uint32_t *, pEFlags, 2); \
     530                \
     531                IEM_MC_FETCH_GREG_U64(u64Src, IEM_GET_MODRM_REG(pVCpu, bRm)); \
     532                IEM_MC_REF_GREG_U64(pu64Dst, IEM_GET_MODRM_RM(pVCpu, bRm)); \
     533                IEM_MC_REF_EFLAGS(pEFlags); \
     534                IEM_MC_CALL_VOID_AIMPL_3(a_fnNormalU64, pu64Dst, u64Src, pEFlags); \
     535                \
     536                IEM_MC_ADVANCE_RIP_AND_FINISH(); \
     537                IEM_MC_END(); \
     538                break; \
     539            \
     540            IEM_NOT_REACHED_DEFAULT_CASE_RET(); \
     541        } \
     542    } \
     543    else \
     544    { \
     545        /* \
     546         * We're accessing memory. \
     547         * Note! We're putting the eflags on the stack here so we can commit them \
     548         *       after the memory. \
     549         */ \
     550        if (!(pVCpu->iem.s.fPrefixes & IEM_OP_PRF_LOCK)) \
     551        { \
     552            switch (pVCpu->iem.s.enmEffOpSize) \
     553            { \
     554                case IEMMODE_16BIT: \
     555                    IEM_MC_BEGIN(3, 3); \
     556                    IEM_MC_ARG(uint16_t const *, pu16Dst,         0); \
     557                    IEM_MC_ARG(uint16_t,         u16Src,          1); \
     558                    IEM_MC_ARG_LOCAL_EFLAGS(     pEFlags, EFlags, 2); \
     559                    IEM_MC_LOCAL(RTGCPTR, GCPtrEffDst); \
     560                    IEM_MC_LOCAL(uint8_t, bUnmapInfo); \
     561                    \
     562                    IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 0); \
     563                    IEMOP_HLP_DONE_DECODING(); \
     564                    IEM_MC_MEM_MAP_U16_RO(pu16Dst, bUnmapInfo, pVCpu->iem.s.iEffSeg, GCPtrEffDst); \
     565                    IEM_MC_FETCH_GREG_U16(u16Src, IEM_GET_MODRM_REG(pVCpu, bRm)); \
     566                    IEM_MC_FETCH_EFLAGS(EFlags); \
     567                    IEM_MC_CALL_VOID_AIMPL_3(a_fnNormalU16, pu16Dst, u16Src, pEFlags); \
     568                    \
     569                    IEM_MC_MEM_COMMIT_AND_UNMAP_RO(pu16Dst, bUnmapInfo); \
     570                    IEM_MC_COMMIT_EFLAGS(EFlags); \
     571                    IEM_MC_ADVANCE_RIP_AND_FINISH(); \
     572                    IEM_MC_END(); \
     573                    break; \
     574                \
     575                case IEMMODE_32BIT: \
     576                    IEM_MC_BEGIN(3, 3); \
     577                    IEM_MC_ARG(uint32_t const *, pu32Dst,         0); \
     578                    IEM_MC_ARG(uint32_t,         u32Src,          1); \
     579                    IEM_MC_ARG_LOCAL_EFLAGS(     pEFlags, EFlags, 2); \
     580                    IEM_MC_LOCAL(RTGCPTR, GCPtrEffDst); \
     581                    IEM_MC_LOCAL(uint8_t, bUnmapInfo); \
     582                    \
     583                    IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 0); \
     584                    IEMOP_HLP_DONE_DECODING(); \
     585                    IEM_MC_MEM_MAP_U32_RO(pu32Dst, bUnmapInfo, pVCpu->iem.s.iEffSeg, GCPtrEffDst); \
     586                    IEM_MC_FETCH_GREG_U32(u32Src, IEM_GET_MODRM_REG(pVCpu, bRm)); \
     587                    IEM_MC_FETCH_EFLAGS(EFlags); \
     588                    IEM_MC_CALL_VOID_AIMPL_3(a_fnNormalU32, pu32Dst, u32Src, pEFlags); \
     589                    \
     590                    IEM_MC_MEM_COMMIT_AND_UNMAP_RO(pu32Dst, bUnmapInfo); \
     591                    IEM_MC_COMMIT_EFLAGS(EFlags); \
     592                    IEM_MC_ADVANCE_RIP_AND_FINISH(); \
     593                    IEM_MC_END(); \
     594                    break; \
     595                \
     596                case IEMMODE_64BIT: \
     597                    IEM_MC_BEGIN(3, 3); \
     598                    IEM_MC_ARG(uint64_t const *, pu64Dst,         0); \
     599                    IEM_MC_ARG(uint64_t,         u64Src,          1); \
     600                    IEM_MC_ARG_LOCAL_EFLAGS(     pEFlags, EFlags, 2); \
     601                    IEM_MC_LOCAL(RTGCPTR, GCPtrEffDst); \
     602                    IEM_MC_LOCAL(uint8_t, bUnmapInfo); \
     603                    \
     604                    IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 0); \
     605                    IEMOP_HLP_DONE_DECODING(); \
     606                    IEM_MC_MEM_MAP_U64_RO(pu64Dst, bUnmapInfo, pVCpu->iem.s.iEffSeg, GCPtrEffDst); \
     607                    IEM_MC_FETCH_GREG_U64(u64Src, IEM_GET_MODRM_REG(pVCpu, bRm)); \
     608                    IEM_MC_FETCH_EFLAGS(EFlags); \
     609                    IEM_MC_CALL_VOID_AIMPL_3(a_fnNormalU64, pu64Dst, u64Src, pEFlags); \
     610                    \
     611                    IEM_MC_MEM_COMMIT_AND_UNMAP_RO(pu64Dst, bUnmapInfo); \
     612                    IEM_MC_COMMIT_EFLAGS(EFlags); \
     613                    IEM_MC_ADVANCE_RIP_AND_FINISH(); \
     614                    IEM_MC_END(); \
     615                    break; \
     616                \
     617                IEM_NOT_REACHED_DEFAULT_CASE_RET(); \
     618            } \
     619        } \
     620        else \
     621        { \
     622            IEMOP_HLP_DONE_DECODING(); \
     623            IEMOP_RAISE_INVALID_LOCK_PREFIX_RET(); \
    476624        } \
    477625    } \
    … …  
    606754{
    607755    IEMOP_MNEMONIC2(MR, ADD, add, Ev, Gv, DISOPTYPE_HARMLESS, IEMOPHINT_LOCK_ALLOWED);
    608     IEMOP_BODY_BINARY_rm_rv(       iemAImpl_add_u16,        iemAImpl_add_u32,        iemAImpl_add_u64, IEM_ACCESS_DATA_RW);
     756    IEMOP_BODY_BINARY_rm_rv_RW(    iemAImpl_add_u16,        iemAImpl_add_u32,        iemAImpl_add_u64);
    609757    IEMOP_BODY_BINARY_rm_rv_LOCKED(iemAImpl_add_u16_locked, iemAImpl_add_u32_locked, iemAImpl_add_u64_locked);
    610758}
    … …  
    728876    IEMOP_MNEMONIC2(MR, OR, or, Ev, Gv, DISOPTYPE_HARMLESS, IEMOPHINT_LOCK_ALLOWED);
    729877    IEMOP_VERIFICATION_UNDEFINED_EFLAGS(X86_EFL_AF);
    730     IEMOP_BODY_BINARY_rm_rv(       iemAImpl_or_u16,        iemAImpl_or_u32,        iemAImpl_or_u64, IEM_ACCESS_DATA_RW);
     878    IEMOP_BODY_BINARY_rm_rv_RW(    iemAImpl_or_u16,        iemAImpl_or_u32,        iemAImpl_or_u64);
    731879    IEMOP_BODY_BINARY_rm_rv_LOCKED(iemAImpl_or_u16_locked, iemAImpl_or_u32_locked, iemAImpl_or_u64_locked);
    732880}
    … …  
    8921040{
    8931041    IEMOP_MNEMONIC2(MR, ADC, adc, Ev, Gv, DISOPTYPE_HARMLESS, IEMOPHINT_LOCK_ALLOWED);
    894     IEMOP_BODY_BINARY_rm_rv(       iemAImpl_adc_u16,        iemAImpl_adc_u32,        iemAImpl_adc_u64, IEM_ACCESS_DATA_RW);
     1042    IEMOP_BODY_BINARY_rm_rv_RW(    iemAImpl_adc_u16,        iemAImpl_adc_u32,        iemAImpl_adc_u64);
    8951043    IEMOP_BODY_BINARY_rm_rv_LOCKED(iemAImpl_adc_u16_locked, iemAImpl_adc_u32_locked, iemAImpl_adc_u64_locked);
    8961044}
    … …  
    10021150{
    10031151    IEMOP_MNEMONIC2(MR, SBB, sbb, Ev, Gv, DISOPTYPE_HARMLESS, IEMOPHINT_LOCK_ALLOWED);
    1004     IEMOP_BODY_BINARY_rm_rv(       iemAImpl_sbb_u16,        iemAImpl_sbb_u32,        iemAImpl_sbb_u64, IEM_ACCESS_DATA_RW);
     1152    IEMOP_BODY_BINARY_rm_rv_RW(    iemAImpl_sbb_u16,        iemAImpl_sbb_u32,        iemAImpl_sbb_u64);
    10051153    IEMOP_BODY_BINARY_rm_rv_LOCKED(iemAImpl_sbb_u16_locked, iemAImpl_sbb_u32_locked, iemAImpl_sbb_u64_locked);
    10061154}
    … …  
    11111259    IEMOP_MNEMONIC2(MR, AND, and, Ev, Gv, DISOPTYPE_HARMLESS, IEMOPHINT_LOCK_ALLOWED);
    11121260    IEMOP_VERIFICATION_UNDEFINED_EFLAGS(X86_EFL_AF);
    1113     IEMOP_BODY_BINARY_rm_rv(       iemAImpl_and_u16,        iemAImpl_and_u32,        iemAImpl_and_u64, IEM_ACCESS_DATA_RW);
     1261    IEMOP_BODY_BINARY_rm_rv_RW(    iemAImpl_and_u16,        iemAImpl_and_u32,        iemAImpl_and_u64);
    11141262    IEMOP_BODY_BINARY_rm_rv_LOCKED(iemAImpl_and_u16_locked, iemAImpl_and_u32_locked, iemAImpl_and_u64_locked);
    11151263}
    … …  
    12331381{
    12341382    IEMOP_MNEMONIC2(MR, SUB, sub, Ev, Gv, DISOPTYPE_HARMLESS, IEMOPHINT_LOCK_ALLOWED);
    1235     IEMOP_BODY_BINARY_rm_rv(       iemAImpl_sub_u16,        iemAImpl_sub_u32,        iemAImpl_sub_u64, IEM_ACCESS_DATA_RW);
     1383    IEMOP_BODY_BINARY_rm_rv_RW(    iemAImpl_sub_u16,        iemAImpl_sub_u32,        iemAImpl_sub_u64);
    12361384    IEMOP_BODY_BINARY_rm_rv_LOCKED(iemAImpl_sub_u16_locked, iemAImpl_sub_u32_locked, iemAImpl_sub_u64_locked);
    12371385}
    … …  
    13491497    IEMOP_MNEMONIC2(MR, XOR, xor, Ev, Gv, DISOPTYPE_HARMLESS, IEMOPHINT_LOCK_ALLOWED);
    13501498    IEMOP_VERIFICATION_UNDEFINED_EFLAGS(X86_EFL_AF);
    1351     IEMOP_BODY_BINARY_rm_rv(       iemAImpl_xor_u16,        iemAImpl_xor_u32,        iemAImpl_xor_u64, IEM_ACCESS_DATA_RW);
     1499    IEMOP_BODY_BINARY_rm_rv_RW(    iemAImpl_xor_u16,        iemAImpl_xor_u32,        iemAImpl_xor_u64);
    13521500    IEMOP_BODY_BINARY_rm_rv_LOCKED(iemAImpl_xor_u16_locked, iemAImpl_xor_u32_locked, iemAImpl_xor_u64_locked);
    13531501}
    … …  
    15001648{
    15011649    IEMOP_MNEMONIC(cmp_Ev_Gv, "cmp Ev,Gv");
    1502     IEMOP_BODY_BINARY_rm_rv(iemAImpl_cmp_u16, iemAImpl_cmp_u32, iemAImpl_cmp_u64, IEM_ACCESS_DATA_R);
    1503     IEMOP_BODY_BINARY_rm_rv_NO_LOCK();
     1650    IEMOP_BODY_BINARY_rm_rv_RO(iemAImpl_cmp_u16, iemAImpl_cmp_u32, iemAImpl_cmp_u64);
    15041651}
    15051652
    … …  
    46914838    IEMOP_MNEMONIC(test_Ev_Gv, "test Ev,Gv");
    46924839    IEMOP_VERIFICATION_UNDEFINED_EFLAGS(X86_EFL_AF);
    4693     IEMOP_BODY_BINARY_rm_rv(iemAImpl_test_u16, iemAImpl_test_u32, iemAImpl_test_u64, IEM_ACCESS_DATA_R);
    4694     IEMOP_BODY_BINARY_rm_rv_NO_LOCK();
     4840    IEMOP_BODY_BINARY_rm_rv_RO(iemAImpl_test_u16, iemAImpl_test_u32, iemAImpl_test_u64);
    46954841}
    46964842
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