VirtualBox

Changeset 97534 in vbox


Ignore:
Timestamp:
Nov 14, 2022 4:55:57 PM (2 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
154563
Message:

IEM: Reworked [V]MOVxDUP to be done directly in microcode. Added MOVBE instruction.

Location:
trunk/src/VBox/VMM
Files:
8 edited

Legend:

Unmodified
Added
Removed

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

    r97337 r97534  
    75867586*********************************************************************************************************************************/
    75877587
     7588#ifdef IEM_WITH_VEX
     7589
    75887590/*
    7589  * MOVSLDUP / VMOVSLDUP
    7590  */
    7591 IEM_DECL_IMPL_DEF(void, iemAImpl_movsldup,(PRTUINT128U puDst, PCRTUINT128U puSrc))
    7592 {
    7593     puDst->au32[0] = puSrc->au32[0];
    7594     puDst->au32[1] = puSrc->au32[0];
    7595     puDst->au32[2] = puSrc->au32[2];
    7596     puDst->au32[3] = puSrc->au32[2];
    7597 }
    7598 
    7599 #ifdef IEM_WITH_VEX
    7600 
     7591 * VMOVSLDUP
     7592 */
    76017593IEM_DECL_IMPL_DEF(void, iemAImpl_vmovsldup_256_rr,(PX86XSAVEAREA pXState, uint8_t iYRegDst, uint8_t iYRegSrc))
    76027594{
    … …  
    76277619
    76287620
     7621#ifdef IEM_WITH_VEX
     7622
    76297623/*
    7630  * MOVSHDUP / VMOVSHDUP
    7631  */
    7632 IEM_DECL_IMPL_DEF(void, iemAImpl_movshdup,(PRTUINT128U puDst, PCRTUINT128U puSrc))
    7633 {
    7634     puDst->au32[0] = puSrc->au32[1];
    7635     puDst->au32[1] = puSrc->au32[1];
    7636     puDst->au32[2] = puSrc->au32[3];
    7637     puDst->au32[3] = puSrc->au32[3];
    7638 }
    7639 
    7640 #ifdef IEM_WITH_VEX
    7641 
     7624 * VMOVSHDUP
     7625 */
    76427626IEM_DECL_IMPL_DEF(void, iemAImpl_vmovshdup_256_rr,(PX86XSAVEAREA pXState, uint8_t iYRegDst, uint8_t iYRegSrc))
    76437627{
    … …  
    76687652
    76697653
     7654#ifdef IEM_WITH_VEX
     7655
    76707656/*
    7671  * MOVDDUP / VMOVDDUP
    7672  */
    7673 IEM_DECL_IMPL_DEF(void, iemAImpl_movddup,(PRTUINT128U puDst, uint64_t uSrc))
    7674 {
    7675     puDst->au64[0] = uSrc;
    7676     puDst->au64[1] = uSrc;
    7677 }
    7678 
    7679 #ifdef IEM_WITH_VEX
    7680 
     7657 * VMOVDDUP
     7658 */
    76817659IEM_DECL_IMPL_DEF(void, iemAImpl_vmovddup_256_rr,(PX86XSAVEAREA pXState, uint8_t iYRegDst, uint8_t iYRegSrc))
    76827660{

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

    r97361 r97534  
    15091509
    15101510
    1511 /** Opcode      0x0f 0x38 0xf0. */
    1512 FNIEMOP_STUB(iemOp_movbe_Gy_My);
    1513 /** Opcode 0x66 0x0f 0x38 0xf0. */
    1514 FNIEMOP_STUB(iemOp_movbe_Gw_Mw);
     1511/** Opcode      [0x66] 0x0f 0x38 0xf0. */
     1512FNIEMOP_DEF(iemOp_movbe_Gv_Mv)
     1513{
     1514    IEMOP_MNEMONIC2(RM, MOVBE, movbe, Gv, Ev, DISOPTYPE_HARMLESS, 0);
     1515    if (!IEM_GET_GUEST_CPU_FEATURES(pVCpu)->fMovBe)
     1516        return iemOp_InvalidNeedRM(pVCpu);
     1517
     1518    uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
     1519    if (!IEM_IS_MODRM_REG_MODE(bRm))
     1520    {
     1521        /*
     1522         * Register, memory.
     1523         */
     1524        switch (pVCpu->iem.s.enmEffOpSize)
     1525        {
     1526            case IEMMODE_16BIT:
     1527                IEM_MC_BEGIN(0, 2);
     1528                IEM_MC_LOCAL(uint16_t,  uSrc);
     1529                IEM_MC_LOCAL(RTGCPTR,   GCPtrEffSrc);
     1530
     1531                IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffSrc, bRm, 0);
     1532                IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
     1533                IEM_MC_FETCH_MEM_U16(uSrc, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
     1534
     1535                IEM_MC_BSWAP_LOCAL_U16(uSrc);
     1536                IEM_MC_STORE_GREG_U16(IEM_GET_MODRM_REG(pVCpu, bRm), uSrc);
     1537
     1538                IEM_MC_ADVANCE_RIP_AND_FINISH();
     1539                IEM_MC_END();
     1540                break;
     1541
     1542            case IEMMODE_32BIT:
     1543                IEM_MC_BEGIN(0, 2);
     1544                IEM_MC_LOCAL(uint32_t,  uSrc);
     1545                IEM_MC_LOCAL(RTGCPTR,   GCPtrEffSrc);
     1546
     1547                IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffSrc, bRm, 0);
     1548                IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
     1549                IEM_MC_FETCH_MEM_U32(uSrc, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
     1550
     1551                IEM_MC_BSWAP_LOCAL_U32(uSrc);
     1552                IEM_MC_STORE_GREG_U32(IEM_GET_MODRM_REG(pVCpu, bRm), uSrc);
     1553
     1554                IEM_MC_ADVANCE_RIP_AND_FINISH();
     1555                IEM_MC_END();
     1556                break;
     1557
     1558            case IEMMODE_64BIT:
     1559                IEM_MC_BEGIN(0, 2);
     1560                IEM_MC_LOCAL(uint64_t,  uSrc);
     1561                IEM_MC_LOCAL(RTGCPTR,   GCPtrEffSrc);
     1562
     1563                IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffSrc, bRm, 0);
     1564                IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
     1565                IEM_MC_FETCH_MEM_U64(uSrc, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
     1566
     1567                IEM_MC_BSWAP_LOCAL_U64(uSrc);
     1568                IEM_MC_STORE_GREG_U64(IEM_GET_MODRM_REG(pVCpu, bRm), uSrc);
     1569
     1570                IEM_MC_ADVANCE_RIP_AND_FINISH();
     1571                IEM_MC_END();
     1572                break;
     1573
     1574            IEM_NOT_REACHED_DEFAULT_CASE_RET();
     1575        }
     1576    }
     1577    else
     1578    {
     1579        /* Reg/reg not supported. */
     1580        return IEMOP_RAISE_INVALID_OPCODE();
     1581    }
     1582}
     1583
     1584
    15151585/*  Opcode 0xf3 0x0f 0x38 0xf0 - invalid. */
    15161586
    … …  
    15641634
    15651635
    1566 /** Opcode      0x0f 0x38 0xf1. */
    1567 FNIEMOP_STUB(iemOp_movbe_My_Gy);
    1568 /** Opcode 0x66 0x0f 0x38 0xf1. */
    1569 FNIEMOP_STUB(iemOp_movbe_Mw_Gw);
     1636/** Opcode      [0x66] 0x0f 0x38 0xf1. */
     1637FNIEMOP_DEF(iemOp_movbe_Mv_Gv)
     1638{
     1639    IEMOP_MNEMONIC2(MR, MOVBE, movbe, Ev, Gv, DISOPTYPE_HARMLESS, 0);
     1640    if (!IEM_GET_GUEST_CPU_FEATURES(pVCpu)->fMovBe)
     1641        return iemOp_InvalidNeedRM(pVCpu);
     1642
     1643    uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
     1644    if (!IEM_IS_MODRM_REG_MODE(bRm))
     1645    {
     1646        /*
     1647         * Memory, register.
     1648         */
     1649        switch (pVCpu->iem.s.enmEffOpSize)
     1650        {
     1651            case IEMMODE_16BIT:
     1652                IEM_MC_BEGIN(0, 2);
     1653                IEM_MC_LOCAL(uint16_t, u16Value);
     1654                IEM_MC_LOCAL(RTGCPTR, GCPtrEffDst);
     1655                IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 0);
     1656                IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
     1657                IEM_MC_FETCH_GREG_U16(u16Value, IEM_GET_MODRM_REG(pVCpu, bRm));
     1658                IEM_MC_BSWAP_LOCAL_U16(u16Value);
     1659                IEM_MC_STORE_MEM_U16(pVCpu->iem.s.iEffSeg, GCPtrEffDst, u16Value);
     1660                IEM_MC_ADVANCE_RIP_AND_FINISH();
     1661                IEM_MC_END();
     1662                break;
     1663
     1664            case IEMMODE_32BIT:
     1665                IEM_MC_BEGIN(0, 2);
     1666                IEM_MC_LOCAL(uint32_t, u32Value);
     1667                IEM_MC_LOCAL(RTGCPTR, GCPtrEffDst);
     1668                IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 0);
     1669                IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
     1670                IEM_MC_FETCH_GREG_U32(u32Value, IEM_GET_MODRM_REG(pVCpu, bRm));
     1671                IEM_MC_BSWAP_LOCAL_U32(u32Value);
     1672                IEM_MC_STORE_MEM_U32(pVCpu->iem.s.iEffSeg, GCPtrEffDst, u32Value);
     1673                IEM_MC_ADVANCE_RIP_AND_FINISH();
     1674                IEM_MC_END();
     1675                break;
     1676
     1677            case IEMMODE_64BIT:
     1678                IEM_MC_BEGIN(0, 2);
     1679                IEM_MC_LOCAL(uint64_t, u64Value);
     1680                IEM_MC_LOCAL(RTGCPTR, GCPtrEffDst);
     1681                IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 0);
     1682                IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
     1683                IEM_MC_FETCH_GREG_U64(u64Value, IEM_GET_MODRM_REG(pVCpu, bRm));
     1684                IEM_MC_BSWAP_LOCAL_U64(u64Value);
     1685                IEM_MC_STORE_MEM_U64(pVCpu->iem.s.iEffSeg, GCPtrEffDst, u64Value);
     1686                IEM_MC_ADVANCE_RIP_AND_FINISH();
     1687                IEM_MC_END();
     1688                break;
     1689
     1690            IEM_NOT_REACHED_DEFAULT_CASE_RET();
     1691        }
     1692    }
     1693    else
     1694    {
     1695        /* Reg/reg not supported. */
     1696        return IEMOP_RAISE_INVALID_OPCODE();
     1697    }
     1698}
     1699
     1700
    15701701/*  Opcode 0xf3 0x0f 0x38 0xf1 - invalid. */
    15711702
    … …  
    20342165    /* 0xef */  IEMOP_X4(iemOp_InvalidNeedRM),
    20352166
    2036     /* 0xf0 */  iemOp_movbe_Gy_My,          iemOp_movbe_Gw_Mw,          iemOp_InvalidNeedRM,        iemOp_crc32_Gd_Eb,
    2037     /* 0xf1 */  iemOp_movbe_My_Gy,          iemOp_movbe_Mw_Gw,          iemOp_InvalidNeedRM,        iemOp_crc32_Gv_Ev,
     2167    /* 0xf0 */  iemOp_movbe_Gv_Mv,          iemOp_movbe_Gv_Mv,          iemOp_InvalidNeedRM,        iemOp_crc32_Gd_Eb,
     2168    /* 0xf1 */  iemOp_movbe_Mv_Gv,          iemOp_movbe_Mv_Gv,          iemOp_InvalidNeedRM,        iemOp_crc32_Gv_Ev,
    20382169    /* 0xf2 */  IEMOP_X4(iemOp_InvalidNeedRM),
    20392170    /* 0xf3 */  IEMOP_X4(iemOp_InvalidNeedRM),

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

    r97479 r97534  
    351351/** Opcode 0x66 0x0f 0x21, */
    352352FNIEMOP_STUB(iemOp_insertps_Vdq_UdqMd_Ib);
    353 /** Opcode 0x66 0x0f 0x22. */
    354 FNIEMOP_STUB(iemOp_pinsrd_q_Vdq_Ey_Ib);
     353
     354
     355FNIEMOP_DEF(iemOp_pinsrd_q_Vdq_Ey_Ib)
     356{
     357    uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
     358    if (pVCpu->iem.s.fPrefixes & IEM_OP_PRF_SIZE_REX_W)
     359    {
     360        /**
     361         * @opcode      0x22
     362         * @opcodesub   rex.w=1
     363         * @oppfx       0x66
     364         * @opcpuid     sse
     365         */
     366        IEMOP_MNEMONIC3(RMI, PINSRQ, pinsrq, Vq, Ey, Ib, DISOPTYPE_HARMLESS | DISOPTYPE_SSE, IEMOPHINT_IGNORES_OZ_PFX);
     367        if (IEM_IS_MODRM_REG_MODE(bRm))
     368        {
     369            /*
     370             * XMM, greg64.
     371             */
     372            uint8_t bImm; IEM_OPCODE_GET_NEXT_U8(&bImm);
     373            IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
     374            IEM_MC_BEGIN(0, 1);
     375            IEM_MC_LOCAL(uint64_t,  uSrc);
     376            IEM_MC_MAYBE_RAISE_SSE41_RELATED_XCPT();
     377            IEM_MC_PREPARE_SSE_USAGE();
     378            IEM_MC_FETCH_GREG_U64(uSrc, IEM_GET_MODRM_RM(pVCpu, bRm));
     379            IEM_MC_AND_LOCAL_U8(bImm, 1);
     380            IEM_MC_STORE_XREG_U64(IEM_GET_MODRM_REG(pVCpu, bRm), bImm /*a_iQword*/, uSrc);
     381            IEM_MC_ADVANCE_RIP_AND_FINISH();
     382            IEM_MC_END();
     383        }
     384        else
     385        {
     386            /*
     387             * XMM, [mem64].
     388             */
     389            IEM_MC_BEGIN(0, 2);
     390            IEM_MC_LOCAL(uint64_t,  uSrc);
     391            IEM_MC_LOCAL(RTGCPTR,   GCPtrEffSrc);
     392
     393            IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffSrc, bRm, 1);
     394            uint8_t bImm; IEM_OPCODE_GET_NEXT_U8(&bImm);
     395            IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
     396            IEM_MC_MAYBE_RAISE_SSE41_RELATED_XCPT();
     397            IEM_MC_PREPARE_SSE_USAGE();
     398
     399            IEM_MC_FETCH_MEM_U64(uSrc, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
     400            IEM_MC_AND_LOCAL_U8(bImm, 1);
     401            IEM_MC_STORE_XREG_U64(IEM_GET_MODRM_REG(pVCpu, bRm), bImm /*a_iQword*/, uSrc);
     402            IEM_MC_ADVANCE_RIP_AND_FINISH();
     403            IEM_MC_END();
     404        }
     405    }
     406    else
     407    {
     408        /**
     409         * @opdone
     410         * @opcode      0x22
     411         * @opcodesub   rex.w=0
     412         * @oppfx       0x66
     413         * @opcpuid     sse
     414         */
     415        IEMOP_MNEMONIC3(RMI, PINSRD, pinsrd, Vd, Ey, Ib, DISOPTYPE_HARMLESS | DISOPTYPE_SSE, IEMOPHINT_IGNORES_OZ_PFX);
     416        if (IEM_IS_MODRM_REG_MODE(bRm))
     417        {
     418            /*
     419             * XMM, greg32.
     420             */
     421            uint8_t bImm; IEM_OPCODE_GET_NEXT_U8(&bImm);
     422            IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
     423            IEM_MC_BEGIN(0, 1);
     424            IEM_MC_LOCAL(uint32_t,  uSrc);
     425            IEM_MC_MAYBE_RAISE_SSE41_RELATED_XCPT();
     426            IEM_MC_PREPARE_SSE_USAGE();
     427            IEM_MC_FETCH_GREG_U32(uSrc, IEM_GET_MODRM_RM(pVCpu, bRm));
     428            IEM_MC_AND_LOCAL_U8(bImm, 3);
     429            IEM_MC_STORE_XREG_U32(IEM_GET_MODRM_REG(pVCpu, bRm), bImm /*a_iDword*/, uSrc);
     430            IEM_MC_ADVANCE_RIP_AND_FINISH();
     431            IEM_MC_END();
     432        }
     433        else
     434        {
     435            /*
     436             * XMM, [mem32].
     437             */
     438            IEM_MC_BEGIN(0, 2);
     439            IEM_MC_LOCAL(uint32_t,  uSrc);
     440            IEM_MC_LOCAL(RTGCPTR,   GCPtrEffSrc);
     441
     442            IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffSrc, bRm, 1);
     443            uint8_t bImm; IEM_OPCODE_GET_NEXT_U8(&bImm);
     444            IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
     445            IEM_MC_MAYBE_RAISE_SSE41_RELATED_XCPT();
     446            IEM_MC_PREPARE_SSE_USAGE();
     447
     448            IEM_MC_FETCH_MEM_U32(uSrc, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
     449            IEM_MC_AND_LOCAL_U8(bImm, 3);
     450            IEM_MC_STORE_XREG_U32(IEM_GET_MODRM_REG(pVCpu, bRm), bImm /*a_iDword*/, uSrc);
     451            IEM_MC_ADVANCE_RIP_AND_FINISH();
     452            IEM_MC_END();
     453        }
     454    }
     455}
     456
     457
    355458/*  Opcode 0x66 0x0f 0x23 - invalid */
    356459/*  Opcode 0x66 0x0f 0x24 - invalid */

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

    r97479 r97534  
    22232223        IEM_MC_ACTUALIZE_SSE_STATE_FOR_CHANGE();
    22242224        IEM_MC_FETCH_XREG_U32(uSrc, IEM_GET_MODRM_RM(pVCpu, bRm));
    2225         IEM_MC_STORE_XREG_U32(IEM_GET_MODRM_REG(pVCpu, bRm), uSrc);
     2225        IEM_MC_STORE_XREG_U32(IEM_GET_MODRM_REG(pVCpu, bRm), 0 /*a_iDword*/, uSrc);
    22262226
    22272227        IEM_MC_ADVANCE_RIP_AND_FINISH();
    … …  
    22762276        IEM_MC_ACTUALIZE_SSE_STATE_FOR_CHANGE();
    22772277        IEM_MC_FETCH_XREG_U64(uSrc, IEM_GET_MODRM_RM(pVCpu, bRm));
    2278         IEM_MC_STORE_XREG_U64(IEM_GET_MODRM_REG(pVCpu, bRm), uSrc);
     2278        IEM_MC_STORE_XREG_U64(IEM_GET_MODRM_REG(pVCpu, bRm), 0 /* a_iQword*/, uSrc);
    22792279
    22802280        IEM_MC_ADVANCE_RIP_AND_FINISH();
    … …  
    24292429        IEM_MC_ACTUALIZE_SSE_STATE_FOR_CHANGE();
    24302430        IEM_MC_FETCH_XREG_U32(uSrc, IEM_GET_MODRM_REG(pVCpu, bRm));
    2431         IEM_MC_STORE_XREG_U32(IEM_GET_MODRM_RM(pVCpu, bRm), uSrc);
     2431        IEM_MC_STORE_XREG_U32(IEM_GET_MODRM_RM(pVCpu, bRm), 0 /*a_iDword*/, uSrc);
    24322432
    24332433        IEM_MC_ADVANCE_RIP_AND_FINISH();
    … …  
    24822482        IEM_MC_ACTUALIZE_SSE_STATE_FOR_CHANGE();
    24832483        IEM_MC_FETCH_XREG_U64(uSrc, IEM_GET_MODRM_REG(pVCpu, bRm));
    2484         IEM_MC_STORE_XREG_U64(IEM_GET_MODRM_RM(pVCpu, bRm), uSrc);
     2484        IEM_MC_STORE_XREG_U64(IEM_GET_MODRM_RM(pVCpu, bRm), 0 /* a_iQword*/, uSrc);
    24852485
    24862486        IEM_MC_ADVANCE_RIP_AND_FINISH();
    … …  
    25342534        IEM_MC_ACTUALIZE_SSE_STATE_FOR_CHANGE();
    25352535        IEM_MC_FETCH_XREG_HI_U64(uSrc, IEM_GET_MODRM_RM(pVCpu, bRm));
    2536         IEM_MC_STORE_XREG_U64(IEM_GET_MODRM_REG(pVCpu, bRm), uSrc);
     2536        IEM_MC_STORE_XREG_U64(IEM_GET_MODRM_REG(pVCpu, bRm), 0 /* a_iQword*/, uSrc);
    25372537
    25382538        IEM_MC_ADVANCE_RIP_AND_FINISH();
    … …  
    25652565
    25662566        IEM_MC_FETCH_MEM_U64(uSrc, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
    2567         IEM_MC_STORE_XREG_U64(IEM_GET_MODRM_REG(pVCpu, bRm), uSrc);
     2567        IEM_MC_STORE_XREG_U64(IEM_GET_MODRM_REG(pVCpu, bRm), 0 /* a_iQword*/, uSrc);
    25682568
    25692569        IEM_MC_ADVANCE_RIP_AND_FINISH();
    … …  
    26002600
    26012601        IEM_MC_FETCH_MEM_U64(uSrc, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
    2602         IEM_MC_STORE_XREG_U64(IEM_GET_MODRM_REG(pVCpu, bRm), uSrc);
     2602        IEM_MC_STORE_XREG_U64(IEM_GET_MODRM_REG(pVCpu, bRm), 0 /* a_iQword*/, uSrc);
    26032603
    26042604        IEM_MC_ADVANCE_RIP_AND_FINISH();
    … …  
    26372637    {
    26382638        /*
    2639          * Register, register.
    2640          */
    2641         IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
    2642         IEM_MC_BEGIN(2, 0);
    2643         IEM_MC_ARG(PRTUINT128U,                 puDst, 0);
    2644         IEM_MC_ARG(PCRTUINT128U,                puSrc, 1);
     2639         * XMM, XMM.
     2640         */
     2641        IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
     2642        IEM_MC_BEGIN(0, 1);
     2643        IEM_MC_LOCAL(RTUINT128U,                uSrc);
    26452644
    26462645        IEM_MC_MAYBE_RAISE_SSE3_RELATED_XCPT();
    26472646        IEM_MC_PREPARE_SSE_USAGE();
    26482647
    2649         IEM_MC_REF_XREG_U128_CONST(puSrc, IEM_GET_MODRM_RM(pVCpu, bRm));
    2650         IEM_MC_REF_XREG_U128(puDst, IEM_GET_MODRM_REG(pVCpu, bRm));
    2651         IEM_MC_CALL_VOID_AIMPL_2(iemAImpl_movsldup, puDst, puSrc);
    2652 
    2653         IEM_MC_ADVANCE_RIP_AND_FINISH();
    2654         IEM_MC_END();
    2655     }
    2656     else
    2657     {
    2658         /*
    2659          * Register, memory.
    2660          */
    2661         IEM_MC_BEGIN(2, 2);
     2648        IEM_MC_FETCH_XREG_U128(uSrc, IEM_GET_MODRM_RM(pVCpu, bRm));
     2649        IEM_MC_STORE_XREG_U32_U128(IEM_GET_MODRM_REG(pVCpu, bRm), 0, uSrc, 0);
     2650        IEM_MC_STORE_XREG_U32_U128(IEM_GET_MODRM_REG(pVCpu, bRm), 1, uSrc, 0);
     2651        IEM_MC_STORE_XREG_U32_U128(IEM_GET_MODRM_REG(pVCpu, bRm), 2, uSrc, 2);
     2652        IEM_MC_STORE_XREG_U32_U128(IEM_GET_MODRM_REG(pVCpu, bRm), 3, uSrc, 2);
     2653
     2654        IEM_MC_ADVANCE_RIP_AND_FINISH();
     2655        IEM_MC_END();
     2656    }
     2657    else
     2658    {
     2659        /*
     2660         * XMM, [mem128].
     2661         */
     2662        IEM_MC_BEGIN(0, 2);
    26622663        IEM_MC_LOCAL(RTUINT128U,                uSrc);
    26632664        IEM_MC_LOCAL(RTGCPTR,                   GCPtrEffSrc);
    2664         IEM_MC_ARG(PRTUINT128U,                 puDst, 0);
    2665         IEM_MC_ARG_LOCAL_REF(PCRTUINT128U,      puSrc, uSrc, 1);
    26662665
    26672666        IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffSrc, bRm, 0);
    … …  
    26712670
    26722671        IEM_MC_FETCH_MEM_U128_ALIGN_SSE(uSrc, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
    2673         IEM_MC_REF_XREG_U128(puDst, IEM_GET_MODRM_REG(pVCpu, bRm));
    2674         IEM_MC_CALL_VOID_AIMPL_2(iemAImpl_movsldup, puDst, puSrc);
     2672        IEM_MC_STORE_XREG_U32_U128(IEM_GET_MODRM_REG(pVCpu, bRm), 0, uSrc, 0);
     2673        IEM_MC_STORE_XREG_U32_U128(IEM_GET_MODRM_REG(pVCpu, bRm), 1, uSrc, 0);
     2674        IEM_MC_STORE_XREG_U32_U128(IEM_GET_MODRM_REG(pVCpu, bRm), 2, uSrc, 2);
     2675        IEM_MC_STORE_XREG_U32_U128(IEM_GET_MODRM_REG(pVCpu, bRm), 3, uSrc, 2);
    26752676
    26762677        IEM_MC_ADVANCE_RIP_AND_FINISH();
    … …  
    26962697    {
    26972698        /*
    2698          * Register, register.
    2699          */
    2700         IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
    2701         IEM_MC_BEGIN(2, 0);
    2702         IEM_MC_ARG(PRTUINT128U,                 puDst, 0);
    2703         IEM_MC_ARG(uint64_t,                    uSrc, 1);
     2699         * XMM128, XMM64.
     2700         */
     2701        IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
     2702        IEM_MC_BEGIN(1, 0);
     2703        IEM_MC_ARG(uint64_t,                    uSrc, 0);
    27042704
    27052705        IEM_MC_MAYBE_RAISE_SSE3_RELATED_XCPT();
    … …  
    27072707
    27082708        IEM_MC_FETCH_XREG_U64(uSrc, IEM_GET_MODRM_RM(pVCpu, bRm));
    2709         IEM_MC_REF_XREG_U128(puDst, IEM_GET_MODRM_REG(pVCpu, bRm));
    2710         IEM_MC_CALL_VOID_AIMPL_2(iemAImpl_movddup, puDst, uSrc);
    2711 
    2712         IEM_MC_ADVANCE_RIP_AND_FINISH();
    2713         IEM_MC_END();
    2714     }
    2715     else
    2716     {
    2717         /*
    2718          * Register, memory.
    2719          */
    2720         IEM_MC_BEGIN(2, 2);
     2709        IEM_MC_STORE_XREG_U64(IEM_GET_MODRM_REG(pVCpu, bRm), 0 /* a_iQword*/, uSrc);
     2710        IEM_MC_STORE_XREG_HI_U64(IEM_GET_MODRM_REG(pVCpu, bRm), uSrc);
     2711
     2712        IEM_MC_ADVANCE_RIP_AND_FINISH();
     2713        IEM_MC_END();
     2714    }
     2715    else
     2716    {
     2717        /*
     2718         * XMM128, [mem64].
     2719         */
     2720        IEM_MC_BEGIN(1, 1);
    27212721        IEM_MC_LOCAL(RTGCPTR,                   GCPtrEffSrc);
    2722         IEM_MC_ARG(PRTUINT128U,                 puDst, 0);
    2723         IEM_MC_ARG(uint64_t,                    uSrc, 1);
     2722        IEM_MC_ARG(uint64_t,                    uSrc, 0);
    27242723
    27252724        IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffSrc, bRm, 0);
    … …  
    27292728
    27302729        IEM_MC_FETCH_MEM_U64(uSrc, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
    2731         IEM_MC_REF_XREG_U128(puDst, IEM_GET_MODRM_REG(pVCpu, bRm));
    2732         IEM_MC_CALL_VOID_AIMPL_2(iemAImpl_movddup, puDst, uSrc);
     2730        IEM_MC_STORE_XREG_U64(IEM_GET_MODRM_REG(pVCpu, bRm), 0 /* a_iQword*/, uSrc);
     2731        IEM_MC_STORE_XREG_HI_U64(IEM_GET_MODRM_REG(pVCpu, bRm), uSrc);
    27332732
    27342733        IEM_MC_ADVANCE_RIP_AND_FINISH();
    … …  
    30593058         */
    30603059        IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
    3061         IEM_MC_BEGIN(2, 0);
    3062         IEM_MC_ARG(PRTUINT128U,                 puDst, 0);
    3063         IEM_MC_ARG(PCRTUINT128U,                puSrc, 1);
     3060        IEM_MC_BEGIN(0, 1);
     3061        IEM_MC_LOCAL(RTUINT128U,                uSrc);
    30643062
    30653063        IEM_MC_MAYBE_RAISE_SSE3_RELATED_XCPT();
    30663064        IEM_MC_PREPARE_SSE_USAGE();
    30673065
    3068         IEM_MC_REF_XREG_U128_CONST(puSrc, IEM_GET_MODRM_RM(pVCpu, bRm));
    3069         IEM_MC_REF_XREG_U128(puDst, IEM_GET_MODRM_REG(pVCpu, bRm));
    3070         IEM_MC_CALL_VOID_AIMPL_2(iemAImpl_movshdup, puDst, puSrc);
     3066        IEM_MC_FETCH_XREG_U128(uSrc, IEM_GET_MODRM_RM(pVCpu, bRm));
     3067        IEM_MC_STORE_XREG_U32_U128(IEM_GET_MODRM_REG(pVCpu, bRm), 0, uSrc, 1);
     3068        IEM_MC_STORE_XREG_U32_U128(IEM_GET_MODRM_REG(pVCpu, bRm), 1, uSrc, 1);
     3069        IEM_MC_STORE_XREG_U32_U128(IEM_GET_MODRM_REG(pVCpu, bRm), 2, uSrc, 3);
     3070        IEM_MC_STORE_XREG_U32_U128(IEM_GET_MODRM_REG(pVCpu, bRm), 3, uSrc, 3);
    30713071
    30723072        IEM_MC_ADVANCE_RIP_AND_FINISH();
    … …  
    30783078         * XMM128, [mem128].
    30793079         */
    3080         IEM_MC_BEGIN(2, 2);
     3080        IEM_MC_BEGIN(0, 2);
    30813081        IEM_MC_LOCAL(RTUINT128U,                uSrc);
    30823082        IEM_MC_LOCAL(RTGCPTR,                   GCPtrEffSrc);
    3083         IEM_MC_ARG(PRTUINT128U,                 puDst, 0);
    3084         IEM_MC_ARG_LOCAL_REF(PCRTUINT128U,      puSrc, uSrc, 1);
    30853083
    30863084        IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffSrc, bRm, 0);
    … …  
    30903088
    30913089        IEM_MC_FETCH_MEM_U128_ALIGN_SSE(uSrc, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
    3092         IEM_MC_REF_XREG_U128(puDst, IEM_GET_MODRM_REG(pVCpu, bRm));
    3093         IEM_MC_CALL_VOID_AIMPL_2(iemAImpl_movshdup, puDst, puSrc);
     3090        IEM_MC_STORE_XREG_U32_U128(IEM_GET_MODRM_REG(pVCpu, bRm), 0, uSrc, 1);
     3091        IEM_MC_STORE_XREG_U32_U128(IEM_GET_MODRM_REG(pVCpu, bRm), 1, uSrc, 1);
     3092        IEM_MC_STORE_XREG_U32_U128(IEM_GET_MODRM_REG(pVCpu, bRm), 2, uSrc, 3);
     3093        IEM_MC_STORE_XREG_U32_U128(IEM_GET_MODRM_REG(pVCpu, bRm), 3, uSrc, 3);
    30943094
    30953095        IEM_MC_ADVANCE_RIP_AND_FINISH();

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

    r97479 r97534  
    11151115        if (pVCpu->iem.s.uVexLength == 0)
    11161116        {
    1117             IEM_MC_BEGIN(2, 0);
    1118             IEM_MC_ARG(PRTUINT128U,                 puDst, 0);
    1119             IEM_MC_ARG(PCRTUINT128U,                puSrc, 1);
     1117            IEM_MC_BEGIN(0, 1);
     1118            IEM_MC_LOCAL(RTUINT128U,                uSrc);
    11201119
    11211120            IEM_MC_MAYBE_RAISE_AVX_RELATED_XCPT();
    11221121            IEM_MC_PREPARE_AVX_USAGE();
    11231122
    1124             IEM_MC_REF_XREG_U128_CONST(puSrc, IEM_GET_MODRM_RM(pVCpu, bRm));
    1125             IEM_MC_REF_XREG_U128(puDst, IEM_GET_MODRM_REG(pVCpu, bRm));
    1126             IEM_MC_CALL_VOID_AIMPL_2(iemAImpl_movsldup, puDst, puSrc);
     1123            IEM_MC_FETCH_XREG_U128(uSrc, IEM_GET_MODRM_RM(pVCpu, bRm));
     1124            IEM_MC_STORE_XREG_U32_U128(IEM_GET_MODRM_REG(pVCpu, bRm), 0, uSrc, 0);
     1125            IEM_MC_STORE_XREG_U32_U128(IEM_GET_MODRM_REG(pVCpu, bRm), 1, uSrc, 0);
     1126            IEM_MC_STORE_XREG_U32_U128(IEM_GET_MODRM_REG(pVCpu, bRm), 2, uSrc, 2);
     1127            IEM_MC_STORE_XREG_U32_U128(IEM_GET_MODRM_REG(pVCpu, bRm), 3, uSrc, 2);
    11271128            IEM_MC_CLEAR_YREG_128_UP(IEM_GET_MODRM_REG(pVCpu, bRm));
    11281129
    … …  
    11521153        if (pVCpu->iem.s.uVexLength == 0)
    11531154        {
    1154             IEM_MC_BEGIN(2, 2);
     1155            IEM_MC_BEGIN(0, 2);
    11551156            IEM_MC_LOCAL(RTUINT128U,                uSrc);
    11561157            IEM_MC_LOCAL(RTGCPTR,                   GCPtrEffSrc);
    1157             IEM_MC_ARG(PRTUINT128U,                 puDst, 0);
    1158             IEM_MC_ARG_LOCAL_REF(PCRTUINT128U,      puSrc, uSrc, 1);
    11591158
    11601159            IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffSrc, bRm, 0);
    … …  
    11641163
    11651164            IEM_MC_FETCH_MEM_U128(uSrc, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
    1166             IEM_MC_REF_XREG_U128(puDst, IEM_GET_MODRM_REG(pVCpu, bRm));
    1167             IEM_MC_CALL_VOID_AIMPL_2(iemAImpl_movsldup, puDst, puSrc);
     1165            IEM_MC_STORE_XREG_U32_U128(IEM_GET_MODRM_REG(pVCpu, bRm), 0, uSrc, 0);
     1166            IEM_MC_STORE_XREG_U32_U128(IEM_GET_MODRM_REG(pVCpu, bRm), 1, uSrc, 0);
     1167            IEM_MC_STORE_XREG_U32_U128(IEM_GET_MODRM_REG(pVCpu, bRm), 2, uSrc, 2);
     1168            IEM_MC_STORE_XREG_U32_U128(IEM_GET_MODRM_REG(pVCpu, bRm), 3, uSrc, 2);
    11681169            IEM_MC_CLEAR_YREG_128_UP(IEM_GET_MODRM_REG(pVCpu, bRm));
    11691170
    … …  
    12181219        if (pVCpu->iem.s.uVexLength == 0)
    12191220        {
    1220             IEM_MC_BEGIN(2, 0);
    1221             IEM_MC_ARG(PRTUINT128U,                 puDst, 0);
    1222             IEM_MC_ARG(uint64_t,                    uSrc, 1);
     1221            IEM_MC_BEGIN(1, 0);
     1222            IEM_MC_ARG(uint64_t,                    uSrc, 0);
    12231223
    12241224            IEM_MC_MAYBE_RAISE_AVX_RELATED_XCPT();
    … …  
    12261226
    12271227            IEM_MC_FETCH_XREG_U64(uSrc, IEM_GET_MODRM_RM(pVCpu, bRm));
    1228             IEM_MC_REF_XREG_U128(puDst, IEM_GET_MODRM_REG(pVCpu, bRm));
    1229             IEM_MC_CALL_VOID_AIMPL_2(iemAImpl_movddup, puDst, uSrc);
     1228            IEM_MC_STORE_XREG_U64(IEM_GET_MODRM_REG(pVCpu, bRm), 0 /* a_iQword*/, uSrc);
     1229            IEM_MC_STORE_XREG_U64(IEM_GET_MODRM_REG(pVCpu, bRm), 1 /* a_iQword*/, uSrc);
    12301230            IEM_MC_CLEAR_YREG_128_UP(IEM_GET_MODRM_REG(pVCpu, bRm));
    12311231
    … …  
    12551255        if (pVCpu->iem.s.uVexLength == 0)
    12561256        {
    1257             IEM_MC_BEGIN(2, 2);
     1257            IEM_MC_BEGIN(1, 1);
    12581258            IEM_MC_LOCAL(RTGCPTR,                   GCPtrEffSrc);
    1259             IEM_MC_ARG(PRTUINT128U,                 puDst, 0);
    1260             IEM_MC_ARG(uint64_t,                    uSrc, 1);
     1259            IEM_MC_ARG(uint64_t,                    uSrc, 0);
    12611260
    12621261            IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffSrc, bRm, 0);
    … …  
    12661265
    12671266            IEM_MC_FETCH_MEM_U64(uSrc, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
    1268             IEM_MC_REF_XREG_U128(puDst, IEM_GET_MODRM_REG(pVCpu, bRm));
    1269             IEM_MC_CALL_VOID_AIMPL_2(iemAImpl_movddup, puDst, uSrc);
     1267            IEM_MC_STORE_XREG_U64(IEM_GET_MODRM_REG(pVCpu, bRm), 0 /* a_iQword*/, uSrc);
     1268            IEM_MC_STORE_XREG_U64(IEM_GET_MODRM_REG(pVCpu, bRm), 1 /* a_iQword*/, uSrc);
    12701269            IEM_MC_CLEAR_YREG_128_UP(IEM_GET_MODRM_REG(pVCpu, bRm));
    12711270
    … …  
    15681567        if (pVCpu->iem.s.uVexLength == 0)
    15691568        {
    1570             IEM_MC_BEGIN(2, 0);
    1571             IEM_MC_ARG(PRTUINT128U,                 puDst, 0);
    1572             IEM_MC_ARG(PCRTUINT128U,                puSrc, 1);
     1569            IEM_MC_BEGIN(0, 1);
     1570            IEM_MC_LOCAL(RTUINT128U,                  uSrc);
    15731571
    15741572            IEM_MC_MAYBE_RAISE_AVX_RELATED_XCPT();
    15751573            IEM_MC_PREPARE_AVX_USAGE();
    15761574
    1577             IEM_MC_REF_XREG_U128_CONST(puSrc, IEM_GET_MODRM_RM(pVCpu, bRm));
    1578             IEM_MC_REF_XREG_U128(puDst, IEM_GET_MODRM_REG(pVCpu, bRm));
    1579             IEM_MC_CALL_VOID_AIMPL_2(iemAImpl_movshdup, puDst, puSrc);
     1575            IEM_MC_FETCH_XREG_U128(uSrc, IEM_GET_MODRM_RM(pVCpu, bRm));
     1576            IEM_MC_STORE_XREG_U32_U128(IEM_GET_MODRM_REG(pVCpu, bRm), 0, uSrc, 1);
     1577            IEM_MC_STORE_XREG_U32_U128(IEM_GET_MODRM_REG(pVCpu, bRm), 1, uSrc, 1);
     1578            IEM_MC_STORE_XREG_U32_U128(IEM_GET_MODRM_REG(pVCpu, bRm), 2, uSrc, 3);
     1579            IEM_MC_STORE_XREG_U32_U128(IEM_GET_MODRM_REG(pVCpu, bRm), 3, uSrc, 3);
    15801580            IEM_MC_CLEAR_YREG_128_UP(IEM_GET_MODRM_REG(pVCpu, bRm));
    15811581
    … …  
    16051605        if (pVCpu->iem.s.uVexLength == 0)
    16061606        {
    1607             IEM_MC_BEGIN(2, 2);
     1607            IEM_MC_BEGIN(0, 2);
    16081608            IEM_MC_LOCAL(RTUINT128U,                uSrc);
    16091609            IEM_MC_LOCAL(RTGCPTR,                   GCPtrEffSrc);
    1610             IEM_MC_ARG(PRTUINT128U,                 puDst, 0);
    1611             IEM_MC_ARG_LOCAL_REF(PCRTUINT128U,      puSrc, uSrc, 1);
    16121610
    16131611            IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffSrc, bRm, 0);
    … …  
    16171615
    16181616            IEM_MC_FETCH_MEM_U128(uSrc, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
    1619             IEM_MC_REF_XREG_U128(puDst, IEM_GET_MODRM_REG(pVCpu, bRm));
    1620             IEM_MC_CALL_VOID_AIMPL_2(iemAImpl_movshdup, puDst, puSrc);
     1617            IEM_MC_STORE_XREG_U32_U128(IEM_GET_MODRM_REG(pVCpu, bRm), 0, uSrc, 1);
     1618            IEM_MC_STORE_XREG_U32_U128(IEM_GET_MODRM_REG(pVCpu, bRm), 1, uSrc, 1);
     1619            IEM_MC_STORE_XREG_U32_U128(IEM_GET_MODRM_REG(pVCpu, bRm), 2, uSrc, 3);
     1620            IEM_MC_STORE_XREG_U32_U128(IEM_GET_MODRM_REG(pVCpu, bRm), 3, uSrc, 3);
    16211621            IEM_MC_CLEAR_YREG_128_UP(IEM_GET_MODRM_REG(pVCpu, bRm));
    16221622

  • trunk/src/VBox/VMM/include/IEMInternal.h

    r97519 r97534  
    22082208/** @name Media (SSE/MMX/AVX) operation: Sort this later
    22092209 * @{ */
    2210 IEM_DECL_IMPL_DEF(void, iemAImpl_movsldup,(PRTUINT128U puDst, PCRTUINT128U puSrc));
    2211 IEM_DECL_IMPL_DEF(void, iemAImpl_movshdup,(PRTUINT128U puDst, PCRTUINT128U puSrc));
    2212 IEM_DECL_IMPL_DEF(void, iemAImpl_movddup,(PRTUINT128U puDst, uint64_t uSrc));
    2213 
    22142210IEM_DECL_IMPL_DEF(void, iemAImpl_vmovsldup_256_rr,(PX86XSAVEAREA pXState, uint8_t iYRegDst, uint8_t iYRegSrc));
    22152211IEM_DECL_IMPL_DEF(void, iemAImpl_vmovsldup_256_rm,(PX86XSAVEAREA pXState, uint8_t iYRegDst, PCRTUINT256U pSrc));

  • trunk/src/VBox/VMM/include/IEMMc.h

    r97452 r97534  
    424424#define IEM_MC_OR_GREG_U64(a_iGReg, a_u64Value)         *iemGRegRefU64(pVCpu, (a_iGReg)) |= (a_u64Value)
    425425
     426#define IEM_MC_BSWAP_LOCAL_U16(a_u16Local)              (a_u16Local) = RT_BSWAP_U16((a_u16Local));
     427#define IEM_MC_BSWAP_LOCAL_U32(a_u32Local)              (a_u32Local) = RT_BSWAP_U32((a_u32Local));
     428#define IEM_MC_BSWAP_LOCAL_U64(a_u64Local)              (a_u64Local) = RT_BSWAP_U64((a_u64Local));
    426429
    427430/** @note Not for IOPL or IF modification. */
    … …  
    497500#define IEM_MC_STORE_XREG_XMM_U64(a_iXReg, a_iQword, a_XmmValue) \
    498501    do { pVCpu->cpum.GstCtx.XState.x87.aXMM[(a_iXReg)].au64[(a_iQword)] = (a_XmmValue).au64[(a_iQword)]; } while (0)
    499 #define IEM_MC_STORE_XREG_U64(a_iXReg, a_u64Value) \
    500     do { pVCpu->cpum.GstCtx.XState.x87.aXMM[(a_iXReg)].au64[0] = (a_u64Value); } while (0)
     502#define IEM_MC_STORE_XREG_U64(a_iXReg, a_iQword, a_u64Value) \
     503    do { pVCpu->cpum.GstCtx.XState.x87.aXMM[(a_iXReg)].au64[(a_iQword)] = (a_u64Value); } while (0)
    501504#define IEM_MC_STORE_XREG_U64_ZX_U128(a_iXReg, a_u64Value) \
    502505    do { pVCpu->cpum.GstCtx.XState.x87.aXMM[(a_iXReg)].au64[0] = (a_u64Value); \
    503506         pVCpu->cpum.GstCtx.XState.x87.aXMM[(a_iXReg)].au64[1] = 0; \
    504507    } while (0)
    505 #define IEM_MC_STORE_XREG_U32(a_iXReg, a_u32Value) \
    506     do { pVCpu->cpum.GstCtx.XState.x87.aXMM[(a_iXReg)].au32[0] = (a_u32Value); } while (0)
     508#define IEM_MC_STORE_XREG_U32(a_iXReg, a_iDword, a_u32Value) \
     509    do { pVCpu->cpum.GstCtx.XState.x87.aXMM[(a_iXReg)].au32[(a_iDword)] = (a_u32Value); } while (0)
     510#define IEM_MC_STORE_XREG_U32_U128(a_iXReg, a_iDwDst, a_u128Value, a_iDwSrc) \
     511    do { pVCpu->cpum.GstCtx.XState.x87.aXMM[(a_iXReg)].au32[(a_iDwDst)] = (a_u128Value).au32[(a_iDwSrc)]; } while (0)
    507512#define IEM_MC_STORE_XREG_R32(a_iXReg, a_r32Value) \
    508513    do { pVCpu->cpum.GstCtx.XState.x87.aXMM[(a_iXReg)].ar32[0] = (a_r32Value); } while (0)

  • trunk/src/VBox/VMM/testcase/tstIEMCheckMc.cpp

    r97441 r97534  
    752752#define IEM_MC_FPU_FROM_MMX_MODE()                      do { (void)fMcBegin; } while (0)
    753753
     754#define IEM_MC_BSWAP_LOCAL_U16(a_u16Local)              do { CHK_TYPE(uint16_t,  a_u16Local); (void)fMcBegin; } while (0)
     755#define IEM_MC_BSWAP_LOCAL_U32(a_u32Local)              do { CHK_TYPE(uint32_t,  a_u32Local);( void)fMcBegin; } while (0)
     756#define IEM_MC_BSWAP_LOCAL_U64(a_u64Local)              do { CHK_TYPE(uint64_t,  a_u64Local); (void)fMcBegin; } while (0)
     757
    754758#define IEM_MC_FETCH_MREG_U64(a_u64Value, a_iMReg)          do { CHK_MREG_IDX(a_iMReg); (a_u64Value) = 0; CHK_TYPE(uint64_t, a_u64Value); (void)fFpuRead; (void)fMcBegin; } while (0)
    755759#define IEM_MC_FETCH_MREG_U32(a_u32Value, a_iMReg)          do { CHK_MREG_IDX(a_iMReg); (a_u32Value) = 0; CHK_TYPE(uint32_t, a_u32Value); (void)fFpuRead; (void)fMcBegin; } while (0)
    … …  
    766770#define IEM_MC_FETCH_XREG_U64(a_u64Value, a_iXReg)          do { CHK_XREG_IDX(a_iXReg); (a_u64Value) = 0; CHK_TYPE(uint64_t, a_u64Value); (void)fSseRead; (void)fMcBegin; } while (0)
    767771#define IEM_MC_FETCH_XREG_U32(a_u32Value, a_iXReg)          do { CHK_XREG_IDX(a_iXReg); (a_u32Value) = 0; CHK_TYPE(uint32_t, a_u32Value); (void)fSseRead; (void)fMcBegin; } while (0)
     772#define IEM_MC_STORE_XREG_U32_U128(a_iXReg, a_iDwDst, a_u128Value, a_iDwSrc)    do { CHK_XREG_IDX(a_iXReg); CHK_TYPE(RTUINT128U, a_u128Value);  AssertCompile((a_iDwDst) < RT_ELEMENTS((a_u128Value).au32)); AssertCompile((a_iDwSrc) < RT_ELEMENTS((a_u128Value).au32)); (void)fSseWrite; (void)fMcBegin; } while (0)
    768773#define IEM_MC_FETCH_XREG_HI_U64(a_u64Value, a_iXReg)       do { CHK_XREG_IDX(a_iXReg); (a_u64Value) = 0; CHK_TYPE(uint64_t, a_u64Value); (void)fSseRead; (void)fMcBegin; } while (0)
    769774#define IEM_MC_STORE_XREG_U128(a_iXReg, a_u128Value)        do { CHK_TYPE(RTUINT128U, a_u128Value); (void)fSseWrite; (void)fMcBegin; } while (0)
    … …  
    771776#define IEM_MC_STORE_XREG_XMM_U32(a_iXReg, a_iDword, a_XmmValue)      do { CHK_XREG_IDX(a_iXReg); CHK_TYPE(X86XMMREG, a_XmmValue);  AssertCompile((a_iDword) < RT_ELEMENTS((a_XmmValue).au32)); (void)fSseWrite; (void)fMcBegin; } while (0)
    772777#define IEM_MC_STORE_XREG_XMM_U64(a_iXReg, a_iQword, a_XmmValue)      do { CHK_XREG_IDX(a_iXReg); CHK_TYPE(X86XMMREG, a_XmmValue);  AssertCompile((a_iQword) < RT_ELEMENTS((a_XmmValue).au64)); (void)fSseWrite; (void)fMcBegin; } while (0)
    773 #define IEM_MC_STORE_XREG_U64(a_iXReg, a_u64Value)          do { CHK_XREG_IDX(a_iXReg); CHK_TYPE(uint64_t,  a_u64Value);  (void)fSseWrite; (void)fMcBegin; } while (0)
     778#define IEM_MC_STORE_XREG_U64(a_iXReg, a_iQword, a_u64Value)          do { CHK_XREG_IDX(a_iXReg); CHK_TYPE(uint64_t,  a_u64Value);  (void)fSseWrite; (void)fMcBegin; } while (0)
    774779#define IEM_MC_STORE_XREG_U64_ZX_U128(a_iXReg, a_u64Value)  do { CHK_XREG_IDX(a_iXReg); CHK_TYPE(uint64_t,  a_u64Value);  (void)fSseWrite; (void)fMcBegin; } while (0)
    775 #define IEM_MC_STORE_XREG_U32(a_iXReg, a_u32Value)          do { CHK_XREG_IDX(a_iXReg); CHK_TYPE(uint32_t,  a_u32Value); (void)fSseWrite; (void)fMcBegin; } while (0)
     780#define IEM_MC_STORE_XREG_U32(a_iXReg, a_iDword, a_u32Value)    do { CHK_XREG_IDX(a_iXReg); CHK_TYPE(uint32_t,  a_u32Value); (void)fSseWrite; (void)fMcBegin; } while (0)
    776781#define IEM_MC_STORE_XREG_U32_ZX_U128(a_iXReg, a_u32Value)  do { CHK_XREG_IDX(a_iXReg); CHK_TYPE(uint32_t,  a_u32Value);  (void)fSseWrite; (void)fMcBegin; } while (0)
    777782#define IEM_MC_STORE_XREG_HI_U64(a_iXReg, a_u64Value)       do { CHK_XREG_IDX(a_iXReg); CHK_TYPE(uint64_t,  a_u64Value);  (void)fSseWrite; (void)fMcBegin; } while (0)
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