VirtualBox

Changeset 99306 in vbox


Ignore:
Timestamp:
Apr 6, 2023 2:07:50 AM (2 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
156694
Message:

VMM/IEM: More work on processing MC blocks, mainly related to reducing number of parameters for MC blocks in threaded function mode. bugref:10369

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r99305 r99306  
    1064810648}
    1064910649
     10650#define IEMOP_BODY_BIT_Ev_Ib(a_fnNormalU16, a_fnNormalU32, a_fnNormalU64, a_fRW) \
     10651    IEMOP_VERIFICATION_UNDEFINED_EFLAGS(X86_EFL_OF | X86_EFL_SF | X86_EFL_ZF | X86_EFL_AF | X86_EFL_PF); \
     10652    \
     10653    if (IEM_IS_MODRM_REG_MODE(bRm)) \
     10654    { \
     10655        /* register destination. */ \
     10656        uint8_t bImm; IEM_OPCODE_GET_NEXT_U8(&bImm); \
     10657        IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX(); \
     10658        \
     10659        switch (pVCpu->iem.s.enmEffOpSize) \
     10660        { \
     10661            case IEMMODE_16BIT: \
     10662                IEM_MC_BEGIN(3, 0); \
     10663                IEM_MC_ARG(uint16_t *,      pu16Dst,                    0); \
     10664                IEM_MC_ARG_CONST(uint16_t,  u16Src, /*=*/ bImm & 0x0f,  1); \
     10665                IEM_MC_ARG(uint32_t *,      pEFlags,                    2); \
     10666                \
     10667                IEM_MC_REF_GREG_U16(pu16Dst, IEM_GET_MODRM_RM(pVCpu, bRm)); \
     10668                IEM_MC_REF_EFLAGS(pEFlags); \
     10669                IEM_MC_CALL_VOID_AIMPL_3(a_fnNormalU16, pu16Dst, u16Src, pEFlags); \
     10670                \
     10671                IEM_MC_ADVANCE_RIP_AND_FINISH(); \
     10672                IEM_MC_END(); \
     10673                break; \
     10674            \
     10675            case IEMMODE_32BIT: \
     10676                IEM_MC_BEGIN(3, 0); \
     10677                IEM_MC_ARG(uint32_t *,      pu32Dst,                    0); \
     10678                IEM_MC_ARG_CONST(uint32_t,  u32Src, /*=*/ bImm & 0x1f,  1); \
     10679                IEM_MC_ARG(uint32_t *,      pEFlags,                    2); \
     10680                \
     10681                IEM_MC_REF_GREG_U32(pu32Dst, IEM_GET_MODRM_RM(pVCpu, bRm)); \
     10682                IEM_MC_REF_EFLAGS(pEFlags); \
     10683                IEM_MC_CALL_VOID_AIMPL_3(a_fnNormalU32, pu32Dst, u32Src, pEFlags); \
     10684                \
     10685                IEM_MC_CLEAR_HIGH_GREG_U64_BY_REF(pu32Dst); \
     10686                IEM_MC_ADVANCE_RIP_AND_FINISH(); \
     10687                IEM_MC_END(); \
     10688                break; \
     10689            \
     10690            case IEMMODE_64BIT: \
     10691                IEM_MC_BEGIN(3, 0); \
     10692                IEM_MC_ARG(uint64_t *,      pu64Dst,                    0); \
     10693                IEM_MC_ARG_CONST(uint64_t,  u64Src, /*=*/ bImm & 0x3f,  1); \
     10694                IEM_MC_ARG(uint32_t *,      pEFlags,                    2); \
     10695                \
     10696                IEM_MC_REF_GREG_U64(pu64Dst, IEM_GET_MODRM_RM(pVCpu, bRm)); \
     10697                IEM_MC_REF_EFLAGS(pEFlags); \
     10698                IEM_MC_CALL_VOID_AIMPL_3(a_fnNormalU64, pu64Dst, u64Src, pEFlags); \
     10699                \
     10700                IEM_MC_ADVANCE_RIP_AND_FINISH(); \
     10701                IEM_MC_END(); \
     10702                break; \
     10703            \
     10704            IEM_NOT_REACHED_DEFAULT_CASE_RET(); \
     10705        } \
     10706    } \
     10707    else \
     10708    { \
     10709        /* memory destination. */ \
     10710        /** @todo test negative bit offsets! */ \
     10711        if (!(pVCpu->iem.s.fPrefixes & IEM_OP_PRF_LOCK)) \
     10712        { \
     10713            switch (pVCpu->iem.s.enmEffOpSize) \
     10714            { \
     10715                case IEMMODE_16BIT: \
     10716                    IEM_MC_BEGIN(3, 1); \
     10717                    IEM_MC_ARG(uint16_t *,              pu16Dst,                0); \
     10718                    IEM_MC_ARG(uint16_t,                u16Src,                 1); \
     10719                    IEM_MC_ARG_LOCAL_EFLAGS(            pEFlags, EFlags,        2); \
     10720                    IEM_MC_LOCAL(RTGCPTR,               GCPtrEffDst); \
     10721                    \
     10722                    IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 1); \
     10723                    uint8_t bImm; IEM_OPCODE_GET_NEXT_U8(&bImm); \
     10724                    IEM_MC_ASSIGN(u16Src, bImm & 0x0f); \
     10725                    IEMOP_HLP_DONE_DECODING(); \
     10726                    IEM_MC_FETCH_EFLAGS(EFlags); \
     10727                    IEM_MC_MEM_MAP(pu16Dst, a_fRW, pVCpu->iem.s.iEffSeg, GCPtrEffDst, 0); \
     10728                    IEM_MC_CALL_VOID_AIMPL_3(a_fnNormalU16, pu16Dst, u16Src, pEFlags); \
     10729                    IEM_MC_MEM_COMMIT_AND_UNMAP(pu16Dst, a_fRW); \
     10730                    \
     10731                    IEM_MC_COMMIT_EFLAGS(EFlags); \
     10732                    IEM_MC_ADVANCE_RIP_AND_FINISH(); \
     10733                    IEM_MC_END(); \
     10734                    break; \
     10735                \
     10736                case IEMMODE_32BIT: \
     10737                    IEM_MC_BEGIN(3, 1); \
     10738                    IEM_MC_ARG(uint32_t *,              pu32Dst,                0); \
     10739                    IEM_MC_ARG(uint32_t,                u32Src,                 1); \
     10740                    IEM_MC_ARG_LOCAL_EFLAGS(            pEFlags, EFlags,        2); \
     10741                    IEM_MC_LOCAL(RTGCPTR,               GCPtrEffDst); \
     10742                    \
     10743                    IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 1); \
     10744                    uint8_t bImm; IEM_OPCODE_GET_NEXT_U8(&bImm); \
     10745                    IEM_MC_ASSIGN(u32Src, bImm & 0x1f); \
     10746                    IEMOP_HLP_DONE_DECODING(); \
     10747                    IEM_MC_FETCH_EFLAGS(EFlags); \
     10748                    IEM_MC_MEM_MAP(pu32Dst, a_fRW, pVCpu->iem.s.iEffSeg, GCPtrEffDst, 0); \
     10749                    IEM_MC_CALL_VOID_AIMPL_3(a_fnNormalU32, pu32Dst, u32Src, pEFlags); \
     10750                    IEM_MC_MEM_COMMIT_AND_UNMAP(pu32Dst, a_fRW); \
     10751                    \
     10752                    IEM_MC_COMMIT_EFLAGS(EFlags); \
     10753                    IEM_MC_ADVANCE_RIP_AND_FINISH(); \
     10754                    IEM_MC_END(); \
     10755                    break; \
     10756                \
     10757                case IEMMODE_64BIT: \
     10758                    IEM_MC_BEGIN(3, 1); \
     10759                    IEM_MC_ARG(uint64_t *,              pu64Dst,                0); \
     10760                    IEM_MC_ARG(uint64_t,                u64Src,                 1); \
     10761                    IEM_MC_ARG_LOCAL_EFLAGS(            pEFlags, EFlags,        2); \
     10762                    IEM_MC_LOCAL(RTGCPTR,               GCPtrEffDst); \
     10763                    \
     10764                    IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 1); \
     10765                    uint8_t bImm; IEM_OPCODE_GET_NEXT_U8(&bImm); \
     10766                    IEM_MC_ASSIGN(u64Src, bImm & 0x3f); \
     10767                    IEMOP_HLP_DONE_DECODING(); \
     10768                    IEM_MC_FETCH_EFLAGS(EFlags); \
     10769                    IEM_MC_MEM_MAP(pu64Dst, a_fRW, pVCpu->iem.s.iEffSeg, GCPtrEffDst, 0); \
     10770                    IEM_MC_CALL_VOID_AIMPL_3(a_fnNormalU64, pu64Dst, u64Src, pEFlags); \
     10771                    IEM_MC_MEM_COMMIT_AND_UNMAP(pu64Dst, a_fRW); \
     10772                    \
     10773                    IEM_MC_COMMIT_EFLAGS(EFlags); \
     10774                    IEM_MC_ADVANCE_RIP_AND_FINISH(); \
     10775                    IEM_MC_END(); \
     10776                    break; \
     10777                \
     10778                IEM_NOT_REACHED_DEFAULT_CASE_RET(); \
     10779            } \
     10780        } \
     10781        else \
     10782        { \
     10783            (void)0
     10784
     10785#define IEMOP_BODY_BIT_Ev_Ib_NO_LOCK() \
     10786            IEMOP_HLP_DONE_DECODING(); \
     10787            return IEMOP_RAISE_INVALID_LOCK_PREFIX(); \
     10788        } \
     10789    } \
     10790    (void)0
     10791
     10792#define IEMOP_BODY_BIT_Ev_Ib_LOCKED(a_fnLockedU16, a_fnLockedU32, a_fnLockedU64) \
     10793            switch (pVCpu->iem.s.enmEffOpSize) \
     10794            { \
     10795                case IEMMODE_16BIT: \
     10796                    IEM_MC_BEGIN(3, 1); \
     10797                    IEM_MC_ARG(uint16_t *,              pu16Dst,                0); \
     10798                    IEM_MC_ARG(uint16_t,                u16Src,                 1); \
     10799                    IEM_MC_ARG_LOCAL_EFLAGS(            pEFlags, EFlags,        2); \
     10800                    IEM_MC_LOCAL(RTGCPTR,               GCPtrEffDst); \
     10801                    \
     10802                    IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 1); \
     10803                    uint8_t bImm; IEM_OPCODE_GET_NEXT_U8(&bImm); \
     10804                    IEM_MC_ASSIGN(u16Src, bImm & 0x0f); \
     10805                    IEMOP_HLP_DONE_DECODING(); \
     10806                    IEM_MC_FETCH_EFLAGS(EFlags); \
     10807                    IEM_MC_MEM_MAP(pu16Dst, IEM_ACCESS_DATA_RW, pVCpu->iem.s.iEffSeg, GCPtrEffDst, 0); \
     10808                    IEM_MC_CALL_VOID_AIMPL_3(a_fnLockedU16, pu16Dst, u16Src, pEFlags); \
     10809                    IEM_MC_MEM_COMMIT_AND_UNMAP(pu16Dst, IEM_ACCESS_DATA_RW); \
     10810                    \
     10811                    IEM_MC_COMMIT_EFLAGS(EFlags); \
     10812                    IEM_MC_ADVANCE_RIP_AND_FINISH(); \
     10813                    IEM_MC_END(); \
     10814                    break; \
     10815                \
     10816                case IEMMODE_32BIT: \
     10817                    IEM_MC_BEGIN(3, 1); \
     10818                    IEM_MC_ARG(uint32_t *,              pu32Dst,                0); \
     10819                    IEM_MC_ARG(uint32_t,                u32Src,                 1); \
     10820                    IEM_MC_ARG_LOCAL_EFLAGS(            pEFlags, EFlags,        2); \
     10821                    IEM_MC_LOCAL(RTGCPTR,               GCPtrEffDst); \
     10822                    \
     10823                    IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 1); \
     10824                    uint8_t bImm; IEM_OPCODE_GET_NEXT_U8(&bImm); \
     10825                    IEM_MC_ASSIGN(u32Src, bImm & 0x1f); \
     10826                    IEMOP_HLP_DONE_DECODING(); \
     10827                    IEM_MC_FETCH_EFLAGS(EFlags); \
     10828                    IEM_MC_MEM_MAP(pu32Dst, IEM_ACCESS_DATA_RW, pVCpu->iem.s.iEffSeg, GCPtrEffDst, 0); \
     10829                    IEM_MC_CALL_VOID_AIMPL_3(a_fnLockedU32, pu32Dst, u32Src, pEFlags); \
     10830                    IEM_MC_MEM_COMMIT_AND_UNMAP(pu32Dst, IEM_ACCESS_DATA_RW); \
     10831                    \
     10832                    IEM_MC_COMMIT_EFLAGS(EFlags); \
     10833                    IEM_MC_ADVANCE_RIP_AND_FINISH(); \
     10834                    IEM_MC_END(); \
     10835                    break; \
     10836                \
     10837                case IEMMODE_64BIT: \
     10838                    IEM_MC_BEGIN(3, 1); \
     10839                    IEM_MC_ARG(uint64_t *,              pu64Dst,                0); \
     10840                    IEM_MC_ARG(uint64_t,                u64Src,                 1); \
     10841                    IEM_MC_ARG_LOCAL_EFLAGS(            pEFlags, EFlags,        2); \
     10842                    IEM_MC_LOCAL(RTGCPTR,               GCPtrEffDst); \
     10843                    \
     10844                    IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 1); \
     10845                    uint8_t bImm; IEM_OPCODE_GET_NEXT_U8(&bImm); \
     10846                    IEM_MC_ASSIGN(u64Src, bImm & 0x3f); \
     10847                    IEMOP_HLP_DONE_DECODING(); \
     10848                    IEM_MC_FETCH_EFLAGS(EFlags); \
     10849                    IEM_MC_MEM_MAP(pu64Dst, IEM_ACCESS_DATA_RW, pVCpu->iem.s.iEffSeg, GCPtrEffDst, 0); \
     10850                    IEM_MC_CALL_VOID_AIMPL_3(a_fnLockedU64, pu64Dst, u64Src, pEFlags); \
     10851                    IEM_MC_MEM_COMMIT_AND_UNMAP(pu64Dst, IEM_ACCESS_DATA_RW); \
     10852                    \
     10853                    IEM_MC_COMMIT_EFLAGS(EFlags); \
     10854                    IEM_MC_ADVANCE_RIP_AND_FINISH(); \
     10855                    IEM_MC_END(); \
     10856                    break; \
     10857                \
     10858                IEM_NOT_REACHED_DEFAULT_CASE_RET(); \
     10859            } \
     10860        } \
     10861    } \
     10862    (void)0
     10863
     10864
     10865/** Opcode 0x0f 0xba /4. */
     10866FNIEMOPRM_DEF(iemOp_Grp8_bt_Ev_Ib)
     10867{
     10868    IEMOP_MNEMONIC(bt_Ev_Ib, "bt  Ev,Ib");
     10869    IEMOP_BODY_BIT_Ev_Ib(iemAImpl_bt_u16, iemAImpl_bt_u32, iemAImpl_bt_u64, IEM_ACCESS_DATA_R);
     10870    IEMOP_BODY_BIT_Ev_Ib_NO_LOCK();
     10871}
     10872
     10873
     10874/** Opcode 0x0f 0xba /5. */
     10875FNIEMOPRM_DEF(iemOp_Grp8_bts_Ev_Ib)
     10876{
     10877    IEMOP_MNEMONIC(bts_Ev_Ib, "bts Ev,Ib");
     10878    IEMOP_BODY_BIT_Ev_Ib(       iemAImpl_bts_u16,        iemAImpl_bts_u32,        iemAImpl_bts_u64, IEM_ACCESS_DATA_RW);
     10879    IEMOP_BODY_BIT_Ev_Ib_LOCKED(iemAImpl_bts_u16_locked, iemAImpl_bts_u32_locked, iemAImpl_bts_u64_locked);
     10880}
     10881
     10882
     10883/** Opcode 0x0f 0xba /6. */
     10884FNIEMOPRM_DEF(iemOp_Grp8_btr_Ev_Ib)
     10885{
     10886    IEMOP_MNEMONIC(btr_Ev_Ib, "btr Ev,Ib");
     10887    IEMOP_BODY_BIT_Ev_Ib(       iemAImpl_btr_u16,        iemAImpl_btr_u32,        iemAImpl_btr_u64, IEM_ACCESS_DATA_RW);
     10888    IEMOP_BODY_BIT_Ev_Ib_LOCKED(iemAImpl_btr_u16_locked, iemAImpl_btr_u32_locked, iemAImpl_btr_u64_locked);
     10889}
     10890
     10891
     10892/** Opcode 0x0f 0xba /7. */
     10893FNIEMOPRM_DEF(iemOp_Grp8_btc_Ev_Ib)
     10894{
     10895    IEMOP_MNEMONIC(btc_Ev_Ib, "btc Ev,Ib");
     10896    IEMOP_BODY_BIT_Ev_Ib(       iemAImpl_btc_u16,        iemAImpl_btc_u32,        iemAImpl_btc_u64, IEM_ACCESS_DATA_RW);
     10897    IEMOP_BODY_BIT_Ev_Ib_LOCKED(iemAImpl_btc_u16_locked, iemAImpl_btc_u32_locked, iemAImpl_btc_u64_locked);
     10898}
     10899
    1065010900
    1065110901/** Opcode 0x0f 0xba. */
    … …  
    1065410904    IEMOP_HLP_MIN_386();
    1065510905    uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
    10656     PCIEMOPBINSIZES pImpl;
    1065710906    switch (IEM_GET_MODRM_REG_8(bRm))
    1065810907    {
     10908        case 4: return FNIEMOP_CALL_1(iemOp_Grp8_bt_Ev_Ib, bRm);
     10909        case 5: return FNIEMOP_CALL_1(iemOp_Grp8_bts_Ev_Ib, bRm);
     10910        case 6: return FNIEMOP_CALL_1(iemOp_Grp8_btr_Ev_Ib, bRm);
     10911        case 7: return FNIEMOP_CALL_1(iemOp_Grp8_btc_Ev_Ib, bRm);
     10912
    1065910913        case 0: case 1: case 2: case 3:
    1066010914            /* Both AMD and Intel want full modr/m decoding and imm8. */
    1066110915            return FNIEMOP_CALL_1(iemOp_InvalidWithRMAllNeedImm8, bRm);
    10662         case 4: pImpl = &g_iemAImpl_bt;  IEMOP_MNEMONIC(bt_Ev_Ib,  "bt  Ev,Ib"); break;
    10663         case 5: pImpl = &g_iemAImpl_bts; IEMOP_MNEMONIC(bts_Ev_Ib, "bts Ev,Ib"); break;
    10664         case 6: pImpl = &g_iemAImpl_btr; IEMOP_MNEMONIC(btr_Ev_Ib, "btr Ev,Ib"); break;
    10665         case 7: pImpl = &g_iemAImpl_btc; IEMOP_MNEMONIC(btc_Ev_Ib, "btc Ev,Ib"); break;
     10916
    1066610917        IEM_NOT_REACHED_DEFAULT_CASE_RET();
    10667     }
    10668     IEMOP_VERIFICATION_UNDEFINED_EFLAGS(X86_EFL_OF | X86_EFL_SF | X86_EFL_ZF | X86_EFL_AF | X86_EFL_PF);
    10669 
    10670     if (IEM_IS_MODRM_REG_MODE(bRm))
    10671     {
    10672         /* register destination. */
    10673         uint8_t u8Bit; IEM_OPCODE_GET_NEXT_U8(&u8Bit);
    10674         IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
    10675 
    10676         switch (pVCpu->iem.s.enmEffOpSize)
    10677         {
    10678             case IEMMODE_16BIT:
    10679                 IEM_MC_BEGIN(3, 0);
    10680                 IEM_MC_ARG(uint16_t *,      pu16Dst,                    0);
    10681                 IEM_MC_ARG_CONST(uint16_t,  u16Src, /*=*/ u8Bit & 0x0f, 1);
    10682                 IEM_MC_ARG(uint32_t *,      pEFlags,                    2);
    10683 
    10684                 IEM_MC_REF_GREG_U16(pu16Dst, IEM_GET_MODRM_RM(pVCpu, bRm));
    10685                 IEM_MC_REF_EFLAGS(pEFlags);
    10686                 IEM_MC_CALL_VOID_AIMPL_3(pImpl->pfnNormalU16, pu16Dst, u16Src, pEFlags);
    10687 
    10688                 IEM_MC_ADVANCE_RIP_AND_FINISH();
    10689                 IEM_MC_END();
    10690                 break;
    10691 
    10692             case IEMMODE_32BIT:
    10693                 IEM_MC_BEGIN(3, 0);
    10694                 IEM_MC_ARG(uint32_t *,      pu32Dst,                    0);
    10695                 IEM_MC_ARG_CONST(uint32_t,  u32Src, /*=*/ u8Bit & 0x1f, 1);
    10696                 IEM_MC_ARG(uint32_t *,      pEFlags,                    2);
    10697 
    10698                 IEM_MC_REF_GREG_U32(pu32Dst, IEM_GET_MODRM_RM(pVCpu, bRm));
    10699                 IEM_MC_REF_EFLAGS(pEFlags);
    10700                 IEM_MC_CALL_VOID_AIMPL_3(pImpl->pfnNormalU32, pu32Dst, u32Src, pEFlags);
    10701 
    10702                 IEM_MC_CLEAR_HIGH_GREG_U64_BY_REF(pu32Dst);
    10703                 IEM_MC_ADVANCE_RIP_AND_FINISH();
    10704                 IEM_MC_END();
    10705                 break;
    10706 
    10707             case IEMMODE_64BIT:
    10708                 IEM_MC_BEGIN(3, 0);
    10709                 IEM_MC_ARG(uint64_t *,      pu64Dst,                    0);
    10710                 IEM_MC_ARG_CONST(uint64_t,  u64Src, /*=*/ u8Bit & 0x3f, 1);
    10711                 IEM_MC_ARG(uint32_t *,      pEFlags,                    2);
    10712 
    10713                 IEM_MC_REF_GREG_U64(pu64Dst, IEM_GET_MODRM_RM(pVCpu, bRm));
    10714                 IEM_MC_REF_EFLAGS(pEFlags);
    10715                 IEM_MC_CALL_VOID_AIMPL_3(pImpl->pfnNormalU64, pu64Dst, u64Src, pEFlags);
    10716 
    10717                 IEM_MC_ADVANCE_RIP_AND_FINISH();
    10718                 IEM_MC_END();
    10719                 break;
    10720 
    10721             IEM_NOT_REACHED_DEFAULT_CASE_RET();
    10722         }
    10723     }
    10724     else
    10725     {
    10726         /* memory destination. */
    10727 
    10728         uint32_t fAccess;
    10729         if (pImpl->pfnLockedU16)
    10730             fAccess = IEM_ACCESS_DATA_RW;
    10731         else /* BT */
    10732             fAccess = IEM_ACCESS_DATA_R;
    10733 
    10734         /** @todo test negative bit offsets! */
    10735         switch (pVCpu->iem.s.enmEffOpSize)
    10736         {
    10737             case IEMMODE_16BIT:
    10738                 IEM_MC_BEGIN(3, 1);
    10739                 IEM_MC_ARG(uint16_t *,              pu16Dst,                0);
    10740                 IEM_MC_ARG(uint16_t,                u16Src,                 1);
    10741                 IEM_MC_ARG_LOCAL_EFLAGS(            pEFlags, EFlags,        2);
    10742                 IEM_MC_LOCAL(RTGCPTR,               GCPtrEffDst);
    10743 
    10744                 IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 1);
    10745                 uint8_t u8Bit; IEM_OPCODE_GET_NEXT_U8(&u8Bit);
    10746                 IEM_MC_ASSIGN(u16Src, u8Bit & 0x0f);
    10747                 if (pImpl->pfnLockedU16)
    10748                     IEMOP_HLP_DONE_DECODING();
    10749                 else
    10750                     IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
    10751                 IEM_MC_FETCH_EFLAGS(EFlags);
    10752                 IEM_MC_MEM_MAP(pu16Dst, fAccess, pVCpu->iem.s.iEffSeg, GCPtrEffDst, 0);
    10753                 if (!(pVCpu->iem.s.fPrefixes & IEM_OP_PRF_LOCK))
    10754                     IEM_MC_CALL_VOID_AIMPL_3(pImpl->pfnNormalU16, pu16Dst, u16Src, pEFlags);
    10755                 else
    10756                     IEM_MC_CALL_VOID_AIMPL_3(pImpl->pfnLockedU16, pu16Dst, u16Src, pEFlags);
    10757                 IEM_MC_MEM_COMMIT_AND_UNMAP(pu16Dst, fAccess);
    10758 
    10759                 IEM_MC_COMMIT_EFLAGS(EFlags);
    10760                 IEM_MC_ADVANCE_RIP_AND_FINISH();
    10761                 IEM_MC_END();
    10762                 break;
    10763 
    10764             case IEMMODE_32BIT:
    10765                 IEM_MC_BEGIN(3, 1);
    10766                 IEM_MC_ARG(uint32_t *,              pu32Dst,                0);
    10767                 IEM_MC_ARG(uint32_t,                u32Src,                 1);
    10768                 IEM_MC_ARG_LOCAL_EFLAGS(            pEFlags, EFlags,        2);
    10769                 IEM_MC_LOCAL(RTGCPTR,               GCPtrEffDst);
    10770 
    10771                 IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 1);
    10772                 uint8_t u8Bit; IEM_OPCODE_GET_NEXT_U8(&u8Bit);
    10773                 IEM_MC_ASSIGN(u32Src, u8Bit & 0x1f);
    10774                 if (pImpl->pfnLockedU16)
    10775                     IEMOP_HLP_DONE_DECODING();
    10776                 else
    10777                     IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
    10778                 IEM_MC_FETCH_EFLAGS(EFlags);
    10779                 IEM_MC_MEM_MAP(pu32Dst, fAccess, pVCpu->iem.s.iEffSeg, GCPtrEffDst, 0);
    10780                 if (!(pVCpu->iem.s.fPrefixes & IEM_OP_PRF_LOCK))
    10781                     IEM_MC_CALL_VOID_AIMPL_3(pImpl->pfnNormalU32, pu32Dst, u32Src, pEFlags);
    10782                 else
    10783                     IEM_MC_CALL_VOID_AIMPL_3(pImpl->pfnLockedU32, pu32Dst, u32Src, pEFlags);
    10784                 IEM_MC_MEM_COMMIT_AND_UNMAP(pu32Dst, fAccess);
    10785 
    10786                 IEM_MC_COMMIT_EFLAGS(EFlags);
    10787                 IEM_MC_ADVANCE_RIP_AND_FINISH();
    10788                 IEM_MC_END();
    10789                 break;
    10790 
    10791             case IEMMODE_64BIT:
    10792                 IEM_MC_BEGIN(3, 1);
    10793                 IEM_MC_ARG(uint64_t *,              pu64Dst,                0);
    10794                 IEM_MC_ARG(uint64_t,                u64Src,                 1);
    10795                 IEM_MC_ARG_LOCAL_EFLAGS(            pEFlags, EFlags,        2);
    10796                 IEM_MC_LOCAL(RTGCPTR,               GCPtrEffDst);
    10797 
    10798                 IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 1);
    10799                 uint8_t u8Bit; IEM_OPCODE_GET_NEXT_U8(&u8Bit);
    10800                 IEM_MC_ASSIGN(u64Src, u8Bit & 0x3f);
    10801                 if (pImpl->pfnLockedU16)
    10802                     IEMOP_HLP_DONE_DECODING();
    10803                 else
    10804                     IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
    10805                 IEM_MC_FETCH_EFLAGS(EFlags);
    10806                 IEM_MC_MEM_MAP(pu64Dst, fAccess, pVCpu->iem.s.iEffSeg, GCPtrEffDst, 0);
    10807                 if (!(pVCpu->iem.s.fPrefixes & IEM_OP_PRF_LOCK))
    10808                     IEM_MC_CALL_VOID_AIMPL_3(pImpl->pfnNormalU64, pu64Dst, u64Src, pEFlags);
    10809                 else
    10810                     IEM_MC_CALL_VOID_AIMPL_3(pImpl->pfnLockedU64, pu64Dst, u64Src, pEFlags);
    10811                 IEM_MC_MEM_COMMIT_AND_UNMAP(pu64Dst, fAccess);
    10812 
    10813                 IEM_MC_COMMIT_EFLAGS(EFlags);
    10814                 IEM_MC_ADVANCE_RIP_AND_FINISH();
    10815                 IEM_MC_END();
    10816                 break;
    10817 
    10818             IEM_NOT_REACHED_DEFAULT_CASE_RET();
    10819         }
    1082010918    }
    1082110919}
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