VirtualBox

Changeset 72634 in vbox for trunk


Ignore:
Timestamp:
Jun 20, 2018 4:08:42 PM (7 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
123137
Message:

EM[R3]: Use pVCpu->cpum.GstCtx and stop keeping and passing pCtx around.

Location:
trunk
Files:
12 edited

Legend:

Unmodified
Added
Removed

  • trunk/include/VBox/vmm/nem.h

    r72555 r72634  
    5555VMMR3DECL(const char *) NEMR3GetExitName(uint32_t uExit);
    5656VMMR3_INT_DECL(VBOXSTRICTRC) NEMR3RunGC(PVM pVM, PVMCPU pVCpu);
    57 VMMR3_INT_DECL(bool) NEMR3CanExecuteGuest(PVM pVM, PVMCPU pVCpu, PCPUMCTX pCtx);
     57VMMR3_INT_DECL(bool) NEMR3CanExecuteGuest(PVM pVM, PVMCPU pVCpu);
    5858VMMR3_INT_DECL(bool) NEMR3SetSingleInstruction(PVM pVM, PVMCPU pVCpu, bool fEnable);
    5959VMMR3_INT_DECL(void) NEMR3NotifyFF(PVM pVM, PVMCPU pVCpu, uint32_t fFlags);

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

    r72522 r72634  
    63336333}
    63346334
     6335
    63356336/**
    63366337 * Fast way for HM to access the IA32_SPEC_CTRL register.

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

    r72606 r72634  
    194194        pVCpu->em.s.idxContinueExitRec  = UINT16_MAX;
    195195
    196         pVCpu->em.s.pCtx                = CPUMQueryGuestCtxPtr(pVCpu);
    197196#ifdef VBOX_WITH_RAW_MODE
    198197        if (VM_IS_RAW_MODE_ENABLED(pVM))
    … …  
    12351234{
    12361235#ifdef LOG_ENABLED
    1237     PCPUMCTX pCtx = pVCpu->em.s.pCtx;
    12381236    uint32_t cpl = CPUMGetGuestCPL(pVCpu);
    12391237
    1240     if (pCtx->eflags.Bits.u1VM)
    1241         Log(("EMV86: %04X:%08X IF=%d\n", pCtx->cs.Sel, pCtx->eip, pCtx->eflags.Bits.u1IF));
     1238    if (pVCpu->cpum.GstCtx.eflags.Bits.u1VM)
     1239        Log(("EMV86: %04X:%08X IF=%d\n", pVCpu->cpum.GstCtx.cs.Sel, pVCpu->cpum.GstCtx.eip, pVCpu->cpum.GstCtx.eflags.Bits.u1IF));
    12421240    else
    1243         Log(("EMR%d: %04X:%08X ESP=%08X IF=%d CR0=%x eflags=%x\n", cpl, pCtx->cs.Sel, pCtx->eip, pCtx->esp, pCtx->eflags.Bits.u1IF, (uint32_t)pCtx->cr0, pCtx->eflags.u));
     1241        Log(("EMR%d: %04X:%08X ESP=%08X IF=%d CR0=%x eflags=%x\n", cpl, pVCpu->cpum.GstCtx.cs.Sel, pVCpu->cpum.GstCtx.eip, pVCpu->cpum.GstCtx.esp, pVCpu->cpum.GstCtx.eflags.Bits.u1IF, (uint32_t)pVCpu->cpum.GstCtx.cr0, pVCpu->cpum.GstCtx.eflags.u));
    12441242#endif
    12451243    STAM_REL_PROFILE_ADV_START(&pVCpu->em.s.StatREMTotal, a);
    … …  
    13541352                    || rc == VERR_IEM_INSTR_NOT_IMPLEMENTED)
    13551353                {
    1356                     EMSTATE enmNewState = emR3Reschedule(pVM, pVCpu, pVCpu->em.s.pCtx);
     1354                    EMSTATE enmNewState = emR3Reschedule(pVM, pVCpu);
    13571355                    if (enmNewState != EMSTATE_REM && enmNewState != EMSTATE_IEM_THEN_REM)
    13581356                    {
    … …  
    14111409        if (!(++cLoops & 7))
    14121410        {
    1413             EMSTATE enmCheck = emR3Reschedule(pVM, pVCpu, pVCpu->em.s.pCtx);
     1411            EMSTATE enmCheck = emR3Reschedule(pVM, pVCpu);
    14141412            if (   enmCheck != EMSTATE_REM
    14151413                && enmCheck != EMSTATE_IEM_THEN_REM)
    … …  
    14481446        DBGFR3_DISAS_INSTR_CUR_LOG(pVCpu, "RSS");
    14491447        emR3RemStep(pVM, pVCpu);
    1450         if (emR3Reschedule(pVM, pVCpu, pVCpu->em.s.pCtx) != EMSTATE_REM)
     1448        if (emR3Reschedule(pVM, pVCpu) != EMSTATE_REM)
    14511449            break;
    14521450    }
    … …  
    14951493        }
    14961494
    1497         EMSTATE enmNewState = emR3Reschedule(pVM, pVCpu, pVCpu->em.s.pCtx);
     1495        EMSTATE enmNewState = emR3Reschedule(pVM, pVCpu);
    14981496        if (enmNewState != EMSTATE_REM && enmNewState != EMSTATE_IEM_THEN_REM)
    14991497        {
    … …  
    15281526 * @param   pVM     The cross context VM structure.
    15291527 * @param   pVCpu   The cross context virtual CPU structure.
    1530  * @param   pCtx    Pointer to the guest CPU context.
    15311528 */
    1532 EMSTATE emR3Reschedule(PVM pVM, PVMCPU pVCpu, PCPUMCTX pCtx)
     1529EMSTATE emR3Reschedule(PVM pVM, PVMCPU pVCpu)
    15331530{
    15341531    /*
    … …  
    15541551    /* !!! THIS MUST BE IN SYNC WITH remR3CanExecuteRaw !!! */
    15551552
    1556     X86EFLAGS EFlags = pCtx->eflags;
     1553    X86EFLAGS EFlags = pVCpu->cpum.GstCtx.eflags;
    15571554    if (!VM_IS_RAW_MODE_ENABLED(pVM))
    15581555    {
    … …  
    15611558            if (VM_IS_HM_ENABLED(pVM))
    15621559            {
    1563                 if (HMR3CanExecuteGuest(pVM, pCtx))
     1560                if (HMR3CanExecuteGuest(pVM, &pVCpu->cpum.GstCtx))
    15641561                    return EMSTATE_HM;
    15651562            }
    1566             else if (NEMR3CanExecuteGuest(pVM, pVCpu, pCtx))
     1563            else if (NEMR3CanExecuteGuest(pVM, pVCpu))
    15671564                return EMSTATE_NEM;
    15681565
    … …  
    15971594
    15981595    /** @todo check up the X86_CR0_AM flag in respect to raw mode!!! We're probably not emulating it right! */
    1599     uint32_t u32CR0 = pCtx->cr0;
     1596    uint32_t u32CR0 = pVCpu->cpum.GstCtx.cr0;
    16001597    if ((u32CR0 & (X86_CR0_PG | X86_CR0_PE)) != (X86_CR0_PG | X86_CR0_PE))
    16011598    {
    … …  
    16041601    }
    16051602
    1606     if (pCtx->cr4 & X86_CR4_PAE)
     1603    if (pVCpu->cpum.GstCtx.cr4 & X86_CR4_PAE)
    16071604    {
    16081605        uint32_t u32Dummy, u32Features;
    … …  
    16131610    }
    16141611
    1615     unsigned uSS = pCtx->ss.Sel;
    1616     if (    pCtx->eflags.Bits.u1VM
     1612    unsigned uSS = pVCpu->cpum.GstCtx.ss.Sel;
     1613    if (    pVCpu->cpum.GstCtx.eflags.Bits.u1VM
    16171614        ||  (uSS & X86_SEL_RPL) == 3)
    16181615    {
    … …  
    16551652        // Let's start with pure 32 bits ring 0 code first
    16561653        /** @todo What's pure 32-bit mode? flat? */
    1657         if (    !(pCtx->ss.Attr.n.u1DefBig)
    1658             ||  !(pCtx->cs.Attr.n.u1DefBig))
     1654        if (    !(pVCpu->cpum.GstCtx.ss.Attr.n.u1DefBig)
     1655            ||  !(pVCpu->cpum.GstCtx.cs.Attr.n.u1DefBig))
    16591656        {
    16601657            Log2(("raw r0 mode refused: SS/CS not 32bit\n"));
    … …  
    16701667
    16711668# ifdef VBOX_WITH_RAW_MODE
    1672         if (PATMShouldUseRawMode(pVM, (RTGCPTR)pCtx->eip))
     1669        if (PATMShouldUseRawMode(pVM, (RTGCPTR)pVCpu->cpum.GstCtx.eip))
    16731670        {
    16741671            Log2(("raw r0 mode forced: patch code\n"));
    16751672#  ifdef VBOX_WITH_SAFE_STR
    1676             Assert(pCtx->tr.Sel);
     1673            Assert(pVCpu->cpum.GstCtx.tr.Sel);
    16771674#  endif
    16781675            return EMSTATE_RAW;
    … …  
    17021699     * Stale hidden selectors means raw-mode is unsafe (being very careful).
    17031700     */
    1704     if (pCtx->cs.fFlags & CPUMSELREG_FLAGS_STALE)
     1701    if (pVCpu->cpum.GstCtx.cs.fFlags & CPUMSELREG_FLAGS_STALE)
    17051702    {
    17061703        Log2(("raw mode refused: stale CS\n"));
    17071704        return EMSTATE_REM;
    17081705    }
    1709     if (pCtx->ss.fFlags & CPUMSELREG_FLAGS_STALE)
     1706    if (pVCpu->cpum.GstCtx.ss.fFlags & CPUMSELREG_FLAGS_STALE)
    17101707    {
    17111708        Log2(("raw mode refused: stale SS\n"));
    17121709        return EMSTATE_REM;
    17131710    }
    1714     if (pCtx->ds.fFlags & CPUMSELREG_FLAGS_STALE)
     1711    if (pVCpu->cpum.GstCtx.ds.fFlags & CPUMSELREG_FLAGS_STALE)
    17151712    {
    17161713        Log2(("raw mode refused: stale DS\n"));
    17171714        return EMSTATE_REM;
    17181715    }
    1719     if (pCtx->es.fFlags & CPUMSELREG_FLAGS_STALE)
     1716    if (pVCpu->cpum.GstCtx.es.fFlags & CPUMSELREG_FLAGS_STALE)
    17201717    {
    17211718        Log2(("raw mode refused: stale ES\n"));
    17221719        return EMSTATE_REM;
    17231720    }
    1724     if (pCtx->fs.fFlags & CPUMSELREG_FLAGS_STALE)
     1721    if (pVCpu->cpum.GstCtx.fs.fFlags & CPUMSELREG_FLAGS_STALE)
    17251722    {
    17261723        Log2(("raw mode refused: stale FS\n"));
    17271724        return EMSTATE_REM;
    17281725    }
    1729     if (pCtx->gs.fFlags & CPUMSELREG_FLAGS_STALE)
     1726    if (pVCpu->cpum.GstCtx.gs.fFlags & CPUMSELREG_FLAGS_STALE)
    17301727    {
    17311728        Log2(("raw mode refused: stale GS\n"));
    … …  
    17341731
    17351732# ifdef VBOX_WITH_SAFE_STR
    1736     if (pCtx->tr.Sel == 0)
     1733    if (pVCpu->cpum.GstCtx.tr.Sel == 0)
    17371734    {
    17381735        Log(("Raw mode refused -> TR=0\n"));
    … …  
    18271824 * @returns VBox status code.
    18281825 * @param   pVCpu       The cross context virtual CPU structure.
    1829  * @param   pCtx        Pointer to the nested-guest CPU context.
    18301826 * @param   pfResched   Where to store whether a reschedule is required.
    18311827 * @param   pfInject    Where to store whether an interrupt was injected (and if
    18321828 *                      a wake up is pending).
    18331829 */
    1834 static int emR3NstGstInjectIntr(PVMCPU pVCpu, PCPUMCTX pCtx, bool *pfResched, bool *pfInject)
     1830static int emR3NstGstInjectIntr(PVMCPU pVCpu, bool *pfResched, bool *pfInject)
    18351831{
    18361832    *pfResched = false;
    18371833    *pfInject  = false;
    1838     if (CPUMIsGuestInSvmNestedHwVirtMode(pCtx))
     1834    if (CPUMIsGuestInSvmNestedHwVirtMode(&pVCpu->cpum.GstCtx))
    18391835    {
    18401836        PVM pVM  = pVCpu->CTX_SUFF(pVM);
    1841         Assert(pCtx->hwvirt.fGif);
    1842         bool fVirtualGif = CPUMGetSvmNstGstVGif(pCtx);
     1837        Assert(pVCpu->cpum.GstCtx.hwvirt.fGif);
     1838        bool fVirtualGif = CPUMGetSvmNstGstVGif(&pVCpu->cpum.GstCtx);
    18431839#ifdef VBOX_WITH_RAW_MODE
    1844         fVirtualGif     &= !PATMIsPatchGCAddr(pVM, pCtx->eip);
     1840        fVirtualGif     &= !PATMIsPatchGCAddr(pVM, pVCpu->cpum.GstCtx.eip);
    18451841#endif
    18461842        if (fVirtualGif)
    18471843        {
    1848             if (CPUMCanSvmNstGstTakePhysIntr(pVCpu, pCtx))
     1844            if (CPUMCanSvmNstGstTakePhysIntr(pVCpu, &pVCpu->cpum.GstCtx))
    18491845            {
    18501846                Assert(pVCpu->em.s.enmState != EMSTATE_WAIT_SIPI);
    18511847                if (VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_INTERRUPT_APIC | VMCPU_FF_INTERRUPT_PIC))
    18521848                {
    1853                     if (CPUMIsGuestSvmCtrlInterceptSet(pVCpu, pCtx, SVM_CTRL_INTERCEPT_INTR))
     1849                    if (CPUMIsGuestSvmCtrlInterceptSet(pVCpu, &pVCpu->cpum.GstCtx, SVM_CTRL_INTERCEPT_INTR))
    18541850                    {
    18551851                        VBOXSTRICTRC rcStrict = IEMExecSvmVmexit(pVCpu, SVM_EXIT_INTR, 0, 0);
    … …  
    18891885
    18901886            if (   VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_INTERRUPT_NESTED_GUEST)
    1891                 && CPUMCanSvmNstGstTakeVirtIntr(pVCpu, pCtx))
     1887                && CPUMCanSvmNstGstTakeVirtIntr(pVCpu, &pVCpu->cpum.GstCtx))
    18921888            {
    1893                 if (CPUMIsGuestSvmCtrlInterceptSet(pVCpu, pCtx, SVM_CTRL_INTERCEPT_VINTR))
     1889                if (CPUMIsGuestSvmCtrlInterceptSet(pVCpu, &pVCpu->cpum.GstCtx, SVM_CTRL_INTERCEPT_VINTR))
    18941890                {
    18951891                    VBOXSTRICTRC rcStrict = IEMExecSvmVmexit(pVCpu, SVM_EXIT_VINTR, 0, 0);
    … …  
    19101906
    19111907                VMCPU_FF_CLEAR(pVCpu, VMCPU_FF_INTERRUPT_NESTED_GUEST);
    1912                 uint8_t const uNstGstVector = CPUMGetSvmNstGstInterrupt(pCtx);
     1908                uint8_t const uNstGstVector = CPUMGetSvmNstGstInterrupt(&pVCpu->cpum.GstCtx);
    19131909                AssertMsg(uNstGstVector > 0 && uNstGstVector <= X86_XCPT_LAST, ("Invalid VINTR vector %#x\n", uNstGstVector));
    19141910                TRPMAssertTrap(pVCpu, uNstGstVector, TRPM_HARDWARE_INT);
    … …  
    19231919    }
    19241920
    1925     if (CPUMIsGuestInVmxNestedHwVirtMode(pCtx))
     1921    if (CPUMIsGuestInVmxNestedHwVirtMode(&pVCpu->cpum.GstCtx))
    19261922    { /** @todo Nested VMX. */ }
    19271923
    … …  
    20522048            Log(("Forced action VMCPU_FF_CSAM_SCAN_PAGE\n"));
    20532049            CPUM_IMPORT_EXTRN_RCSTRICT(pVCpu, ~CPUMCTX_EXTRN_KEEPER_MASK, rc);
    2054             PCPUMCTX pCtx = pVCpu->em.s.pCtx;
    2055             CSAMR3CheckCodeEx(pVM, pCtx, pCtx->eip);
     2050            CSAMR3CheckCodeEx(pVM, &pVCpu->cpum.GstCtx, pVCpu->cpum.GstCtx.eip);
    20562051            VMCPU_FF_CLEAR(pVCpu, VMCPU_FF_CSAM_SCAN_PAGE);
    20572052        }
    … …  
    22552250            {
    22562251                Assert(!HMR3IsEventPending(pVCpu));
    2257                 PCPUMCTX pCtx = pVCpu->em.s.pCtx;
    22582252#ifdef VBOX_WITH_NESTED_HWVIRT_SVM
    2259                 if (CPUMIsGuestInNestedHwVirtMode(pCtx))
     2253                if (CPUMIsGuestInNestedHwVirtMode(&pVCpu->cpum.GstCtx))
    22602254                {
    22612255                    bool fResched, fInject;
    2262                     rc2 = emR3NstGstInjectIntr(pVCpu, pCtx, &fResched, &fInject);
     2256                    rc2 = emR3NstGstInjectIntr(pVCpu, &fResched, &fInject);
    22632257                    if (fInject)
    22642258                    {
    … …  
    22772271                    if (   VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_INTERRUPT_APIC | VMCPU_FF_INTERRUPT_PIC)
    22782272#ifdef VBOX_WITH_NESTED_HWVIRT_SVM
    2279                         && pCtx->hwvirt.fGif
     2273                        && pVCpu->cpum.GstCtx.hwvirt.fGif
    22802274#endif
    22812275#ifdef VBOX_WITH_RAW_MODE
    2282                         && !PATMIsPatchGCAddr(pVM, pCtx->eip)
    2283 #endif
    2284                         && pCtx->eflags.Bits.u1IF)
     2276                        && !PATMIsPatchGCAddr(pVM, pVCpu->cpum.GstCtx.eip)
     2277#endif
     2278                        && pVCpu->cpum.GstCtx.eflags.Bits.u1IF)
    22852279                    {
    22862280                        Assert(pVCpu->em.s.enmState != EMSTATE_WAIT_SIPI);
    … …  
    25072501            pVCpu->em.s.enmState = pVCpu->em.s.enmPrevState;
    25082502        else
    2509             pVCpu->em.s.enmState = emR3Reschedule(pVM, pVCpu, pVCpu->em.s.pCtx);
     2503            pVCpu->em.s.enmState = emR3Reschedule(pVM, pVCpu);
    25102504        pVCpu->em.s.cIemThenRemInstructions = 0;
    25112505        Log(("EMR3ExecuteVM: enmState=%s\n", emR3GetStateName(pVCpu->em.s.enmState)));
    … …  
    26352629                case VINF_EM_RESCHEDULE:
    26362630                {
    2637                     EMSTATE enmState = emR3Reschedule(pVM, pVCpu, pVCpu->em.s.pCtx);
     2631                    EMSTATE enmState = emR3Reschedule(pVM, pVCpu);
    26382632                    Log2(("EMR3ExecuteVM: VINF_EM_RESCHEDULE: %d -> %d (%s)\n", enmOldState, enmState, emR3GetStateName(enmState)));
    26392633                    if (pVCpu->em.s.enmState != enmState && enmState == EMSTATE_IEM_THEN_REM)
    … …  
    26792673                    if (pVCpu->idCpu == 0)
    26802674                    {
    2681                         EMSTATE enmState = emR3Reschedule(pVM, pVCpu, pVCpu->em.s.pCtx);
     2675                        EMSTATE enmState = emR3Reschedule(pVM, pVCpu);
    26822676                        Log2(("EMR3ExecuteVM: VINF_EM_RESET: %d -> %d (%s)\n", enmOldState, enmState, emR3GetStateName(enmState)));
    26832677                        if (pVCpu->em.s.enmState != enmState && enmState == EMSTATE_IEM_THEN_REM)

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

    r72598 r72634  
    6464*   Internal Functions                                                                                                           *
    6565*********************************************************************************************************************************/
     66static int      emR3HmHandleRC(PVM pVM, PVMCPU pVCpu, int rc);
    6667DECLINLINE(int) emR3HmExecuteInstruction(PVM pVM, PVMCPU pVCpu, const char *pszPrefix, int rcGC = VINF_SUCCESS);
    6768static int      emR3HmExecuteIOInstruction(PVM pVM, PVMCPU pVCpu);
    68 static int      emR3HmForcedActions(PVM pVM, PVMCPU pVCpu, PCPUMCTX pCtx);
     69static int      emR3HmForcedActions(PVM pVM, PVMCPU pVCpu);
    6970
    7071#define EMHANDLERC_WITH_HM
    … …  
    9192VMMR3_INT_DECL(VBOXSTRICTRC) EMR3HmSingleInstruction(PVM pVM, PVMCPU pVCpu, uint32_t fFlags)
    9293{
    93     PCPUMCTX pCtx = pVCpu->em.s.pCtx;
    9494    Assert(!(fFlags & ~EM_ONE_INS_FLAGS_MASK));
    9595
    96     if (!HMR3CanExecuteGuest(pVM, pCtx))
     96    if (!HMR3CanExecuteGuest(pVM, &pVCpu->cpum.GstCtx))
    9797        return VINF_EM_RESCHEDULE;
    9898
    99     uint64_t const uOldRip = pCtx->rip;
     99    uint64_t const uOldRip = pVCpu->cpum.GstCtx.rip;
    100100    for (;;)
    101101    {
    … …  
    106106            || VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_HIGH_PRIORITY_PRE_RAW_MASK))
    107107        {
    108             VBOXSTRICTRC rcStrict = emR3HmForcedActions(pVM, pVCpu, pCtx);
     108            VBOXSTRICTRC rcStrict = emR3HmForcedActions(pVM, pVCpu);
    109109            if (rcStrict != VINF_SUCCESS)
    110110            {
    … …  
    136136        if (rcStrict != VINF_SUCCESS && (rcStrict < VINF_EM_FIRST || rcStrict > VINF_EM_LAST))
    137137        {
    138             rcStrict = emR3HmHandleRC(pVM, pVCpu, pCtx, VBOXSTRICTRC_TODO(rcStrict));
     138            rcStrict = emR3HmHandleRC(pVM, pVCpu, VBOXSTRICTRC_TODO(rcStrict));
    139139            Log(("EMR3HmSingleInstruction: emR3HmHandleRC -> %Rrc\n", VBOXSTRICTRC_VAL(rcStrict)));
    140140        }
    … …  
    145145        if (   (rcStrict != VINF_SUCCESS && rcStrict != VINF_EM_DBG_STEPPED)
    146146            || !(fFlags & EM_ONE_INS_FLAGS_RIP_CHANGE)
    147             || pCtx->rip != uOldRip)
    148         {
    149             if (rcStrict == VINF_SUCCESS && pCtx->rip != uOldRip)
     147            || pVCpu->cpum.GstCtx.rip != uOldRip)
     148        {
     149            if (rcStrict == VINF_SUCCESS && pVCpu->cpum.GstCtx.rip != uOldRip)
    150150                rcStrict = VINF_EM_DBG_STEPPED;
    151             Log(("EMR3HmSingleInstruction: returns %Rrc (rip %llx -> %llx)\n", VBOXSTRICTRC_VAL(rcStrict), uOldRip, pCtx->rip));
     151            Log(("EMR3HmSingleInstruction: returns %Rrc (rip %llx -> %llx)\n", VBOXSTRICTRC_VAL(rcStrict), uOldRip, pVCpu->cpum.GstCtx.rip));
    152152            CPUM_IMPORT_EXTRN_RET(pVCpu, ~CPUMCTX_EXTRN_KEEPER_MASK);
    153153            return rcStrict;
    … …  
    174174#endif
    175175{
     176    NOREF(rcRC);
     177
    176178#ifdef LOG_ENABLED
    177     PCPUMCTX pCtx = pVCpu->em.s.pCtx;
    178 #endif
    179     NOREF(rcRC);
    180 
    181 #ifdef LOG_ENABLED
    182179    /*
    183180     * Log it.
    184181     */
    185     Log(("EMINS: %04x:%RGv RSP=%RGv\n", pCtx->cs.Sel, (RTGCPTR)pCtx->rip, (RTGCPTR)pCtx->rsp));
     182    Log(("EMINS: %04x:%RGv RSP=%RGv\n", pVCpu->cpum.GstCtx.cs.Sel, (RTGCPTR)pVCpu->cpum.GstCtx.rip, (RTGCPTR)pVCpu->cpum.GstCtx.rsp));
    186183    if (pszPrefix)
    187184    {
    … …  
    269266static int emR3HmExecuteIOInstruction(PVM pVM, PVMCPU pVCpu)
    270267{
    271     PCPUMCTX pCtx = pVCpu->em.s.pCtx;
    272 
    273268    STAM_PROFILE_START(&pVCpu->em.s.StatIOEmu, a);
    274269
    … …  
    281276         * Try to restart the io instruction that was refused in ring-0.
    282277         */
    283         rcStrict = HMR3RestartPendingIOInstr(pVM, pVCpu, pCtx);
     278        rcStrict = HMR3RestartPendingIOInstr(pVM, pVCpu, &pVCpu->cpum.GstCtx);
    284279        if (IOM_SUCCESS(rcStrict))
    285280        {
    … …  
    324319 * @param   pVM         The cross context VM structure.
    325320 * @param   pVCpu       The cross context virtual CPU structure.
    326  * @param   pCtx        Pointer to the guest CPU context.
    327  */
    328 static int emR3HmForcedActions(PVM pVM, PVMCPU pVCpu, PCPUMCTX pCtx)
     321 */
     322static int emR3HmForcedActions(PVM pVM, PVMCPU pVCpu)
    329323{
    330324    /*
    … …  
    335329        CPUM_IMPORT_EXTRN_RET(pVCpu, CPUMCTX_EXTRN_CR0 | CPUMCTX_EXTRN_CR3 | CPUMCTX_EXTRN_CR4);
    336330        Assert(pVCpu->em.s.enmState != EMSTATE_WAIT_SIPI);
    337         int rc = PGMSyncCR3(pVCpu, pCtx->cr0, pCtx->cr3, pCtx->cr4, VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_PGM_SYNC_CR3));
     331        int rc = PGMSyncCR3(pVCpu, pVCpu->cpum.GstCtx.cr0, pVCpu->cpum.GstCtx.cr3, pVCpu->cpum.GstCtx.cr4, VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_PGM_SYNC_CR3));
    338332        if (RT_FAILURE(rc))
    339333            return rc;
    … …  
    347341        /** @todo this should be skipped! */
    348342        CPUM_IMPORT_EXTRN_RET(pVCpu, CPUMCTX_EXTRN_CS | CPUMCTX_EXTRN_SS);
    349         rc = PGMPrefetchPage(pVCpu, SELMToFlat(pVM, DISSELREG_CS, CPUMCTX2CORE(pCtx), pCtx->rip));
     343        rc = PGMPrefetchPage(pVCpu, SELMToFlat(pVM, DISSELREG_CS, CPUMCTX2CORE(&pVCpu->cpum.GstCtx), pVCpu->cpum.GstCtx.rip));
    350344        if (rc == VINF_SUCCESS)
    351             rc = PGMPrefetchPage(pVCpu, SELMToFlat(pVM, DISSELREG_SS, CPUMCTX2CORE(pCtx), pCtx->rsp));
     345            rc = PGMPrefetchPage(pVCpu, SELMToFlat(pVM, DISSELREG_SS, CPUMCTX2CORE(&pVCpu->cpum.GstCtx), pVCpu->cpum.GstCtx.rsp));
    352346        if (rc != VINF_SUCCESS)
    353347        {
    … …  
    357351                return rc;
    358352            }
    359             rc = PGMSyncCR3(pVCpu, pCtx->cr0, pCtx->cr3, pCtx->cr4, VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_PGM_SYNC_CR3));
     353            rc = PGMSyncCR3(pVCpu, pVCpu->cpum.GstCtx.cr0, pVCpu->cpum.GstCtx.cr3, pVCpu->cpum.GstCtx.cr4, VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_PGM_SYNC_CR3));
    360354            if (RT_FAILURE(rc))
    361355                return rc;
    … …  
    408402{
    409403    int      rc = VERR_IPE_UNINITIALIZED_STATUS;
    410     PCPUMCTX pCtx = pVCpu->em.s.pCtx;
    411 
    412     LogFlow(("emR3HmExecute%d: (cs:eip=%04x:%RGv)\n", pVCpu->idCpu, pCtx->cs.Sel, (RTGCPTR)pCtx->rip));
     404
     405    LogFlow(("emR3HmExecute%d: (cs:eip=%04x:%RGv)\n", pVCpu->idCpu, pVCpu->cpum.GstCtx.cs.Sel, (RTGCPTR)pVCpu->cpum.GstCtx.rip));
    413406    *pfFFDone = false;
    414407
    … …  
    427420
    428421        /* Check if a forced reschedule is pending. */
    429         if (HMR3IsRescheduleRequired(pVM, pCtx))
     422        if (HMR3IsRescheduleRequired(pVM, &pVCpu->cpum.GstCtx))
    430423        {
    431424            rc = VINF_EM_RESCHEDULE;
    … …  
    442435            ||  VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_HIGH_PRIORITY_PRE_RAW_MASK))
    443436        {
    444             rc = emR3HmForcedActions(pVM, pVCpu, pCtx);
     437            rc = emR3HmForcedActions(pVM, pVCpu);
    445438            if (rc != VINF_SUCCESS)
    446439                break;
    … …  
    452445         */
    453446        if (TRPMHasTrap(pVCpu))
    454             Log(("CPU%d: Pending hardware interrupt=0x%x cs:rip=%04X:%RGv\n", pVCpu->idCpu, TRPMGetTrapNo(pVCpu), pCtx->cs.Sel, (RTGCPTR)pCtx->rip));
     447            Log(("CPU%d: Pending hardware interrupt=0x%x cs:rip=%04X:%RGv\n", pVCpu->idCpu, TRPMGetTrapNo(pVCpu), pVCpu->cpum.GstCtx.cs.Sel, (RTGCPTR)pVCpu->cpum.GstCtx.rip));
    455448
    456449        uint32_t cpl = CPUMGetGuestCPL(pVCpu);
    457450        if (pVM->cCpus == 1)
    458451        {
    459             if (pCtx->eflags.Bits.u1VM)
    460                 Log(("HWV86: %08X IF=%d\n", pCtx->eip, pCtx->eflags.Bits.u1IF));
    461             else if (CPUMIsGuestIn64BitCodeEx(pCtx))
    462                 Log(("HWR%d: %04X:%RGv ESP=%RGv IF=%d IOPL=%d CR0=%x CR4=%x EFER=%x\n", cpl, pCtx->cs.Sel, (RTGCPTR)pCtx->rip, pCtx->rsp, pCtx->eflags.Bits.u1IF, pCtx->eflags.Bits.u2IOPL, (uint32_t)pCtx->cr0, (uint32_t)pCtx->cr4, (uint32_t)pCtx->msrEFER));
     452            if (pVCpu->cpum.GstCtx.eflags.Bits.u1VM)
     453                Log(("HWV86: %08X IF=%d\n", pVCpu->cpum.GstCtx.eip, pVCpu->cpum.GstCtx.eflags.Bits.u1IF));
     454            else if (CPUMIsGuestIn64BitCodeEx(&pVCpu->cpum.GstCtx))
     455                Log(("HWR%d: %04X:%RGv ESP=%RGv IF=%d IOPL=%d CR0=%x CR4=%x EFER=%x\n", cpl, pVCpu->cpum.GstCtx.cs.Sel, (RTGCPTR)pVCpu->cpum.GstCtx.rip, pVCpu->cpum.GstCtx.rsp, pVCpu->cpum.GstCtx.eflags.Bits.u1IF, pVCpu->cpum.GstCtx.eflags.Bits.u2IOPL, (uint32_t)pVCpu->cpum.GstCtx.cr0, (uint32_t)pVCpu->cpum.GstCtx.cr4, (uint32_t)pVCpu->cpum.GstCtx.msrEFER));
    463456            else
    464                 Log(("HWR%d: %04X:%08X ESP=%08X IF=%d IOPL=%d CR0=%x CR4=%x EFER=%x\n", cpl, pCtx->cs.Sel,          pCtx->eip, pCtx->esp, pCtx->eflags.Bits.u1IF, pCtx->eflags.Bits.u2IOPL, (uint32_t)pCtx->cr0, (uint32_t)pCtx->cr4, (uint32_t)pCtx->msrEFER));
     457                Log(("HWR%d: %04X:%08X ESP=%08X IF=%d IOPL=%d CR0=%x CR4=%x EFER=%x\n", cpl, pVCpu->cpum.GstCtx.cs.Sel,          pVCpu->cpum.GstCtx.eip, pVCpu->cpum.GstCtx.esp, pVCpu->cpum.GstCtx.eflags.Bits.u1IF, pVCpu->cpum.GstCtx.eflags.Bits.u2IOPL, (uint32_t)pVCpu->cpum.GstCtx.cr0, (uint32_t)pVCpu->cpum.GstCtx.cr4, (uint32_t)pVCpu->cpum.GstCtx.msrEFER));
    465458        }
    466459        else
    467460        {
    468             if (pCtx->eflags.Bits.u1VM)
    469                 Log(("HWV86-CPU%d: %08X IF=%d\n", pVCpu->idCpu, pCtx->eip, pCtx->eflags.Bits.u1IF));
    470             else if (CPUMIsGuestIn64BitCodeEx(pCtx))
    471                 Log(("HWR%d-CPU%d: %04X:%RGv ESP=%RGv IF=%d IOPL=%d CR0=%x CR4=%x EFER=%x\n", cpl, pVCpu->idCpu, pCtx->cs.Sel, (RTGCPTR)pCtx->rip, pCtx->rsp, pCtx->eflags.Bits.u1IF, pCtx->eflags.Bits.u2IOPL, (uint32_t)pCtx->cr0, (uint32_t)pCtx->cr4, (uint32_t)pCtx->msrEFER));
     461            if (pVCpu->cpum.GstCtx.eflags.Bits.u1VM)
     462                Log(("HWV86-CPU%d: %08X IF=%d\n", pVCpu->idCpu, pVCpu->cpum.GstCtx.eip, pVCpu->cpum.GstCtx.eflags.Bits.u1IF));
     463            else if (CPUMIsGuestIn64BitCodeEx(&pVCpu->cpum.GstCtx))
     464                Log(("HWR%d-CPU%d: %04X:%RGv ESP=%RGv IF=%d IOPL=%d CR0=%x CR4=%x EFER=%x\n", cpl, pVCpu->idCpu, pVCpu->cpum.GstCtx.cs.Sel, (RTGCPTR)pVCpu->cpum.GstCtx.rip, pVCpu->cpum.GstCtx.rsp, pVCpu->cpum.GstCtx.eflags.Bits.u1IF, pVCpu->cpum.GstCtx.eflags.Bits.u2IOPL, (uint32_t)pVCpu->cpum.GstCtx.cr0, (uint32_t)pVCpu->cpum.GstCtx.cr4, (uint32_t)pVCpu->cpum.GstCtx.msrEFER));
    472465            else
    473                 Log(("HWR%d-CPU%d: %04X:%08X ESP=%08X IF=%d IOPL=%d CR0=%x CR4=%x EFER=%x\n", cpl, pVCpu->idCpu, pCtx->cs.Sel,          pCtx->eip, pCtx->esp, pCtx->eflags.Bits.u1IF, pCtx->eflags.Bits.u2IOPL, (uint32_t)pCtx->cr0, (uint32_t)pCtx->cr4, (uint32_t)pCtx->msrEFER));
     466                Log(("HWR%d-CPU%d: %04X:%08X ESP=%08X IF=%d IOPL=%d CR0=%x CR4=%x EFER=%x\n", cpl, pVCpu->idCpu, pVCpu->cpum.GstCtx.cs.Sel,          pVCpu->cpum.GstCtx.eip, pVCpu->cpum.GstCtx.esp, pVCpu->cpum.GstCtx.eflags.Bits.u1IF, pVCpu->cpum.GstCtx.eflags.Bits.u2IOPL, (uint32_t)pVCpu->cpum.GstCtx.cr0, (uint32_t)pVCpu->cpum.GstCtx.cr4, (uint32_t)pVCpu->cpum.GstCtx.msrEFER));
    474467        }
    475468#endif /* LOG_ENABLED */
    … …  
    510503            break;
    511504
    512         rc = emR3HmHandleRC(pVM, pVCpu, pCtx, rc);
     505        rc = emR3HmHandleRC(pVM, pVCpu, rc);
    513506        if (rc != VINF_SUCCESS)
    514507            break;

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

    r72580 r72634  
    6464*   Internal Functions                                                                                                           *
    6565*********************************************************************************************************************************/
     66static int      emR3NemHandleRC(PVM pVM, PVMCPU pVCpu, int rc);
    6667DECLINLINE(int) emR3NemExecuteInstruction(PVM pVM, PVMCPU pVCpu, const char *pszPrefix, int rcGC = VINF_SUCCESS);
    6768static int      emR3NemExecuteIOInstruction(PVM pVM, PVMCPU pVCpu);
    68 static int      emR3NemForcedActions(PVM pVM, PVMCPU pVCpu, PCPUMCTX pCtx);
     69static int      emR3NemForcedActions(PVM pVM, PVMCPU pVCpu);
    6970
    7071#define EMHANDLERC_WITH_NEM
    … …  
    9192VBOXSTRICTRC emR3NemSingleInstruction(PVM pVM, PVMCPU pVCpu, uint32_t fFlags)
    9293{
    93     Assert(pVCpu->em.s.pCtx == &pVCpu->cpum.GstCtx);
    9494    Assert(!(fFlags & ~EM_ONE_INS_FLAGS_MASK));
    9595
    96     if (!NEMR3CanExecuteGuest(pVM, pVCpu, &pVCpu->cpum.GstCtx))
     96    if (!NEMR3CanExecuteGuest(pVM, pVCpu))
    9797        return VINF_EM_RESCHEDULE;
    9898
    … …  
    106106            || VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_HIGH_PRIORITY_PRE_RAW_MASK))
    107107        {
    108             VBOXSTRICTRC rcStrict = emR3NemForcedActions(pVM, pVCpu, &pVCpu->cpum.GstCtx);
     108            VBOXSTRICTRC rcStrict = emR3NemForcedActions(pVM, pVCpu);
    109109            if (rcStrict != VINF_SUCCESS)
    110110            {
    … …  
    136136        if (rcStrict != VINF_SUCCESS && (rcStrict < VINF_EM_FIRST || rcStrict > VINF_EM_LAST))
    137137        {
    138             rcStrict = emR3NemHandleRC(pVM, pVCpu, &pVCpu->cpum.GstCtx, VBOXSTRICTRC_TODO(rcStrict));
     138            rcStrict = emR3NemHandleRC(pVM, pVCpu, VBOXSTRICTRC_TODO(rcStrict));
    139139            Log(("emR3NemSingleInstruction: emR3NemHandleRC -> %Rrc\n", VBOXSTRICTRC_VAL(rcStrict)));
    140140        }
    … …  
    176176#endif
    177177{
    178 #if defined(LOG_ENABLED)
    179     PCPUMCTX pCtx = pVCpu->em.s.pCtx;
    180 #endif
    181178    NOREF(rcRC);
    182179
    … …  
    185182     * Log it.
    186183     */
    187     Log(("EMINS: %04x:%RGv RSP=%RGv\n", pCtx->cs.Sel, (RTGCPTR)pCtx->rip, (RTGCPTR)pCtx->rsp));
     184    Log(("EMINS: %04x:%RGv RSP=%RGv\n", pVCpu->cpum.GstCtx.cs.Sel, (RTGCPTR)pVCpu->cpum.GstCtx.rip, (RTGCPTR)pVCpu->cpum.GstCtx.rsp));
    188185    if (pszPrefix)
    189186    {
    … …  
    308305 * @param   pVM         The cross context VM structure.
    309306 * @param   pVCpu       The cross context virtual CPU structure.
    310  * @param   pCtx        Pointer to the guest CPU context.
    311  */
    312 static int emR3NemForcedActions(PVM pVM, PVMCPU pVCpu, PCPUMCTX pCtx)
     307 */
     308static int emR3NemForcedActions(PVM pVM, PVMCPU pVCpu)
    313309{
    314310#ifdef VBOX_WITH_RAW_MODE
    … …  
    345341        return VINF_EM_NO_MEMORY;
    346342
    347     RT_NOREF_PV(pCtx);
    348343    return VINF_SUCCESS;
    349344}
    … …  
    367362{
    368363    VBOXSTRICTRC rcStrict = VERR_IPE_UNINITIALIZED_STATUS;
    369     PCPUMCTX     pCtx     = pVCpu->em.s.pCtx;
    370 
    371     LogFlow(("emR3NemExecute%d: (cs:eip=%04x:%RGv)\n", pVCpu->idCpu, pCtx->cs.Sel, (RTGCPTR)pCtx->rip));
     364
     365    LogFlow(("emR3NemExecute%d: (cs:eip=%04x:%RGv)\n", pVCpu->idCpu, pVCpu->cpum.GstCtx.cs.Sel, (RTGCPTR)pVCpu->cpum.GstCtx.rip));
    372366    *pfFFDone = false;
    373367
    … …  
    383377#if 0
    384378        /* Check if a forced reschedule is pending. */
    385         if (NEMR3IsRescheduleRequired(pVM, pCtx))
     379        if (NEMR3IsRescheduleRequired(pVCpu))
    386380        {
    387381            rcStrict = VINF_EM_RESCHEDULE;
    … …  
    396390            || VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_HIGH_PRIORITY_PRE_RAW_MASK))
    397391        {
    398             rcStrict = emR3NemForcedActions(pVM, pVCpu, pCtx);
     392            rcStrict = emR3NemForcedActions(pVM, pVCpu);
    399393            if (rcStrict != VINF_SUCCESS)
    400394                break;
    … …  
    406400         */
    407401        if (TRPMHasTrap(pVCpu))
    408             Log(("CPU%d: Pending hardware interrupt=0x%x cs:rip=%04X:%RGv\n", pVCpu->idCpu, TRPMGetTrapNo(pVCpu), pCtx->cs.Sel, (RTGCPTR)pCtx->rip));
     402            Log(("CPU%d: Pending hardware interrupt=0x%x cs:rip=%04X:%RGv\n", pVCpu->idCpu, TRPMGetTrapNo(pVCpu), pVCpu->cpum.GstCtx.cs.Sel, (RTGCPTR)pVCpu->cpum.GstCtx.rip));
    409403
    410404        uint32_t cpl = CPUMGetGuestCPL(pVCpu);
    411405        if (pVM->cCpus == 1)
    412406        {
    413             if (pCtx->eflags.Bits.u1VM)
    414                 Log(("NEMV86: %08x IF=%d\n", pCtx->eip, pCtx->eflags.Bits.u1IF));
    415             else if (CPUMIsGuestIn64BitCodeEx(pCtx))
    416                 Log(("NEMR%d: %04x:%RGv ESP=%RGv IF=%d IOPL=%d CR0=%x CR4=%x EFER=%x\n", cpl, pCtx->cs.Sel, (RTGCPTR)pCtx->rip, pCtx->rsp, pCtx->eflags.Bits.u1IF, pCtx->eflags.Bits.u2IOPL, (uint32_t)pCtx->cr0, (uint32_t)pCtx->cr4, (uint32_t)pCtx->msrEFER));
     407            if (pVCpu->cpum.GstCtx.eflags.Bits.u1VM)
     408                Log(("NEMV86: %08x IF=%d\n", pVCpu->cpum.GstCtx.eip, pVCpu->cpum.GstCtx.eflags.Bits.u1IF));
     409            else if (CPUMIsGuestIn64BitCodeEx(&pVCpu->cpum.GstCtx))
     410                Log(("NEMR%d: %04x:%RGv ESP=%RGv IF=%d IOPL=%d CR0=%x CR4=%x EFER=%x\n", cpl, pVCpu->cpum.GstCtx.cs.Sel, (RTGCPTR)pVCpu->cpum.GstCtx.rip, pVCpu->cpum.GstCtx.rsp, pVCpu->cpum.GstCtx.eflags.Bits.u1IF, pVCpu->cpum.GstCtx.eflags.Bits.u2IOPL, (uint32_t)pVCpu->cpum.GstCtx.cr0, (uint32_t)pVCpu->cpum.GstCtx.cr4, (uint32_t)pVCpu->cpum.GstCtx.msrEFER));
    417411            else
    418                 Log(("NEMR%d: %04x:%08x ESP=%08X IF=%d IOPL=%d CR0=%x CR4=%x EFER=%x\n", cpl, pCtx->cs.Sel,          pCtx->eip, pCtx->esp, pCtx->eflags.Bits.u1IF, pCtx->eflags.Bits.u2IOPL, (uint32_t)pCtx->cr0, (uint32_t)pCtx->cr4, (uint32_t)pCtx->msrEFER));
     412                Log(("NEMR%d: %04x:%08x ESP=%08X IF=%d IOPL=%d CR0=%x CR4=%x EFER=%x\n", cpl, pVCpu->cpum.GstCtx.cs.Sel,          pVCpu->cpum.GstCtx.eip, pVCpu->cpum.GstCtx.esp, pVCpu->cpum.GstCtx.eflags.Bits.u1IF, pVCpu->cpum.GstCtx.eflags.Bits.u2IOPL, (uint32_t)pVCpu->cpum.GstCtx.cr0, (uint32_t)pVCpu->cpum.GstCtx.cr4, (uint32_t)pVCpu->cpum.GstCtx.msrEFER));
    419413        }
    420414        else
    421415        {
    422             if (pCtx->eflags.Bits.u1VM)
    423                 Log(("NEMV86-CPU%d: %08x IF=%d\n", pVCpu->idCpu, pCtx->eip, pCtx->eflags.Bits.u1IF));
    424             else if (CPUMIsGuestIn64BitCodeEx(pCtx))
    425                 Log(("NEMR%d-CPU%d: %04x:%RGv ESP=%RGv IF=%d IOPL=%d CR0=%x CR4=%x EFER=%x\n", cpl, pVCpu->idCpu, pCtx->cs.Sel, (RTGCPTR)pCtx->rip, pCtx->rsp, pCtx->eflags.Bits.u1IF, pCtx->eflags.Bits.u2IOPL, (uint32_t)pCtx->cr0, (uint32_t)pCtx->cr4, (uint32_t)pCtx->msrEFER));
     416            if (pVCpu->cpum.GstCtx.eflags.Bits.u1VM)
     417                Log(("NEMV86-CPU%d: %08x IF=%d\n", pVCpu->idCpu, pVCpu->cpum.GstCtx.eip, pVCpu->cpum.GstCtx.eflags.Bits.u1IF));
     418            else if (CPUMIsGuestIn64BitCodeEx(&pVCpu->cpum.GstCtx))
     419                Log(("NEMR%d-CPU%d: %04x:%RGv ESP=%RGv IF=%d IOPL=%d CR0=%x CR4=%x EFER=%x\n", cpl, pVCpu->idCpu, pVCpu->cpum.GstCtx.cs.Sel, (RTGCPTR)pVCpu->cpum.GstCtx.rip, pVCpu->cpum.GstCtx.rsp, pVCpu->cpum.GstCtx.eflags.Bits.u1IF, pVCpu->cpum.GstCtx.eflags.Bits.u2IOPL, (uint32_t)pVCpu->cpum.GstCtx.cr0, (uint32_t)pVCpu->cpum.GstCtx.cr4, (uint32_t)pVCpu->cpum.GstCtx.msrEFER));
    426420            else
    427                 Log(("NEMR%d-CPU%d: %04x:%08x ESP=%08X IF=%d IOPL=%d CR0=%x CR4=%x EFER=%x\n", cpl, pVCpu->idCpu, pCtx->cs.Sel,          pCtx->eip, pCtx->esp, pCtx->eflags.Bits.u1IF, pCtx->eflags.Bits.u2IOPL, (uint32_t)pCtx->cr0, (uint32_t)pCtx->cr4, (uint32_t)pCtx->msrEFER));
     421                Log(("NEMR%d-CPU%d: %04x:%08x ESP=%08X IF=%d IOPL=%d CR0=%x CR4=%x EFER=%x\n", cpl, pVCpu->idCpu, pVCpu->cpum.GstCtx.cs.Sel,          pVCpu->cpum.GstCtx.eip, pVCpu->cpum.GstCtx.esp, pVCpu->cpum.GstCtx.eflags.Bits.u1IF, pVCpu->cpum.GstCtx.eflags.Bits.u2IOPL, (uint32_t)pVCpu->cpum.GstCtx.cr0, (uint32_t)pVCpu->cpum.GstCtx.cr4, (uint32_t)pVCpu->cpum.GstCtx.msrEFER));
    428422        }
    429423#endif /* LOG_ENABLED */
    … …  
    464458            break;
    465459
    466         rcStrict = emR3NemHandleRC(pVM, pVCpu, pCtx, VBOXSTRICTRC_TODO(rcStrict));
     460        rcStrict = emR3NemHandleRC(pVM, pVCpu, VBOXSTRICTRC_TODO(rcStrict));
    467461        if (rcStrict != VINF_SUCCESS)
    468462            break;
    … …  
    494488     *       status over import errors.
    495489     */
    496     if (pCtx->fExtrn)
    497     {
    498         int rcImport = NEMImportStateOnDemand(pVCpu, pCtx, pCtx->fExtrn);
     490    if (pVCpu->cpum.GstCtx.fExtrn)
     491    {
     492        int rcImport = NEMImportStateOnDemand(pVCpu, &pVCpu->cpum.GstCtx, pVCpu->cpum.GstCtx.fExtrn);
    499493        AssertReturn(RT_SUCCESS(rcImport) || RT_FAILURE_NP(rcStrict), rcImport);
    500494    }

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

    r72488 r72634  
    6161*   Internal Functions                                                                                                           *
    6262*********************************************************************************************************************************/
    63 static int      emR3RawForcedActions(PVM pVM, PVMCPU pVCpu, PCPUMCTX pCtx);
     63static int      emR3RawHandleRC(PVM pVM, PVMCPU pVCpu, int rc);
     64static int      emR3RawForcedActions(PVM pVM, PVMCPU pVCpu);
    6465DECLINLINE(int) emR3RawExecuteInstruction(PVM pVM, PVMCPU pVCpu, const char *pszPrefix, int rcGC = VINF_SUCCESS);
    6566static int      emR3RawGuestTrap(PVM pVM, PVMCPU pVCpu);
    66 static int      emR3RawPatchTrap(PVM pVM, PVMCPU pVCpu, PCPUMCTX pCtx, int gcret);
     67static int      emR3RawPatchTrap(PVM pVM, PVMCPU pVCpu, int gcret);
    6768static int      emR3RawPrivileged(PVM pVM, PVMCPU pVCpu);
    6869static int      emR3RawExecuteIOInstruction(PVM pVM, PVMCPU pVCpu);
    6970static int      emR3RawRingSwitch(PVM pVM, PVMCPU pVCpu);
     71static int      emR3RawUpdateForceFlag(PVM pVM, PVMCPU pVCpu, int rc);
    7072
    7173#define EMHANDLERC_WITH_PATM
    … …  
    124126{
    125127    int         rc;
    126     PCPUMCTX    pCtx = pVCpu->em.s.pCtx;
    127128    Assert(pVCpu->em.s.enmState == EMSTATE_DEBUG_HYPER);
    128     Log(("emR3RawResumeHyper: cs:eip=%RTsel:%RGr efl=%RGr\n", pCtx->cs.Sel, pCtx->eip, pCtx->eflags));
     129    Log(("emR3RawResumeHyper: cs:eip=%RTsel:%RGr efl=%RGr\n", pVCpu->cpum.GstCtx.cs.Sel, pVCpu->cpum.GstCtx.eip, pVCpu->cpum.GstCtx.eflags));
    129130
    130131    /*
    … …  
    134135    CPUMSetHyperEFlags(pVCpu, CPUMGetHyperEFlags(pVCpu) | X86_EFL_RF);
    135136    rc = VMMR3ResumeHyper(pVM, pVCpu);
    136     Log(("emR3RawResumeHyper: cs:eip=%RTsel:%RGr efl=%RGr - returned from GC with rc=%Rrc\n", pCtx->cs.Sel, pCtx->eip, pCtx->eflags, rc));
     137    Log(("emR3RawResumeHyper: cs:eip=%RTsel:%RGr efl=%RGr - returned from GC with rc=%Rrc\n", pVCpu->cpum.GstCtx.cs.Sel, pVCpu->cpum.GstCtx.eip, pVCpu->cpum.GstCtx.eflags, rc));
    137138    rc = CPUMRawLeave(pVCpu, rc);
    138139    VMCPU_FF_CLEAR(pVCpu, VMCPU_FF_RESUME_GUEST_MASK);
    … …  
    142143     */
    143144    rc = VBOXSTRICTRC_TODO(emR3HighPriorityPostForcedActions(pVM, pVCpu, rc));
    144     rc = emR3RawHandleRC(pVM, pVCpu, pCtx, rc);
    145     rc = emR3RawUpdateForceFlag(pVM, pVCpu, pCtx, rc);
     145    rc = emR3RawHandleRC(pVM, pVCpu, rc);
     146    rc = emR3RawUpdateForceFlag(pVM, pVCpu, rc);
    146147    return rc;
    147148}
    … …  
    161162           || pVCpu->em.s.enmState == EMSTATE_DEBUG_GUEST_REM);
    162163    int         rc;
    163     PCPUMCTX    pCtx   = pVCpu->em.s.pCtx;
    164164    bool        fGuest = pVCpu->em.s.enmState != EMSTATE_DEBUG_HYPER;
    165165#ifndef DEBUG_sander
    … …  
    175175            ||  VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_HIGH_PRIORITY_PRE_RAW_MASK))
    176176        {
    177             rc = emR3RawForcedActions(pVM, pVCpu, pCtx);
     177            rc = emR3RawForcedActions(pVM, pVCpu);
    178178            VBOXVMM_EM_FF_RAW_RET(pVCpu, rc);
    179179            if (rc != VINF_SUCCESS)
    … …  
    222222     */
    223223    rc = VBOXSTRICTRC_TODO(emR3HighPriorityPostForcedActions(pVM, pVCpu, rc));
    224     rc = emR3RawHandleRC(pVM, pVCpu, pCtx, rc);
    225     rc = emR3RawUpdateForceFlag(pVM, pVCpu, pCtx, rc);
     224    rc = emR3RawHandleRC(pVM, pVCpu, rc);
     225    rc = emR3RawUpdateForceFlag(pVM, pVCpu, rc);
    226226    return rc;
    227227}
    … …  
    273273#endif
    274274{
    275     PCPUMCTX pCtx = pVCpu->em.s.pCtx;
    276275    int      rc;
    277276
    … …  
    293292     * to allow us execute the code in REM.
    294293     */
    295     if (PATMIsPatchGCAddr(pVM, pCtx->eip))
    296     {
    297         Log(("emR3RawExecuteInstruction: In patch block. eip=%RRv\n", (RTRCPTR)pCtx->eip));
     294    if (PATMIsPatchGCAddr(pVM, pVCpu->cpum.GstCtx.eip))
     295    {
     296        Log(("emR3RawExecuteInstruction: In patch block. eip=%RRv\n", (RTRCPTR)pVCpu->cpum.GstCtx.eip));
    298297
    299298        RTGCPTR uNewEip;
    300         rc = PATMR3HandleTrap(pVM, pCtx, pCtx->eip, &uNewEip);
     299        rc = PATMR3HandleTrap(pVM, &pVCpu->cpum.GstCtx, pVCpu->cpum.GstCtx.eip, &uNewEip);
    301300        switch (rc)
    302301        {
    … …  
    307306            case VINF_SUCCESS:
    308307                Log(("emR3RawExecuteInstruction: Executing instruction starting at new address %RGv IF=%d VMIF=%x\n",
    309                      uNewEip, pCtx->eflags.Bits.u1IF, pVCpu->em.s.pPatmGCState->uVMFlags));
    310                 pCtx->eip = uNewEip;
    311                 Assert(pCtx->eip);
    312 
    313                 if (pCtx->eflags.Bits.u1IF)
     308                     uNewEip, pVCpu->cpum.GstCtx.eflags.Bits.u1IF, pVCpu->em.s.pPatmGCState->uVMFlags));
     309                pVCpu->cpum.GstCtx.eip = uNewEip;
     310                Assert(pVCpu->cpum.GstCtx.eip);
     311
     312                if (pVCpu->cpum.GstCtx.eflags.Bits.u1IF)
    314313                {
    315314                    /*
    … …  
    331330            case VINF_PATCH_EMULATE_INSTR:
    332331                Log(("emR3RawExecuteInstruction: Emulate patched instruction at %RGv IF=%d VMIF=%x\n",
    333                      uNewEip, pCtx->eflags.Bits.u1IF, pVCpu->em.s.pPatmGCState->uVMFlags));
    334                 pCtx->eip = uNewEip;
     332                     uNewEip, pVCpu->cpum.GstCtx.eflags.Bits.u1IF, pVCpu->em.s.pPatmGCState->uVMFlags));
     333                pVCpu->cpum.GstCtx.eip = uNewEip;
    335334                return emR3RawExecuteInstruction(pVM, pVCpu, "PATCHIR");
    336335
    … …  
    340339            case VERR_PATCH_DISABLED:
    341340                Log(("emR3RawExecuteInstruction: Disabled patch -> new eip %RGv IF=%d VMIF=%x\n",
    342                      uNewEip, pCtx->eflags.Bits.u1IF, pVCpu->em.s.pPatmGCState->uVMFlags));
    343                 pCtx->eip = uNewEip;
    344                 if (pCtx->eflags.Bits.u1IF)
     341                     uNewEip, pVCpu->cpum.GstCtx.eflags.Bits.u1IF, pVCpu->em.s.pPatmGCState->uVMFlags));
     342                pVCpu->cpum.GstCtx.eip = uNewEip;
     343                if (pVCpu->cpum.GstCtx.eflags.Bits.u1IF)
    345344                {
    346345                    /*
    … …  
    369368#define VBOX_WITH_FIRST_IEM_STEP_B
    370369#if defined(VBOX_WITH_FIRST_IEM_STEP_B) || !defined(VBOX_WITH_REM)
    371     Log(("EMINS: %04x:%RGv RSP=%RGv\n", pCtx->cs.Sel, (RTGCPTR)pCtx->rip, (RTGCPTR)pCtx->rsp));
     370    Log(("EMINS: %04x:%RGv RSP=%RGv\n", pVCpu->cpum.GstCtx.cs.Sel, (RTGCPTR)pVCpu->cpum.GstCtx.rip, (RTGCPTR)pVCpu->cpum.GstCtx.rsp));
    372371    STAM_PROFILE_START(&pVCpu->em.s.StatIEMEmu, a);
    373372    rc = VBOXSTRICTRC_TODO(IEMExecOne(pVCpu));
    … …  
    385384        STAM_PROFILE_START(&pVCpu->em.s.StatREMEmu, b);
    386385# ifndef VBOX_WITH_FIRST_IEM_STEP_B
    387         Log(("EMINS[rem]: %04x:%RGv RSP=%RGv\n", pCtx->cs.Sel, (RTGCPTR)pCtx->rip, (RTGCPTR)pCtx->rsp));
     386        Log(("EMINS[rem]: %04x:%RGv RSP=%RGv\n", pVCpu->cpum.GstCtx.cs.Sel, (RTGCPTR)pVCpu->cpum.GstCtx.rip, (RTGCPTR)pVCpu->cpum.GstCtx.rsp));
    388387//# elif defined(DEBUG_bird)
    389388//        AssertFailed();
    … …  
    457456static int emR3RawGuestTrap(PVM pVM, PVMCPU pVCpu)
    458457{
    459     PCPUMCTX pCtx = pVCpu->em.s.pCtx;
    460 
    461458    /*
    462459     * Get the trap info.
    … …  
    484481    uint32_t uCpl = CPUMGetGuestCPL(pVCpu);
    485482    if (    uCpl == 0
    486         &&  PATMIsPatchGCAddr(pVM, pCtx->eip))
    487     {
    488         LogFlow(("emR3RawGuestTrap: trap %#x in patch code; eip=%08x\n", u8TrapNo, pCtx->eip));
    489         return emR3RawPatchTrap(pVM, pVCpu, pCtx, rc);
     483        &&  PATMIsPatchGCAddr(pVM, pVCpu->cpum.GstCtx.eip))
     484    {
     485        LogFlow(("emR3RawGuestTrap: trap %#x in patch code; eip=%08x\n", u8TrapNo, pVCpu->cpum.GstCtx.eip));
     486        return emR3RawPatchTrap(pVM, pVCpu, rc);
    490487    }
    491488#endif
    … …  
    512509                                   ? TRPM_TRAP_HAS_ERRORCODE
    513510                                   : TRPM_TRAP_NO_ERRORCODE;
    514             rc = TRPMForwardTrap(pVCpu, CPUMCTX2CORE(pCtx), u8TrapNo, uErrorCode, enmError, TRPM_TRAP, -1);
     511            rc = TRPMForwardTrap(pVCpu, CPUMCTX2CORE(&pVCpu->cpum.GstCtx), u8TrapNo, uErrorCode, enmError, TRPM_TRAP, -1);
    515512            if (rc == VINF_SUCCESS /* Don't use RT_SUCCESS */)
    516513            {
    … …  
    526523     */
    527524    /** @todo move this up before the dispatching? */
    528     if (    (pCtx->ss.Sel & X86_SEL_RPL) <= 1
    529         &&  !pCtx->eflags.Bits.u1VM)
    530     {
    531         Assert(!PATMIsPatchGCAddr(pVM, pCtx->eip));
    532         CSAMR3CheckCodeEx(pVM, pCtx, pCtx->eip);
     525    if (    (pVCpu->cpum.GstCtx.ss.Sel & X86_SEL_RPL) <= 1
     526        &&  !pVCpu->cpum.GstCtx.eflags.Bits.u1VM)
     527    {
     528        Assert(!PATMIsPatchGCAddr(pVM, pVCpu->cpum.GstCtx.eip));
     529        CSAMR3CheckCodeEx(pVM, &pVCpu->cpum.GstCtx, pVCpu->cpum.GstCtx.eip);
    533530    }
    534531
    … …  
    542539         */
    543540        DISCPUSTATE cpu;
    544         rc = CPUMR3DisasmInstrCPU(pVM, pVCpu, pCtx, pCtx->rip, &cpu, "Guest Trap (#UD): ");
     541        rc = CPUMR3DisasmInstrCPU(pVM, pVCpu, &pVCpu->cpum.GstCtx, pVCpu->cpum.GstCtx.rip, &cpu, "Guest Trap (#UD): ");
    545542        if (    RT_SUCCESS(rc)
    546543            && (cpu.pCurInstr->uOpcode == OP_MONITOR || cpu.pCurInstr->uOpcode == OP_MWAIT))
    … …  
    553550                AssertRC(rc);
    554551
    555                 rc = VBOXSTRICTRC_TODO(EMInterpretInstructionDisasState(pVCpu, &cpu, CPUMCTX2CORE(pCtx), 0, EMCODETYPE_SUPERVISOR));
     552                rc = VBOXSTRICTRC_TODO(EMInterpretInstructionDisasState(pVCpu, &cpu, CPUMCTX2CORE(&pVCpu->cpum.GstCtx),
     553                                                                        0, EMCODETYPE_SUPERVISOR));
    556554                if (RT_SUCCESS(rc))
    557555                    return rc;
    … …  
    568566         *        I/O access. We can easily handle those in RC.  */
    569567        DISCPUSTATE cpu;
    570         rc = CPUMR3DisasmInstrCPU(pVM, pVCpu, pCtx, pCtx->rip, &cpu, "Guest Trap: ");
     568        rc = CPUMR3DisasmInstrCPU(pVM, pVCpu, &pVCpu->cpum.GstCtx, pVCpu->cpum.GstCtx.rip, &cpu, "Guest Trap: ");
    571569        if (    RT_SUCCESS(rc)
    572570            &&  (cpu.pCurInstr->fOpType & DISOPTYPE_PORTIO))
    … …  
    591589    int rc2 = PGMGstGetPage(pVCpu, uCR2, &fFlags, &GCPhys);
    592590    Log(("emR3RawGuestTrap: cs:eip=%04x:%08x: trap=%02x err=%08x cr2=%08x cr0=%08x%s: Phys=%RGp fFlags=%08llx %s %s %s%s rc2=%d\n",
    593          pCtx->cs.Sel, pCtx->eip, u8TrapNo, uErrorCode, uCR2, (uint32_t)pCtx->cr0,
     591         pVCpu->cpum.GstCtx.cs.Sel, pVCpu->cpum.GstCtx.eip, u8TrapNo, uErrorCode, uCR2, (uint32_t)pVCpu->cpum.GstCtx.cr0,
    594592         (enmType == TRPM_SOFTWARE_INT) ? " software" : "",  GCPhys, fFlags,
    595593         fFlags & X86_PTE_P  ? "P " : "NP", fFlags & X86_PTE_US ? "U"  : "S",
    … …  
    602600     */
    603601    if (u8TrapNo == 14 /* #PG */)
    604         pCtx->cr2 = uCR2;
     602        pVCpu->cpum.GstCtx.cr2 = uCR2;
    605603
    606604    return VINF_EM_RESCHEDULE_REM;
    … …  
    620618    int         rc;
    621619    DISCPUSTATE Cpu;
    622     PCPUMCTX    pCtx = pVCpu->em.s.pCtx;
    623620
    624621    /*
    625622     * sysenter, syscall & callgate
    626623     */
    627     rc = CPUMR3DisasmInstrCPU(pVM, pVCpu, pCtx, pCtx->rip, &Cpu, "RSWITCH: ");
     624    rc = CPUMR3DisasmInstrCPU(pVM, pVCpu, &pVCpu->cpum.GstCtx, pVCpu->cpum.GstCtx.rip, &Cpu, "RSWITCH: ");
    628625    if (RT_SUCCESS(rc))
    629626    {
    630627        if (Cpu.pCurInstr->uOpcode == OP_SYSENTER)
    631628        {
    632             if (pCtx->SysEnter.cs != 0)
     629            if (pVCpu->cpum.GstCtx.SysEnter.cs != 0)
    633630            {
    634                 rc = PATMR3InstallPatch(pVM, SELMToFlat(pVM, DISSELREG_CS, CPUMCTX2CORE(pCtx), pCtx->eip),
     631                rc = PATMR3InstallPatch(pVM, SELMToFlat(pVM, DISSELREG_CS, CPUMCTX2CORE(&pVCpu->cpum.GstCtx), pVCpu->cpum.GstCtx.eip),
    635632                                        CPUMGetGuestCodeBits(pVCpu) == 32 ? PATMFL_CODE32 : 0);
    636633                if (RT_SUCCESS(rc))
    … …  
    674671 * @param   pVM     The cross context VM structure.
    675672 * @param   pVCpu   The cross context virtual CPU structure.
    676  * @param   pCtx    Pointer to the guest CPU context.
    677673 * @param   gcret   GC return code.
    678674 */
    679 static int emR3RawPatchTrap(PVM pVM, PVMCPU pVCpu, PCPUMCTX pCtx, int gcret)
     675static int emR3RawPatchTrap(PVM pVM, PVMCPU pVCpu, int gcret)
    680676{
    681677    uint8_t         u8TrapNo;
    … …  
    685681    RTGCUINTPTR     uCR2;
    686682
    687     Assert(PATMIsPatchGCAddr(pVM, pCtx->eip));
     683    Assert(PATMIsPatchGCAddr(pVM, pVCpu->cpum.GstCtx.eip));
    688684
    689685    if (gcret == VINF_PATM_PATCH_INT3)
    … …  
    723719
    724720        DISCPUSTATE Cpu;
    725         rc = CPUMR3DisasmInstrCPU(pVM, pVCpu, pCtx, pCtx->eip, &Cpu, "Patch code: ");
     721        rc = CPUMR3DisasmInstrCPU(pVM, pVCpu, &pVCpu->cpum.GstCtx, pVCpu->cpum.GstCtx.eip, &Cpu, "Patch code: ");
    726722        if (    RT_SUCCESS(rc)
    727723            &&  Cpu.pCurInstr->uOpcode == OP_IRET)
    … …  
    730726
    731727            /* Iret crashes are bad as we have already changed the flags on the stack */
    732             rc  = PGMPhysSimpleReadGCPtr(pVCpu, &eip,     pCtx->esp, 4);
    733             rc |= PGMPhysSimpleReadGCPtr(pVCpu, &selCS,   pCtx->esp+4, 4);
    734             rc |= PGMPhysSimpleReadGCPtr(pVCpu, &uEFlags, pCtx->esp+8, 4);
     728            rc  = PGMPhysSimpleReadGCPtr(pVCpu, &eip,     pVCpu->cpum.GstCtx.esp, 4);
     729            rc |= PGMPhysSimpleReadGCPtr(pVCpu, &selCS,   pVCpu->cpum.GstCtx.esp+4, 4);
     730            rc |= PGMPhysSimpleReadGCPtr(pVCpu, &uEFlags, pVCpu->cpum.GstCtx.esp+8, 4);
    735731            if (rc == VINF_SUCCESS)
    736732            {
    … …  
    740736                    uint32_t selSS, esp;
    741737
    742                     rc |= PGMPhysSimpleReadGCPtr(pVCpu, &esp,     pCtx->esp + 12, 4);
    743                     rc |= PGMPhysSimpleReadGCPtr(pVCpu, &selSS,   pCtx->esp + 16, 4);
     738                    rc |= PGMPhysSimpleReadGCPtr(pVCpu, &esp,     pVCpu->cpum.GstCtx.esp + 12, 4);
     739                    rc |= PGMPhysSimpleReadGCPtr(pVCpu, &selSS,   pVCpu->cpum.GstCtx.esp + 16, 4);
    744740
    745741                    if (uEFlags & X86_EFL_VM)
    746742                    {
    747743                        uint32_t selDS, selES, selFS, selGS;
    748                         rc  = PGMPhysSimpleReadGCPtr(pVCpu, &selES,   pCtx->esp + 20, 4);
    749                         rc |= PGMPhysSimpleReadGCPtr(pVCpu, &selDS,   pCtx->esp + 24, 4);
    750                         rc |= PGMPhysSimpleReadGCPtr(pVCpu, &selFS,   pCtx->esp + 28, 4);
    751                         rc |= PGMPhysSimpleReadGCPtr(pVCpu, &selGS,   pCtx->esp + 32, 4);
     744                        rc  = PGMPhysSimpleReadGCPtr(pVCpu, &selES,   pVCpu->cpum.GstCtx.esp + 20, 4);
     745                        rc |= PGMPhysSimpleReadGCPtr(pVCpu, &selDS,   pVCpu->cpum.GstCtx.esp + 24, 4);
     746                        rc |= PGMPhysSimpleReadGCPtr(pVCpu, &selFS,   pVCpu->cpum.GstCtx.esp + 28, 4);
     747                        rc |= PGMPhysSimpleReadGCPtr(pVCpu, &selGS,   pVCpu->cpum.GstCtx.esp + 32, 4);
    752748                        if (rc == VINF_SUCCESS)
    753749                        {
    … …  
    765761#endif /* LOG_ENABLED */
    766762        Log(("emR3RawPatchTrap: in patch: eip=%08x: trap=%02x err=%08x cr2=%08x cr0=%08x\n",
    767              pCtx->eip, u8TrapNo, uErrorCode, uCR2, (uint32_t)pCtx->cr0));
     763             pVCpu->cpum.GstCtx.eip, u8TrapNo, uErrorCode, uCR2, (uint32_t)pVCpu->cpum.GstCtx.cr0));
    768764
    769765        RTGCPTR uNewEip;
    770         rc = PATMR3HandleTrap(pVM, pCtx, pCtx->eip, &uNewEip);
     766        rc = PATMR3HandleTrap(pVM, &pVCpu->cpum.GstCtx, pVCpu->cpum.GstCtx.eip, &uNewEip);
    771767        switch (rc)
    772768        {
    … …  
    781777                    Log(("emR3RawPatchTrap: Virtual IF flag disabled!!\n"));
    782778
    783                 pCtx->eip = uNewEip;
    784                 AssertRelease(pCtx->eip);
    785 
    786                 if (pCtx->eflags.Bits.u1IF)
     779                pVCpu->cpum.GstCtx.eip = uNewEip;
     780                AssertRelease(pVCpu->cpum.GstCtx.eip);
     781
     782                if (pVCpu->cpum.GstCtx.eflags.Bits.u1IF)
    787783                {
    788784                    /* Windows XP lets irets fault intentionally and then takes action based on the opcode; an
    … …  
    790786                     */
    791787                    if (    u8TrapNo == X86_XCPT_GP
    792                         &&  PATMIsInt3Patch(pVM, pCtx->eip, NULL, NULL))
     788                        &&  PATMIsInt3Patch(pVM, pVCpu->cpum.GstCtx.eip, NULL, NULL))
    793789                    {
    794790                        /** @todo move to PATMR3HandleTrap */
    795                         Log(("Possible Windows XP iret fault at %08RX32\n", pCtx->eip));
    796                         PATMR3RemovePatch(pVM, pCtx->eip);
     791                        Log(("Possible Windows XP iret fault at %08RX32\n", pVCpu->cpum.GstCtx.eip));
     792                        PATMR3RemovePatch(pVM, pVCpu->cpum.GstCtx.eip);
    797793                    }
    798794
    … …  
    812808            case VINF_PATCH_EMULATE_INSTR:
    813809                Log(("emR3RawPatchTrap: Emulate patched instruction at %RGv IF=%d VMIF=%x\n",
    814                      uNewEip, pCtx->eflags.Bits.u1IF, pVCpu->em.s.pPatmGCState->uVMFlags));
    815                 pCtx->eip = uNewEip;
    816                 AssertRelease(pCtx->eip);
     810                     uNewEip, pVCpu->cpum.GstCtx.eflags.Bits.u1IF, pVCpu->em.s.pPatmGCState->uVMFlags));
     811                pVCpu->cpum.GstCtx.eip = uNewEip;
     812                AssertRelease(pVCpu->cpum.GstCtx.eip);
    817813                return emR3RawExecuteInstruction(pVM, pVCpu, "PATCHEMUL: ");
    818814
    … …  
    823819                if (!(pVCpu->em.s.pPatmGCState->uVMFlags & X86_EFL_IF))
    824820                    Log(("emR3RawPatchTrap: Virtual IF flag disabled!!\n"));
    825                 pCtx->eip = uNewEip;
    826                 AssertRelease(pCtx->eip);
    827 
    828                 if (pCtx->eflags.Bits.u1IF)
     821                pVCpu->cpum.GstCtx.eip = uNewEip;
     822                AssertRelease(pVCpu->cpum.GstCtx.eip);
     823
     824                if (pVCpu->cpum.GstCtx.eflags.Bits.u1IF)
    829825                {
    830826                    /*
    … …  
    861857static int emR3RawPrivileged(PVM pVM, PVMCPU pVCpu)
    862858{
    863     PCPUMCTX    pCtx = pVCpu->em.s.pCtx;
    864 
    865     Assert(!pCtx->eflags.Bits.u1VM);
     859    Assert(!pVCpu->cpum.GstCtx.eflags.Bits.u1VM);
    866860
    867861    if (PATMIsEnabled(pVM))
    … …  
    870864         * Check if in patch code.
    871865         */
    872         if (PATMR3IsInsidePatchJump(pVM, pCtx->eip, NULL))
     866        if (PATMR3IsInsidePatchJump(pVM, pVCpu->cpum.GstCtx.eip, NULL))
    873867        {
    874868#ifdef LOG_ENABLED
    875869            DBGFR3_INFO_LOG(pVM, pVCpu, "cpumguest", "PRIV");
    876870#endif
    877             AssertMsgFailed(("FATAL ERROR: executing random instruction inside generated patch jump %08x\n", pCtx->eip));
     871            AssertMsgFailed(("FATAL ERROR: executing random instruction inside generated patch jump %08x\n", pVCpu->cpum.GstCtx.eip));
    878872            return VERR_EM_RAW_PATCH_CONFLICT;
    879873        }
    880         if (   (pCtx->ss.Sel & X86_SEL_RPL) == 0
    881             && !pCtx->eflags.Bits.u1VM
    882             && !PATMIsPatchGCAddr(pVM, pCtx->eip))
    883         {
    884             int rc = PATMR3InstallPatch(pVM, SELMToFlat(pVM, DISSELREG_CS, CPUMCTX2CORE(pCtx), pCtx->eip),
     874        if (   (pVCpu->cpum.GstCtx.ss.Sel & X86_SEL_RPL) == 0
     875            && !pVCpu->cpum.GstCtx.eflags.Bits.u1VM
     876            && !PATMIsPatchGCAddr(pVM, pVCpu->cpum.GstCtx.eip))
     877        {
     878            int rc = PATMR3InstallPatch(pVM, SELMToFlat(pVM, DISSELREG_CS, CPUMCTX2CORE(&pVCpu->cpum.GstCtx), pVCpu->cpum.GstCtx.eip),
    885879                                        CPUMGetGuestCodeBits(pVCpu) == 32 ? PATMFL_CODE32 : 0);
    886880            if (RT_SUCCESS(rc))
    … …  
    896890
    897891#ifdef LOG_ENABLED
    898     if (!PATMIsPatchGCAddr(pVM, pCtx->eip))
     892    if (!PATMIsPatchGCAddr(pVM, pVCpu->cpum.GstCtx.eip))
    899893    {
    900894        DBGFR3_INFO_LOG(pVM, pVCpu, "cpumguest", "PRIV");
    … …  
    909903    int         rc;
    910904
    911     rc = CPUMR3DisasmInstrCPU(pVM, pVCpu, pCtx, pCtx->rip, &Cpu, "PRIV: ");
     905    rc = CPUMR3DisasmInstrCPU(pVM, pVCpu, &pVCpu->cpum.GstCtx, pVCpu->cpum.GstCtx.rip, &Cpu, "PRIV: ");
    912906    if (RT_SUCCESS(rc))
    913907    {
    … …  
    924918            case OP_CLI:
    925919                STAM_COUNTER_INC(&pStats->StatCli);
    926                 emR3RecordCli(pVM, pVCpu, pCtx->rip);
     920                emR3RecordCli(pVM, pVCpu, pVCpu->cpum.GstCtx.rip);
    927921                break;
    928922            case OP_STI:
    … …  
    988982        }
    989983#endif /* VBOX_WITH_STATISTICS */
    990         if (    (pCtx->ss.Sel & X86_SEL_RPL) == 0
    991             &&  !pCtx->eflags.Bits.u1VM
     984        if (    (pVCpu->cpum.GstCtx.ss.Sel & X86_SEL_RPL) == 0
     985            &&  !pVCpu->cpum.GstCtx.eflags.Bits.u1VM
    992986            &&  CPUMGetGuestCodeBits(pVCpu) == 32)
    993987        {
    … …  
    996990            {
    997991                case OP_CLI:
    998                     pCtx->eflags.u32 &= ~X86_EFL_IF;
     992                    pVCpu->cpum.GstCtx.eflags.u32 &= ~X86_EFL_IF;
    999993                    Assert(Cpu.cbInstr == 1);
    1000                     pCtx->rip += Cpu.cbInstr;
     994                    pVCpu->cpum.GstCtx.rip += Cpu.cbInstr;
    1001995                    STAM_PROFILE_STOP(&pVCpu->em.s.StatPrivEmu, a);
    1002996                    return VINF_EM_RESCHEDULE_REM; /* must go to the recompiler now! */
    1003997
    1004998                case OP_STI:
    1005                     pCtx->eflags.u32 |= X86_EFL_IF;
    1006                     EMSetInhibitInterruptsPC(pVCpu, pCtx->rip + Cpu.cbInstr);
     999                    pVCpu->cpum.GstCtx.eflags.u32 |= X86_EFL_IF;
     1000                    EMSetInhibitInterruptsPC(pVCpu, pVCpu->cpum.GstCtx.rip + Cpu.cbInstr);
    10071001                    Assert(Cpu.cbInstr == 1);
    1008                     pCtx->rip += Cpu.cbInstr;
     1002                    pVCpu->cpum.GstCtx.rip += Cpu.cbInstr;
    10091003                    STAM_PROFILE_STOP(&pVCpu->em.s.StatPrivEmu, a);
    10101004                    return VINF_SUCCESS;
    10111005
    10121006                case OP_HLT:
    1013                     if (PATMIsPatchGCAddr(pVM, pCtx->eip))
     1007                    if (PATMIsPatchGCAddr(pVM, pVCpu->cpum.GstCtx.eip))
    10141008                    {
    10151009                        PATMTRANSSTATE  enmState;
    1016                         RTGCPTR         pOrgInstrGC = PATMR3PatchToGCPtr(pVM, pCtx->eip, &enmState);
     1010                        RTGCPTR         pOrgInstrGC = PATMR3PatchToGCPtr(pVM, pVCpu->cpum.GstCtx.eip, &enmState);
    10171011
    10181012                        if (enmState == PATMTRANS_OVERWRITTEN)
    … …  
    10211015                            Assert(rc == VERR_PATCH_DISABLED);
    10221016                            /* Conflict detected, patch disabled */
    1023                             Log(("emR3RawPrivileged: detected conflict -> disabled patch at %08RX32\n", pCtx->eip));
     1017                            Log(("emR3RawPrivileged: detected conflict -> disabled patch at %08RX32\n", pVCpu->cpum.GstCtx.eip));
    10241018
    10251019                            enmState = PATMTRANS_SAFE;
    … …  
    10271021
    10281022                        /* The translation had better be successful. Otherwise we can't recover. */
    1029                         AssertReleaseMsg(pOrgInstrGC && enmState != PATMTRANS_OVERWRITTEN, ("Unable to translate instruction address at %08RX32\n", pCtx->eip));
     1023                        AssertReleaseMsg(pOrgInstrGC && enmState != PATMTRANS_OVERWRITTEN, ("Unable to translate instruction address at %08RX32\n", pVCpu->cpum.GstCtx.eip));
    10301024                        if (enmState != PATMTRANS_OVERWRITTEN)
    1031                             pCtx->eip = pOrgInstrGC;
     1025                            pVCpu->cpum.GstCtx.eip = pOrgInstrGC;
    10321026                    }
    10331027                    /* no break; we could just return VINF_EM_HALT here */
    … …  
    10371031                case OP_MOV_DR:
    10381032#ifdef LOG_ENABLED
    1039                     if (PATMIsPatchGCAddr(pVM, pCtx->eip))
     1033                    if (PATMIsPatchGCAddr(pVM, pVCpu->cpum.GstCtx.eip))
    10401034                    {
    10411035                        DBGFR3_INFO_LOG(pVM, pVCpu, "cpumguest", "PRIV");
    … …  
    10441038#endif
    10451039
    1046                     rc = VBOXSTRICTRC_TODO(EMInterpretInstructionDisasState(pVCpu, &Cpu, CPUMCTX2CORE(pCtx), 0, EMCODETYPE_SUPERVISOR));
     1040                    rc = VBOXSTRICTRC_TODO(EMInterpretInstructionDisasState(pVCpu, &Cpu, CPUMCTX2CORE(&pVCpu->cpum.GstCtx),
     1041                                                                            0, EMCODETYPE_SUPERVISOR));
    10471042                    if (RT_SUCCESS(rc))
    10481043                    {
    … …  
    10561051                             * us to go to the recompiler.
    10571052                             */
    1058                             if (   PATMIsPatchGCAddr(pVM, pCtx->rip)
    1059                                 && (pCtx->cr0 & (X86_CR0_WP|X86_CR0_PG|X86_CR0_PE)) != (X86_CR0_WP|X86_CR0_PG|X86_CR0_PE))
     1053                            if (   PATMIsPatchGCAddr(pVM, pVCpu->cpum.GstCtx.rip)
     1054                                && (pVCpu->cpum.GstCtx.cr0 & (X86_CR0_WP|X86_CR0_PG|X86_CR0_PE)) != (X86_CR0_WP|X86_CR0_PG|X86_CR0_PE))
    10601055                            {
    10611056                                PATMTRANSSTATE  enmState;
    1062                                 RTGCPTR         pOrgInstrGC = PATMR3PatchToGCPtr(pVM, pCtx->rip, &enmState);
    1063 
    1064                                 Log(("Force recompiler switch due to cr0 (%RGp) update rip=%RGv -> %RGv (enmState=%d)\n", pCtx->cr0, pCtx->rip, pOrgInstrGC, enmState));
     1057                                RTGCPTR         pOrgInstrGC = PATMR3PatchToGCPtr(pVM, pVCpu->cpum.GstCtx.rip, &enmState);
     1058
     1059                                Log(("Force recompiler switch due to cr0 (%RGp) update rip=%RGv -> %RGv (enmState=%d)\n", pVCpu->cpum.GstCtx.cr0, pVCpu->cpum.GstCtx.rip, pOrgInstrGC, enmState));
    10651060                                if (enmState == PATMTRANS_OVERWRITTEN)
    10661061                                {
    … …  
    10681063                                    Assert(rc == VERR_PATCH_DISABLED);
    10691064                                    /* Conflict detected, patch disabled */
    1070                                     Log(("emR3RawPrivileged: detected conflict -> disabled patch at %RGv\n", (RTGCPTR)pCtx->rip));
     1065                                    Log(("emR3RawPrivileged: detected conflict -> disabled patch at %RGv\n", (RTGCPTR)pVCpu->cpum.GstCtx.rip));
    10711066                                    enmState = PATMTRANS_SAFE;
    10721067                                }
    10731068                                /* The translation had better be successful. Otherwise we can't recover. */
    1074                                 AssertReleaseMsg(pOrgInstrGC && enmState != PATMTRANS_OVERWRITTEN, ("Unable to translate instruction address at %RGv\n", (RTGCPTR)pCtx->rip));
     1069                                AssertReleaseMsg(pOrgInstrGC && enmState != PATMTRANS_OVERWRITTEN, ("Unable to translate instruction address at %RGv\n", (RTGCPTR)pVCpu->cpum.GstCtx.rip));
    10751070                                if (enmState != PATMTRANS_OVERWRITTEN)
    1076                                     pCtx->rip = pOrgInstrGC;
     1071                                    pVCpu->cpum.GstCtx.rip = pOrgInstrGC;
    10771072                            }
    10781073
    … …  
    10891084    }
    10901085
    1091     if (PATMIsPatchGCAddr(pVM, pCtx->eip))
    1092         return emR3RawPatchTrap(pVM, pVCpu, pCtx, VINF_PATM_PATCH_TRAP_GP);
     1086    if (PATMIsPatchGCAddr(pVM, pVCpu->cpum.GstCtx.eip))
     1087        return emR3RawPatchTrap(pVM, pVCpu, VINF_PATM_PATCH_TRAP_GP);
    10931088
    10941089    return emR3RawExecuteInstruction(pVM, pVCpu, "PRIV");
    … …  
    11111106 * @param   pVM     The cross context VM structure.
    11121107 * @param   pVCpu   The cross context virtual CPU structure.
    1113  * @param   pCtx    Pointer to the guest CPU context.
    11141108 * @param   rc      The result code.
    11151109 */
    1116 int emR3RawUpdateForceFlag(PVM pVM, PVMCPU pVCpu, PCPUMCTX pCtx, int rc)
     1110static int emR3RawUpdateForceFlag(PVM pVM, PVMCPU pVCpu, int rc)
    11171111{
    1118     if (PATMIsPatchGCAddr(pVM, pCtx->eip)) /** @todo check cs selector base/type */
     1112    if (PATMIsPatchGCAddr(pVM, pVCpu->cpum.GstCtx.eip)) /** @todo check cs selector base/type */
    11191113    {
    11201114        /* ignore reschedule attempts. */
    … …  
    11451139VMMR3_INT_DECL(int) EMR3CheckRawForcedActions(PVM pVM, PVMCPU pVCpu)
    11461140{
    1147     int rc = emR3RawForcedActions(pVM, pVCpu, pVCpu->em.s.pCtx);
     1141    int rc = emR3RawForcedActions(pVM, pVCpu);
    11481142    VBOXVMM_EM_FF_RAW_RET(pVCpu, rc);
    11491143    return rc;
    … …  
    11601154 * @param   pVM         The cross context VM structure.
    11611155 * @param   pVCpu       The cross context virtual CPU structure.
    1162  * @param   pCtx        Pointer to the guest CPU context.
    11631156 */
    1164 static int emR3RawForcedActions(PVM pVM, PVMCPU pVCpu, PCPUMCTX pCtx)
     1157static int emR3RawForcedActions(PVM pVM, PVMCPU pVCpu)
    11651158{
    11661159    /*
    … …  
    11931186            && CSAMIsEnabled(pVM))
    11941187        {
    1195             int rc = PGMSyncCR3(pVCpu, pCtx->cr0, pCtx->cr3, pCtx->cr4, VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_PGM_SYNC_CR3));
     1188            int rc = PGMSyncCR3(pVCpu, pVCpu->cpum.GstCtx.cr0, pVCpu->cpum.GstCtx.cr3, pVCpu->cpum.GstCtx.cr4, VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_PGM_SYNC_CR3));
    11961189            if (RT_FAILURE(rc))
    11971190                return rc;
    … …  
    12191212    {
    12201213        Assert(pVCpu->em.s.enmState != EMSTATE_WAIT_SIPI);
    1221         int rc = PGMSyncCR3(pVCpu, pCtx->cr0, pCtx->cr3, pCtx->cr4, VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_PGM_SYNC_CR3));
     1214        int rc = PGMSyncCR3(pVCpu, pVCpu->cpum.GstCtx.cr0, pVCpu->cpum.GstCtx.cr3, pVCpu->cpum.GstCtx.cr4, VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_PGM_SYNC_CR3));
    12221215        if (RT_FAILURE(rc))
    12231216            return rc == VERR_PGM_NO_HYPERVISOR_ADDRESS ? VINF_EM_RESCHEDULE_REM : rc;
    … …  
    12271220        /* Prefetch pages for EIP and ESP. */
    12281221        /** @todo This is rather expensive. Should investigate if it really helps at all. */
    1229         rc = PGMPrefetchPage(pVCpu, SELMToFlat(pVM, DISSELREG_CS, CPUMCTX2CORE(pCtx), pCtx->rip));
     1222        rc = PGMPrefetchPage(pVCpu, SELMToFlat(pVM, DISSELREG_CS, CPUMCTX2CORE(&pVCpu->cpum.GstCtx), pVCpu->cpum.GstCtx.rip));
    12301223        if (rc == VINF_SUCCESS)
    1231             rc = PGMPrefetchPage(pVCpu, SELMToFlat(pVM, DISSELREG_SS, CPUMCTX2CORE(pCtx), pCtx->rsp));
     1224            rc = PGMPrefetchPage(pVCpu, SELMToFlat(pVM, DISSELREG_SS, CPUMCTX2CORE(&pVCpu->cpum.GstCtx), pVCpu->cpum.GstCtx.rsp));
    12321225        if (rc != VINF_SUCCESS)
    12331226        {
    … …  
    12371230                return rc;
    12381231            }
    1239             rc = PGMSyncCR3(pVCpu, pCtx->cr0, pCtx->cr3, pCtx->cr4, VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_PGM_SYNC_CR3));
     1232            rc = PGMSyncCR3(pVCpu, pVCpu->cpum.GstCtx.cr0, pVCpu->cpum.GstCtx.cr3, pVCpu->cpum.GstCtx.cr4, VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_PGM_SYNC_CR3));
    12401233            if (RT_FAILURE(rc))
    12411234                return rc;
    … …  
    12881281
    12891282    int      rc = VERR_IPE_UNINITIALIZED_STATUS;
    1290     PCPUMCTX pCtx = pVCpu->em.s.pCtx;
    1291     LogFlow(("emR3RawExecute: (cs:eip=%04x:%08x)\n", pCtx->cs.Sel, pCtx->eip));
     1283    LogFlow(("emR3RawExecute: (cs:eip=%04x:%08x)\n", pVCpu->cpum.GstCtx.cs.Sel, pVCpu->cpum.GstCtx.eip));
    12921284    pVCpu->em.s.fForceRAW = false;
    12931285    *pfFFDone = false;
    … …  
    13081300         */
    13091301#ifdef VBOX_STRICT
    1310         Assert(pCtx->eflags.Bits.u1VM || (pCtx->ss.Sel & X86_SEL_RPL) == 3 || (pCtx->ss.Sel & X86_SEL_RPL) == 0
    1311                || (EMIsRawRing1Enabled(pVM) && (pCtx->ss.Sel & X86_SEL_RPL) == 1));
    1312         AssertMsg(   (pCtx->eflags.u32 & X86_EFL_IF)
    1313                   || PATMShouldUseRawMode(pVM, (RTGCPTR)pCtx->eip),
    1314                   ("Tried to execute code with IF at EIP=%08x!\n", pCtx->eip));
     1302        Assert(pVCpu->cpum.GstCtx.eflags.Bits.u1VM || (pVCpu->cpum.GstCtx.ss.Sel & X86_SEL_RPL) == 3 || (pVCpu->cpum.GstCtx.ss.Sel & X86_SEL_RPL) == 0
     1303               || (EMIsRawRing1Enabled(pVM) && (pVCpu->cpum.GstCtx.ss.Sel & X86_SEL_RPL) == 1));
     1304        AssertMsg(   (pVCpu->cpum.GstCtx.eflags.u32 & X86_EFL_IF)
     1305                  || PATMShouldUseRawMode(pVM, (RTGCPTR)pVCpu->cpum.GstCtx.eip),
     1306                  ("Tried to execute code with IF at EIP=%08x!\n", pVCpu->cpum.GstCtx.eip));
    13151307        if (    !VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_PGM_SYNC_CR3 | VMCPU_FF_PGM_SYNC_CR3_NON_GLOBAL)
    13161308            &&  PGMMapHasConflicts(pVM))
    … …  
    13281320            ||  VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_HIGH_PRIORITY_PRE_RAW_MASK))
    13291321        {
    1330             rc = emR3RawForcedActions(pVM, pVCpu, pCtx);
     1322            rc = emR3RawForcedActions(pVM, pVCpu);
    13311323            VBOXVMM_EM_FF_RAW_RET(pVCpu, rc);
    13321324            if (rc != VINF_SUCCESS)
    … …  
    13491341         * Scan code before executing it. Don't bother with user mode or V86 code
    13501342         */
    1351         if (    (pCtx->ss.Sel & X86_SEL_RPL) <= 1
    1352             &&  !pCtx->eflags.Bits.u1VM
    1353             && !PATMIsPatchGCAddr(pVM, pCtx->eip))
     1343        if (    (pVCpu->cpum.GstCtx.ss.Sel & X86_SEL_RPL) <= 1
     1344            &&  !pVCpu->cpum.GstCtx.eflags.Bits.u1VM
     1345            && !PATMIsPatchGCAddr(pVM, pVCpu->cpum.GstCtx.eip))
    13541346        {
    13551347            STAM_PROFILE_ADV_SUSPEND(&pVCpu->em.s.StatRAWEntry, b);
    1356             CSAMR3CheckCodeEx(pVM, pCtx, pCtx->eip);
     1348            CSAMR3CheckCodeEx(pVM, &pVCpu->cpum.GstCtx, pVCpu->cpum.GstCtx.eip);
    13571349            STAM_PROFILE_ADV_RESUME(&pVCpu->em.s.StatRAWEntry, b);
    13581350            if (    VM_FF_IS_PENDING(pVM, VM_FF_HIGH_PRIORITY_PRE_RAW_MASK)
    13591351                ||  VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_HIGH_PRIORITY_PRE_RAW_MASK))
    13601352            {
    1361                 rc = emR3RawForcedActions(pVM, pVCpu, pCtx);
     1353                rc = emR3RawForcedActions(pVM, pVCpu);
    13621354                VBOXVMM_EM_FF_RAW_RET(pVCpu, rc);
    13631355                if (rc != VINF_SUCCESS)
    … …  
    13741366         */
    13751367        PPATMGCSTATE pGCState = PATMR3QueryGCStateHC(pVM);
    1376         if (pCtx->eflags.Bits.u1VM)
    1377             Log(("RV86: %04x:%08x IF=%d VMFlags=%x\n", pCtx->cs.Sel, pCtx->eip, pCtx->eflags.Bits.u1IF, pGCState->uVMFlags));
    1378         else if ((pCtx->ss.Sel & X86_SEL_RPL) == 1)
     1368        if (pVCpu->cpum.GstCtx.eflags.Bits.u1VM)
     1369            Log(("RV86: %04x:%08x IF=%d VMFlags=%x\n", pVCpu->cpum.GstCtx.cs.Sel, pVCpu->cpum.GstCtx.eip, pVCpu->cpum.GstCtx.eflags.Bits.u1IF, pGCState->uVMFlags));
     1370        else if ((pVCpu->cpum.GstCtx.ss.Sel & X86_SEL_RPL) == 1)
    13791371            Log(("RR0: %x:%08x ESP=%x:%08x EFL=%x IF=%d/%d VMFlags=%x PIF=%d CPL=%d (Scanned=%d)\n",
    1380                  pCtx->cs.Sel, pCtx->eip, pCtx->ss.Sel, pCtx->esp, CPUMRawGetEFlags(pVCpu), !!(pGCState->uVMFlags & X86_EFL_IF), pCtx->eflags.Bits.u1IF,
    1381                  pGCState->uVMFlags, pGCState->fPIF, (pCtx->ss.Sel & X86_SEL_RPL), CSAMIsPageScanned(pVM, (RTGCPTR)pCtx->eip)));
     1372                 pVCpu->cpum.GstCtx.cs.Sel, pVCpu->cpum.GstCtx.eip, pVCpu->cpum.GstCtx.ss.Sel, pVCpu->cpum.GstCtx.esp, CPUMRawGetEFlags(pVCpu), !!(pGCState->uVMFlags & X86_EFL_IF), pVCpu->cpum.GstCtx.eflags.Bits.u1IF,
     1373                 pGCState->uVMFlags, pGCState->fPIF, (pVCpu->cpum.GstCtx.ss.Sel & X86_SEL_RPL), CSAMIsPageScanned(pVM, (RTGCPTR)pVCpu->cpum.GstCtx.eip)));
    13821374# ifdef VBOX_WITH_RAW_RING1
    1383         else if ((pCtx->ss.Sel & X86_SEL_RPL) == 2)
    1384             Log(("RR1: %x:%08x ESP=%x:%08x IF=%d VMFlags=%x CPL=%x\n", pCtx->cs.Sel, pCtx->eip, pCtx->ss.Sel, pCtx->esp, pCtx->eflags.Bits.u1IF, pGCState->uVMFlags, (pCtx->ss.Sel & X86_SEL_RPL)));
     1375        else if ((pVCpu->cpum.GstCtx.ss.Sel & X86_SEL_RPL) == 2)
     1376            Log(("RR1: %x:%08x ESP=%x:%08x IF=%d VMFlags=%x CPL=%x\n", pVCpu->cpum.GstCtx.cs.Sel, pVCpu->cpum.GstCtx.eip, pVCpu->cpum.GstCtx.ss.Sel, pVCpu->cpum.GstCtx.esp, pVCpu->cpum.GstCtx.eflags.Bits.u1IF, pGCState->uVMFlags, (pVCpu->cpum.GstCtx.ss.Sel & X86_SEL_RPL)));
    13851377# endif
    1386         else if ((pCtx->ss.Sel & X86_SEL_RPL) == 3)
    1387             Log(("RR3: %x:%08x ESP=%x:%08x IF=%d VMFlags=%x\n", pCtx->cs.Sel, pCtx->eip, pCtx->ss.Sel, pCtx->esp, pCtx->eflags.Bits.u1IF, pGCState->uVMFlags));
     1378        else if ((pVCpu->cpum.GstCtx.ss.Sel & X86_SEL_RPL) == 3)
     1379            Log(("RR3: %x:%08x ESP=%x:%08x IF=%d VMFlags=%x\n", pVCpu->cpum.GstCtx.cs.Sel, pVCpu->cpum.GstCtx.eip, pVCpu->cpum.GstCtx.ss.Sel, pVCpu->cpum.GstCtx.esp, pVCpu->cpum.GstCtx.eflags.Bits.u1IF, pGCState->uVMFlags));
    13881380#endif /* LOG_ENABLED */
    13891381
    … …  
    13971389        {
    13981390            STAM_PROFILE_START(&pVCpu->em.s.StatRAWExec, c);
    1399             VBOXVMM_EM_RAW_RUN_PRE(pVCpu, pCtx);
     1391            VBOXVMM_EM_RAW_RUN_PRE(pVCpu, &pVCpu->cpum.GstCtx);
    14001392            rc = VMMR3RawRunGC(pVM, pVCpu);
    1401             VBOXVMM_EM_RAW_RUN_RET(pVCpu, pCtx, rc);
     1393            VBOXVMM_EM_RAW_RUN_RET(pVCpu, &pVCpu->cpum.GstCtx, rc);
    14021394            STAM_PROFILE_STOP(&pVCpu->em.s.StatRAWExec, c);
    14031395        }
    … …  
    14131405
    14141406        LogFlow(("RR%u-E: %08x ESP=%08x EFL=%x IF=%d/%d VMFlags=%x PIF=%d\n",
    1415                  (pCtx->ss.Sel & X86_SEL_RPL), pCtx->eip, pCtx->esp, CPUMRawGetEFlags(pVCpu),
    1416                  !!(pGCState->uVMFlags & X86_EFL_IF), pCtx->eflags.Bits.u1IF, pGCState->uVMFlags, pGCState->fPIF));
     1407                 (pVCpu->cpum.GstCtx.ss.Sel & X86_SEL_RPL), pVCpu->cpum.GstCtx.eip, pVCpu->cpum.GstCtx.esp, CPUMRawGetEFlags(pVCpu),
     1408                 !!(pGCState->uVMFlags & X86_EFL_IF), pVCpu->cpum.GstCtx.eflags.Bits.u1IF, pGCState->uVMFlags, pGCState->fPIF));
    14171409        LogFlow(("VMMR3RawRunGC returned %Rrc\n", rc));
    14181410
    … …  
    14501442
    14511443            default:
    1452                 if (PATMIsPatchGCAddr(pVM, pCtx->eip) && !(pCtx->eflags.u32 & X86_EFL_TF))
     1444                if (PATMIsPatchGCAddr(pVM, pVCpu->cpum.GstCtx.eip) && !(pVCpu->cpum.GstCtx.eflags.u32 & X86_EFL_TF))
    14531445                    LogIt(0, LOG_GROUP_PATM, ("Patch code interrupted at %RRv for reason %Rrc\n", (RTRCPTR)CPUMGetGuestEIP(pVCpu), rc));
    14541446                break;
    … …  
    14741466            break;
    14751467        }
    1476         rc = emR3RawHandleRC(pVM, pVCpu, pCtx, rc);
     1468        rc = emR3RawHandleRC(pVM, pVCpu, rc);
    14771469        if (rc != VINF_SUCCESS)
    14781470        {
    1479             rc = emR3RawUpdateForceFlag(pVM, pVCpu, pCtx, rc);
     1471            rc = emR3RawUpdateForceFlag(pVM, pVCpu, rc);
    14801472            if (rc != VINF_SUCCESS)
    14811473            {
    … …  
    14951487            ||  VMCPU_FF_IS_PENDING(pVCpu, ~VMCPU_FF_HIGH_PRIORITY_PRE_RAW_MASK))
    14961488        {
    1497             Assert(pCtx->eflags.Bits.u1VM || (pCtx->ss.Sel & X86_SEL_RPL) != (EMIsRawRing1Enabled(pVM) ? 2U : 1U));
     1489            Assert(pVCpu->cpum.GstCtx.eflags.Bits.u1VM || (pVCpu->cpum.GstCtx.ss.Sel & X86_SEL_RPL) != (EMIsRawRing1Enabled(pVM) ? 2U : 1U));
    14981490
    14991491            STAM_REL_PROFILE_ADV_SUSPEND(&pVCpu->em.s.StatRAWTotal, a);
    … …  
    15041496                &&  rc != VINF_EM_RESCHEDULE_RAW)
    15051497            {
    1506                 rc = emR3RawUpdateForceFlag(pVM, pVCpu, pCtx, rc);
     1498                rc = emR3RawUpdateForceFlag(pVM, pVCpu, rc);
    15071499                if (rc != VINF_SUCCESS)
    15081500                {

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

    r72575 r72634  
    364364
    365365
    366 VMMR3_INT_DECL(bool) NEMR3CanExecuteGuest(PVM pVM, PVMCPU pVCpu, PCPUMCTX pCtx)
     366VMMR3_INT_DECL(bool) NEMR3CanExecuteGuest(PVM pVM, PVMCPU pVCpu)
    367367{
    368368    Assert(VM_IS_NEM_ENABLED(pVM));
    369369#ifdef VBOX_WITH_NATIVE_NEM
    370     return nemR3NativeCanExecuteGuest(pVM, pVCpu, pCtx);
    371 #else
    372     NOREF(pVM); NOREF(pVCpu); NOREF(pCtx);
     370    return nemR3NativeCanExecuteGuest(pVM, pVCpu);
     371#else
     372    NOREF(pVM); NOREF(pVCpu);
    373373    return false;
    374374#endif

  • trunk/src/VBox/VMM/VMMR3/NEMR3Native-win.cpp

    r72555 r72634  
    22772277
    22782278
    2279 bool nemR3NativeCanExecuteGuest(PVM pVM, PVMCPU pVCpu, PCPUMCTX pCtx)
    2280 {
    2281     NOREF(pVM); NOREF(pVCpu); NOREF(pCtx);
     2279bool nemR3NativeCanExecuteGuest(PVM pVM, PVMCPU pVCpu)
     2280{
     2281    NOREF(pVM); NOREF(pVCpu);
    22822282    return true;
    22832283}

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

    r72580 r72634  
    2525
    2626/**
    27  * Process a subset of the raw-mode and hm return codes.
     27 * Process a subset of the raw-mode, HM and NEM return codes.
    2828 *
    2929 * Since we have to share this with raw-mode single stepping, this inline
    … …  
    3535 * @param   pVM     The cross context VM structure.
    3636 * @param   pVCpu   The cross context virtual CPU structure.
    37  * @param   pCtx    Pointer to the guest CPU context.
    3837 * @param   rc      The return code.
    3938 */
    4039#ifdef EMHANDLERC_WITH_PATM
    41 int emR3RawHandleRC(PVM pVM, PVMCPU pVCpu, PCPUMCTX pCtx, int rc)
     40int emR3RawHandleRC(PVM pVM, PVMCPU pVCpu, int rc)
    4241#elif defined(EMHANDLERC_WITH_HM) || defined(DOXYGEN_RUNNING)
    43 int emR3HmHandleRC(PVM pVM, PVMCPU pVCpu, PCPUMCTX pCtx, int rc)
     42int emR3HmHandleRC(PVM pVM, PVMCPU pVCpu, int rc)
    4443#elif defined(EMHANDLERC_WITH_NEM)
    45 int emR3NemHandleRC(PVM pVM, PVMCPU pVCpu, PCPUMCTX pCtx, int rc)
     44int emR3NemHandleRC(PVM pVM, PVMCPU pVCpu, int rc)
    4645#endif
    4746{
    48     NOREF(pCtx);
    49 
    5047    switch (rc)
    5148    {
    … …  
    7774             * Got a trap which needs dispatching.
    7875             */
    79             if (PATMR3IsInsidePatchJump(pVM, pCtx->eip, NULL))
     76            if (PATMR3IsInsidePatchJump(pVM, pVCpu->cpum.GstCtx.eip, NULL))
    8077            {
    8178                AssertReleaseMsgFailed(("FATAL ERROR: executing random instruction inside generated patch jump %08X\n", CPUMGetGuestEIP(pVCpu)));
    … …  
    9188        case VINF_PATM_PATCH_TRAP_PF:
    9289        case VINF_PATM_PATCH_INT3:
    93             rc = emR3RawPatchTrap(pVM, pVCpu, pCtx, rc);
     90            rc = emR3RawPatchTrap(pVM, pVCpu, rc);
    9491            break;
    9592
    9693        case VINF_PATM_DUPLICATE_FUNCTION:
    97             Assert(PATMIsPatchGCAddr(pVM, pCtx->eip));
    98             rc = PATMR3DuplicateFunctionRequest(pVM, pCtx);
     94            Assert(PATMIsPatchGCAddr(pVM, pVCpu->cpum.GstCtx.eip));
     95            rc = PATMR3DuplicateFunctionRequest(pVM, &pVCpu->cpum.GstCtx);
    9996            AssertRC(rc);
    10097            rc = VINF_SUCCESS;
    … …  
    118115         */
    119116        case VINF_PATM_HC_MMIO_PATCH_READ:
    120             rc = PATMR3InstallPatch(pVM, SELMToFlat(pVM, DISSELREG_CS, CPUMCTX2CORE(pCtx), pCtx->eip),
     117            rc = PATMR3InstallPatch(pVM, SELMToFlat(pVM, DISSELREG_CS, CPUMCTX2CORE(&pVCpu->cpum.GstCtx), pVCpu->cpum.GstCtx.eip),
    121118                                      PATMFL_MMIO_ACCESS
    122119                                    | (CPUMGetGuestCodeBits(pVCpu) == 32 ? PATMFL_CODE32 : 0));
    … …  
    167164        case VINF_PGM_CHANGE_MODE:
    168165            CPUM_ASSERT_NOT_EXTRN(pVCpu, CPUMCTX_EXTRN_CR0 | CPUMCTX_EXTRN_CR3 | CPUMCTX_EXTRN_CR4 | CPUMCTX_EXTRN_EFER);
    169             rc = PGMChangeMode(pVCpu, pCtx->cr0, pCtx->cr4, pCtx->msrEFER);
     166            rc = PGMChangeMode(pVCpu, pVCpu->cpum.GstCtx.cr0, pVCpu->cpum.GstCtx.cr4, pVCpu->cpum.GstCtx.msrEFER);
    170167            if (rc == VINF_SUCCESS)
    171168                rc = VINF_EM_RESCHEDULE;
    … …  
    188185        case VINF_EM_RAW_RING_SWITCH_INT:
    189186            Assert(TRPMHasTrap(pVCpu));
    190             Assert(!PATMIsPatchGCAddr(pVM, pCtx->eip));
     187            Assert(!PATMIsPatchGCAddr(pVM, pVCpu->cpum.GstCtx.eip));
    191188
    192189            if (TRPMHasTrap(pVCpu))
    … …  
    260257         */
    261258        case VINF_EM_RAW_EMULATE_IO_BLOCK:
    262             rc = HMR3EmulateIoBlock(pVM, pCtx);
     259            rc = HMR3EmulateIoBlock(pVM, &pVCpu->cpum.GstCtx);
    263260            break;
    264261
    265262        case VINF_EM_HM_PATCH_TPR_INSTR:
    266             rc = HMR3PatchTprInstr(pVM, pVCpu, pCtx);
     263            rc = HMR3PatchTprInstr(pVM, pVCpu, &pVCpu->cpum.GstCtx);
    267264            break;
    268265#endif
    … …  
    313310        case VINF_EM_RAW_IRET_TRAP:
    314311            /* We will not go to the recompiler if EIP points to patch code. */
    315             if (PATMIsPatchGCAddr(pVM, pCtx->eip))
     312            if (PATMIsPatchGCAddr(pVM, pVCpu->cpum.GstCtx.eip))
    316313            {
    317                 pCtx->eip = PATMR3PatchToGCPtr(pVM, (RTGCPTR)pCtx->eip, 0);
     314                pVCpu->cpum.GstCtx.eip = PATMR3PatchToGCPtr(pVM, (RTGCPTR)pVCpu->cpum.GstCtx.eip, 0);
    318315            }
    319316            LogFlow(("emR3RawHandleRC: %Rrc -> %Rrc\n", rc, VINF_EM_RESCHEDULE_REM));

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

    r72583 r72634  
    399399    RTR3PTR                 R3PtrPaddingNoRaw;
    400400#endif
    401 
    402     /** Pointer to the guest CPUM state. (R3 Ptr)
    403      * @deprecated Use pVCpu->cpum.GstCtx!  */
    404     R3PTRTYPE(PCPUMCTX)     pCtx;
    405 
     401    RTR3PTR                 R3PtrNullPadding; /**< Used to be pCtx. */
    406402#if GC_ARCH_BITS == 64
    407403    RTGCPTR                 aPadding1;
    … …  
    550546/** @} */
    551547
    552 int     emR3InitDbg(PVM pVM);
    553 
    554 int          emR3HmExecute(PVM pVM, PVMCPU pVCpu, bool *pfFFDone);
    555 VBOXSTRICTRC emR3NemExecute(PVM pVM, PVMCPU pVCpu, bool *pfFFDone);
    556 int          emR3RawExecute(PVM pVM, PVMCPU pVCpu, bool *pfFFDone);
    557 
    558 int     emR3RawHandleRC(PVM pVM, PVMCPU pVCpu, PCPUMCTX pCtx, int rc);
    559 int     emR3HmHandleRC(PVM pVM, PVMCPU pVCpu, PCPUMCTX pCtx, int rc);
    560 int     emR3NemHandleRC(PVM pVM, PVMCPU pVCpu, PCPUMCTX pCtx, int rc);
    561 
    562 EMSTATE emR3Reschedule(PVM pVM, PVMCPU pVCpu, PCPUMCTX pCtx);
    563 int     emR3ForcedActions(PVM pVM, PVMCPU pVCpu, int rc);
    564 VBOXSTRICTRC emR3HighPriorityPostForcedActions(PVM pVM, PVMCPU pVCpu, VBOXSTRICTRC rc);
    565 
    566 int     emR3RawUpdateForceFlag(PVM pVM, PVMCPU pVCpu, PCPUMCTX pCtx, int rc);
    567 int     emR3RawResumeHyper(PVM pVM, PVMCPU pVCpu);
    568 int     emR3RawStep(PVM pVM, PVMCPU pVCpu);
    569 
    570 VBOXSTRICTRC emR3NemSingleInstruction(PVM pVM, PVMCPU pVCpu, uint32_t fFlags);
    571 
    572 int     emR3SingleStepExecRem(PVM pVM, PVMCPU pVCpu, uint32_t cIterations);
    573 
    574 bool    emR3IsExecutionAllowed(PVM pVM, PVMCPU pVCpu);
    575 
    576 VBOXSTRICTRC emR3ExecutePendingIoPortWrite(PVM pVM, PVMCPU pVCpu);
    577 VBOXSTRICTRC emR3ExecutePendingIoPortRead(PVM pVM, PVMCPU pVCpu);
     548int             emR3InitDbg(PVM pVM);
     549
     550int             emR3HmExecute(PVM pVM, PVMCPU pVCpu, bool *pfFFDone);
     551VBOXSTRICTRC    emR3NemExecute(PVM pVM, PVMCPU pVCpu, bool *pfFFDone);
     552int             emR3RawExecute(PVM pVM, PVMCPU pVCpu, bool *pfFFDone);
     553
     554EMSTATE         emR3Reschedule(PVM pVM, PVMCPU pVCpu);
     555int             emR3ForcedActions(PVM pVM, PVMCPU pVCpu, int rc);
     556VBOXSTRICTRC    emR3HighPriorityPostForcedActions(PVM pVM, PVMCPU pVCpu, VBOXSTRICTRC rc);
     557
     558int             emR3RawResumeHyper(PVM pVM, PVMCPU pVCpu);
     559int             emR3RawStep(PVM pVM, PVMCPU pVCpu);
     560
     561VBOXSTRICTRC    emR3NemSingleInstruction(PVM pVM, PVMCPU pVCpu, uint32_t fFlags);
     562
     563int             emR3SingleStepExecRem(PVM pVM, PVMCPU pVCpu, uint32_t cIterations);
     564
     565bool            emR3IsExecutionAllowed(PVM pVM, PVMCPU pVCpu);
     566
     567VBOXSTRICTRC    emR3ExecutePendingIoPortWrite(PVM pVM, PVMCPU pVCpu);
     568VBOXSTRICTRC    emR3ExecutePendingIoPortRead(PVM pVM, PVMCPU pVCpu);
    578569
    579570RT_C_DECLS_END

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

    r72575 r72634  
    398398void    nemR3NativeResetCpu(PVMCPU pVCpu, bool fInitIpi);
    399399VBOXSTRICTRC    nemR3NativeRunGC(PVM pVM, PVMCPU pVCpu);
    400 bool            nemR3NativeCanExecuteGuest(PVM pVM, PVMCPU pVCpu, PCPUMCTX pCtx);
     400bool            nemR3NativeCanExecuteGuest(PVM pVM, PVMCPU pVCpu);
    401401bool            nemR3NativeSetSingleInstruction(PVM pVM, PVMCPU pVCpu, bool fEnable);
    402402void            nemR3NativeNotifyFF(PVM pVM, PVMCPU pVCpu, uint32_t fFlags);

  • trunk/src/VBox/VMM/testcase/tstVMStruct.h

    r72494 r72634  
    272272    GEN_CHECK_SIZE(EM);
    273273    GEN_CHECK_OFF(EM, offVM);
    274     GEN_CHECK_OFF(EMCPU, pCtx);
    275274    GEN_CHECK_OFF(EMCPU, enmState);
    276275    GEN_CHECK_OFF(EMCPU, fForceRAW);
Note: See TracChangeset for help on using the changeset viewer.

© 2025 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette