VirtualBox

Changeset 47740 in vbox for trunk/src/VBox


Ignore:
Timestamp:
Aug 14, 2013 7:55:03 PM (11 years ago)
Author:
vboxsync
Message:

IEM: Implemented RF. Working on verfication against VT-x.

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

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/VMM/Makefile.kmk

    r47652 r47740  
    6666# VMM_COMMON_DEFS += VBOX_WITH_NS_ACCOUNTING_STATS
    6767
    68 # Special IEM debug mode which compares the result with REM.
     68# Special IEM debug mode which compares the result with HM/REM
    6969ifdef IEM_VERIFICATION_MODE
    70  VMM_COMMON_DEFS += IEM_VERIFICATION_MODE IEM_VERIFICATION_MODE_FULL
     70 VMM_COMMON_DEFS += IEM_VERIFICATION_MODE IEM_VERIFICATION_MODE_FULL IEM_VERIFICATION_MODE_FULL_HM
    7171endif
    7272

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

    r47713 r47740  
    729729static VBOXSTRICTRC     iemVerifyFakeIOPortWrite(PIEMCPU pIemCpu, RTIOPORT Port, uint32_t u32Value, size_t cbValue);
    730730
    731 static void             iemHlpLoadNullDataSelectorProt(PCPUMSELREG pSReg, RTSEL uRpl);
    732731
    733732
    … …  
    22292228
    22302229/**
     2230 * Loads a NULL data selector into when coming from V8086 mode.
     2231 *
     2232 * @param   pIemCpu         The IEM per CPU instance data.
     2233 * @param   pSReg               Pointer to the segment register.
     2234 */
     2235static void iemHlpLoadNullDataSelectorOnV86Xcpt(PIEMCPU pIemCpu, PCPUMSELREG pSReg)
     2236{
     2237    pSReg->Sel      = 0;
     2238    pSReg->ValidSel = 0;
     2239    if (IEM_IS_GUEST_CPU_INTEL(pIemCpu) && !IEM_FULL_VERIFICATION_REM_ENABLED(pIemCpu))
     2240    {
     2241        /* VT-x (Intel 3960x) doesn't change the base and limit, clears and sets the following attributes */
     2242        pSReg->Attr.u &= X86DESCATTR_DT | X86DESCATTR_TYPE | X86DESCATTR_DPL | X86DESCATTR_G | X86DESCATTR_D;
     2243        pSReg->Attr.u |= X86DESCATTR_UNUSABLE;
     2244    }
     2245    else
     2246    {
     2247        pSReg->fFlags   = CPUMSELREG_FLAGS_VALID;
     2248        /** @todo check this on AMD-V */
     2249        pSReg->u64Base  = 0;
     2250        pSReg->u32Limit = 0;
     2251    }
     2252}
     2253
     2254
     2255/**
    22312256 * Implements exceptions and interrupts for protected mode.
    22322257 *
    … …  
    23962421    }
    23972422
    2398     uint32_t        fEfl    = IEMMISC_GET_EFL(pIemCpu, pCtx);
    23992423    uint8_t const   uNewCpl = DescCS.Legacy.Gen.u4Type & X86_SEL_TYPE_CONF
    24002424                            ? pIemCpu->uCpl : DescCS.Legacy.Gen.u2Dpl;
     2425    uint32_t        fEfl    = IEMMISC_GET_EFL(pIemCpu, pCtx);
     2426    if (   !(fFlags & IEM_XCPT_FLAGS_T_SOFT_INT)
     2427        && (u8Vector != X86_XCPT_DE || (fFlags & IEM_XCPT_FLAGS_T_EXT_INT))
     2428        && !IEM_FULL_VERIFICATION_REM_ENABLED(pIemCpu))
     2429        fEfl |= X86_EFL_RF; /* Vagueness is all I've found on this so far... */ /** @todo Automatically pushing EFLAGS.RF. */
    24012430
    24022431    /* From V8086 mode only go to CPL 0. */
    … …  
    25272556        if (fEfl & X86_EFL_VM)
    25282557        {
    2529             iemHlpLoadNullDataSelectorProt(&pCtx->gs, 0);
    2530             iemHlpLoadNullDataSelectorProt(&pCtx->fs, 0);
    2531             iemHlpLoadNullDataSelectorProt(&pCtx->es, 0);
    2532             iemHlpLoadNullDataSelectorProt(&pCtx->ds, 0);
     2558            iemHlpLoadNullDataSelectorOnV86Xcpt(pIemCpu, &pCtx->gs);
     2559            iemHlpLoadNullDataSelectorOnV86Xcpt(pIemCpu, &pCtx->fs);
     2560            iemHlpLoadNullDataSelectorOnV86Xcpt(pIemCpu, &pCtx->es);
     2561            iemHlpLoadNullDataSelectorOnV86Xcpt(pIemCpu, &pCtx->ds);
    25332562        }
    25342563    }
    … …  
    38123841 * Updates the RIP/EIP/IP to point to the next instruction.
    38133842 *
     3843 * This function leaves the EFLAGS.RF flag alone.
     3844 *
    38143845 * @param   pIemCpu             The per CPU data.
    38153846 * @param   cbInstr             The number of bytes to add.
    38163847 */
    3817 static void iemRegAddToRip(PIEMCPU pIemCpu, uint8_t cbInstr)
     3848static void iemRegAddToRipKeepRF(PIEMCPU pIemCpu, uint8_t cbInstr)
    38183849{
    38193850    PCPUMCTX pCtx = pIemCpu->CTX_SUFF(pCtx);
    … …  
    38393870
    38403871
     3872#if 0
    38413873/**
    38423874 * Updates the RIP/EIP/IP to point to the next instruction.
    … …  
    38443876 * @param   pIemCpu             The per CPU data.
    38453877 */
    3846 static void iemRegUpdateRip(PIEMCPU pIemCpu)
    3847 {
    3848     return iemRegAddToRip(pIemCpu, pIemCpu->offOpcode);
     3878static void iemRegUpdateRipKeepRF(PIEMCPU pIemCpu)
     3879{
     3880    return iemRegAddToRipKeepRF(pIemCpu, pIemCpu->offOpcode);
     3881}
     3882#endif
     3883
     3884
     3885
     3886/**
     3887 * Updates the RIP/EIP/IP to point to the next instruction and clears EFLAGS.RF.
     3888 *
     3889 * @param   pIemCpu             The per CPU data.
     3890 * @param   cbInstr             The number of bytes to add.
     3891 */
     3892static void iemRegAddToRipAndClearRF(PIEMCPU pIemCpu, uint8_t cbInstr)
     3893{
     3894    PCPUMCTX pCtx = pIemCpu->CTX_SUFF(pCtx);
     3895
     3896    pCtx->eflags.Bits.u1RF = 0;
     3897
     3898    switch (pIemCpu->enmCpuMode)
     3899    {
     3900        case IEMMODE_16BIT:
     3901            Assert(pCtx->rip <= UINT16_MAX);
     3902            pCtx->eip += cbInstr;
     3903            pCtx->eip &= UINT32_C(0xffff);
     3904            break;
     3905
     3906        case IEMMODE_32BIT:
     3907            pCtx->eip += cbInstr;
     3908            Assert(pCtx->rip <= UINT32_MAX);
     3909            break;
     3910
     3911        case IEMMODE_64BIT:
     3912            pCtx->rip += cbInstr;
     3913            break;
     3914        default: AssertFailed();
     3915    }
     3916}
     3917
     3918
     3919/**
     3920 * Updates the RIP/EIP/IP to point to the next instruction and clears EFLAGS.RF.
     3921 *
     3922 * @param   pIemCpu             The per CPU data.
     3923 */
     3924static void iemRegUpdateRipAndClearRF(PIEMCPU pIemCpu)
     3925{
     3926    return iemRegAddToRipAndClearRF(pIemCpu, pIemCpu->offOpcode);
    38493927}
    38503928
    … …  
    51285206                    * The upper boundary is defined by the B bit, not the G bit!
    51295207                    */
    5130                    if (   GCPtrFirst32 < pSel->u32Limit + 1
    5131                        || GCPtrLast32  > (pSel->Attr.n.u1DefBig ? 0xFFFFFFFF : 0xFFFF))
     5208                   if (   GCPtrFirst32 < pSel->u32Limit + UINT32_C(1)
     5209                       || GCPtrLast32  > (pSel->Attr.n.u1DefBig ? UINT32_MAX : UINT32_C(0xffff)))
    51325210                      return iemRaiseSelectorBounds(pIemCpu, iSegReg, fAccess);
    5133                    
    51345211                }
    51355212                *pGCPtrMem = GCPtrFirst32 += (uint32_t)pSel->u64Base;
    … …  
    52695346    /* Force the alternative path so we can ignore writes. */
    52705347    if ((fAccess & IEM_ACCESS_TYPE_WRITE) && !pIemCpu->fNoRem)
     5348    {
     5349        if (IEM_FULL_VERIFICATION_ENABLED(pIemCpu))
     5350        {
     5351            int rc2 = PGMPhysIemQueryAccess(IEMCPU_TO_VM(pIemCpu), GCPhysMem,
     5352                                            RT_BOOL(fAccess & IEM_ACCESS_TYPE_WRITE), pIemCpu->fBypassHandlers);
     5353            if (RT_FAILURE(rc2))
     5354                pIemCpu->fProblematicMemory = true;
     5355        }
    52715356        return VERR_PGM_PHYS_TLB_CATCH_ALL;
     5357    }
    52725358#endif
    52735359#ifdef IEM_LOG_MEMORY_WRITES
    … …  
    52915377    /*Log(("PGMPhysIemGCPhys2Ptr %Rrc pLock=%.*Rhxs\n", rc, sizeof(*pLock), pLock));*/
    52925378    AssertMsg(rc == VINF_SUCCESS || RT_FAILURE_NP(rc), ("%Rrc\n", rc));
     5379
     5380#ifdef IEM_VERIFICATION_MODE_FULL
     5381    if (RT_FAILURE(rc) && IEM_FULL_VERIFICATION_ENABLED(pIemCpu))
     5382        pIemCpu->fProblematicMemory = true;
     5383#endif
    52935384    return rc;
    52945385}
    … …  
    55085599    GCPhysSecond &= ~(RTGCPHYS)PAGE_OFFSET_MASK;
    55095600
     5601#ifdef IEM_VERIFICATION_MODE_FULL
     5602    /*
     5603     * Detect problematic memory when verifying so we can select
     5604     * the right execution engine. (TLB: Redo this.)
     5605     */
     5606    if (IEM_FULL_VERIFICATION_ENABLED(pIemCpu))
     5607    {
     5608        int rc2 = PGMPhysIemQueryAccess(IEMCPU_TO_VM(pIemCpu), GCPhysFirst,
     5609                                        RT_BOOL(fAccess & IEM_ACCESS_TYPE_WRITE), pIemCpu->fBypassHandlers);
     5610        if (RT_SUCCESS(rc2))
     5611            rc2 = PGMPhysIemQueryAccess(IEMCPU_TO_VM(pIemCpu), GCPhysSecond,
     5612                                        RT_BOOL(fAccess & IEM_ACCESS_TYPE_WRITE), pIemCpu->fBypassHandlers);
     5613        if (RT_FAILURE(rc2))
     5614            pIemCpu->fProblematicMemory = true;
     5615    }
     5616#endif
     5617
     5618
    55105619    /*
    55115620     * Read in the current memory content if it's a read, execute or partial
    … …  
    71067215    } while (0)
    71077216
    7108 #define IEM_MC_ADVANCE_RIP()                            iemRegUpdateRip(pIemCpu)
     7217#define IEM_MC_ADVANCE_RIP()                            iemRegUpdateRipAndClearRF(pIemCpu)
    71097218#define IEM_MC_REL_JMP_S8(a_i8)                         IEM_MC_RETURN_ON_FAILURE(iemRegRipRelativeJumpS8(pIemCpu, a_i8))
    71107219#define IEM_MC_REL_JMP_S16(a_i16)                       IEM_MC_RETURN_ON_FAILURE(iemRegRipRelativeJumpS16(pIemCpu, a_i16))
    … …  
    85448653    pIemCpu->fIgnoreRaxRdx = false;
    85458654    pIemCpu->fOverlappingMovs = false;
     8655    pIemCpu->fProblematicMemory = false;
    85468656    pIemCpu->fUndefinedEFlags = 0;
    85478657
    … …  
    88778987 * @param   pIemCpu         The IEM per CPU data.
    88788988 * @param   pEvtRec         The write record.
    8879  */
    8880 static void iemVerifyWriteRecord(PIEMCPU pIemCpu, PIEMVERIFYEVTREC pEvtRec)
     8989 * @param   fRem            Set if REM was doing the other executing. If clear
     8990 *                          it was HM.
     8991 */
     8992static void iemVerifyWriteRecord(PIEMCPU pIemCpu, PIEMVERIFYEVTREC pEvtRec, bool fRem)
    88818993{
    88828994    uint8_t abBuf[sizeof(pEvtRec->u.RamWrite.ab)]; RT_ZERO(abBuf);
    … …  
    89009012                if (pEvtRec->u.RamWrite.cb != 512)
    89019013                {
     9014                    const char *pszWho = fRem ? "rem" : HMR3IsVmxEnabled(IEMCPU_TO_VM(pIemCpu)->pUVM) ? "vmx" : "svm";
    89029015                    RTAssertMsg1(NULL, __LINE__, __FILE__, __PRETTY_FUNCTION__);
    89039016                    RTAssertMsg2Weak("Memory at %RGv differs\n", pEvtRec->u.RamWrite.GCPhys);
    8904                     RTAssertMsg2Add("REM: %.*Rhxs\n"
    8905                                     "IEM: %.*Rhxs\n",
    8906                                     pEvtRec->u.RamWrite.cb, abBuf,
     9017                    RTAssertMsg2Add("%s: %.*Rhxs\n"
     9018                                    "iem: %.*Rhxs\n",
     9019                                    pszWho, pEvtRec->u.RamWrite.cb, abBuf,
    89079020                                    pEvtRec->u.RamWrite.cb, pEvtRec->u.RamWrite.ab);
    89089021                    iemVerifyAssertAddRecordDump(pEvtRec);
    … …  
    89359048     * Execute the instruction in REM.
    89369049     */
     9050    bool   fRem  = false;
    89379051    PVM    pVM   = IEMCPU_TO_VM(pIemCpu);
    89389052    PVMCPU pVCpu = IEMCPU_TO_VMCPU(pIemCpu);
    89399053    VBOXSTRICTRC rc = VERR_EM_CANNOT_EXEC_GUEST;
    8940 #if 1
     9054#ifdef IEM_VERIFICATION_MODE_FULL_HM
    89419055    if (   HMIsEnabled(pVM)
    89429056        && pIemCpu->cIOReads == 0
    8943         && pIemCpu->cIOWrites == 0)
    8944     {
     9057        && pIemCpu->cIOWrites == 0
     9058        && !pIemCpu->fProblematicMemory)
     9059    {
     9060        unsigned iLoops = 0;
    89459061        do
     9062        {
    89469063            rc = EMR3HmSingleInstruction(pVM, pVCpu, EM_ONE_INS_FLAGS_RIP_CHANGE);
    8947         while (   rc == VINF_SUCCESS
    8948                || (   rc == VINF_EM_DBG_STEPPED
    8949                    && VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_INHIBIT_INTERRUPTS)
    8950                    && EMGetInhibitInterruptsPC(pVCpu) == pOrgCtx->rip) );
     9064            iLoops++;
     9065        } while (   rc == VINF_SUCCESS
     9066                 || (   rc == VINF_EM_DBG_STEPPED
     9067                     && VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_INHIBIT_INTERRUPTS)
     9068                     && EMGetInhibitInterruptsPC(pVCpu) == pOrgCtx->rip)
     9069                 || (   pOrgCtx->rip < pDebugCtx->rip
     9070                     && (pDebugCtx->rip - pOrgCtx->rip) < 15)
     9071                     && iLoops < 32);
    89519072    }
    89529073#endif
    … …  
    89639084        AssertRC(rc);
    89649085        EMRemUnlock(pVM);
     9086        fRem = true;
    89659087    }
    89669088
    … …  
    89729094    {
    89739095        //Log(("REM and IEM ends up with different registers!\n"));
     9096        const char *pszWho = fRem ? "rem" : HMR3IsVmxEnabled(pVM->pUVM) ? "vmx" : "svm";
    89749097
    89759098#  define CHECK_FIELD(a_Field) \
    8976         do \
     9099    do \
     9100    { \
     9101        if (pOrgCtx->a_Field != pDebugCtx->a_Field) \
    89779102        { \
    8978             if (pOrgCtx->a_Field != pDebugCtx->a_Field) \
     9103            switch (sizeof(pOrgCtx->a_Field)) \
    89799104            { \
    8980                 switch (sizeof(pOrgCtx->a_Field)) \
    8981                 { \
    8982                     case 1: RTAssertMsg2Weak("  %8s differs - iem=%02x - rem=%02x\n", #a_Field, pDebugCtx->a_Field, pOrgCtx->a_Field); break; \
    8983                     case 2: RTAssertMsg2Weak("  %8s differs - iem=%04x - rem=%04x\n", #a_Field, pDebugCtx->a_Field, pOrgCtx->a_Field); break; \
    8984                     case 4: RTAssertMsg2Weak("  %8s differs - iem=%08x - rem=%08x\n", #a_Field, pDebugCtx->a_Field, pOrgCtx->a_Field); break; \
    8985                     case 8: RTAssertMsg2Weak("  %8s differs - iem=%016llx - rem=%016llx\n", #a_Field, pDebugCtx->a_Field, pOrgCtx->a_Field); break; \
    8986                     default: RTAssertMsg2Weak("  %8s differs\n", #a_Field); break; \
    8987                 } \
    8988                 cDiffs++; \
     9105                case 1: RTAssertMsg2Weak("  %8s differs - iem=%02x - %s=%02x\n", #a_Field, pDebugCtx->a_Field, pszWho, pOrgCtx->a_Field); break; \
     9106                case 2: RTAssertMsg2Weak("  %8s differs - iem=%04x - %s=%04x\n", #a_Field, pDebugCtx->a_Field, pszWho, pOrgCtx->a_Field); break; \
     9107                case 4: RTAssertMsg2Weak("  %8s differs - iem=%08x - %s=%08x\n", #a_Field, pDebugCtx->a_Field, pszWho, pOrgCtx->a_Field); break; \
     9108                case 8: RTAssertMsg2Weak("  %8s differs - iem=%016llx - %s=%016llx\n", #a_Field, pDebugCtx->a_Field, pszWho, pOrgCtx->a_Field); break; \
     9109                default: RTAssertMsg2Weak("  %8s differs\n", #a_Field); break; \
    89899110            } \
    8990         } while (0)
     9111            cDiffs++; \
     9112        } \
     9113    } while (0)
    89919114
    89929115#  define CHECK_BIT_FIELD(a_Field) \
    8993         do \
     9116    do \
     9117    { \
     9118        if (pOrgCtx->a_Field != pDebugCtx->a_Field) \
    89949119        { \
    8995             if (pOrgCtx->a_Field != pDebugCtx->a_Field) \
    8996             { \
    8997                 RTAssertMsg2Weak("  %8s differs - iem=%02x - rem=%02x\n", #a_Field, pDebugCtx->a_Field, pOrgCtx->a_Field); \
    8998                 cDiffs++; \
    8999             } \
    9000         } while (0)
     9120            RTAssertMsg2Weak("  %8s differs - iem=%02x - %s=%02x\n", #a_Field, pDebugCtx->a_Field, pszWho, pOrgCtx->a_Field); \
     9121            cDiffs++; \
     9122        } \
     9123    } while (0)
    90019124
    90029125#  define CHECK_SEL(a_Sel) \
    9003         do \
    9004         { \
    9005             CHECK_FIELD(a_Sel.Sel); \
    9006             CHECK_FIELD(a_Sel.Attr.u); \
    9007             CHECK_FIELD(a_Sel.u64Base); \
    9008             CHECK_FIELD(a_Sel.u32Limit); \
    9009             CHECK_FIELD(a_Sel.fFlags); \
    9010         } while (0)
     9126    do \
     9127    { \
     9128        CHECK_FIELD(a_Sel.Sel); \
     9129        CHECK_FIELD(a_Sel.Attr.u); \
     9130        CHECK_FIELD(a_Sel.u64Base); \
     9131        CHECK_FIELD(a_Sel.u32Limit); \
     9132        CHECK_FIELD(a_Sel.fFlags); \
     9133    } while (0)
    90119134
    90129135#if 1 /* The recompiler doesn't update these the intel way. */
    9013         pOrgCtx->fpu.FOP        = pDebugCtx->fpu.FOP;
    9014         pOrgCtx->fpu.FPUIP      = pDebugCtx->fpu.FPUIP;
    9015         pOrgCtx->fpu.CS         = pDebugCtx->fpu.CS;
    9016         pOrgCtx->fpu.Rsrvd1     = pDebugCtx->fpu.Rsrvd1;
    9017         pOrgCtx->fpu.FPUDP      = pDebugCtx->fpu.FPUDP;
    9018         pOrgCtx->fpu.DS         = pDebugCtx->fpu.DS;
    9019         pOrgCtx->fpu.Rsrvd2     = pDebugCtx->fpu.Rsrvd2;
    9020         pOrgCtx->fpu.MXCSR_MASK = pDebugCtx->fpu.MXCSR_MASK; /* only for the time being - old snapshots here. */
    9021         if ((pOrgCtx->fpu.FSW & X86_FSW_TOP_MASK) == (pDebugCtx->fpu.FSW & X86_FSW_TOP_MASK))
    9022             pOrgCtx->fpu.FSW = pDebugCtx->fpu.FSW;
     9136        if (fRem)
     9137        {
     9138            pOrgCtx->fpu.FOP        = pDebugCtx->fpu.FOP;
     9139            pOrgCtx->fpu.FPUIP      = pDebugCtx->fpu.FPUIP;
     9140            pOrgCtx->fpu.CS         = pDebugCtx->fpu.CS;
     9141            pOrgCtx->fpu.Rsrvd1     = pDebugCtx->fpu.Rsrvd1;
     9142            pOrgCtx->fpu.FPUDP      = pDebugCtx->fpu.FPUDP;
     9143            pOrgCtx->fpu.DS         = pDebugCtx->fpu.DS;
     9144            pOrgCtx->fpu.Rsrvd2     = pDebugCtx->fpu.Rsrvd2;
     9145            //pOrgCtx->fpu.MXCSR_MASK = pDebugCtx->fpu.MXCSR_MASK;
     9146            if ((pOrgCtx->fpu.FSW & X86_FSW_TOP_MASK) == (pDebugCtx->fpu.FSW & X86_FSW_TOP_MASK))
     9147                pOrgCtx->fpu.FSW = pDebugCtx->fpu.FSW;
     9148        }
    90239149#endif
    90249150        if (memcmp(&pOrgCtx->fpu, &pDebugCtx->fpu, sizeof(pDebugCtx->fpu)))
    … …  
    90699195        if ((pOrgCtx->rflags.u & fFlagsMask) != (pDebugCtx->rflags.u & fFlagsMask))
    90709196        {
    9071             RTAssertMsg2Weak("  rflags differs - iem=%08llx rem=%08llx\n", pDebugCtx->rflags.u, pOrgCtx->rflags.u);
     9197            RTAssertMsg2Weak("  rflags differs - iem=%08llx %s=%08llx\n", pDebugCtx->rflags.u, pszWho, pOrgCtx->rflags.u);
    90729198            CHECK_BIT_FIELD(rflags.Bits.u1CF);
    90739199            CHECK_BIT_FIELD(rflags.Bits.u1Reserved0);
    … …  
    90859211            CHECK_BIT_FIELD(rflags.Bits.u1NT);
    90869212            CHECK_BIT_FIELD(rflags.Bits.u1Reserved3);
    9087             CHECK_BIT_FIELD(rflags.Bits.u1RF);
     9213            if (fRem)
     9214                CHECK_BIT_FIELD(rflags.Bits.u1RF);
    90889215            CHECK_BIT_FIELD(rflags.Bits.u1VM);
    90899216            CHECK_BIT_FIELD(rflags.Bits.u1AC);
    … …  
    91169243        CHECK_SEL(gs);
    91179244        CHECK_FIELD(cr0);
    9118         /* Klugde #1: REM fetches code and accross the page boundrary and faults on the next page, while we execute
     9245
     9246        /* Klugde #1: REM fetches code and across the page boundrary and faults on the next page, while we execute
    91199247           the faulting instruction first: 001b:77f61ff3 66 8b 42 02   mov ax, word [edx+002h] (NT4SP1) */
    91209248        /* Kludge #2: CR2 differs slightly on cross page boundrary faults, we report the last address of the access
    … …  
    91229250        if (pOrgCtx->cr2 != pDebugCtx->cr2)
    91239251        {
    9124             if (pIemCpu->uOldCs == 0x1b && pIemCpu->uOldRip == 0x77f61ff3)
     9252            if (pIemCpu->uOldCs == 0x1b && pIemCpu->uOldRip == 0x77f61ff3 && fRem)
    91259253            { /* ignore */ }
    91269254            else if (   (pOrgCtx->cr2 & ~(uint64_t)3) == (pDebugCtx->cr2 & ~(uint64_t)3)
    9127                      && (pOrgCtx->cr2 & PAGE_OFFSET_MASK) == 0)
     9255                     && (pOrgCtx->cr2 & PAGE_OFFSET_MASK) == 0
     9256                     && fRem)
    91289257            { /* ignore */ }
    91299258            else
    … …  
    91379266        CHECK_FIELD(dr[3]);
    91389267        CHECK_FIELD(dr[6]);
    9139         if ((pOrgCtx->dr[7] & ~X86_DR7_RA1_MASK) != (pDebugCtx->dr[7] & ~X86_DR7_RA1_MASK)) /* REM 'mov drX,greg' bug.*/
     9268        if (!fRem || (pOrgCtx->dr[7] & ~X86_DR7_RA1_MASK) != (pDebugCtx->dr[7] & ~X86_DR7_RA1_MASK)) /* REM 'mov drX,greg' bug.*/
    91409269            CHECK_FIELD(dr[7]);
    91419270        CHECK_FIELD(gdtr.cbGdt);
    … …  
    91889317            {
    91899318                if (pIemRec->enmEvent == IEMVERIFYEVENT_RAM_WRITE)
    9190                     iemVerifyWriteRecord(pIemCpu, pIemRec);
     9319                    iemVerifyWriteRecord(pIemCpu, pIemRec, fRem);
    91919320                pIemRec = pIemRec->pNext;
    91929321            }
    … …  
    92389367        {
    92399368            if (pIemRec->enmEvent == IEMVERIFYEVENT_RAM_WRITE)
    9240                 iemVerifyWriteRecord(pIemCpu, pIemRec);
     9369                iemVerifyWriteRecord(pIemCpu, pIemRec, fRem);
    92419370            pIemRec = pIemRec->pNext;
    92429371        }

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

    r47699 r47740  
    183183    pCtx->eflags.u &= ~(fToUpdate | fUndefined);
    184184    pCtx->eflags.u |= (fToUpdate | fUndefined) & fEFlags;
     185#ifdef IEM_VERIFICATION_MODE_FULL
     186    pIemCpu->fUndefinedEFlags |= fUndefined;
     187#endif
    185188}
    186189
    … …  
    190193 * visible parts, in protected mode.
    191194 *
     195 * @param   pIemCpu             The IEM state of the calling EMT.
    192196 * @param   pSReg               Pointer to the segment register.
    193197 * @param   uRpl                The RPL.
    194198 */
    195 static void iemHlpLoadNullDataSelectorProt(PCPUMSELREG pSReg, RTSEL uRpl)
     199static void iemHlpLoadNullDataSelectorProt(PIEMCPU pIemCpu, PCPUMSELREG pSReg, RTSEL uRpl)
    196200{
    197201    /** @todo Testcase: write a testcase checking what happends when loading a NULL
    … …  
    200204    pSReg->ValidSel = uRpl;
    201205    pSReg->fFlags   = CPUMSELREG_FLAGS_VALID;
    202     pSReg->u64Base  = 0;
    203     pSReg->u32Limit = 0;
    204     pSReg->Attr.u   = X86DESCATTR_UNUSABLE;
     206    if (IEM_IS_GUEST_CPU_INTEL(pIemCpu) && !IEM_FULL_VERIFICATION_REM_ENABLED(pIemCpu))
     207    {
     208        /* VT-x (Intel 3960x) observed doing something like this. */
     209        pSReg->Attr.u   = X86DESCATTR_UNUSABLE | X86DESCATTR_G | X86DESCATTR_D;
     210        pSReg->u32Limit = UINT32_MAX;
     211        pSReg->u64Base  = 0;
     212    }
     213    else
     214    {
     215        pSReg->Attr.u   = X86DESCATTR_UNUSABLE;
     216        pSReg->u32Limit = 0;
     217        pSReg->u64Base  = 0;
     218    }
    205219}
    206220
    … …  
    225239        &&    (pSReg->Attr.n.u4Type & (X86_SEL_TYPE_CODE | X86_SEL_TYPE_CONF))
    226240           !=                         (X86_SEL_TYPE_CODE | X86_SEL_TYPE_CONF)) /* not conforming code */
    227         iemHlpLoadNullDataSelectorProt(pSReg, 0);
     241        iemHlpLoadNullDataSelectorProt(pIemCpu, pSReg, 0);
    228242}
    229243
    … …  
    288302        {
    289303            pCtx->rsp = TmpRsp.u;
    290             iemRegAddToRip(pIemCpu, cbInstr);
     304            iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
    291305        }
    292306    }
    … …  
    309323            {
    310324                iemRegAddToRsp(pIemCpu, pCtx, 16);
    311                 iemRegAddToRip(pIemCpu, cbInstr);
     325                iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
    312326            }
    313327        }
    … …  
    369383#endif
    370384            pCtx->rsp = TmpRsp.u;
    371             iemRegAddToRip(pIemCpu, cbInstr);
     385            iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
    372386        }
    373387    }
    … …  
    390404            {
    391405                iemRegAddToRsp(pIemCpu, pCtx, 32);
    392                 iemRegAddToRip(pIemCpu, cbInstr);
     406                iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
    393407            }
    394408        }
    … …  
    440454        {
    441455            pCtx->rsp = TmpRsp.u;
    442             iemRegAddToRip(pIemCpu, cbInstr);
     456            iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
    443457        }
    444458    }
    … …  
    462476            {
    463477                iemRegSubFromRsp(pIemCpu, pCtx, 16);
    464                 iemRegAddToRip(pIemCpu, cbInstr);
     478                iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
    465479            }
    466480        }
    … …  
    512526        {
    513527            pCtx->rsp = TmpRsp.u;
    514             iemRegAddToRip(pIemCpu, cbInstr);
     528            iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
    515529        }
    516530    }
    … …  
    534548            {
    535549                iemRegSubFromRsp(pIemCpu, pCtx, 32);
    536                 iemRegAddToRip(pIemCpu, cbInstr);
     550                iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
    537551            }
    538552        }
    … …  
    591605        return rcStrict;
    592606
    593     iemRegAddToRip(pIemCpu, cbInstr);
     607    iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
    594608    return VINF_SUCCESS;
    595609}
    … …  
    730744    Assert(fEflNew & RT_BIT_32(1));
    731745    IEMMISC_SET_EFL(pIemCpu, pCtx, fEflNew);
    732     iemRegAddToRip(pIemCpu, cbInstr);
     746    iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
    733747
    734748    return VINF_SUCCESS;
    … …  
    755769
    756770    pCtx->rip = uNewPC;
     771    pCtx->eflags.Bits.u1RF = 0;
    757772    return VINF_SUCCESS;
    758 
    759773}
    760774
    … …  
    778792
    779793    pCtx->rip = uNewPC;
     794    pCtx->eflags.Bits.u1RF = 0;
    780795    return VINF_SUCCESS;
    781796}
    … …  
    801816
    802817    pCtx->rip = uNewPC;
     818    pCtx->eflags.Bits.u1RF = 0;
    803819    return VINF_SUCCESS;
    804 
    805820}
    806821
    … …  
    824839
    825840    pCtx->rip = uNewPC;
     841    pCtx->eflags.Bits.u1RF = 0;
    826842    return VINF_SUCCESS;
    827843}
    … …  
    847863
    848864    pCtx->rip = uNewPC;
     865    pCtx->eflags.Bits.u1RF = 0;
    849866    return VINF_SUCCESS;
    850 
    851867}
    852868
    … …  
    870886
    871887    pCtx->rip = uNewPC;
     888    pCtx->eflags.Bits.u1RF = 0;
    872889    return VINF_SUCCESS;
    873890}
    … …  
    885902IEM_CIMPL_DEF_4(iemCImpl_BranchTaskSegment, uint16_t, uSel, IEMBRANCH, enmBranch, IEMMODE, enmEffOpSize, PIEMSELDESC, pDesc)
    886903{
    887     /* Call various functions to do the work. */
     904    /* Call various functions to do the work.  Clear RF? */
    888905    IEM_RETURN_ASPECT_NOT_IMPLEMENTED();
    889906}
    … …  
    901918IEM_CIMPL_DEF_4(iemCImpl_BranchTaskGate, uint16_t, uSel, IEMBRANCH, enmBranch, IEMMODE, enmEffOpSize, PIEMSELDESC, pDesc)
    902919{
    903     /* Call various functions to do the work. */
     920    /* Call various functions to do the work. Don't clear RF */
    904921    IEM_RETURN_ASPECT_NOT_IMPLEMENTED();
    905922}
    … …  
    917934IEM_CIMPL_DEF_4(iemCImpl_BranchCallGate, uint16_t, uSel, IEMBRANCH, enmBranch, IEMMODE, enmEffOpSize, PIEMSELDESC, pDesc)
    918935{
    919     /* Call various functions to do the work. */
     936    /* Call various functions to do the work.  Clear RF. */
    920937    IEM_RETURN_ASPECT_NOT_IMPLEMENTED();
    921938}
    … …  
    10171034        pCtx->cs.fFlags     = CPUMSELREG_FLAGS_VALID;
    10181035        pCtx->cs.u64Base    = (uint32_t)uSel << 4;
     1036        pCtx->eflags.Bits.u1RF = 0;
    10191037        return VINF_SUCCESS;
    10201038    }
    … …  
    11311149    pCtx->cs.u32Limit    = cbLimit;
    11321150    pCtx->cs.u64Base     = u64Base;
     1151    pCtx->eflags.Bits.u1RF = 0;
    11331152    /** @todo check if the hidden bits are loaded correctly for 64-bit
    11341153     *        mode.  */
    … …  
    11941213        pCtx->cs.fFlags     = CPUMSELREG_FLAGS_VALID;
    11951214        pCtx->cs.u64Base    = (uint32_t)uSel << 4;
     1215        pCtx->eflags.Bits.u1RF = 0;
    11961216        return VINF_SUCCESS;
    11971217    }
    … …  
    13461366    pCtx->cs.u32Limit    = cbLimit;
    13471367    pCtx->cs.u64Base     = u64Base;
     1368    pCtx->eflags.Bits.u1RF = 0;
    13481369    /** @todo check if the hidden bits are loaded correctly for 64-bit
    13491370     *        mode.  */
    … …  
    14171438        pCtx->cs.fFlags     = CPUMSELREG_FLAGS_VALID;
    14181439        pCtx->cs.u64Base    = (uint32_t)uNewCs << 4;
     1440        pCtx->eflags.Bits.u1RF = 0;
    14191441        /** @todo do we load attribs and limit as well? */
    14201442        if (cbPop)
    … …  
    16691691        if (cbPop)
    16701692            iemRegAddToRsp(pIemCpu, pCtx, cbPop);
     1693        pCtx->eflags.Bits.u1RF = 0;
    16711694
    16721695        /* Done! */
    … …  
    17331756        if (cbPop)
    17341757            iemRegAddToRsp(pIemCpu, pCtx, cbPop);
     1758        pCtx->eflags.Bits.u1RF = 0;
    17351759    }
    17361760    return VINF_SUCCESS;
    … …  
    18011825    if (cbPop)
    18021826        iemRegAddToRsp(pIemCpu, pCtx, cbPop);
     1827    pCtx->eflags.Bits.u1RF = 0;
    18031828
    18041829    return VINF_SUCCESS;
    … …  
    19151940    pCtx->rbp = NewRbp.u;
    19161941    pCtx->rsp = NewRsp.u;
    1917     iemRegAddToRip(pIemCpu, cbInstr);
     1942    iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
    19181943
    19191944    return VINF_SUCCESS;
    … …  
    19721997    pCtx->rbp = NewRbp.u;
    19731998    pCtx->rsp = NewRsp.u;
    1974     iemRegAddToRip(pIemCpu, cbInstr);
     1999    iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
    19752000
    19762001    return VINF_SUCCESS;
    … …  
    30823107#endif
    30833108        CPUMSetChangedFlags(IEMCPU_TO_VMCPU(pIemCpu), CPUM_CHANGED_HIDDEN_SEL_REGS);
    3084         iemRegAddToRip(pIemCpu, cbInstr);
     3109        iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
    30853110        return VINF_SUCCESS;
    30863111    }
    … …  
    31123137
    31133138        *pSel = uSel;   /* Not RPL, remember :-) */
    3114         iemHlpLoadNullDataSelectorProt(pHid, uSel);
     3139        iemHlpLoadNullDataSelectorProt(pIemCpu, pHid, uSel);
    31153140        if (iSegReg == X86_SREG_SS)
    31163141            pHid->Attr.u |= pIemCpu->uCpl << X86DESCATTR_DPL_SHIFT;
    … …  
    31193144        CPUMSetChangedFlags(IEMCPU_TO_VMCPU(pIemCpu), CPUM_CHANGED_HIDDEN_SEL_REGS);
    31203145
    3121         iemRegAddToRip(pIemCpu, cbInstr);
     3146        iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
    31223147        return VINF_SUCCESS;
    31233148    }
    … …  
    32303255
    32313256    CPUMSetChangedFlags(IEMCPU_TO_VMCPU(pIemCpu), CPUM_CHANGED_HIDDEN_SEL_REGS);
    3232     iemRegAddToRip(pIemCpu, cbInstr);
     3257    iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
    32333258    return VINF_SUCCESS;
    32343259}
    … …  
    34593484    pIemCpu->CTX_SUFF(pCtx)->eflags.Bits.u1ZF = fAccessible;
    34603485
    3461     iemRegAddToRip(pIemCpu, cbInstr);
     3486    iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
    34623487    return VINF_SUCCESS;
    34633488}
    … …  
    35653590    /* commit flags value and advance rip. */
    35663591    pIemCpu->CTX_SUFF(pCtx)->eflags.Bits.u1ZF = fDescOk;
    3567     iemRegAddToRip(pIemCpu, cbInstr);
     3592    iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
    35683593
    35693594    return VINF_SUCCESS;
    … …  
    36193644        }
    36203645        if (rcStrict == VINF_SUCCESS)
    3621             iemRegAddToRip(pIemCpu, cbInstr);
     3646            iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
    36223647    }
    36233648    return rcStrict;
    … …  
    36423667    VBOXSTRICTRC rcStrict = iemMemStoreDataXdtr(pIemCpu, pCtx->gdtr.cbGdt, pCtx->gdtr.pGdt, iEffSeg, GCPtrEffDst, enmEffOpSize);
    36433668    if (rcStrict == VINF_SUCCESS)
    3644         iemRegAddToRip(pIemCpu, cbInstr);
     3669        iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
    36453670    return rcStrict;
    36463671}
    … …  
    36763701            pCtx->idtr.pIdt  = GCPtrBase;
    36773702        }
    3678         iemRegAddToRip(pIemCpu, cbInstr);
     3703        iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
    36793704    }
    36803705    return rcStrict;
    … …  
    36993724    VBOXSTRICTRC rcStrict = iemMemStoreDataXdtr(pIemCpu, pCtx->idtr.cbIdt, pCtx->idtr.pIdt, iEffSeg, GCPtrEffDst, enmEffOpSize);
    37003725    if (rcStrict == VINF_SUCCESS)
    3701         iemRegAddToRip(pIemCpu, cbInstr);
     3726        iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
    37023727    return rcStrict;
    37033728}
    … …  
    37443769        pCtx->ldtr.ValidSel = uNewLdt;
    37453770        pCtx->ldtr.fFlags   = CPUMSELREG_FLAGS_VALID;
    3746         pCtx->ldtr.Attr.u   = X86DESCATTR_UNUSABLE;
    3747         if (!IEM_IS_GUEST_CPU_AMD(pIemCpu) || !IEM_VERIFICATION_ENABLED(pIemCpu)) /* See bs-cpu-hidden-regs-1 on AMD. */
    3748         {
     3771        if (!IEM_FULL_VERIFICATION_REM_ENABLED(pIemCpu))
     3772        {
     3773            pCtx->ldtr.Attr.u = X86DESCATTR_UNUSABLE;
     3774            pCtx->ldtr.u64Base = pCtx->ldtr.u32Limit = 0; /* For verfication against REM. */
     3775        }
     3776        else if (IEM_IS_GUEST_CPU_AMD(pIemCpu))
     3777        {
     3778            /* AMD-V seems to leave the base and limit alone. */
     3779            pCtx->ldtr.Attr.u = X86DESCATTR_UNUSABLE;
     3780        }
     3781        else if (!IEM_FULL_VERIFICATION_REM_ENABLED(pIemCpu))
     3782        {
     3783            /* VT-x (Intel 3960x) seems to be doing the following. */
     3784            pCtx->ldtr.Attr.u   = X86DESCATTR_UNUSABLE | X86DESCATTR_G | X86DESCATTR_D;
    37493785            pCtx->ldtr.u64Base  = 0;
    3750             pCtx->ldtr.u32Limit = 0;
    3751         }
    3752 
    3753         iemRegAddToRip(pIemCpu, cbInstr);
     3786            pCtx->ldtr.u32Limit = UINT32_MAX;
     3787        }
     3788
     3789        iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
    37543790        return VINF_SUCCESS;
    37553791    }
    … …  
    38143850    pCtx->ldtr.u64Base  = u64Base;
    38153851
    3816     iemRegAddToRip(pIemCpu, cbInstr);
     3852    iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
    38173853    return VINF_SUCCESS;
    38183854}
    … …  
    39353971    pCtx->tr.u64Base  = u64Base;
    39363972
    3937     iemRegAddToRip(pIemCpu, cbInstr);
     3973    iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
    39383974    return VINF_SUCCESS;
    39393975}
    … …  
    39804016        *(uint64_t *)iemGRegRef(pIemCpu, iGReg) = (uint32_t)crX;
    39814017
    3982     iemRegAddToRip(pIemCpu, cbInstr);
     4018    iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
    39834019    return VINF_SUCCESS;
    39844020}
    … …  
    42784314        if (rcStrict != VINF_SUCCESS)
    42794315            rcStrict = iemSetPassUpStatus(pIemCpu, rcStrict);
    4280         iemRegAddToRip(pIemCpu, cbInstr);
     4316        iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
    42814317    }
    42824318
    … …  
    44094445        *(uint64_t *)iemGRegRef(pIemCpu, iGReg) = (uint32_t)drX;
    44104446
    4411     iemRegAddToRip(pIemCpu, cbInstr);
     4447    iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
    44124448    return VINF_SUCCESS;
    44134449}
    … …  
    45054541        pCtx->dr[iDrReg] = uNewDrX;
    45064542
    4507     iemRegAddToRip(pIemCpu, cbInstr);
     4543    iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
    45084544    return VINF_SUCCESS;
    45094545}
    … …  
    45244560
    45254561    int rc = PGMInvalidatePage(IEMCPU_TO_VMCPU(pIemCpu), GCPtrPage);
    4526     iemRegAddToRip(pIemCpu, cbInstr);
     4562    iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
    45274563
    45284564    if (rc == VINF_SUCCESS)
    … …  
    45674603#endif
    45684604
    4569     iemRegAddToRip(pIemCpu, cbInstr);
     4605    iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
    45704606    return VINF_SUCCESS;
    45714607}
    … …  
    46024638    pCtx->rdx = uValue.s.Hi;
    46034639
    4604     iemRegAddToRip(pIemCpu, cbInstr);
     4640    iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
    46054641    return VINF_SUCCESS;
    46064642}
    … …  
    46474683    }
    46484684
    4649     iemRegAddToRip(pIemCpu, cbInstr);
     4685    iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
    46504686    return VINF_SUCCESS;
    46514687}
    … …  
    46864722            default: AssertFailedReturn(VERR_INTERNAL_ERROR_3);
    46874723        }
    4688         iemRegAddToRip(pIemCpu, cbInstr);
     4724        iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
    46894725        pIemCpu->cPotentialExits++;
    46904726        if (rcStrict != VINF_SUCCESS)
    … …  
    47564792    if (IOM_SUCCESS(rcStrict))
    47574793    {
    4758         iemRegAddToRip(pIemCpu, cbInstr);
     4794        iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
    47594795        pIemCpu->cPotentialExits++;
    47604796        if (rcStrict != VINF_SUCCESS)
    … …  
    48284864    /* Commit. */
    48294865    IEMMISC_SET_EFL(pIemCpu, pCtx, fEfl);
    4830     iemRegAddToRip(pIemCpu, cbInstr);
     4866    iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
    48314867    Log2(("CLI: %#x -> %#x\n", fEflOld, fEfl)); NOREF(fEflOld);
    48324868    return VINF_SUCCESS;
    … …  
    48744910    /* Commit. */
    48754911    IEMMISC_SET_EFL(pIemCpu, pCtx, fEfl);
    4876     iemRegAddToRip(pIemCpu, cbInstr);
    4877     if ((!(fEflOld & X86_EFL_IF) && (fEfl & X86_EFL_IF)) || IEM_VERIFICATION_ENABLED(pIemCpu))
     4912    iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
     4913    if ((!(fEflOld & X86_EFL_IF) && (fEfl & X86_EFL_IF)) || IEM_FULL_VERIFICATION_REM_ENABLED(pIemCpu))
    48784914        EMSetInhibitInterruptsPC(IEMCPU_TO_VMCPU(pIemCpu), pCtx->rip);
    48794915    Log2(("STI: %#x -> %#x\n", fEflOld, fEfl));
    … …  
    48894925    if (pIemCpu->uCpl != 0)
    48904926        return iemRaiseGeneralProtectionFault0(pIemCpu);
    4891     iemRegAddToRip(pIemCpu, cbInstr);
     4927    iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
    48924928    return VINF_EM_HALT;
    48934929}
    … …  
    49434979    Assert(rcStrict == VINF_SUCCESS);
    49444980
    4945     iemRegAddToRip(pIemCpu, cbInstr);
     4981    iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
    49464982    return rcStrict;
    49474983}
    … …  
    49995035    VBOXSTRICTRC rcStrict = EMMonitorWaitPerform(IEMCPU_TO_VMCPU(pIemCpu), uEax, uEcx);
    50005036
    5001     iemRegAddToRip(pIemCpu, cbInstr);
     5037    iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
    50025038    return rcStrict;
    50035039}
    … …  
    50285064    pCtx->gs.u64Base = uOtherGsBase;
    50295065
    5030     iemRegAddToRip(pIemCpu, cbInstr);
     5066    iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
    50315067    return VINF_SUCCESS;
    50325068}
    … …  
    50465082    pCtx->rdx &= UINT32_C(0xffffffff);
    50475083
    5048     iemRegAddToRip(pIemCpu, cbInstr);
     5084    iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
    50495085    return VINF_SUCCESS;
    50505086}
    … …  
    50675103                              X86_EFL_OF | X86_EFL_AF | X86_EFL_CF);
    50685104
    5069     iemRegAddToRip(pIemCpu, cbInstr);
     5105    iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
    50705106    return VINF_SUCCESS;
    50715107}
    … …  
    50905126                              X86_EFL_OF | X86_EFL_AF | X86_EFL_CF);
    50915127
    5092     iemRegAddToRip(pIemCpu, cbInstr);
     5128    iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
    50935129    return VINF_SUCCESS;
    50945130}
    … …  
    51835219
    51845220    iemHlpUsedFpu(pIemCpu);
    5185     iemRegAddToRip(pIemCpu, cbInstr);
     5221    iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
    51865222    return VINF_SUCCESS;
    51875223}
    … …  
    52805316        return rcStrict;
    52815317
    5282     iemRegAddToRip(pIemCpu, cbInstr);
     5318    iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
    52835319    return VINF_SUCCESS;
    52845320}
    … …  
    53935429
    53945430    iemHlpUsedFpu(pIemCpu);
    5395     iemRegAddToRip(pIemCpu, cbInstr);
     5431    iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
    53965432    return VINF_SUCCESS;
    53975433}
    … …  
    55495585
    55505586    /* Note: C0, C1, C2 and C3 are documented as undefined, we leave them untouched! */
    5551     iemRegAddToRip(pIemCpu, cbInstr);
     5587    iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
    55525588    return VINF_SUCCESS;
    55535589}
    … …  
    55975633
    55985634    iemHlpUsedFpu(pIemCpu);
    5599     iemRegAddToRip(pIemCpu, cbInstr);
     5635    iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
    56005636    return VINF_SUCCESS;
    56015637}
    … …  
    56265662
    56275663    iemHlpUsedFpu(pIemCpu);
    5628     iemRegAddToRip(pIemCpu, cbInstr);
     5664    iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
    56295665    return VINF_SUCCESS;
    56305666}
    … …  
    56615697
    56625698    iemHlpUsedFpu(pIemCpu);
    5663     iemRegAddToRip(pIemCpu, cbInstr);
     5699    iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
    56645700    return VINF_SUCCESS;
    56655701}
    … …  
    56855721    /* Note: C0, C1, C2 and C3 are documented as undefined, we leave them untouched! */
    56865722    iemHlpUsedFpu(pIemCpu);
    5687     iemRegAddToRip(pIemCpu, cbInstr);
     5723    iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
    56885724    return VINF_SUCCESS;
    56895725}
    … …  
    57345770    iemFpuUpdateOpcodeAndIpWorker(pIemCpu, pCtx);
    57355771    iemHlpUsedFpu(pIemCpu);
    5736     iemRegAddToRip(pIemCpu, cbInstr);
     5772    iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
    57375773    return VINF_SUCCESS;
    57385774}
    … …  
    58035839    iemFpuUpdateOpcodeAndIpWorker(pIemCpu, pCtx);
    58045840    iemHlpUsedFpu(pIemCpu);
    5805     iemRegAddToRip(pIemCpu, cbInstr);
     5841    iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
    58065842    return VINF_SUCCESS;
    58075843}

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

    r47707 r47740  
    7676    if (uCounterReg == 0)
    7777    {
    78         iemRegAddToRip(pIemCpu, cbInstr);
     78        iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
    7979        return VINF_SUCCESS;
    8080    }
    … …  
    214214     * Done.
    215215     */
    216     iemRegAddToRip(pIemCpu, cbInstr);
     216    iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
    217217    return VINF_SUCCESS;
    218218}
    … …  
    232232    if (uCounterReg == 0)
    233233    {
    234         iemRegAddToRip(pIemCpu, cbInstr);
     234        iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
    235235        return VINF_SUCCESS;
    236236    }
    … …  
    370370     * Done.
    371371     */
    372     iemRegAddToRip(pIemCpu, cbInstr);
     372    iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
    373373    return VINF_SUCCESS;
    374374}
    … …  
    388388    if (uCounterReg == 0)
    389389    {
    390         iemRegAddToRip(pIemCpu, cbInstr);
     390        iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
    391391        return VINF_SUCCESS;
    392392    }
    … …  
    492492     * Done.
    493493     */
    494     iemRegAddToRip(pIemCpu, cbInstr);
     494    iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
    495495    return VINF_SUCCESS;
    496496}
    … …  
    510510    if (uCounterReg == 0)
    511511    {
    512         iemRegAddToRip(pIemCpu, cbInstr);
     512        iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
    513513        return VINF_SUCCESS;
    514514    }
    … …  
    613613     * Done.
    614614     */
    615     iemRegAddToRip(pIemCpu, cbInstr);
     615    iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
    616616    return VINF_SUCCESS;
    617617}
    … …  
    633633    if (uCounterReg == 0)
    634634    {
    635         iemRegAddToRip(pIemCpu, cbInstr);
     635        iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
    636636        return VINF_SUCCESS;
    637637    }
    … …  
    776776     * Done.
    777777     */
    778     iemRegAddToRip(pIemCpu, cbInstr);
     778    iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
    779779    return VINF_SUCCESS;
    780780}
    … …  
    794794    if (uCounterReg == 0)
    795795    {
    796         iemRegAddToRip(pIemCpu, cbInstr);
     796        iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
    797797        return VINF_SUCCESS;
    798798    }
    … …  
    896896     * Done.
    897897     */
    898     iemRegAddToRip(pIemCpu, cbInstr);
     898    iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
    899899    return VINF_SUCCESS;
    900900}
    … …  
    914914    if (uCounterReg == 0)
    915915    {
    916         iemRegAddToRip(pIemCpu, cbInstr);
     916        iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
    917917        return VINF_SUCCESS;
    918918    }
    … …  
    10081008     * Done.
    10091009     */
    1010     iemRegAddToRip(pIemCpu, cbInstr);
     1010    iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
    10111011    return VINF_SUCCESS;
    10121012}
    … …  
    10641064            else
    10651065                pCtx->ADDR_rDI -= OP_SIZE / 8;
    1066             iemRegAddToRip(pIemCpu, cbInstr);
     1066            iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
    10671067        }
    10681068        /* iemMemMap already check permissions, so this may only be real errors
    … …  
    11011101    if (uCounterReg == 0)
    11021102    {
    1103         iemRegAddToRip(pIemCpu, cbInstr);
     1103        iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
    11041104        return VINF_SUCCESS;
    11051105    }
    … …  
    11811181                            rcStrict = iemSetPassUpStatus(pIemCpu, rcStrict);
    11821182                            if (uCounterReg == 0)
    1183                                 iemRegAddToRip(pIemCpu, cbInstr);
     1183                                iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
    11841184                        }
    11851185                        iemMemPageUnmap(pIemCpu, GCPhysMem, IEM_ACCESS_DATA_W, puMem, &PgLockMem);
    … …  
    12361236            {
    12371237                if (uCounterReg == 0)
    1238                     iemRegAddToRip(pIemCpu, cbInstr);
     1238                    iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
    12391239                rcStrict = iemSetPassUpStatus(pIemCpu, rcStrict);
    12401240                return rcStrict;
    … …  
    12461246     * Done.
    12471247     */
    1248     iemRegAddToRip(pIemCpu, cbInstr);
     1248    iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
    12491249    return VINF_SUCCESS;
    12501250}
    … …  
    12861286            else
    12871287                pCtx->ADDR_rSI -= OP_SIZE / 8;
    1288             iemRegAddToRip(pIemCpu, cbInstr);
     1288            iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
    12891289            if (rcStrict != VINF_SUCCESS)
    12901290                rcStrict = iemSetPassUpStatus(pIemCpu, rcStrict);
    … …  
    13191319    if (uCounterReg == 0)
    13201320    {
    1321         iemRegAddToRip(pIemCpu, cbInstr);
     1321        iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
    13221322        return VINF_SUCCESS;
    13231323    }
    … …  
    13901390                            rcStrict = iemSetPassUpStatus(pIemCpu, rcStrict);
    13911391                            if (uCounterReg == 0)
    1392                                 iemRegAddToRip(pIemCpu, cbInstr);
     1392                                iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
    13931393                        }
    13941394                        iemMemPageUnmap(pIemCpu, GCPhysMem, IEM_ACCESS_DATA_R, puMem, &PgLockMem);
    … …  
    14411441                {
    14421442                    if (uCounterReg == 0)
    1443                         iemRegAddToRip(pIemCpu, cbInstr);
     1443                        iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
    14441444                    rcStrict = iemSetPassUpStatus(pIemCpu, rcStrict);
    14451445                }
    … …  
    14521452     * Done.
    14531453     */
    1454     iemRegAddToRip(pIemCpu, cbInstr);
     1454    iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
    14551455    return VINF_SUCCESS;
    14561456}

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

    r47669 r47740  
    1019010190    {
    1019110191        pCtx->rsp = TmpRsp.u;
    10192         iemRegUpdateRip(pIemCpu);
     10192        iemRegUpdateRipAndClearRF(pIemCpu);
    1019310193    }
    1019410194    return rcStrict;

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

    r47568 r47740  
    261261     *  was executed, causing the memory write records to be incorrrect. */
    262262    bool                    fOverlappingMovs;
     263    /** Set if there are problematic memory accesses (MMIO, write monitored, ++). */
     264    bool                    fProblematicMemory;
    263265    /** This is used to communicate a CPL changed caused by IEMInjectTrap that
    264266     * CPUM doesn't yet reflect. */
    265267    uint8_t                 uInjectCpl;
    266     bool                    afAlignment2[4];
     268    bool                    afAlignment2[3];
    267269    /** Mask of undefined eflags.
    268270     * The verifier will any difference in these flags. */
    … …  
    534536 * Tests if full verification mode is enabled.
    535537 *
    536  * This expands to @c false when IEM_VERIFICATION_MODE is not defined and
     538 * This expands to @c false when IEM_VERIFICATION_MODE_FULL is not defined and
    537539 * should therefore cause the compiler to eliminate the verification branch
    538540 * of an if statement.  */
    … …  
    541543#else
    542544# define IEM_FULL_VERIFICATION_ENABLED(a_pIemCpu) (false)
     545#endif
     546
     547/**
     548 * Tests if full verification mode is enabled again REM.
     549 *
     550 * This expands to @c false when IEM_VERIFICATION_MODE_FULL is not defined and
     551 * should therefore cause the compiler to eliminate the verification branch
     552 * of an if statement.  */
     553#ifdef IEM_VERIFICATION_MODE_FULL
     554# ifdef IEM_VERIFICATION_MODE_FULL_HM
     555#  define IEM_FULL_VERIFICATION_REM_ENABLED(a_pIemCpu) (!(a_pIemCpu)->fNoRem && !HMIsEnabled(IEMCPU_TO_VM(a_pIemCpu)))
     556# else
     557#  define IEM_FULL_VERIFICATION_REM_ENABLED(a_pIemCpu) (!(a_pIemCpu)->fNoRem)
     558# endif
     559#else
     560# define IEM_FULL_VERIFICATION_REM_ENABLED(a_pIemCpu) (false)
    543561#endif
    544562
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