VirtualBox

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


Ignore:
Timestamp:
Jul 24, 2013 10:31:09 PM (12 years ago)
Author:
vboxsync
Message:

IEM: MOVD XM,GREG (sse2,mmx); REX prefix decoding fixes (must be last prefix). VEX preps, correcting LDS and LES to not be available in 64-bit mode.

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

Legend:

Unmodified
Added
Removed

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

    r47350 r47382  
    66746674            return iemRaiseMathFault(pIemCpu); \
    66756675    } while (0)
     6676#define IEM_MC_MAYBE_RAISE_SSE2_RELATED_XCPT() \
     6677    do { \
     6678        if (   (pIemCpu->CTX_SUFF(pCtx)->cr0 & X86_CR0_EM) \
     6679            || !(pIemCpu->CTX_SUFF(pCtx)->cr4 & X86_CR4_OSFSXR) \
     6680            || !IEM_IS_INTEL_CPUID_FEATURE_PRESENT_EDX(X86_CPUID_FEATURE_EDX_SSE2) ) \
     6681            return iemRaiseUndefinedOpcode(pIemCpu); \
     6682        if (pIemCpu->CTX_SUFF(pCtx)->cr0 & X86_CR0_TS) \
     6683            return iemRaiseDeviceNotAvailable(pIemCpu); \
     6684    } while (0)
     6685#define IEM_MC_MAYBE_RAISE_MMX_RELATED_XCPT() \
     6686    do { \
     6687        if (   ((pIemCpu)->CTX_SUFF(pCtx)->cr0 & X86_CR0_EM) \
     6688            || !IEM_IS_INTEL_CPUID_FEATURE_PRESENT_EDX(X86_CPUID_FEATURE_EDX_MMX) ) \
     6689            return iemRaiseUndefinedOpcode(pIemCpu); \
     6690        if (pIemCpu->CTX_SUFF(pCtx)->cr0 & X86_CR0_TS) \
     6691            return iemRaiseDeviceNotAvailable(pIemCpu); \
     6692    } while (0)
    66766693#define IEM_MC_RAISE_GP0_IF_CPL_NOT_ZERO() \
    66776694    do { \
    … …  
    68346851
    68356852#define IEM_MC_CLEAR_FSW_EX()   do { (pIemCpu)->CTX_SUFF(pCtx)->fpu.FSW &= X86_FSW_C_MASK | X86_FSW_TOP_MASK; } while (0)
     6853
     6854
     6855#define IEM_MC_STORE_MREG_U64(a_iMReg, a_u64Value) \
     6856    do { pIemCpu->CTX_SUFF(pCtx)->fpu.aRegs[(a_iMReg)].mmx = (a_u64Value); } while (0)
     6857#define IEM_MC_STORE_MREG_U32_ZX_U64(a_iMReg, a_u32Value) \
     6858    do { pIemCpu->CTX_SUFF(pCtx)->fpu.aRegs[(a_iMReg)].mmx = (uint32_t)(a_u32Value); } while (0)
     6859
     6860#define IEM_MC_STORE_XREG_U64_ZX_U128(a_iXReg, a_u64Value) \
     6861    do { pIemCpu->CTX_SUFF(pCtx)->fpu.aXMM[(a_iXReg)].au64[0] = (a_u64Value); \
     6862         pIemCpu->CTX_SUFF(pCtx)->fpu.aXMM[(a_iXReg)].au64[1] = 0; \
     6863    } while (0)
     6864#define IEM_MC_STORE_XREG_U32_ZX_U128(a_iXReg, a_u32Value) \
     6865    do { pIemCpu->CTX_SUFF(pCtx)->fpu.aXMM[(a_iXReg)].au64[0] = (uint32_t)(a_u32Value); \
     6866         pIemCpu->CTX_SUFF(pCtx)->fpu.aXMM[(a_iXReg)].au64[1] = 0; \
     6867    } while (0)
    68366868
    68376869
    … …  
    74297461        if (pIemCpu->enmCpuMode == IEMMODE_64BIT) \
    74307462            pIemCpu->enmEffOpSize = pIemCpu->enmDefOpSize = IEMMODE_64BIT; \
     7463    } while (0)
     7464
     7465/** Only a REX prefix immediately preceeding the first opcode byte takes
     7466 * effect. This macro helps ensuring this as well as logging bad guest code.  */
     7467#define IEMOP_HLP_CLEAR_REX_NOT_BEFORE_OPCODE(a_szPrf) \
     7468    do \
     7469    { \
     7470        if (RT_UNLIKELY(pIemCpu->fPrefixes & IEM_OP_PRF_REX)) \
     7471        { \
     7472            Log5((a_szPrf ## ": Overriding REX prefix at %RX16! fPrefixes=%#x\n", \
     7473                  pIemCpu->CTX_SUFF(pCtx)->rip, pIemCpu->fPrefixes)); \
     7474            pIemCpu->fPrefixes &= ~IEM_OP_PRF_REX_MASK; \
     7475            pIemCpu->uRexB     = 0; \
     7476            pIemCpu->uRexIndex = 0; \
     7477            pIemCpu->uRexReg   = 0; \
     7478            iemRecalEffOpSize(pIemCpu); \
     7479        } \
    74317480    } while (0)
    74327481

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

    r47379 r47382  
    18221822FNIEMOP_STUB(iemOp_maxps_Vps_Wps__maxpd_Vpd_Wpd__maxss_Vss_Wss__maxsd_Vsd_Wsd);
    18231823/** Opcode 0x0f 0x60. */
    1824 FNIEMOP_STUB(iemOp_punpcklbw_Pq_Qd__punpcklbw_Vdq_Wdq);
     1824FNIEMOP_STUB(iemOp_punpcklbw_Pq_Qd__punpcklbw_Vdq_Wdq); // NEXT
    18251825/** Opcode 0x0f 0x61. */
    18261826FNIEMOP_STUB(iemOp_punpcklwd_Pq_Qd__punpcklwd_Vdq_Wdq);
    … …  
    18491849/** Opcode 0x0f 0x6d. */
    18501850FNIEMOP_STUB(iemOp_punpckhqdq_Vdq_Wdq);
     1851
     1852
    18511853/** Opcode 0x0f 0x6e. */
    1852 FNIEMOP_STUB(iemOp_movd_q_Pd_Ey__movd_q_Vy_Ey);
     1854FNIEMOP_DEF(iemOp_movd_q_Pd_Ey__movd_q_Vy_Ey)
     1855{
     1856    uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
     1857    if ((bRm & X86_MODRM_MOD_MASK) == (3 << X86_MODRM_MOD_SHIFT))
     1858    {
     1859        IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
     1860        IEM_MC_BEGIN(0, 1);
     1861        if (pIemCpu->fPrefixes & IEM_OP_PRF_SIZE_OP)
     1862        {
     1863            /* XMM, greg*/
     1864            IEM_MC_MAYBE_RAISE_SSE2_RELATED_XCPT();
     1865            if (pIemCpu->fPrefixes & IEM_OP_PRF_SIZE_REX_W)
     1866            {
     1867                IEM_MC_LOCAL(uint64_t, u64Tmp);
     1868                IEM_MC_FETCH_GREG_U64(u64Tmp, (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB);
     1869                IEM_MC_STORE_XREG_U64_ZX_U128(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg, u64Tmp);
     1870            }
     1871            else
     1872            {
     1873                IEM_MC_LOCAL(uint32_t, u32Tmp);
     1874                IEM_MC_FETCH_GREG_U32(u32Tmp, (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB);
     1875                IEM_MC_STORE_XREG_U32_ZX_U128(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg, u32Tmp);
     1876            }
     1877        }
     1878        else
     1879        {
     1880            /* MMX, greg */
     1881            IEM_MC_MAYBE_RAISE_MMX_RELATED_XCPT();
     1882            IEM_MC_LOCAL(uint64_t, u64Tmp);
     1883            if (pIemCpu->fPrefixes & IEM_OP_PRF_SIZE_REX_W)
     1884                IEM_MC_FETCH_GREG_U64(u64Tmp, (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB);
     1885            else
     1886                IEM_MC_FETCH_GREG_U32_ZX_U64(u64Tmp, (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB);
     1887            IEM_MC_STORE_MREG_U64(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg, u64Tmp);
     1888        }
     1889        IEM_MC_ADVANCE_RIP();
     1890        IEM_MC_END();
     1891    }
     1892    else
     1893    {
     1894        /* memory source operand. */
     1895        IEM_MC_BEGIN(0, 2);
     1896        IEM_MC_LOCAL(RTGCPTR, GCPtrEffSrc);
     1897        if (pIemCpu->fPrefixes & IEM_OP_PRF_SIZE_OP)
     1898        {
     1899            /* XMM, [mem] */
     1900            IEM_MC_MAYBE_RAISE_SSE2_RELATED_XCPT();
     1901            IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffSrc, bRm, 1);
     1902            IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
     1903            if (pIemCpu->fPrefixes & IEM_OP_PRF_SIZE_REX_W)
     1904            {
     1905                IEM_MC_LOCAL(uint64_t, u64Tmp);
     1906                IEM_MC_FETCH_MEM_U64(u64Tmp, pIemCpu->iEffSeg, GCPtrEffSrc);
     1907                IEM_MC_STORE_XREG_U64_ZX_U128(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg, u64Tmp);
     1908            }
     1909            else
     1910            {
     1911                IEM_MC_LOCAL(uint32_t, u32Tmp);
     1912                IEM_MC_FETCH_MEM_U32(u32Tmp, pIemCpu->iEffSeg, GCPtrEffSrc);
     1913                IEM_MC_STORE_XREG_U32_ZX_U128(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg, u32Tmp);
     1914            }
     1915        }
     1916        else
     1917        {
     1918            /* MMX, [mem] */
     1919            IEM_MC_MAYBE_RAISE_MMX_RELATED_XCPT();
     1920            IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffSrc, bRm, 1);
     1921            IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
     1922            if (pIemCpu->fPrefixes & IEM_OP_PRF_SIZE_REX_W)
     1923            {
     1924                IEM_MC_LOCAL(uint64_t, u64Tmp);
     1925                IEM_MC_FETCH_MEM_U64(u64Tmp, pIemCpu->iEffSeg, GCPtrEffSrc);
     1926                IEM_MC_STORE_MREG_U64(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg, u64Tmp);
     1927            }
     1928            else
     1929            {
     1930                IEM_MC_LOCAL(uint32_t, u32Tmp);
     1931                IEM_MC_FETCH_MEM_U32(u32Tmp, pIemCpu->iEffSeg, GCPtrEffSrc);
     1932                IEM_MC_STORE_MREG_U32_ZX_U64(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg, u32Tmp);
     1933            }
     1934        }
     1935        IEM_MC_ADVANCE_RIP();
     1936        IEM_MC_END();
     1937    }
     1938
     1939    return VINF_SUCCESS;
     1940}
     1941
    18531942/** Opcode 0x0f 0x6f. */
    1854 FNIEMOP_STUB(iemOp_movq_Pq_Qq__movdqa_Vdq_Wdq__movdqu_Vdq_Wdq);
     1943FNIEMOP_STUB(iemOp_movq_Pq_Qq__movdqa_Vdq_Wdq__movdqu_Vdq_Wdq); // NEXT
    18551944/** Opcode 0x0f 0x70. */
    1856 FNIEMOP_STUB(iemOp_pshufw_Pq_Qq_Ib__pshufd_Vdq_Wdq_Ib__pshufhw_Vdq_Wdq_Ib__pshuflq_Vdq_Wdq_Ib);
     1945FNIEMOP_STUB(iemOp_pshufw_Pq_Qq_Ib__pshufd_Vdq_Wdq_Ib__pshufhw_Vdq_Wdq_Ib__pshuflq_Vdq_Wdq_Ib); // NEXT
    18571946
    18581947/** Opcode 0x0f 0x71 11/2. */
    … …  
    20272116
    20282117/** Opcode 0x0f 0x74. */
    2029 FNIEMOP_STUB(iemOp_pcmpeqb_Pq_Qq__pcmpeqb_Vdq_Wdq);
     2118FNIEMOP_STUB(iemOp_pcmpeqb_Pq_Qq__pcmpeqb_Vdq_Wdq); // NEXT
    20302119/** Opcode 0x0f 0x75. */
    20312120FNIEMOP_STUB(iemOp_pcmpeqw_Pq_Qq__pcmpeqw_Vdq_Wdq);
    … …  
    43054394
    43064395
    4307 FNIEMOP_DEF_1(iemOpCommonLoadSRegAndGreg, uint8_t, iSegReg)
    4308 {
    4309     uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
    4310     IEMOP_HLP_NO_LOCK_PREFIX(); /** @todo should probably not be raised until we've fetched all the opcode bytes? */
    4311 
    4312     /* The source cannot be a register. */
    4313     if ((bRm & X86_MODRM_MOD_MASK) == (3 << X86_MODRM_MOD_SHIFT))
    4314         return IEMOP_RAISE_INVALID_OPCODE();
     4396FNIEMOP_DEF_2(iemOpCommonLoadSRegAndGreg, uint8_t, iSegReg, uint8_t, bRm)
     4397{
     4398    Assert((bRm & X86_MODRM_MOD_MASK) != (3 << X86_MODRM_MOD_SHIFT)); /* Caller checks this */
    43154399    uint8_t const iGReg = ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg;
    43164400
    … …  
    43264410            IEM_MC_LOCAL(RTGCPTR,       GCPtrEff);
    43274411            IEM_MC_CALC_RM_EFF_ADDR(GCPtrEff, bRm, 0);
     4412            IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
    43284413            IEM_MC_FETCH_MEM_U16(offSeg, pIemCpu->iEffSeg, GCPtrEff);
    43294414            IEM_MC_FETCH_MEM_U16_DISP(uSel, pIemCpu->iEffSeg, GCPtrEff, 2);
    … …  
    43414426            IEM_MC_LOCAL(RTGCPTR,       GCPtrEff);
    43424427            IEM_MC_CALC_RM_EFF_ADDR(GCPtrEff, bRm, 0);
     4428            IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
    43434429            IEM_MC_FETCH_MEM_U32(offSeg, pIemCpu->iEffSeg, GCPtrEff);
    43444430            IEM_MC_FETCH_MEM_U16_DISP(uSel, pIemCpu->iEffSeg, GCPtrEff, 4);
    … …  
    43564442            IEM_MC_LOCAL(RTGCPTR,       GCPtrEff);
    43574443            IEM_MC_CALC_RM_EFF_ADDR(GCPtrEff, bRm, 0);
    4358             IEM_MC_FETCH_MEM_U64(offSeg, pIemCpu->iEffSeg, GCPtrEff);
     4444            IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
     4445            if (IEM_IS_GUEST_CPU_AMD(pIemCpu)) /** @todo testcase: rev 3.15 of the amd manuals claims it only loads a 32-bit greg. */
     4446                IEM_MC_FETCH_MEM_U32_SX_U64(offSeg, pIemCpu->iEffSeg, GCPtrEff);
     4447            else
     4448                IEM_MC_FETCH_MEM_U64(offSeg, pIemCpu->iEffSeg, GCPtrEff);
    43594449            IEM_MC_FETCH_MEM_U16_DISP(uSel, pIemCpu->iEffSeg, GCPtrEff, 8);
    43604450            IEM_MC_CALL_CIMPL_5(iemCImpl_load_SReg_Greg, uSel, offSeg, iSegRegArg, iGRegArg, enmEffOpSize);
    … …  
    43714461{
    43724462    IEMOP_MNEMONIC("lss Gv,Mp");
    4373     return FNIEMOP_CALL_1(iemOpCommonLoadSRegAndGreg, X86_SREG_SS);
     4463    uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
     4464    if ((bRm & X86_MODRM_MOD_MASK) == (3 << X86_MODRM_MOD_SHIFT))
     4465        return IEMOP_RAISE_INVALID_OPCODE();
     4466    return FNIEMOP_CALL_2(iemOpCommonLoadSRegAndGreg, X86_SREG_SS, bRm);
    43744467}
    43754468
    … …  
    43874480{
    43884481    IEMOP_MNEMONIC("lfs Gv,Mp");
    4389     return FNIEMOP_CALL_1(iemOpCommonLoadSRegAndGreg, X86_SREG_FS);
     4482    uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
     4483    if ((bRm & X86_MODRM_MOD_MASK) == (3 << X86_MODRM_MOD_SHIFT))
     4484        return IEMOP_RAISE_INVALID_OPCODE();
     4485    return FNIEMOP_CALL_2(iemOpCommonLoadSRegAndGreg, X86_SREG_FS, bRm);
    43904486}
    43914487
    … …  
    43954491{
    43964492    IEMOP_MNEMONIC("lgs Gv,Mp");
    4397     return FNIEMOP_CALL_1(iemOpCommonLoadSRegAndGreg, X86_SREG_GS);
     4493    uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
     4494    if ((bRm & X86_MODRM_MOD_MASK) == (3 << X86_MODRM_MOD_SHIFT))
     4495        return IEMOP_RAISE_INVALID_OPCODE();
     4496    return FNIEMOP_CALL_2(iemOpCommonLoadSRegAndGreg, X86_SREG_GS, bRm);
    43984497}
    43994498
    … …  
    53775476FNIEMOP_STUB(iemOp_movq_Wq_Vq__movq2dq_Vdq_Nq__movdq2q_Pq_Uq);
    53785477/** Opcode 0x0f 0xd7. */
    5379 FNIEMOP_STUB(iemOp_pmovmskb_Gd_Nq__pmovmskb_Gd_Udq);
     5478FNIEMOP_STUB(iemOp_pmovmskb_Gd_Nq__pmovmskb_Gd_Udq); //NEXT
    53805479/** Opcode 0x0f 0xd8. */
    53815480FNIEMOP_STUB(iemOp_psubusb_Pq_Qq__psubusb_Vdq_Wdq);
    … …  
    54255524FNIEMOP_STUB(iemOp_pmaxsw_Pq_Qq__pmaxsw_Vdq_Wdq);
    54265525/** Opcode 0x0f 0xef. */
    5427 FNIEMOP_STUB(iemOp_pxor_Pq_Qq__pxor_Vdq_Wdq);
     5526FNIEMOP_STUB(iemOp_pxor_Pq_Qq__pxor_Vdq_Wdq); // NEXT
    54285527/** Opcode 0x0f 0xf0. */
    54295528FNIEMOP_STUB(iemOp_lddqu_Vdq_Mdq);
    … …  
    60506149FNIEMOP_DEF(iemOp_seg_ES)
    60516150{
     6151    IEMOP_HLP_CLEAR_REX_NOT_BEFORE_OPCODE("seg es");
    60526152    pIemCpu->fPrefixes |= IEM_OP_PRF_SEG_ES;
    60536153    pIemCpu->iEffSeg    = X86_SREG_ES;
    … …  
    61136213FNIEMOP_DEF(iemOp_seg_CS)
    61146214{
     6215    IEMOP_HLP_CLEAR_REX_NOT_BEFORE_OPCODE("seg cs");
    61156216    pIemCpu->fPrefixes |= IEM_OP_PRF_SEG_CS;
    61166217    pIemCpu->iEffSeg    = X86_SREG_CS;
    … …  
    61826283FNIEMOP_DEF(iemOp_seg_SS)
    61836284{
     6285    IEMOP_HLP_CLEAR_REX_NOT_BEFORE_OPCODE("seg ss");
    61846286    pIemCpu->fPrefixes |= IEM_OP_PRF_SEG_SS;
    61856287    pIemCpu->iEffSeg    = X86_SREG_SS;
    … …  
    62476349FNIEMOP_DEF(iemOp_seg_DS)
    62486350{
     6351    IEMOP_HLP_CLEAR_REX_NOT_BEFORE_OPCODE("seg ds");
    62496352    pIemCpu->fPrefixes |= IEM_OP_PRF_SEG_DS;
    62506353    pIemCpu->iEffSeg    = X86_SREG_DS;
    … …  
    63126415    if (pIemCpu->enmCpuMode == IEMMODE_64BIT)
    63136416    {
     6417        IEMOP_HLP_CLEAR_REX_NOT_BEFORE_OPCODE("rex");
    63146418        pIemCpu->fPrefixes |= IEM_OP_PRF_REX;
    63156419
    … …  
    63316435    if (pIemCpu->enmCpuMode == IEMMODE_64BIT)
    63326436    {
     6437        IEMOP_HLP_CLEAR_REX_NOT_BEFORE_OPCODE("rex.b");
    63336438        pIemCpu->fPrefixes |= IEM_OP_PRF_REX | IEM_OP_PRF_REX_B;
    63346439        pIemCpu->uRexB     = 1 << 3;
    … …  
    63516456    if (pIemCpu->enmCpuMode == IEMMODE_64BIT)
    63526457    {
     6458        IEMOP_HLP_CLEAR_REX_NOT_BEFORE_OPCODE("rex.x");
    63536459        pIemCpu->fPrefixes |= IEM_OP_PRF_REX | IEM_OP_PRF_REX_X;
    63546460        pIemCpu->uRexIndex = 1 << 3;
    … …  
    63726478    if (pIemCpu->enmCpuMode == IEMMODE_64BIT)
    63736479    {
     6480        IEMOP_HLP_CLEAR_REX_NOT_BEFORE_OPCODE("rex.bx");
    63746481        pIemCpu->fPrefixes |= IEM_OP_PRF_REX | IEM_OP_PRF_REX_B | IEM_OP_PRF_REX_X;
    63756482        pIemCpu->uRexB     = 1 << 3;
    … …  
    63936500    if (pIemCpu->enmCpuMode == IEMMODE_64BIT)
    63946501    {
     6502        IEMOP_HLP_CLEAR_REX_NOT_BEFORE_OPCODE("rex.r");
    63956503        pIemCpu->fPrefixes |= IEM_OP_PRF_REX | IEM_OP_PRF_REX_R;
    63966504        pIemCpu->uRexReg   = 1 << 3;
    … …  
    64136521    if (pIemCpu->enmCpuMode == IEMMODE_64BIT)
    64146522    {
     6523        IEMOP_HLP_CLEAR_REX_NOT_BEFORE_OPCODE("rex.rb");
    64156524        pIemCpu->fPrefixes |= IEM_OP_PRF_REX | IEM_OP_PRF_REX_R | IEM_OP_PRF_REX_B;
    64166525        pIemCpu->uRexReg   = 1 << 3;
    … …  
    64346543    if (pIemCpu->enmCpuMode == IEMMODE_64BIT)
    64356544    {
     6545        IEMOP_HLP_CLEAR_REX_NOT_BEFORE_OPCODE("rex.rx");
    64366546        pIemCpu->fPrefixes |= IEM_OP_PRF_REX | IEM_OP_PRF_REX_R | IEM_OP_PRF_REX_X;
    64376547        pIemCpu->uRexReg   = 1 << 3;
    … …  
    64556565    if (pIemCpu->enmCpuMode == IEMMODE_64BIT)
    64566566    {
     6567        IEMOP_HLP_CLEAR_REX_NOT_BEFORE_OPCODE("rex.rbx");
    64576568        pIemCpu->fPrefixes |= IEM_OP_PRF_REX | IEM_OP_PRF_REX_R | IEM_OP_PRF_REX_B | IEM_OP_PRF_REX_X;
    64586569        pIemCpu->uRexReg   = 1 << 3;
    … …  
    64776588    if (pIemCpu->enmCpuMode == IEMMODE_64BIT)
    64786589    {
     6590        IEMOP_HLP_CLEAR_REX_NOT_BEFORE_OPCODE("rex.w");
    64796591        pIemCpu->fPrefixes |= IEM_OP_PRF_REX | IEM_OP_PRF_SIZE_REX_W;
    64806592        iemRecalEffOpSize(pIemCpu);
    … …  
    64976609    if (pIemCpu->enmCpuMode == IEMMODE_64BIT)
    64986610    {
     6611        IEMOP_HLP_CLEAR_REX_NOT_BEFORE_OPCODE("rex.bw");
    64996612        pIemCpu->fPrefixes |= IEM_OP_PRF_REX | IEM_OP_PRF_REX_B | IEM_OP_PRF_SIZE_REX_W;
    65006613        pIemCpu->uRexB     = 1 << 3;
    … …  
    65186631    if (pIemCpu->enmCpuMode == IEMMODE_64BIT)
    65196632    {
     6633        IEMOP_HLP_CLEAR_REX_NOT_BEFORE_OPCODE("rex.xw");
    65206634        pIemCpu->fPrefixes |= IEM_OP_PRF_REX | IEM_OP_PRF_REX_X | IEM_OP_PRF_SIZE_REX_W;
    65216635        pIemCpu->uRexIndex = 1 << 3;
    … …  
    65396653    if (pIemCpu->enmCpuMode == IEMMODE_64BIT)
    65406654    {
     6655        IEMOP_HLP_CLEAR_REX_NOT_BEFORE_OPCODE("rex.bxw");
    65416656        pIemCpu->fPrefixes |= IEM_OP_PRF_REX | IEM_OP_PRF_REX_B | IEM_OP_PRF_REX_X | IEM_OP_PRF_SIZE_REX_W;
    65426657        pIemCpu->uRexB     = 1 << 3;
    … …  
    65616676    if (pIemCpu->enmCpuMode == IEMMODE_64BIT)
    65626677    {
     6678        IEMOP_HLP_CLEAR_REX_NOT_BEFORE_OPCODE("rex.rw");
    65636679        pIemCpu->fPrefixes |= IEM_OP_PRF_REX | IEM_OP_PRF_REX_R | IEM_OP_PRF_SIZE_REX_W;
    65646680        pIemCpu->uRexReg   = 1 << 3;
    … …  
    65826698    if (pIemCpu->enmCpuMode == IEMMODE_64BIT)
    65836699    {
     6700        IEMOP_HLP_CLEAR_REX_NOT_BEFORE_OPCODE("rex.rbw");
    65846701        pIemCpu->fPrefixes |= IEM_OP_PRF_REX | IEM_OP_PRF_REX_R | IEM_OP_PRF_REX_B | IEM_OP_PRF_SIZE_REX_W;
    65856702        pIemCpu->uRexReg   = 1 << 3;
    … …  
    66046721    if (pIemCpu->enmCpuMode == IEMMODE_64BIT)
    66056722    {
     6723        IEMOP_HLP_CLEAR_REX_NOT_BEFORE_OPCODE("rex.rxw");
    66066724        pIemCpu->fPrefixes |= IEM_OP_PRF_REX | IEM_OP_PRF_REX_R | IEM_OP_PRF_REX_X | IEM_OP_PRF_SIZE_REX_W;
    66076725        pIemCpu->uRexReg   = 1 << 3;
    … …  
    66266744    if (pIemCpu->enmCpuMode == IEMMODE_64BIT)
    66276745    {
     6746        IEMOP_HLP_CLEAR_REX_NOT_BEFORE_OPCODE("rex.rbxw");
    66286747        pIemCpu->fPrefixes |= IEM_OP_PRF_REX | IEM_OP_PRF_REX_R | IEM_OP_PRF_REX_B | IEM_OP_PRF_REX_X | IEM_OP_PRF_SIZE_REX_W;
    66296748        pIemCpu->uRexReg   = 1 << 3;
    … …  
    69457064FNIEMOP_DEF(iemOp_seg_FS)
    69467065{
     7066    IEMOP_HLP_CLEAR_REX_NOT_BEFORE_OPCODE("seg fs");
    69477067    pIemCpu->fPrefixes |= IEM_OP_PRF_SEG_FS;
    69487068    pIemCpu->iEffSeg    = X86_SREG_FS;
    … …  
    69567076FNIEMOP_DEF(iemOp_seg_GS)
    69577077{
     7078    IEMOP_HLP_CLEAR_REX_NOT_BEFORE_OPCODE("seg gs");
    69587079    pIemCpu->fPrefixes |= IEM_OP_PRF_SEG_GS;
    69597080    pIemCpu->iEffSeg    = X86_SREG_GS;
    … …  
    69677088FNIEMOP_DEF(iemOp_op_size)
    69687089{
     7090    IEMOP_HLP_CLEAR_REX_NOT_BEFORE_OPCODE("op size");
    69697091    pIemCpu->fPrefixes |= IEM_OP_PRF_SIZE_OP;
    69707092    iemRecalEffOpSize(pIemCpu);
    … …  
    69787100FNIEMOP_DEF(iemOp_addr_size)
    69797101{
     7102    IEMOP_HLP_CLEAR_REX_NOT_BEFORE_OPCODE("addr size");
    69807103    pIemCpu->fPrefixes |= IEM_OP_PRF_SIZE_ADDR;
    69817104    switch (pIemCpu->enmDefAddrMode)
    … …  
    1071810841FNIEMOP_DEF(iemOp_les_Gv_Mp)
    1071910842{
     10843    uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
     10844    if (   pIemCpu->enmCpuMode == IEMMODE_64BIT
     10845        || (bRm & X86_MODRM_MOD_MASK) == (3 << X86_MODRM_MOD_SHIFT))
     10846    {
     10847        IEMOP_MNEMONIC("2-byte-vex");
     10848        /* The LES instruction is invalid 64-bit mode. In legacy and
     10849           compatability mode it is invalid with MOD=3.
     10850           The use as a VEX prefix is made possible by assigning the inverted
     10851           REX.R to the top MOD bit, and the top bit in the inverted register
     10852           specifier to the bottom MOD bit, thereby effectively limiting 32-bit
     10853           to accessing registers 0..7 in this VEX form. */
     10854        /** @todo VEX: Just use new tables for it. */
     10855        return IEMOP_RAISE_INVALID_OPCODE();
     10856    }
    1072010857    IEMOP_MNEMONIC("les Gv,Mp");
    10721     return FNIEMOP_CALL_1(iemOpCommonLoadSRegAndGreg, X86_SREG_ES);
     10858    return FNIEMOP_CALL_2(iemOpCommonLoadSRegAndGreg, X86_SREG_ES, bRm);
    1072210859}
    1072310860
    … …  
    1072610863FNIEMOP_DEF(iemOp_lds_Gv_Mp)
    1072710864{
     10865    uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
     10866    if (   pIemCpu->enmCpuMode == IEMMODE_64BIT
     10867        || (bRm & X86_MODRM_MOD_MASK) == (3 << X86_MODRM_MOD_SHIFT))
     10868    {
     10869        IEMOP_MNEMONIC("3-byte-vex");
     10870        /* The LDS instruction is invalid 64-bit mode. In legacy and
     10871           compatability mode it is invalid with MOD=3.
     10872           The use as a VEX prefix is made possible by assigning the inverted
     10873           REX.R and REX.X to the two MOD bits, since the REX bits are ignored
     10874           outside of 64-bit mode. */
     10875        /** @todo VEX: Just use new tables for it. */
     10876        return IEMOP_RAISE_INVALID_OPCODE();
     10877    }
    1072810878    IEMOP_MNEMONIC("lds Gv,Mp");
    10729     return FNIEMOP_CALL_1(iemOpCommonLoadSRegAndGreg, X86_SREG_DS);
     10879    return FNIEMOP_CALL_2(iemOpCommonLoadSRegAndGreg, X86_SREG_DS, bRm);
    1073010880}
    1073110881
    … …  
    1476714917FNIEMOP_DEF(iemOp_lock)
    1476814918{
     14919    IEMOP_HLP_CLEAR_REX_NOT_BEFORE_OPCODE("lock");
    1476914920    pIemCpu->fPrefixes |= IEM_OP_PRF_LOCK;
    1477014921
    … …  
    1477914930    /* This overrides any previous REPE prefix. */
    1478014931    pIemCpu->fPrefixes &= ~IEM_OP_PRF_REPZ;
     14932    IEMOP_HLP_CLEAR_REX_NOT_BEFORE_OPCODE("repne");
    1478114933    pIemCpu->fPrefixes |= IEM_OP_PRF_REPNZ;
    1478214934
    … …  
    1479114943    /* This overrides any previous REPNE prefix. */
    1479214944    pIemCpu->fPrefixes &= ~IEM_OP_PRF_REPNZ;
     14945    IEMOP_HLP_CLEAR_REX_NOT_BEFORE_OPCODE("repe");
    1479314946    pIemCpu->fPrefixes |= IEM_OP_PRF_REPZ;
    1479414947
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