VirtualBox

Changeset 36780 in vbox


Ignore:
Timestamp:
Apr 21, 2011 12:38:30 AM (14 years ago)
Author:
vboxsync
Message:

IEM: Some more bits.

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

Legend:

Unmodified
Added
Removed

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

    r36778 r36780  
    10821082
    10831083static VBOXSTRICTRC iemRaiseGeneralProtectionFault0(PIEMCPU pIemCpu)
     1084{
     1085    AssertFailed(/** @todo implement this */);
     1086    return VERR_NOT_IMPLEMENTED;
     1087}
     1088
     1089
     1090static VBOXSTRICTRC iemRaiseNotCanonical(PIEMCPU pIemCpu)
    10841091{
    10851092    AssertFailed(/** @todo implement this */);
    … …  
    38523859    PCPUMCTX pCtx  = pIemCpu->CTX_SUFF(pCtx);
    38533860    uint64_t OldPC = pCtx->rip + cbInstr;
     3861    uint64_t NewPC = OldPC + offDisp;
     3862    if (!IEM_IS_CANONICAL(NewPC))
     3863        return iemRaiseNotCanonical(pIemCpu);
    38543864
    38553865    VBOXSTRICTRC rcStrict = iemMemStackPushU64(pIemCpu, OldPC);
    … …  
    38573867        return rcStrict;
    38583868
    3859     pCtx->rip = OldPC + offDisp;
     3869    pCtx->rip = NewPC;
    38603870    return VINF_SUCCESS;
    38613871}
    … …  
    39743984        else
    39753985        {
    3976             if (offSeg > offSeg)
     3986            if (offSeg > cbLimit)
    39773987            {
    39783988                Log(("jmpf %04x:%08x -> out of bounds (%#x)\n", uSel, offSeg, cbLimit));
    … …  
    41584168        /* Check the limit of the new EIP. */
    41594169        /** @todo Intel pseudo code only does the limit check for 16-bit
    4160          *        operands, AMD does make any distinction. What is right? */
     4170         *        operands, AMD does not make any distinction. What is right? */
    41614171        if (uNewEip > pCtx->csHid.u32Limit)
    41624172            return iemRaiseSelectorBounds(pIemCpu, X86_SREG_CS, IEM_ACCESS_INSTRUCTION);
    … …  
    41814191
    41824192/**
     4193 * Implements retn.
     4194 *
     4195 * We're doing this in C because of the \#GP that might be raised if the popped
     4196 * program counter is out of bounds.
     4197 *
     4198 * @param   enmEffOpSize    The effective operand size.
     4199 * @param   cbPop           The amount of arguments to pop from the stack
     4200 *                          (bytes).
     4201 */
     4202IEM_CIMPL_DEF_2(iemCImpl_retn, IEMMODE, enmEffOpSize, uint16_t, cbPop)
     4203{
     4204    PCPUMCTX        pCtx = pIemCpu->CTX_SUFF(pCtx);
     4205
     4206    /* Fetch the RSP from the stack. */
     4207    VBOXSTRICTRC    rcStrict;
     4208    RTUINT64U       NewRip;
     4209    RTUINT64U       NewRsp;
     4210    NewRsp.u = pCtx->rsp;
     4211    switch (enmEffOpSize)
     4212    {
     4213        case IEMMODE_16BIT:
     4214            NewRip.u = 0;
     4215            rcStrict = iemMemStackPopU16Ex(pIemCpu, &NewRip.Words.w0, &NewRsp);
     4216            break;
     4217        case IEMMODE_32BIT:
     4218            NewRip.u = 0;
     4219            rcStrict = iemMemStackPopU32Ex(pIemCpu, &NewRip.DWords.dw0, &NewRsp);
     4220            break;
     4221        case IEMMODE_64BIT:
     4222            rcStrict = iemMemStackPopU64Ex(pIemCpu, &NewRip.u, &NewRsp);
     4223            break;
     4224        IEM_NOT_REACHED_DEFAULT_CASE_RET();
     4225    }
     4226    if (rcStrict != VINF_SUCCESS)
     4227        return rcStrict;
     4228
     4229    /* Check the new RSP before loading it. */
     4230    /** @todo Should test this as the intel+amd pseudo code doesn't mention half
     4231     *        of it.  The canonical test is performed here and for call. */
     4232    if (enmEffOpSize != IEMMODE_64BIT)
     4233    {
     4234        if (NewRip.DWords.dw0 > pCtx->csHid.u32Limit)
     4235        {
     4236            Log(("retn newrip=%llx - out of bounds (%x) -> #GP\n", NewRip.u, pCtx->csHid.u32Limit));
     4237            return iemRaiseSelectorBounds(pIemCpu, X86_SREG_CS, IEM_ACCESS_INSTRUCTION);
     4238        }
     4239    }
     4240    else
     4241    {
     4242        if (!IEM_IS_CANONICAL(NewRip.u))
     4243        {
     4244            Log(("retn newrip=%llx - not canonical -> #GP\n", NewRip.u));
     4245            return iemRaiseNotCanonical(pIemCpu);
     4246        }
     4247    }
     4248
     4249    /* Commit it. */
     4250    pCtx->rip = NewRip.u;
     4251    pCtx->rsp = NewRsp.u;
     4252    if (cbPop)
     4253        iemRegAddToRsp(pCtx, cbPop);
     4254
     4255    return VINF_SUCCESS;
     4256}
     4257
     4258
     4259/**
    41834260 * Implements int3 and int XX.
    41844261 *
    … …  
    42214298
    42224299        /* load the vector address into cs:ip. */
    4223         pCtx->cs            = Idte.sel;
    4224         pCtx->csHid.u64Base = (uint32_t)Idte.sel << 4;
     4300        pCtx->cs               = Idte.sel;
     4301        pCtx->csHid.u64Base    = (uint32_t)Idte.sel << 4;
    42254302        /** @todo do we load attribs and limit as well? Should we check against limit like far jump? */
    4226         pCtx->rip           = Idte.off;
     4303        pCtx->rip              = Idte.off;
     4304        pCtx->eflags.Bits.u1IF = 0;
    42274305        return VINF_SUCCESS;
    42284306    }
    … …  
    52965374
    52975375#define IEM_MC_FETCH_GREG_U8(a_u8Dst, a_iGReg)          (a_u8Dst)  = iemGRegFetchU8(pIemCpu, (a_iGReg))
     5376#define IEM_MC_FETCH_GREG_U8_ZX_U16(a_u16Dst, a_iGReg)  (a_u16Dst) = iemGRegFetchU8(pIemCpu, (a_iGReg))
     5377#define IEM_MC_FETCH_GREG_U8_ZX_U32(a_u32Dst, a_iGReg)  (a_u32Dst) = iemGRegFetchU8(pIemCpu, (a_iGReg))
     5378#define IEM_MC_FETCH_GREG_U8_ZX_U64(a_u64Dst, a_iGReg)  (a_u64Dst) = iemGRegFetchU8(pIemCpu, (a_iGReg))
    52985379#define IEM_MC_FETCH_GREG_U16(a_u16Dst, a_iGReg)        (a_u16Dst) = iemGRegFetchU16(pIemCpu, (a_iGReg))
     5380#define IEM_MC_FETCH_GREG_U16_ZX_U32(a_u32Dst, a_iGReg) (a_u32Dst) = iemGRegFetchU16(pIemCpu, (a_iGReg))
     5381#define IEM_MC_FETCH_GREG_U16_ZX_U64(a_u64Dst, a_iGReg) (a_u64Dst) = iemGRegFetchU16(pIemCpu, (a_iGReg))
    52995382#define IEM_MC_FETCH_GREG_U32(a_u32Dst, a_iGReg)        (a_u32Dst) = iemGRegFetchU32(pIemCpu, (a_iGReg))
     5383#define IEM_MC_FETCH_GREG_U32_ZX_U64(a_u64Dst, a_iGReg) (a_u64Dst) = iemGRegFetchU32(pIemCpu, (a_iGReg))
    53005384#define IEM_MC_FETCH_GREG_U64(a_u64Dst, a_iGReg)        (a_u64Dst) = iemGRegFetchU64(pIemCpu, (a_iGReg))
    53015385#define IEM_MC_FETCH_SREG_U16(a_u16Dst, a_iSReg)        (a_u16Dst) = iemSRegFetchU16(pIemCpu, (a_iSReg))
    5302 #define IEM_MC_FETCH_SREG_U32_ZX(a_u32Dst, a_iSReg)     (a_u32Dst) = iemSRegFetchU16(pIemCpu, (a_iSReg))
    5303 #define IEM_MC_FETCH_SREG_U64_ZX(a_u64Dst, a_iSReg)     (a_u64Dst) = iemSRegFetchU16(pIemCpu, (a_iSReg))
     5386#define IEM_MC_FETCH_SREG_ZX_U32(a_u32Dst, a_iSReg)     (a_u32Dst) = iemSRegFetchU16(pIemCpu, (a_iSReg))
     5387#define IEM_MC_FETCH_SREG_ZX_U64(a_u64Dst, a_iSReg)     (a_u64Dst) = iemSRegFetchU16(pIemCpu, (a_iSReg))
    53045388#define IEM_MC_FETCH_EFLAGS(a_EFlags)                   (a_EFlags) = (pIemCpu)->CTX_SUFF(pCtx)->eflags.u
    53055389
    … …  
    53525436#define IEM_MC_FETCH_MEM_U64(a_u64Dst, a_iSeg, a_GCPtrMem) \
    53535437    IEM_MC_RETURN_ON_FAILURE(iemMemFetchDataU64(pIemCpu, &(a_u64Dst), (a_iSeg), (a_GCPtrMem)))
     5438
     5439#define IEM_MC_FETCH_MEM_U8_ZX_U16(a_u16Dst, a_iSeg, a_GCPtrMem) \
     5440    do { \
     5441        uint8_t u8Tmp; \
     5442        IEM_MC_RETURN_ON_FAILURE(iemMemFetchDataU8(pIemCpu, &u8Tmp, (a_iSeg), (a_GCPtrMem))); \
     5443        (a_u16Dst) = u8Tmp; \
     5444    } while (0)
     5445#define IEM_MC_FETCH_MEM_U8_ZX_U32(a_u32Dst, a_iSeg, a_GCPtrMem) \
     5446    do { \
     5447        uint8_t u8Tmp; \
     5448        IEM_MC_RETURN_ON_FAILURE(iemMemFetchDataU8(pIemCpu, &u8Tmp, (a_iSeg), (a_GCPtrMem))); \
     5449        (a_u32Dst) = u8Tmp; \
     5450    } while (0)
     5451#define IEM_MC_FETCH_MEM_U8_ZX_U64(a_u64Dst, a_iSeg, a_GCPtrMem) \
     5452    do { \
     5453        uint8_t u8Tmp; \
     5454        IEM_MC_RETURN_ON_FAILURE(iemMemFetchDataU8(pIemCpu, &u8Tmp, (a_iSeg), (a_GCPtrMem))); \
     5455        (a_u64Dst) = u8Tmp; \
     5456    } while (0)
     5457#define IEM_MC_FETCH_MEM_U16_ZX_U32(a_u32Dst, a_iSeg, a_GCPtrMem) \
     5458    do { \
     5459        uint16_t u16Tmp; \
     5460        IEM_MC_RETURN_ON_FAILURE(iemMemFetchDataU16(pIemCpu, &u16Tmp, (a_iSeg), (a_GCPtrMem))); \
     5461        (a_u32Dst) = u16Tmp; \
     5462    } while (0)
     5463#define IEM_MC_FETCH_MEM_U16_ZX_U64(a_u64Dst, a_iSeg, a_GCPtrMem) \
     5464    do { \
     5465        uint16_t u16Tmp; \
     5466        IEM_MC_RETURN_ON_FAILURE(iemMemFetchDataU16(pIemCpu, &u16Tmp, (a_iSeg), (a_GCPtrMem))); \
     5467        (a_u64Dst) = u16Tmp; \
     5468    } while (0)
     5469#define IEM_MC_FETCH_MEM_U32_ZX_U64(a_u64Dst, a_iSeg, a_GCPtrMem) \
     5470    do { \
     5471        uint32_t u32Tmp; \
     5472        IEM_MC_RETURN_ON_FAILURE(iemMemFetchDataU32(pIemCpu, &u32Tmp, (a_iSeg), (a_GCPtrMem))); \
     5473        (a_u64Dst) = u32Tmp; \
     5474    } while (0)
    53545475
    53555476#define IEM_MC_STORE_MEM_U8(a_iSeg, a_GCPtrMem, a_u8Value) \
    … …  
    58775998static void iemExecVerificationModeSetup(PIEMCPU pIemCpu)
    58785999{
     6000    /*
     6001     * Switch state.
     6002     */
    58796003    static CPUMCTX  s_DebugCtx; /* Ugly! */
    58806004
    … …  
    58826006    s_DebugCtx = *pOrgCtx;
    58836007    pIemCpu->CTX_SUFF(pCtx) = &s_DebugCtx;
     6008
     6009    /*
     6010     * See if there is an interrupt pending in TRPM and inject it if we can.
     6011     */
     6012    PVMCPU pVCpu = IEMCPU_TO_VMCPU(pIemCpu);
     6013    if (   pOrgCtx->eflags.Bits.u1IF
     6014        && TRPMHasTrap(pVCpu)
     6015        //&& TRPMIsSoftwareInterrupt(pVCpu)
     6016        && EMGetInhibitInterruptsPC(pVCpu) != pOrgCtx->rip)
     6017    {
     6018        Log(("Injecting trap %#x\n", TRPMGetTrapNo(pVCpu)));
     6019        iemCImpl_int(pIemCpu, 0, TRPMGetTrapNo(pVCpu), false);
     6020    }
     6021
     6022    /*
     6023     * Reset the counters.
     6024     */
    58846025    pIemCpu->cIOReads    = 0;
    58856026    pIemCpu->cIOWrites   = 0;
    58866027    pIemCpu->fMulDivHack = false;
    58876028    pIemCpu->fShlHack    = false;
    5888 
    58896029}
    58906030
    … …  
    59426082            }
    59436083            else
    5944                 RTAssertMsg2Weak("  the FPU state differs - happends the first time...\n");
     6084                RTAssertMsg2Weak("  the FPU state differs - happens the first time...\n");
    59456085        }
    59466086        CHECK_FIELD(rip);
    … …  
    60676207{
    60686208    PIEMCPU  pIemCpu = &pVCpu->iem.s;
     6209
     6210#if defined(IEM_VERIFICATION_MODE) && defined(IN_RING3)
     6211    iemExecVerificationModeSetup(pIemCpu);
     6212#endif
    60696213#ifdef DEBUG
    60706214    PCPUMCTX pCtx = pIemCpu->CTX_SUFF(pCtx);
    … …  
    60876231          szInstr));
    60886232#endif
    6089 #if defined(IEM_VERIFICATION_MODE) && defined(IN_RING3)
    6090     iemExecVerificationModeSetup(pIemCpu);
    6091 #endif
    60926233
    60936234    /*
    … …  
    61026243    if (rcStrict == VINF_SUCCESS)
    61036244        pIemCpu->cInstructions++;
     6245//#ifdef DEBUG
     6246//    AssertMsg(pIemCpu->offOpcode == cbInstr || rcStrict != VINF_SUCCESS, ("%u %u\n", pIemCpu->offOpcode, cbInstr));
     6247//#endif
    61046248
    61056249    /* Execute the next instruction as well if a cli, pop ss or
    … …  
    61226266     * Assert some sanity.
    61236267     */
    6124 #ifdef DEBUG
    6125     AssertMsg(pIemCpu->offOpcode == cbInstr || rcStrict != VINF_SUCCESS, ("%u %u\n", pIemCpu->offOpcode, cbInstr));
    6126 #endif
    61276268#if defined(IEM_VERIFICATION_MODE) && defined(IN_RING3)
    61286269    iemExecVerificationModeCheck(pIemCpu);

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

    r36775 r36780  
    17181718/** Opcode 0x0f 0xb5. */
    17191719FNIEMOP_STUB(iemOp_lgs_Gv_Mp);
     1720
     1721
    17201722/** Opcode 0x0f 0xb6. */
    1721 FNIEMOP_STUB(iemOp_movzx_Gv_Eb);
     1723FNIEMOP_DEF(iemOp_movzx_Gv_Eb)
     1724{
     1725    IEMOP_MNEMONIC("movzx Gv,Eb");
     1726
     1727    uint8_t bRm; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &bRm);
     1728    IEMOP_HLP_NO_LOCK_PREFIX(); /** @todo should probably not be raised until we've fetched all the opcode bytes? */
     1729
     1730    /*
     1731     * If rm is denoting a register, no more instruction bytes.
     1732     */
     1733    if ((bRm & X86_MODRM_MOD_MASK) == (3 << X86_MODRM_MOD_SHIFT))
     1734    {
     1735        switch (pIemCpu->enmEffOpSize)
     1736        {
     1737            case IEMMODE_16BIT:
     1738                IEM_MC_BEGIN(0, 1);
     1739                IEM_MC_LOCAL(uint16_t, u16Value);
     1740                IEM_MC_FETCH_GREG_U8_ZX_U16(u16Value, (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB);
     1741                IEM_MC_STORE_GREG_U16(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg, u16Value);
     1742                IEM_MC_ADVANCE_RIP();
     1743                IEM_MC_END();
     1744                return VINF_SUCCESS;
     1745
     1746            case IEMMODE_32BIT:
     1747                IEM_MC_BEGIN(0, 1);
     1748                IEM_MC_LOCAL(uint32_t, u32Value);
     1749                IEM_MC_FETCH_GREG_U8_ZX_U32(u32Value, (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB);
     1750                IEM_MC_STORE_GREG_U32(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg, u32Value);
     1751                IEM_MC_ADVANCE_RIP();
     1752                IEM_MC_END();
     1753                return VINF_SUCCESS;
     1754
     1755            case IEMMODE_64BIT:
     1756                IEM_MC_BEGIN(0, 1);
     1757                IEM_MC_LOCAL(uint64_t, u64Value);
     1758                IEM_MC_FETCH_GREG_U8_ZX_U64(u64Value, (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB);
     1759                IEM_MC_STORE_GREG_U64(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg, u64Value);
     1760                IEM_MC_ADVANCE_RIP();
     1761                IEM_MC_END();
     1762                return VINF_SUCCESS;
     1763
     1764            IEM_NOT_REACHED_DEFAULT_CASE_RET();
     1765        }
     1766    }
     1767    else
     1768    {
     1769        /*
     1770         * We're loading a register from memory.
     1771         */
     1772        switch (pIemCpu->enmEffOpSize)
     1773        {
     1774            case IEMMODE_16BIT:
     1775                IEM_MC_BEGIN(0, 2);
     1776                IEM_MC_LOCAL(uint16_t, u16Value);
     1777                IEM_MC_LOCAL(RTGCPTR, GCPtrEffDst);
     1778                IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm);
     1779                IEM_MC_FETCH_MEM_U8_ZX_U16(u16Value, pIemCpu->iEffSeg, GCPtrEffDst);
     1780                IEM_MC_STORE_GREG_U16(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg, u16Value);
     1781                IEM_MC_ADVANCE_RIP();
     1782                IEM_MC_END();
     1783                return VINF_SUCCESS;
     1784
     1785            case IEMMODE_32BIT:
     1786                IEM_MC_BEGIN(0, 2);
     1787                IEM_MC_LOCAL(uint32_t, u32Value);
     1788                IEM_MC_LOCAL(RTGCPTR, GCPtrEffDst);
     1789                IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm);
     1790                IEM_MC_FETCH_MEM_U8_ZX_U32(u32Value, pIemCpu->iEffSeg, GCPtrEffDst);
     1791                IEM_MC_STORE_GREG_U32(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg, u32Value);
     1792                IEM_MC_ADVANCE_RIP();
     1793                IEM_MC_END();
     1794                return VINF_SUCCESS;
     1795
     1796            case IEMMODE_64BIT:
     1797                IEM_MC_BEGIN(0, 2);
     1798                IEM_MC_LOCAL(uint64_t, u64Value);
     1799                IEM_MC_LOCAL(RTGCPTR, GCPtrEffDst);
     1800                IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm);
     1801                IEM_MC_FETCH_MEM_U8_ZX_U64(u64Value, pIemCpu->iEffSeg, GCPtrEffDst);
     1802                IEM_MC_STORE_GREG_U64(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg, u64Value);
     1803                IEM_MC_ADVANCE_RIP();
     1804                IEM_MC_END();
     1805                return VINF_SUCCESS;
     1806
     1807            IEM_NOT_REACHED_DEFAULT_CASE_RET();
     1808        }
     1809    }
     1810}
     1811
     1812
    17221813/** Opcode 0x0f 0xb7. */
    17231814FNIEMOP_STUB(iemOp_movzx_Gv_Ew);
    … …  
    21012192            IEM_MC_BEGIN(0, 1);
    21022193            IEM_MC_LOCAL(uint32_t, u32Value);
    2103             IEM_MC_FETCH_SREG_U32_ZX(u32Value, iReg);
     2194            IEM_MC_FETCH_SREG_ZX_U32(u32Value, iReg);
    21042195            IEM_MC_PUSH_U32(u32Value);
    21052196            IEM_MC_ADVANCE_RIP();
    … …  
    21102201            IEM_MC_BEGIN(0, 1);
    21112202            IEM_MC_LOCAL(uint64_t, u64Value);
    2112             IEM_MC_FETCH_SREG_U64_ZX(u64Value, iReg);
     2203            IEM_MC_FETCH_SREG_ZX_U64(u64Value, iReg);
    21132204            IEM_MC_PUSH_U64(u64Value);
    21142205            IEM_MC_ADVANCE_RIP();
    … …  
    36303721FNIEMOP_DEF(iemOp_insb_Yb_DX)
    36313722{
    3632     uint8_t u8Imm; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &u8Imm);
    36333723    IEMOP_HLP_NO_LOCK_PREFIX();
    3634 
    3635     /*
    3636      * Use the C implementation if a repeate prefix is encountered.
    3637      */
    36383724    if (pIemCpu->fPrefixes & (IEM_OP_PRF_REPNZ | IEM_OP_PRF_REPZ))
    36393725    {
    … …  
    36443730            case IEMMODE_32BIT: return IEM_MC_DEFER_TO_CIMPL_0(iemCImpl_rep_ins_op8_addr32);
    36453731            case IEMMODE_64BIT: return IEM_MC_DEFER_TO_CIMPL_0(iemCImpl_rep_ins_op8_addr64);
     3732            IEM_NOT_REACHED_DEFAULT_CASE_RET();
    36463733        }
    36473734    }
    … …  
    36543741            case IEMMODE_32BIT: return IEM_MC_DEFER_TO_CIMPL_0(iemCImpl_ins_op8_addr32);
    36553742            case IEMMODE_64BIT: return IEM_MC_DEFER_TO_CIMPL_0(iemCImpl_ins_op8_addr64);
     3743            IEM_NOT_REACHED_DEFAULT_CASE_RET();
    36563744        }
    36573745    }
    3658     AssertFailedReturn(VERR_INTERNAL_ERROR_3);
    36593746}
    36603747
    … …  
    36633750FNIEMOP_DEF(iemOp_inswd_Yv_DX)
    36643751{
    3665     uint8_t u8Imm; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &u8Imm);
    36663752    IEMOP_HLP_NO_LOCK_PREFIX();
    36673753    if (pIemCpu->fPrefixes & (IEM_OP_PRF_REPZ | IEM_OP_PRF_REPNZ))
    … …  
    36763762                    case IEMMODE_32BIT: return IEM_MC_DEFER_TO_CIMPL_0(iemCImpl_rep_ins_op16_addr32);
    36773763                    case IEMMODE_64BIT: return IEM_MC_DEFER_TO_CIMPL_0(iemCImpl_rep_ins_op16_addr64);
     3764                    IEM_NOT_REACHED_DEFAULT_CASE_RET();
    36783765                }
    36793766                break;
    … …  
    36853772                    case IEMMODE_32BIT: return IEM_MC_DEFER_TO_CIMPL_0(iemCImpl_rep_ins_op32_addr32);
    36863773                    case IEMMODE_64BIT: return IEM_MC_DEFER_TO_CIMPL_0(iemCImpl_rep_ins_op32_addr64);
     3774                    IEM_NOT_REACHED_DEFAULT_CASE_RET();
    36873775                }
    36883776                break;
     3777            IEM_NOT_REACHED_DEFAULT_CASE_RET();
    36893778        }
    36903779    }
    … …  
    37003789                    case IEMMODE_32BIT: return IEM_MC_DEFER_TO_CIMPL_0(iemCImpl_ins_op16_addr32);
    37013790                    case IEMMODE_64BIT: return IEM_MC_DEFER_TO_CIMPL_0(iemCImpl_ins_op16_addr64);
     3791                    IEM_NOT_REACHED_DEFAULT_CASE_RET();
    37023792                }
    37033793                break;
    … …  
    37093799                    case IEMMODE_32BIT: return IEM_MC_DEFER_TO_CIMPL_0(iemCImpl_ins_op32_addr32);
    37103800                    case IEMMODE_64BIT: return IEM_MC_DEFER_TO_CIMPL_0(iemCImpl_ins_op32_addr64);
     3801                    IEM_NOT_REACHED_DEFAULT_CASE_RET();
    37113802                }
    37123803                break;
     3804            IEM_NOT_REACHED_DEFAULT_CASE_RET();
    37133805        }
    37143806    }
    3715     AssertFailedReturn(VERR_INTERNAL_ERROR_3);
    37163807}
    37173808
    … …  
    37203811FNIEMOP_DEF(iemOp_outsb_Yb_DX)
    37213812{
    3722     uint8_t u8Imm; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &u8Imm);
    37233813    IEMOP_HLP_NO_LOCK_PREFIX();
    3724 
    3725     /*
    3726      * Use the C implementation if a repeate prefix is encountered.
    3727      */
    37283814    if (pIemCpu->fPrefixes & (IEM_OP_PRF_REPNZ | IEM_OP_PRF_REPZ))
    37293815    {
    … …  
    37343820            case IEMMODE_32BIT: return IEM_MC_DEFER_TO_CIMPL_0(iemCImpl_rep_outs_op8_addr32);
    37353821            case IEMMODE_64BIT: return IEM_MC_DEFER_TO_CIMPL_0(iemCImpl_rep_outs_op8_addr64);
     3822            IEM_NOT_REACHED_DEFAULT_CASE_RET();
    37363823        }
    37373824    }
    … …  
    37443831            case IEMMODE_32BIT: return IEM_MC_DEFER_TO_CIMPL_0(iemCImpl_outs_op8_addr32);
    37453832            case IEMMODE_64BIT: return IEM_MC_DEFER_TO_CIMPL_0(iemCImpl_outs_op8_addr64);
     3833            IEM_NOT_REACHED_DEFAULT_CASE_RET();
    37463834        }
    37473835    }
    3748     AssertFailedReturn(VERR_INTERNAL_ERROR_3);
    37493836}
    37503837
    … …  
    37533840FNIEMOP_DEF(iemOp_outswd_Yv_DX)
    37543841{
    3755     uint8_t u8Imm; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &u8Imm);
    37563842    IEMOP_HLP_NO_LOCK_PREFIX();
    37573843    if (pIemCpu->fPrefixes & (IEM_OP_PRF_REPZ | IEM_OP_PRF_REPNZ))
    … …  
    37663852                    case IEMMODE_32BIT: return IEM_MC_DEFER_TO_CIMPL_0(iemCImpl_rep_outs_op16_addr32);
    37673853                    case IEMMODE_64BIT: return IEM_MC_DEFER_TO_CIMPL_0(iemCImpl_rep_outs_op16_addr64);
     3854                    IEM_NOT_REACHED_DEFAULT_CASE_RET();
    37683855                }
    37693856                break;
    … …  
    37753862                    case IEMMODE_32BIT: return IEM_MC_DEFER_TO_CIMPL_0(iemCImpl_rep_outs_op32_addr32);
    37763863                    case IEMMODE_64BIT: return IEM_MC_DEFER_TO_CIMPL_0(iemCImpl_rep_outs_op32_addr64);
     3864                    IEM_NOT_REACHED_DEFAULT_CASE_RET();
    37773865                }
    37783866                break;
     3867            IEM_NOT_REACHED_DEFAULT_CASE_RET();
    37793868        }
    37803869    }
    … …  
    37903879                    case IEMMODE_32BIT: return IEM_MC_DEFER_TO_CIMPL_0(iemCImpl_outs_op16_addr32);
    37913880                    case IEMMODE_64BIT: return IEM_MC_DEFER_TO_CIMPL_0(iemCImpl_outs_op16_addr64);
     3881                    IEM_NOT_REACHED_DEFAULT_CASE_RET();
    37923882                }
    37933883                break;
    … …  
    37993889                    case IEMMODE_32BIT: return IEM_MC_DEFER_TO_CIMPL_0(iemCImpl_outs_op32_addr32);
    38003890                    case IEMMODE_64BIT: return IEM_MC_DEFER_TO_CIMPL_0(iemCImpl_outs_op32_addr64);
     3891                    IEM_NOT_REACHED_DEFAULT_CASE_RET();
    38013892                }
    38023893                break;
     3894            IEM_NOT_REACHED_DEFAULT_CASE_RET();
    38033895        }
    38043896    }
    3805     AssertFailedReturn(VERR_INTERNAL_ERROR_3);
    38063897}
    38073898
    … …  
    47624853                IEM_MC_LOCAL(RTGCPTR, GCPtrEffDst);
    47634854                IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm);
    4764 Log(("GCPtrEffDst=%RGv\n", GCPtrEffDst));
    47654855                IEM_MC_FETCH_MEM_U16(u16Value, pIemCpu->iEffSeg, GCPtrEffDst);
    4766 Log(("u16Value=%#x\n", u16Value));
    47674856                IEM_MC_STORE_GREG_U16(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg, u16Value);
    47684857                IEM_MC_ADVANCE_RIP();
    … …  
    48344923                IEM_MC_BEGIN(0, 1);
    48354924                IEM_MC_LOCAL(uint32_t, u32Value);
    4836                 IEM_MC_FETCH_SREG_U32_ZX(u32Value, iSegReg);
     4925                IEM_MC_FETCH_SREG_ZX_U32(u32Value, iSegReg);
    48374926                IEM_MC_STORE_GREG_U32((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, u32Value);
    48384927                IEM_MC_ADVANCE_RIP();
    … …  
    48434932                IEM_MC_BEGIN(0, 1);
    48444933                IEM_MC_LOCAL(uint64_t, u64Value);
    4845                 IEM_MC_FETCH_SREG_U64_ZX(u64Value, iSegReg);
     4934                IEM_MC_FETCH_SREG_ZX_U64(u64Value, iSegReg);
    48464935                IEM_MC_STORE_GREG_U64((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, u64Value);
    48474936                IEM_MC_ADVANCE_RIP();
    … …  
    60076096
    60086097/** Opcode 0xc2. */
    6009 FNIEMOP_STUB(iemOp_retn_Iw);
     6098FNIEMOP_DEF(iemOp_retn_Iw)
     6099{
     6100    IEMOP_MNEMONIC("retn Iw");
     6101    uint16_t u16Imm; IEM_OPCODE_GET_NEXT_U16(pIemCpu, &u16Imm);
     6102    IEMOP_HLP_NO_LOCK_PREFIX();
     6103    IEMOP_HLP_DEFAULT_64BIT_OP_SIZE();
     6104    return IEM_MC_DEFER_TO_CIMPL_2(iemCImpl_retn, pIemCpu->enmEffOpSize, u16Imm);
     6105}
    60106106
    60116107
    … …  
    60156111    IEMOP_MNEMONIC("retn");
    60166112    IEMOP_HLP_DEFAULT_64BIT_OP_SIZE();
    6017     switch (pIemCpu->enmEffOpSize)
    6018     {
    6019         case IEMMODE_16BIT:
    6020             IEM_MC_BEGIN(0, 1);
    6021             IEM_MC_LOCAL(uint16_t, u16NewIP);
    6022             IEM_MC_POP_U16(&u16NewIP);
    6023             /** @todo This should raise GP(0) if u16NewIP > csHid.u32Limit.
    6024              *        The intel manual does not indicate that this is the
    6025              *        case for 32-bit or 64-bit (canonical check). Needs to
    6026              *        be tested. */
    6027             IEM_MC_SET_RIP_U16(u16NewIP);
    6028             IEM_MC_END()
    6029             return VINF_SUCCESS;
    6030 
    6031         case IEMMODE_32BIT:
    6032             IEM_MC_BEGIN(0, 1);
    6033             IEM_MC_LOCAL(uint32_t, u32NewIP);
    6034             IEM_MC_POP_U32(&u32NewIP);
    6035             IEM_MC_SET_RIP_U32(u32NewIP);
    6036             IEM_MC_END()
    6037             return VINF_SUCCESS;
    6038 
    6039         case IEMMODE_64BIT:
    6040             IEM_MC_BEGIN(0, 1);
    6041             IEM_MC_LOCAL(uint64_t, u64NewIP);
    6042             IEM_MC_POP_U64(&u64NewIP);
    6043             IEM_MC_SET_RIP_U64(u64NewIP);
    6044             IEM_MC_END()
    6045             return VINF_SUCCESS;
    6046 
    6047         default:
    6048             AssertFailedReturn(VERR_INTERNAL_ERROR_2);
    6049     }
     6113    IEMOP_HLP_NO_LOCK_PREFIX();
     6114    return IEM_MC_DEFER_TO_CIMPL_2(iemCImpl_retn, pIemCpu->enmEffOpSize, 0);
    60506115}
    60516116
    … …  
    61866251    uint16_t u16Imm; IEM_OPCODE_GET_NEXT_U16(pIemCpu, &u16Imm);
    61876252    IEMOP_HLP_NO_LOCK_PREFIX();
     6253    IEMOP_HLP_DEFAULT_64BIT_OP_SIZE();
    61886254    return IEM_MC_DEFER_TO_CIMPL_2(iemCImpl_retf, pIemCpu->enmEffOpSize, u16Imm);
    61896255}
    … …  
    61956261    IEMOP_MNEMONIC("retf");
    61966262    IEMOP_HLP_NO_LOCK_PREFIX();
     6263    IEMOP_HLP_DEFAULT_64BIT_OP_SIZE();
    61976264    return IEM_MC_DEFER_TO_CIMPL_2(iemCImpl_retf, pIemCpu->enmEffOpSize, 0);
    61986265}
    … …  
    63036370        case 2: pImpl = &g_iemAImpl_rcl; IEMOP_MNEMONIC("rcl Ev,1"); break;
    63046371        case 3: pImpl = &g_iemAImpl_rcr; IEMOP_MNEMONIC("rcr Ev,1"); break;
    6305         case 4: pImpl = &g_iemAImpl_shl; IEMOP_MNEMONIC("shl Ev,1"); break;
     6372        case 4:
     6373            pImpl = &g_iemAImpl_shl; IEMOP_MNEMONIC("shl Ev,1");
     6374#ifdef IEM_VERIFICATION_MODE
     6375            pIemCpu->fShlHack = true;
     6376#endif
     6377            break;
    63066378        case 5: pImpl = &g_iemAImpl_shr; IEMOP_MNEMONIC("shr Ev,1"); break;
    63076379        case 7: pImpl = &g_iemAImpl_sar; IEMOP_MNEMONIC("sar Ev,1"); break;
    … …  
    64906562        case 2: pImpl = &g_iemAImpl_rcl; IEMOP_MNEMONIC("rcl Ev,CL"); break;
    64916563        case 3: pImpl = &g_iemAImpl_rcr; IEMOP_MNEMONIC("rcr Ev,CL"); break;
    6492         case 4: pImpl = &g_iemAImpl_shl; IEMOP_MNEMONIC("shl Ev,CL"); break;
     6564        case 4:
     6565            pImpl = &g_iemAImpl_shl; IEMOP_MNEMONIC("shl Ev,CL");
     6566#ifdef IEM_VERIFICATION_MODE
     6567            pIemCpu->fShlHack = true;
     6568#endif
     6569            break;
    64936570        case 5: pImpl = &g_iemAImpl_shr; IEMOP_MNEMONIC("shr Ev,CL"); break;
    64946571        case 7: pImpl = &g_iemAImpl_sar; IEMOP_MNEMONIC("sar Ev,CL"); break;

  • trunk/src/VBox/VMM/VMMR3/EM.cpp

    r36768 r36780  
    19951995                 */
    19961996                case EMSTATE_RAW:
    1997 #ifdef IEM_VERIFICATION_MODE /* remove later */
     1997#ifndef IEM_VERIFICATION_MODE /* remove later */
    19981998                    AssertFailed();
    1999 #endif
    20001999                    rc = emR3RawExecute(pVM, pVCpu, &fFFDone);
    20012000                    break;
     2001#endif
    20022002
    20032003                /*
    … …  
    20052005                 */
    20062006                case EMSTATE_HWACC:
    2007 #ifdef IEM_VERIFICATION_MODE /* remove later */
     2007#ifndef IEM_VERIFICATION_MODE /* remove later */
    20082008                    AssertFailed();
    2009 #endif
    20102009                    rc = emR3HwAccExecute(pVM, pVCpu, &fFFDone);
    20112010                    break;
     2011#endif
    20122012
    20132013                /*
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