VirtualBox

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


Ignore:
Timestamp:
Feb 5, 2024 10:53:27 PM (13 months ago)
Author:
vboxsync
Message:

VMM/IEMAllInst*: Liveness analysis, part 6: Flag input & modification annotations. bugref:10372

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r103212 r103213  
    1383213832
    1383313833
    13834 /** Opcode 0xf6 /4, /5, /6 and /7. */
    13835 FNIEMOP_DEF_2(iemOpCommonGrp3MulDivEb, uint8_t, bRm, PFNIEMAIMPLMULDIVU8, pfnU8)
    13836 {
    13837     if (IEM_IS_MODRM_REG_MODE(bRm))
    13838     {
    13839         /* register access */
    13840         IEM_MC_BEGIN(3, 1, 0, 0);
    13841         IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
    13842         IEM_MC_ARG(uint16_t *,      pu16AX,     0);
    13843         IEM_MC_ARG(uint8_t,         u8Value,    1);
    13844         IEM_MC_ARG(uint32_t *,      pEFlags,    2);
    13845         IEM_MC_LOCAL(int32_t,       rc);
    13846 
    13847         IEM_MC_FETCH_GREG_U8(u8Value, IEM_GET_MODRM_RM(pVCpu, bRm));
    13848         IEM_MC_REF_GREG_U16(pu16AX, X86_GREG_xAX);
    13849         IEM_MC_REF_EFLAGS(pEFlags);
    13850         IEM_MC_CALL_AIMPL_3(rc, pfnU8, pu16AX, u8Value, pEFlags);
    13851         IEM_MC_IF_LOCAL_IS_Z(rc) {
    13852             IEM_MC_ADVANCE_RIP_AND_FINISH();
    13853         } IEM_MC_ELSE() {
    13854             IEM_MC_RAISE_DIVIDE_ERROR();
    13855         } IEM_MC_ENDIF();
    13856 
    13857         IEM_MC_END();
    13858     }
    13859     else
    13860     {
    13861         /* memory access. */
    13862         IEM_MC_BEGIN(3, 2, 0, 0);
    13863         IEM_MC_ARG(uint16_t *,      pu16AX,     0);
    13864         IEM_MC_ARG(uint8_t,         u8Value,    1);
    13865         IEM_MC_ARG(uint32_t *,      pEFlags,    2);
    13866         IEM_MC_LOCAL(RTGCPTR, GCPtrEffDst);
    13867         IEM_MC_LOCAL(int32_t,       rc);
    13868 
    13869         IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 0);
    13870         IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
    13871         IEM_MC_FETCH_MEM_U8(u8Value, pVCpu->iem.s.iEffSeg, GCPtrEffDst);
    13872         IEM_MC_REF_GREG_U16(pu16AX, X86_GREG_xAX);
    13873         IEM_MC_REF_EFLAGS(pEFlags);
    13874         IEM_MC_CALL_AIMPL_3(rc, pfnU8, pu16AX, u8Value, pEFlags);
    13875         IEM_MC_IF_LOCAL_IS_Z(rc) {
    13876             IEM_MC_ADVANCE_RIP_AND_FINISH();
    13877         } IEM_MC_ELSE() {
    13878             IEM_MC_RAISE_DIVIDE_ERROR();
    13879         } IEM_MC_ENDIF();
    13880 
    13881         IEM_MC_END();
    13882     }
    13883 }
    13884 
    13885 
    13886 /** Opcode 0xf7 /4, /5, /6 and /7. */
    13887 FNIEMOP_DEF_2(iemOpCommonGrp3MulDivEv, uint8_t, bRm, PCIEMOPMULDIVSIZES, pImpl)
    13888 {
    13889     IEMOP_VERIFICATION_UNDEFINED_EFLAGS(X86_EFL_SF | X86_EFL_ZF | X86_EFL_AF | X86_EFL_PF);
    13890 
    13891     if (IEM_IS_MODRM_REG_MODE(bRm))
    13892     {
    13893         /* register access */
    13894         switch (pVCpu->iem.s.enmEffOpSize)
    13895         {
    13896             case IEMMODE_16BIT:
    13897                 IEM_MC_BEGIN(4, 1, 0, 0);
    13898                 IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
    13899                 IEM_MC_ARG(uint16_t *,      pu16AX,     0);
    13900                 IEM_MC_ARG(uint16_t *,      pu16DX,     1);
    13901                 IEM_MC_ARG(uint16_t,        u16Value,   2);
    13902                 IEM_MC_ARG(uint32_t *,      pEFlags,    3);
    13903                 IEM_MC_LOCAL(int32_t,       rc);
    13904 
    13905                 IEM_MC_FETCH_GREG_U16(u16Value, IEM_GET_MODRM_RM(pVCpu, bRm));
    13906                 IEM_MC_REF_GREG_U16(pu16AX, X86_GREG_xAX);
    13907                 IEM_MC_REF_GREG_U16(pu16DX, X86_GREG_xDX);
    13908                 IEM_MC_REF_EFLAGS(pEFlags);
    13909                 IEM_MC_CALL_AIMPL_4(rc, pImpl->pfnU16, pu16AX, pu16DX, u16Value, pEFlags);
    13910                 IEM_MC_IF_LOCAL_IS_Z(rc) {
    13911                     IEM_MC_ADVANCE_RIP_AND_FINISH();
    13912                 } IEM_MC_ELSE() {
    13913                     IEM_MC_RAISE_DIVIDE_ERROR();
    13914                 } IEM_MC_ENDIF();
    13915 
    13916                 IEM_MC_END();
    13917                 break;
    13918 
    13919             case IEMMODE_32BIT:
    13920                 IEM_MC_BEGIN(4, 1, IEM_MC_F_MIN_386, 0);
    13921                 IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
    13922                 IEM_MC_ARG(uint32_t *,      pu32AX,     0);
    13923                 IEM_MC_ARG(uint32_t *,      pu32DX,     1);
    13924                 IEM_MC_ARG(uint32_t,        u32Value,   2);
    13925                 IEM_MC_ARG(uint32_t *,      pEFlags,    3);
    13926                 IEM_MC_LOCAL(int32_t,       rc);
    13927 
    13928                 IEM_MC_FETCH_GREG_U32(u32Value, IEM_GET_MODRM_RM(pVCpu, bRm));
    13929                 IEM_MC_REF_GREG_U32(pu32AX, X86_GREG_xAX);
    13930                 IEM_MC_REF_GREG_U32(pu32DX, X86_GREG_xDX);
    13931                 IEM_MC_REF_EFLAGS(pEFlags);
    13932                 IEM_MC_CALL_AIMPL_4(rc, pImpl->pfnU32, pu32AX, pu32DX, u32Value, pEFlags);
    13933                 IEM_MC_IF_LOCAL_IS_Z(rc) {
    13934                     IEM_MC_CLEAR_HIGH_GREG_U64(X86_GREG_xAX);
    13935                     IEM_MC_CLEAR_HIGH_GREG_U64(X86_GREG_xDX);
    13936                     IEM_MC_ADVANCE_RIP_AND_FINISH();
    13937                 } IEM_MC_ELSE() {
    13938                     IEM_MC_RAISE_DIVIDE_ERROR();
    13939                 } IEM_MC_ENDIF();
    13940 
    13941                 IEM_MC_END();
    13942                 break;
    13943 
    13944             case IEMMODE_64BIT:
    13945                 IEM_MC_BEGIN(4, 1, IEM_MC_F_64BIT, 0);
    13946                 IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
    13947                 IEM_MC_ARG(uint64_t *,      pu64AX,     0);
    13948                 IEM_MC_ARG(uint64_t *,      pu64DX,     1);
    13949                 IEM_MC_ARG(uint64_t,        u64Value,   2);
    13950                 IEM_MC_ARG(uint32_t *,      pEFlags,    3);
    13951                 IEM_MC_LOCAL(int32_t,       rc);
    13952 
    13953                 IEM_MC_FETCH_GREG_U64(u64Value, IEM_GET_MODRM_RM(pVCpu, bRm));
    13954                 IEM_MC_REF_GREG_U64(pu64AX, X86_GREG_xAX);
    13955                 IEM_MC_REF_GREG_U64(pu64DX, X86_GREG_xDX);
    13956                 IEM_MC_REF_EFLAGS(pEFlags);
    13957                 IEM_MC_CALL_AIMPL_4(rc, pImpl->pfnU64, pu64AX, pu64DX, u64Value, pEFlags);
    13958                 IEM_MC_IF_LOCAL_IS_Z(rc) {
    13959                     IEM_MC_ADVANCE_RIP_AND_FINISH();
    13960                 } IEM_MC_ELSE() {
    13961                     IEM_MC_RAISE_DIVIDE_ERROR();
    13962                 } IEM_MC_ENDIF();
    13963 
    13964                 IEM_MC_END();
    13965                 break;
    13966 
    13967             IEM_NOT_REACHED_DEFAULT_CASE_RET();
    13968         }
    13969     }
    13970     else
    13971     {
    13972         /* memory access. */
    13973         switch (pVCpu->iem.s.enmEffOpSize)
    13974         {
    13975             case IEMMODE_16BIT:
    13976                 IEM_MC_BEGIN(4, 2, 0, 0);
    13977                 IEM_MC_ARG(uint16_t *,      pu16AX,     0);
    13978                 IEM_MC_ARG(uint16_t *,      pu16DX,     1);
    13979                 IEM_MC_ARG(uint16_t,        u16Value,   2);
    13980                 IEM_MC_ARG(uint32_t *,      pEFlags,    3);
    13981                 IEM_MC_LOCAL(RTGCPTR, GCPtrEffDst);
    13982                 IEM_MC_LOCAL(int32_t,       rc);
    13983 
    13984                 IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 0);
    13985                 IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
    13986                 IEM_MC_FETCH_MEM_U16(u16Value, pVCpu->iem.s.iEffSeg, GCPtrEffDst);
    13987                 IEM_MC_REF_GREG_U16(pu16AX, X86_GREG_xAX);
    13988                 IEM_MC_REF_GREG_U16(pu16DX, X86_GREG_xDX);
    13989                 IEM_MC_REF_EFLAGS(pEFlags);
    13990                 IEM_MC_CALL_AIMPL_4(rc, pImpl->pfnU16, pu16AX, pu16DX, u16Value, pEFlags);
    13991                 IEM_MC_IF_LOCAL_IS_Z(rc) {
    13992                     IEM_MC_ADVANCE_RIP_AND_FINISH();
    13993                 } IEM_MC_ELSE() {
    13994                     IEM_MC_RAISE_DIVIDE_ERROR();
    13995                 } IEM_MC_ENDIF();
    13996 
    13997                 IEM_MC_END();
    13998                 break;
    13999 
    14000             case IEMMODE_32BIT:
    14001                 IEM_MC_BEGIN(4, 2, IEM_MC_F_MIN_386, 0);
    14002                 IEM_MC_ARG(uint32_t *,      pu32AX,     0);
    14003                 IEM_MC_ARG(uint32_t *,      pu32DX,     1);
    14004                 IEM_MC_ARG(uint32_t,        u32Value,   2);
    14005                 IEM_MC_ARG(uint32_t *,      pEFlags,    3);
    14006                 IEM_MC_LOCAL(RTGCPTR, GCPtrEffDst);
    14007                 IEM_MC_LOCAL(int32_t,       rc);
    14008 
    14009                 IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 0);
    14010                 IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
    14011                 IEM_MC_FETCH_MEM_U32(u32Value, pVCpu->iem.s.iEffSeg, GCPtrEffDst);
    14012                 IEM_MC_REF_GREG_U32(pu32AX, X86_GREG_xAX);
    14013                 IEM_MC_REF_GREG_U32(pu32DX, X86_GREG_xDX);
    14014                 IEM_MC_REF_EFLAGS(pEFlags);
    14015                 IEM_MC_CALL_AIMPL_4(rc, pImpl->pfnU32, pu32AX, pu32DX, u32Value, pEFlags);
    14016                 IEM_MC_IF_LOCAL_IS_Z(rc) {
    14017                     IEM_MC_CLEAR_HIGH_GREG_U64(X86_GREG_xAX);
    14018                     IEM_MC_CLEAR_HIGH_GREG_U64(X86_GREG_xDX);
    14019                     IEM_MC_ADVANCE_RIP_AND_FINISH();
    14020                 } IEM_MC_ELSE() {
    14021                     IEM_MC_RAISE_DIVIDE_ERROR();
    14022                 } IEM_MC_ENDIF();
    14023 
    14024                 IEM_MC_END();
    14025                 break;
    14026 
    14027             case IEMMODE_64BIT:
    14028                 IEM_MC_BEGIN(4, 2, IEM_MC_F_64BIT, 0);
    14029                 IEM_MC_ARG(uint64_t *,      pu64AX,     0);
    14030                 IEM_MC_ARG(uint64_t *,      pu64DX,     1);
    14031                 IEM_MC_ARG(uint64_t,        u64Value,   2);
    14032                 IEM_MC_ARG(uint32_t *,      pEFlags,    3);
    14033                 IEM_MC_LOCAL(RTGCPTR, GCPtrEffDst);
    14034                 IEM_MC_LOCAL(int32_t,       rc);
    14035 
    14036                 IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 0);
    14037                 IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
    14038                 IEM_MC_FETCH_MEM_U64(u64Value, pVCpu->iem.s.iEffSeg, GCPtrEffDst);
    14039                 IEM_MC_REF_GREG_U64(pu64AX, X86_GREG_xAX);
    14040                 IEM_MC_REF_GREG_U64(pu64DX, X86_GREG_xDX);
    14041                 IEM_MC_REF_EFLAGS(pEFlags);
    14042                 IEM_MC_CALL_AIMPL_4(rc, pImpl->pfnU64, pu64AX, pu64DX, u64Value, pEFlags);
    14043                 IEM_MC_IF_LOCAL_IS_Z(rc) {
    14044                     IEM_MC_ADVANCE_RIP_AND_FINISH();
    14045                 } IEM_MC_ELSE() {
    14046                     IEM_MC_RAISE_DIVIDE_ERROR();
    14047                 } IEM_MC_ENDIF();
    14048 
    14049                 IEM_MC_END();
    14050                 break;
    14051 
    14052             IEM_NOT_REACHED_DEFAULT_CASE_RET();
    14053         }
    14054     }
    14055 }
     13834/* Body for opcode 0xf6 variations /4, /5, /6 and /7. */
     13835#define IEMOP_GRP3_MUL_DIV_EB(bRm, a_pfnU8Expr) \
     13836    PFNIEMAIMPLMULDIVU8 const pfnU8 = (a_pfnU8Expr); \
     13837    if (IEM_IS_MODRM_REG_MODE(bRm)) \
     13838    { \
     13839        /* register access */ \
     13840        IEM_MC_BEGIN(3, 1, 0, 0); \
     13841        IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX(); \
     13842        IEM_MC_ARG(uint16_t *,      pu16AX,     0); \
     13843        IEM_MC_ARG(uint8_t,         u8Value,    1); \
     13844        IEM_MC_ARG(uint32_t *,      pEFlags,    2); \
     13845        IEM_MC_LOCAL(int32_t,       rc); \
     13846        \
     13847        IEM_MC_FETCH_GREG_U8(u8Value, IEM_GET_MODRM_RM(pVCpu, bRm)); \
     13848        IEM_MC_REF_GREG_U16(pu16AX, X86_GREG_xAX); \
     13849        IEM_MC_REF_EFLAGS(pEFlags); \
     13850        IEM_MC_CALL_AIMPL_3(rc, pfnU8, pu16AX, u8Value, pEFlags); \
     13851        IEM_MC_IF_LOCAL_IS_Z(rc) { \
     13852            IEM_MC_ADVANCE_RIP_AND_FINISH(); \
     13853        } IEM_MC_ELSE() { \
     13854            IEM_MC_RAISE_DIVIDE_ERROR(); \
     13855        } IEM_MC_ENDIF(); \
     13856        \
     13857        IEM_MC_END(); \
     13858    } \
     13859    else \
     13860    { \
     13861        /* memory access. */ \
     13862        IEM_MC_BEGIN(3, 2, 0, 0); \
     13863        IEM_MC_ARG(uint16_t *,      pu16AX,     0); \
     13864        IEM_MC_ARG(uint8_t,         u8Value,    1); \
     13865        IEM_MC_ARG(uint32_t *,      pEFlags,    2); \
     13866        IEM_MC_LOCAL(RTGCPTR, GCPtrEffDst); \
     13867        IEM_MC_LOCAL(int32_t,       rc); \
     13868        \
     13869        IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 0); \
     13870        IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX(); \
     13871        IEM_MC_FETCH_MEM_U8(u8Value, pVCpu->iem.s.iEffSeg, GCPtrEffDst); \
     13872        IEM_MC_REF_GREG_U16(pu16AX, X86_GREG_xAX); \
     13873        IEM_MC_REF_EFLAGS(pEFlags); \
     13874        IEM_MC_CALL_AIMPL_3(rc, pfnU8, pu16AX, u8Value, pEFlags); \
     13875        IEM_MC_IF_LOCAL_IS_Z(rc) { \
     13876            IEM_MC_ADVANCE_RIP_AND_FINISH(); \
     13877        } IEM_MC_ELSE() { \
     13878            IEM_MC_RAISE_DIVIDE_ERROR(); \
     13879        } IEM_MC_ENDIF(); \
     13880        \
     13881        IEM_MC_END(); \
     13882    } (void)0
     13883
     13884
     13885/* Body for opcode 0xf7 variant /4, /5, /6 and /7. */
     13886#define IEMOP_BODY_GRP3_MUL_DIV_EV(bRm, a_pImplExpr) \
     13887    PCIEMOPMULDIVSIZES const pImpl = (a_pImplExpr); \
     13888    if (IEM_IS_MODRM_REG_MODE(bRm)) \
     13889    { \
     13890        /* register access */ \
     13891        switch (pVCpu->iem.s.enmEffOpSize) \
     13892        { \
     13893            case IEMMODE_16BIT: \
     13894                IEM_MC_BEGIN(4, 1, 0, 0); \
     13895                IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX(); \
     13896                IEM_MC_ARG(uint16_t *,      pu16AX,     0); \
     13897                IEM_MC_ARG(uint16_t *,      pu16DX,     1); \
     13898                IEM_MC_ARG(uint16_t,        u16Value,   2); \
     13899                IEM_MC_ARG(uint32_t *,      pEFlags,    3); \
     13900                IEM_MC_LOCAL(int32_t,       rc); \
     13901                \
     13902                IEM_MC_FETCH_GREG_U16(u16Value, IEM_GET_MODRM_RM(pVCpu, bRm)); \
     13903                IEM_MC_REF_GREG_U16(pu16AX, X86_GREG_xAX); \
     13904                IEM_MC_REF_GREG_U16(pu16DX, X86_GREG_xDX); \
     13905                IEM_MC_REF_EFLAGS(pEFlags); \
     13906                IEM_MC_CALL_AIMPL_4(rc, pImpl->pfnU16, pu16AX, pu16DX, u16Value, pEFlags); \
     13907                IEM_MC_IF_LOCAL_IS_Z(rc) { \
     13908                    IEM_MC_ADVANCE_RIP_AND_FINISH(); \
     13909                } IEM_MC_ELSE() { \
     13910                    IEM_MC_RAISE_DIVIDE_ERROR(); \
     13911                } IEM_MC_ENDIF(); \
     13912                \
     13913                IEM_MC_END(); \
     13914                break; \
     13915                \
     13916            case IEMMODE_32BIT: \
     13917                IEM_MC_BEGIN(4, 1, IEM_MC_F_MIN_386, 0); \
     13918                IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX(); \
     13919                IEM_MC_ARG(uint32_t *,      pu32AX,     0); \
     13920                IEM_MC_ARG(uint32_t *,      pu32DX,     1); \
     13921                IEM_MC_ARG(uint32_t,        u32Value,   2); \
     13922                IEM_MC_ARG(uint32_t *,      pEFlags,    3); \
     13923                IEM_MC_LOCAL(int32_t,       rc); \
     13924                \
     13925                IEM_MC_FETCH_GREG_U32(u32Value, IEM_GET_MODRM_RM(pVCpu, bRm)); \
     13926                IEM_MC_REF_GREG_U32(pu32AX, X86_GREG_xAX); \
     13927                IEM_MC_REF_GREG_U32(pu32DX, X86_GREG_xDX); \
     13928                IEM_MC_REF_EFLAGS(pEFlags); \
     13929                IEM_MC_CALL_AIMPL_4(rc, pImpl->pfnU32, pu32AX, pu32DX, u32Value, pEFlags); \
     13930                IEM_MC_IF_LOCAL_IS_Z(rc) { \
     13931                    IEM_MC_CLEAR_HIGH_GREG_U64(X86_GREG_xAX); \
     13932                    IEM_MC_CLEAR_HIGH_GREG_U64(X86_GREG_xDX); \
     13933                    IEM_MC_ADVANCE_RIP_AND_FINISH(); \
     13934                } IEM_MC_ELSE() { \
     13935                    IEM_MC_RAISE_DIVIDE_ERROR(); \
     13936                } IEM_MC_ENDIF(); \
     13937                \
     13938                IEM_MC_END(); \
     13939                break; \
     13940                \
     13941            case IEMMODE_64BIT: \
     13942                IEM_MC_BEGIN(4, 1, IEM_MC_F_64BIT, 0); \
     13943                IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX(); \
     13944                IEM_MC_ARG(uint64_t *,      pu64AX,     0); \
     13945                IEM_MC_ARG(uint64_t *,      pu64DX,     1); \
     13946                IEM_MC_ARG(uint64_t,        u64Value,   2); \
     13947                IEM_MC_ARG(uint32_t *,      pEFlags,    3); \
     13948                IEM_MC_LOCAL(int32_t,       rc); \
     13949                \
     13950                IEM_MC_FETCH_GREG_U64(u64Value, IEM_GET_MODRM_RM(pVCpu, bRm)); \
     13951                IEM_MC_REF_GREG_U64(pu64AX, X86_GREG_xAX); \
     13952                IEM_MC_REF_GREG_U64(pu64DX, X86_GREG_xDX); \
     13953                IEM_MC_REF_EFLAGS(pEFlags); \
     13954                IEM_MC_CALL_AIMPL_4(rc, pImpl->pfnU64, pu64AX, pu64DX, u64Value, pEFlags); \
     13955                IEM_MC_IF_LOCAL_IS_Z(rc) { \
     13956                    IEM_MC_ADVANCE_RIP_AND_FINISH(); \
     13957                } IEM_MC_ELSE() { \
     13958                    IEM_MC_RAISE_DIVIDE_ERROR(); \
     13959                } IEM_MC_ENDIF(); \
     13960                \
     13961                IEM_MC_END(); \
     13962                break; \
     13963                \
     13964            IEM_NOT_REACHED_DEFAULT_CASE_RET(); \
     13965        } \
     13966    } \
     13967    else \
     13968    { \
     13969        /* memory access. */ \
     13970        switch (pVCpu->iem.s.enmEffOpSize) \
     13971        { \
     13972            case IEMMODE_16BIT: \
     13973                IEM_MC_BEGIN(4, 2, 0, 0); \
     13974                IEM_MC_ARG(uint16_t *,      pu16AX,     0); \
     13975                IEM_MC_ARG(uint16_t *,      pu16DX,     1); \
     13976                IEM_MC_ARG(uint16_t,        u16Value,   2); \
     13977                IEM_MC_ARG(uint32_t *,      pEFlags,    3); \
     13978                IEM_MC_LOCAL(RTGCPTR, GCPtrEffDst); \
     13979                IEM_MC_LOCAL(int32_t,       rc); \
     13980                \
     13981                IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 0); \
     13982                IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX(); \
     13983                IEM_MC_FETCH_MEM_U16(u16Value, pVCpu->iem.s.iEffSeg, GCPtrEffDst); \
     13984                IEM_MC_REF_GREG_U16(pu16AX, X86_GREG_xAX); \
     13985                IEM_MC_REF_GREG_U16(pu16DX, X86_GREG_xDX); \
     13986                IEM_MC_REF_EFLAGS(pEFlags); \
     13987                IEM_MC_CALL_AIMPL_4(rc, pImpl->pfnU16, pu16AX, pu16DX, u16Value, pEFlags); \
     13988                IEM_MC_IF_LOCAL_IS_Z(rc) { \
     13989                    IEM_MC_ADVANCE_RIP_AND_FINISH(); \
     13990                } IEM_MC_ELSE() { \
     13991                    IEM_MC_RAISE_DIVIDE_ERROR(); \
     13992                } IEM_MC_ENDIF(); \
     13993                \
     13994                IEM_MC_END(); \
     13995                break; \
     13996                \
     13997            case IEMMODE_32BIT: \
     13998                IEM_MC_BEGIN(4, 2, IEM_MC_F_MIN_386, 0); \
     13999                IEM_MC_ARG(uint32_t *,      pu32AX,     0); \
     14000                IEM_MC_ARG(uint32_t *,      pu32DX,     1); \
     14001                IEM_MC_ARG(uint32_t,        u32Value,   2); \
     14002                IEM_MC_ARG(uint32_t *,      pEFlags,    3); \
     14003                IEM_MC_LOCAL(RTGCPTR, GCPtrEffDst); \
     14004                IEM_MC_LOCAL(int32_t,       rc); \
     14005                \
     14006                IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 0); \
     14007                IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX(); \
     14008                IEM_MC_FETCH_MEM_U32(u32Value, pVCpu->iem.s.iEffSeg, GCPtrEffDst); \
     14009                IEM_MC_REF_GREG_U32(pu32AX, X86_GREG_xAX); \
     14010                IEM_MC_REF_GREG_U32(pu32DX, X86_GREG_xDX); \
     14011                IEM_MC_REF_EFLAGS(pEFlags); \
     14012                IEM_MC_CALL_AIMPL_4(rc, pImpl->pfnU32, pu32AX, pu32DX, u32Value, pEFlags); \
     14013                IEM_MC_IF_LOCAL_IS_Z(rc) { \
     14014                    IEM_MC_CLEAR_HIGH_GREG_U64(X86_GREG_xAX); \
     14015                    IEM_MC_CLEAR_HIGH_GREG_U64(X86_GREG_xDX); \
     14016                    IEM_MC_ADVANCE_RIP_AND_FINISH(); \
     14017                } IEM_MC_ELSE() { \
     14018                    IEM_MC_RAISE_DIVIDE_ERROR(); \
     14019                } IEM_MC_ENDIF(); \
     14020                \
     14021                IEM_MC_END(); \
     14022                break; \
     14023                \
     14024            case IEMMODE_64BIT: \
     14025                IEM_MC_BEGIN(4, 2, IEM_MC_F_64BIT, 0); \
     14026                IEM_MC_ARG(uint64_t *,      pu64AX,     0); \
     14027                IEM_MC_ARG(uint64_t *,      pu64DX,     1); \
     14028                IEM_MC_ARG(uint64_t,        u64Value,   2); \
     14029                IEM_MC_ARG(uint32_t *,      pEFlags,    3); \
     14030                IEM_MC_LOCAL(RTGCPTR, GCPtrEffDst); \
     14031                IEM_MC_LOCAL(int32_t,       rc); \
     14032                \
     14033                IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 0); \
     14034                IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX(); \
     14035                IEM_MC_FETCH_MEM_U64(u64Value, pVCpu->iem.s.iEffSeg, GCPtrEffDst); \
     14036                IEM_MC_REF_GREG_U64(pu64AX, X86_GREG_xAX); \
     14037                IEM_MC_REF_GREG_U64(pu64DX, X86_GREG_xDX); \
     14038                IEM_MC_REF_EFLAGS(pEFlags); \
     14039                IEM_MC_CALL_AIMPL_4(rc, pImpl->pfnU64, pu64AX, pu64DX, u64Value, pEFlags); \
     14040                IEM_MC_IF_LOCAL_IS_Z(rc) { \
     14041                    IEM_MC_ADVANCE_RIP_AND_FINISH(); \
     14042                } IEM_MC_ELSE() { \
     14043                    IEM_MC_RAISE_DIVIDE_ERROR(); \
     14044                } IEM_MC_ENDIF(); \
     14045                \
     14046                IEM_MC_END(); \
     14047                break; \
     14048                \
     14049            IEM_NOT_REACHED_DEFAULT_CASE_RET(); \
     14050        } \
     14051    } (void)0
    1405614052
    1405714053
    … …  
    1410214098            IEMOP_MNEMONIC(mul_Eb, "mul Eb");
    1410314099            IEMOP_VERIFICATION_UNDEFINED_EFLAGS(X86_EFL_SF | X86_EFL_ZF | X86_EFL_AF | X86_EFL_PF);
    14104             return FNIEMOP_CALL_2(iemOpCommonGrp3MulDivEb, bRm, IEMTARGETCPU_EFL_BEHAVIOR_SELECT(g_iemAImpl_mul_u8_eflags));
     14100            IEMOP_GRP3_MUL_DIV_EB(bRm, IEMTARGETCPU_EFL_BEHAVIOR_SELECT(g_iemAImpl_mul_u8_eflags));
     14101            break;
    1410514102        case 5:
    1410614103            /**
    … …  
    1411214109            IEMOP_MNEMONIC(imul_Eb, "imul Eb");
    1411314110            IEMOP_VERIFICATION_UNDEFINED_EFLAGS(X86_EFL_SF | X86_EFL_ZF | X86_EFL_AF | X86_EFL_PF);
    14114             return FNIEMOP_CALL_2(iemOpCommonGrp3MulDivEb, bRm, IEMTARGETCPU_EFL_BEHAVIOR_SELECT(g_iemAImpl_imul_u8_eflags));
     14111            IEMOP_GRP3_MUL_DIV_EB(bRm, IEMTARGETCPU_EFL_BEHAVIOR_SELECT(g_iemAImpl_imul_u8_eflags));
     14112            break;
    1411514113        case 6:
    1411614114            /**
    … …  
    1412214120            IEMOP_MNEMONIC(div_Eb, "div Eb");
    1412314121            IEMOP_VERIFICATION_UNDEFINED_EFLAGS(X86_EFL_SF | X86_EFL_ZF | X86_EFL_AF | X86_EFL_PF | X86_EFL_OF | X86_EFL_CF);
    14124             return FNIEMOP_CALL_2(iemOpCommonGrp3MulDivEb, bRm, IEMTARGETCPU_EFL_BEHAVIOR_SELECT(g_iemAImpl_div_u8_eflags));
     14122            IEMOP_GRP3_MUL_DIV_EB(bRm, IEMTARGETCPU_EFL_BEHAVIOR_SELECT(g_iemAImpl_div_u8_eflags));
     14123            break;
    1412514124        case 7:
    1412614125            /**
    … …  
    1413214131            IEMOP_MNEMONIC(idiv_Eb, "idiv Eb");
    1413314132            IEMOP_VERIFICATION_UNDEFINED_EFLAGS(X86_EFL_SF | X86_EFL_ZF | X86_EFL_AF | X86_EFL_PF | X86_EFL_OF | X86_EFL_CF);
    14134             return FNIEMOP_CALL_2(iemOpCommonGrp3MulDivEb, bRm, IEMTARGETCPU_EFL_BEHAVIOR_SELECT(g_iemAImpl_idiv_u8_eflags));
     14133            IEMOP_GRP3_MUL_DIV_EB(bRm, IEMTARGETCPU_EFL_BEHAVIOR_SELECT(g_iemAImpl_idiv_u8_eflags));
     14134            break;
    1413514135        IEM_NOT_REACHED_DEFAULT_CASE_RET();
    1413614136    }
    … …  
    1432714327            IEMOP_MNEMONIC(mul_Ev, "mul Ev");
    1432814328            IEMOP_VERIFICATION_UNDEFINED_EFLAGS(X86_EFL_SF | X86_EFL_ZF | X86_EFL_AF | X86_EFL_PF);
    14329             return FNIEMOP_CALL_2(iemOpCommonGrp3MulDivEv, bRm, IEMTARGETCPU_EFL_BEHAVIOR_SELECT(g_iemAImpl_mul_eflags));
     14329            IEMOP_BODY_GRP3_MUL_DIV_EV(bRm, IEMTARGETCPU_EFL_BEHAVIOR_SELECT(g_iemAImpl_mul_eflags));
     14330            break;
    1433014331        case 5:
    1433114332            /**
    … …  
    1433714338            IEMOP_MNEMONIC(imul_Ev, "imul Ev");
    1433814339            IEMOP_VERIFICATION_UNDEFINED_EFLAGS(X86_EFL_SF | X86_EFL_ZF | X86_EFL_AF | X86_EFL_PF);
    14339             return FNIEMOP_CALL_2(iemOpCommonGrp3MulDivEv, bRm, IEMTARGETCPU_EFL_BEHAVIOR_SELECT(g_iemAImpl_imul_eflags));
     14340            IEMOP_BODY_GRP3_MUL_DIV_EV(bRm, IEMTARGETCPU_EFL_BEHAVIOR_SELECT(g_iemAImpl_imul_eflags));
     14341            break;
    1434014342        case 6:
    1434114343            /**
    … …  
    1434714349            IEMOP_MNEMONIC(div_Ev, "div Ev");
    1434814350            IEMOP_VERIFICATION_UNDEFINED_EFLAGS(X86_EFL_SF | X86_EFL_ZF | X86_EFL_AF | X86_EFL_PF | X86_EFL_OF | X86_EFL_CF);
    14349             return FNIEMOP_CALL_2(iemOpCommonGrp3MulDivEv, bRm, IEMTARGETCPU_EFL_BEHAVIOR_SELECT(g_iemAImpl_div_eflags));
     14351            IEMOP_BODY_GRP3_MUL_DIV_EV(bRm, IEMTARGETCPU_EFL_BEHAVIOR_SELECT(g_iemAImpl_div_eflags));
     14352            break;
    1435014353        case 7:
    1435114354            /**
    … …  
    1435714360            IEMOP_MNEMONIC(idiv_Ev, "idiv Ev");
    1435814361            IEMOP_VERIFICATION_UNDEFINED_EFLAGS(X86_EFL_SF | X86_EFL_ZF | X86_EFL_AF | X86_EFL_PF | X86_EFL_OF | X86_EFL_CF);
    14359             return FNIEMOP_CALL_2(iemOpCommonGrp3MulDivEv, bRm, IEMTARGETCPU_EFL_BEHAVIOR_SELECT(g_iemAImpl_idiv_eflags));
     14362            IEMOP_BODY_GRP3_MUL_DIV_EV(bRm, IEMTARGETCPU_EFL_BEHAVIOR_SELECT(g_iemAImpl_idiv_eflags));
     14363            break;
    1436014364        IEM_NOT_REACHED_DEFAULT_CASE_RET();
    1436114365    }
Note: See TracChangeset for help on using the changeset viewer.

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