VirtualBox

Changeset 36840 in vbox for trunk/src/VBox/VMM


Ignore:
Timestamp:
Apr 25, 2011 7:47:38 PM (14 years ago)
Author:
vboxsync
Message:

IEM: cpuid, clts, fixes.

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

Legend:

Unmodified
Added
Removed

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

    r36838 r36840  
    614614    RTGCPHYS const offPrevOpcodes = GCPhys - pIemCpu->GCPhysOpcodes;
    615615    pIemCpu->GCPhysOpcodes = GCPhys;
    616     if (offPrevOpcodes < cbOldOpcodes)
     616    if (   offPrevOpcodes < cbOldOpcodes
     617        && PAGE_SIZE - (GCPhys & PAGE_OFFSET_MASK) > sizeof(pIemCpu->abOpcode))
    617618    {
    618619        uint8_t cbNew = cbOldOpcodes - (uint8_t)offPrevOpcodes;
    … …  
    660661     */
    661662    PCPUMCTX    pCtx = pIemCpu->CTX_SUFF(pCtx);
     663    uint8_t     cbLeft = pIemCpu->cbOpcode - pIemCpu->offOpcode; Assert(cbLeft < cbMin);
    662664    uint32_t    cbToTryRead;
    663665    RTGCPTR     GCPtrNext;
    … …  
    669671            return iemRaiseGeneralProtectionFault0(pIemCpu);
    670672        cbToTryRead = PAGE_SIZE - (GCPtrNext & PAGE_OFFSET_MASK);
    671         Assert(cbToTryRead >= cbMin); /* ASSUMPTION based on iemInitDecoderAndPrefetchOpcodes. */
     673        Assert(cbToTryRead >= cbMin - cbLeft); /* ASSUMPTION based on iemInitDecoderAndPrefetchOpcodes. */
    672674    }
    673675    else
    … …  
    679681            return iemRaiseSelectorBounds(pIemCpu, X86_SREG_CS, IEM_ACCESS_INSTRUCTION);
    680682        cbToTryRead = pCtx->csHid.u32Limit - GCPtrNext32 + 1;
    681         if (cbToTryRead < cbMin)
     683        if (cbToTryRead < cbMin - cbLeft)
    682684            return iemRaiseSelectorBounds(pIemCpu, X86_SREG_CS, IEM_ACCESS_INSTRUCTION);
    683685        GCPtrNext = pCtx->csHid.u64Base + GCPtrNext32;
    … …  
    694696        return iemRaisePageFault(pIemCpu, GCPtrNext, IEM_ACCESS_INSTRUCTION, VERR_ACCESS_DENIED);
    695697    GCPhys |= GCPtrNext & PAGE_OFFSET_MASK;
     698    //Log(("GCPtrNext=%RGv GCPhys=%RGp cbOpcodes=%#x\n",  GCPtrNext,  GCPhys,  pIemCpu->cbOpcode));
    696699    /** @todo Check reserved bits and such stuff. PGM is better at doing
    697700     *        that, so do it when implementing the guest virtual address
    … …  
    706709    if (cbToTryRead > sizeof(pIemCpu->abOpcode) - pIemCpu->cbOpcode)
    707710        cbToTryRead = sizeof(pIemCpu->abOpcode) - pIemCpu->cbOpcode;
     711    Assert(cbToTryRead >= cbMin - cbLeft);
    708712    if (!pIemCpu->fByPassHandlers)
    709713        rc = PGMPhysRead(IEMCPU_TO_VM(pIemCpu), GCPhys, &pIemCpu->abOpcode[pIemCpu->cbOpcode], cbToTryRead);
    … …  
    713717        return rc;
    714718    pIemCpu->cbOpcode += cbToTryRead;
     719    //Log(("%.*Rhxs\n", pIemCpu->cbOpcode, pIemCpu->abOpcode));
    715720
    716721    return VINF_SUCCESS;
    … …  
    41734178    pIemCpu->fNoRem = !LogIsEnabled(); /* logging triggers the no-rem/rem verification stuff */
    41744179
     4180#if 0
     4181    // Auto enable; DSL.
     4182    if (    pIemCpu->fNoRem
     4183        &&  pOrgCtx->cs  == 0x10
     4184        &&  (   pOrgCtx->rip == 0x00100fc7
     4185             || pOrgCtx->rip == 0x00100ffc
     4186             || pOrgCtx->rip == 0x00100ffe
     4187            )
     4188       )
     4189    {
     4190        RTLogFlags(NULL, "enabled");
     4191        pIemCpu->fNoRem = false;
     4192    }
     4193#endif
     4194
    41754195    /*
    41764196     * Switch state.
    … …  
    45034523                && pEvtRec->u.RamWrite.cb != 4) )
    45044524        {
    4505             RTAssertMsg1(NULL, __LINE__, __FILE__, __PRETTY_FUNCTION__);
    4506             RTAssertMsg2Weak("Memory at %RGv differs\n", pEvtRec->u.RamWrite.GCPhys);
    4507             RTAssertMsg2Add("REM: %.*Rhxs\n"
    4508                             "IEM: %.*Rhxs\n",
    4509                             pEvtRec->u.RamWrite.cb, abBuf,
    4510                             pEvtRec->u.RamWrite.cb, pEvtRec->u.RamWrite.ab);
    4511             iemVerifyAssertAddRecordDump(pEvtRec);
    4512             iemOpStubMsg2(pIemCpu);
    4513             RTAssertPanic();
     4525            /* fend off ROMs */
     4526            if (   pEvtRec->u.RamWrite.GCPhys - UINT32_C(0x000c0000) > UINT32_C(0x8000)
     4527                && pEvtRec->u.RamWrite.GCPhys - UINT32_C(0x000e0000) > UINT32_C(0x20000)
     4528                && pEvtRec->u.RamWrite.GCPhys - UINT32_C(0xfffc0000) > UINT32_C(0x40000) )
     4529            {
     4530                RTAssertMsg1(NULL, __LINE__, __FILE__, __PRETTY_FUNCTION__);
     4531                RTAssertMsg2Weak("Memory at %RGv differs\n", pEvtRec->u.RamWrite.GCPhys);
     4532                RTAssertMsg2Add("REM: %.*Rhxs\n"
     4533                                "IEM: %.*Rhxs\n",
     4534                                pEvtRec->u.RamWrite.cb, abBuf,
     4535                                pEvtRec->u.RamWrite.cb, pEvtRec->u.RamWrite.ab);
     4536                iemVerifyAssertAddRecordDump(pEvtRec);
     4537                iemOpStubMsg2(pIemCpu);
     4538                RTAssertPanic();
     4539            }
    45144540        }
    45154541    }
    … …  
    45744600        } while (0)
    45754601
     4602#  define CHECK_SEL(a_Sel) \
     4603        do \
     4604        { \
     4605            CHECK_FIELD(a_Sel); \
     4606            if (   pOrgCtx->a_Sel##Hid.Attr.u != pDebugCtx->a_Sel##Hid.Attr.u \
     4607                && (pOrgCtx->a_Sel##Hid.Attr.u | X86_SEL_TYPE_ACCESSED) != pDebugCtx->a_Sel##Hid.Attr.u) \
     4608            { \
     4609                RTAssertMsg2Weak("  %8sHid.Attr differs - iem=%02x - rem=%02x\n", #a_Sel, pDebugCtx->a_Sel##Hid.Attr.u, pOrgCtx->a_Sel##Hid.Attr.u); \
     4610                cDiffs++; \
     4611            } \
     4612            CHECK_FIELD(a_Sel##Hid.u64Base); \
     4613            CHECK_FIELD(a_Sel##Hid.u32Limit); \
     4614        } while (0)
     4615
    45764616        if (memcmp(&pOrgCtx->fpu, &pDebugCtx->fpu, sizeof(pDebugCtx->fpu)))
    45774617        {
    … …  
    45894629            fFlagsMask &= ~(X86_EFL_SF | X86_EFL_ZF | X86_EFL_AF | X86_EFL_PF | X86_EFL_CF);
    45904630        if (pIemCpu->fShiftOfHack)
    4591             fFlagsMask &= ~(X86_EFL_OF);
     4631            fFlagsMask &= ~(X86_EFL_OF | X86_EFL_AF);
    45924632        if ((pOrgCtx->rflags.u & fFlagsMask) != (pDebugCtx->rflags.u & fFlagsMask))
    45934633        {
    … …  
    46314671        CHECK_FIELD(r12);
    46324672        CHECK_FIELD(r13);
    4633         CHECK_FIELD(cs);
    4634         CHECK_FIELD(csHid.u64Base);
    4635         CHECK_FIELD(csHid.u32Limit);
    4636         CHECK_FIELD(csHid.Attr.u);
    4637         CHECK_FIELD(ss);
    4638         CHECK_FIELD(ssHid.u64Base);
    4639         CHECK_FIELD(ssHid.u32Limit);
    4640         CHECK_FIELD(ssHid.Attr.u);
    4641         CHECK_FIELD(ds);
    4642         CHECK_FIELD(dsHid.u64Base);
    4643         CHECK_FIELD(dsHid.u32Limit);
    4644         CHECK_FIELD(dsHid.Attr.u);
    4645         CHECK_FIELD(es);
    4646         CHECK_FIELD(esHid.u64Base);
    4647         CHECK_FIELD(esHid.u32Limit);
    4648         CHECK_FIELD(esHid.Attr.u);
    4649         CHECK_FIELD(fs);
    4650         CHECK_FIELD(fsHid.u64Base);
    4651         CHECK_FIELD(fsHid.u32Limit);
    4652         CHECK_FIELD(fsHid.Attr.u);
    4653         CHECK_FIELD(gs);
    4654         CHECK_FIELD(gsHid.u64Base);
    4655         CHECK_FIELD(gsHid.u32Limit);
    4656         CHECK_FIELD(gsHid.Attr.u);
     4673        CHECK_SEL(cs);
     4674        CHECK_SEL(ss);
     4675        CHECK_SEL(ds);
     4676        CHECK_SEL(es);
     4677        CHECK_SEL(fs);
     4678        CHECK_SEL(gs);
    46574679        CHECK_FIELD(cr0);
    46584680        CHECK_FIELD(cr2);

  • trunk/src/VBox/VMM/VMMAll/IEMAllAImpl.asm

    r36815 r36840  
    618618IEMIMPL_SHIFT_OP rcl, (X86_EFL_OF | X86_EFL_CF), 0
    619619IEMIMPL_SHIFT_OP rcr, (X86_EFL_OF | X86_EFL_CF), 0
     620%ifndef IEM_VERIFICATION_MODE
    620621IEMIMPL_SHIFT_OP shl, (X86_EFL_OF | X86_EFL_SF | X86_EFL_ZF | X86_EFL_PF | X86_EFL_CF), (X86_EFL_AF)
    621622IEMIMPL_SHIFT_OP shr, (X86_EFL_OF | X86_EFL_SF | X86_EFL_ZF | X86_EFL_PF | X86_EFL_CF), (X86_EFL_AF)
    622623IEMIMPL_SHIFT_OP sar, (X86_EFL_OF | X86_EFL_SF | X86_EFL_ZF | X86_EFL_PF | X86_EFL_CF), (X86_EFL_AF)
     624%else
     625IEMIMPL_SHIFT_OP shl, (X86_EFL_OF | X86_EFL_SF | X86_EFL_ZF | X86_EFL_PF | X86_EFL_CF | X86_EFL_AF), 0
     626IEMIMPL_SHIFT_OP shr, (X86_EFL_OF | X86_EFL_SF | X86_EFL_ZF | X86_EFL_PF | X86_EFL_CF | X86_EFL_AF), 0
     627IEMIMPL_SHIFT_OP sar, (X86_EFL_OF | X86_EFL_SF | X86_EFL_ZF | X86_EFL_PF | X86_EFL_CF | X86_EFL_AF), 0
     628%endif
    623629
    624630

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

    r36838 r36840  
    19921992    uint64_t uNewCr0 = pCtx->cr0     & ~(X86_CR0_MP | X86_CR0_EM | X86_CR0_TS);
    19931993    uNewCr0 |= u16NewMsw & (X86_CR0_PE | X86_CR0_MP | X86_CR0_EM | X86_CR0_TS);
    1994     return IEM_CIMPL_CALL_2(iemCImpl_load_CrX, 0, uNewCr0);
     1994    return IEM_CIMPL_CALL_2(iemCImpl_load_CrX, /*cr*/ 0, uNewCr0);
     1995}
     1996
     1997
     1998/**
     1999 * Implements 'CLTS'.
     2000 */
     2001IEM_CIMPL_DEF_0(iemOpCImpl_clts)
     2002{
     2003    if (pIemCpu->uCpl != 0)
     2004        return iemRaiseGeneralProtectionFault0(pIemCpu);
     2005
     2006    PCPUMCTX pCtx = pIemCpu->CTX_SUFF(pCtx);
     2007    uint64_t uNewCr0 = pCtx->cr0;
     2008    uNewCr0 &= ~X86_CR0_TS;
     2009    return IEM_CIMPL_CALL_2(iemCImpl_load_CrX, /*cr*/ 0, uNewCr0);
    19952010}
    19962011
    … …  
    21972212
    21982213
     2214/**
     2215 * Implements 'CPUID'.
     2216 */
     2217IEM_CIMPL_DEF_0(iemOpCImpl_cpuid)
     2218{
     2219    PCPUMCTX pCtx = pIemCpu->CTX_SUFF(pCtx);
     2220
     2221    CPUMGetGuestCpuId(IEMCPU_TO_VMCPU(pIemCpu), pCtx->eax, &pCtx->eax, &pCtx->ebx, &pCtx->ecx, &pCtx->edx);
     2222    pCtx->rax &= UINT32_C(0xffffffff);
     2223    pCtx->rbx &= UINT32_C(0xffffffff);
     2224    pCtx->rcx &= UINT32_C(0xffffffff);
     2225    pCtx->rdx &= UINT32_C(0xffffffff);
     2226
     2227    iemRegAddToRip(pIemCpu, cbInstr);
     2228    return VINF_SUCCESS;
     2229}
     2230
     2231
    21992232/*
    22002233 * Instantiate the various string operation combinations.

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

    r36838 r36840  
    880880/** Opcode 0x0f 0x04. */
    881881FNIEMOP_STUB(iemOp_syscall);
     882
     883
    882884/** Opcode 0x0f 0x05. */
    883 FNIEMOP_STUB(iemOp_clts);
     885FNIEMOP_DEF(iemOp_clts)
     886{
     887    IEMOP_MNEMONIC("clts");
     888    IEMOP_HLP_NO_LOCK_PREFIX();
     889    return IEM_MC_DEFER_TO_CIMPL_0(iemOpCImpl_clts);
     890}
     891
     892
    884893/** Opcode 0x0f 0x06. */
    885894FNIEMOP_STUB(iemOp_sysret);
    … …  
    24012410FNIEMOP_DEF(iemOp_push_fs)
    24022411{
     2412    IEMOP_MNEMONIC("push fs");
    24032413    IEMOP_HLP_NO_LOCK_PREFIX();
    24042414    return FNIEMOP_CALL_1(iemOpCommonPushSReg, X86_SREG_FS);
    … …  
    24092419FNIEMOP_DEF(iemOp_pop_fs)
    24102420{
     2421    IEMOP_MNEMONIC("pop fs");
    24112422    IEMOP_HLP_NO_LOCK_PREFIX();
    24122423    return IEM_MC_DEFER_TO_CIMPL_2(iemOpCImpl_pop_Sreg, X86_SREG_FS, pIemCpu->enmEffOpSize);
    … …  
    24152426
    24162427/** Opcode 0x0f 0xa2. */
    2417 FNIEMOP_STUB(iemOp_cpuid);
     2428FNIEMOP_DEF(iemOp_cpuid)
     2429{
     2430    IEMOP_MNEMONIC("cpuid");
     2431    IEMOP_HLP_NO_LOCK_PREFIX();
     2432    return IEM_MC_DEFER_TO_CIMPL_0(iemOpCImpl_cpuid);
     2433}
     2434
     2435
    24182436/** Opcode 0x0f 0xa3. */
    24192437FNIEMOP_STUB(iemOp_bt_Ev_Gv);
    … …  
    24272445FNIEMOP_DEF(iemOp_push_gs)
    24282446{
     2447    IEMOP_MNEMONIC("push gs");
    24292448    IEMOP_HLP_NO_LOCK_PREFIX();
    24302449    return FNIEMOP_CALL_1(iemOpCommonPushSReg, X86_SREG_GS);
    … …  
    24352454FNIEMOP_DEF(iemOp_pop_gs)
    24362455{
     2456    IEMOP_MNEMONIC("pop gs");
    24372457    IEMOP_HLP_NO_LOCK_PREFIX();
    24382458    return IEM_MC_DEFER_TO_CIMPL_2(iemOpCImpl_pop_Sreg, X86_SREG_GS, pIemCpu->enmEffOpSize);
    … …  
    63696389/** Opcode 0x9b. */
    63706390FNIEMOP_STUB(iemOp_wait);
     6391/** @todo Do WAIT next. */
    63716392
    63726393
    … …  
    64536474     * Get the offset and fend of lock prefixes.
    64546475     */
     6476    IEMOP_MNEMONIC("mov rAX,Ov");
    64556477    RTGCPTR GCPtrMemOff;
    64566478    IEMOP_FETCH_MOFFS_XX(GCPtrMemOff);
    … …  
    75817603        IEM_NOT_REACHED_DEFAULT_CASE_RET(); /* gcc maybe stupid */
    75827604    }
     7605#ifdef IEM_VERIFICATION_MODE
     7606    pIemCpu->fShiftOfHack = true;
     7607#endif
    75837608
    75847609    if ((bRm & X86_MODRM_MOD_MASK) == (3 << X86_MODRM_MOD_SHIFT))
    … …  
    75937618        IEM_MC_REF_GREG_U8(pu8Dst, (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB);
    75947619        IEM_MC_REF_EFLAGS(pEFlags);
    7595 #ifdef IEM_VERIFICATION_MODE
    7596         if (cShift > 1) pIemCpu->fShiftOfHack = true;
    7597 #endif
    75987620        IEM_MC_CALL_VOID_AIMPL_3(pImpl->pfnNormalU8, pu8Dst, cShiftArg, pEFlags);
    75997621        IEM_MC_ADVANCE_RIP();
    … …  
    76157637        IEM_MC_MEM_MAP(pu8Dst, IEM_ACCESS_DATA_RW, pIemCpu->iEffSeg, GCPtrEffDst, 0 /*arg*/);
    76167638        IEM_MC_FETCH_EFLAGS(EFlags);
    7617 #ifdef IEM_VERIFICATION_MODE
    7618         if (cShift > 1) pIemCpu->fShiftOfHack = true;
    7619 #endif
    76207639        IEM_MC_CALL_VOID_AIMPL_3(pImpl->pfnNormalU8, pu8Dst, cShiftArg, pEFlags);
    76217640
    … …  
    76467665        IEM_NOT_REACHED_DEFAULT_CASE_RET(); /* gcc maybe stupid */
    76477666    }
     7667#ifdef IEM_VERIFICATION_MODE
     7668    pIemCpu->fShiftOfHack = true;
     7669#endif
    76487670
    76497671    if ((bRm & X86_MODRM_MOD_MASK) == (3 << X86_MODRM_MOD_SHIFT))
    … …  
    76517673        /* register */
    76527674        uint8_t cShift; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &cShift);
    7653 #ifdef IEM_VERIFICATION_MODE
    7654         if (cShift > 1) pIemCpu->fShiftOfHack = true;
    7655 #endif
    76567675        IEMOP_HLP_NO_LOCK_PREFIX();
    76577676        switch (pIemCpu->enmEffOpSize)
    … …  
    77117730                IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm);
    77127731                uint8_t cShift; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &cShift);
    7713 #ifdef IEM_VERIFICATION_MODE
    7714                 if (cShift > 1) pIemCpu->fShiftOfHack = true;
    7715 #endif
    77167732                IEM_MC_ASSIGN(cShiftArg, cShift);
    77177733                IEM_MC_MEM_MAP(pu16Dst, IEM_ACCESS_DATA_RW, pIemCpu->iEffSeg, GCPtrEffDst, 0 /*arg*/);
    … …  
    77347750                IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm);
    77357751                uint8_t cShift; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &cShift);
    7736 #ifdef IEM_VERIFICATION_MODE
    7737                 if (cShift > 1) pIemCpu->fShiftOfHack = true;
    7738 #endif
    77397752                IEM_MC_ASSIGN(cShiftArg, cShift);
    77407753                IEM_MC_MEM_MAP(pu32Dst, IEM_ACCESS_DATA_RW, pIemCpu->iEffSeg, GCPtrEffDst, 0 /*arg*/);
    … …  
    77577770                IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm);
    77587771                uint8_t cShift; IEM_OPCODE_GET_NEXT_BYTE(pIemCpu, &cShift);
    7759 #ifdef IEM_VERIFICATION_MODE
    7760                 if (cShift > 1) pIemCpu->fShiftOfHack = true;
    7761 #endif
    77627772                IEM_MC_ASSIGN(cShiftArg, cShift);
    77637773                IEM_MC_MEM_MAP(pu64Dst, IEM_ACCESS_DATA_RW, pIemCpu->iEffSeg, GCPtrEffDst, 0 /*arg*/);
    … …  
    80118021        IEM_NOT_REACHED_DEFAULT_CASE_RET(); /* gcc maybe, well... */
    80128022    }
     8023#ifdef IEM_VERIFICATION_MODE
     8024    pIemCpu->fShiftOfHack = true;
     8025#endif
    80138026
    80148027    if ((bRm & X86_MODRM_MOD_MASK) == (3 << X86_MODRM_MOD_SHIFT))
    … …  
    80688081        IEM_NOT_REACHED_DEFAULT_CASE_RET(); /* gcc maybe, well... */
    80698082    }
     8083#ifdef IEM_VERIFICATION_MODE
     8084    pIemCpu->fShiftOfHack = true;
     8085#endif
    80708086
    80718087    if ((bRm & X86_MODRM_MOD_MASK) == (3 << X86_MODRM_MOD_SHIFT))
    … …  
    81978213        IEM_NOT_REACHED_DEFAULT_CASE_RET(); /* gcc, grr. */
    81988214    }
     8215#ifdef IEM_VERIFICATION_MODE
     8216    pIemCpu->fShiftOfHack = true;
     8217#endif
    81998218
    82008219    if ((bRm & X86_MODRM_MOD_MASK) == (3 << X86_MODRM_MOD_SHIFT))
    … …  
    82098228        IEM_MC_FETCH_GREG_U8(cShiftArg, X86_GREG_xCX);
    82108229        IEM_MC_REF_EFLAGS(pEFlags);
    8211 #ifdef IEM_VERIFICATION_MODE
    8212         if (cShiftArg > 1) pIemCpu->fShiftOfHack = true;
    8213 #endif
    82148230        IEM_MC_CALL_VOID_AIMPL_3(pImpl->pfnNormalU8, pu8Dst, cShiftArg, pEFlags);
    82158231        IEM_MC_ADVANCE_RIP();
    … …  
    82308246        IEM_MC_MEM_MAP(pu8Dst, IEM_ACCESS_DATA_RW, pIemCpu->iEffSeg, GCPtrEffDst, 0 /*arg*/);
    82318247        IEM_MC_FETCH_EFLAGS(EFlags);
    8232 #ifdef IEM_VERIFICATION_MODE
    8233         if (cShiftArg > 1) pIemCpu->fShiftOfHack = true;
    8234 #endif
    82358248        IEM_MC_CALL_VOID_AIMPL_3(pImpl->pfnNormalU8, pu8Dst, cShiftArg, pEFlags);
    82368249
    … …  
    82618274        IEM_NOT_REACHED_DEFAULT_CASE_RET(); /* gcc maybe stupid */
    82628275    }
     8276#ifdef IEM_VERIFICATION_MODE
     8277    pIemCpu->fShiftOfHack = true;
     8278#endif
    82638279
    82648280    if ((bRm & X86_MODRM_MOD_MASK) == (3 << X86_MODRM_MOD_SHIFT))
    … …  
    82768292                IEM_MC_FETCH_GREG_U8(cShiftArg, X86_GREG_xCX);
    82778293                IEM_MC_REF_EFLAGS(pEFlags);
    8278 #ifdef IEM_VERIFICATION_MODE
    8279                 if (cShiftArg > 1) pIemCpu->fShiftOfHack = true;
    8280 #endif
    82818294                IEM_MC_CALL_VOID_AIMPL_3(pImpl->pfnNormalU16, pu16Dst, cShiftArg, pEFlags);
    82828295                IEM_MC_ADVANCE_RIP();
    … …  
    82928305                IEM_MC_FETCH_GREG_U8(cShiftArg, X86_GREG_xCX);
    82938306                IEM_MC_REF_EFLAGS(pEFlags);
    8294 #ifdef IEM_VERIFICATION_MODE
    8295                 if (cShiftArg > 1) pIemCpu->fShiftOfHack = true;
    8296 #endif
    82978307                IEM_MC_CALL_VOID_AIMPL_3(pImpl->pfnNormalU32, pu32Dst, cShiftArg, pEFlags);
    82988308                IEM_MC_ADVANCE_RIP();
    … …  
    83088318                IEM_MC_FETCH_GREG_U8(cShiftArg, X86_GREG_xCX);
    83098319                IEM_MC_REF_EFLAGS(pEFlags);
    8310 #ifdef IEM_VERIFICATION_MODE
    8311                 if (cShiftArg > 1) pIemCpu->fShiftOfHack = true;
    8312 #endif
    83138320                IEM_MC_CALL_VOID_AIMPL_3(pImpl->pfnNormalU64, pu64Dst, cShiftArg, pEFlags);
    83148321                IEM_MC_ADVANCE_RIP();
    … …  
    83368343                IEM_MC_MEM_MAP(pu16Dst, IEM_ACCESS_DATA_RW, pIemCpu->iEffSeg, GCPtrEffDst, 0 /*arg*/);
    83378344                IEM_MC_FETCH_EFLAGS(EFlags);
    8338 #ifdef IEM_VERIFICATION_MODE
    8339                 if (cShiftArg > 1) pIemCpu->fShiftOfHack = true;
    8340 #endif
    83418345                IEM_MC_CALL_VOID_AIMPL_3(pImpl->pfnNormalU16, pu16Dst, cShiftArg, pEFlags);
    83428346
    … …  
    83588362                IEM_MC_MEM_MAP(pu32Dst, IEM_ACCESS_DATA_RW, pIemCpu->iEffSeg, GCPtrEffDst, 0 /*arg*/);
    83598363                IEM_MC_FETCH_EFLAGS(EFlags);
    8360 #ifdef IEM_VERIFICATION_MODE
    8361                 if (cShiftArg > 1) pIemCpu->fShiftOfHack = true;
    8362 #endif
    83638364                IEM_MC_CALL_VOID_AIMPL_3(pImpl->pfnNormalU32, pu32Dst, cShiftArg, pEFlags);
    83648365
    … …  
    83808381                IEM_MC_MEM_MAP(pu64Dst, IEM_ACCESS_DATA_RW, pIemCpu->iEffSeg, GCPtrEffDst, 0 /*arg*/);
    83818382                IEM_MC_FETCH_EFLAGS(EFlags);
    8382 #ifdef IEM_VERIFICATION_MODE
    8383                 if (cShiftArg > 1) pIemCpu->fShiftOfHack = true;
    8384 #endif
    83858383                IEM_MC_CALL_VOID_AIMPL_3(pImpl->pfnNormalU64, pu64Dst, cShiftArg, pEFlags);
    83868384
    … …  
    84578455/** Opcode 0xdb. */
    84588456FNIEMOP_STUB(iemOp_EscF3);
     8457/** @todo Do FINIT next. */
     8458
    84598459/** Opcode 0xdc. */
    84608460FNIEMOP_STUB(iemOp_EscF4);
    … …  
    84658465/** Opcode 0xdf. */
    84668466FNIEMOP_STUB(iemOp_EscF7);
     8467/** @todo Do FNSTSW next. */
    84678468
    84688469
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