VirtualBox

Changeset 72496 in vbox


Ignore:
Timestamp:
Jun 10, 2018 5:21:36 PM (7 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
122981
Message:

IEM: Use pVCpu->cpum.s.GstCtx, avoid passing pCtx as a parameter or having it as a local variable.

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

Legend:

Unmodified
Added
Removed

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

    r72494 r72496  
    452452 */
    453453# define IEM_RETURN_SVM_VMEXIT(a_pVCpu, a_uExitCode, a_uExitInfo1, a_uExitInfo2) \
    454     do \
    455     { \
    456         return iemSvmVmexit((a_pVCpu), IEM_GET_CTX(a_pVCpu), (a_uExitCode), (a_uExitInfo1), (a_uExitInfo2)); \
    457     } while (0)
     454    do { return iemSvmVmexit((a_pVCpu), (a_uExitCode), (a_uExitInfo1), (a_uExitInfo2)); } while (0)
    458455
    459456/**
    … …  
    894891
    895892#ifdef VBOX_WITH_NESTED_HWVIRT_SVM
    896 IEM_STATIC VBOXSTRICTRC     iemSvmVmexit(PVMCPU pVCpu, PCPUMCTX pCtx, uint64_t uExitCode, uint64_t uExitInfo1,
    897                                          uint64_t uExitInfo2);
    898 IEM_STATIC VBOXSTRICTRC     iemHandleSvmEventIntercept(PVMCPU pVCpu, PCPUMCTX pCtx, uint8_t u8Vector, uint32_t fFlags,
    899                                                        uint32_t uErr, uint64_t uCr2);
     893IEM_STATIC VBOXSTRICTRC     iemSvmVmexit(PVMCPU pVCpu, uint64_t uExitCode, uint64_t uExitInfo1, uint64_t uExitInfo2);
     894IEM_STATIC VBOXSTRICTRC     iemHandleSvmEventIntercept(PVMCPU pVCpu, uint8_t u8Vector, uint32_t fFlags, uint32_t uErr, uint64_t uCr2);
    900895#endif
    901896
    … …  
    947942 *
    948943 * @returns CPU mode.
    949  * @param   pCtx        The register context for the CPU.
    950  */
    951 DECLINLINE(IEMMODE) iemCalcCpuMode(PCPUMCTX pCtx)
    952 {
    953     if (CPUMIsGuestIn64BitCodeEx(pCtx))
     944 * @param   pVCpu               The cross context virtual CPU structure of the
     945 *                              calling thread.
     946 */
     947DECLINLINE(IEMMODE) iemCalcCpuMode(PVMCPU pVCpu)
     948{
     949    if (CPUMIsGuestIn64BitCodeEx(&pVCpu->cpum.GstCtx))
    954950        return IEMMODE_64BIT;
    955     if (pCtx->cs.Attr.n.u1DefBig) /** @todo check if this is correct... */
     951    if (pVCpu->cpum.GstCtx.cs.Attr.n.u1DefBig) /** @todo check if this is correct... */
    956952        return IEMMODE_32BIT;
    957953    return IEMMODE_16BIT;
    … …  
    971967DECLINLINE(void) iemInitExec(PVMCPU pVCpu, bool fBypassHandlers)
    972968{
    973     PCPUMCTX const pCtx = IEM_GET_CTX(pVCpu);
    974 
    975     IEM_CTX_ASSERT(pCtx, IEM_CPUMCTX_EXTRN_MUST_MASK);
     969    IEM_CTX_ASSERT(pVCpu, IEM_CPUMCTX_EXTRN_MUST_MASK);
    976970    Assert(!VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_IEM));
    977971
    978972#if defined(VBOX_STRICT) && !defined(VBOX_WITH_RAW_MODE_NOT_R0)
    979     Assert(CPUMSELREG_ARE_HIDDEN_PARTS_VALID(pVCpu, &pCtx->cs));
    980     Assert(CPUMSELREG_ARE_HIDDEN_PARTS_VALID(pVCpu, &pCtx->ss));
    981     Assert(CPUMSELREG_ARE_HIDDEN_PARTS_VALID(pVCpu, &pCtx->es));
    982     Assert(CPUMSELREG_ARE_HIDDEN_PARTS_VALID(pVCpu, &pCtx->ds));
    983     Assert(CPUMSELREG_ARE_HIDDEN_PARTS_VALID(pVCpu, &pCtx->fs));
    984     Assert(CPUMSELREG_ARE_HIDDEN_PARTS_VALID(pVCpu, &pCtx->gs));
    985     Assert(CPUMSELREG_ARE_HIDDEN_PARTS_VALID(pVCpu, &pCtx->ldtr));
    986     Assert(CPUMSELREG_ARE_HIDDEN_PARTS_VALID(pVCpu, &pCtx->tr));
     973    Assert(CPUMSELREG_ARE_HIDDEN_PARTS_VALID(pVCpu, &pVCpu->cpum.GstCtx.cs));
     974    Assert(CPUMSELREG_ARE_HIDDEN_PARTS_VALID(pVCpu, &pVCpu->cpum.GstCtx.ss));
     975    Assert(CPUMSELREG_ARE_HIDDEN_PARTS_VALID(pVCpu, &pVCpu->cpum.GstCtx.es));
     976    Assert(CPUMSELREG_ARE_HIDDEN_PARTS_VALID(pVCpu, &pVCpu->cpum.GstCtx.ds));
     977    Assert(CPUMSELREG_ARE_HIDDEN_PARTS_VALID(pVCpu, &pVCpu->cpum.GstCtx.fs));
     978    Assert(CPUMSELREG_ARE_HIDDEN_PARTS_VALID(pVCpu, &pVCpu->cpum.GstCtx.gs));
     979    Assert(CPUMSELREG_ARE_HIDDEN_PARTS_VALID(pVCpu, &pVCpu->cpum.GstCtx.ldtr));
     980    Assert(CPUMSELREG_ARE_HIDDEN_PARTS_VALID(pVCpu, &pVCpu->cpum.GstCtx.tr));
    987981#endif
    988982
    … …  
    991985#endif
    992986    pVCpu->iem.s.uCpl               = CPUMGetGuestCPL(pVCpu);
    993     pVCpu->iem.s.enmCpuMode         = iemCalcCpuMode(pCtx);
     987    pVCpu->iem.s.enmCpuMode         = iemCalcCpuMode(pVCpu);
    994988#ifdef VBOX_STRICT
    995989    pVCpu->iem.s.enmDefAddrMode     = (IEMMODE)0xfe;
    … …  
    10261020#ifdef VBOX_WITH_RAW_MODE_NOT_R0
    10271021    pVCpu->iem.s.fInPatchCode       = pVCpu->iem.s.uCpl == 0
    1028                                && pCtx->cs.u64Base == 0
    1029                                && pCtx->cs.u32Limit == UINT32_MAX
    1030                                && PATMIsPatchGCAddr(pVCpu->CTX_SUFF(pVM), pCtx->eip);
     1022                               && pVCpu->cpum.GstCtx.cs.u64Base == 0
     1023                               && pVCpu->cpum.GstCtx.cs.u32Limit == UINT32_MAX
     1024                               && PATMIsPatchGCAddr(pVCpu->CTX_SUFF(pVM), pVCpu->cpum.GstCtx.eip);
    10311025    if (!pVCpu->iem.s.fInPatchCode)
    10321026        CPUMRawLeave(pVCpu, VINF_SUCCESS);
    … …  
    10461040IEM_STATIC void iemReInitExec(PVMCPU pVCpu)
    10471041{
    1048     PCPUMCTX const pCtx   = IEM_GET_CTX(pVCpu);
    1049     IEMMODE const enmMode = iemCalcCpuMode(pCtx);
     1042    IEMMODE const enmMode = iemCalcCpuMode(pVCpu);
    10501043    uint8_t const uCpl    = CPUMGetGuestCPL(pVCpu);
    10511044
    … …  
    11061099DECLINLINE(void) iemInitDecoder(PVMCPU pVCpu, bool fBypassHandlers)
    11071100{
    1108     PCPUMCTX const pCtx = IEM_GET_CTX(pVCpu);
    1109 
    1110     IEM_CTX_ASSERT(IEM_GET_CTX(pVCpu), IEM_CPUMCTX_EXTRN_MUST_MASK);
     1101    IEM_CTX_ASSERT(pVCpu, IEM_CPUMCTX_EXTRN_MUST_MASK);
    11111102    Assert(!VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_IEM));
    11121103
    11131104#if defined(VBOX_STRICT) && !defined(VBOX_WITH_RAW_MODE_NOT_R0)
    1114     Assert(CPUMSELREG_ARE_HIDDEN_PARTS_VALID(pVCpu, &pCtx->cs));
    1115     Assert(CPUMSELREG_ARE_HIDDEN_PARTS_VALID(pVCpu, &pCtx->ss));
    1116     Assert(CPUMSELREG_ARE_HIDDEN_PARTS_VALID(pVCpu, &pCtx->es));
    1117     Assert(CPUMSELREG_ARE_HIDDEN_PARTS_VALID(pVCpu, &pCtx->ds));
    1118     Assert(CPUMSELREG_ARE_HIDDEN_PARTS_VALID(pVCpu, &pCtx->fs));
    1119     Assert(CPUMSELREG_ARE_HIDDEN_PARTS_VALID(pVCpu, &pCtx->gs));
    1120     Assert(CPUMSELREG_ARE_HIDDEN_PARTS_VALID(pVCpu, &pCtx->ldtr));
    1121     Assert(CPUMSELREG_ARE_HIDDEN_PARTS_VALID(pVCpu, &pCtx->tr));
     1105    Assert(CPUMSELREG_ARE_HIDDEN_PARTS_VALID(pVCpu, &pVCpu->cpum.GstCtx.cs));
     1106    Assert(CPUMSELREG_ARE_HIDDEN_PARTS_VALID(pVCpu, &pVCpu->cpum.GstCtx.ss));
     1107    Assert(CPUMSELREG_ARE_HIDDEN_PARTS_VALID(pVCpu, &pVCpu->cpum.GstCtx.es));
     1108    Assert(CPUMSELREG_ARE_HIDDEN_PARTS_VALID(pVCpu, &pVCpu->cpum.GstCtx.ds));
     1109    Assert(CPUMSELREG_ARE_HIDDEN_PARTS_VALID(pVCpu, &pVCpu->cpum.GstCtx.fs));
     1110    Assert(CPUMSELREG_ARE_HIDDEN_PARTS_VALID(pVCpu, &pVCpu->cpum.GstCtx.gs));
     1111    Assert(CPUMSELREG_ARE_HIDDEN_PARTS_VALID(pVCpu, &pVCpu->cpum.GstCtx.ldtr));
     1112    Assert(CPUMSELREG_ARE_HIDDEN_PARTS_VALID(pVCpu, &pVCpu->cpum.GstCtx.tr));
    11221113#endif
    11231114
    … …  
    11261117#endif
    11271118    pVCpu->iem.s.uCpl               = CPUMGetGuestCPL(pVCpu);
    1128     IEMMODE enmMode = iemCalcCpuMode(pCtx);
     1119    IEMMODE enmMode = iemCalcCpuMode(pVCpu);
    11291120    pVCpu->iem.s.enmCpuMode         = enmMode;
    11301121    pVCpu->iem.s.enmDefAddrMode     = enmMode;  /** @todo check if this is correct... */
    … …  
    11681159#ifdef VBOX_WITH_RAW_MODE_NOT_R0
    11691160    pVCpu->iem.s.fInPatchCode       = pVCpu->iem.s.uCpl == 0
    1170                                && pCtx->cs.u64Base == 0
    1171                                && pCtx->cs.u32Limit == UINT32_MAX
    1172                                && PATMIsPatchGCAddr(pVCpu->CTX_SUFF(pVM), pCtx->eip);
     1161                               && pVCpu->cpum.GstCtx.cs.u64Base == 0
     1162                               && pVCpu->cpum.GstCtx.cs.u32Limit == UINT32_MAX
     1163                               && PATMIsPatchGCAddr(pVCpu->CTX_SUFF(pVM), pVCpu->cpum.GstCtx.eip);
    11731164    if (!pVCpu->iem.s.fInPatchCode)
    11741165        CPUMRawLeave(pVCpu, VINF_SUCCESS);
    … …  
    11791170    {
    11801171        case IEMMODE_64BIT:
    1181             RTTraceBufAddMsgF(pVCpu->CTX_SUFF(pVM)->CTX_SUFF(hTraceBuf), "I64/%u %08llx", pVCpu->iem.s.uCpl, pCtx->rip);
     1172            RTTraceBufAddMsgF(pVCpu->CTX_SUFF(pVM)->CTX_SUFF(hTraceBuf), "I64/%u %08llx", pVCpu->iem.s.uCpl, pVCpu->cpum.GstCtx.rip);
    11821173            break;
    11831174        case IEMMODE_32BIT:
    1184             RTTraceBufAddMsgF(pVCpu->CTX_SUFF(pVM)->CTX_SUFF(hTraceBuf), "I32/%u %04x:%08x", pVCpu->iem.s.uCpl, pCtx->cs.Sel, pCtx->eip);
     1175            RTTraceBufAddMsgF(pVCpu->CTX_SUFF(pVM)->CTX_SUFF(hTraceBuf), "I32/%u %04x:%08x", pVCpu->iem.s.uCpl, pVCpu->cpum.GstCtx.cs.Sel, pVCpu->cpum.GstCtx.eip);
    11851176            break;
    11861177        case IEMMODE_16BIT:
    1187             RTTraceBufAddMsgF(pVCpu->CTX_SUFF(pVM)->CTX_SUFF(hTraceBuf), "I16/%u %04x:%04x", pVCpu->iem.s.uCpl, pCtx->cs.Sel, pCtx->eip);
     1178            RTTraceBufAddMsgF(pVCpu->CTX_SUFF(pVM)->CTX_SUFF(hTraceBuf), "I16/%u %04x:%04x", pVCpu->iem.s.uCpl, pVCpu->cpum.GstCtx.cs.Sel, pVCpu->cpum.GstCtx.eip);
    11881179            break;
    11891180    }
    … …  
    12011192DECLINLINE(void) iemReInitDecoder(PVMCPU pVCpu)
    12021193{
    1203     PCPUMCTX const pCtx = IEM_GET_CTX(pVCpu);
    1204 
    12051194    Assert(!VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_IEM));
    12061195
    12071196#if defined(VBOX_STRICT) && !defined(VBOX_WITH_RAW_MODE_NOT_R0)
    1208     Assert(CPUMSELREG_ARE_HIDDEN_PARTS_VALID(pVCpu, &pCtx->cs));
    1209     Assert(CPUMSELREG_ARE_HIDDEN_PARTS_VALID(pVCpu, &pCtx->ss));
    1210     Assert(CPUMSELREG_ARE_HIDDEN_PARTS_VALID(pVCpu, &pCtx->es));
    1211     Assert(CPUMSELREG_ARE_HIDDEN_PARTS_VALID(pVCpu, &pCtx->ds));
    1212     Assert(CPUMSELREG_ARE_HIDDEN_PARTS_VALID(pVCpu, &pCtx->fs));
    1213     Assert(CPUMSELREG_ARE_HIDDEN_PARTS_VALID(pVCpu, &pCtx->gs));
    1214     Assert(CPUMSELREG_ARE_HIDDEN_PARTS_VALID(pVCpu, &pCtx->ldtr));
    1215     Assert(CPUMSELREG_ARE_HIDDEN_PARTS_VALID(pVCpu, &pCtx->tr));
     1197    Assert(CPUMSELREG_ARE_HIDDEN_PARTS_VALID(pVCpu, &pVCpu->cpum.GstCtx.cs));
     1198    Assert(CPUMSELREG_ARE_HIDDEN_PARTS_VALID(pVCpu, &pVCpu->cpum.GstCtx.ss));
     1199    Assert(CPUMSELREG_ARE_HIDDEN_PARTS_VALID(pVCpu, &pVCpu->cpum.GstCtx.es));
     1200    Assert(CPUMSELREG_ARE_HIDDEN_PARTS_VALID(pVCpu, &pVCpu->cpum.GstCtx.ds));
     1201    Assert(CPUMSELREG_ARE_HIDDEN_PARTS_VALID(pVCpu, &pVCpu->cpum.GstCtx.fs));
     1202    Assert(CPUMSELREG_ARE_HIDDEN_PARTS_VALID(pVCpu, &pVCpu->cpum.GstCtx.gs));
     1203    Assert(CPUMSELREG_ARE_HIDDEN_PARTS_VALID(pVCpu, &pVCpu->cpum.GstCtx.ldtr));
     1204    Assert(CPUMSELREG_ARE_HIDDEN_PARTS_VALID(pVCpu, &pVCpu->cpum.GstCtx.tr));
    12161205#endif
    12171206
    12181207    pVCpu->iem.s.uCpl               = CPUMGetGuestCPL(pVCpu);   /** @todo this should be updated during execution! */
    1219     IEMMODE enmMode = iemCalcCpuMode(pCtx);
     1208    IEMMODE enmMode = iemCalcCpuMode(pVCpu);
    12201209    pVCpu->iem.s.enmCpuMode         = enmMode;                  /** @todo this should be updated during execution! */
    12211210    pVCpu->iem.s.enmDefAddrMode     = enmMode;  /** @todo check if this is correct... */
    … …  
    12431232    if (pVCpu->iem.s.pbInstrBuf)
    12441233    {
    1245         uint64_t off = (pVCpu->iem.s.enmCpuMode == IEMMODE_64BIT ? pCtx->rip : pCtx->eip + (uint32_t)pCtx->cs.u64Base)
     1234        uint64_t off = (pVCpu->iem.s.enmCpuMode == IEMMODE_64BIT ? pVCpu->cpum.GstCtx.rip : pVCpu->cpum.GstCtx.eip + (uint32_t)pVCpu->cpum.GstCtx.cs.u64Base)
    12461235                     - pVCpu->iem.s.uInstrBufPc;
    12471236        if (off < pVCpu->iem.s.cbInstrBufTotal)
    … …  
    12841273    {
    12851274        pVCpu->iem.s.fInPatchCode   = pVCpu->iem.s.uCpl == 0
    1286                                && pCtx->cs.u64Base == 0
    1287                                && pCtx->cs.u32Limit == UINT32_MAX
    1288                                && PATMIsPatchGCAddr(pVCpu->CTX_SUFF(pVM), pCtx->eip);
     1275                               && pVCpu->cpum.GstCtx.cs.u64Base == 0
     1276                               && pVCpu->cpum.GstCtx.cs.u32Limit == UINT32_MAX
     1277                               && PATMIsPatchGCAddr(pVCpu->CTX_SUFF(pVM), pVCpu->cpum.GstCtx.eip);
    12891278        if (!pVCpu->iem.s.fInPatchCode)
    12901279            CPUMRawLeave(pVCpu, VINF_SUCCESS);
    … …  
    12961285    {
    12971286        case IEMMODE_64BIT:
    1298             RTTraceBufAddMsgF(pVCpu->CTX_SUFF(pVM)->CTX_SUFF(hTraceBuf), "I64/%u %08llx", pVCpu->iem.s.uCpl, pCtx->rip);
     1287            RTTraceBufAddMsgF(pVCpu->CTX_SUFF(pVM)->CTX_SUFF(hTraceBuf), "I64/%u %08llx", pVCpu->iem.s.uCpl, pVCpu->cpum.GstCtx.rip);
    12991288            break;
    13001289        case IEMMODE_32BIT:
    1301             RTTraceBufAddMsgF(pVCpu->CTX_SUFF(pVM)->CTX_SUFF(hTraceBuf), "I32/%u %04x:%08x", pVCpu->iem.s.uCpl, pCtx->cs.Sel, pCtx->eip);
     1290            RTTraceBufAddMsgF(pVCpu->CTX_SUFF(pVM)->CTX_SUFF(hTraceBuf), "I32/%u %04x:%08x", pVCpu->iem.s.uCpl, pVCpu->cpum.GstCtx.cs.Sel, pVCpu->cpum.GstCtx.eip);
    13021291            break;
    13031292        case IEMMODE_16BIT:
    1304             RTTraceBufAddMsgF(pVCpu->CTX_SUFF(pVM)->CTX_SUFF(hTraceBuf), "I16/%u %04x:%04x", pVCpu->iem.s.uCpl, pCtx->cs.Sel, pCtx->eip);
     1293            RTTraceBufAddMsgF(pVCpu->CTX_SUFF(pVM)->CTX_SUFF(hTraceBuf), "I16/%u %04x:%04x", pVCpu->iem.s.uCpl, pVCpu->cpum.GstCtx.cs.Sel, pVCpu->cpum.GstCtx.eip);
    13051294            break;
    13061295    }
    … …  
    13321321     * First translate CS:rIP to a physical address.
    13331322     */
    1334     PCPUMCTX    pCtx = IEM_GET_CTX(pVCpu);
    13351323    uint32_t    cbToTryRead;
    13361324    RTGCPTR     GCPtrPC;
    … …  
    13381326    {
    13391327        cbToTryRead = PAGE_SIZE;
    1340         GCPtrPC     = pCtx->rip;
     1328        GCPtrPC     = pVCpu->cpum.GstCtx.rip;
    13411329        if (IEM_IS_CANONICAL(GCPtrPC))
    13421330            cbToTryRead = PAGE_SIZE - (GCPtrPC & PAGE_OFFSET_MASK);
    … …  
    13461334    else
    13471335    {
    1348         uint32_t GCPtrPC32 = pCtx->eip;
    1349         AssertMsg(!(GCPtrPC32 & ~(uint32_t)UINT16_MAX) || pVCpu->iem.s.enmCpuMode == IEMMODE_32BIT, ("%04x:%RX64\n", pCtx->cs.Sel, pCtx->rip));
    1350         if (GCPtrPC32 <= pCtx->cs.u32Limit)
    1351             cbToTryRead = pCtx->cs.u32Limit - GCPtrPC32 + 1;
     1336        uint32_t GCPtrPC32 = pVCpu->cpum.GstCtx.eip;
     1337        AssertMsg(!(GCPtrPC32 & ~(uint32_t)UINT16_MAX) || pVCpu->iem.s.enmCpuMode == IEMMODE_32BIT, ("%04x:%RX64\n", pVCpu->cpum.GstCtx.cs.Sel, pVCpu->cpum.GstCtx.rip));
     1338        if (GCPtrPC32 <= pVCpu->cpum.GstCtx.cs.u32Limit)
     1339            cbToTryRead = pVCpu->cpum.GstCtx.cs.u32Limit - GCPtrPC32 + 1;
    13521340        else
    13531341            return iemRaiseSelectorBounds(pVCpu, X86_SREG_CS, IEM_ACCESS_INSTRUCTION);
    … …  
    13551343        else /* overflowed */
    13561344        {
    1357             Assert(GCPtrPC32 == 0); Assert(pCtx->cs.u32Limit == UINT32_MAX);
     1345            Assert(GCPtrPC32 == 0); Assert(pVCpu->cpum.GstCtx.cs.u32Limit == UINT32_MAX);
    13581346            cbToTryRead = UINT32_MAX;
    13591347        }
    1360         GCPtrPC = (uint32_t)pCtx->cs.u64Base + GCPtrPC32;
     1348        GCPtrPC = (uint32_t)pVCpu->cpum.GstCtx.cs.u64Base + GCPtrPC32;
    13611349        Assert(GCPtrPC <= UINT32_MAX);
    13621350    }
    … …  
    13901378        return iemRaisePageFault(pVCpu, GCPtrPC, IEM_ACCESS_INSTRUCTION, VERR_ACCESS_DENIED);
    13911379    }
    1392     if (!(fFlags & X86_PTE_PAE_NX) || !(pCtx->msrEFER & MSR_K6_EFER_NXE)) { /* likely */ }
     1380    if (!(fFlags & X86_PTE_PAE_NX) || !(pVCpu->cpum.GstCtx.msrEFER & MSR_K6_EFER_NXE)) { /* likely */ }
    13931381    else
    13941382    {
    … …  
    16561644         * end up in trouble and we need to do that first before faulting.
    16571645         */
    1658         PCPUMCTX pCtx = IEM_GET_CTX(pVCpu);
    16591646        RTGCPTR  GCPtrFirst;
    16601647        uint32_t cbMaxRead;
    16611648        if (pVCpu->iem.s.enmCpuMode == IEMMODE_64BIT)
    16621649        {
    1663             GCPtrFirst = pCtx->rip + (offBuf - (uint32_t)(int32_t)pVCpu->iem.s.offCurInstrStart);
     1650            GCPtrFirst = pVCpu->cpum.GstCtx.rip + (offBuf - (uint32_t)(int32_t)pVCpu->iem.s.offCurInstrStart);
    16641651            if (RT_LIKELY(IEM_IS_CANONICAL(GCPtrFirst)))
    16651652            { /* likely */ }
    … …  
    16701657        else
    16711658        {
    1672             GCPtrFirst = pCtx->eip + (offBuf - (uint32_t)(int32_t)pVCpu->iem.s.offCurInstrStart);
     1659            GCPtrFirst = pVCpu->cpum.GstCtx.eip + (offBuf - (uint32_t)(int32_t)pVCpu->iem.s.offCurInstrStart);
    16731660            Assert(!(GCPtrFirst & ~(uint32_t)UINT16_MAX) || pVCpu->iem.s.enmCpuMode == IEMMODE_32BIT);
    1674             if (RT_LIKELY((uint32_t)GCPtrFirst <= pCtx->cs.u32Limit))
     1661            if (RT_LIKELY((uint32_t)GCPtrFirst <= pVCpu->cpum.GstCtx.cs.u32Limit))
    16751662            { /* likely */ }
    16761663            else
    16771664                iemRaiseSelectorBoundsJmp(pVCpu, X86_SREG_CS, IEM_ACCESS_INSTRUCTION);
    1678             cbMaxRead = pCtx->cs.u32Limit - (uint32_t)GCPtrFirst + 1;
     1665            cbMaxRead = pVCpu->cpum.GstCtx.cs.u32Limit - (uint32_t)GCPtrFirst + 1;
    16791666            if (cbMaxRead != 0)
    16801667            { /* likely */ }
    … …  
    16821669            {
    16831670                /* Overflowed because address is 0 and limit is max. */
    1684                 Assert(GCPtrFirst == 0); Assert(pCtx->cs.u32Limit == UINT32_MAX);
     1671                Assert(GCPtrFirst == 0); Assert(pVCpu->cpum.GstCtx.cs.u32Limit == UINT32_MAX);
    16851672                cbMaxRead = X86_PAGE_SIZE;
    16861673            }
    1687             GCPtrFirst = (uint32_t)GCPtrFirst + (uint32_t)pCtx->cs.u64Base;
     1674            GCPtrFirst = (uint32_t)GCPtrFirst + (uint32_t)pVCpu->cpum.GstCtx.cs.u64Base;
    16881675            uint32_t cbMaxRead2 = X86_PAGE_SIZE - ((uint32_t)GCPtrFirst & X86_PAGE_OFFSET_MASK);
    16891676            if (cbMaxRead2 < cbMaxRead)
    … …  
    17091696            pVCpu->iem.s.CodeTlb.cTlbMisses++;
    17101697# ifdef VBOX_WITH_RAW_MODE_NOT_R0
    1711             if (PATMIsPatchGCAddr(pVCpu->CTX_SUFF(pVM), pCtx->eip))
     1698            if (PATMIsPatchGCAddr(pVCpu->CTX_SUFF(pVM), pVCpu->cpum.GstCtx.eip))
    17121699            {
    17131700                pTlbe->uTag             = uTag;
    … …  
    17471734                iemRaisePageFaultJmp(pVCpu, GCPtrFirst, IEM_ACCESS_INSTRUCTION, VERR_ACCESS_DENIED);
    17481735            }
    1749             if ((pTlbe->fFlagsAndPhysRev & IEMTLBE_F_PT_NO_EXEC) && (pCtx->msrEFER & MSR_K6_EFER_NXE))
     1736            if ((pTlbe->fFlagsAndPhysRev & IEMTLBE_F_PT_NO_EXEC) && (pVCpu->cpum.GstCtx.msrEFER & MSR_K6_EFER_NXE))
    17501737            {
    17511738                Log(("iemOpcodeFetchMoreBytes: %RGv - NX\n", GCPtrFirst));
    … …  
    19171904     * First translate CS:rIP to a physical address.
    19181905     */
    1919     PCPUMCTX    pCtx = IEM_GET_CTX(pVCpu);
    19201906    uint8_t     cbLeft = pVCpu->iem.s.cbOpcode - pVCpu->iem.s.offOpcode; Assert(cbLeft < cbMin);
    19211907    uint32_t    cbToTryRead;
    … …  
    19241910    {
    19251911        cbToTryRead = PAGE_SIZE;
    1926         GCPtrNext   = pCtx->rip + pVCpu->iem.s.cbOpcode;
     1912        GCPtrNext   = pVCpu->cpum.GstCtx.rip + pVCpu->iem.s.cbOpcode;
    19271913        if (!IEM_IS_CANONICAL(GCPtrNext))
    19281914            return iemRaiseGeneralProtectionFault0(pVCpu);
    … …  
    19301916    else
    19311917    {
    1932         uint32_t GCPtrNext32 = pCtx->eip;
     1918        uint32_t GCPtrNext32 = pVCpu->cpum.GstCtx.eip;
    19331919        Assert(!(GCPtrNext32 & ~(uint32_t)UINT16_MAX) || pVCpu->iem.s.enmCpuMode == IEMMODE_32BIT);
    19341920        GCPtrNext32 += pVCpu->iem.s.cbOpcode;
    1935         if (GCPtrNext32 > pCtx->cs.u32Limit)
     1921        if (GCPtrNext32 > pVCpu->cpum.GstCtx.cs.u32Limit)
    19361922            return iemRaiseSelectorBounds(pVCpu, X86_SREG_CS, IEM_ACCESS_INSTRUCTION);
    1937         cbToTryRead = pCtx->cs.u32Limit - GCPtrNext32 + 1;
     1923        cbToTryRead = pVCpu->cpum.GstCtx.cs.u32Limit - GCPtrNext32 + 1;
    19381924        if (!cbToTryRead) /* overflowed */
    19391925        {
    1940             Assert(GCPtrNext32 == 0); Assert(pCtx->cs.u32Limit == UINT32_MAX);
     1926            Assert(GCPtrNext32 == 0); Assert(pVCpu->cpum.GstCtx.cs.u32Limit == UINT32_MAX);
    19411927            cbToTryRead = UINT32_MAX;
    19421928            /** @todo check out wrapping around the code segment.  */
    … …  
    19441930        if (cbToTryRead < cbMin - cbLeft)
    19451931            return iemRaiseSelectorBounds(pVCpu, X86_SREG_CS, IEM_ACCESS_INSTRUCTION);
    1946         GCPtrNext = (uint32_t)pCtx->cs.u64Base + GCPtrNext32;
     1932        GCPtrNext = (uint32_t)pVCpu->cpum.GstCtx.cs.u64Base + GCPtrNext32;
    19471933    }
    19481934
    … …  
    19831969        return iemRaisePageFault(pVCpu, GCPtrNext, IEM_ACCESS_INSTRUCTION, VERR_ACCESS_DENIED);
    19841970    }
    1985     if ((fFlags & X86_PTE_PAE_NX) && (pCtx->msrEFER & MSR_K6_EFER_NXE))
     1971    if ((fFlags & X86_PTE_PAE_NX) && (pVCpu->cpum.GstCtx.msrEFER & MSR_K6_EFER_NXE))
    19861972    {
    19871973        Log(("iemOpcodeFetchMoreBytes: %RGv - NX\n", GCPtrNext));
    … …  
    33333319 * @param   pVCpu           The cross context virtual CPU structure of the
    33343320 *                          calling thread.
    3335  * @param   pCtx            The CPU context.
    33363321 * @param   NewSS           The new SS selctor.
    33373322 * @param   uCpl            The CPL to load the stack for.
    33383323 * @param   pDesc           Where to return the descriptor.
    33393324 */
    3340 IEM_STATIC VBOXSTRICTRC iemMiscValidateNewSS(PVMCPU pVCpu, PCCPUMCTX pCtx, RTSEL NewSS, uint8_t uCpl, PIEMSELDESC pDesc)
    3341 {
    3342     NOREF(pCtx);
    3343 
     3325IEM_STATIC VBOXSTRICTRC iemMiscValidateNewSS(PVMCPU pVCpu, RTSEL NewSS, uint8_t uCpl, PIEMSELDESC pDesc)
     3326{
    33443327    /* Null selectors are not allowed (we're not called for dispatching
    33453328       interrupts with SS=0 in long mode). */
    … …  
    34023385 *
    34033386 * @param   a_pVCpu The cross context virtual CPU structure of the calling thread.
    3404  * @param   a_pCtx  The CPU context.
    34053387 */
    34063388#ifdef VBOX_WITH_RAW_MODE_NOT_R0
    3407 # define IEMMISC_GET_EFL(a_pVCpu, a_pCtx) ( CPUMRawGetEFlags(a_pVCpu) )
     3389# define IEMMISC_GET_EFL(a_pVCpu)          ( CPUMRawGetEFlags(a_pVCpu) )
    34083390#else
    3409 # define IEMMISC_GET_EFL(a_pVCpu, a_pCtx) ( (a_pCtx)->eflags.u  )
     3391# define IEMMISC_GET_EFL(a_pVCpu)           ( (a_pVCpu)->cpum.GstCtx.eflags.u  )
    34103392#endif
    34113393
    … …  
    34143396 *
    34153397 * @param   a_pVCpu The cross context virtual CPU structure of the calling thread.
    3416  * @param   a_pCtx  The CPU context.
    34173398 * @param   a_fEfl  The new EFLAGS.
    34183399 */
    34193400#ifdef VBOX_WITH_RAW_MODE_NOT_R0
    3420 # define IEMMISC_SET_EFL(a_pVCpu, a_pCtx, a_fEfl) CPUMRawSetEFlags((a_pVCpu), a_fEfl)
     3401# define IEMMISC_SET_EFL(a_pVCpu, a_fEfl)  CPUMRawSetEFlags((a_pVCpu), a_fEfl)
    34213402#else
    3422 # define IEMMISC_SET_EFL(a_pVCpu, a_pCtx, a_fEfl) do { (a_pCtx)->eflags.u = (a_fEfl); } while (0)
     3403# define IEMMISC_SET_EFL(a_pVCpu, a_fEfl)   do { (a_pVCpu)->cpum.GstCtx.eflags.u = (a_fEfl); } while (0)
    34233404#endif
    34243405
    … …  
    34373418 * @returns VBox strict status code.
    34383419 * @param   pVCpu           The cross context virtual CPU structure of the calling thread.
    3439  * @param   pCtx            The CPU context.
    34403420 * @param   uCpl            The CPL to load the stack for.
    34413421 * @param   pSelSS          Where to return the new stack segment.
    34423422 * @param   puEsp           Where to return the new stack pointer.
    34433423 */
    3444 IEM_STATIC VBOXSTRICTRC iemRaiseLoadStackFromTss32Or16(PVMCPU pVCpu, PCCPUMCTX pCtx, uint8_t uCpl,
    3445                                                        PRTSEL pSelSS, uint32_t *puEsp)
     3424IEM_STATIC VBOXSTRICTRC iemRaiseLoadStackFromTss32Or16(PVMCPU pVCpu, uint8_t uCpl, PRTSEL pSelSS, uint32_t *puEsp)
    34463425{
    34473426    VBOXSTRICTRC rcStrict;
    34483427    Assert(uCpl < 4);
    34493428
    3450     IEM_CTX_IMPORT_RET(pVCpu, (PCPUMCTX)pCtx, CPUMCTX_EXTRN_TR | CPUMCTX_EXTRN_GDTR | CPUMCTX_EXTRN_LDTR);
    3451     switch (pCtx->tr.Attr.n.u4Type)
     3429    IEM_CTX_IMPORT_RET(pVCpu, CPUMCTX_EXTRN_TR | CPUMCTX_EXTRN_GDTR | CPUMCTX_EXTRN_LDTR);
     3430    switch (pVCpu->cpum.GstCtx.tr.Attr.n.u4Type)
    34523431    {
    34533432        /*
    … …  
    34583437        {
    34593438            uint32_t off = uCpl * 4 + 2;
    3460             if (off + 4 <= pCtx->tr.u32Limit)
     3439            if (off + 4 <= pVCpu->cpum.GstCtx.tr.u32Limit)
    34613440            {
    34623441                /** @todo check actual access pattern here. */
    34633442                uint32_t u32Tmp = 0; /* gcc maybe... */
    3464                 rcStrict = iemMemFetchSysU32(pVCpu, &u32Tmp, UINT8_MAX, pCtx->tr.u64Base + off);
     3443                rcStrict = iemMemFetchSysU32(pVCpu, &u32Tmp, UINT8_MAX, pVCpu->cpum.GstCtx.tr.u64Base + off);
    34653444                if (rcStrict == VINF_SUCCESS)
    34663445                {
    … …  
    34723451            else
    34733452            {
    3474                 Log(("LoadStackFromTss32Or16: out of bounds! uCpl=%d, u32Limit=%#x TSS16\n", uCpl, pCtx->tr.u32Limit));
     3453                Log(("LoadStackFromTss32Or16: out of bounds! uCpl=%d, u32Limit=%#x TSS16\n", uCpl, pVCpu->cpum.GstCtx.tr.u32Limit));
    34753454                rcStrict = iemRaiseTaskSwitchFaultCurrentTSS(pVCpu);
    34763455            }
    … …  
    34853464        {
    34863465            uint32_t off = uCpl * 8 + 4;
    3487             if (off + 7 <= pCtx->tr.u32Limit)
     3466            if (off + 7 <= pVCpu->cpum.GstCtx.tr.u32Limit)
    34883467            {
    34893468/** @todo check actual access pattern here. */
    34903469                uint64_t u64Tmp;
    3491                 rcStrict = iemMemFetchSysU64(pVCpu, &u64Tmp, UINT8_MAX, pCtx->tr.u64Base + off);
     3470                rcStrict = iemMemFetchSysU64(pVCpu, &u64Tmp, UINT8_MAX, pVCpu->cpum.GstCtx.tr.u64Base + off);
    34923471                if (rcStrict == VINF_SUCCESS)
    34933472                {
    … …  
    34993478            else
    35003479            {
    3501                 Log(("LoadStackFromTss32Or16: out of bounds! uCpl=%d, u32Limit=%#x TSS16\n", uCpl, pCtx->tr.u32Limit));
     3480                Log(("LoadStackFromTss32Or16: out of bounds! uCpl=%d, u32Limit=%#x TSS16\n", uCpl, pVCpu->cpum.GstCtx.tr.u32Limit));
    35023481                rcStrict = iemRaiseTaskSwitchFaultCurrentTSS(pVCpu);
    35033482            }
    … …  
    35223501 * @returns VBox strict status code.
    35233502 * @param   pVCpu           The cross context virtual CPU structure of the calling thread.
    3524  * @param   pCtx            The CPU context.
    35253503 * @param   uCpl            The CPL to load the stack for.
    35263504 * @param   uIst            The interrupt stack table index, 0 if to use uCpl.
    35273505 * @param   puRsp           Where to return the new stack pointer.
    35283506 */
    3529 IEM_STATIC VBOXSTRICTRC iemRaiseLoadStackFromTss64(PVMCPU pVCpu, PCCPUMCTX pCtx, uint8_t uCpl, uint8_t uIst, uint64_t *puRsp)
     3507IEM_STATIC VBOXSTRICTRC iemRaiseLoadStackFromTss64(PVMCPU pVCpu, uint8_t uCpl, uint8_t uIst, uint64_t *puRsp)
    35303508{
    35313509    Assert(uCpl < 4);
    … …  
    35333511    *puRsp  = 0; /* make gcc happy */
    35343512
    3535     IEM_CTX_IMPORT_RET(pVCpu, (PCPUMCTX)pCtx, CPUMCTX_EXTRN_TR | CPUMCTX_EXTRN_GDTR | CPUMCTX_EXTRN_LDTR);
    3536     AssertReturn(pCtx->tr.Attr.n.u4Type == AMD64_SEL_TYPE_SYS_TSS_BUSY, VERR_IEM_IPE_5);
     3513    IEM_CTX_IMPORT_RET(pVCpu, CPUMCTX_EXTRN_TR | CPUMCTX_EXTRN_GDTR | CPUMCTX_EXTRN_LDTR);
     3514    AssertReturn(pVCpu->cpum.GstCtx.tr.Attr.n.u4Type == AMD64_SEL_TYPE_SYS_TSS_BUSY, VERR_IEM_IPE_5);
    35373515
    35383516    uint32_t off;
    … …  
    35413519    else
    35423520        off = uCpl * sizeof(uint64_t) + RT_OFFSETOF(X86TSS64, rsp0);
    3543     if (off + sizeof(uint64_t) > pCtx->tr.u32Limit)
    3544     {
    3545         Log(("iemRaiseLoadStackFromTss64: out of bounds! uCpl=%d uIst=%d, u32Limit=%#x\n", uCpl, uIst, pCtx->tr.u32Limit));
     3521    if (off + sizeof(uint64_t) > pVCpu->cpum.GstCtx.tr.u32Limit)
     3522    {
     3523        Log(("iemRaiseLoadStackFromTss64: out of bounds! uCpl=%d uIst=%d, u32Limit=%#x\n", uCpl, uIst, pVCpu->cpum.GstCtx.tr.u32Limit));
    35463524        return iemRaiseTaskSwitchFaultCurrentTSS(pVCpu);
    35473525    }
    35483526
    3549     return iemMemFetchSysU64(pVCpu, puRsp, UINT8_MAX, pCtx->tr.u64Base + off);
     3527    return iemMemFetchSysU64(pVCpu, puRsp, UINT8_MAX, pVCpu->cpum.GstCtx.tr.u64Base + off);
    35503528}
    35513529
    … …  
    35543532 * Adjust the CPU state according to the exception being raised.
    35553533 *
    3556  * @param   pCtx                The CPU context.
    3557  * @param   u8Vector            The exception that has been raised.
    3558  */
    3559 DECLINLINE(void) iemRaiseXcptAdjustState(PCPUMCTX pCtx, uint8_t u8Vector)
     3534 * @param   pVCpu           The cross context virtual CPU structure of the calling thread.
     3535 * @param   u8Vector        The exception that has been raised.
     3536 */
     3537DECLINLINE(void) iemRaiseXcptAdjustState(PVMCPU pVCpu, uint8_t u8Vector)
    35603538{
    35613539    switch (u8Vector)
    35623540    {
    35633541        case X86_XCPT_DB:
    3564             IEM_CTX_ASSERT(pCtx, CPUMCTX_EXTRN_DR7);
    3565             pCtx->dr[7] &= ~X86_DR7_GD;
     3542            IEM_CTX_ASSERT(pVCpu, CPUMCTX_EXTRN_DR7);
     3543            pVCpu->cpum.GstCtx.dr[7] &= ~X86_DR7_GD;
    35663544            break;
    35673545        /** @todo Read the AMD and Intel exception reference... */
    … …  
    35753553 * @returns VBox strict status code.
    35763554 * @param   pVCpu           The cross context virtual CPU structure of the calling thread.
    3577  * @param   pCtx            The CPU context.
    35783555 * @param   cbInstr         The number of bytes to offset rIP by in the return
    35793556 *                          address.
    … …  
    35853562IEM_STATIC VBOXSTRICTRC
    35863563iemRaiseXcptOrIntInRealMode(PVMCPU      pVCpu,
    3587                             PCPUMCTX    pCtx,
    35883564                            uint8_t     cbInstr,
    35893565                            uint8_t     u8Vector,
    … …  
    35933569{
    35943570    NOREF(uErr); NOREF(uCr2);
    3595     IEM_CTX_ASSERT(pCtx, IEM_CPUMCTX_EXTRN_XCPT_MASK);
     3571    IEM_CTX_ASSERT(pVCpu, IEM_CPUMCTX_EXTRN_XCPT_MASK);
    35963572
    35973573    /*
    35983574     * Read the IDT entry.
    35993575     */
    3600     if (pCtx->idtr.cbIdt < UINT32_C(4) * u8Vector + 3)
    3601     {
    3602         Log(("RaiseXcptOrIntInRealMode: %#x is out of bounds (%#x)\n", u8Vector, pCtx->idtr.cbIdt));
     3576    if (pVCpu->cpum.GstCtx.idtr.cbIdt < UINT32_C(4) * u8Vector + 3)
     3577    {
     3578        Log(("RaiseXcptOrIntInRealMode: %#x is out of bounds (%#x)\n", u8Vector, pVCpu->cpum.GstCtx.idtr.cbIdt));
    36033579        return iemRaiseGeneralProtectionFault(pVCpu, X86_TRAP_ERR_IDT | ((uint16_t)u8Vector << X86_TRAP_ERR_SEL_SHIFT));
    36043580    }
    36053581    RTFAR16 Idte;
    3606     VBOXSTRICTRC rcStrict = iemMemFetchDataU32(pVCpu, (uint32_t *)&Idte, UINT8_MAX, pCtx->idtr.pIdt + UINT32_C(4) * u8Vector);
     3582    VBOXSTRICTRC rcStrict = iemMemFetchDataU32(pVCpu, (uint32_t *)&Idte, UINT8_MAX, pVCpu->cpum.GstCtx.idtr.pIdt + UINT32_C(4) * u8Vector);
    36073583    if (RT_UNLIKELY(rcStrict != VINF_SUCCESS))
    36083584    {
    … …  
    36203596        return rcStrict;
    36213597
    3622     uint32_t fEfl = IEMMISC_GET_EFL(pVCpu, pCtx);
     3598    uint32_t fEfl = IEMMISC_GET_EFL(pVCpu);
    36233599#if IEM_CFG_TARGET_CPU == IEMTARGETCPU_DYNAMIC
    36243600    AssertCompile(IEMTARGETCPU_8086 <= IEMTARGETCPU_186 && IEMTARGETCPU_V20 <= IEMTARGETCPU_186 && IEMTARGETCPU_286 > IEMTARGETCPU_186);
    … …  
    36273603#endif
    36283604    pu16Frame[2] = (uint16_t)fEfl;
    3629     pu16Frame[1] = (uint16_t)pCtx->cs.Sel;
    3630     pu16Frame[0] = (fFlags & IEM_XCPT_FLAGS_T_SOFT_INT) ? pCtx->ip + cbInstr : pCtx->ip;
     3605    pu16Frame[1] = (uint16_t)pVCpu->cpum.GstCtx.cs.Sel;
     3606    pu16Frame[0] = (fFlags & IEM_XCPT_FLAGS_T_SOFT_INT) ? pVCpu->cpum.GstCtx.ip + cbInstr : pVCpu->cpum.GstCtx.ip;
    36313607    rcStrict = iemMemStackPushCommitSpecial(pVCpu, pu16Frame, uNewRsp);
    36323608    if (RT_UNLIKELY(rcStrict != VINF_SUCCESS))
    … …  
    36373613     * adjustments.
    36383614     */
    3639     pCtx->cs.Sel           = Idte.sel;
    3640     pCtx->cs.ValidSel      = Idte.sel;
    3641     pCtx->cs.fFlags        = CPUMSELREG_FLAGS_VALID;
    3642     pCtx->cs.u64Base       = (uint32_t)Idte.sel << 4;
     3615    pVCpu->cpum.GstCtx.cs.Sel           = Idte.sel;
     3616    pVCpu->cpum.GstCtx.cs.ValidSel      = Idte.sel;
     3617    pVCpu->cpum.GstCtx.cs.fFlags        = CPUMSELREG_FLAGS_VALID;
     3618    pVCpu->cpum.GstCtx.cs.u64Base       = (uint32_t)Idte.sel << 4;
    36433619    /** @todo do we load attribs and limit as well? Should we check against limit like far jump? */
    3644     pCtx->rip              = Idte.off;
     3620    pVCpu->cpum.GstCtx.rip              = Idte.off;
    36453621    fEfl &= ~(X86_EFL_IF | X86_EFL_TF | X86_EFL_AC);
    3646     IEMMISC_SET_EFL(pVCpu, pCtx, fEfl);
     3622    IEMMISC_SET_EFL(pVCpu, fEfl);
    36473623
    36483624    /** @todo do we actually do this in real mode? */
    36493625    if (fFlags & IEM_XCPT_FLAGS_T_CPU_XCPT)
    3650         iemRaiseXcptAdjustState(pCtx, u8Vector);
     3626        iemRaiseXcptAdjustState(pVCpu, u8Vector);
    36513627
    36523628    return fFlags & IEM_XCPT_FLAGS_T_CPU_XCPT ? VINF_IEM_RAISED_XCPT : VINF_SUCCESS;
    … …  
    38423818 * @returns VBox strict status code.
    38433819 * @param   pVCpu           The cross context virtual CPU structure of the calling thread.
    3844  * @param   pCtx            The CPU context.
    38453820 * @param   enmTaskSwitch   What caused this task switch.
    38463821 * @param   uNextEip        The EIP effective after the task switch.
    … …  
    38533828IEM_STATIC VBOXSTRICTRC
    38543829iemTaskSwitch(PVMCPU          pVCpu,
    3855               PCPUMCTX        pCtx,
    38563830              IEMTASKSWITCH   enmTaskSwitch,
    38573831              uint32_t        uNextEip,
    … …  
    38643838    Assert(!IEM_IS_REAL_MODE(pVCpu));
    38653839    Assert(pVCpu->iem.s.enmCpuMode != IEMMODE_64BIT);
    3866     IEM_CTX_ASSERT(pCtx, IEM_CPUMCTX_EXTRN_XCPT_MASK);
     3840    IEM_CTX_ASSERT(pVCpu, IEM_CPUMCTX_EXTRN_XCPT_MASK);
    38673841
    38683842    uint32_t const uNewTSSType = pNewDescTSS->Legacy.Gate.u4Type;
    … …  
    38763850
    38773851    Log(("iemTaskSwitch: enmTaskSwitch=%u NewTSS=%#x fIsNewTSS386=%RTbool EIP=%#RX32 uNextEip=%#RX32\n", enmTaskSwitch, SelTSS,
    3878          fIsNewTSS386, pCtx->eip, uNextEip));
     3852         fIsNewTSS386, pVCpu->cpum.GstCtx.eip, uNextEip));
    38793853
    38803854    /* Update CR2 in case it's a page-fault. */
    … …  
    38823856     *        @bugref{5653#c49}. */
    38833857    if (fFlags & IEM_XCPT_FLAGS_CR2)
    3884         pCtx->cr2 = uCr2;
     3858        pVCpu->cpum.GstCtx.cr2 = uCr2;
    38853859
    38863860    /*
    … …  
    39133887        if (fFlags & IEM_XCPT_FLAGS_ERR)
    39143888            uExitInfo2 |= SVM_EXIT2_TASK_SWITCH_HAS_ERROR_CODE;
    3915         if (pCtx->eflags.Bits.u1RF)
     3889        if (pVCpu->cpum.GstCtx.eflags.Bits.u1RF)
    39163890            uExitInfo2 |= SVM_EXIT2_TASK_SWITCH_EFLAGS_RF;
    39173891
    … …  
    39303904     * end up with smaller than "legal" TSS limits.
    39313905     */
    3932     uint32_t const uCurTSSLimit    = pCtx->tr.u32Limit;
     3906    uint32_t const uCurTSSLimit    = pVCpu->cpum.GstCtx.tr.u32Limit;
    39333907    uint32_t const uCurTSSLimitMin = fIsNewTSS386 ? 0x5F : 0x29;
    39343908    if (uCurTSSLimit < uCurTSSLimitMin)
    … …  
    39613935     * Clear the busy bit in current task's TSS descriptor if it's a task switch due to JMP/IRET.
    39623936     */
    3963     uint32_t u32EFlags = pCtx->eflags.u32;
     3937    uint32_t u32EFlags = pVCpu->cpum.GstCtx.eflags.u32;
    39643938    if (   enmTaskSwitch == IEMTASKSWITCH_JUMP
    39653939        || enmTaskSwitch == IEMTASKSWITCH_IRET)
    … …  
    39673941        PX86DESC pDescCurTSS;
    39683942        rcStrict = iemMemMap(pVCpu, (void **)&pDescCurTSS, sizeof(*pDescCurTSS), UINT8_MAX,
    3969                              pCtx->gdtr.pGdt + (pCtx->tr.Sel & X86_SEL_MASK), IEM_ACCESS_SYS_RW);
     3943                             pVCpu->cpum.GstCtx.gdtr.pGdt + (pVCpu->cpum.GstCtx.tr.Sel & X86_SEL_MASK), IEM_ACCESS_SYS_RW);
    39703944        if (rcStrict != VINF_SUCCESS)
    39713945        {
    39723946            Log(("iemTaskSwitch: Failed to read new TSS descriptor in GDT. enmTaskSwitch=%u pGdt=%#RX64 rc=%Rrc\n",
    3973                  enmTaskSwitch, pCtx->gdtr.pGdt, VBOXSTRICTRC_VAL(rcStrict)));
     3947                 enmTaskSwitch, pVCpu->cpum.GstCtx.gdtr.pGdt, VBOXSTRICTRC_VAL(rcStrict)));
    39743948            return rcStrict;
    39753949        }
    … …  
    39803954        {
    39813955            Log(("iemTaskSwitch: Failed to commit new TSS descriptor in GDT. enmTaskSwitch=%u pGdt=%#RX64 rc=%Rrc\n",
    3982                  enmTaskSwitch, pCtx->gdtr.pGdt, VBOXSTRICTRC_VAL(rcStrict)));
     3956                 enmTaskSwitch, pVCpu->cpum.GstCtx.gdtr.pGdt, VBOXSTRICTRC_VAL(rcStrict)));
    39833957            return rcStrict;
    39843958        }
    … …  
    39963970     * Save the CPU state into the current TSS.
    39973971     */
    3998     RTGCPTR GCPtrCurTSS = pCtx->tr.u64Base;
     3972    RTGCPTR GCPtrCurTSS = pVCpu->cpum.GstCtx.tr.u64Base;
    39993973    if (GCPtrNewTSS == GCPtrCurTSS)
    40003974    {
    40013975        Log(("iemTaskSwitch: Switching to the same TSS! enmTaskSwitch=%u GCPtr[Cur|New]TSS=%#RGv\n", enmTaskSwitch, GCPtrCurTSS));
    40023976        Log(("uCurCr3=%#x uCurEip=%#x uCurEflags=%#x uCurEax=%#x uCurEsp=%#x uCurEbp=%#x uCurCS=%#04x uCurSS=%#04x uCurLdt=%#x\n",
    4003              pCtx->cr3, pCtx->eip, pCtx->eflags.u32, pCtx->eax, pCtx->esp, pCtx->ebp, pCtx->cs.Sel, pCtx->ss.Sel, pCtx->ldtr.Sel));
     3977             pVCpu->cpum.GstCtx.cr3, pVCpu->cpum.GstCtx.eip, pVCpu->cpum.GstCtx.eflags.u32, pVCpu->cpum.GstCtx.eax, pVCpu->cpum.GstCtx.esp, pVCpu->cpum.GstCtx.ebp, pVCpu->cpum.GstCtx.cs.Sel, pVCpu->cpum.GstCtx.ss.Sel, pVCpu->cpum.GstCtx.ldtr.Sel));
    40043978    }
    40053979    if (fIsNewTSS386)
    … …  
    40253999        pCurTSS32->eip    = uNextEip;
    40264000        pCurTSS32->eflags = u32EFlags;
    4027         pCurTSS32->eax    = pCtx->eax;
    4028         pCurTSS32->ecx    = pCtx->ecx;
    4029         pCurTSS32->edx    = pCtx->edx;
    4030         pCurTSS32->ebx    = pCtx->ebx;
    4031         pCurTSS32->esp    = pCtx->esp;
    4032         pCurTSS32->ebp    = pCtx->ebp;
    4033         pCurTSS32->esi    = pCtx->esi;
    4034         pCurTSS32->edi    = pCtx->edi;
    4035         pCurTSS32->es     = pCtx->es.Sel;
    4036         pCurTSS32->cs     = pCtx->cs.Sel;
    4037         pCurTSS32->ss     = pCtx->ss.Sel;
    4038         pCurTSS32->ds     = pCtx->ds.Sel;
    4039         pCurTSS32->fs     = pCtx->fs.Sel;
    4040         pCurTSS32->gs     = pCtx->gs.Sel;
     4001        pCurTSS32->eax    = pVCpu->cpum.GstCtx.eax;
     4002        pCurTSS32->ecx    = pVCpu->cpum.GstCtx.ecx;
     4003        pCurTSS32->edx    = pVCpu->cpum.GstCtx.edx;
     4004        pCurTSS32->ebx    = pVCpu->cpum.GstCtx.ebx;
     4005        pCurTSS32->esp    = pVCpu->cpum.GstCtx.esp;
     4006        pCurTSS32->ebp    = pVCpu->cpum.GstCtx.ebp;
     4007        pCurTSS32->esi    = pVCpu->cpum.GstCtx.esi;
     4008        pCurTSS32->edi    = pVCpu->cpum.GstCtx.edi;
     4009        pCurTSS32->es     = pVCpu->cpum.GstCtx.es.Sel;
     4010        pCurTSS32->cs     = pVCpu->cpum.GstCtx.cs.Sel;
     4011        pCurTSS32->ss     = pVCpu->cpum.GstCtx.ss.Sel;
     4012        pCurTSS32->ds     = pVCpu->cpum.GstCtx.ds.Sel;
     4013        pCurTSS32->fs     = pVCpu->cpum.GstCtx.fs.Sel;
     4014        pCurTSS32->gs     = pVCpu->cpum.GstCtx.gs.Sel;
    40414015
    40424016        rcStrict = iemMemCommitAndUnmap(pVCpu, pvCurTSS32, IEM_ACCESS_SYS_RW);
    … …  
    40694043        pCurTSS16->ip    = uNextEip;
    40704044        pCurTSS16->flags = u32EFlags;
    4071         pCurTSS16->ax    = pCtx->ax;
    4072         pCurTSS16->cx    = pCtx->cx;
    4073         pCurTSS16->dx    = pCtx->dx;
    4074         pCurTSS16->bx    = pCtx->bx;
    4075         pCurTSS16->sp    = pCtx->sp;
    4076         pCurTSS16->bp    = pCtx->bp;
    4077         pCurTSS16->si    = pCtx->si;
    4078         pCurTSS16->di    = pCtx->di;
    4079         pCurTSS16->es    = pCtx->es.Sel;
    4080         pCurTSS16->cs    = pCtx->cs.Sel;
    4081         pCurTSS16->ss    = pCtx->ss.Sel;
    4082         pCurTSS16->ds    = pCtx->ds.Sel;
     4045        pCurTSS16->ax    = pVCpu->cpum.GstCtx.ax;
     4046        pCurTSS16->cx    = pVCpu->cpum.GstCtx.cx;
     4047        pCurTSS16->dx    = pVCpu->cpum.GstCtx.dx;
     4048        pCurTSS16->bx    = pVCpu->cpum.GstCtx.bx;
     4049        pCurTSS16->sp    = pVCpu->cpum.GstCtx.sp;
     4050        pCurTSS16->bp    = pVCpu->cpum.GstCtx.bp;
     4051        pCurTSS16->si    = pVCpu->cpum.GstCtx.si;
     4052        pCurTSS16->di    = pVCpu->cpum.GstCtx.di;
     4053        pCurTSS16->es    = pVCpu->cpum.GstCtx.es.Sel;
     4054        pCurTSS16->cs    = pVCpu->cpum.GstCtx.cs.Sel;
     4055        pCurTSS16->ss    = pVCpu->cpum.GstCtx.ss.Sel;
     4056        pCurTSS16->ds    = pVCpu->cpum.GstCtx.ds.Sel;
    40834057
    40844058        rcStrict = iemMemCommitAndUnmap(pVCpu, pvCurTSS16, IEM_ACCESS_SYS_RW);
    … …  
    40994073        /* 16 or 32-bit TSS doesn't matter, we only access the first, common 16-bit field (selPrev) here. */
    41004074        PX86TSS32 pNewTSS = (PX86TSS32)pvNewTSS;
    4101         pNewTSS->selPrev  = pCtx->tr.Sel;
     4075        pNewTSS->selPrev  = pVCpu->cpum.GstCtx.tr.Sel;
    41024076    }
    41034077
    … …  
    41124086    {
    41134087        PX86TSS32 pNewTSS32 = (PX86TSS32)pvNewTSS;
    4114         uNewCr3       = (pCtx->cr0 & X86_CR0_PG) ? pNewTSS32->cr3 : 0;
     4088        uNewCr3       = (pVCpu->cpum.GstCtx.cr0 & X86_CR0_PG) ? pNewTSS32->cr3 : 0;
    41154089        uNewEip       = pNewTSS32->eip;
    41164090        uNewEflags    = pNewTSS32->eflags;
    … …  
    41764150    {
    41774151        rcStrict = iemMemMap(pVCpu, (void **)&pNewDescTSS, sizeof(*pNewDescTSS), UINT8_MAX,
    4178                              pCtx->gdtr.pGdt + (SelTSS & X86_SEL_MASK), IEM_ACCESS_SYS_RW);
     4152                             pVCpu->cpum.GstCtx.gdtr.pGdt + (SelTSS & X86_SEL_MASK), IEM_ACCESS_SYS_RW);
    41794153        if (rcStrict != VINF_SUCCESS)
    41804154        {
    41814155            Log(("iemTaskSwitch: Failed to read new TSS descriptor in GDT (2). enmTaskSwitch=%u pGdt=%#RX64 rc=%Rrc\n",
    4182                  enmTaskSwitch, pCtx->gdtr.pGdt, VBOXSTRICTRC_VAL(rcStrict)));
     4156                 enmTaskSwitch, pVCpu->cpum.GstCtx.gdtr.pGdt, VBOXSTRICTRC_VAL(rcStrict)));
    41834157            return rcStrict;
    41844158        }
    … …  
    41944168        {
    41954169            Log(("iemTaskSwitch: Failed to commit new TSS descriptor in GDT (2). enmTaskSwitch=%u pGdt=%#RX64 rc=%Rrc\n",
    4196                  enmTaskSwitch, pCtx->gdtr.pGdt, VBOXSTRICTRC_VAL(rcStrict)));
     4170                 enmTaskSwitch, pVCpu->cpum.GstCtx.gdtr.pGdt, VBOXSTRICTRC_VAL(rcStrict)));
    41974171            return rcStrict;
    41984172        }
    … …  
    42034177     * until the completion of the task switch but before executing any instructions in the new task.
    42044178     */
    4205     pCtx->tr.Sel      = SelTSS;
    4206     pCtx->tr.ValidSel = SelTSS;
    4207     pCtx->tr.fFlags   = CPUMSELREG_FLAGS_VALID;
    4208     pCtx->tr.Attr.u   = X86DESC_GET_HID_ATTR(&pNewDescTSS->Legacy);
    4209     pCtx->tr.u32Limit = X86DESC_LIMIT_G(&pNewDescTSS->Legacy);
    4210     pCtx->tr.u64Base  = X86DESC_BASE(&pNewDescTSS->Legacy);
     4179    pVCpu->cpum.GstCtx.tr.Sel      = SelTSS;
     4180    pVCpu->cpum.GstCtx.tr.ValidSel = SelTSS;
     4181    pVCpu->cpum.GstCtx.tr.fFlags   = CPUMSELREG_FLAGS_VALID;
     4182    pVCpu->cpum.GstCtx.tr.Attr.u   = X86DESC_GET_HID_ATTR(&pNewDescTSS->Legacy);
     4183    pVCpu->cpum.GstCtx.tr.u32Limit = X86DESC_LIMIT_G(&pNewDescTSS->Legacy);
     4184    pVCpu->cpum.GstCtx.tr.u64Base  = X86DESC_BASE(&pNewDescTSS->Legacy);
    42114185    CPUMSetChangedFlags(pVCpu, CPUM_CHANGED_TR);
    42124186
    42134187    /* Set the busy bit in TR. */
    4214     pCtx->tr.Attr.n.u4Type |= X86_SEL_TYPE_SYS_TSS_BUSY_MASK;
     4188    pVCpu->cpum.GstCtx.tr.Attr.n.u4Type |= X86_SEL_TYPE_SYS_TSS_BUSY_MASK;
    42154189    /* Set EFLAGS.NT (Nested Task) in the eflags loaded from the new TSS, if it's a task switch due to a CALL/INT_XCPT. */
    42164190    if (   enmTaskSwitch == IEMTASKSWITCH_CALL
    … …  
    42204194    }
    42214195
    4222     pCtx->dr[7] &= ~X86_DR7_LE_ALL;     /** @todo Should we clear DR7.LE bit too? */
    4223     pCtx->cr0   |= X86_CR0_TS;
     4196    pVCpu->cpum.GstCtx.dr[7] &= ~X86_DR7_LE_ALL;     /** @todo Should we clear DR7.LE bit too? */
     4197    pVCpu->cpum.GstCtx.cr0   |= X86_CR0_TS;
    42244198    CPUMSetChangedFlags(pVCpu, CPUM_CHANGED_CR0);
    42254199
    4226     pCtx->eip    = uNewEip;
    4227     pCtx->eax    = uNewEax;
    4228     pCtx->ecx    = uNewEcx;
    4229     pCtx->edx    = uNewEdx;
    4230     pCtx->ebx    = uNewEbx;
    4231     pCtx->esp    = uNewEsp;
    4232     pCtx->ebp    = uNewEbp;
    4233     pCtx->esi    = uNewEsi;
    4234     pCtx->edi    = uNewEdi;
     4200    pVCpu->cpum.GstCtx.eip    = uNewEip;
     4201    pVCpu->cpum.GstCtx.eax    = uNewEax;
     4202    pVCpu->cpum.GstCtx.ecx    = uNewEcx;
     4203    pVCpu->cpum.GstCtx.edx    = uNewEdx;
     4204    pVCpu->cpum.GstCtx.ebx    = uNewEbx;
     4205    pVCpu->cpum.GstCtx.esp    = uNewEsp;
     4206    pVCpu->cpum.GstCtx.ebp    = uNewEbp;
     4207    pVCpu->cpum.GstCtx.esi    = uNewEsi;
     4208    pVCpu->cpum.GstCtx.edi    = uNewEdi;
    42354209
    42364210    uNewEflags &= X86_EFL_LIVE_MASK;
    42374211    uNewEflags |= X86_EFL_RA1_MASK;
    4238     IEMMISC_SET_EFL(pVCpu, pCtx, uNewEflags);
     4212    IEMMISC_SET_EFL(pVCpu, uNewEflags);
    42394213
    42404214    /*
    … …  
    42434217     * due to the hidden part data originating from the guest LDT/GDT which is accessed through paging.
    42444218     */
    4245     pCtx->es.Sel       = uNewES;
    4246     pCtx->es.Attr.u   &= ~X86DESCATTR_P;
    4247 
    4248     pCtx->cs.Sel       = uNewCS;
    4249     pCtx->cs.Attr.u   &= ~X86DESCATTR_P;
    4250 
    4251     pCtx->ss.Sel       = uNewSS;
    4252     pCtx->ss.Attr.u   &= ~X86DESCATTR_P;
    4253 
    4254     pCtx->ds.Sel       = uNewDS;
    4255     pCtx->ds.Attr.u   &= ~X86DESCATTR_P;
    4256 
    4257     pCtx->fs.Sel       = uNewFS;
    4258     pCtx->fs.Attr.u   &= ~X86DESCATTR_P;
    4259 
    4260     pCtx->gs.Sel       = uNewGS;
    4261     pCtx->gs.Attr.u   &= ~X86DESCATTR_P;
     4219    pVCpu->cpum.GstCtx.es.Sel       = uNewES;
     4220    pVCpu->cpum.GstCtx.es.Attr.u   &= ~X86DESCATTR_P;
     4221
     4222    pVCpu->cpum.GstCtx.cs.Sel       = uNewCS;
     4223    pVCpu->cpum.GstCtx.cs.Attr.u   &= ~X86DESCATTR_P;
     4224
     4225    pVCpu->cpum.GstCtx.ss.Sel       = uNewSS;
     4226    pVCpu->cpum.GstCtx.ss.Attr.u   &= ~X86DESCATTR_P;
     4227
     4228    pVCpu->cpum.GstCtx.ds.Sel       = uNewDS;
     4229    pVCpu->cpum.GstCtx.ds.Attr.u   &= ~X86DESCATTR_P;
     4230
     4231    pVCpu->cpum.GstCtx.fs.Sel       = uNewFS;
     4232    pVCpu->cpum.GstCtx.fs.Attr.u   &= ~X86DESCATTR_P;
     4233
     4234    pVCpu->cpum.GstCtx.gs.Sel       = uNewGS;
     4235    pVCpu->cpum.GstCtx.gs.Attr.u   &= ~X86DESCATTR_P;
    42624236    CPUMSetChangedFlags(pVCpu, CPUM_CHANGED_HIDDEN_SEL_REGS);
    42634237
    4264     pCtx->ldtr.Sel     = uNewLdt;
    4265     pCtx->ldtr.fFlags  = CPUMSELREG_FLAGS_STALE;
    4266     pCtx->ldtr.Attr.u &= ~X86DESCATTR_P;
     4238    pVCpu->cpum.GstCtx.ldtr.Sel     = uNewLdt;
     4239    pVCpu->cpum.GstCtx.ldtr.fFlags  = CPUMSELREG_FLAGS_STALE;
     4240    pVCpu->cpum.GstCtx.ldtr.Attr.u &= ~X86DESCATTR_P;
    42674241    CPUMSetChangedFlags(pVCpu, CPUM_CHANGED_LDTR);
    42684242
    42694243    if (IEM_IS_GUEST_CPU_INTEL(pVCpu))
    42704244    {
    4271         pCtx->es.Attr.u   |= X86DESCATTR_UNUSABLE;
    4272         pCtx->cs.Attr.u   |= X86DESCATTR_UNUSABLE;
    4273         pCtx->ss.Attr.u   |= X86DESCATTR_UNUSABLE;
    4274         pCtx->ds.Attr.u   |= X86DESCATTR_UNUSABLE;
    4275         pCtx->fs.Attr.u   |= X86DESCATTR_UNUSABLE;
    4276         pCtx->gs.Attr.u   |= X86DESCATTR_UNUSABLE;
    4277         pCtx->ldtr.Attr.u |= X86DESCATTR_UNUSABLE;
     4245        pVCpu->cpum.GstCtx.es.Attr.u   |= X86DESCATTR_UNUSABLE;
     4246        pVCpu->cpum.GstCtx.cs.Attr.u   |= X86DESCATTR_UNUSABLE;
     4247        pVCpu->cpum.GstCtx.ss.Attr.u   |= X86DESCATTR_UNUSABLE;
     4248        pVCpu->cpum.GstCtx.ds.Attr.u   |= X86DESCATTR_UNUSABLE;
     4249        pVCpu->cpum.GstCtx.fs.Attr.u   |= X86DESCATTR_UNUSABLE;
     4250        pVCpu->cpum.GstCtx.gs.Attr.u   |= X86DESCATTR_UNUSABLE;
     4251        pVCpu->cpum.GstCtx.ldtr.Attr.u |= X86DESCATTR_UNUSABLE;
    42784252    }
    42794253
    … …  
    42824256     */
    42834257    if (   fIsNewTSS386
    4284         && (pCtx->cr0 & X86_CR0_PG))
     4258        && (pVCpu->cpum.GstCtx.cr0 & X86_CR0_PG))
    42854259    {
    42864260        /** @todo Should we update and flush TLBs only if CR3 value actually changes? */
    … …  
    42894263
    42904264        /* Inform PGM. */
    4291         rc = PGMFlushTLB(pVCpu, pCtx->cr3, !(pCtx->cr4 & X86_CR4_PGE));
     4265        rc = PGMFlushTLB(pVCpu, pVCpu->cpum.GstCtx.cr3, !(pVCpu->cpum.GstCtx.cr4 & X86_CR4_PGE));
    42924266        AssertRCReturn(rc, rc);
    42934267        /* ignore informational status codes */
    … …  
    43004274     */
    43014275    if (!(uNewLdt & X86_SEL_MASK_OFF_RPL))
    4302         iemHlpLoadNullDataSelectorProt(pVCpu, &pCtx->ldtr, uNewLdt);
     4276        iemHlpLoadNullDataSelectorProt(pVCpu, &pVCpu->cpum.GstCtx.ldtr, uNewLdt);
    43034277    else
    43044278    {
    4305         Assert(!pCtx->ldtr.Attr.n.u1Present);       /* Ensures that LDT.TI check passes in iemMemFetchSelDesc() below. */
     4279        Assert(!pVCpu->cpum.GstCtx.ldtr.Attr.n.u1Present);       /* Ensures that LDT.TI check passes in iemMemFetchSelDesc() below. */
    43064280
    43074281        IEMSELDESC DescNewLdt;
    … …  
    43104284        {
    43114285            Log(("iemTaskSwitch: fetching LDT failed. enmTaskSwitch=%u uNewLdt=%u cbGdt=%u rc=%Rrc\n", enmTaskSwitch,
    4312                  uNewLdt, pCtx->gdtr.cbGdt, VBOXSTRICTRC_VAL(rcStrict)));
     4286                 uNewLdt, pVCpu->cpum.GstCtx.gdtr.cbGdt, VBOXSTRICTRC_VAL(rcStrict)));
    43134287            return rcStrict;
    43144288        }
    … …  
    43224296        }
    43234297
    4324         pCtx->ldtr.ValidSel = uNewLdt;
    4325         pCtx->ldtr.fFlags   = CPUMSELREG_FLAGS_VALID;
    4326         pCtx->ldtr.u64Base  = X86DESC_BASE(&DescNewLdt.Legacy);
    4327         pCtx->ldtr.u32Limit = X86DESC_LIMIT_G(&DescNewLdt.Legacy);
    4328         pCtx->ldtr.Attr.u   = X86DESC_GET_HID_ATTR(&DescNewLdt.Legacy);
     4298        pVCpu->cpum.GstCtx.ldtr.ValidSel = uNewLdt;
     4299        pVCpu->cpum.GstCtx.ldtr.fFlags   = CPUMSELREG_FLAGS_VALID;
     4300        pVCpu->cpum.GstCtx.ldtr.u64Base  = X86DESC_BASE(&DescNewLdt.Legacy);
     4301        pVCpu->cpum.GstCtx.ldtr.u32Limit = X86DESC_LIMIT_G(&DescNewLdt.Legacy);
     4302        pVCpu->cpum.GstCtx.ldtr.Attr.u   = X86DESC_GET_HID_ATTR(&DescNewLdt.Legacy);
    43294303        if (IEM_IS_GUEST_CPU_INTEL(pVCpu))
    4330             pCtx->ldtr.Attr.u &= ~X86DESCATTR_UNUSABLE;
    4331         Assert(CPUMSELREG_ARE_HIDDEN_PARTS_VALID(pVCpu, &pCtx->ldtr));
     4304            pVCpu->cpum.GstCtx.ldtr.Attr.u &= ~X86DESCATTR_UNUSABLE;
     4305        Assert(CPUMSELREG_ARE_HIDDEN_PARTS_VALID(pVCpu, &pVCpu->cpum.GstCtx.ldtr));
    43324306    }
    43334307
    … …  
    43364310    {
    43374311        pVCpu->iem.s.uCpl = 3;
    4338         iemHlpLoadSelectorInV86Mode(&pCtx->es, uNewES);
    4339         iemHlpLoadSelectorInV86Mode(&pCtx->cs, uNewCS);
    4340         iemHlpLoadSelectorInV86Mode(&pCtx->ss, uNewSS);
    4341         iemHlpLoadSelectorInV86Mode(&pCtx->ds, uNewDS);
    4342         iemHlpLoadSelectorInV86Mode(&pCtx->fs, uNewFS);
    4343         iemHlpLoadSelectorInV86Mode(&pCtx->gs, uNewGS);
     4312        iemHlpLoadSelectorInV86Mode(&pVCpu->cpum.GstCtx.es, uNewES);
     4313        iemHlpLoadSelectorInV86Mode(&pVCpu->cpum.GstCtx.cs, uNewCS);
     4314        iemHlpLoadSelectorInV86Mode(&pVCpu->cpum.GstCtx.ss, uNewSS);
     4315        iemHlpLoadSelectorInV86Mode(&pVCpu->cpum.GstCtx.ds, uNewDS);
     4316        iemHlpLoadSelectorInV86Mode(&pVCpu->cpum.GstCtx.fs, uNewFS);
     4317        iemHlpLoadSelectorInV86Mode(&pVCpu->cpum.GstCtx.gs, uNewGS);
    43444318
    43454319        /* quick fix: fake DescSS. */ /** @todo fix the code further down? */
    43464320        DescSS.Legacy.u = 0;
    4347         DescSS.Legacy.Gen.u16LimitLow = (uint16_t)pCtx->ss.u32Limit;
    4348         DescSS.Legacy.Gen.u4LimitHigh = pCtx->ss.u32Limit >> 16;
    4349         DescSS.Legacy.Gen.u16BaseLow  = (uint16_t)pCtx->ss.u64Base;
    4350         DescSS.Legacy.Gen.u8BaseHigh1 = (uint8_t)(pCtx->ss.u64Base >> 16);
    4351         DescSS.Legacy.Gen.u8BaseHigh2 = (uint8_t)(pCtx->ss.u64Base >> 24);
     4321        DescSS.Legacy.Gen.u16LimitLow = (uint16_t)pVCpu->cpum.GstCtx.ss.u32Limit;
     4322        DescSS.Legacy.Gen.u4LimitHigh = pVCpu->cpum.GstCtx.ss.u32Limit >> 16;
     4323        DescSS.Legacy.Gen.u16BaseLow  = (uint16_t)pVCpu->cpum.GstCtx.ss.u64Base;
     4324        DescSS.Legacy.Gen.u8BaseHigh1 = (uint8_t)(pVCpu->cpum.GstCtx.ss.u64Base >> 16);
     4325        DescSS.Legacy.Gen.u8BaseHigh2 = (uint8_t)(pVCpu->cpum.GstCtx.ss.u64Base >> 24);
    43524326        DescSS.Legacy.Gen.u4Type      = X86_SEL_TYPE_RW_ACC;
    43534327        DescSS.Legacy.Gen.u2Dpl       = 3;
    … …  
    44144388
    44154389        /* Commit SS. */
    4416         pCtx->ss.Sel      = uNewSS;
    4417         pCtx->ss.ValidSel = uNewSS;
    4418         pCtx->ss.Attr.u   = X86DESC_GET_HID_ATTR(&DescSS.Legacy);
    4419         pCtx->ss.u32Limit = cbLimit;
    4420         pCtx->ss.u64Base  = u64Base;
    4421         pCtx->ss.fFlags   = CPUMSELREG_FLAGS_VALID;
    4422         Assert(CPUMSELREG_ARE_HIDDEN_PARTS_VALID(pVCpu, &pCtx->ss));
     4390        pVCpu->cpum.GstCtx.ss.Sel      = uNewSS;
     4391        pVCpu->cpum.GstCtx.ss.ValidSel = uNewSS;
     4392        pVCpu->cpum.GstCtx.ss.Attr.u   = X86DESC_GET_HID_ATTR(&DescSS.Legacy);
     4393        pVCpu->cpum.GstCtx.ss.u32Limit = cbLimit;
     4394        pVCpu->cpum.GstCtx.ss.u64Base  = u64Base;
     4395        pVCpu->cpum.GstCtx.ss.fFlags   = CPUMSELREG_FLAGS_VALID;
     4396        Assert(CPUMSELREG_ARE_HIDDEN_PARTS_VALID(pVCpu, &pVCpu->cpum.GstCtx.ss));
    44234397
    44244398        /* CPL has changed, update IEM before loading rest of segments. */
    … …  
    44284402         * Load the data segments for the new task.
    44294403         */
    4430         rcStrict = iemHlpTaskSwitchLoadDataSelectorInProtMode(pVCpu, &pCtx->es, uNewES);
     4404        rcStrict = iemHlpTaskSwitchLoadDataSelectorInProtMode(pVCpu, &pVCpu->cpum.GstCtx.es, uNewES);
    44314405        if (rcStrict != VINF_SUCCESS)
    44324406            return rcStrict;
    4433         rcStrict = iemHlpTaskSwitchLoadDataSelectorInProtMode(pVCpu, &pCtx->ds, uNewDS);
     4407        rcStrict = iemHlpTaskSwitchLoadDataSelectorInProtMode(pVCpu, &pVCpu->cpum.GstCtx.ds, uNewDS);
    44344408        if (rcStrict != VINF_SUCCESS)
    44354409            return rcStrict;
    4436         rcStrict = iemHlpTaskSwitchLoadDataSelectorInProtMode(pVCpu, &pCtx->fs, uNewFS);
     4410        rcStrict = iemHlpTaskSwitchLoadDataSelectorInProtMode(pVCpu, &pVCpu->cpum.GstCtx.fs, uNewFS);
    44374411        if (rcStrict != VINF_SUCCESS)
    44384412            return rcStrict;
    4439         rcStrict = iemHlpTaskSwitchLoadDataSelectorInProtMode(pVCpu, &pCtx->gs, uNewGS);
     4413        rcStrict = iemHlpTaskSwitchLoadDataSelectorInProtMode(pVCpu, &pVCpu->cpum.GstCtx.gs, uNewGS);
    44404414        if (rcStrict != VINF_SUCCESS)
    44414415            return rcStrict;
    … …  
    45064480
    45074481        /* Commit CS. */
    4508         pCtx->cs.Sel      = uNewCS;
    4509         pCtx->cs.ValidSel = uNewCS;
    4510         pCtx->cs.Attr.u   = X86DESC_GET_HID_ATTR(&DescCS.Legacy);
    4511         pCtx->cs.u32Limit = cbLimit;
    4512         pCtx->cs.u64Base  = u64Base;
    4513         pCtx->cs.fFlags   = CPUMSELREG_FLAGS_VALID;
    4514         Assert(CPUMSELREG_ARE_HIDDEN_PARTS_VALID(pVCpu, &pCtx->cs));
     4482        pVCpu->cpum.GstCtx.cs.Sel      = uNewCS;
     4483        pVCpu->cpum.GstCtx.cs.ValidSel = uNewCS;
     4484        pVCpu->cpum.GstCtx.cs.Attr.u   = X86DESC_GET_HID_ATTR(&DescCS.Legacy);
     4485        pVCpu->cpum.GstCtx.cs.u32Limit = cbLimit;
     4486        pVCpu->cpum.GstCtx.cs.u64Base  = u64Base;
     4487        pVCpu->cpum.GstCtx.cs.fFlags   = CPUMSELREG_FLAGS_VALID;
     4488        Assert(CPUMSELREG_ARE_HIDDEN_PARTS_VALID(pVCpu, &pVCpu->cpum.GstCtx.cs));
    45154489    }
    45164490
    … …  
    45464520        if (!(DescSS.Legacy.Gen.u4Type & X86_SEL_TYPE_DOWN))
    45474521        {
    4548             if (   pCtx->esp - 1 > cbLimitSS
    4549                 || pCtx->esp < cbStackFrame)
     4522            if (   pVCpu->cpum.GstCtx.esp - 1 > cbLimitSS
     4523                || pVCpu->cpum.GstCtx.esp < cbStackFrame)
    45504524            {
    45514525                /** @todo Intel says \#SS(EXT) for INT/XCPT, I couldn't figure out AMD yet. */
    45524526                Log(("iemTaskSwitch: SS=%#x ESP=%#x cbStackFrame=%#x is out of bounds -> #SS\n",
    4553                      pCtx->ss.Sel, pCtx->esp, cbStackFrame));
     4527                     pVCpu->cpum.GstCtx.ss.Sel, pVCpu->cpum.GstCtx.esp, cbStackFrame));
    45544528                return iemRaiseStackSelectorNotPresentWithErr(pVCpu, uExt);
    45554529            }
    … …  
    45574531        else
    45584532        {
    4559             if (   pCtx->esp - 1 > (DescSS.Legacy.Gen.u1DefBig ? UINT32_MAX : UINT32_C(0xffff))
    4560                 || pCtx->esp - cbStackFrame < cbLimitSS + UINT32_C(1))
     4533            if (   pVCpu->cpum.GstCtx.esp - 1 > (DescSS.Legacy.Gen.u1DefBig ? UINT32_MAX : UINT32_C(0xffff))
     4534                || pVCpu->cpum.GstCtx.esp - cbStackFrame < cbLimitSS + UINT32_C(1))
    45614535            {
    45624536                Log(("iemTaskSwitch: SS=%#x ESP=%#x cbStackFrame=%#x (expand down) is out of bounds -> #SS\n",
    4563                      pCtx->ss.Sel, pCtx->esp, cbStackFrame));
     4537                     pVCpu->cpum.GstCtx.ss.Sel, pVCpu->cpum.GstCtx.esp, cbStackFrame));
    45644538                return iemRaiseStackSelectorNotPresentWithErr(pVCpu, uExt);
    45654539            }
    … …  
    45804554
    45814555    /* Check the new EIP against the new CS limit. */
    4582     if (pCtx->eip > pCtx->cs.u32Limit)
     4556    if (pVCpu->cpum.GstCtx.eip > pVCpu->cpum.GstCtx.cs.u32Limit)
    45834557    {
    45844558        Log(("iemHlpTaskSwitchLoadDataSelectorInProtMode: New EIP exceeds CS limit. uNewEIP=%#RX32 CS limit=%u -> #GP(0)\n",
    4585              pCtx->eip, pCtx->cs.u32Limit));
     4559             pVCpu->cpum.GstCtx.eip, pVCpu->cpum.GstCtx.cs.u32Limit));
    45864560        /** @todo Intel says \#GP(EXT) for INT/XCPT, I couldn't figure out AMD yet. */
    45874561        return iemRaiseGeneralProtectionFault(pVCpu, uExt);
    45884562    }
    45894563
    4590     Log(("iemTaskSwitch: Success! New CS:EIP=%#04x:%#x SS=%#04x\n", pCtx->cs.Sel, pCtx->eip, pCtx->ss.Sel));
     4564    Log(("iemTaskSwitch: Success! New CS:EIP=%#04x:%#x SS=%#04x\n", pVCpu->cpum.GstCtx.cs.Sel, pVCpu->cpum.GstCtx.eip, pVCpu->cpum.GstCtx.ss.Sel));
    45914565    return fFlags & IEM_XCPT_FLAGS_T_CPU_XCPT ? VINF_IEM_RAISED_XCPT : VINF_SUCCESS;
    45924566}
    … …  
    45984572 * @returns VBox strict status code.
    45994573 * @param   pVCpu           The cross context virtual CPU structure of the calling thread.
    4600  * @param   pCtx            The CPU context.
    46014574 * @param   cbInstr         The number of bytes to offset rIP by in the return
    46024575 *                          address.
    … …  
    46084581IEM_STATIC VBOXSTRICTRC
    46094582iemRaiseXcptOrIntInProtMode(PVMCPU      pVCpu,
    4610                             PCPUMCTX    pCtx,
    46114583                            uint8_t     cbInstr,
    46124584                            uint8_t     u8Vector,
    … …  
    46154587                            uint64_t    uCr2)
    46164588{
    4617     IEM_CTX_ASSERT(pCtx, IEM_CPUMCTX_EXTRN_XCPT_MASK);
     4589    IEM_CTX_ASSERT(pVCpu, IEM_CPUMCTX_EXTRN_XCPT_MASK);
    46184590
    46194591    /*
    46204592     * Read the IDT entry.
    46214593     */
    4622     if (pCtx->idtr.cbIdt < UINT32_C(8) * u8Vector + 7)
    4623     {
    4624         Log(("RaiseXcptOrIntInProtMode: %#x is out of bounds (%#x)\n", u8Vector, pCtx->idtr.cbIdt));
     4594    if (pVCpu->cpum.GstCtx.idtr.cbIdt < UINT32_C(8) * u8Vector + 7)
     4595    {
     4596        Log(("RaiseXcptOrIntInProtMode: %#x is out of bounds (%#x)\n", u8Vector, pVCpu->cpum.GstCtx.idtr.cbIdt));
    46254597        return iemRaiseGeneralProtectionFault(pVCpu, X86_TRAP_ERR_IDT | ((uint16_t)u8Vector << X86_TRAP_ERR_SEL_SHIFT));
    46264598    }
    46274599    X86DESC Idte;
    46284600    VBOXSTRICTRC rcStrict = iemMemFetchSysU64(pVCpu, &Idte.u, UINT8_MAX,
    4629                                               pCtx->idtr.pIdt + UINT32_C(8) * u8Vector);
     4601                                              pVCpu->cpum.GstCtx.idtr.pIdt + UINT32_C(8) * u8Vector);
    46304602    if (RT_UNLIKELY(rcStrict != VINF_SUCCESS))
    46314603    {
    … …  
    47494721
    47504722        /* Do the actual task switch. */
    4751         return iemTaskSwitch(pVCpu, pCtx, IEMTASKSWITCH_INT_XCPT, pCtx->eip, fFlags, uErr, uCr2, SelTSS, &DescTSS);
     4723        return iemTaskSwitch(pVCpu, IEMTASKSWITCH_INT_XCPT, pVCpu->cpum.GstCtx.eip, fFlags, uErr, uCr2, SelTSS, &DescTSS);
    47524724    }
    47534725
    … …  
    48154787
    48164788    /* Calc the flag image to push. */
    4817     uint32_t        fEfl    = IEMMISC_GET_EFL(pVCpu, pCtx);
     4789    uint32_t        fEfl    = IEMMISC_GET_EFL(pVCpu);
    48184790    if (fFlags & (IEM_XCPT_FLAGS_DRx_INSTR_BP | IEM_XCPT_FLAGS_T_SOFT_INT))
    48194791        fEfl &= ~X86_EFL_RF;
    … …  
    48384810        RTSEL    NewSS;
    48394811        uint32_t uNewEsp;
    4840         rcStrict = iemRaiseLoadStackFromTss32Or16(pVCpu, pCtx, uNewCpl, &NewSS, &uNewEsp);
     4812        rcStrict = iemRaiseLoadStackFromTss32Or16(pVCpu, uNewCpl, &NewSS, &uNewEsp);
    48414813        if (rcStrict != VINF_SUCCESS)
    48424814            return rcStrict;
    48434815
    48444816        IEMSELDESC DescSS;
    4845         rcStrict = iemMiscValidateNewSS(pVCpu, pCtx, NewSS, uNewCpl, &DescSS);
     4817        rcStrict = iemMiscValidateNewSS(pVCpu, NewSS, uNewCpl, &DescSS);
    48464818        if (rcStrict != VINF_SUCCESS)
    48474819            return rcStrict;
    … …  
    48534825        }
    48544826
    4855         Log7(("iemRaiseXcptOrIntInProtMode: New SS=%#x ESP=%#x (from TSS); current SS=%#x ESP=%#x\n", NewSS, uNewEsp, pCtx->ss.Sel, pCtx->esp));
     4827        Log7(("iemRaiseXcptOrIntInProtMode: New SS=%#x ESP=%#x (from TSS); current SS=%#x ESP=%#x\n", NewSS, uNewEsp, pVCpu->cpum.GstCtx.ss.Sel, pVCpu->cpum.GstCtx.esp));
    48564828
    48574829        /* Check that there is sufficient space for the stack frame. */
    … …  
    49014873            if (fFlags & IEM_XCPT_FLAGS_ERR)
    49024874                *uStackFrame.pu32++ = uErr;
    4903             uStackFrame.pu32[0] = (fFlags & IEM_XCPT_FLAGS_T_SOFT_INT) ? pCtx->eip + cbInstr : pCtx->eip;
    4904             uStackFrame.pu32[1] = (pCtx->cs.Sel & ~X86_SEL_RPL) | uOldCpl;
     4875            uStackFrame.pu32[0] = (fFlags & IEM_XCPT_FLAGS_T_SOFT_INT) ? pVCpu->cpum.GstCtx.eip + cbInstr : pVCpu->cpum.GstCtx.eip;
     4876            uStackFrame.pu32[1] = (pVCpu->cpum.GstCtx.cs.Sel & ~X86_SEL_RPL) | uOldCpl;
    49054877            uStackFrame.pu32[2] = fEfl;
    4906             uStackFrame.pu32[3] = pCtx->esp;
    4907             uStackFrame.pu32[4] = pCtx->ss.Sel;
    4908             Log7(("iemRaiseXcptOrIntInProtMode: 32-bit push SS=%#x ESP=%#x\n", pCtx->ss.Sel, pCtx->esp));
     4878            uStackFrame.pu32[3] = pVCpu->cpum.GstCtx.esp;
     4879            uStackFrame.pu32[4] = pVCpu->cpum.GstCtx.ss.Sel;
     4880            Log7(("iemRaiseXcptOrIntInProtMode: 32-bit push SS=%#x ESP=%#x\n", pVCpu->cpum.GstCtx.ss.Sel, pVCpu->cpum.GstCtx.esp));
    49094881            if (fEfl & X86_EFL_VM)
    49104882            {
    4911                 uStackFrame.pu32[1] = pCtx->cs.Sel;
    4912                 uStackFrame.pu32[5] = pCtx->es.Sel;
    4913                 uStackFrame.pu32[6] = pCtx->ds.Sel;
    4914                 uStackFrame.pu32[7] = pCtx->fs.Sel;
    4915                 uStackFrame.pu32[8] = pCtx->gs.Sel;
     4883                uStackFrame.pu32[1] = pVCpu->cpum.GstCtx.cs.Sel;
     4884                uStackFrame.pu32[5] = pVCpu->cpum.GstCtx.es.Sel;
     4885                uStackFrame.pu32[6] = pVCpu->cpum.GstCtx.ds.Sel;
     4886                uStackFrame.pu32[7] = pVCpu->cpum.GstCtx.fs.Sel;
     4887                uStackFrame.pu32[8] = pVCpu->cpum.GstCtx.gs.Sel;
    49164888            }
    49174889        }
    … …  
    49204892            if (fFlags & IEM_XCPT_FLAGS_ERR)
    49214893                *uStackFrame.pu16++ = uErr;
    4922             uStackFrame.pu16[0] = (fFlags & IEM_XCPT_FLAGS_T_SOFT_INT) ? pCtx->ip + cbInstr : pCtx->ip;
    4923             uStackFrame.pu16[1] = (pCtx->cs.Sel & ~X86_SEL_RPL) | uOldCpl;
     4894            uStackFrame.pu16[0] = (fFlags & IEM_XCPT_FLAGS_T_SOFT_INT) ? pVCpu->cpum.GstCtx.ip + cbInstr : pVCpu->cpum.GstCtx.ip;
     4895            uStackFrame.pu16[1] = (pVCpu->cpum.GstCtx.cs.Sel & ~X86_SEL_RPL) | uOldCpl;
    49244896            uStackFrame.pu16[2] = fEfl;
    4925             uStackFrame.pu16[3] = pCtx->sp;
    4926             uStackFrame.pu16[4] = pCtx->ss.Sel;
    4927             Log7(("iemRaiseXcptOrIntInProtMode: 16-bit push SS=%#x SP=%#x\n", pCtx->ss.Sel, pCtx->sp));
     4897            uStackFrame.pu16[3] = pVCpu->cpum.GstCtx.sp;
     4898            uStackFrame.pu16[4] = pVCpu->cpum.GstCtx.ss.Sel;
     4899            Log7(("iemRaiseXcptOrIntInProtMode: 16-bit push SS=%#x SP=%#x\n", pVCpu->cpum.GstCtx.ss.Sel, pVCpu->cpum.GstCtx.sp));
    49284900            if (fEfl & X86_EFL_VM)
    49294901            {
    4930                 uStackFrame.pu16[1] = pCtx->cs.Sel;
    4931                 uStackFrame.pu16[5] = pCtx->es.Sel;
    4932                 uStackFrame.pu16[6] = pCtx->ds.Sel;
    4933                 uStackFrame.pu16[7] = pCtx->fs.Sel;
    4934                 uStackFrame.pu16[8] = pCtx->gs.Sel;
     4902                uStackFrame.pu16[1] = pVCpu->cpum.GstCtx.cs.Sel;
     4903                uStackFrame.pu16[5] = pVCpu->cpum.GstCtx.es.Sel;
     4904                uStackFrame.pu16[6] = pVCpu->cpum.GstCtx.ds.Sel;
     4905                uStackFrame.pu16[7] = pVCpu->cpum.GstCtx.fs.Sel;
     4906                uStackFrame.pu16[8] = pVCpu->cpum.GstCtx.gs.Sel;
    49354907            }
    49364908        }
    … …  
    49624934         * Start comitting the register changes (joins with the DPL=CPL branch).
    49634935         */
    4964         pCtx->ss.Sel            = NewSS;
    4965         pCtx->ss.ValidSel       = NewSS;
    4966         pCtx->ss.fFlags         = CPUMSELREG_FLAGS_VALID;
    4967         pCtx->ss.u32Limit       = cbLimitSS;
    4968         pCtx->ss.u64Base        = X86DESC_BASE(&DescSS.Legacy);
    4969         pCtx->ss.Attr.u         = X86DESC_GET_HID_ATTR(&DescSS.Legacy);
     4936        pVCpu->cpum.GstCtx.ss.Sel            = NewSS;
     4937        pVCpu->cpum.GstCtx.ss.ValidSel       = NewSS;
     4938        pVCpu->cpum.GstCtx.ss.fFlags         = CPUMSELREG_FLAGS_VALID;
     4939        pVCpu->cpum.GstCtx.ss.u32Limit       = cbLimitSS;
     4940        pVCpu->cpum.GstCtx.ss.u64Base        = X86DESC_BASE(&DescSS.Legacy);
     4941        pVCpu->cpum.GstCtx.ss.Attr.u         = X86DESC_GET_HID_ATTR(&DescSS.Legacy);
    49704942        /** @todo When coming from 32-bit code and operating with a 16-bit TSS and
    49714943         *        16-bit handler, the high word of ESP remains unchanged (i.e. only
    … …  
    49744946         *      - 16-bit TSS, 32-bit handler
    49754947         *      - 32-bit TSS, 16-bit handler */
    4976         if (!pCtx->ss.Attr.n.u1DefBig)
    4977             pCtx->sp            = (uint16_t)(uNewEsp - cbStackFrame);
     4948        if (!pVCpu->cpum.GstCtx.ss.Attr.n.u1DefBig)
     4949            pVCpu->cpum.GstCtx.sp            = (uint16_t)(uNewEsp - cbStackFrame);
    49784950        else
    4979             pCtx->rsp           = uNewEsp - cbStackFrame;
     4951            pVCpu->cpum.GstCtx.rsp           = uNewEsp - cbStackFrame;
    49804952
    49814953        if (fEfl & X86_EFL_VM)
    49824954        {
    4983             iemHlpLoadNullDataSelectorOnV86Xcpt(pVCpu, &pCtx->gs);
    4984             iemHlpLoadNullDataSelectorOnV86Xcpt(pVCpu, &pCtx->fs);
    4985             iemHlpLoadNullDataSelectorOnV86Xcpt(pVCpu, &pCtx->es);
    4986             iemHlpLoadNullDataSelectorOnV86Xcpt(pVCpu, &pCtx->ds);
     4955            iemHlpLoadNullDataSelectorOnV86Xcpt(pVCpu, &pVCpu->cpum.GstCtx.gs);
     4956            iemHlpLoadNullDataSelectorOnV86Xcpt(pVCpu, &pVCpu->cpum.GstCtx.fs);
     4957            iemHlpLoadNullDataSelectorOnV86Xcpt(pVCpu, &pVCpu->cpum.GstCtx.es);
     4958            iemHlpLoadNullDataSelectorOnV86Xcpt(pVCpu, &pVCpu->cpum.GstCtx.ds);
    49874959        }
    49884960    }
    … …  
    50044976            if (fFlags & IEM_XCPT_FLAGS_ERR)
    50054977                *uStackFrame.pu32++ = uErr;
    5006             uStackFrame.pu32[0] = fFlags & IEM_XCPT_FLAGS_T_SOFT_INT ? pCtx->eip + cbInstr : pCtx->eip;
    5007             uStackFrame.pu32[1] = (pCtx->cs.Sel & ~X86_SEL_RPL) | pVCpu->iem.s.uCpl;
     4978            uStackFrame.pu32[0] = fFlags & IEM_XCPT_FLAGS_T_SOFT_INT ? pVCpu->cpum.GstCtx.eip + cbInstr : pVCpu->cpum.GstCtx.eip;
     4979            uStackFrame.pu32[1] = (pVCpu->cpum.GstCtx.cs.Sel & ~X86_SEL_RPL) | pVCpu->iem.s.uCpl;
    50084980            uStackFrame.pu32[2] = fEfl;
    50094981        }
    … …  
    50124984            if (fFlags & IEM_XCPT_FLAGS_ERR)
    50134985                *uStackFrame.pu16++ = uErr;
    5014             uStackFrame.pu16[0] = fFlags & IEM_XCPT_FLAGS_T_SOFT_INT ? pCtx->eip + cbInstr : pCtx->eip;
    5015             uStackFrame.pu16[1] = (pCtx->cs.Sel & ~X86_SEL_RPL) | pVCpu->iem.s.uCpl;
     4986            uStackFrame.pu16[0] = fFlags & IEM_XCPT_FLAGS_T_SOFT_INT ? pVCpu->cpum.GstCtx.eip + cbInstr : pVCpu->cpum.GstCtx.eip;
     4987            uStackFrame.pu16[1] = (pVCpu->cpum.GstCtx.cs.Sel & ~X86_SEL_RPL) | pVCpu->iem.s.uCpl;
    50164988            uStackFrame.pu16[2] = fEfl;
    50174989        }
    … …  
    50325004         * Start committing the register changes (joins with the other branch).
    50335005         */
    5034         pCtx->rsp = uNewRsp;
     5006        pVCpu->cpum.GstCtx.rsp = uNewRsp;
    50355007    }
    50365008
    50375009    /* ... register committing continues. */
    5038     pCtx->cs.Sel            = (NewCS & ~X86_SEL_RPL) | uNewCpl;
    5039     pCtx->cs.ValidSel       = (NewCS & ~X86_SEL_RPL) | uNewCpl;
    5040     pCtx->cs.fFlags         = CPUMSELREG_FLAGS_VALID;
    5041     pCtx->cs.u32Limit       = cbLimitCS;
    5042     pCtx->cs.u64Base        = X86DESC_BASE(&DescCS.Legacy);
    5043     pCtx->cs.Attr.u         = X86DESC_GET_HID_ATTR(&DescCS.Legacy);
    5044 
    5045     pCtx->rip               = uNewEip;  /* (The entire register is modified, see pe16_32 bs3kit tests.) */
     5010    pVCpu->cpum.GstCtx.cs.Sel            = (NewCS & ~X86_SEL_RPL) | uNewCpl;
     5011    pVCpu->cpum.GstCtx.cs.ValidSel       = (NewCS & ~X86_SEL_RPL) | uNewCpl;
     5012    pVCpu->cpum.GstCtx.cs.fFlags         = CPUMSELREG_FLAGS_VALID;
     5013    pVCpu->cpum.GstCtx.cs.u32Limit       = cbLimitCS;
     5014    pVCpu->cpum.GstCtx.cs.u64Base        = X86DESC_BASE(&DescCS.Legacy);
     5015    pVCpu->cpum.GstCtx.cs.Attr.u         = X86DESC_GET_HID_ATTR(&DescCS.Legacy);
     5016
     5017    pVCpu->cpum.GstCtx.rip               = uNewEip;  /* (The entire register is modified, see pe16_32 bs3kit tests.) */
    50465018    fEfl &= ~fEflToClear;
    5047     IEMMISC_SET_EFL(pVCpu, pCtx, fEfl);
     5019    IEMMISC_SET_EFL(pVCpu, fEfl);
    50485020
    50495021    if (fFlags & IEM_XCPT_FLAGS_CR2)
    5050         pCtx->cr2 = uCr2;
     5022        pVCpu->cpum.GstCtx.cr2 = uCr2;
    50515023
    50525024    if (fFlags & IEM_XCPT_FLAGS_T_CPU_XCPT)
    5053         iemRaiseXcptAdjustState(pCtx, u8Vector);
     5025        iemRaiseXcptAdjustState(pVCpu, u8Vector);
    50545026
    50555027    return fFlags & IEM_XCPT_FLAGS_T_CPU_XCPT ? VINF_IEM_RAISED_XCPT : VINF_SUCCESS;
    … …  
    50625034 * @returns VBox strict status code.
    50635035 * @param   pVCpu           The cross context virtual CPU structure of the calling thread.
    5064  * @param   pCtx            The CPU context.
    50655036 * @param   cbInstr         The number of bytes to offset rIP by in the return
    50665037 *                          address.
    … …  
    50725043IEM_STATIC VBOXSTRICTRC
    50735044iemRaiseXcptOrIntInLongMode(PVMCPU      pVCpu,
    5074                             PCPUMCTX    pCtx,
    50755045                            uint8_t     cbInstr,
    50765046                            uint8_t     u8Vector,
    … …  
    50795049                            uint64_t    uCr2)
    50805050{
    5081     IEM_CTX_ASSERT(pCtx, IEM_CPUMCTX_EXTRN_XCPT_MASK);
     5051    IEM_CTX_ASSERT(pVCpu, IEM_CPUMCTX_EXTRN_XCPT_MASK);
    50825052
    50835053    /*
    … …  
    50855055     */
    50865056    uint16_t offIdt = (uint16_t)u8Vector << 4;
    5087     if (pCtx->idtr.cbIdt < offIdt + 7)
    5088     {
    5089         Log(("iemRaiseXcptOrIntInLongMode: %#x is out of bounds (%#x)\n", u8Vector, pCtx->idtr.cbIdt));
     5057    if (pVCpu->cpum.GstCtx.idtr.cbIdt < offIdt + 7)
     5058    {
     5059        Log(("iemRaiseXcptOrIntInLongMode: %#x is out of bounds (%#x)\n", u8Vector, pVCpu->cpum.GstCtx.idtr.cbIdt));
    50905060        return iemRaiseGeneralProtectionFault(pVCpu, X86_TRAP_ERR_IDT | ((uint16_t)u8Vector << X86_TRAP_ERR_SEL_SHIFT));
    50915061    }
    50925062    X86DESC64 Idte;
    5093     VBOXSTRICTRC rcStrict = iemMemFetchSysU64(pVCpu, &Idte.au64[0], UINT8_MAX, pCtx->idtr.pIdt + offIdt);
     5063    VBOXSTRICTRC rcStrict = iemMemFetchSysU64(pVCpu, &Idte.au64[0], UINT8_MAX, pVCpu->cpum.GstCtx.idtr.pIdt + offIdt);
    50945064    if (RT_LIKELY(rcStrict == VINF_SUCCESS))
    5095         rcStrict = iemMemFetchSysU64(pVCpu, &Idte.au64[1], UINT8_MAX, pCtx->idtr.pIdt + offIdt + 8);
     5065        rcStrict = iemMemFetchSysU64(pVCpu, &Idte.au64[1], UINT8_MAX, pVCpu->cpum.GstCtx.idtr.pIdt + offIdt + 8);
    50965066    if (RT_UNLIKELY(rcStrict != VINF_SUCCESS))
    50975067    {
    … …  
    52165186        || Idte.Gate.u3IST != 0)
    52175187    {
    5218         rcStrict = iemRaiseLoadStackFromTss64(pVCpu, pCtx, uNewCpl, Idte.Gate.u3IST, &uNewRsp);
     5188        rcStrict = iemRaiseLoadStackFromTss64(pVCpu, uNewCpl, Idte.Gate.u3IST, &uNewRsp);
    52195189        if (rcStrict != VINF_SUCCESS)
    52205190            return rcStrict;
    52215191    }
    52225192    else
    5223         uNewRsp = pCtx->rsp;
     5193        uNewRsp = pVCpu->cpum.GstCtx.rsp;
    52245194    uNewRsp &= ~(uint64_t)0xf;
    52255195
    … …  
    52275197     * Calc the flag image to push.
    52285198     */
    5229     uint32_t        fEfl    = IEMMISC_GET_EFL(pVCpu, pCtx);
     5199    uint32_t        fEfl    = IEMMISC_GET_EFL(pVCpu);
    52305200    if (fFlags & (IEM_XCPT_FLAGS_DRx_INSTR_BP | IEM_XCPT_FLAGS_T_SOFT_INT))
    52315201        fEfl &= ~X86_EFL_RF;
    … …  
    52515221    if (fFlags & IEM_XCPT_FLAGS_ERR)
    52525222        *uStackFrame.pu64++ = uErr;
    5253     uStackFrame.pu64[0] = fFlags & IEM_XCPT_FLAGS_T_SOFT_INT ? pCtx->rip + cbInstr : pCtx->rip;
    5254     uStackFrame.pu64[1] = (pCtx->cs.Sel & ~X86_SEL_RPL) | uOldCpl; /* CPL paranoia */
     5223    uStackFrame.pu64[0] = fFlags & IEM_XCPT_FLAGS_T_SOFT_INT ? pVCpu->cpum.GstCtx.rip + cbInstr : pVCpu->cpum.GstCtx.rip;
     5224    uStackFrame.pu64[1] = (pVCpu->cpum.GstCtx.cs.Sel & ~X86_SEL_RPL) | uOldCpl; /* CPL paranoia */
    52555225    uStackFrame.pu64[2] = fEfl;
    5256     uStackFrame.pu64[3] = pCtx->rsp;
    5257     uStackFrame.pu64[4] = pCtx->ss.Sel;
     5226    uStackFrame.pu64[3] = pVCpu->cpum.GstCtx.rsp;
     5227    uStackFrame.pu64[4] = pVCpu->cpum.GstCtx.ss.Sel;
    52585228    rcStrict = iemMemCommitAndUnmap(pVCpu, pvStackFrame, IEM_ACCESS_STACK_W | IEM_ACCESS_WHAT_SYS);
    52595229    if (rcStrict != VINF_SUCCESS)
    … …  
    52795249    if (uNewCpl != uOldCpl)
    52805250    {
    5281         pCtx->ss.Sel        = 0 | uNewCpl;
    5282         pCtx->ss.ValidSel   = 0 | uNewCpl;
    5283         pCtx->ss.fFlags     = CPUMSELREG_FLAGS_VALID;
    5284         pCtx->ss.u32Limit   = UINT32_MAX;
    5285         pCtx->ss.u64Base    = 0;
    5286         pCtx->ss.Attr.u     = (uNewCpl << X86DESCATTR_DPL_SHIFT) | X86DESCATTR_UNUSABLE;
    5287     }
    5288     pCtx->rsp           = uNewRsp - cbStackFrame;
    5289     pCtx->cs.Sel        = (NewCS & ~X86_SEL_RPL) | uNewCpl;
    5290     pCtx->cs.ValidSel   = (NewCS & ~X86_SEL_RPL) | uNewCpl;
    5291     pCtx->cs.fFlags     = CPUMSELREG_FLAGS_VALID;
    5292     pCtx->cs.u32Limit   = X86DESC_LIMIT_G(&DescCS.Legacy);
    5293     pCtx->cs.u64Base    = X86DESC_BASE(&DescCS.Legacy);
    5294     pCtx->cs.Attr.u     = X86DESC_GET_HID_ATTR(&DescCS.Legacy);
    5295     pCtx->rip           = uNewRip;
     5251        pVCpu->cpum.GstCtx.ss.Sel        = 0 | uNewCpl;
     5252        pVCpu->cpum.GstCtx.ss.ValidSel   = 0 | uNewCpl;
     5253        pVCpu->cpum.GstCtx.ss.fFlags     = CPUMSELREG_FLAGS_VALID;
     5254        pVCpu->cpum.GstCtx.ss.u32Limit   = UINT32_MAX;
     5255        pVCpu->cpum.GstCtx.ss.u64Base    = 0;
     5256        pVCpu->cpum.GstCtx.ss.Attr.u     = (uNewCpl << X86DESCATTR_DPL_SHIFT) | X86DESCATTR_UNUSABLE;
     5257    }
     5258    pVCpu->cpum.GstCtx.rsp           = uNewRsp - cbStackFrame;
     5259    pVCpu->cpum.GstCtx.cs.Sel        = (NewCS & ~X86_SEL_RPL) | uNewCpl;
     5260    pVCpu->cpum.GstCtx.cs.ValidSel   = (NewCS & ~X86_SEL_RPL) | uNewCpl;
     5261    pVCpu->cpum.GstCtx.cs.fFlags     = CPUMSELREG_FLAGS_VALID;
     5262    pVCpu->cpum.GstCtx.cs.u32Limit   = X86DESC_LIMIT_G(&DescCS.Legacy);
     5263    pVCpu->cpum.GstCtx.cs.u64Base    = X86DESC_BASE(&DescCS.Legacy);
     5264    pVCpu->cpum.GstCtx.cs.Attr.u     = X86DESC_GET_HID_ATTR(&DescCS.Legacy);
     5265    pVCpu->cpum.GstCtx.rip           = uNewRip;
    52965266
    52975267    fEfl &= ~fEflToClear;
    5298     IEMMISC_SET_EFL(pVCpu, pCtx, fEfl);
     5268    IEMMISC_SET_EFL(pVCpu, fEfl);
    52995269
    53005270    if (fFlags & IEM_XCPT_FLAGS_CR2)
    5301         pCtx->cr2 = uCr2;
     5271        pVCpu->cpum.GstCtx.cr2 = uCr2;
    53025272
    53035273    if (fFlags & IEM_XCPT_FLAGS_T_CPU_XCPT)
    5304         iemRaiseXcptAdjustState(pCtx, u8Vector);
     5274        iemRaiseXcptAdjustState(pVCpu, u8Vector);
    53055275
    53065276    return fFlags & IEM_XCPT_FLAGS_T_CPU_XCPT ? VINF_IEM_RAISED_XCPT : VINF_SUCCESS;
    … …  
    53305300                  uint64_t    uCr2)
    53315301{
    5332     PCPUMCTX pCtx = IEM_GET_CTX(pVCpu);
    5333 
    53345302    /*
    53355303     * Get all the state that we might need here.
    53365304     */
    53375305#ifdef IN_RING0
    5338     int rc = HMR0EnsureCompleteBasicContext(pVCpu, pCtx);
     5306    int rc = HMR0EnsureCompleteBasicContext(pVCpu, IEM_GET_CTX(pVCpu));
    53395307    AssertRCReturn(rc, rc);
    53405308#endif
    5341     IEM_CTX_IMPORT_RET(pVCpu, pCtx, IEM_CPUMCTX_EXTRN_XCPT_MASK);
    5342     IEM_CTX_ASSERT(pCtx, IEM_CPUMCTX_EXTRN_XCPT_MASK);
     5309    IEM_CTX_IMPORT_RET(pVCpu, IEM_CPUMCTX_EXTRN_XCPT_MASK);
     5310    IEM_CTX_ASSERT(pVCpu, IEM_CPUMCTX_EXTRN_XCPT_MASK);
    53435311
    53445312#ifndef IEM_WITH_CODE_TLB /** @todo we're doing it afterwards too, that should suffice... */
    … …  
    53525320     * Perform the V8086 IOPL check and upgrade the fault without nesting.
    53535321     */
    5354     if (   pCtx->eflags.Bits.u1VM
    5355         && pCtx->eflags.Bits.u2IOPL != 3
     5322    if (   pVCpu->cpum.GstCtx.eflags.Bits.u1VM
     5323        && pVCpu->cpum.GstCtx.eflags.Bits.u2IOPL != 3
    53565324        && (fFlags & (IEM_XCPT_FLAGS_T_SOFT_INT | IEM_XCPT_FLAGS_BP_INSTR)) == IEM_XCPT_FLAGS_T_SOFT_INT
    5357         && (pCtx->cr0 & X86_CR0_PE) )
     5325        && (pVCpu->cpum.GstCtx.cr0 & X86_CR0_PE) )
    53585326    {
    53595327        Log(("iemRaiseXcptOrInt: V8086 IOPL check failed for int %#x -> #GP(0)\n", u8Vector));
    … …  
    53655333    RTTraceBufAddMsgF(pVCpu->CTX_SUFF(pVM)->CTX_SUFF(hTraceBuf), "Xcpt/%u: %02x %u %x %x %llx %04x:%04llx %04x:%04llx",
    53665334                      pVCpu->iem.s.cXcptRecursions, u8Vector, cbInstr, fFlags, uErr, uCr2,
    5367                       pCtx->cs.Sel, pCtx->rip, pCtx->ss.Sel, pCtx->rsp);
     5335                      pVCpu->cpum.GstCtx.cs.Sel, pVCpu->cpum.GstCtx.rip, pVCpu->cpum.GstCtx.ss.Sel, pVCpu->cpum.GstCtx.rsp);
    53685336#endif
    53695337
    53705338#ifdef VBOX_WITH_NESTED_HWVIRT_SVM
    5371     if (CPUMIsGuestInSvmNestedHwVirtMode(pCtx))
     5339    if (CPUMIsGuestInSvmNestedHwVirtMode(IEM_GET_CTX(pVCpu)))
    53725340    {
    53735341        /*
    … …  
    53775345         * See AMD spec. 15.20 "Event Injection".
    53785346         */
    5379         if (!pCtx->hwvirt.svm.fInterceptEvents)
    5380             pCtx->hwvirt.svm.fInterceptEvents = 1;
     5347        if (!pVCpu->cpum.GstCtx.hwvirt.svm.fInterceptEvents)
     5348            pVCpu->cpum.GstCtx.hwvirt.svm.fInterceptEvents = 1;
    53815349        else
    53825350        {
    … …  
    53845352             * Check and handle if the event being raised is intercepted.
    53855353             */
    5386             VBOXSTRICTRC rcStrict0 = iemHandleSvmEventIntercept(pVCpu, pCtx, u8Vector, fFlags, uErr, uCr2);
     5354            VBOXSTRICTRC rcStrict0 = iemHandleSvmEventIntercept(pVCpu, u8Vector, fFlags, uErr, uCr2);
    53875355            if (rcStrict0 != VINF_HM_INTERCEPT_NOT_ACTIVE)
    53885356                return rcStrict0;
    … …  
    53985366    if (pVCpu->iem.s.cXcptRecursions == 0)
    53995367        Log(("iemRaiseXcptOrInt: %#x at %04x:%RGv cbInstr=%#x fFlags=%#x uErr=%#x uCr2=%llx\n",
    5400              u8Vector, pCtx->cs.Sel, pCtx->rip, cbInstr, fFlags, uErr, uCr2));
     5368             u8Vector, pVCpu->cpum.GstCtx.cs.Sel, pVCpu->cpum.GstCtx.rip, cbInstr, fFlags, uErr, uCr2));
    54015369    else
    54025370    {
    54035371        Log(("iemRaiseXcptOrInt: %#x at %04x:%RGv cbInstr=%#x fFlags=%#x uErr=%#x uCr2=%llx; prev=%#x depth=%d flags=%#x\n",
    5404              u8Vector, pCtx->cs.Sel, pCtx->rip, cbInstr, fFlags, uErr, uCr2, pVCpu->iem.s.uCurXcpt,
     5372             u8Vector, pVCpu->cpum.GstCtx.cs.Sel, pVCpu->cpum.GstCtx.rip, cbInstr, fFlags, uErr, uCr2, pVCpu->iem.s.uCurXcpt,
    54055373             pVCpu->iem.s.cXcptRecursions + 1, fPrevXcpt));
    54065374
    … …  
    54395407            /* If a nested-guest enters an endless CPU loop condition, we'll emulate it; otherwise guru. */
    54405408            Log2(("iemRaiseXcptOrInt: CPU hang condition detected\n"));
    5441             if (!CPUMIsGuestInNestedHwVirtMode(pCtx))
     5409            if (!CPUMIsGuestInNestedHwVirtMode(IEM_GET_CTX(pVCpu)))
    54425410                return VERR_EM_GUEST_CPU_HANG;
    54435411        }
    … …  
    55215489     */
    55225490    VBOXSTRICTRC    rcStrict;
    5523     if (!(pCtx->cr0 & X86_CR0_PE))
    5524         rcStrict = iemRaiseXcptOrIntInRealMode(pVCpu, pCtx, cbInstr, u8Vector, fFlags, uErr, uCr2);
    5525     else if (pCtx->msrEFER & MSR_K6_EFER_LMA)
    5526         rcStrict = iemRaiseXcptOrIntInLongMode(pVCpu, pCtx, cbInstr, u8Vector, fFlags, uErr, uCr2);
     5491    if (!(pVCpu->cpum.GstCtx.cr0 & X86_CR0_PE))
     5492        rcStrict = iemRaiseXcptOrIntInRealMode(pVCpu, cbInstr, u8Vector, fFlags, uErr, uCr2);
     5493    else if (pVCpu->cpum.GstCtx.msrEFER & MSR_K6_EFER_LMA)
     5494        rcStrict = iemRaiseXcptOrIntInLongMode(pVCpu, cbInstr, u8Vector, fFlags, uErr, uCr2);
    55275495    else
    5528         rcStrict = iemRaiseXcptOrIntInProtMode(pVCpu, pCtx, cbInstr, u8Vector, fFlags, uErr, uCr2);
     5496        rcStrict = iemRaiseXcptOrIntInProtMode(pVCpu, cbInstr, u8Vector, fFlags, uErr, uCr2);
    55295497
    55305498    /* Flush the prefetch buffer. */
    … …  
    55425510    pVCpu->iem.s.fCurXcpt = fPrevXcpt;
    55435511    Log(("iemRaiseXcptOrInt: returns %Rrc (vec=%#x); cs:rip=%04x:%RGv ss:rsp=%04x:%RGv cpl=%u depth=%d\n",
    5544          VBOXSTRICTRC_VAL(rcStrict), u8Vector, pCtx->cs.Sel, pCtx->rip, pCtx->ss.Sel, pCtx->esp, pVCpu->iem.s.uCpl,
     5512         VBOXSTRICTRC_VAL(rcStrict), u8Vector, pVCpu->cpum.GstCtx.cs.Sel, pVCpu->cpum.GstCtx.rip, pVCpu->cpum.GstCtx.ss.Sel, pVCpu->cpum.GstCtx.esp, pVCpu->iem.s.uCpl,
    55455513         pVCpu->iem.s.cXcptRecursions + 1));
    55465514    return rcStrict;
    … …  
    60686036{
    60696037    Assert(iSegReg < X86_SREG_COUNT);
    6070     PCPUMCTX    pCtx = IEM_GET_CTX(pVCpu);
    6071     IEM_CTX_ASSERT(pCtx, CPUMCTX_EXTRN_SREG_FROM_IDX(iSegReg));
    6072     PCPUMSELREG pSReg = &pCtx->aSRegs[iSegReg];
     6038    IEM_CTX_ASSERT(pVCpu, CPUMCTX_EXTRN_SREG_FROM_IDX(iSegReg));
     6039    PCPUMSELREG pSReg = &pVCpu->cpum.GstCtx.aSRegs[iSegReg];
    60736040
    60746041#ifdef VBOX_WITH_RAW_MODE_NOT_R0
    … …  
    61156082{
    61166083    Assert(iSegReg < X86_SREG_COUNT);
    6117     PCPUMCTX pCtx = IEM_GET_CTX(pVCpu);
    6118     IEM_CTX_ASSERT(pCtx, CPUMCTX_EXTRN_SREG_FROM_IDX(iSegReg));
    6119     return &pCtx->aSRegs[iSegReg].Sel;
     6084    IEM_CTX_ASSERT(pVCpu, CPUMCTX_EXTRN_SREG_FROM_IDX(iSegReg));
     6085    return &pVCpu->cpum.GstCtx.aSRegs[iSegReg].Sel;
    61206086}
    61216087
    … …  
    61316097{
    61326098    Assert(iSegReg < X86_SREG_COUNT);
    6133     PCPUMCTX pCtx = IEM_GET_CTX(pVCpu);
    6134     IEM_CTX_ASSERT(pCtx, CPUMCTX_EXTRN_SREG_FROM_IDX(iSegReg));
    6135     return pCtx->aSRegs[iSegReg].Sel;
     6099    IEM_CTX_ASSERT(pVCpu, CPUMCTX_EXTRN_SREG_FROM_IDX(iSegReg));
     6100    return pVCpu->cpum.GstCtx.aSRegs[iSegReg].Sel;
    61366101}
    61376102
    … …  
    61476112{
    61486113    Assert(iSegReg < X86_SREG_COUNT);
    6149     PCPUMCTX pCtx = IEM_GET_CTX(pVCpu);
    6150     IEM_CTX_ASSERT(pCtx, CPUMCTX_EXTRN_SREG_FROM_IDX(iSegReg));
    6151     return pCtx->aSRegs[iSegReg].u64Base;
     6114    IEM_CTX_ASSERT(pVCpu, CPUMCTX_EXTRN_SREG_FROM_IDX(iSegReg));
     6115    return pVCpu->cpum.GstCtx.aSRegs[iSegReg].u64Base;
    61526116}
    61536117
    … …  
    61636127{
    61646128    Assert(iReg < 16);
    6165     PCPUMCTX pCtx = IEM_GET_CTX(pVCpu);
    6166     return &pCtx->aGRegs[iReg];
     6129    return &pVCpu->cpum.GstCtx.aGRegs[iReg];
    61676130}
    61686131
    … …  
    61796142DECLINLINE(uint8_t *) iemGRegRefU8(PVMCPU pVCpu, uint8_t iReg)
    61806143{
    6181     PCPUMCTX pCtx = IEM_GET_CTX(pVCpu);
    61826144    if (iReg < 4 || (pVCpu->iem.s.fPrefixes & IEM_OP_PRF_REX))
    61836145    {
    61846146        Assert(iReg < 16);
    6185         return &pCtx->aGRegs[iReg].u8;
     6147        return &pVCpu->cpum.GstCtx.aGRegs[iReg].u8;
    61866148    }
    61876149    /* high 8-bit register. */
    61886150    Assert(iReg < 8);
    6189     return &pCtx->aGRegs[iReg & 3].bHi;
     6151    return &pVCpu->cpum.GstCtx.aGRegs[iReg & 3].bHi;
    61906152}
    61916153
    … …  
    62016163{
    62026164    Assert(iReg < 16);
    6203     PCPUMCTX pCtx = IEM_GET_CTX(pVCpu);
    6204     return &pCtx->aGRegs[iReg].u16;
     6165    return &pVCpu->cpum.GstCtx.aGRegs[iReg].u16;
    62056166}
    62066167
    … …  
    62166177{
    62176178    Assert(iReg < 16);
    6218     PCPUMCTX pCtx = IEM_GET_CTX(pVCpu);
    6219     return &pCtx->aGRegs[iReg].u32;
     6179    return &pVCpu->cpum.GstCtx.aGRegs[iReg].u32;
    62206180}
    62216181
    … …  
    62316191{
    62326192    Assert(iReg < 64);
    6233     PCPUMCTX pCtx = IEM_GET_CTX(pVCpu);
    6234     return &pCtx->aGRegs[iReg].u64;
     6193    return &pVCpu->cpum.GstCtx.aGRegs[iReg].u64;
    62356194}
    62366195
    … …  
    62466205{
    62476206    Assert(iSegReg < X86_SREG_COUNT);
    6248     PCPUMCTX pCtx = IEM_GET_CTX(pVCpu);
    6249     IEM_CTX_ASSERT(pCtx, CPUMCTX_EXTRN_SREG_FROM_IDX(iSegReg));
    6250     return &pCtx->aSRegs[iSegReg].u64Base;
     6207    IEM_CTX_ASSERT(pVCpu, CPUMCTX_EXTRN_SREG_FROM_IDX(iSegReg));
     6208    return &pVCpu->cpum.GstCtx.aSRegs[iSegReg].u64Base;
    62516209}
    62526210
    … …  
    63186276IEM_STATIC VBOXSTRICTRC iemRegRipRelativeJumpS8(PVMCPU pVCpu, int8_t offNextInstr)
    63196277{
    6320     PCPUMCTX pCtx = IEM_GET_CTX(pVCpu);
    63216278    switch (pVCpu->iem.s.enmEffOpSize)
    63226279    {
    63236280        case IEMMODE_16BIT:
    63246281        {
    6325             uint16_t uNewIp = pCtx->ip + offNextInstr + IEM_GET_INSTR_LEN(pVCpu);
    6326             if (   uNewIp > pCtx->cs.u32Limit
     6282            uint16_t uNewIp = pVCpu->cpum.GstCtx.ip + offNextInstr + IEM_GET_INSTR_LEN(pVCpu);
     6283            if (   uNewIp > pVCpu->cpum.GstCtx.cs.u32Limit
    63276284                && pVCpu->iem.s.enmCpuMode != IEMMODE_64BIT) /* no need to check for non-canonical. */
    63286285                return iemRaiseGeneralProtectionFault0(pVCpu);
    6329             pCtx->rip = uNewIp;
     6286            pVCpu->cpum.GstCtx.rip = uNewIp;
    63306287            break;
    63316288        }
    … …  
    63336290        case IEMMODE_32BIT:
    63346291        {
    6335             Assert(pCtx->rip <= UINT32_MAX);
     6292            Assert(pVCpu->cpum.GstCtx.rip <= UINT32_MAX);
    63366293            Assert(pVCpu->iem.s.enmCpuMode != IEMMODE_64BIT);
    63376294
    6338             uint32_t uNewEip = pCtx->eip + offNextInstr + IEM_GET_INSTR_LEN(pVCpu);
    6339             if (uNewEip > pCtx->cs.u32Limit)
     6295            uint32_t uNewEip = pVCpu->cpum.GstCtx.eip + offNextInstr + IEM_GET_INSTR_LEN(pVCpu);
     6296            if (uNewEip > pVCpu->cpum.GstCtx.cs.u32Limit)
    63406297                return iemRaiseGeneralProtectionFault0(pVCpu);
    6341             pCtx->rip = uNewEip;
     6298            pVCpu->cpum.GstCtx.rip = uNewEip;
    63426299            break;
    63436300        }
    … …  
    63476304            Assert(pVCpu->iem.s.enmCpuMode == IEMMODE_64BIT);
    63486305
    6349             uint64_t uNewRip = pCtx->rip + offNextInstr + IEM_GET_INSTR_LEN(pVCpu);
     6306            uint64_t uNewRip = pVCpu->cpum.GstCtx.rip + offNextInstr + IEM_GET_INSTR_LEN(pVCpu);
    63506307            if (!IEM_IS_CANONICAL(uNewRip))
    63516308                return iemRaiseGeneralProtectionFault0(pVCpu);
    6352             pCtx->rip = uNewRip;
     6309            pVCpu->cpum.GstCtx.rip = uNewRip;
    63536310            break;
    63546311        }
    … …  
    63576314    }
    63586315
    6359     pCtx->eflags.Bits.u1RF = 0;
     6316    pVCpu->cpum.GstCtx.eflags.Bits.u1RF = 0;
    63606317
    63616318#ifndef IEM_WITH_CODE_TLB
    … …  
    63806337IEM_STATIC VBOXSTRICTRC iemRegRipRelativeJumpS16(PVMCPU pVCpu, int16_t offNextInstr)
    63816338{
    6382     PCPUMCTX pCtx = IEM_GET_CTX(pVCpu);
    63836339    Assert(pVCpu->iem.s.enmEffOpSize == IEMMODE_16BIT);
    63846340
    6385     uint16_t uNewIp = pCtx->ip + offNextInstr + IEM_GET_INSTR_LEN(pVCpu);
    6386     if (   uNewIp > pCtx->cs.u32Limit
     6341    uint16_t uNewIp = pVCpu->cpum.GstCtx.ip + offNextInstr + IEM_GET_INSTR_LEN(pVCpu);
     6342    if (   uNewIp > pVCpu->cpum.GstCtx.cs.u32Limit
    63876343        && pVCpu->iem.s.enmCpuMode != IEMMODE_64BIT) /* no need to check for non-canonical. */
    63886344        return iemRaiseGeneralProtectionFault0(pVCpu);
    63896345    /** @todo Test 16-bit jump in 64-bit mode. possible?  */
    6390     pCtx->rip = uNewIp;
    6391     pCtx->eflags.Bits.u1RF = 0;
     6346    pVCpu->cpum.GstCtx.rip = uNewIp;
     6347    pVCpu->cpum.GstCtx.eflags.Bits.u1RF = 0;
    63926348
    63936349#ifndef IEM_WITH_CODE_TLB
    … …  
    64126368IEM_STATIC VBOXSTRICTRC iemRegRipRelativeJumpS32(PVMCPU pVCpu, int32_t offNextInstr)
    64136369{
    6414     PCPUMCTX pCtx = IEM_GET_CTX(pVCpu);
    64156370    Assert(pVCpu->iem.s.enmEffOpSize != IEMMODE_16BIT);
    64166371
    64176372    if (pVCpu->iem.s.enmEffOpSize == IEMMODE_32BIT)
    64186373    {
    6419         Assert(pCtx->rip <= UINT32_MAX); Assert(pVCpu->iem.s.enmCpuMode != IEMMODE_64BIT);
    6420 
    6421         uint32_t uNewEip = pCtx->eip + offNextInstr + IEM_GET_INSTR_LEN(pVCpu);
    6422         if (uNewEip > pCtx->cs.u32Limit)
     6374        Assert(pVCpu->cpum.GstCtx.rip <= UINT32_MAX); Assert(pVCpu->iem.s.enmCpuMode != IEMMODE_64BIT);
     6375
     6376        uint32_t uNewEip = pVCpu->cpum.GstCtx.eip + offNextInstr + IEM_GET_INSTR_LEN(pVCpu);
     6377        if (uNewEip > pVCpu->cpum.GstCtx.cs.u32Limit)
    64236378            return iemRaiseGeneralProtectionFault0(pVCpu);
    6424         pCtx->rip = uNewEip;
     6379        pVCpu->cpum.GstCtx.rip = uNewEip;
    64256380    }
    64266381    else
    … …  
    64286383        Assert(pVCpu->iem.s.enmCpuMode == IEMMODE_64BIT);
    64296384
    6430         uint64_t uNewRip = pCtx->rip + offNextInstr + IEM_GET_INSTR_LEN(pVCpu);
     6385        uint64_t uNewRip = pVCpu->cpum.GstCtx.rip + offNextInstr + IEM_GET_INSTR_LEN(pVCpu);
    64316386        if (!IEM_IS_CANONICAL(uNewRip))
    64326387            return iemRaiseGeneralProtectionFault0(pVCpu);
    6433         pCtx->rip = uNewRip;
    6434     }
    6435     pCtx->eflags.Bits.u1RF = 0;
     6388        pVCpu->cpum.GstCtx.rip = uNewRip;
     6389    }
     6390    pVCpu->cpum.GstCtx.eflags.Bits.u1RF = 0;
    64366391
    64376392#ifndef IEM_WITH_CODE_TLB
    … …  
    64556410IEM_STATIC VBOXSTRICTRC iemRegRipJump(PVMCPU pVCpu, uint64_t uNewRip)
    64566411{
    6457     PCPUMCTX pCtx = IEM_GET_CTX(pVCpu);
    64586412    switch (pVCpu->iem.s.enmEffOpSize)
    64596413    {
    … …  
    64616415        {
    64626416            Assert(uNewRip <= UINT16_MAX);
    6463             if (   uNewRip > pCtx->cs.u32Limit
     6417            if (   uNewRip > pVCpu->cpum.GstCtx.cs.u32Limit
    64646418                && pVCpu->iem.s.enmCpuMode != IEMMODE_64BIT) /* no need to check for non-canonical. */
    64656419                return iemRaiseGeneralProtectionFault0(pVCpu);
    64666420            /** @todo Test 16-bit jump in 64-bit mode.  */
    6467             pCtx->rip = uNewRip;
     6421            pVCpu->cpum.GstCtx.rip = uNewRip;
    64686422            break;
    64696423        }
    … …  
    64726426        {
    64736427            Assert(uNewRip <= UINT32_MAX);
    6474             Assert(pCtx->rip <= UINT32_MAX);
     6428            Assert(pVCpu->cpum.GstCtx.rip <= UINT32_MAX);
    64756429            Assert(pVCpu->iem.s.enmCpuMode != IEMMODE_64BIT);
    64766430
    6477             if (uNewRip > pCtx->cs.u32Limit)
     6431            if (uNewRip > pVCpu->cpum.GstCtx.cs.u32Limit)
    64786432                return iemRaiseGeneralProtectionFault0(pVCpu);
    6479             pCtx->rip = uNewRip;
     6433            pVCpu->cpum.GstCtx.rip = uNewRip;
    64806434            break;
    64816435        }
    … …  
    64876441            if (!IEM_IS_CANONICAL(uNewRip))
    64886442                return iemRaiseGeneralProtectionFault0(pVCpu);
    6489             pCtx->rip = uNewRip;
     6443            pVCpu->cpum.GstCtx.rip = uNewRip;
    64906444            break;
    64916445        }
    … …  
    64946448    }
    64956449
    6496     pCtx->eflags.Bits.u1RF = 0;
     6450    pVCpu->cpum.GstCtx.eflags.Bits.u1RF = 0;
    64976451
    64986452#ifndef IEM_WITH_CODE_TLB
    … …  
    65096463 *
    65106464 * @param   pVCpu               The cross context virtual CPU structure of the calling thread.
    6511  * @param   pCtx                The CPU context which SP/ESP/RSP should be
    6512  *                              read.
    6513  */
    6514 DECLINLINE(RTGCPTR) iemRegGetEffRsp(PCVMCPU pVCpu, PCCPUMCTX pCtx)
     6465 */
     6466DECLINLINE(RTGCPTR) iemRegGetEffRsp(PCVMCPU pVCpu)
    65156467{
    65166468    if (pVCpu->iem.s.enmCpuMode == IEMMODE_64BIT)
    6517         return pCtx->rsp;
    6518     if (pCtx->ss.Attr.n.u1DefBig)
    6519         return pCtx->esp;
    6520     return pCtx->sp;
     6469        return pVCpu->cpum.GstCtx.rsp;
     6470    if (pVCpu->cpum.GstCtx.ss.Attr.n.u1DefBig)
     6471        return pVCpu->cpum.GstCtx.esp;
     6472    return pVCpu->cpum.GstCtx.sp;
    65216473}
    65226474
    … …  
    65326484IEM_STATIC void iemRegAddToRipKeepRF(PVMCPU pVCpu, uint8_t cbInstr)
    65336485{
    6534     PCPUMCTX pCtx = IEM_GET_CTX(pVCpu);
    65356486    switch (pVCpu->iem.s.enmCpuMode)
    65366487    {
    65376488        case IEMMODE_16BIT:
    6538             Assert(pCtx->rip <= UINT16_MAX);
    6539             pCtx->eip += cbInstr;
    6540             pCtx->eip &= UINT32_C(0xffff);
     6489            Assert(pVCpu->cpum.GstCtx.rip <= UINT16_MAX);
     6490            pVCpu->cpum.GstCtx.eip += cbInstr;
     6491            pVCpu->cpum.GstCtx.eip &= UINT32_C(0xffff);
    65416492            break;
    65426493
    65436494        case IEMMODE_32BIT:
    6544             pCtx->eip += cbInstr;
    6545             Assert(pCtx->rip <= UINT32_MAX);
     6495            pVCpu->cpum.GstCtx.eip += cbInstr;
     6496            Assert(pVCpu->cpum.GstCtx.rip <= UINT32_MAX);
    65466497            break;
    65476498
    65486499        case IEMMODE_64BIT:
    6549             pCtx->rip += cbInstr;
     6500            pVCpu->cpum.GstCtx.rip += cbInstr;
    65506501            break;
    65516502        default: AssertFailed();
    … …  
    65766527IEM_STATIC void iemRegAddToRipAndClearRF(PVMCPU pVCpu, uint8_t cbInstr)
    65776528{
    6578     PCPUMCTX pCtx = IEM_GET_CTX(pVCpu);
    6579 
    6580     pCtx->eflags.Bits.u1RF = 0;
     6529    pVCpu->cpum.GstCtx.eflags.Bits.u1RF = 0;
    65816530
    65826531    AssertCompile(IEMMODE_16BIT == 0 && IEMMODE_32BIT == 1 && IEMMODE_64BIT == 2);
    65836532#if ARCH_BITS >= 64
    65846533    static uint64_t const s_aRipMasks[] = { UINT64_C(0xffffffff), UINT64_C(0xffffffff), UINT64_MAX };
    6585     Assert(pCtx->rip <= s_aRipMasks[(unsigned)pVCpu->iem.s.enmCpuMode]);
    6586     pCtx->rip = (pCtx->rip + cbInstr) & s_aRipMasks[(unsigned)pVCpu->iem.s.enmCpuMode];
     6534    Assert(pVCpu->cpum.GstCtx.rip <= s_aRipMasks[(unsigned)pVCpu->iem.s.enmCpuMode]);
     6535    pVCpu->cpum.GstCtx.rip = (pVCpu->cpum.GstCtx.rip + cbInstr) & s_aRipMasks[(unsigned)pVCpu->iem.s.enmCpuMode];
    65876536#else
    65886537    if (pVCpu->iem.s.enmCpuMode == IEMMODE_64BIT)
    6589         pCtx->rip += cbInstr;
     6538        pVCpu->cpum.GstCtx.rip += cbInstr;
    65906539    else
    6591         pCtx->eip += cbInstr;
     6540        pVCpu->cpum.GstCtx.eip += cbInstr;
    65926541#endif
    65936542}
    … …  
    66096558 *
    66106559 * @param   pVCpu               The cross context virtual CPU structure of the calling thread.
    6611  * @param   pCtx                The CPU context which SP/ESP/RSP should be
    6612  *                              updated.
    66136560 * @param   cbToAdd             The number of bytes to add (8-bit!).
    66146561 */
    6615 DECLINLINE(void) iemRegAddToRsp(PCVMCPU pVCpu, PCPUMCTX pCtx, uint8_t cbToAdd)
     6562DECLINLINE(void) iemRegAddToRsp(PVMCPU pVCpu, uint8_t cbToAdd)
    66166563{
    66176564    if (pVCpu->iem.s.enmCpuMode == IEMMODE_64BIT)
    6618         pCtx->rsp += cbToAdd;
    6619     else if (pCtx->ss.Attr.n.u1DefBig)
    6620         pCtx->esp += cbToAdd;
     6565        pVCpu->cpum.GstCtx.rsp += cbToAdd;
     6566    else if (pVCpu->cpum.GstCtx.ss.Attr.n.u1DefBig)
     6567        pVCpu->cpum.GstCtx.esp += cbToAdd;
    66216568    else
    6622         pCtx->sp  += cbToAdd;
     6569        pVCpu->cpum.GstCtx.sp  += cbToAdd;
    66236570}
    66246571
    … …  
    66286575 *
    66296576 * @param   pVCpu               The cross context virtual CPU structure of the calling thread.
    6630  * @param   pCtx                The CPU context which SP/ESP/RSP should be
    6631  *                              updated.
    66326577 * @param   cbToSub             The number of bytes to subtract (8-bit!).
    66336578 */
    6634 DECLINLINE(void) iemRegSubFromRsp(PCVMCPU pVCpu, PCPUMCTX pCtx, uint8_t cbToSub)
     6579DECLINLINE(void) iemRegSubFromRsp(PVMCPU pVCpu, uint8_t cbToSub)
    66356580{
    66366581    if (pVCpu->iem.s.enmCpuMode == IEMMODE_64BIT)
    6637         pCtx->rsp -= cbToSub;
    6638     else if (pCtx->ss.Attr.n.u1DefBig)
    6639         pCtx->esp -= cbToSub;
     6582        pVCpu->cpum.GstCtx.rsp -= cbToSub;
     6583    else if (pVCpu->cpum.GstCtx.ss.Attr.n.u1DefBig)
     6584        pVCpu->cpum.GstCtx.esp -= cbToSub;
    66406585    else
    6641         pCtx->sp  -= cbToSub;
     6586        pVCpu->cpum.GstCtx.sp  -= cbToSub;
    66426587}
    66436588
    … …  
    66496594 * @param   pTmpRsp             The temporary SP/ESP/RSP to update.
    66506595 * @param   cbToAdd             The number of bytes to add (16-bit).
    6651  * @param   pCtx                Where to get the current stack mode.
    6652  */
    6653 DECLINLINE(void) iemRegAddToRspEx(PCVMCPU pVCpu, PCCPUMCTX pCtx, PRTUINT64U pTmpRsp, uint16_t cbToAdd)
     6596 */
     6597DECLINLINE(void) iemRegAddToRspEx(PCVMCPU pVCpu, PRTUINT64U pTmpRsp, uint16_t cbToAdd)
    66546598{
    66556599    if (pVCpu->iem.s.enmCpuMode == IEMMODE_64BIT)
    66566600        pTmpRsp->u           += cbToAdd;
    6657     else if (pCtx->ss.Attr.n.u1DefBig)
     6601    else if (pVCpu->cpum.GstCtx.ss.Attr.n.u1DefBig)
    66586602        pTmpRsp->DWords.dw0  += cbToAdd;
    66596603    else
    … …  
    66686612 * @param   pTmpRsp             The temporary SP/ESP/RSP to update.
    66696613 * @param   cbToSub             The number of bytes to subtract.
    6670  * @param   pCtx                Where to get the current stack mode.
    66716614 * @remarks The @a cbToSub argument *MUST* be 16-bit, iemCImpl_enter is
    66726615 *          expecting that.
    66736616 */
    6674 DECLINLINE(void) iemRegSubFromRspEx(PCVMCPU pVCpu, PCCPUMCTX pCtx, PRTUINT64U pTmpRsp, uint16_t cbToSub)
     6617DECLINLINE(void) iemRegSubFromRspEx(PCVMCPU pVCpu, PRTUINT64U pTmpRsp, uint16_t cbToSub)
    66756618{
    66766619    if (pVCpu->iem.s.enmCpuMode == IEMMODE_64BIT)
    66776620        pTmpRsp->u          -= cbToSub;
    6678     else if (pCtx->ss.Attr.n.u1DefBig)
     6621    else if (pVCpu->cpum.GstCtx.ss.Attr.n.u1DefBig)
    66796622        pTmpRsp->DWords.dw0 -= cbToSub;
    66806623    else
    … …  
    66896632 * @returns Effective stack addressf for the push.
    66906633 * @param   pVCpu               The cross context virtual CPU structure of the calling thread.
    6691  * @param   pCtx                Where to get the current stack mode.
    66926634 * @param   cbItem              The size of the stack item to pop.
    66936635 * @param   puNewRsp            Where to return the new RSP value.
    66946636 */
    6695 DECLINLINE(RTGCPTR) iemRegGetRspForPush(PCVMCPU pVCpu, PCCPUMCTX pCtx, uint8_t cbItem, uint64_t *puNewRsp)
     6637DECLINLINE(RTGCPTR) iemRegGetRspForPush(PCVMCPU pVCpu, uint8_t cbItem, uint64_t *puNewRsp)
    66966638{
    66976639    RTUINT64U   uTmpRsp;
    66986640    RTGCPTR     GCPtrTop;
    6699     uTmpRsp.u = pCtx->rsp;
     6641    uTmpRsp.u = pVCpu->cpum.GstCtx.rsp;
    67006642
    67016643    if (pVCpu->iem.s.enmCpuMode == IEMMODE_64BIT)
    67026644        GCPtrTop = uTmpRsp.u            -= cbItem;
    6703     else if (pCtx->ss.Attr.n.u1DefBig)
     6645    else if (pVCpu->cpum.GstCtx.ss.Attr.n.u1DefBig)
    67046646        GCPtrTop = uTmpRsp.DWords.dw0   -= cbItem;
    67056647    else
    … …  
    67166658 * @returns Current stack pointer.
    67176659 * @param   pVCpu               The cross context virtual CPU structure of the calling thread.
    6718  * @param   pCtx                Where to get the current stack mode.
    67196660 * @param   cbItem              The size of the stack item to pop.
    67206661 * @param   puNewRsp            Where to return the new RSP value.
    67216662 */
    6722 DECLINLINE(RTGCPTR) iemRegGetRspForPop(PCVMCPU pVCpu, PCCPUMCTX pCtx, uint8_t cbItem, uint64_t *puNewRsp)
     6663DECLINLINE(RTGCPTR) iemRegGetRspForPop(PCVMCPU pVCpu, uint8_t cbItem, uint64_t *puNewRsp)
    67236664{
    67246665    RTUINT64U   uTmpRsp;
    67256666    RTGCPTR     GCPtrTop;
    6726     uTmpRsp.u = pCtx->rsp;
     6667    uTmpRsp.u = pVCpu->cpum.GstCtx.rsp;
    67276668
    67286669    if (pVCpu->iem.s.enmCpuMode == IEMMODE_64BIT)
    … …  
    67316672        uTmpRsp.u += cbItem;
    67326673    }
    6733     else if (pCtx->ss.Attr.n.u1DefBig)
     6674    else if (pVCpu->cpum.GstCtx.ss.Attr.n.u1DefBig)
    67346675    {
    67356676        GCPtrTop = uTmpRsp.DWords.dw0;
    … …  
    67526693 * @returns Effective stack addressf for the push.
    67536694 * @param   pVCpu               The cross context virtual CPU structure of the calling thread.
    6754  * @param   pCtx                Where to get the current stack mode.
    67556695 * @param   pTmpRsp             The temporary stack pointer.  This is updated.
    67566696 * @param   cbItem              The size of the stack item to pop.
    67576697 */
    6758 DECLINLINE(RTGCPTR) iemRegGetRspForPushEx(PCVMCPU pVCpu, PCCPUMCTX pCtx, PRTUINT64U pTmpRsp, uint8_t cbItem)
     6698DECLINLINE(RTGCPTR) iemRegGetRspForPushEx(PCVMCPU pVCpu, PRTUINT64U pTmpRsp, uint8_t cbItem)
    67596699{
    67606700    RTGCPTR GCPtrTop;
    … …  
    67626702    if (pVCpu->iem.s.enmCpuMode == IEMMODE_64BIT)
    67636703        GCPtrTop = pTmpRsp->u          -= cbItem;
    6764     else if (pCtx->ss.Attr.n.u1DefBig)
     6704    else if (pVCpu->cpum.GstCtx.ss.Attr.n.u1DefBig)
    67656705        GCPtrTop = pTmpRsp->DWords.dw0 -= cbItem;
    67666706    else
    … …  
    67766716 * @returns Current stack pointer.
    67776717 * @param   pVCpu               The cross context virtual CPU structure of the calling thread.
    6778  * @param   pCtx                Where to get the current stack mode.
    67796718 * @param   pTmpRsp             The temporary stack pointer.  This is updated.
    67806719 * @param   cbItem              The size of the stack item to pop.
    67816720 */
    6782 DECLINLINE(RTGCPTR) iemRegGetRspForPopEx(PCVMCPU pVCpu, PCCPUMCTX pCtx, PRTUINT64U pTmpRsp, uint8_t cbItem)
     6721DECLINLINE(RTGCPTR) iemRegGetRspForPopEx(PCVMCPU pVCpu, PRTUINT64U pTmpRsp, uint8_t cbItem)
    67836722{
    67846723    RTGCPTR GCPtrTop;
    … …  
    67886727        pTmpRsp->u          += cbItem;
    67896728    }
    6790     else if (pCtx->ss.Attr.n.u1DefBig)
     6729    else if (pVCpu->cpum.GstCtx.ss.Attr.n.u1DefBig)
    67916730    {
    67926731        GCPtrTop = pTmpRsp->DWords.dw0;
    … …  
    68246763    CPUMRZFpuStatePrepareHostCpuForUse(pVCpu);
    68256764#endif
    6826     PCPUMCTX pCtx = IEM_GET_CTX(pVCpu);
    6827     IEM_CTX_IMPORT_NORET(pVCpu, pCtx, CPUMCTX_EXTRN_X87 | CPUMCTX_EXTRN_SSE_AVX | CPUMCTX_EXTRN_OTHER_XSAVE | CPUMCTX_EXTRN_XCRx);
     6765    IEM_CTX_IMPORT_NORET(pVCpu, CPUMCTX_EXTRN_X87 | CPUMCTX_EXTRN_SSE_AVX | CPUMCTX_EXTRN_OTHER_XSAVE | CPUMCTX_EXTRN_XCRx);
    68286766}
    68296767
    … …  
    68696807    CPUMRZFpuStateActualizeForRead(pVCpu);
    68706808#endif
    6871     PCPUMCTX pCtx = IEM_GET_CTX(pVCpu);
    6872     IEM_CTX_IMPORT_NORET(pVCpu, pCtx, CPUMCTX_EXTRN_X87 | CPUMCTX_EXTRN_SSE_AVX | CPUMCTX_EXTRN_OTHER_XSAVE | CPUMCTX_EXTRN_XCRx);
     6809    IEM_CTX_IMPORT_NORET(pVCpu, CPUMCTX_EXTRN_X87 | CPUMCTX_EXTRN_SSE_AVX | CPUMCTX_EXTRN_OTHER_XSAVE | CPUMCTX_EXTRN_XCRx);
    68736810}
    68746811
    … …  
    68886825    CPUMRZFpuStateActualizeForChange(pVCpu);
    68896826#endif
    6890     PCPUMCTX pCtx = IEM_GET_CTX(pVCpu);
    6891     IEM_CTX_IMPORT_NORET(pVCpu, pCtx, CPUMCTX_EXTRN_X87 | CPUMCTX_EXTRN_SSE_AVX | CPUMCTX_EXTRN_OTHER_XSAVE | CPUMCTX_EXTRN_XCRx);
     6827    IEM_CTX_IMPORT_NORET(pVCpu, CPUMCTX_EXTRN_X87 | CPUMCTX_EXTRN_SSE_AVX | CPUMCTX_EXTRN_OTHER_XSAVE | CPUMCTX_EXTRN_XCRx);
    68926828}
    68936829
    … …  
    69086844    CPUMRZFpuStateActualizeSseForRead(pVCpu);
    69096845#endif
    6910     PCPUMCTX pCtx = IEM_GET_CTX(pVCpu);
    6911     IEM_CTX_IMPORT_NORET(pVCpu, pCtx, CPUMCTX_EXTRN_X87 | CPUMCTX_EXTRN_SSE_AVX | CPUMCTX_EXTRN_OTHER_XSAVE | CPUMCTX_EXTRN_XCRx);
     6846    IEM_CTX_IMPORT_NORET(pVCpu, CPUMCTX_EXTRN_X87 | CPUMCTX_EXTRN_SSE_AVX | CPUMCTX_EXTRN_OTHER_XSAVE | CPUMCTX_EXTRN_XCRx);
    69126847}
    69136848
    … …  
    69286863    CPUMRZFpuStateActualizeForChange(pVCpu);
    69296864#endif
    6930     PCPUMCTX pCtx = IEM_GET_CTX(pVCpu);
    6931     IEM_CTX_IMPORT_NORET(pVCpu, pCtx, CPUMCTX_EXTRN_X87 | CPUMCTX_EXTRN_SSE_AVX | CPUMCTX_EXTRN_OTHER_XSAVE | CPUMCTX_EXTRN_XCRx);
     6865    IEM_CTX_IMPORT_NORET(pVCpu, CPUMCTX_EXTRN_X87 | CPUMCTX_EXTRN_SSE_AVX | CPUMCTX_EXTRN_OTHER_XSAVE | CPUMCTX_EXTRN_XCRx);
    69326866}
    69336867
    … …  
    69486882    CPUMRZFpuStateActualizeAvxForRead(pVCpu);
    69496883#endif
    6950     PCPUMCTX pCtx = IEM_GET_CTX(pVCpu);
    6951     IEM_CTX_IMPORT_NORET(pVCpu, pCtx, CPUMCTX_EXTRN_X87 | CPUMCTX_EXTRN_SSE_AVX | CPUMCTX_EXTRN_OTHER_XSAVE | CPUMCTX_EXTRN_XCRx);
     6884    IEM_CTX_IMPORT_NORET(pVCpu, CPUMCTX_EXTRN_X87 | CPUMCTX_EXTRN_SSE_AVX | CPUMCTX_EXTRN_OTHER_XSAVE | CPUMCTX_EXTRN_XCRx);
    69526885}
    69536886
    … …  
    69686901    CPUMRZFpuStateActualizeForChange(pVCpu);
    69696902#endif
    6970     PCPUMCTX pCtx = IEM_GET_CTX(pVCpu);
    6971     IEM_CTX_IMPORT_NORET(pVCpu, pCtx, CPUMCTX_EXTRN_X87 | CPUMCTX_EXTRN_SSE_AVX | CPUMCTX_EXTRN_OTHER_XSAVE | CPUMCTX_EXTRN_XCRx);
     6903    IEM_CTX_IMPORT_NORET(pVCpu, CPUMCTX_EXTRN_X87 | CPUMCTX_EXTRN_SSE_AVX | CPUMCTX_EXTRN_OTHER_XSAVE | CPUMCTX_EXTRN_XCRx);
    69726904}
    69736905
    … …  
    69906922 *
    69916923 * @param   pVCpu               The cross context virtual CPU structure of the calling thread.
    6992  * @param   pCtx                The CPU context.
    69936924 * @param   pFpuCtx             The FPU context.
    69946925 */
    6995 DECLINLINE(void) iemFpuUpdateOpcodeAndIpWorker(PVMCPU pVCpu, PCPUMCTX pCtx, PX86FXSTATE pFpuCtx)
     6926DECLINLINE(void) iemFpuUpdateOpcodeAndIpWorker(PVMCPU pVCpu, PX86FXSTATE pFpuCtx)
    69966927{
    69976928    Assert(pVCpu->iem.s.uFpuOpcode != UINT16_MAX);
    … …  
    70036934         *        happens in real mode here based on the fnsave and fnstenv images. */
    70046935        pFpuCtx->CS    = 0;
    7005         pFpuCtx->FPUIP = pCtx->eip | ((uint32_t)pCtx->cs.Sel << 4);
     6936        pFpuCtx->FPUIP = pVCpu->cpum.GstCtx.eip | ((uint32_t)pVCpu->cpum.GstCtx.cs.Sel << 4);
    70066937    }
    70076938    else
    70086939    {
    7009         pFpuCtx->CS    = pCtx->cs.Sel;
    7010         pFpuCtx->FPUIP = pCtx->rip;
     6940        pFpuCtx->CS    = pVCpu->cpum.GstCtx.cs.Sel;
     6941        pFpuCtx->FPUIP = pVCpu->cpum.GstCtx.rip;
    70116942    }
    70126943}
    … …  
    70176948 *
    70186949 * @param   pVCpu               The cross context virtual CPU structure of the calling thread.
    7019  * @param   pCtx                The CPU context.
    70206950 * @param   pFpuCtx             The FPU context.
    70216951 * @param   iEffSeg             The effective segment register.
    70226952 * @param   GCPtrEff            The effective address relative to @a iEffSeg.
    70236953 */
    7024 DECLINLINE(void) iemFpuUpdateDP(PVMCPU pVCpu, PCPUMCTX pCtx, PX86FXSTATE pFpuCtx, uint8_t iEffSeg, RTGCPTR GCPtrEff)
     6954DECLINLINE(void) iemFpuUpdateDP(PVMCPU pVCpu, PX86FXSTATE pFpuCtx, uint8_t iEffSeg, RTGCPTR GCPtrEff)
    70256955{
    70266956    RTSEL sel;
    70276957    switch (iEffSeg)
    70286958    {
    7029         case X86_SREG_DS: sel = pCtx->ds.Sel; break;
    7030         case X86_SREG_SS: sel = pCtx->ss.Sel; break;
    7031         case X86_SREG_CS: sel = pCtx->cs.Sel; break;
    7032         case X86_SREG_ES: sel = pCtx->es.Sel; break;
    7033         case X86_SREG_FS: sel = pCtx->fs.Sel; break;
    7034         case X86_SREG_GS: sel = pCtx->gs.Sel; break;
     6959        case X86_SREG_DS: sel = pVCpu->cpum.GstCtx.ds.Sel; break;
     6960        case X86_SREG_SS: sel = pVCpu->cpum.GstCtx.ss.Sel; break;
     6961        case X86_SREG_CS: sel = pVCpu->cpum.GstCtx.cs.Sel; break;
     6962        case X86_SREG_ES: sel = pVCpu->cpum.GstCtx.es.Sel; break;
     6963        case X86_SREG_FS: sel = pVCpu->cpum.GstCtx.fs.Sel; break;
     6964        case X86_SREG_GS: sel = pVCpu->cpum.GstCtx.gs.Sel; break;
    70356965        default:
    70366966            AssertMsgFailed(("%d\n", iEffSeg));
    7037             sel = pCtx->ds.Sel;
     6967            sel = pVCpu->cpum.GstCtx.ds.Sel;
    70386968    }
    70396969    /** @todo pFpuCtx->DS and FPUDP needs to be kept seperately. */
    … …  
    72097139IEM_STATIC void iemFpuPushResult(PVMCPU pVCpu, PIEMFPURESULT pResult)
    72107140{
    7211     PCPUMCTX    pCtx    = IEM_GET_CTX(pVCpu);
    7212     PX86FXSTATE pFpuCtx = &pCtx->CTX_SUFF(pXState)->x87;
    7213     iemFpuUpdateOpcodeAndIpWorker(pVCpu, pCtx, pFpuCtx);
     7141    PX86FXSTATE pFpuCtx = &pVCpu->cpum.GstCtx.CTX_SUFF(pXState)->x87;
     7142    iemFpuUpdateOpcodeAndIpWorker(pVCpu, pFpuCtx);
    72147143    iemFpuMaybePushResult(pResult, pFpuCtx);
    72157144}
    … …  
    72277156IEM_STATIC void iemFpuPushResultWithMemOp(PVMCPU pVCpu, PIEMFPURESULT pResult, uint8_t iEffSeg, RTGCPTR GCPtrEff)
    72287157{
    7229     PCPUMCTX    pCtx    = IEM_GET_CTX(pVCpu);
    7230     PX86FXSTATE pFpuCtx = &pCtx->CTX_SUFF(pXState)->x87;
    7231     iemFpuUpdateDP(pVCpu, pCtx, pFpuCtx, iEffSeg, GCPtrEff);
    7232     iemFpuUpdateOpcodeAndIpWorker(pVCpu, pCtx, pFpuCtx);
     7158    PX86FXSTATE pFpuCtx = &pVCpu->cpum.GstCtx.CTX_SUFF(pXState)->x87;
     7159    iemFpuUpdateDP(pVCpu, pFpuCtx, iEffSeg, GCPtrEff);
     7160    iemFpuUpdateOpcodeAndIpWorker(pVCpu, pFpuCtx);
    72337161    iemFpuMaybePushResult(pResult, pFpuCtx);
    72347162}
    … …  
    72447172IEM_STATIC void iemFpuPushResultTwo(PVMCPU pVCpu, PIEMFPURESULTTWO pResult)
    72457173{
    7246     PCPUMCTX    pCtx    = IEM_GET_CTX(pVCpu);
    7247     PX86FXSTATE pFpuCtx = &pCtx->CTX_SUFF(pXState)->x87;
    7248     iemFpuUpdateOpcodeAndIpWorker(pVCpu, pCtx, pFpuCtx);
     7174    PX86FXSTATE pFpuCtx = &pVCpu->cpum.GstCtx.CTX_SUFF(pXState)->x87;
     7175    iemFpuUpdateOpcodeAndIpWorker(pVCpu, pFpuCtx);
    72497176
    72507177    /* Update FSW and bail if there are pending exceptions afterwards. */
    … …  
    72997226IEM_STATIC void iemFpuStoreResult(PVMCPU pVCpu, PIEMFPURESULT pResult, uint8_t iStReg)
    73007227{
    7301     PCPUMCTX    pCtx    = IEM_GET_CTX(pVCpu);
    7302     PX86FXSTATE pFpuCtx = &pCtx->CTX_SUFF(pXState)->x87;
    7303     iemFpuUpdateOpcodeAndIpWorker(pVCpu, pCtx, pFpuCtx);
     7228    PX86FXSTATE pFpuCtx = &pVCpu->cpum.GstCtx.CTX_SUFF(pXState)->x87;
     7229    iemFpuUpdateOpcodeAndIpWorker(pVCpu, pFpuCtx);
    73047230    iemFpuStoreResultOnly(pFpuCtx, pResult, iStReg);
    73057231}
    … …  
    73167242IEM_STATIC void iemFpuStoreResultThenPop(PVMCPU pVCpu, PIEMFPURESULT pResult, uint8_t iStReg)
    73177243{
    7318     PCPUMCTX    pCtx    = IEM_GET_CTX(pVCpu);
    7319     PX86FXSTATE pFpuCtx = &pCtx->CTX_SUFF(pXState)->x87;
    7320     iemFpuUpdateOpcodeAndIpWorker(pVCpu, pCtx, pFpuCtx);
     7244    PX86FXSTATE pFpuCtx = &pVCpu->cpum.GstCtx.CTX_SUFF(pXState)->x87;
     7245    iemFpuUpdateOpcodeAndIpWorker(pVCpu, pFpuCtx);
    73217246    iemFpuStoreResultOnly(pFpuCtx, pResult, iStReg);
    73227247    iemFpuMaybePopOne(pFpuCtx);
    … …  
    73377262                                           uint8_t iEffSeg, RTGCPTR GCPtrEff)
    73387263{
    7339     PCPUMCTX    pCtx    = IEM_GET_CTX(pVCpu);
    7340     PX86FXSTATE pFpuCtx = &pCtx->CTX_SUFF(pXState)->x87;
    7341     iemFpuUpdateDP(pVCpu, pCtx, pFpuCtx, iEffSeg, GCPtrEff);
    7342     iemFpuUpdateOpcodeAndIpWorker(pVCpu, pCtx, pFpuCtx);
     7264    PX86FXSTATE pFpuCtx = &pVCpu->cpum.GstCtx.CTX_SUFF(pXState)->x87;
     7265    iemFpuUpdateDP(pVCpu, pFpuCtx, iEffSeg, GCPtrEff);
     7266    iemFpuUpdateOpcodeAndIpWorker(pVCpu, pFpuCtx);
    73437267    iemFpuStoreResultOnly(pFpuCtx, pResult, iStReg);
    73447268}
    … …  
    73587282                                                  uint8_t iStReg, uint8_t iEffSeg, RTGCPTR GCPtrEff)
    73597283{
    7360     PCPUMCTX    pCtx    = IEM_GET_CTX(pVCpu);
    7361     PX86FXSTATE pFpuCtx = &pCtx->CTX_SUFF(pXState)->x87;
    7362     iemFpuUpdateDP(pVCpu, pCtx, pFpuCtx, iEffSeg, GCPtrEff);
    7363     iemFpuUpdateOpcodeAndIpWorker(pVCpu, pCtx, pFpuCtx);
     7284    PX86FXSTATE pFpuCtx = &pVCpu->cpum.GstCtx.CTX_SUFF(pXState)->x87;
     7285    iemFpuUpdateDP(pVCpu, pFpuCtx, iEffSeg, GCPtrEff);
     7286    iemFpuUpdateOpcodeAndIpWorker(pVCpu, pFpuCtx);
    73647287    iemFpuStoreResultOnly(pFpuCtx, pResult, iStReg);
    73657288    iemFpuMaybePopOne(pFpuCtx);
    … …  
    73747297IEM_STATIC void iemFpuUpdateOpcodeAndIp(PVMCPU pVCpu)
    73757298{
    7376     PCPUMCTX    pCtx    = IEM_GET_CTX(pVCpu);
    7377     PX86FXSTATE pFpuCtx = &pCtx->CTX_SUFF(pXState)->x87;
    7378     iemFpuUpdateOpcodeAndIpWorker(pVCpu, pCtx, pFpuCtx);
     7299    PX86FXSTATE pFpuCtx = &pVCpu->cpum.GstCtx.CTX_SUFF(pXState)->x87;
     7300    iemFpuUpdateOpcodeAndIpWorker(pVCpu, pFpuCtx);
    73797301}
    73807302
    … …  
    74377359IEM_STATIC void iemFpuUpdateFSW(PVMCPU pVCpu, uint16_t u16FSW)
    74387360{
    7439     PCPUMCTX    pCtx    = IEM_GET_CTX(pVCpu);
    7440     PX86FXSTATE pFpuCtx = &pCtx->CTX_SUFF(pXState)->x87;
    7441     iemFpuUpdateOpcodeAndIpWorker(pVCpu, pCtx, pFpuCtx);
     7361    PX86FXSTATE pFpuCtx = &pVCpu->cpum.GstCtx.CTX_SUFF(pXState)->x87;
     7362    iemFpuUpdateOpcodeAndIpWorker(pVCpu, pFpuCtx);
    74427363    iemFpuUpdateFSWOnly(pFpuCtx, u16FSW);
    74437364}
    … …  
    74527373IEM_STATIC void iemFpuUpdateFSWThenPop(PVMCPU pVCpu, uint16_t u16FSW)
    74537374{
    7454     PCPUMCTX    pCtx    = IEM_GET_CTX(pVCpu);
    7455     PX86FXSTATE pFpuCtx = &pCtx->CTX_SUFF(pXState)->x87;
    7456     iemFpuUpdateOpcodeAndIpWorker(pVCpu, pCtx, pFpuCtx);
     7375    PX86FXSTATE pFpuCtx = &pVCpu->cpum.GstCtx.CTX_SUFF(pXState)->x87;
     7376    iemFpuUpdateOpcodeAndIpWorker(pVCpu, pFpuCtx);
    74577377    iemFpuUpdateFSWOnly(pFpuCtx, u16FSW);
    74587378    iemFpuMaybePopOne(pFpuCtx);
    … …  
    74707390IEM_STATIC void iemFpuUpdateFSWWithMemOp(PVMCPU pVCpu, uint16_t u16FSW, uint8_t iEffSeg, RTGCPTR GCPtrEff)
    74717391{
    7472     PCPUMCTX    pCtx    = IEM_GET_CTX(pVCpu);
    7473     PX86FXSTATE pFpuCtx = &pCtx->CTX_SUFF(pXState)->x87;
    7474     iemFpuUpdateDP(pVCpu, pCtx, pFpuCtx, iEffSeg, GCPtrEff);
    7475     iemFpuUpdateOpcodeAndIpWorker(pVCpu, pCtx, pFpuCtx);
     7392    PX86FXSTATE pFpuCtx = &pVCpu->cpum.GstCtx.CTX_SUFF(pXState)->x87;
     7393    iemFpuUpdateDP(pVCpu, pFpuCtx, iEffSeg, GCPtrEff);
     7394    iemFpuUpdateOpcodeAndIpWorker(pVCpu, pFpuCtx);
    74767395    iemFpuUpdateFSWOnly(pFpuCtx, u16FSW);
    74777396}
    … …  
    74867405IEM_STATIC void iemFpuUpdateFSWThenPopPop(PVMCPU pVCpu, uint16_t u16FSW)
    74877406{
    7488     PCPUMCTX    pCtx    = IEM_GET_CTX(pVCpu);
    7489     PX86FXSTATE pFpuCtx = &pCtx->CTX_SUFF(pXState)->x87;
    7490     iemFpuUpdateOpcodeAndIpWorker(pVCpu, pCtx, pFpuCtx);
     7407    PX86FXSTATE pFpuCtx = &pVCpu->cpum.GstCtx.CTX_SUFF(pXState)->x87;
     7408    iemFpuUpdateOpcodeAndIpWorker(pVCpu, pFpuCtx);
    74917409    iemFpuUpdateFSWOnly(pFpuCtx, u16FSW);
    74927410    iemFpuMaybePopOne(pFpuCtx);
    … …  
    75057423IEM_STATIC void iemFpuUpdateFSWWithMemOpThenPop(PVMCPU pVCpu, uint16_t u16FSW, uint8_t iEffSeg, RTGCPTR GCPtrEff)
    75067424{
    7507     PCPUMCTX    pCtx    = IEM_GET_CTX(pVCpu);
    7508     PX86FXSTATE pFpuCtx = &pCtx->CTX_SUFF(pXState)->x87;
    7509     iemFpuUpdateDP(pVCpu, pCtx, pFpuCtx, iEffSeg, GCPtrEff);
    7510     iemFpuUpdateOpcodeAndIpWorker(pVCpu, pCtx, pFpuCtx);
     7425    PX86FXSTATE pFpuCtx = &pVCpu->cpum.GstCtx.CTX_SUFF(pXState)->x87;
     7426    iemFpuUpdateDP(pVCpu, pFpuCtx, iEffSeg, GCPtrEff);
     7427    iemFpuUpdateOpcodeAndIpWorker(pVCpu, pFpuCtx);
    75117428    iemFpuUpdateFSWOnly(pFpuCtx, u16FSW);
    75127429    iemFpuMaybePopOne(pFpuCtx);
    … …  
    75537470DECL_NO_INLINE(IEM_STATIC, void) iemFpuStackUnderflow(PVMCPU pVCpu, uint8_t iStReg)
    75547471{
    7555     PCPUMCTX    pCtx    = IEM_GET_CTX(pVCpu);
    7556     PX86FXSTATE pFpuCtx = &pCtx->CTX_SUFF(pXState)->x87;
    7557     iemFpuUpdateOpcodeAndIpWorker(pVCpu, pCtx, pFpuCtx);
     7472    PX86FXSTATE pFpuCtx = &pVCpu->cpum.GstCtx.CTX_SUFF(pXState)->x87;
     7473    iemFpuUpdateOpcodeAndIpWorker(pVCpu, pFpuCtx);
    75587474    iemFpuStackUnderflowOnly(pFpuCtx, iStReg);
    75597475}
    … …  
    75637479iemFpuStackUnderflowWithMemOp(PVMCPU pVCpu, uint8_t iStReg, uint8_t iEffSeg, RTGCPTR GCPtrEff)
    75647480{
    7565     PCPUMCTX    pCtx    = IEM_GET_CTX(pVCpu);
    7566     PX86FXSTATE pFpuCtx = &pCtx->CTX_SUFF(pXState)->x87;
    7567     iemFpuUpdateDP(pVCpu, pCtx, pFpuCtx, iEffSeg, GCPtrEff);
    7568     iemFpuUpdateOpcodeAndIpWorker(pVCpu, pCtx, pFpuCtx);
     7481    PX86FXSTATE pFpuCtx = &pVCpu->cpum.GstCtx.CTX_SUFF(pXState)->x87;
     7482    iemFpuUpdateDP(pVCpu, pFpuCtx, iEffSeg, GCPtrEff);
     7483    iemFpuUpdateOpcodeAndIpWorker(pVCpu, pFpuCtx);
    75697484    iemFpuStackUnderflowOnly(pFpuCtx, iStReg);
    75707485}
    … …  
    75737488DECL_NO_INLINE(IEM_STATIC, void) iemFpuStackUnderflowThenPop(PVMCPU pVCpu, uint8_t iStReg)
    75747489{
    7575     PCPUMCTX    pCtx    = IEM_GET_CTX(pVCpu);
    7576     PX86FXSTATE pFpuCtx = &pCtx->CTX_SUFF(pXState)->x87;
    7577     iemFpuUpdateOpcodeAndIpWorker(pVCpu, pCtx, pFpuCtx);
     7490    PX86FXSTATE pFpuCtx = &pVCpu->cpum.GstCtx.CTX_SUFF(pXState)->x87;
     7491    iemFpuUpdateOpcodeAndIpWorker(pVCpu, pFpuCtx);
    75787492    iemFpuStackUnderflowOnly(pFpuCtx, iStReg);
    75797493    iemFpuMaybePopOne(pFpuCtx);
    … …  
    75847498iemFpuStackUnderflowWithMemOpThenPop(PVMCPU pVCpu, uint8_t iStReg, uint8_t iEffSeg, RTGCPTR GCPtrEff)
    75857499{
    7586     PCPUMCTX    pCtx      = IEM_GET_CTX(pVCpu);
    7587     PX86FXSTATE pFpuCtx = &pCtx->CTX_SUFF(pXState)->x87;
    7588     iemFpuUpdateDP(pVCpu, pCtx, pFpuCtx, iEffSeg, GCPtrEff);
    7589     iemFpuUpdateOpcodeAndIpWorker(pVCpu, pCtx, pFpuCtx);
     7500    PX86FXSTATE pFpuCtx = &pVCpu->cpum.GstCtx.CTX_SUFF(pXState)->x87;
     7501    iemFpuUpdateDP(pVCpu, pFpuCtx, iEffSeg, GCPtrEff);
     7502    iemFpuUpdateOpcodeAndIpWorker(pVCpu, pFpuCtx);
    75907503    iemFpuStackUnderflowOnly(pFpuCtx, iStReg);
    75917504    iemFpuMaybePopOne(pFpuCtx);
    … …  
    75957508DECL_NO_INLINE(IEM_STATIC, void) iemFpuStackUnderflowThenPopPop(PVMCPU pVCpu)
    75967509{
    7597     PCPUMCTX    pCtx    = IEM_GET_CTX(pVCpu);
    7598     PX86FXSTATE pFpuCtx = &pCtx->CTX_SUFF(pXState)->x87;
    7599     iemFpuUpdateOpcodeAndIpWorker(pVCpu, pCtx, pFpuCtx);
     7510    PX86FXSTATE pFpuCtx = &pVCpu->cpum.GstCtx.CTX_SUFF(pXState)->x87;
     7511    iemFpuUpdateOpcodeAndIpWorker(pVCpu, pFpuCtx);
    76007512    iemFpuStackUnderflowOnly(pFpuCtx, UINT8_MAX);
    76017513    iemFpuMaybePopOne(pFpuCtx);
    … …  
    76077519iemFpuStackPushUnderflow(PVMCPU pVCpu)
    76087520{
    7609     PCPUMCTX    pCtx    = IEM_GET_CTX(pVCpu);
    7610     PX86FXSTATE pFpuCtx = &pCtx->CTX_SUFF(pXState)->x87;
    7611     iemFpuUpdateOpcodeAndIpWorker(pVCpu, pCtx, pFpuCtx);
     7521    PX86FXSTATE pFpuCtx = &pVCpu->cpum.GstCtx.CTX_SUFF(pXState)->x87;
     7522    iemFpuUpdateOpcodeAndIpWorker(pVCpu, pFpuCtx);
    76127523
    76137524    if (pFpuCtx->FCW & X86_FCW_IM)
    … …  
    76347545iemFpuStackPushUnderflowTwo(PVMCPU pVCpu)
    76357546{
    7636     PCPUMCTX    pCtx    = IEM_GET_CTX(pVCpu);
    7637     PX86FXSTATE pFpuCtx = &pCtx->CTX_SUFF(pXState)->x87;
    7638     iemFpuUpdateOpcodeAndIpWorker(pVCpu, pCtx, pFpuCtx);
     7547    PX86FXSTATE pFpuCtx = &pVCpu->cpum.GstCtx.CTX_SUFF(pXState)->x87;
     7548    iemFpuUpdateOpcodeAndIpWorker(pVCpu, pFpuCtx);
    76397549
    76407550    if (pFpuCtx->FCW & X86_FCW_IM)
    … …  
    76937603DECL_NO_INLINE(IEM_STATIC, void) iemFpuStackPushOverflow(PVMCPU pVCpu)
    76947604{
    7695     PCPUMCTX    pCtx    = IEM_GET_CTX(pVCpu);
    7696     PX86FXSTATE pFpuCtx = &pCtx->CTX_SUFF(pXState)->x87;
    7697     iemFpuUpdateOpcodeAndIpWorker(pVCpu, pCtx, pFpuCtx);
     7605    PX86FXSTATE pFpuCtx = &pVCpu->cpum.GstCtx.CTX_SUFF(pXState)->x87;
     7606    iemFpuUpdateOpcodeAndIpWorker(pVCpu, pFpuCtx);
    76987607    iemFpuStackPushOverflowOnly(pFpuCtx);
    76997608}
    … …  
    77107619iemFpuStackPushOverflowWithMemOp(PVMCPU pVCpu, uint8_t iEffSeg, RTGCPTR GCPtrEff)
    77117620{
    7712     PCPUMCTX    pCtx    = IEM_GET_CTX(pVCpu);
    7713     PX86FXSTATE pFpuCtx = &pCtx->CTX_SUFF(pXState)->x87;
    7714     iemFpuUpdateDP(pVCpu, pCtx, pFpuCtx, iEffSeg, GCPtrEff);
    7715     iemFpuUpdateOpcodeAndIpWorker(pVCpu, pCtx, pFpuCtx);
     7621    PX86FXSTATE pFpuCtx = &pVCpu->cpum.GstCtx.CTX_SUFF(pXState)->x87;
     7622    iemFpuUpdateDP(pVCpu, pFpuCtx, iEffSeg, GCPtrEff);
     7623    iemFpuUpdateOpcodeAndIpWorker(pVCpu, pFpuCtx);
    77167624    iemFpuStackPushOverflowOnly(pFpuCtx);
    77177625}
    … …  
    78907798iemMemSegCheckWriteAccessEx(PVMCPU pVCpu, PCCPUMSELREGHID pHid, uint8_t iSegReg, uint64_t *pu64BaseAddr)
    78917799{
    7892     IEM_CTX_ASSERT(IEM_GET_CTX(pVCpu), CPUMCTX_EXTRN_SREG_FROM_IDX(iSegReg));
     7800    IEM_CTX_ASSERT(pVCpu, CPUMCTX_EXTRN_SREG_FROM_IDX(iSegReg));
    78937801
    78947802    if (pVCpu->iem.s.enmCpuMode == IEMMODE_64BIT)
    … …  
    79307838iemMemSegCheckReadAccessEx(PVMCPU pVCpu, PCCPUMSELREGHID pHid, uint8_t iSegReg, uint64_t *pu64BaseAddr)
    79317839{
    7932     IEM_CTX_ASSERT(IEM_GET_CTX(pVCpu), CPUMCTX_EXTRN_SREG_FROM_IDX(iSegReg));
     7840    IEM_CTX_ASSERT(pVCpu, CPUMCTX_EXTRN_SREG_FROM_IDX(iSegReg));
    79337841
    79347842    if (pVCpu->iem.s.enmCpuMode == IEMMODE_64BIT)
    … …  
    79747882        return VINF_SUCCESS;
    79757883
    7976     IEM_CTX_IMPORT_RET(pVCpu, IEM_GET_CTX(pVCpu), CPUMCTX_EXTRN_SREG_FROM_IDX(iSegReg));
     7884    IEM_CTX_IMPORT_RET(pVCpu, CPUMCTX_EXTRN_SREG_FROM_IDX(iSegReg));
    79777885    PCPUMSELREGHID pSel = iemSRegGetHid(pVCpu, iSegReg);
    79787886    switch (pVCpu->iem.s.enmCpuMode)
    … …  
    91359043        if (iSegReg >= X86_SREG_FS)
    91369044        {
    9137             IEM_CTX_IMPORT_JMP(pVCpu, IEM_GET_CTX(pVCpu), CPUMCTX_EXTRN_SREG_FROM_IDX(iSegReg));
     9045            IEM_CTX_IMPORT_JMP(pVCpu, CPUMCTX_EXTRN_SREG_FROM_IDX(iSegReg));
    91389046            PCPUMSELREGHID pSel = iemSRegGetHid(pVCpu, iSegReg);
    91399047            GCPtrMem += pSel->u64Base;
    … …  
    91489056    else
    91499057    {
    9150         IEM_CTX_IMPORT_JMP(pVCpu, IEM_GET_CTX(pVCpu), CPUMCTX_EXTRN_SREG_FROM_IDX(iSegReg));
     9058        IEM_CTX_IMPORT_JMP(pVCpu, CPUMCTX_EXTRN_SREG_FROM_IDX(iSegReg));
    91519059        PCPUMSELREGHID pSel = iemSRegGetHid(pVCpu, iSegReg);
    91529060        if (      (pSel->Attr.u & (X86DESCATTR_P | X86DESCATTR_UNUSABLE | X86_SEL_TYPE_CODE | X86_SEL_TYPE_DOWN))
    … …  
    91919099        if (iSegReg >= X86_SREG_FS)
    91929100        {
    9193             IEM_CTX_IMPORT_JMP(pVCpu, IEM_GET_CTX(pVCpu), CPUMCTX_EXTRN_SREG_FROM_IDX(iSegReg));
     9101            IEM_CTX_IMPORT_JMP(pVCpu, CPUMCTX_EXTRN_SREG_FROM_IDX(iSegReg));
    91949102            PCPUMSELREGHID pSel = iemSRegGetHid(pVCpu, iSegReg);
    91959103            GCPtrMem += pSel->u64Base;
    … …  
    92049112    else
    92059113    {
    9206         IEM_CTX_IMPORT_JMP(pVCpu, IEM_GET_CTX(pVCpu), CPUMCTX_EXTRN_SREG_FROM_IDX(iSegReg));
     9114        IEM_CTX_IMPORT_JMP(pVCpu, CPUMCTX_EXTRN_SREG_FROM_IDX(iSegReg));
    92079115        PCPUMSELREGHID pSel           = iemSRegGetHid(pVCpu, iSegReg);
    92089116        uint32_t const fRelevantAttrs = pSel->Attr.u & (  X86DESCATTR_P     | X86DESCATTR_UNUSABLE
    … …  
    1019910107    /* Increment the stack pointer. */
    1020010108    uint64_t    uNewRsp;
    10201     PCPUMCTX    pCtx     = IEM_GET_CTX(pVCpu);
    10202     RTGCPTR     GCPtrTop = iemRegGetRspForPush(pVCpu, pCtx, 2, &uNewRsp);
     10109    RTGCPTR     GCPtrTop = iemRegGetRspForPush(pVCpu, 2, &uNewRsp);
    1020310110
    1020410111    /* Write the word the lazy way. */
    … …  
    1021310120    /* Commit the new RSP value unless we an access handler made trouble. */
    1021410121    if (rc == VINF_SUCCESS)
    10215         pCtx->rsp = uNewRsp;
     10122        pVCpu->cpum.GstCtx.rsp = uNewRsp;
    1021610123
    1021710124    return rc;
    … …  
    1023010137    /* Increment the stack pointer. */
    1023110138    uint64_t    uNewRsp;
    10232     PCPUMCTX    pCtx     = IEM_GET_CTX(pVCpu);
    10233     RTGCPTR     GCPtrTop = iemRegGetRspForPush(pVCpu, pCtx, 4, &uNewRsp);
     10139    RTGCPTR     GCPtrTop = iemRegGetRspForPush(pVCpu, 4, &uNewRsp);
    1023410140
    1023510141    /* Write the dword the lazy way. */
    … …  
    1024410150    /* Commit the new RSP value unless we an access handler made trouble. */
    1024510151    if (rc == VINF_SUCCESS)
    10246         pCtx->rsp = uNewRsp;
     10152        pVCpu->cpum.GstCtx.rsp = uNewRsp;
    1024710153
    1024810154    return rc;
    … …  
    1026110167    /* Increment the stack pointer. */
    1026210168    uint64_t    uNewRsp;
    10263     PCPUMCTX    pCtx     = IEM_GET_CTX(pVCpu);
    10264     RTGCPTR     GCPtrTop = iemRegGetRspForPush(pVCpu, pCtx, 4, &uNewRsp);
     10169    RTGCPTR     GCPtrTop = iemRegGetRspForPush(pVCpu, 4, &uNewRsp);
    1026510170
    1026610171    /* The intel docs talks about zero extending the selector register
    … …  
    1028410189    /* Commit the new RSP value unless we an access handler made trouble. */
    1028510190    if (rc == VINF_SUCCESS)
    10286         pCtx->rsp = uNewRsp;
     10191        pVCpu->cpum.GstCtx.rsp = uNewRsp;
    1028710192
    1028810193    return rc;
    … …  
    1030110206    /* Increment the stack pointer. */
    1030210207    uint64_t    uNewRsp;
    10303     PCPUMCTX    pCtx     = IEM_GET_CTX(pVCpu);
    10304     RTGCPTR     GCPtrTop = iemRegGetRspForPush(pVCpu, pCtx, 8, &uNewRsp);
     10208    RTGCPTR     GCPtrTop = iemRegGetRspForPush(pVCpu, 8, &uNewRsp);
    1030510209
    1030610210    /* Write the word the lazy way. */
    … …  
    1031510219    /* Commit the new RSP value unless we an access handler made trouble. */
    1031610220    if (rc == VINF_SUCCESS)
    10317         pCtx->rsp = uNewRsp;
     10221        pVCpu->cpum.GstCtx.rsp = uNewRsp;
    1031810222
    1031910223    return rc;
    … …  
    1033210236    /* Increment the stack pointer. */
    1033310237    uint64_t    uNewRsp;
    10334     PCPUMCTX    pCtx     = IEM_GET_CTX(pVCpu);
    10335     RTGCPTR     GCPtrTop = iemRegGetRspForPop(pVCpu, pCtx, 2, &uNewRsp);
     10238    RTGCPTR     GCPtrTop = iemRegGetRspForPop(pVCpu, 2, &uNewRsp);
    1033610239
    1033710240    /* Write the word the lazy way. */
    … …  
    1034510248        /* Commit the new RSP value. */
    1034610249        if (rc == VINF_SUCCESS)
    10347             pCtx->rsp = uNewRsp;
     10250            pVCpu->cpum.GstCtx.rsp = uNewRsp;
    1034810251    }
    1034910252
    … …  
    1036310266    /* Increment the stack pointer. */
    1036410267    uint64_t    uNewRsp;
    10365     PCPUMCTX    pCtx     = IEM_GET_CTX(pVCpu);
    10366     RTGCPTR     GCPtrTop = iemRegGetRspForPop(pVCpu, pCtx, 4, &uNewRsp);
     10268    RTGCPTR     GCPtrTop = iemRegGetRspForPop(pVCpu, 4, &uNewRsp);
    1036710269
    1036810270    /* Write the word the lazy way. */
    … …  
    1037610278        /* Commit the new RSP value. */
    1037710279        if (rc == VINF_SUCCESS)
    10378             pCtx->rsp = uNewRsp;
     10280            pVCpu->cpum.GstCtx.rsp = uNewRsp;
    1037910281    }
    1038010282
    … …  
    1039410296    /* Increment the stack pointer. */
    1039510297    uint64_t    uNewRsp;
    10396     PCPUMCTX    pCtx     = IEM_GET_CTX(pVCpu);
    10397     RTGCPTR     GCPtrTop = iemRegGetRspForPop(pVCpu, pCtx, 8, &uNewRsp);
     10298    RTGCPTR     GCPtrTop = iemRegGetRspForPop(pVCpu, 8, &uNewRsp);
    1039810299
    1039910300    /* Write the word the lazy way. */
    … …  
    1040710308        /* Commit the new RSP value. */
    1040810309        if (rc == VINF_SUCCESS)
    10409             pCtx->rsp = uNewRsp;
     10310            pVCpu->cpum.GstCtx.rsp = uNewRsp;
    1041010311    }
    1041110312
    … …  
    1042510326{
    1042610327    /* Increment the stack pointer. */
    10427     PCPUMCTX    pCtx = IEM_GET_CTX(pVCpu);
    1042810328    RTUINT64U   NewRsp = *pTmpRsp;
    10429     RTGCPTR     GCPtrTop = iemRegGetRspForPushEx(pVCpu, pCtx, &NewRsp, 2);
     10329    RTGCPTR     GCPtrTop = iemRegGetRspForPushEx(pVCpu, &NewRsp, 2);
    1043010330
    1043110331    /* Write the word the lazy way. */
    … …  
    1045710357{
    1045810358    /* Increment the stack pointer. */
    10459     PCPUMCTX    pCtx = IEM_GET_CTX(pVCpu);
    1046010359    RTUINT64U   NewRsp = *pTmpRsp;
    10461     RTGCPTR     GCPtrTop = iemRegGetRspForPushEx(pVCpu, pCtx, &NewRsp, 4);
     10360    RTGCPTR     GCPtrTop = iemRegGetRspForPushEx(pVCpu, &NewRsp, 4);
    1046210361
    1046310362    /* Write the word the lazy way. */
    … …  
    1048910388{
    1049010389    /* Increment the stack pointer. */
    10491     PCPUMCTX    pCtx = IEM_GET_CTX(pVCpu);
    1049210390    RTUINT64U   NewRsp = *pTmpRsp;
    10493     RTGCPTR     GCPtrTop = iemRegGetRspForPushEx(pVCpu, pCtx, &NewRsp, 8);
     10391    RTGCPTR     GCPtrTop = iemRegGetRspForPushEx(pVCpu, &NewRsp, 8);
    1049410392
    1049510393    /* Write the word the lazy way. */
    … …  
    1052110419{
    1052210420    /* Increment the stack pointer. */
    10523     PCPUMCTX    pCtx = IEM_GET_CTX(pVCpu);
    1052410421    RTUINT64U   NewRsp = *pTmpRsp;
    10525     RTGCPTR     GCPtrTop = iemRegGetRspForPopEx(pVCpu, pCtx, &NewRsp, 2);
     10422    RTGCPTR     GCPtrTop = iemRegGetRspForPopEx(pVCpu, &NewRsp, 2);
    1052610423
    1052710424    /* Write the word the lazy way. */
    … …  
    1055310450{
    1055410451    /* Increment the stack pointer. */
    10555     PCPUMCTX    pCtx = IEM_GET_CTX(pVCpu);
    1055610452    RTUINT64U   NewRsp = *pTmpRsp;
    10557     RTGCPTR     GCPtrTop = iemRegGetRspForPopEx(pVCpu, pCtx, &NewRsp, 4);
     10453    RTGCPTR     GCPtrTop = iemRegGetRspForPopEx(pVCpu, &NewRsp, 4);
    1055810454
    1055910455    /* Write the word the lazy way. */
    … …  
    1058510481{
    1058610482    /* Increment the stack pointer. */
    10587     PCPUMCTX    pCtx = IEM_GET_CTX(pVCpu);
    1058810483    RTUINT64U   NewRsp = *pTmpRsp;
    10589     RTGCPTR     GCPtrTop = iemRegGetRspForPopEx(pVCpu, pCtx, &NewRsp, 8);
     10484    RTGCPTR     GCPtrTop = iemRegGetRspForPopEx(pVCpu, &NewRsp, 8);
    1059010485
    1059110486    /* Write the word the lazy way. */
    … …  
    1062610521{
    1062710522    Assert(cbMem < UINT8_MAX);
    10628     PCPUMCTX    pCtx     = IEM_GET_CTX(pVCpu);
    10629     RTGCPTR     GCPtrTop = iemRegGetRspForPush(pVCpu, pCtx, (uint8_t)cbMem, puNewRsp);
     10523    RTGCPTR     GCPtrTop = iemRegGetRspForPush(pVCpu, (uint8_t)cbMem, puNewRsp);
    1063010524    return iemMemMap(pVCpu, ppvMem, cbMem, X86_SREG_SS, GCPtrTop, IEM_ACCESS_STACK_W);
    1063110525}
    … …  
    1067010564{
    1067110565    Assert(cbMem < UINT8_MAX);
    10672     PCPUMCTX    pCtx     = IEM_GET_CTX(pVCpu);
    10673     RTGCPTR     GCPtrTop = iemRegGetRspForPop(pVCpu, pCtx, (uint8_t)cbMem, puNewRsp);
     10566    RTGCPTR     GCPtrTop = iemRegGetRspForPop(pVCpu, (uint8_t)cbMem, puNewRsp);
    1067410567    return iemMemMap(pVCpu, (void **)ppvMem, cbMem, X86_SREG_SS, GCPtrTop, IEM_ACCESS_STACK_R);
    1067510568}
    … …  
    1069310586{
    1069410587    Assert(cbMem < UINT8_MAX);
    10695     PCPUMCTX    pCtx = IEM_GET_CTX(pVCpu);
    1069610588    RTUINT64U   NewRsp;
    1069710589    NewRsp.u = *puNewRsp;
    10698     RTGCPTR     GCPtrTop = iemRegGetRspForPopEx(pVCpu, pCtx, &NewRsp, 8);
     10590    RTGCPTR     GCPtrTop = iemRegGetRspForPopEx(pVCpu, &NewRsp, 8);
    1069910591    *puNewRsp = NewRsp.u;
    1070010592    return iemMemMap(pVCpu, (void **)ppvMem, cbMem, X86_SREG_SS, GCPtrTop, IEM_ACCESS_STACK_R);
    … …  
    1083010722{
    1083110723    AssertPtr(pDesc);
    10832     PCPUMCTX pCtx = IEM_GET_CTX(pVCpu);
    10833     IEM_CTX_IMPORT_RET(pVCpu, pCtx, CPUMCTX_EXTRN_GDTR | CPUMCTX_EXTRN_LDTR);
     10724    IEM_CTX_IMPORT_RET(pVCpu, CPUMCTX_EXTRN_GDTR | CPUMCTX_EXTRN_LDTR);
    1083410725
    1083510726    /** @todo did the 286 require all 8 bytes to be accessible? */
    … …  
    1084010731    if (uSel & X86_SEL_LDT)
    1084110732    {
    10842         if (   !pCtx->ldtr.Attr.n.u1Present
    10843             || (uSel | X86_SEL_RPL_LDT) > pCtx->ldtr.u32Limit )
     10733        if (   !pVCpu->cpum.GstCtx.ldtr.Attr.n.u1Present
     10734            || (uSel | X86_SEL_RPL_LDT) > pVCpu->cpum.GstCtx.ldtr.u32Limit )
    1084410735        {
    1084510736            Log(("iemMemFetchSelDesc: LDT selector %#x is out of bounds (%3x) or ldtr is NP (%#x)\n",
    10846                  uSel, pCtx->ldtr.u32Limit, pCtx->ldtr.Sel));
     10737                 uSel, pVCpu->cpum.GstCtx.ldtr.u32Limit, pVCpu->cpum.GstCtx.ldtr.Sel));
    1084710738            return iemRaiseXcptOrInt(pVCpu, 0, uXcpt, IEM_XCPT_FLAGS_T_CPU_XCPT | IEM_XCPT_FLAGS_ERR,
    1084810739                                     uErrorCode, 0);
    1084910740        }
    1085010741
    10851         Assert(pCtx->ldtr.Attr.n.u1Present);
    10852         GCPtrBase = pCtx->ldtr.u64Base;
     10742        Assert(pVCpu->cpum.GstCtx.ldtr.Attr.n.u1Present);
     10743        GCPtrBase = pVCpu->cpum.GstCtx.ldtr.u64Base;
    1085310744    }
    1085410745    else
    1085510746    {
    10856         if ((uSel | X86_SEL_RPL_LDT) > pCtx->gdtr.cbGdt)
     10747        if ((uSel | X86_SEL_RPL_LDT) > pVCpu->cpum.GstCtx.gdtr.cbGdt)
    1085710748        {
    10858             Log(("iemMemFetchSelDesc: GDT selector %#x is out of bounds (%3x)\n", uSel, pCtx->gdtr.cbGdt));
     10749            Log(("iemMemFetchSelDesc: GDT selector %#x is out of bounds (%3x)\n", uSel, pVCpu->cpum.GstCtx.gdtr.cbGdt));
    1085910750            return iemRaiseXcptOrInt(pVCpu, 0, uXcpt, IEM_XCPT_FLAGS_T_CPU_XCPT | IEM_XCPT_FLAGS_ERR,
    1086010751                                     uErrorCode, 0);
    1086110752        }
    10862         GCPtrBase = pCtx->gdtr.pGdt;
     10753        GCPtrBase = pVCpu->cpum.GstCtx.gdtr.pGdt;
    1086310754    }
    1086410755
    … …  
    1088810779            || pDesc->Legacy.Gen.u1DescType)
    1088910780            pDesc->Long.au64[1] = 0;
    10890         else if ((uint32_t)(uSel | X86_SEL_RPL_LDT) + 8 <= (uSel & X86_SEL_LDT ? pCtx->ldtr.u32Limit : pCtx->gdtr.cbGdt))
     10781        else if ((uint32_t)(uSel | X86_SEL_RPL_LDT) + 8 <= (uSel & X86_SEL_LDT ? pVCpu->cpum.GstCtx.ldtr.u32Limit : pVCpu->cpum.GstCtx.gdtr.cbGdt))
    1089110782            rcStrict = iemMemFetchSysU64(pVCpu, &pDesc->Long.au64[1], UINT8_MAX, GCPtrBase + (uSel | X86_SEL_RPL_LDT) + 1);
    1089210783        else
    … …  
    1094610837IEM_STATIC VBOXSTRICTRC iemMemMarkSelDescAccessed(PVMCPU pVCpu, uint16_t uSel)
    1094710838{
    10948     PCPUMCTX pCtx = IEM_GET_CTX(pVCpu);
    10949 
    1095010839    /*
    1095110840     * Get the selector table base and calculate the entry address.
    1095210841     */
    1095310842    RTGCPTR GCPtr = uSel & X86_SEL_LDT
    10954                   ? pCtx->ldtr.u64Base
    10955                   : pCtx->gdtr.pGdt;
     10843                  ? pVCpu->cpum.GstCtx.ldtr.u64Base
     10844                  : pVCpu->cpum.GstCtx.gdtr.pGdt;
    1095610845    GCPtr += uSel & X86_SEL_MASK;
    1095710846
    … …  
    1117311062#define IEM_MC_FETCH_GREG_U64_ZX_U64                    IEM_MC_FETCH_GREG_U64
    1117411063#define IEM_MC_FETCH_SREG_U16(a_u16Dst, a_iSReg) do { \
    11175         IEM_CTX_IMPORT_NORET(pVCpu, IEM_GET_CTX(pVCpu), CPUMCTX_EXTRN_SREG_FROM_IDX(a_iSReg)); \
     11064        IEM_CTX_IMPORT_NORET(pVCpu, CPUMCTX_EXTRN_SREG_FROM_IDX(a_iSReg)); \
    1117611065        (a_u16Dst) = iemSRegFetchU16(pVCpu, (a_iSReg)); \
    1117711066    } while (0)
    1117811067#define IEM_MC_FETCH_SREG_ZX_U32(a_u32Dst, a_iSReg) do { \
    11179         IEM_CTX_IMPORT_NORET(pVCpu, IEM_GET_CTX(pVCpu), CPUMCTX_EXTRN_SREG_FROM_IDX(a_iSReg)); \
     11068        IEM_CTX_IMPORT_NORET(pVCpu, CPUMCTX_EXTRN_SREG_FROM_IDX(a_iSReg)); \
    1118011069        (a_u32Dst) = iemSRegFetchU16(pVCpu, (a_iSReg)); \
    1118111070    } while (0)
    1118211071#define IEM_MC_FETCH_SREG_ZX_U64(a_u64Dst, a_iSReg) do { \
    11183         IEM_CTX_IMPORT_NORET(pVCpu, IEM_GET_CTX(pVCpu), CPUMCTX_EXTRN_SREG_FROM_IDX(a_iSReg)); \
     11072        IEM_CTX_IMPORT_NORET(pVCpu, CPUMCTX_EXTRN_SREG_FROM_IDX(a_iSReg)); \
    1118411073        (a_u64Dst) = iemSRegFetchU16(pVCpu, (a_iSReg)); \
    1118511074    } while (0)
    1118611075/** @todo IEM_MC_FETCH_SREG_BASE_U64 & IEM_MC_FETCH_SREG_BASE_U32 probably aren't worth it... */
    1118711076#define IEM_MC_FETCH_SREG_BASE_U64(a_u64Dst, a_iSReg) do { \
    11188         IEM_CTX_IMPORT_NORET(pVCpu, IEM_GET_CTX(pVCpu), CPUMCTX_EXTRN_SREG_FROM_IDX(a_iSReg)); \
     11077        IEM_CTX_IMPORT_NORET(pVCpu, CPUMCTX_EXTRN_SREG_FROM_IDX(a_iSReg)); \
    1118911078        (a_u64Dst) = iemSRegBaseFetchU64(pVCpu, (a_iSReg)); \
    1119011079    } while (0)
    1119111080#define IEM_MC_FETCH_SREG_BASE_U32(a_u32Dst, a_iSReg) do { \
    11192         IEM_CTX_IMPORT_NORET(pVCpu, IEM_GET_CTX(pVCpu), CPUMCTX_EXTRN_SREG_FROM_IDX(a_iSReg)); \
     11081        IEM_CTX_IMPORT_NORET(pVCpu, CPUMCTX_EXTRN_SREG_FROM_IDX(a_iSReg)); \
    1119311082        (a_u32Dst) = iemSRegBaseFetchU64(pVCpu, (a_iSReg)); \
    1119411083    } while (0)
    … …  
    1119811087/** @todo IEM_MC_FETCH_LDTR_U16, IEM_MC_FETCH_LDTR_U32, IEM_MC_FETCH_LDTR_U64, IEM_MC_FETCH_TR_U16, IEM_MC_FETCH_TR_U32, and IEM_MC_FETCH_TR_U64 aren't worth it... */
    1119911088#define IEM_MC_FETCH_LDTR_U16(a_u16Dst) do { \
    11200         IEM_CTX_IMPORT_NORET(pVCpu, IEM_GET_CTX(pVCpu), CPUMCTX_EXTRN_LDTR); \
     11089        IEM_CTX_IMPORT_NORET(pVCpu, CPUMCTX_EXTRN_LDTR); \
    1120111090        (a_u16Dst) = IEM_GET_CTX(pVCpu)->ldtr.Sel; \
    1120211091   } while (0)
    1120311092#define IEM_MC_FETCH_LDTR_U32(a_u32Dst) do { \
    11204         IEM_CTX_IMPORT_NORET(pVCpu, IEM_GET_CTX(pVCpu), CPUMCTX_EXTRN_LDTR); \
     11093        IEM_CTX_IMPORT_NORET(pVCpu, CPUMCTX_EXTRN_LDTR); \
    1120511094        (a_u32Dst) = IEM_GET_CTX(pVCpu)->ldtr.Sel; \
    1120611095    } while (0)
    1120711096#define IEM_MC_FETCH_LDTR_U64(a_u64Dst) do { \
    11208         IEM_CTX_IMPORT_NORET(pVCpu, IEM_GET_CTX(pVCpu), CPUMCTX_EXTRN_LDTR); \
     11097        IEM_CTX_IMPORT_NORET(pVCpu, CPUMCTX_EXTRN_LDTR); \
    1120911098        (a_u64Dst) = IEM_GET_CTX(pVCpu)->ldtr.Sel; \
    1121011099   } while (0)
    1121111100#define IEM_MC_FETCH_TR_U16(a_u16Dst) do { \
    11212         IEM_CTX_IMPORT_NORET(pVCpu, IEM_GET_CTX(pVCpu), CPUMCTX_EXTRN_TR); \
     11101        IEM_CTX_IMPORT_NORET(pVCpu, CPUMCTX_EXTRN_TR); \
    1121311102        (a_u16Dst) = IEM_GET_CTX(pVCpu)->tr.Sel; \
    1121411103   } while (0)
    1121511104#define IEM_MC_FETCH_TR_U32(a_u32Dst) do { \
    11216         IEM_CTX_IMPORT_NORET(pVCpu, IEM_GET_CTX(pVCpu), CPUMCTX_EXTRN_TR); \
     11105        IEM_CTX_IMPORT_NORET(pVCpu, CPUMCTX_EXTRN_TR); \
    1121711106        (a_u32Dst) = IEM_GET_CTX(pVCpu)->tr.Sel; \
    1121811107   } while (0)
    1121911108#define IEM_MC_FETCH_TR_U64(a_u64Dst) do { \
    11220         IEM_CTX_IMPORT_NORET(pVCpu, IEM_GET_CTX(pVCpu), CPUMCTX_EXTRN_TR); \
     11109        IEM_CTX_IMPORT_NORET(pVCpu, CPUMCTX_EXTRN_TR); \
    1122111110        (a_u64Dst) = IEM_GET_CTX(pVCpu)->tr.Sel; \
    1122211111   } while (0)
    … …  
    1123911128/** @todo IEM_MC_STORE_SREG_BASE_U64 & IEM_MC_STORE_SREG_BASE_U32 aren't worth it... */
    1124011129#define IEM_MC_STORE_SREG_BASE_U64(a_iSReg, a_u64Value) do { \
    11241         IEM_CTX_IMPORT_NORET(pVCpu, IEM_GET_CTX(pVCpu), CPUMCTX_EXTRN_SREG_FROM_IDX(a_iSReg)); \
     11130        IEM_CTX_IMPORT_NORET(pVCpu, CPUMCTX_EXTRN_SREG_FROM_IDX(a_iSReg)); \
    1124211131        *iemSRegBaseRefU64(pVCpu, (a_iSReg)) = (a_u64Value); \
    1124311132    } while (0)
    1124411133#define IEM_MC_STORE_SREG_BASE_U32(a_iSReg, a_u32Value) do { \
    11245         IEM_CTX_IMPORT_NORET(pVCpu, IEM_GET_CTX(pVCpu), CPUMCTX_EXTRN_SREG_FROM_IDX(a_iSReg)); \
     11134        IEM_CTX_IMPORT_NORET(pVCpu, CPUMCTX_EXTRN_SREG_FROM_IDX(a_iSReg)); \
    1124611135        *iemSRegBaseRefU64(pVCpu, (a_iSReg)) = (uint32_t)(a_u32Value); /* clear high bits. */ \
    1124711136    } while (0)
    … …  
    1279212681{
    1279312682    Log5(("iemOpHlpCalcRmEffAddr: bRm=%#x\n", bRm));
    12794     PCCPUMCTX pCtx = IEM_GET_CTX(pVCpu);
    1279512683# define SET_SS_DEF() \
    1279612684    do \
    … …  
    1282412712                switch (bRm & X86_MODRM_RM_MASK)
    1282512713                {
    12826                     case 0: u16EffAddr += pCtx->bx + pCtx->si; break;
    12827                     case 1: u16EffAddr += pCtx->bx + pCtx->di; break;
    12828                     case 2: u16EffAddr += pCtx->bp + pCtx->si; SET_SS_DEF(); break;
    12829                     case 3: u16EffAddr += pCtx->bp + pCtx->di; SET_SS_DEF(); break;
    12830                     case 4: u16EffAddr += pCtx->si;            break;
    12831                     case 5: u16EffAddr += pCtx->di;            break;
    12832                     case 6: u16EffAddr += pCtx->bp;            SET_SS_DEF(); break;
    12833                     case 7: u16EffAddr += pCtx->bx;            break;
     12714                    case 0: u16EffAddr += pVCpu->cpum.GstCtx.bx + pVCpu->cpum.GstCtx.si; break;
     12715                    case 1: u16EffAddr += pVCpu->cpum.GstCtx.bx + pVCpu->cpum.GstCtx.di; break;
     12716                    case 2: u16EffAddr += pVCpu->cpum.GstCtx.bp + pVCpu->cpum.GstCtx.si; SET_SS_DEF(); break;
     12717                    case 3: u16EffAddr += pVCpu->cpum.GstCtx.bp + pVCpu->cpum.GstCtx.di; SET_SS_DEF(); break;
     12718                    case 4: u16EffAddr += pVCpu->cpum.GstCtx.si;            break;
     12719                    case 5: u16EffAddr += pVCpu->cpum.GstCtx.di;            break;
     12720                    case 6: u16EffAddr += pVCpu->cpum.GstCtx.bp;            SET_SS_DEF(); break;
     12721                    case 7: u16EffAddr += pVCpu->cpum.GstCtx.bx;            break;
    1283412722                }
    1283512723            }
    … …  
    1285012738                switch ((bRm & X86_MODRM_RM_MASK))
    1285112739                {
    12852                     case 0: u32EffAddr = pCtx->eax; break;
    12853                     case 1: u32EffAddr = pCtx->ecx; break;
    12854                     case 2: u32EffAddr = pCtx->edx; break;
    12855                     case 3: u32EffAddr = pCtx->ebx; break;
     12740                    case 0: u32EffAddr = pVCpu->cpum.GstCtx.eax; break;
     12741                    case 1: u32EffAddr = pVCpu->cpum.GstCtx.ecx; break;
     12742                    case 2: u32EffAddr = pVCpu->cpum.GstCtx.edx; break;
     12743                    case 3: u32EffAddr = pVCpu->cpum.GstCtx.ebx; break;
    1285612744                    case 4: /* SIB */
    1285712745                    {
    … …  
    1286112749                        switch ((bSib >> X86_SIB_INDEX_SHIFT) & X86_SIB_INDEX_SMASK)
    1286212750                        {
    12863                             case 0: u32EffAddr = pCtx->eax; break;
    12864                             case 1: u32EffAddr = pCtx->ecx; break;
    12865                             case 2: u32EffAddr = pCtx->edx; break;
    12866                             case 3: u32EffAddr = pCtx->ebx; break;
     12751                            case 0: u32EffAddr = pVCpu->cpum.GstCtx.eax; break;
     12752                            case 1: u32EffAddr = pVCpu->cpum.GstCtx.ecx; break;
     12753                            case 2: u32EffAddr = pVCpu->cpum.GstCtx.edx; break;
     12754                            case 3: u32EffAddr = pVCpu->cpum.GstCtx.ebx; break;
    1286712755                            case 4: u32EffAddr = 0; /*none */ break;
    12868                             case 5: u32EffAddr = pCtx->ebp; break;
    12869                             case 6: u32EffAddr = pCtx->esi; break;
    12870                             case 7: u32EffAddr = pCtx->edi; break;
     12756                            case 5: u32EffAddr = pVCpu->cpum.GstCtx.ebp; break;
     12757                            case 6: u32EffAddr = pVCpu->cpum.GstCtx.esi; break;
     12758                            case 7: u32EffAddr = pVCpu->cpum.GstCtx.edi; break;
    1287112759                            IEM_NOT_REACHED_DEFAULT_CASE_RET();
    1287212760                        }
    … …  
    1287612764                        switch (bSib & X86_SIB_BASE_MASK)
    1287712765                        {
    12878                             case 0: u32EffAddr += pCtx->eax; break;
    12879                             case 1: u32EffAddr += pCtx->ecx; break;
    12880                             case 2: u32EffAddr += pCtx->edx; break;
    12881                             case 3: u32EffAddr += pCtx->ebx; break;
    12882                             case 4: u32EffAddr += pCtx->esp; SET_SS_DEF(); break;
     12766                            case 0: u32EffAddr += pVCpu->cpum.GstCtx.eax; break;
     12767                            case 1: u32EffAddr += pVCpu->cpum.GstCtx.ecx; break;
     12768                            case 2: u32EffAddr += pVCpu->cpum.GstCtx.edx; break;
     12769                            case 3: u32EffAddr += pVCpu->cpum.GstCtx.ebx; break;
     12770                            case 4: u32EffAddr += pVCpu->cpum.GstCtx.esp; SET_SS_DEF(); break;
    1288312771                            case 5:
    1288412772                                if ((bRm & X86_MODRM_MOD_MASK) != 0)
    1288512773                                {
    12886                                     u32EffAddr += pCtx->ebp;
     12774                                    u32EffAddr += pVCpu->cpum.GstCtx.ebp;
    1288712775                                    SET_SS_DEF();
    1288812776                                }
    … …  
    1289412782                                }
    1289512783                                break;
    12896                             case 6: u32EffAddr += pCtx->esi; break;
    12897                             case 7: u32EffAddr += pCtx->edi; break;
     12784                            case 6: u32EffAddr += pVCpu->cpum.GstCtx.esi; break;
     12785                            case 7: u32EffAddr += pVCpu->cpum.GstCtx.edi; break;
    1289812786                            IEM_NOT_REACHED_DEFAULT_CASE_RET();
    1289912787                        }
    1290012788                        break;
    1290112789                    }
    12902                     case 5: u32EffAddr = pCtx->ebp; SET_SS_DEF(); break;
    12903                     case 6: u32EffAddr = pCtx->esi; break;
    12904                     case 7: u32EffAddr = pCtx->edi; break;
     12790                    case 5: u32EffAddr = pVCpu->cpum.GstCtx.ebp; SET_SS_DEF(); break;
     12791                    case 6: u32EffAddr = pVCpu->cpum.GstCtx.esi; break;
     12792                    case 7: u32EffAddr = pVCpu->cpum.GstCtx.edi; break;
    1290512793                    IEM_NOT_REACHED_DEFAULT_CASE_RET();
    1290612794                }
    … …  
    1294512833        {
    1294612834            IEM_OPCODE_GET_NEXT_S32_SX_U64(&u64EffAddr);
    12947             u64EffAddr += pCtx->rip + IEM_GET_INSTR_LEN(pVCpu) + cbImm;
     12835            u64EffAddr += pVCpu->cpum.GstCtx.rip + IEM_GET_INSTR_LEN(pVCpu) + cbImm;
    1294812836        }
    1294912837        else
    … …  
    1295212840            switch ((bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB)
    1295312841            {
    12954                 case  0: u64EffAddr = pCtx->rax; break;
    12955                 case  1: u64EffAddr = pCtx->rcx; break;
    12956                 case  2: u64EffAddr = pCtx->rdx; break;
    12957                 case  3: u64EffAddr = pCtx->rbx; break;
    12958                 case  5: u64EffAddr = pCtx->rbp; SET_SS_DEF(); break;
    12959                 case  6: u64EffAddr = pCtx->rsi; break;
    12960                 case  7: u64EffAddr = pCtx->rdi; break;
    12961                 case  8: u64EffAddr = pCtx->r8;  break;
    12962                 case  9: u64EffAddr = pCtx->r9;  break;
    12963                 case 10: u64EffAddr = pCtx->r10; break;
    12964                 case 11: u64EffAddr = pCtx->r11; break;
    12965                 case 13: u64EffAddr = pCtx->r13; break;
    12966                 case 14: u64EffAddr = pCtx->r14; break;
    12967                 case 15: u64EffAddr = pCtx->r15; break;
     12842                case  0: u64EffAddr = pVCpu->cpum.GstCtx.rax; break;
     12843                case  1: u64EffAddr = pVCpu->cpum.GstCtx.rcx; break;
     12844                case  2: u64EffAddr = pVCpu->cpum.GstCtx.rdx; break;
     12845                case  3: u64EffAddr = pVCpu->cpum.GstCtx.rbx; break;
     12846                case  5: u64EffAddr = pVCpu->cpum.GstCtx.rbp; SET_SS_DEF(); break;
     12847                case  6: u64EffAddr = pVCpu->cpum.GstCtx.rsi; break;
     12848                case  7: u64EffAddr = pVCpu->cpum.GstCtx.rdi; break;
     12849                case  8: u64EffAddr = pVCpu->cpum.GstCtx.r8;  break;
     12850                case  9: u64EffAddr = pVCpu->cpum.GstCtx.r9;  break;
     12851                case 10: u64EffAddr = pVCpu->cpum.GstCtx.r10; break;
     12852                case 11: u64EffAddr = pVCpu->cpum.GstCtx.r11; break;
     12853                case 13: u64EffAddr = pVCpu->cpum.GstCtx.r13; break;
     12854                case 14: u64EffAddr = pVCpu->cpum.GstCtx.r14; break;
     12855                case 15: u64EffAddr = pVCpu->cpum.GstCtx.r15; break;
    1296812856                /* SIB */
    1296912857                case 4:
    … …  
    1297512863                    switch (((bSib >> X86_SIB_INDEX_SHIFT) & X86_SIB_INDEX_SMASK) | pVCpu->iem.s.uRexIndex)
    1297612864                    {
    12977                         case  0: u64EffAddr = pCtx->rax; break;
    12978                         case  1: u64EffAddr = pCtx->rcx; break;
    12979                         case  2: u64EffAddr = pCtx->rdx; break;
    12980                         case  3: u64EffAddr = pCtx->rbx; break;
     12865                        case  0: u64EffAddr = pVCpu->cpum.GstCtx.rax; break;
     12866                        case  1: u64EffAddr = pVCpu->cpum.GstCtx.rcx; break;
     12867                        case  2: u64EffAddr = pVCpu->cpum.GstCtx.rdx; break;
     12868                        case  3: u64EffAddr = pVCpu->cpum.GstCtx.rbx; break;
    1298112869                        case  4: u64EffAddr = 0; /*none */ break;
    12982                         case  5: u64EffAddr = pCtx->rbp; break;
    12983                         case  6: u64EffAddr = pCtx->rsi; break;
    12984                         case  7: u64EffAddr = pCtx->rdi; break;
    12985                         case  8: u64EffAddr = pCtx->r8;  break;
    12986                         case  9: u64EffAddr = pCtx->r9;  break;
    12987                         case 10: u64EffAddr = pCtx->r10; break;
    12988                         case 11: u64EffAddr = pCtx->r11; break;
    12989                         case 12: u64EffAddr = pCtx->r12; break;
    12990                         case 13: u64EffAddr = pCtx->r13; break;
    12991                         case 14: u64EffAddr = pCtx->r14; break;
    12992                         case 15: u64EffAddr = pCtx->r15; break;
     12870                        case  5: u64EffAddr = pVCpu->cpum.GstCtx.rbp; break;
     12871                        case  6: u64EffAddr = pVCpu->cpum.GstCtx.rsi; break;
     12872                        case  7: u64EffAddr = pVCpu->cpum.GstCtx.rdi; break;
     12873                        case  8: u64EffAddr = pVCpu->cpum.GstCtx.r8;  break;
     12874                        case  9: u64EffAddr = pVCpu->cpum.GstCtx.r9;  break;
     12875                        case 10: u64EffAddr = pVCpu->cpum.GstCtx.r10; break;
     12876                        case 11: u64EffAddr = pVCpu->cpum.GstCtx.r11; break;
     12877                        case 12: u64EffAddr = pVCpu->cpum.GstCtx.r12; break;
     12878                        case 13: u64EffAddr = pVCpu->cpum.GstCtx.r13; break;
     12879                        case 14: u64EffAddr = pVCpu->cpum.GstCtx.r14; break;
     12880                        case 15: u64EffAddr = pVCpu->cpum.GstCtx.r15; break;
    1299312881                        IEM_NOT_REACHED_DEFAULT_CASE_RET();
    1299412882                    }
    … …  
    1299812886                    switch ((bSib & X86_SIB_BASE_MASK) | pVCpu->iem.s.uRexB)
    1299912887                    {
    13000                         case  0: u64EffAddr += pCtx->rax; break;
    13001                         case  1: u64EffAddr += pCtx->rcx; break;
    13002                         case  2: u64EffAddr += pCtx->rdx; break;
    13003                         case  3: u64EffAddr += pCtx->rbx; break;
    13004                         case  4: u64EffAddr += pCtx->rsp; SET_SS_DEF(); break;
    13005                         case  6: u64EffAddr += pCtx->rsi; break;
    13006                         case  7: u64EffAddr += pCtx->rdi; break;
    13007                         case  8: u64EffAddr += pCtx->r8;  break;
    13008                         case  9: u64EffAddr += pCtx->r9;  break;
    13009                         case 10: u64EffAddr += pCtx->r10; break;
    13010                         case 11: u64EffAddr += pCtx->r11; break;
    13011                         case 12: u64EffAddr += pCtx->r12; break;
    13012                         case 14: u64EffAddr += pCtx->r14; break;
    13013                         case 15: u64EffAddr += pCtx->r15; break;
     12888                        case  0: u64EffAddr += pVCpu->cpum.GstCtx.rax; break;
     12889                        case  1: u64EffAddr += pVCpu->cpum.GstCtx.rcx; break;
     12890                        case  2: u64EffAddr += pVCpu->cpum.GstCtx.rdx; break;
     12891                        case  3: u64EffAddr += pVCpu->cpum.GstCtx.rbx; break;
     12892                        case  4: u64EffAddr += pVCpu->cpum.GstCtx.rsp; SET_SS_DEF(); break;
     12893                        case  6: u64EffAddr += pVCpu->cpum.GstCtx.rsi; break;
     12894                        case  7: u64EffAddr += pVCpu->cpum.GstCtx.rdi; break;
     12895                        case  8: u64EffAddr += pVCpu->cpum.GstCtx.r8;  break;
     12896                        case  9: u64EffAddr += pVCpu->cpum.GstCtx.r9;  break;
     12897                        case 10: u64EffAddr += pVCpu->cpum.GstCtx.r10; break;
     12898                        case 11: u64EffAddr += pVCpu->cpum.GstCtx.r11; break;
     12899                        case 12: u64EffAddr += pVCpu->cpum.GstCtx.r12; break;
     12900                        case 14: u64EffAddr += pVCpu->cpum.GstCtx.r14; break;
     12901                        case 15: u64EffAddr += pVCpu->cpum.GstCtx.r15; break;
    1301412902                        /* complicated encodings */
    1301512903                        case 5:
    … …  
    1301912907                                if (!pVCpu->iem.s.uRexB)
    1302012908                                {
    13021                                     u64EffAddr += pCtx->rbp;
     12909                                    u64EffAddr += pVCpu->cpum.GstCtx.rbp;
    1302212910                                    SET_SS_DEF();
    1302312911                                }
    1302412912                                else
    13025                                     u64EffAddr += pCtx->r13;
     12913                                    u64EffAddr += pVCpu->cpum.GstCtx.r13;
    1302612914                            }
    1302712915                            else
    … …  
    1309412982{
    1309512983    Log5(("iemOpHlpCalcRmEffAddr: bRm=%#x\n", bRm));
    13096     PCCPUMCTX pCtx = IEM_GET_CTX(pVCpu);
    1309712984# define SET_SS_DEF() \
    1309812985    do \
    … …  
    1312613013                switch (bRm & X86_MODRM_RM_MASK)
    1312713014                {
    13128                     case 0: u16EffAddr += pCtx->bx + pCtx->si; break;
    13129                     case 1: u16EffAddr += pCtx->bx + pCtx->di; break;
    13130                     case 2: u16EffAddr += pCtx->bp + pCtx->si; SET_SS_DEF(); break;
    13131                     case 3: u16EffAddr += pCtx->bp + pCtx->di; SET_SS_DEF(); break;
    13132                     case 4: u16EffAddr += pCtx->si;            break;
    13133                     case 5: u16EffAddr += pCtx->di;            break;
    13134                     case 6: u16EffAddr += pCtx->bp;            SET_SS_DEF(); break;
    13135                     case 7: u16EffAddr += pCtx->bx;            break;
     13015                    case 0: u16EffAddr += pVCpu->cpum.GstCtx.bx + pVCpu->cpum.GstCtx.si; break;
     13016                    case 1: u16EffAddr += pVCpu->cpum.GstCtx.bx + pVCpu->cpum.GstCtx.di; break;
     13017                    case 2: u16EffAddr += pVCpu->cpum.GstCtx.bp + pVCpu->cpum.GstCtx.si; SET_SS_DEF(); break;
     13018                    case 3: u16EffAddr += pVCpu->cpum.GstCtx.bp + pVCpu->cpum.GstCtx.di; SET_SS_DEF(); break;
     13019                    case 4: u16EffAddr += pVCpu->cpum.GstCtx.si;            break;
     13020                    case 5: u16EffAddr += pVCpu->cpum.GstCtx.di;            break;
     13021                    case 6: u16EffAddr += pVCpu->cpum.GstCtx.bp;            SET_SS_DEF(); break;
     13022                    case 7: u16EffAddr += pVCpu->cpum.GstCtx.bx;            break;
    1313613023                }
    1313713024            }
    … …  
    1315213039                switch ((bRm & X86_MODRM_RM_MASK))
    1315313040                {
    13154                     case 0: u32EffAddr = pCtx->eax; break;
    13155                     case 1: u32EffAddr = pCtx->ecx; break;
    13156                     case 2: u32EffAddr = pCtx->edx; break;
    13157                     case 3: u32EffAddr = pCtx->ebx; break;
     13041                    case 0: u32EffAddr = pVCpu->cpum.GstCtx.eax; break;
     13042                    case 1: u32EffAddr = pVCpu->cpum.GstCtx.ecx; break;
     13043                    case 2: u32EffAddr = pVCpu->cpum.GstCtx.edx; break;
     13044                    case 3: u32EffAddr = pVCpu->cpum.GstCtx.ebx; break;
    1315813045                    case 4: /* SIB */
    1315913046                    {
    … …  
    1316313050                        switch ((bSib >> X86_SIB_INDEX_SHIFT) & X86_SIB_INDEX_SMASK)
    1316413051                        {
    13165                             case 0: u32EffAddr = pCtx->eax; break;
    13166                             case 1: u32EffAddr = pCtx->ecx; break;
    13167                             case 2: u32EffAddr = pCtx->edx; break;
    13168                             case 3: u32EffAddr = pCtx->ebx; break;
     13052                            case 0: u32EffAddr = pVCpu->cpum.GstCtx.eax; break;
     13053                            case 1: u32EffAddr = pVCpu->cpum.GstCtx.ecx; break;
     13054                            case 2: u32EffAddr = pVCpu->cpum.GstCtx.edx; break;
     13055                            case 3: u32EffAddr = pVCpu->cpum.GstCtx.ebx; break;
    1316913056                            case 4: u32EffAddr = 0; /*none */ break;
    13170                             case 5: u32EffAddr = pCtx->ebp; break;
    13171                             case 6: u32EffAddr = pCtx->esi; break;
    13172                             case 7: u32EffAddr = pCtx->edi; break;
     13057                            case 5: u32EffAddr = pVCpu->cpum.GstCtx.ebp; break;
     13058                            case 6: u32EffAddr = pVCpu->cpum.GstCtx.esi; break;
     13059                            case 7: u32EffAddr = pVCpu->cpum.GstCtx.edi; break;
    1317313060                            IEM_NOT_REACHED_DEFAULT_CASE_RET();
    1317413061                        }
    … …  
    1317813065                        switch (bSib & X86_SIB_BASE_MASK)
    1317913066                        {
    13180                             case 0: u32EffAddr += pCtx->eax; break;
    13181                             case 1: u32EffAddr += pCtx->ecx; break;
    13182                             case 2: u32EffAddr += pCtx->edx; break;
    13183                             case 3: u32EffAddr += pCtx->ebx; break;
     13067                            case 0: u32EffAddr += pVCpu->cpum.GstCtx.eax; break;
     13068                            case 1: u32EffAddr += pVCpu->cpum.GstCtx.ecx; break;
     13069                            case 2: u32EffAddr += pVCpu->cpum.GstCtx.edx; break;
     13070                            case 3: u32EffAddr += pVCpu->cpum.GstCtx.ebx; break;
    1318413071                            case 4:
    13185                                 u32EffAddr += pCtx->esp + offRsp;
     13072                                u32EffAddr += pVCpu->cpum.GstCtx.esp + offRsp;
    1318613073                                SET_SS_DEF();
    1318713074                                break;
    … …  
    1318913076                                if ((bRm & X86_MODRM_MOD_MASK) != 0)
    1319013077                                {
    13191                                     u32EffAddr += pCtx->ebp;
     13078                                    u32EffAddr += pVCpu->cpum.GstCtx.ebp;
    1319213079                                    SET_SS_DEF();
    1319313080                                }
    … …  
    1319913086                                }
    1320013087                                break;
    13201                             case 6: u32EffAddr += pCtx->esi; break;
    13202                             case 7: u32EffAddr += pCtx->edi; break;
     13088                            case 6: u32EffAddr += pVCpu->cpum.GstCtx.esi; break;
     13089                            case 7: u32EffAddr += pVCpu->cpum.GstCtx.edi; break;
    1320313090                            IEM_NOT_REACHED_DEFAULT_CASE_RET();
    1320413091                        }
    1320513092                        break;
    1320613093                    }
    13207                     case 5: u32EffAddr = pCtx->ebp; SET_SS_DEF(); break;
    13208                     case 6: u32EffAddr = pCtx->esi; break;
    13209                     case 7: u32EffAddr = pCtx->edi; break;
     13094                    case 5: u32EffAddr = pVCpu->cpum.GstCtx.ebp; SET_SS_DEF(); break;
     13095                    case 6: u32EffAddr = pVCpu->cpum.GstCtx.esi; break;
     13096                    case 7: u32EffAddr = pVCpu->cpum.GstCtx.edi; break;
    1321013097                    IEM_NOT_REACHED_DEFAULT_CASE_RET();
    1321113098                }
    … …  
    1325013137        {
    1325113138            IEM_OPCODE_GET_NEXT_S32_SX_U64(&u64EffAddr);
    13252             u64EffAddr += pCtx->rip + IEM_GET_INSTR_LEN(pVCpu) + cbImm;
     13139            u64EffAddr += pVCpu->cpum.GstCtx.rip + IEM_GET_INSTR_LEN(pVCpu) + cbImm;
    1325313140        }
    1325413141        else
    … …  
    1325713144            switch ((bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB)
    1325813145            {
    13259                 case  0: u64EffAddr = pCtx->rax; break;
    13260                 case  1: u64EffAddr = pCtx->rcx; break;
    13261                 case  2: u64EffAddr = pCtx->rdx; break;
    13262                 case  3: u64EffAddr = pCtx->rbx; break;
    13263                 case  5: u64EffAddr = pCtx->rbp; SET_SS_DEF(); break;
    13264                 case  6: u64EffAddr = pCtx->rsi; break;
    13265                 case  7: u64EffAddr = pCtx->rdi; break;
    13266                 case  8: u64EffAddr = pCtx->r8;  break;
    13267                 case  9: u64EffAddr = pCtx->r9;  break;
    13268                 case 10: u64EffAddr = pCtx->r10; break;
    13269                 case 11: u64EffAddr = pCtx->r11; break;
    13270                 case 13: u64EffAddr = pCtx->r13; break;
    13271                 case 14: u64EffAddr = pCtx->r14; break;
    13272                 case 15: u64EffAddr = pCtx->r15; break;
     13146                case  0: u64EffAddr = pVCpu->cpum.GstCtx.rax; break;
     13147                case  1: u64EffAddr = pVCpu->cpum.GstCtx.rcx; break;
     13148                case  2: u64EffAddr = pVCpu->cpum.GstCtx.rdx; break;
     13149                case  3: u64EffAddr = pVCpu->cpum.GstCtx.rbx; break;
     13150                case  5: u64EffAddr = pVCpu->cpum.GstCtx.rbp; SET_SS_DEF(); break;
     13151                case  6: u64EffAddr = pVCpu->cpum.GstCtx.rsi; break;
     13152                case  7: u64EffAddr = pVCpu->cpum.GstCtx.rdi; break;
     13153                case  8: u64EffAddr = pVCpu->cpum.GstCtx.r8;  break;
     13154                case  9: u64EffAddr = pVCpu->cpum.GstCtx.r9;  break;
     13155                case 10: u64EffAddr = pVCpu->cpum.GstCtx.r10; break;
     13156                case 11: u64EffAddr = pVCpu->cpum.GstCtx.r11; break;
     13157                case 13: u64EffAddr = pVCpu->cpum.GstCtx.r13; break;
     13158                case 14: u64EffAddr = pVCpu->cpum.GstCtx.r14; break;
     13159                case 15: u64EffAddr = pVCpu->cpum.GstCtx.r15; break;
    1327313160                /* SIB */
    1327413161                case 4:
    … …  
    1328013167                    switch (((bSib >> X86_SIB_INDEX_SHIFT) & X86_SIB_INDEX_SMASK) | pVCpu->iem.s.uRexIndex)
    1328113168                    {
    13282                         case  0: u64EffAddr = pCtx->rax; break;
    13283                         case  1: u64EffAddr = pCtx->rcx; break;
    13284                         case  2: u64EffAddr = pCtx->rdx; break;
    13285                         case  3: u64EffAddr = pCtx->rbx; break;
     13169                        case  0: u64EffAddr = pVCpu->cpum.GstCtx.rax; break;
     13170                        case  1: u64EffAddr = pVCpu->cpum.GstCtx.rcx; break;
     13171                        case  2: u64EffAddr = pVCpu->cpum.GstCtx.rdx; break;
     13172                        case  3: u64EffAddr = pVCpu->cpum.GstCtx.rbx; break;
    1328613173                        case  4: u64EffAddr = 0; /*none */ break;
    13287                         case  5: u64EffAddr = pCtx->rbp; break;
    13288                         case  6: u64EffAddr = pCtx->rsi; break;
    13289                         case  7: u64EffAddr = pCtx->rdi; break;
    13290                         case  8: u64EffAddr = pCtx->r8;  break;
    13291                         case  9: u64EffAddr = pCtx->r9;  break;
    13292                         case 10: u64EffAddr = pCtx->r10; break;
    13293                         case 11: u64EffAddr = pCtx->r11; break;
    13294                         case 12: u64EffAddr = pCtx->r12; break;
    13295                         case 13: u64EffAddr = pCtx->r13; break;
    13296                         case 14: u64EffAddr = pCtx->r14; break;
    13297                         case 15: u64EffAddr = pCtx->r15; break;
     13174                        case  5: u64EffAddr = pVCpu->cpum.GstCtx.rbp; break;
     13175                        case  6: u64EffAddr = pVCpu->cpum.GstCtx.rsi; break;
     13176                        case  7: u64EffAddr = pVCpu->cpum.GstCtx.rdi; break;
     13177                        case  8: u64EffAddr = pVCpu->cpum.GstCtx.r8;  break;
     13178                        case  9: u64EffAddr = pVCpu->cpum.GstCtx.r9;  break;
     13179                        case 10: u64EffAddr = pVCpu->cpum.GstCtx.r10; break;
     13180                        case 11: u64EffAddr = pVCpu->cpum.GstCtx.r11; break;
     13181                        case 12: u64EffAddr = pVCpu->cpum.GstCtx.r12; break;
     13182                        case 13: u64EffAddr = pVCpu->cpum.GstCtx.r13; break;
     13183                        case 14: u64EffAddr = pVCpu->cpum.GstCtx.r14; break;
     13184                        case 15: u64EffAddr = pVCpu->cpum.GstCtx.r15; break;
    1329813185                        IEM_NOT_REACHED_DEFAULT_CASE_RET();
    1329913186                    }
    … …  
    1330313190                    switch ((bSib & X86_SIB_BASE_MASK) | pVCpu->iem.s.uRexB)
    1330413191                    {
    13305                         case  0: u64EffAddr += pCtx->rax; break;
    13306                         case  1: u64EffAddr += pCtx->rcx; break;
    13307                         case  2: u64EffAddr += pCtx->rdx; break;
    13308                         case  3: u64EffAddr += pCtx->rbx; break;
    13309                         case  4: u64EffAddr += pCtx->rsp + offRsp; SET_SS_DEF(); break;
    13310                         case  6: u64EffAddr += pCtx->rsi; break;
    13311                         case  7: u64EffAddr += pCtx->rdi; break;
    13312                         case  8: u64EffAddr += pCtx->r8;  break;
    13313                         case  9: u64EffAddr += pCtx->r9;  break;
    13314                         case 10: u64EffAddr += pCtx->r10; break;
    13315                         case 11: u64EffAddr += pCtx->r11; break;
    13316                         case 12: u64EffAddr += pCtx->r12; break;
    13317                         case 14: u64EffAddr += pCtx->r14; break;
    13318                         case 15: u64EffAddr += pCtx->r15; break;
     13192                        case  0: u64EffAddr += pVCpu->cpum.GstCtx.rax; break;
     13193                        case  1: u64EffAddr += pVCpu->cpum.GstCtx.rcx; break;
     13194                        case  2: u64EffAddr += pVCpu->cpum.GstCtx.rdx; break;
     13195                        case  3: u64EffAddr += pVCpu->cpum.GstCtx.rbx; break;
     13196                        case  4: u64EffAddr += pVCpu->cpum.GstCtx.rsp + offRsp; SET_SS_DEF(); break;
     13197                        case  6: u64EffAddr += pVCpu->cpum.GstCtx.rsi; break;
     13198                        case  7: u64EffAddr += pVCpu->cpum.GstCtx.rdi; break;
     13199                        case  8: u64EffAddr += pVCpu->cpum.GstCtx.r8;  break;
     13200                        case  9: u64EffAddr += pVCpu->cpum.GstCtx.r9;  break;
     13201                        case 10: u64EffAddr += pVCpu->cpum.GstCtx.r10; break;
     13202                        case 11: u64EffAddr += pVCpu->cpum.GstCtx.r11; break;
     13203                        case 12: u64EffAddr += pVCpu->cpum.GstCtx.r12; break;
     13204                        case 14: u64EffAddr += pVCpu->cpum.GstCtx.r14; break;
     13205                        case 15: u64EffAddr += pVCpu->cpum.GstCtx.r15; break;
    1331913206                        /* complicated encodings */
    1332013207                        case 5:
    … …  
    1332413211                                if (!pVCpu->iem.s.uRexB)
    1332513212                                {
    13326                                     u64EffAddr += pCtx->rbp;
     13213                                    u64EffAddr += pVCpu->cpum.GstCtx.rbp;
    1332713214                                    SET_SS_DEF();
    1332813215                                }
    1332913216                                else
    13330                                     u64EffAddr += pCtx->r13;
     13217                                    u64EffAddr += pVCpu->cpum.GstCtx.r13;
    1333113218                            }
    1333213219                            else
    … …  
    1340013287{
    1340113288    Log5(("iemOpHlpCalcRmEffAddrJmp: bRm=%#x\n", bRm));
    13402     PCCPUMCTX pCtx = IEM_GET_CTX(pVCpu);
    1340313289# define SET_SS_DEF() \
    1340413290    do \
    … …  
    1343213318                switch (bRm & X86_MODRM_RM_MASK)
    1343313319                {
    13434                     case 0: u16EffAddr += pCtx->bx + pCtx->si; break;
    13435                     case 1: u16EffAddr += pCtx->bx + pCtx->di; break;
    13436                     case 2: u16EffAddr += pCtx->bp + pCtx->si; SET_SS_DEF(); break;
    13437                     case 3: u16EffAddr += pCtx->bp + pCtx->di; SET_SS_DEF(); break;
    13438                     case 4: u16EffAddr += pCtx->si;            break;
    13439                     case 5: u16EffAddr += pCtx->di;            break;
    13440                     case 6: u16EffAddr += pCtx->bp;            SET_SS_DEF(); break;
    13441                     case 7: u16EffAddr += pCtx->bx;            break;
     13320                    case 0: u16EffAddr += pVCpu->cpum.GstCtx.bx + pVCpu->cpum.GstCtx.si; break;
     13321                    case 1: u16EffAddr += pVCpu->cpum.GstCtx.bx + pVCpu->cpum.GstCtx.di; break;
     13322                    case 2: u16EffAddr += pVCpu->cpum.GstCtx.bp + pVCpu->cpum.GstCtx.si; SET_SS_DEF(); break;
     13323                    case 3: u16EffAddr += pVCpu->cpum.GstCtx.bp + pVCpu->cpum.GstCtx.di; SET_SS_DEF(); break;
     13324                    case 4: u16EffAddr += pVCpu->cpum.GstCtx.si;            break;
     13325                    case 5: u16EffAddr += pVCpu->cpum.GstCtx.di;            break;
     13326                    case 6: u16EffAddr += pVCpu->cpum.GstCtx.bp;            SET_SS_DEF(); break;
     13327                    case 7: u16EffAddr += pVCpu->cpum.GstCtx.bx;            break;
    1344213328                }
    1344313329            }
    … …  
    1345813344            switch ((bRm & X86_MODRM_RM_MASK))
    1345913345            {
    13460                 case 0: u32EffAddr = pCtx->eax; break;
    13461                 case 1: u32EffAddr = pCtx->ecx; break;
    13462                 case 2: u32EffAddr = pCtx->edx; break;
    13463                 case 3: u32EffAddr = pCtx->ebx; break;
     13346                case 0: u32EffAddr = pVCpu->cpum.GstCtx.eax; break;
     13347                case 1: u32EffAddr = pVCpu->cpum.GstCtx.ecx; break;
     13348                case 2: u32EffAddr = pVCpu->cpum.GstCtx.edx; break;
     13349                case 3: u32EffAddr = pVCpu->cpum.GstCtx.ebx; break;
    1346413350                case 4: /* SIB */
    1346513351                {
    … …  
    1346913355                    switch ((bSib >> X86_SIB_INDEX_SHIFT) & X86_SIB_INDEX_SMASK)
    1347013356                    {
    13471                         case 0: u32EffAddr = pCtx->eax; break;
    13472                         case 1: u32EffAddr = pCtx->ecx; break;
    13473                         case 2: u32EffAddr = pCtx->edx; break;
    13474                         case 3: u32EffAddr = pCtx->ebx; break;
     13357                        case 0: u32EffAddr = pVCpu->cpum.GstCtx.eax; break;
     13358                        case 1: u32EffAddr = pVCpu->cpum.GstCtx.ecx; break;
     13359                        case 2: u32EffAddr = pVCpu->cpum.GstCtx.edx; break;
     13360                        case 3: u32EffAddr = pVCpu->cpum.GstCtx.ebx; break;
    1347513361                        case 4: u32EffAddr = 0; /*none */ break;
    13476                         case 5: u32EffAddr = pCtx->ebp; break;
    13477                         case 6: u32EffAddr = pCtx->esi; break;
    13478                         case 7: u32EffAddr = pCtx->edi; break;
     13362                        case 5: u32EffAddr = pVCpu->cpum.GstCtx.ebp; break;
     13363                        case 6: u32EffAddr = pVCpu->cpum.GstCtx.esi; break;
     13364                        case 7: u32EffAddr = pVCpu->cpum.GstCtx.edi; break;
    1347913365                        IEM_NOT_REACHED_DEFAULT_CASE_RET2(RTGCPTR_MAX);
    1348013366                    }
    … …  
    1348413370                    switch (bSib & X86_SIB_BASE_MASK)
    1348513371                    {
    13486                         case 0: u32EffAddr += pCtx->eax; break;
    13487                         case 1: u32EffAddr += pCtx->ecx; break;
    13488                         case 2: u32EffAddr += pCtx->edx; break;
    13489                         case 3: u32EffAddr += pCtx->ebx; break;
    13490                         case 4: u32EffAddr += pCtx->esp; SET_SS_DEF(); break;
     13372                        case 0: u32EffAddr += pVCpu->cpum.GstCtx.eax; break;
     13373                        case 1: u32EffAddr += pVCpu->cpum.GstCtx.ecx; break;
     13374                        case 2: u32EffAddr += pVCpu->cpum.GstCtx.edx; break;
     13375                        case 3: u32EffAddr += pVCpu->cpum.GstCtx.ebx; break;
     13376                        case 4: u32EffAddr += pVCpu->cpum.GstCtx.esp; SET_SS_DEF(); break;
    1349113377                        case 5:
    1349213378                            if ((bRm & X86_MODRM_MOD_MASK) != 0)
    1349313379                            {
    13494                                 u32EffAddr += pCtx->ebp;
     13380                                u32EffAddr += pVCpu->cpum.GstCtx.ebp;
    1349513381                                SET_SS_DEF();
    1349613382                            }
    … …  
    1350213388                            }
    1350313389                            break;
    13504                         case 6: u32EffAddr += pCtx->esi; break;
    13505                         case 7: u32EffAddr += pCtx->edi; break;
     13390                        case 6: u32EffAddr += pVCpu->cpum.GstCtx.esi; break;
     13391                        case 7: u32EffAddr += pVCpu->cpum.GstCtx.edi; break;
    1350613392                        IEM_NOT_REACHED_DEFAULT_CASE_RET2(RTGCPTR_MAX);
    1350713393                    }
    1350813394                    break;
    1350913395                }
    13510                 case 5: u32EffAddr = pCtx->ebp; SET_SS_DEF(); break;
    13511                 case 6: u32EffAddr = pCtx->esi; break;
    13512                 case 7: u32EffAddr = pCtx->edi; break;
     13396                case 5: u32EffAddr = pVCpu->cpum.GstCtx.ebp; SET_SS_DEF(); break;
     13397                case 6: u32EffAddr = pVCpu->cpum.GstCtx.esi; break;
     13398                case 7: u32EffAddr = pVCpu->cpum.GstCtx.edi; break;
    1351313399                IEM_NOT_REACHED_DEFAULT_CASE_RET2(RTGCPTR_MAX);
    1351413400            }
    … …  
    1355213438    {
    1355313439        IEM_OPCODE_GET_NEXT_S32_SX_U64(&u64EffAddr);
    13554         u64EffAddr += pCtx->rip + IEM_GET_INSTR_LEN(pVCpu) + cbImm;
     13440        u64EffAddr += pVCpu->cpum.GstCtx.rip + IEM_GET_INSTR_LEN(pVCpu) + cbImm;
    1355513441    }
    1355613442    else
    … …  
    1355913445        switch ((bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB)
    1356013446        {
    13561             case  0: u64EffAddr = pCtx->rax; break;
    13562             case  1: u64EffAddr = pCtx->rcx; break;
    13563             case  2: u64EffAddr = pCtx->rdx; break;
    13564             case  3: u64EffAddr = pCtx->rbx; break;
    13565             case  5: u64EffAddr = pCtx->rbp; SET_SS_DEF(); break;
    13566             case  6: u64EffAddr = pCtx->rsi; break;
    13567             case  7: u64EffAddr = pCtx->rdi; break;
    13568             case  8: u64EffAddr = pCtx->r8;  break;
    13569             case  9: u64EffAddr = pCtx->r9;  break;
    13570             case 10: u64EffAddr = pCtx->r10; break;
    13571             case 11: u64EffAddr = pCtx->r11; break;
    13572             case 13: u64EffAddr = pCtx->r13; break;
    13573             case 14: u64EffAddr = pCtx->r14; break;
    13574             case 15: u64EffAddr = pCtx->r15; break;
     13447            case  0: u64EffAddr = pVCpu->cpum.GstCtx.rax; break;
     13448            case  1: u64EffAddr = pVCpu->cpum.GstCtx.rcx; break;
     13449            case  2: u64EffAddr = pVCpu->cpum.GstCtx.rdx; break;
     13450            case  3: u64EffAddr = pVCpu->cpum.GstCtx.rbx; break;
     13451            case  5: u64EffAddr = pVCpu->cpum.GstCtx.rbp; SET_SS_DEF(); break;
     13452            case  6: u64EffAddr = pVCpu->cpum.GstCtx.rsi; break;
     13453            case  7: u64EffAddr = pVCpu->cpum.GstCtx.rdi; break;
     13454            case  8: u64EffAddr = pVCpu->cpum.GstCtx.r8;  break;
     13455            case  9: u64EffAddr = pVCpu->cpum.GstCtx.r9;  break;
     13456            case 10: u64EffAddr = pVCpu->cpum.GstCtx.r10; break;
     13457            case 11: u64EffAddr = pVCpu->cpum.GstCtx.r11; break;
     13458            case 13: u64EffAddr = pVCpu->cpum.GstCtx.r13; break;
     13459            case 14: u64EffAddr = pVCpu->cpum.GstCtx.r14; break;
     13460            case 15: u64EffAddr = pVCpu->cpum.GstCtx.r15; break;
    1357513461            /* SIB */
    1357613462            case 4:
    … …  
    1358213468                switch (((bSib >> X86_SIB_INDEX_SHIFT) & X86_SIB_INDEX_SMASK) | pVCpu->iem.s.uRexIndex)
    1358313469                {
    13584                     case  0: u64EffAddr = pCtx->rax; break;
    13585                     case  1: u64EffAddr = pCtx->rcx; break;
    13586                     case  2: u64EffAddr = pCtx->rdx; break;
    13587                     case  3: u64EffAddr = pCtx->rbx; break;
     13470                    case  0: u64EffAddr = pVCpu->cpum.GstCtx.rax; break;
     13471                    case  1: u64EffAddr = pVCpu->cpum.GstCtx.rcx; break;
     13472                    case  2: u64EffAddr = pVCpu->cpum.GstCtx.rdx; break;
     13473                    case  3: u64EffAddr = pVCpu->cpum.GstCtx.rbx; break;
    1358813474                    case  4: u64EffAddr = 0; /*none */ break;
    13589                     case  5: u64EffAddr = pCtx->rbp; break;
    13590                     case  6: u64EffAddr = pCtx->rsi; break;
    13591                     case  7: u64EffAddr = pCtx->rdi; break;
    13592                     case  8: u64EffAddr = pCtx->r8;  break;
    13593                     case  9: u64EffAddr = pCtx->r9;  break;
    13594                     case 10: u64EffAddr = pCtx->r10; break;
    13595                     case 11: u64EffAddr = pCtx->r11; break;
    13596                     case 12: u64EffAddr = pCtx->r12; break;
    13597                     case 13: u64EffAddr = pCtx->r13; break;
    13598                     case 14: u64EffAddr = pCtx->r14; break;
    13599                     case 15: u64EffAddr = pCtx->r15; break;
     13475                    case  5: u64EffAddr = pVCpu->cpum.GstCtx.rbp; break;
     13476                    case  6: u64EffAddr = pVCpu->cpum.GstCtx.rsi; break;
     13477                    case  7: u64EffAddr = pVCpu->cpum.GstCtx.rdi; break;
     13478                    case  8: u64EffAddr = pVCpu->cpum.GstCtx.r8;  break;
     13479                    case  9: u64EffAddr = pVCpu->cpum.GstCtx.r9;  break;
     13480                    case 10: u64EffAddr = pVCpu->cpum.GstCtx.r10; break;
     13481                    case 11: u64EffAddr = pVCpu->cpum.GstCtx.r11; break;
     13482                    case 12: u64EffAddr = pVCpu->cpum.GstCtx.r12; break;
     13483                    case 13: u64EffAddr = pVCpu->cpum.GstCtx.r13; break;
     13484                    case 14: u64EffAddr = pVCpu->cpum.GstCtx.r14; break;
     13485                    case 15: u64EffAddr = pVCpu->cpum.GstCtx.r15; break;
    1360013486                    IEM_NOT_REACHED_DEFAULT_CASE_RET2(RTGCPTR_MAX);
    1360113487                }
    … …  
    1360513491                switch ((bSib & X86_SIB_BASE_MASK) | pVCpu->iem.s.uRexB)
    1360613492                {
    13607                     case  0: u64EffAddr += pCtx->rax; break;
    13608                     case  1: u64EffAddr += pCtx->rcx; break;
    13609                     case  2: u64EffAddr += pCtx->rdx; break;
    13610                     case  3: u64EffAddr += pCtx->rbx; break;
    13611                     case  4: u64EffAddr += pCtx->rsp; SET_SS_DEF(); break;
    13612                     case  6: u64EffAddr += pCtx->rsi; break;
    13613                     case  7: u64EffAddr += pCtx->rdi; break;
    13614                     case  8: u64EffAddr += pCtx->r8;  break;
    13615                     case  9: u64EffAddr += pCtx->r9;  break;
    13616                     case 10: u64EffAddr += pCtx->r10; break;
    13617                     case 11: u64EffAddr += pCtx->r11; break;
    13618                     case 12: u64EffAddr += pCtx->r12; break;
    13619                     case 14: u64EffAddr += pCtx->r14; break;
    13620                     case 15: u64EffAddr += pCtx->r15; break;
     13493                    case  0: u64EffAddr += pVCpu->cpum.GstCtx.rax; break;
     13494                    case  1: u64EffAddr += pVCpu->cpum.GstCtx.rcx; break;
     13495                    case  2: u64EffAddr += pVCpu->cpum.GstCtx.rdx; break;
     13496                    case  3: u64EffAddr += pVCpu->cpum.GstCtx.rbx; break;
     13497                    case  4: u64EffAddr += pVCpu->cpum.GstCtx.rsp; SET_SS_DEF(); break;
     13498                    case  6: u64EffAddr += pVCpu->cpum.GstCtx.rsi; break;
     13499                    case  7: u64EffAddr += pVCpu->cpum.GstCtx.rdi; break;
     13500                    case  8: u64EffAddr += pVCpu->cpum.GstCtx.r8;  break;
     13501                    case  9: u64EffAddr += pVCpu->cpum.GstCtx.r9;  break;
     13502                    case 10: u64EffAddr += pVCpu->cpum.GstCtx.r10; break;
     13503                    case 11: u64EffAddr += pVCpu->cpum.GstCtx.r11; break;
     13504                    case 12: u64EffAddr += pVCpu->cpum.GstCtx.r12; break;
     13505                    case 14: u64EffAddr += pVCpu->cpum.GstCtx.r14; break;
     13506                    case 15: u64EffAddr += pVCpu->cpum.GstCtx.r15; break;
    1362113507                    /* complicated encodings */
    1362213508                    case 5:
    … …  
    1362613512                            if (!pVCpu->iem.s.uRexB)
    1362713513                            {
    13628                                 u64EffAddr += pCtx->rbp;
     13514                                u64EffAddr += pVCpu->cpum.GstCtx.rbp;
    1362913515                                SET_SS_DEF();
    1363013516                            }
    1363113517                            else
    13632                                 u64EffAddr += pCtx->r13;
     13518                                u64EffAddr += pVCpu->cpum.GstCtx.r13;
    1363313519                        }
    1363413520                        else
    … …  
    1369613582 * Logs the current instruction.
    1369713583 * @param   pVCpu       The cross context virtual CPU structure of the calling EMT.
    13698  * @param   pCtx        The current CPU context.
    1369913584 * @param   fSameCtx    Set if we have the same context information as the VMM,
    1370013585 *                      clear if we may have already executed an instruction in
    1370113586 *                      our debug context. When clear, we assume IEMCPU holds
    1370213587 *                      valid CPU mode info.
    13703  */
    13704 IEM_STATIC void iemLogCurInstr(PVMCPU pVCpu, PCPUMCTX pCtx, bool fSameCtx)
     13588 *
     13589 *                      The @a fSameCtx parameter is now misleading and obsolete.
     13590 */
     13591IEM_STATIC void iemLogCurInstr(PVMCPU pVCpu, bool fSameCtx)
    1370513592{
    1370613593# ifdef IN_RING3
    … …  
    1372113608                case IEMMODE_32BIT: fFlags |= DBGF_DISAS_FLAGS_32BIT_MODE; break;
    1372213609                case IEMMODE_16BIT:
    13723                     if (!(pCtx->cr0 & X86_CR0_PE) || pCtx->eflags.Bits.u1VM)
     13610                    if (!(pVCpu->cpum.GstCtx.cr0 & X86_CR0_PE) || pVCpu->cpum.GstCtx.eflags.Bits.u1VM)
    1372413611                        fFlags |= DBGF_DISAS_FLAGS_16BIT_REAL_MODE;
    1372513612                    else
    … …  
    1372713614                    break;
    1372813615            }
    13729             DBGFR3DisasInstrEx(pVCpu->pVMR3->pUVM, pVCpu->idCpu, pCtx->cs.Sel, pCtx->rip, fFlags,
     13616            DBGFR3DisasInstrEx(pVCpu->pVMR3->pUVM, pVCpu->idCpu, pVCpu->cpum.GstCtx.cs.Sel, pVCpu->cpum.GstCtx.rip, fFlags,
    1373013617                               szInstr, sizeof(szInstr), &cbInstr);
    1373113618        }
    1373213619
    13733         PCX86FXSTATE pFpuCtx = &pCtx->CTX_SUFF(pXState)->x87;
     13620        PCX86FXSTATE pFpuCtx = &pVCpu->cpum.GstCtx.CTX_SUFF(pXState)->x87;
    1373413621        Log2(("****\n"
    1373513622              " eax=%08x ebx=%08x ecx=%08x edx=%08x esi=%08x edi=%08x\n"
    … …  
    1373913626              " %s\n"
    1374013627              ,
    13741               pCtx->eax, pCtx->ebx, pCtx->ecx, pCtx->edx, pCtx->esi, pCtx->edi,
    13742               pCtx->eip, pCtx->esp, pCtx->ebp, pCtx->eflags.Bits.u2IOPL, pCtx->tr.Sel,
    13743               pCtx->cs.Sel, pCtx->ss.Sel, pCtx->ds.Sel, pCtx->es.Sel,
    13744               pCtx->fs.Sel, pCtx->gs.Sel, pCtx->eflags.u,
     13628              pVCpu->cpum.GstCtx.eax, pVCpu->cpum.GstCtx.ebx, pVCpu->cpum.GstCtx.ecx, pVCpu->cpum.GstCtx.edx, pVCpu->cpum.GstCtx.esi, pVCpu->cpum.GstCtx.edi,
     13629              pVCpu->cpum.GstCtx.eip, pVCpu->cpum.GstCtx.esp, pVCpu->cpum.GstCtx.ebp, pVCpu->cpum.GstCtx.eflags.Bits.u2IOPL, pVCpu->cpum.GstCtx.tr.Sel,
     13630              pVCpu->cpum.GstCtx.cs.Sel, pVCpu->cpum.GstCtx.ss.Sel, pVCpu->cpum.GstCtx.ds.Sel, pVCpu->cpum.GstCtx.es.Sel,
     13631              pVCpu->cpum.GstCtx.fs.Sel, pVCpu->cpum.GstCtx.gs.Sel, pVCpu->cpum.GstCtx.eflags.u,
    1374513632              pFpuCtx->FSW, pFpuCtx->FCW, pFpuCtx->FTW, pFpuCtx->MXCSR, pFpuCtx->MXCSR_MASK,
    1374613633              szInstr));
    … …  
    1375213639# endif
    1375313640        LogFlow(("IEMExecOne: cs:rip=%04x:%08RX64 ss:rsp=%04x:%08RX64 EFL=%06x\n",
    13754                  pCtx->cs.Sel, pCtx->rip, pCtx->ss.Sel, pCtx->rsp, pCtx->eflags.u));
    13755     RT_NOREF_PV(pVCpu); RT_NOREF_PV(pCtx); RT_NOREF_PV(fSameCtx);
     13641                 pVCpu->cpum.GstCtx.cs.Sel, pVCpu->cpum.GstCtx.rip, pVCpu->cpum.GstCtx.ss.Sel, pVCpu->cpum.GstCtx.rsp, pVCpu->cpum.GstCtx.eflags.u));
     13642    RT_NOREF_PV(pVCpu); RT_NOREF_PV(fSameCtx);
    1375613643}
    1375713644#endif /* LOG_ENABLED */
    … …  
    1389913786        {
    1390013787#ifdef LOG_ENABLED
    13901             iemLogCurInstr(pVCpu, IEM_GET_CTX(pVCpu), false);
     13788            iemLogCurInstr(pVCpu, false);
    1390213789#endif
    1390313790#ifdef IEM_WITH_SETJMP
    … …  
    1394813835 * @returns rcStrict, maybe modified.
    1394913836 * @param   pVCpu       The cross context virtual CPU structure of the calling thread.
    13950  * @param   pCtx        The current CPU context.
    1395113837 * @param   rcStrict    The status code returne by the interpreter.
    1395213838 */
    13953 DECLINLINE(VBOXSTRICTRC) iemRCRawMaybeReenter(PVMCPU pVCpu, PCPUMCTX pCtx, VBOXSTRICTRC rcStrict)
     13839DECLINLINE(VBOXSTRICTRC) iemRCRawMaybeReenter(PVMCPU pVCpu, VBOXSTRICTRC rcStrict)
    1395413840{
    1395513841    if (   !pVCpu->iem.s.fInPatchCode
    … …  
    1395813844            || rcStrict == VERR_IEM_ASPECT_NOT_IMPLEMENTED /* ditto */ ) )
    1395913845    {
    13960         if (pCtx->eflags.Bits.u1IF || rcStrict != VINF_SUCCESS)
     13846        if (pVCpu->cpum.GstCtx.eflags.Bits.u1IF || rcStrict != VINF_SUCCESS)
    1396113847            CPUMRawEnter(pVCpu);
    1396213848        else
    … …  
    1398013866{
    1398113867#ifdef LOG_ENABLED
    13982     PCPUMCTX pCtx = IEM_GET_CTX(pVCpu);
    13983     iemLogCurInstr(pVCpu, pCtx, true);
     13868    iemLogCurInstr(pVCpu, true);
    1398413869#endif
    1398513870
    … …  
    1399413879
    1399513880#ifdef IN_RC
    13996     rcStrict = iemRCRawMaybeReenter(pVCpu, IEM_GET_CTX(pVCpu), rcStrict);
     13881    rcStrict = iemRCRawMaybeReenter(pVCpu, rcStrict);
    1399713882#endif
    1399813883    if (rcStrict != VINF_SUCCESS)
    1399913884        LogFlow(("IEMExecOne: cs:rip=%04x:%08RX64 ss:rsp=%04x:%08RX64 EFL=%06x - rcStrict=%Rrc\n",
    14000                  pCtx->cs.Sel, pCtx->rip, pCtx->ss.Sel, pCtx->rsp, pCtx->eflags.u, VBOXSTRICTRC_VAL(rcStrict)));
     13885                 pVCpu->cpum.GstCtx.cs.Sel, pVCpu->cpum.GstCtx.rip, pVCpu->cpum.GstCtx.ss.Sel, pVCpu->cpum.GstCtx.rsp, pVCpu->cpum.GstCtx.eflags.u, VBOXSTRICTRC_VAL(rcStrict)));
    1400113886    return rcStrict;
    1400213887}
    … …  
    1402013905
    1402113906#ifdef IN_RC
    14022     rcStrict = iemRCRawMaybeReenter(pVCpu, pCtx, rcStrict);
     13907    rcStrict = iemRCRawMaybeReenter(pVCpu, rcStrict);
    1402313908#endif
    1402413909    return rcStrict;
    … …  
    1403413919    VBOXSTRICTRC rcStrict;
    1403513920    if (   cbOpcodeBytes
    14036         && pCtx->rip == OpcodeBytesPC)
     13921        && pVCpu->cpum.GstCtx.rip == OpcodeBytesPC)
    1403713922    {
    1403813923        iemInitDecoder(pVCpu, false);
    … …  
    1405713942
    1405813943#ifdef IN_RC
    14059     rcStrict = iemRCRawMaybeReenter(pVCpu, pCtx, rcStrict);
     13944    rcStrict = iemRCRawMaybeReenter(pVCpu, rcStrict);
    1406013945#endif
    1406113946    return rcStrict;
    … …  
    1408013965
    1408113966#ifdef IN_RC
    14082     rcStrict = iemRCRawMaybeReenter(pVCpu, pCtx, rcStrict);
     13967    rcStrict = iemRCRawMaybeReenter(pVCpu, rcStrict);
    1408313968#endif
    1408413969    return rcStrict;
    … …  
    1409413979    VBOXSTRICTRC rcStrict;
    1409513980    if (   cbOpcodeBytes
    14096         && pCtx->rip == OpcodeBytesPC)
     13981        && pVCpu->cpum.GstCtx.rip == OpcodeBytesPC)
    1409713982    {
    1409813983        iemInitDecoder(pVCpu, true);
    … …  
    1411714002
    1411814003#ifdef IN_RC
    14119     rcStrict = iemRCRawMaybeReenter(pVCpu, pCtx, rcStrict);
     14004    rcStrict = iemRCRawMaybeReenter(pVCpu, rcStrict);
    1412014005#endif
    1412114006    return rcStrict;
    … …  
    1414614031    VBOXSTRICTRC rcStrict;
    1414714032    if (   cbOpcodeBytes
    14148         && pCtx->rip == OpcodeBytesPC)
     14033        && pVCpu->cpum.GstCtx.rip == OpcodeBytesPC)
    1414914034    {
    1415014035        iemInitDecoder(pVCpu, true);
    … …  
    1417314058
    1417414059#ifdef IN_RC
    14175     rcStrict = iemRCRawMaybeReenter(pVCpu, pCtx, rcStrict);
     14060    rcStrict = iemRCRawMaybeReenter(pVCpu, rcStrict);
    1417614061#endif
    1417714062    return rcStrict;
    … …  
    1418614071     * See if there is an interrupt pending in TRPM, inject it if we can.
    1418714072     */
    14188     PCPUMCTX pCtx = IEM_GET_CTX(pVCpu);
    14189 
    1419014073    /** @todo Can we centralize this under CPUMCanInjectInterrupt()? */
    1419114074#if defined(VBOX_WITH_NESTED_HWVIRT_SVM)
    14192     bool fIntrEnabled = pCtx->hwvirt.fGif;
     14075    bool fIntrEnabled = pVCpu->cpum.GstCtx.hwvirt.fGif;
    1419314076    if (fIntrEnabled)
    1419414077    {
    14195         if (CPUMIsGuestInSvmNestedHwVirtMode(pCtx))
    14196             fIntrEnabled = CPUMCanSvmNstGstTakePhysIntr(pVCpu, pCtx);
     14078        if (CPUMIsGuestInSvmNestedHwVirtMode(IEM_GET_CTX(pVCpu)))
     14079            fIntrEnabled = CPUMCanSvmNstGstTakePhysIntr(pVCpu, IEM_GET_CTX(pVCpu));
    1419714080        else
    14198             fIntrEnabled = pCtx->eflags.Bits.u1IF;
     14081            fIntrEnabled = pVCpu->cpum.GstCtx.eflags.Bits.u1IF;
    1419914082    }
    1420014083#else
    14201     bool fIntrEnabled = pCtx->eflags.Bits.u1IF;
     14084    bool fIntrEnabled = pVCpu->cpum.GstCtx.eflags.Bits.u1IF;
    1420214085#endif
    1420314086    if (   fIntrEnabled
    1420414087        && TRPMHasTrap(pVCpu)
    14205         && EMGetInhibitInterruptsPC(pVCpu) != pCtx->rip)
     14088        && EMGetInhibitInterruptsPC(pVCpu) != pVCpu->cpum.GstCtx.rip)
    1420614089    {
    1420714090        uint8_t     u8TrapNo;
    … …  
    1423914122                 */
    1424014123#ifdef LOG_ENABLED
    14241                 iemLogCurInstr(pVCpu, pCtx, true);
     14124                iemLogCurInstr(pVCpu, true);
    1424214125#endif
    1424314126
    … …  
    1426914152                        if (RT_LIKELY(   (   !fCpu
    1427014153                                          || (   !(fCpu & ~(VMCPU_FF_INTERRUPT_APIC | VMCPU_FF_INTERRUPT_PIC))
    14271                                               && !pCtx->rflags.Bits.u1IF) )
     14154                                              && !pVCpu->cpum.GstCtx.rflags.Bits.u1IF) )
    1427214155                                      && !VM_FF_IS_PENDING(pVM, VM_FF_ALL_MASK) ))
    1427314156                        {
    … …  
    1432214205     */
    1432314206#ifdef IN_RC
    14324     rcStrict = iemRCRawMaybeReenter(pVCpu, IEM_GET_CTX(pVCpu), rcStrict);
     14207    rcStrict = iemRCRawMaybeReenter(pVCpu, rcStrict);
    1432514208#endif
    1432614209    if (rcStrict != VINF_SUCCESS)
    1432714210        LogFlow(("IEMExecLots: cs:rip=%04x:%08RX64 ss:rsp=%04x:%08RX64 EFL=%06x - rcStrict=%Rrc\n",
    14328                  pCtx->cs.Sel, pCtx->rip, pCtx->ss.Sel, pCtx->rsp, pCtx->eflags.u, VBOXSTRICTRC_VAL(rcStrict)));
     14211                 pVCpu->cpum.GstCtx.cs.Sel, pVCpu->cpum.GstCtx.rip, pVCpu->cpum.GstCtx.ss.Sel, pVCpu->cpum.GstCtx.rsp, pVCpu->cpum.GstCtx.eflags.u, VBOXSTRICTRC_VAL(rcStrict)));
    1432914212    if (pcInstructions)
    1433014213        *pcInstructions = pVCpu->iem.s.cInstructions - cInstructionsAtStart;
    … …  
    1447914362    else
    1448014363        LogFlow(("IEMExecInstr_iret: cs:rip=%04x:%08RX64 ss:rsp=%04x:%08RX64 EFL=%06x - rcStrict=%Rrc\n",
    14481                  pCtx->cs, pCtx->rip, pCtx->ss, pCtx->rsp, pCtx->eflags.u, VBOXSTRICTRC_VAL(rcStrict)));
     14364                 pVCpu->cpum.GstCtx.cs, pVCpu->cpum.GstCtx.rip, pVCpu->cpum.GstCtx.ss, pVCpu->cpum.GstCtx.rsp, pVCpu->cpum.GstCtx.eflags.u, VBOXSTRICTRC_VAL(rcStrict)));
    1448214365    return rcStrict;
    1448314366}
    … …  
    1451114394    iemUninitExec(pVCpu);
    1451214395#ifdef IN_RC
    14513     return iemRCRawMaybeReenter(pVCpu, IEM_GET_CTX(pVCpu),
    14514                                 iemExecStatusCodeFiddling(pVCpu, rcStrict));
     14396    return iemRCRawMaybeReenter(pVCpu, iemExecStatusCodeFiddling(pVCpu, rcStrict));
    1451514397#else
    1451614398    return iemExecStatusCodeFiddling(pVCpu, rcStrict);
    … …  
    1510314985VMM_INT_DECL(VBOXSTRICTRC) IEMExecSvmVmexit(PVMCPU pVCpu, uint64_t uExitCode, uint64_t uExitInfo1, uint64_t uExitInfo2)
    1510414986{
    15105     IEM_CTX_ASSERT(IEM_GET_CTX(pVCpu), IEM_CPUMCTX_EXTRN_MUST_MASK);
    15106     VBOXSTRICTRC rcStrict = iemSvmVmexit(pVCpu, IEM_GET_CTX(pVCpu), uExitCode, uExitInfo1, uExitInfo2);
     14987    IEM_CTX_ASSERT(pVCpu, IEM_CPUMCTX_EXTRN_MUST_MASK);
     14988    VBOXSTRICTRC rcStrict = iemSvmVmexit(pVCpu, uExitCode, uExitInfo1, uExitInfo2);
    1510714989    return iemExecStatusCodeFiddling(pVCpu, rcStrict);
    1510814990}

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

    r72494 r72496  
    3131 *
    3232 * @param   pVCpu               The cross context virtual CPU structure of the calling thread.
    33  * @param   pCtx                The register context.
    3433 * @param   u16Port             The port number.
    3534 * @param   cbOperand           The operand size.
    3635 */
    37 static VBOXSTRICTRC iemHlpCheckPortIOPermissionBitmap(PVMCPU pVCpu, PCCPUMCTX pCtx, uint16_t u16Port, uint8_t cbOperand)
     36static VBOXSTRICTRC iemHlpCheckPortIOPermissionBitmap(PVMCPU pVCpu, uint16_t u16Port, uint8_t cbOperand)
    3837{
    3938    /* The TSS bits we're interested in are the same on 386 and AMD64. */
    … …  
    4342    AssertCompile(sizeof(X86TSS32) == sizeof(X86TSS64));
    4443
    45     IEM_CTX_IMPORT_RET(pVCpu, (PCPUMCTX)pCtx, CPUMCTX_EXTRN_TR);
     44    IEM_CTX_IMPORT_RET(pVCpu, CPUMCTX_EXTRN_TR);
    4645
    4746    /*
    4847     * Check the TSS type, 16-bit TSSes doesn't have any I/O permission bitmap.
    4948     */
    50     Assert(!pCtx->tr.Attr.n.u1DescType);
    51     if (RT_UNLIKELY(   pCtx->tr.Attr.n.u4Type != AMD64_SEL_TYPE_SYS_TSS_BUSY
    52                     && pCtx->tr.Attr.n.u4Type != AMD64_SEL_TYPE_SYS_TSS_AVAIL))
     49    Assert(!pVCpu->cpum.GstCtx.tr.Attr.n.u1DescType);
     50    if (RT_UNLIKELY(   pVCpu->cpum.GstCtx.tr.Attr.n.u4Type != AMD64_SEL_TYPE_SYS_TSS_BUSY
     51                    && pVCpu->cpum.GstCtx.tr.Attr.n.u4Type != AMD64_SEL_TYPE_SYS_TSS_AVAIL))
    5352    {
    5453        Log(("iemHlpCheckPortIOPermissionBitmap: Port=%#x cb=%d - TSS type %#x (attr=%#x) has no I/O bitmap -> #GP(0)\n",
    55              u16Port, cbOperand, pCtx->tr.Attr.n.u4Type, pCtx->tr.Attr.u));
     54             u16Port, cbOperand, pVCpu->cpum.GstCtx.tr.Attr.n.u4Type, pVCpu->cpum.GstCtx.tr.Attr.u));
    5655        return iemRaiseGeneralProtectionFault0(pVCpu);
    5756    }
    … …  
    6261    uint16_t offBitmap;
    6362    VBOXSTRICTRC rcStrict = iemMemFetchSysU16(pVCpu, &offBitmap, UINT8_MAX,
    64                                               pCtx->tr.u64Base + RT_OFFSETOF(X86TSS64, offIoBitmap));
     63                                              pVCpu->cpum.GstCtx.tr.u64Base + RT_OFFSETOF(X86TSS64, offIoBitmap));
    6564    if (rcStrict != VINF_SUCCESS)
    6665    {
    … …  
    7776    /** @todo check if real CPUs ensures that offBitmap has a minimum value of
    7877     *        for instance sizeof(X86TSS32). */
    79     if (offFirstBit + 1 > pCtx->tr.u32Limit) /* the limit is inclusive */
     78    if (offFirstBit + 1 > pVCpu->cpum.GstCtx.tr.u32Limit) /* the limit is inclusive */
    8079    {
    8180        Log(("iemHlpCheckPortIOPermissionBitmap: offFirstBit=%#x + 1 is beyond u32Limit=%#x -> #GP(0)\n",
    82              offFirstBit, pCtx->tr.u32Limit));
     81             offFirstBit, pVCpu->cpum.GstCtx.tr.u32Limit));
    8382        return iemRaiseGeneralProtectionFault0(pVCpu);
    8483    }
    … …  
    9190     *        2nd byte when it's not required. */
    9291    uint16_t bmBytes = UINT16_MAX;
    93     rcStrict = iemMemFetchSysU16(pVCpu, &bmBytes, UINT8_MAX, pCtx->tr.u64Base + offFirstBit);
     92    rcStrict = iemMemFetchSysU16(pVCpu, &bmBytes, UINT8_MAX, pVCpu->cpum.GstCtx.tr.u64Base + offFirstBit);
    9493    if (rcStrict != VINF_SUCCESS)
    9594    {
    … …  
    122121 *
    123122 * @param   pVCpu               The cross context virtual CPU structure of the calling thread.
    124  * @param   pCtx                The register context.
    125123 * @param   u16Port             The port number.
    126124 * @param   cbOperand           The operand size.
    127125 */
    128 DECLINLINE(VBOXSTRICTRC) iemHlpCheckPortIOPermission(PVMCPU pVCpu, PCCPUMCTX pCtx, uint16_t u16Port, uint8_t cbOperand)
     126DECLINLINE(VBOXSTRICTRC) iemHlpCheckPortIOPermission(PVMCPU pVCpu, uint16_t u16Port, uint8_t cbOperand)
    129127{
    130128    X86EFLAGS Efl;
    131     Efl.u = IEMMISC_GET_EFL(pVCpu, pCtx);
    132     if (   (pCtx->cr0 & X86_CR0_PE)
     129    Efl.u = IEMMISC_GET_EFL(pVCpu);
     130    if (   (pVCpu->cpum.GstCtx.cr0 & X86_CR0_PE)
    133131        && (    pVCpu->iem.s.uCpl > Efl.Bits.u2IOPL
    134132            ||  Efl.Bits.u1VM) )
    135         return iemHlpCheckPortIOPermissionBitmap(pVCpu, pCtx, u16Port, cbOperand);
     133        return iemHlpCheckPortIOPermissionBitmap(pVCpu, u16Port, cbOperand);
    136134    return VINF_SUCCESS;
    137135}
    … …  
    182180static void iemHlpUpdateArithEFlagsU8(PVMCPU pVCpu, uint8_t u8Result, uint32_t fToUpdate, uint32_t fUndefined)
    183181{
    184     PCPUMCTX pCtx = IEM_GET_CTX(pVCpu);
    185 
    186     uint32_t fEFlags = pCtx->eflags.u;
     182    uint32_t fEFlags = pVCpu->cpum.GstCtx.eflags.u;
    187183    iemAImpl_test_u8(&u8Result, u8Result, &fEFlags);
    188     pCtx->eflags.u &= ~(fToUpdate | fUndefined);
    189     pCtx->eflags.u |= (fToUpdate | fUndefined) & fEFlags;
     184    pVCpu->cpum.GstCtx.eflags.u &= ~(fToUpdate | fUndefined);
     185    pVCpu->cpum.GstCtx.eflags.u |= (fToUpdate | fUndefined) & fEFlags;
    190186}
    191187
    … …  
    201197static void iemHlpUpdateArithEFlagsU16(PVMCPU pVCpu, uint16_t u16Result, uint32_t fToUpdate, uint32_t fUndefined)
    202198{
    203     PCPUMCTX pCtx = IEM_GET_CTX(pVCpu);
    204 
    205     uint32_t fEFlags = pCtx->eflags.u;
     199    uint32_t fEFlags = pVCpu->cpum.GstCtx.eflags.u;
    206200    iemAImpl_test_u16(&u16Result, u16Result, &fEFlags);
    207     pCtx->eflags.u &= ~(fToUpdate | fUndefined);
    208     pCtx->eflags.u |= (fToUpdate | fUndefined) & fEFlags;
     201    pVCpu->cpum.GstCtx.eflags.u &= ~(fToUpdate | fUndefined);
     202    pVCpu->cpum.GstCtx.eflags.u |= (fToUpdate | fUndefined) & fEFlags;
    209203}
    210204
    … …  
    225219    Assert(CPUMSELREG_ARE_HIDDEN_PARTS_VALID(pVCpu, pSReg));
    226220#endif
    227     IEM_CTX_ASSERT(IEM_GET_CTX(pVCpu), CPUMCTX_EXTRN_SREG_MASK);
     221    IEM_CTX_ASSERT(pVCpu, CPUMCTX_EXTRN_SREG_MASK);
    228222
    229223    if (   uCpl > pSReg->Attr.n.u2Dpl
    … …  
    256250IEM_CIMPL_DEF_0(iemCImpl_popa_16)
    257251{
    258     PCPUMCTX        pCtx        = IEM_GET_CTX(pVCpu);
    259     RTGCPTR         GCPtrStart  = iemRegGetEffRsp(pVCpu, pCtx);
     252    RTGCPTR         GCPtrStart  = iemRegGetEffRsp(pVCpu);
    260253    RTGCPTR         GCPtrLast   = GCPtrStart + 15;
    261254    VBOXSTRICTRC    rcStrict;
    … …  
    270263    /** @todo do popa boundary / wrap-around checks.  */
    271264    if (RT_UNLIKELY(   IEM_IS_REAL_OR_V86_MODE(pVCpu)
    272                     && (pCtx->cs.u32Limit < GCPtrLast)) ) /* ASSUMES 64-bit RTGCPTR */
     265                    && (pVCpu->cpum.GstCtx.cs.u32Limit < GCPtrLast)) ) /* ASSUMES 64-bit RTGCPTR */
    273266    {
    274267        /* word-by-word */
    275268        RTUINT64U TmpRsp;
    276         TmpRsp.u = pCtx->rsp;
    277         rcStrict = iemMemStackPopU16Ex(pVCpu, &pCtx->di, &TmpRsp);
     269        TmpRsp.u = pVCpu->cpum.GstCtx.rsp;
     270        rcStrict = iemMemStackPopU16Ex(pVCpu, &pVCpu->cpum.GstCtx.di, &TmpRsp);
    278271        if (rcStrict == VINF_SUCCESS)
    279             rcStrict = iemMemStackPopU16Ex(pVCpu, &pCtx->si, &TmpRsp);
     272            rcStrict = iemMemStackPopU16Ex(pVCpu, &pVCpu->cpum.GstCtx.si, &TmpRsp);
    280273        if (rcStrict == VINF_SUCCESS)
    281             rcStrict = iemMemStackPopU16Ex(pVCpu, &pCtx->bp, &TmpRsp);
     274            rcStrict = iemMemStackPopU16Ex(pVCpu, &pVCpu->cpum.GstCtx.bp, &TmpRsp);
    282275        if (rcStrict == VINF_SUCCESS)
    283276        {
    284             iemRegAddToRspEx(pVCpu, pCtx, &TmpRsp, 2); /* sp */
    285             rcStrict = iemMemStackPopU16Ex(pVCpu, &pCtx->bx, &TmpRsp);
     277            iemRegAddToRspEx(pVCpu, &TmpRsp, 2); /* sp */
     278            rcStrict = iemMemStackPopU16Ex(pVCpu, &pVCpu->cpum.GstCtx.bx, &TmpRsp);
    286279        }
    287280        if (rcStrict == VINF_SUCCESS)
    288             rcStrict = iemMemStackPopU16Ex(pVCpu, &pCtx->dx, &TmpRsp);
     281            rcStrict = iemMemStackPopU16Ex(pVCpu, &pVCpu->cpum.GstCtx.dx, &TmpRsp);
    289282        if (rcStrict == VINF_SUCCESS)
    290             rcStrict = iemMemStackPopU16Ex(pVCpu, &pCtx->cx, &TmpRsp);
     283            rcStrict = iemMemStackPopU16Ex(pVCpu, &pVCpu->cpum.GstCtx.cx, &TmpRsp);
    291284        if (rcStrict == VINF_SUCCESS)
    292             rcStrict = iemMemStackPopU16Ex(pVCpu, &pCtx->ax, &TmpRsp);
     285            rcStrict = iemMemStackPopU16Ex(pVCpu, &pVCpu->cpum.GstCtx.ax, &TmpRsp);
    293286        if (rcStrict == VINF_SUCCESS)
    294287        {
    295             pCtx->rsp = TmpRsp.u;
     288            pVCpu->cpum.GstCtx.rsp = TmpRsp.u;
    296289            iemRegAddToRipAndClearRF(pVCpu, cbInstr);
    297290        }
    … …  
    303296        if (rcStrict == VINF_SUCCESS)
    304297        {
    305             pCtx->di = pa16Mem[7 - X86_GREG_xDI];
    306             pCtx->si = pa16Mem[7 - X86_GREG_xSI];
    307             pCtx->bp = pa16Mem[7 - X86_GREG_xBP];
     298            pVCpu->cpum.GstCtx.di = pa16Mem[7 - X86_GREG_xDI];
     299            pVCpu->cpum.GstCtx.si = pa16Mem[7 - X86_GREG_xSI];
     300            pVCpu->cpum.GstCtx.bp = pa16Mem[7 - X86_GREG_xBP];
    308301            /* skip sp */
    309             pCtx->bx = pa16Mem[7 - X86_GREG_xBX];
    310             pCtx->dx = pa16Mem[7 - X86_GREG_xDX];
    311             pCtx->cx = pa16Mem[7 - X86_GREG_xCX];
    312             pCtx->ax = pa16Mem[7 - X86_GREG_xAX];
     302            pVCpu->cpum.GstCtx.bx = pa16Mem[7 - X86_GREG_xBX];
     303            pVCpu->cpum.GstCtx.dx = pa16Mem[7 - X86_GREG_xDX];
     304            pVCpu->cpum.GstCtx.cx = pa16Mem[7 - X86_GREG_xCX];
     305            pVCpu->cpum.GstCtx.ax = pa16Mem[7 - X86_GREG_xAX];
    313306            rcStrict = iemMemCommitAndUnmap(pVCpu, (void *)pa16Mem, IEM_ACCESS_STACK_R);
    314307            if (rcStrict == VINF_SUCCESS)
    315308            {
    316                 iemRegAddToRsp(pVCpu, pCtx, 16);
     309                iemRegAddToRsp(pVCpu, 16);
    317310                iemRegAddToRipAndClearRF(pVCpu, cbInstr);
    318311            }
    … …  
    328321IEM_CIMPL_DEF_0(iemCImpl_popa_32)
    329322{
    330     PCPUMCTX        pCtx        = IEM_GET_CTX(pVCpu);
    331     RTGCPTR         GCPtrStart  = iemRegGetEffRsp(pVCpu, pCtx);
     323    RTGCPTR         GCPtrStart  = iemRegGetEffRsp(pVCpu);
    332324    RTGCPTR         GCPtrLast   = GCPtrStart + 31;
    333325    VBOXSTRICTRC    rcStrict;
    … …  
    342334    /** @todo do popa boundary / wrap-around checks.  */
    343335    if (RT_UNLIKELY(   IEM_IS_REAL_OR_V86_MODE(pVCpu)
    344                     && (pCtx->cs.u32Limit < GCPtrLast)) ) /* ASSUMES 64-bit RTGCPTR */
     336                    && (pVCpu->cpum.GstCtx.cs.u32Limit < GCPtrLast)) ) /* ASSUMES 64-bit RTGCPTR */
    345337    {
    346338        /* word-by-word */
    347339        RTUINT64U TmpRsp;
    348         TmpRsp.u = pCtx->rsp;
    349         rcStrict = iemMemStackPopU32Ex(pVCpu, &pCtx->edi, &TmpRsp);
     340        TmpRsp.u = pVCpu->cpum.GstCtx.rsp;
     341        rcStrict = iemMemStackPopU32Ex(pVCpu, &pVCpu->cpum.GstCtx.edi, &TmpRsp);
    350342        if (rcStrict == VINF_SUCCESS)
    351             rcStrict = iemMemStackPopU32Ex(pVCpu, &pCtx->esi, &TmpRsp);
     343            rcStrict = iemMemStackPopU32Ex(pVCpu, &pVCpu->cpum.GstCtx.esi, &TmpRsp);
    352344        if (rcStrict == VINF_SUCCESS)
    353             rcStrict = iemMemStackPopU32Ex(pVCpu, &pCtx->ebp, &TmpRsp);
     345            rcStrict = iemMemStackPopU32Ex(pVCpu, &pVCpu->cpum.GstCtx.ebp, &TmpRsp);
    354346        if (rcStrict == VINF_SUCCESS)
    355347        {
    356             iemRegAddToRspEx(pVCpu, pCtx, &TmpRsp, 2); /* sp */
    357             rcStrict = iemMemStackPopU32Ex(pVCpu, &pCtx->ebx, &TmpRsp);
     348            iemRegAddToRspEx(pVCpu, &TmpRsp, 2); /* sp */
     349            rcStrict = iemMemStackPopU32Ex(pVCpu, &pVCpu->cpum.GstCtx.ebx, &TmpRsp);
    358350        }
    359351        if (rcStrict == VINF_SUCCESS)
    360             rcStrict = iemMemStackPopU32Ex(pVCpu, &pCtx->edx, &TmpRsp);
     352            rcStrict = iemMemStackPopU32Ex(pVCpu, &pVCpu->cpum.GstCtx.edx, &TmpRsp);
    361353        if (rcStrict == VINF_SUCCESS)
    362             rcStrict = iemMemStackPopU32Ex(pVCpu, &pCtx->ecx, &TmpRsp);
     354            rcStrict = iemMemStackPopU32Ex(pVCpu, &pVCpu->cpum.GstCtx.ecx, &TmpRsp);
    363355        if (rcStrict == VINF_SUCCESS)
    364             rcStrict = iemMemStackPopU32Ex(pVCpu, &pCtx->eax, &TmpRsp);
     356            rcStrict = iemMemStackPopU32Ex(pVCpu, &pVCpu->cpum.GstCtx.eax, &TmpRsp);
    365357        if (rcStrict == VINF_SUCCESS)
    366358        {
    367359#if 1  /** @todo what actually happens with the high bits when we're in 16-bit mode? */
    368             pCtx->rdi &= UINT32_MAX;
    369             pCtx->rsi &= UINT32_MAX;
    370             pCtx->rbp &= UINT32_MAX;
    371             pCtx->rbx &= UINT32_MAX;
    372             pCtx->rdx &= UINT32_MAX;
    373             pCtx->rcx &= UINT32_MAX;
    374             pCtx->rax &= UINT32_MAX;
     360            pVCpu->cpum.GstCtx.rdi &= UINT32_MAX;
     361            pVCpu->cpum.GstCtx.rsi &= UINT32_MAX;
     362            pVCpu->cpum.GstCtx.rbp &= UINT32_MAX;
     363            pVCpu->cpum.GstCtx.rbx &= UINT32_MAX;
     364            pVCpu->cpum.GstCtx.rdx &= UINT32_MAX;
     365            pVCpu->cpum.GstCtx.rcx &= UINT32_MAX;
     366            pVCpu->cpum.GstCtx.rax &= UINT32_MAX;
    375367#endif
    376             pCtx->rsp = TmpRsp.u;
     368            pVCpu->cpum.GstCtx.rsp = TmpRsp.u;
    377369            iemRegAddToRipAndClearRF(pVCpu, cbInstr);
    378370        }
    … …  
    384376        if (rcStrict == VINF_SUCCESS)
    385377        {
    386             pCtx->rdi = pa32Mem[7 - X86_GREG_xDI];
    387             pCtx->rsi = pa32Mem[7 - X86_GREG_xSI];
    388             pCtx->rbp = pa32Mem[7 - X86_GREG_xBP];
     378            pVCpu->cpum.GstCtx.rdi = pa32Mem[7 - X86_GREG_xDI];
     379            pVCpu->cpum.GstCtx.rsi = pa32Mem[7 - X86_GREG_xSI];
     380            pVCpu->cpum.GstCtx.rbp = pa32Mem[7 - X86_GREG_xBP];
    389381            /* skip esp */
    390             pCtx->rbx = pa32Mem[7 - X86_GREG_xBX];
    391             pCtx->rdx = pa32Mem[7 - X86_GREG_xDX];
    392             pCtx->rcx = pa32Mem[7 - X86_GREG_xCX];
    393             pCtx->rax = pa32Mem[7 - X86_GREG_xAX];
     382            pVCpu->cpum.GstCtx.rbx = pa32Mem[7 - X86_GREG_xBX];
     383            pVCpu->cpum.GstCtx.rdx = pa32Mem[7 - X86_GREG_xDX];
     384            pVCpu->cpum.GstCtx.rcx = pa32Mem[7 - X86_GREG_xCX];
     385            pVCpu->cpum.GstCtx.rax = pa32Mem[7 - X86_GREG_xAX];
    394386            rcStrict = iemMemCommitAndUnmap(pVCpu, (void *)pa32Mem, IEM_ACCESS_STACK_R);
    395387            if (rcStrict == VINF_SUCCESS)
    396388            {
    397                 iemRegAddToRsp(pVCpu, pCtx, 32);
     389                iemRegAddToRsp(pVCpu, 32);
    398390                iemRegAddToRipAndClearRF(pVCpu, cbInstr);
    399391            }
    … …  
    409401IEM_CIMPL_DEF_0(iemCImpl_pusha_16)
    410402{
    411     PCPUMCTX        pCtx        = IEM_GET_CTX(pVCpu);
    412     RTGCPTR         GCPtrTop    = iemRegGetEffRsp(pVCpu, pCtx);
     403    RTGCPTR         GCPtrTop    = iemRegGetEffRsp(pVCpu);
    413404    RTGCPTR         GCPtrBottom = GCPtrTop - 15;
    414405    VBOXSTRICTRC    rcStrict;
    … …  
    427418        /* word-by-word */
    428419        RTUINT64U TmpRsp;
    429         TmpRsp.u = pCtx->rsp;
    430         rcStrict = iemMemStackPushU16Ex(pVCpu, pCtx->ax, &TmpRsp);
     420        TmpRsp.u = pVCpu->cpum.GstCtx.rsp;
     421        rcStrict = iemMemStackPushU16Ex(pVCpu, pVCpu->cpum.GstCtx.ax, &TmpRsp);
    431422        if (rcStrict == VINF_SUCCESS)
    432             rcStrict = iemMemStackPushU16Ex(pVCpu, pCtx->cx, &TmpRsp);
     423            rcStrict = iemMemStackPushU16Ex(pVCpu, pVCpu->cpum.GstCtx.cx, &TmpRsp);
    433424        if (rcStrict == VINF_SUCCESS)
    434             rcStrict = iemMemStackPushU16Ex(pVCpu, pCtx->dx, &TmpRsp);
     425            rcStrict = iemMemStackPushU16Ex(pVCpu, pVCpu->cpum.GstCtx.dx, &TmpRsp);
    435426        if (rcStrict == VINF_SUCCESS)
    436             rcStrict = iemMemStackPushU16Ex(pVCpu, pCtx->bx, &TmpRsp);
     427            rcStrict = iemMemStackPushU16Ex(pVCpu, pVCpu->cpum.GstCtx.bx, &TmpRsp);
    437428        if (rcStrict == VINF_SUCCESS)
    438             rcStrict = iemMemStackPushU16Ex(pVCpu, pCtx->sp, &TmpRsp);
     429            rcStrict = iemMemStackPushU16Ex(pVCpu, pVCpu->cpum.GstCtx.sp, &TmpRsp);
    439430        if (rcStrict == VINF_SUCCESS)
    440             rcStrict = iemMemStackPushU16Ex(pVCpu, pCtx->bp, &TmpRsp);
     431            rcStrict = iemMemStackPushU16Ex(pVCpu, pVCpu->cpum.GstCtx.bp, &TmpRsp);
    441432        if (rcStrict == VINF_SUCCESS)
    442             rcStrict = iemMemStackPushU16Ex(pVCpu, pCtx->si, &TmpRsp);
     433            rcStrict = iemMemStackPushU16Ex(pVCpu, pVCpu->cpum.GstCtx.si, &TmpRsp);
    443434        if (rcStrict == VINF_SUCCESS)
    444             rcStrict = iemMemStackPushU16Ex(pVCpu, pCtx->di, &TmpRsp);
     435            rcStrict = iemMemStackPushU16Ex(pVCpu, pVCpu->cpum.GstCtx.di, &TmpRsp);
    445436        if (rcStrict == VINF_SUCCESS)
    446437        {
    447             pCtx->rsp = TmpRsp.u;
     438            pVCpu->cpum.GstCtx.rsp = TmpRsp.u;
    448439            iemRegAddToRipAndClearRF(pVCpu, cbInstr);
    449440        }
    … …  
    456447        if (rcStrict == VINF_SUCCESS)
    457448        {
    458             pa16Mem[7 - X86_GREG_xDI] = pCtx->di;
    459             pa16Mem[7 - X86_GREG_xSI] = pCtx->si;
    460             pa16Mem[7 - X86_GREG_xBP] = pCtx->bp;
    461             pa16Mem[7 - X86_GREG_xSP] = pCtx->sp;
    462             pa16Mem[7 - X86_GREG_xBX] = pCtx->bx;
    463             pa16Mem[7 - X86_GREG_xDX] = pCtx->dx;
    464             pa16Mem[7 - X86_GREG_xCX] = pCtx->cx;
    465             pa16Mem[7 - X86_GREG_xAX] = pCtx->ax;
     449            pa16Mem[7 - X86_GREG_xDI] = pVCpu->cpum.GstCtx.di;
     450            pa16Mem[7 - X86_GREG_xSI] = pVCpu->cpum.GstCtx.si;
     451            pa16Mem[7 - X86_GREG_xBP] = pVCpu->cpum.GstCtx.bp;
     452            pa16Mem[7 - X86_GREG_xSP] = pVCpu->cpum.GstCtx.sp;
     453            pa16Mem[7 - X86_GREG_xBX] = pVCpu->cpum.GstCtx.bx;
     454            pa16Mem[7 - X86_GREG_xDX] = pVCpu->cpum.GstCtx.dx;
     455            pa16Mem[7 - X86_GREG_xCX] = pVCpu->cpum.GstCtx.cx;
     456            pa16Mem[7 - X86_GREG_xAX] = pVCpu->cpum.GstCtx.ax;
    466457            rcStrict = iemMemCommitAndUnmap(pVCpu, (void *)pa16Mem, IEM_ACCESS_STACK_W);
    467458            if (rcStrict == VINF_SUCCESS)
    468459            {
    469                 iemRegSubFromRsp(pVCpu, pCtx, 16);
     460                iemRegSubFromRsp(pVCpu, 16);
    470461                iemRegAddToRipAndClearRF(pVCpu, cbInstr);
    471462            }
    … …  
    481472IEM_CIMPL_DEF_0(iemCImpl_pusha_32)
    482473{
    483     PCPUMCTX        pCtx        = IEM_GET_CTX(pVCpu);
    484     RTGCPTR         GCPtrTop    = iemRegGetEffRsp(pVCpu, pCtx);
     474    RTGCPTR         GCPtrTop    = iemRegGetEffRsp(pVCpu);
    485475    RTGCPTR         GCPtrBottom = GCPtrTop - 31;
    486476    VBOXSTRICTRC    rcStrict;
    … …  
    499489        /* word-by-word */
    500490        RTUINT64U TmpRsp;
    501         TmpRsp.u = pCtx->rsp;
    502         rcStrict = iemMemStackPushU32Ex(pVCpu, pCtx->eax, &TmpRsp);
     491        TmpRsp.u = pVCpu->cpum.GstCtx.rsp;
     492        rcStrict = iemMemStackPushU32Ex(pVCpu, pVCpu->cpum.GstCtx.eax, &TmpRsp);
    503493        if (rcStrict == VINF_SUCCESS)
    504             rcStrict = iemMemStackPushU32Ex(pVCpu, pCtx->ecx, &TmpRsp);
     494            rcStrict = iemMemStackPushU32Ex(pVCpu, pVCpu->cpum.GstCtx.ecx, &TmpRsp);
    505495        if (rcStrict == VINF_SUCCESS)
    506             rcStrict = iemMemStackPushU32Ex(pVCpu, pCtx->edx, &TmpRsp);
     496            rcStrict = iemMemStackPushU32Ex(pVCpu, pVCpu->cpum.GstCtx.edx, &TmpRsp);
    507497        if (rcStrict == VINF_SUCCESS)
    508             rcStrict = iemMemStackPushU32Ex(pVCpu, pCtx->ebx, &TmpRsp);
     498            rcStrict = iemMemStackPushU32Ex(pVCpu, pVCpu->cpum.GstCtx.ebx, &TmpRsp);
    509499        if (rcStrict == VINF_SUCCESS)
    510             rcStrict = iemMemStackPushU32Ex(pVCpu, pCtx->esp, &TmpRsp);
     500            rcStrict = iemMemStackPushU32Ex(pVCpu, pVCpu->cpum.GstCtx.esp, &TmpRsp);
    511501        if (rcStrict == VINF_SUCCESS)
    512             rcStrict = iemMemStackPushU32Ex(pVCpu, pCtx->ebp, &TmpRsp);
     502            rcStrict = iemMemStackPushU32Ex(pVCpu, pVCpu->cpum.GstCtx.ebp, &TmpRsp);
    513503        if (rcStrict == VINF_SUCCESS)
    514             rcStrict = iemMemStackPushU32Ex(pVCpu, pCtx->esi, &TmpRsp);
     504            rcStrict = iemMemStackPushU32Ex(pVCpu, pVCpu->cpum.GstCtx.esi, &TmpRsp);
    515505        if (rcStrict == VINF_SUCCESS)
    516             rcStrict = iemMemStackPushU32Ex(pVCpu, pCtx->edi, &TmpRsp);
     506            rcStrict = iemMemStackPushU32Ex(pVCpu, pVCpu->cpum.GstCtx.edi, &TmpRsp);
    517507        if (rcStrict == VINF_SUCCESS)
    518508        {
    519             pCtx->rsp = TmpRsp.u;
     509            pVCpu->cpum.GstCtx.rsp = TmpRsp.u;
    520510            iemRegAddToRipAndClearRF(pVCpu, cbInstr);
    521511        }
    … …  
    528518        if (rcStrict == VINF_SUCCESS)
    529519        {
    530             pa32Mem[7 - X86_GREG_xDI] = pCtx->edi;
    531             pa32Mem[7 - X86_GREG_xSI] = pCtx->esi;
    532             pa32Mem[7 - X86_GREG_xBP] = pCtx->ebp;
    533             pa32Mem[7 - X86_GREG_xSP] = pCtx->esp;
    534             pa32Mem[7 - X86_GREG_xBX] = pCtx->ebx;
    535             pa32Mem[7 - X86_GREG_xDX] = pCtx->edx;
    536             pa32Mem[7 - X86_GREG_xCX] = pCtx->ecx;
    537             pa32Mem[7 - X86_GREG_xAX] = pCtx->eax;
     520            pa32Mem[7 - X86_GREG_xDI] = pVCpu->cpum.GstCtx.edi;
     521            pa32Mem[7 - X86_GREG_xSI] = pVCpu->cpum.GstCtx.esi;
     522            pa32Mem[7 - X86_GREG_xBP] = pVCpu->cpum.GstCtx.ebp;
     523            pa32Mem[7 - X86_GREG_xSP] = pVCpu->cpum.GstCtx.esp;
     524            pa32Mem[7 - X86_GREG_xBX] = pVCpu->cpum.GstCtx.ebx;
     525            pa32Mem[7 - X86_GREG_xDX] = pVCpu->cpum.GstCtx.edx;
     526            pa32Mem[7 - X86_GREG_xCX] = pVCpu->cpum.GstCtx.ecx;
     527            pa32Mem[7 - X86_GREG_xAX] = pVCpu->cpum.GstCtx.eax;
    538528            rcStrict = iemMemCommitAndUnmap(pVCpu, pa32Mem, IEM_ACCESS_STACK_W);
    539529            if (rcStrict == VINF_SUCCESS)
    540530            {
    541                 iemRegSubFromRsp(pVCpu, pCtx, 32);
     531                iemRegSubFromRsp(pVCpu, 32);
    542532                iemRegAddToRipAndClearRF(pVCpu, cbInstr);
    543533            }
    … …  
    556546IEM_CIMPL_DEF_1(iemCImpl_pushf, IEMMODE, enmEffOpSize)
    557547{
    558     PCPUMCTX pCtx = IEM_GET_CTX(pVCpu);
    559548    VBOXSTRICTRC rcStrict;
    560549
    … …  
    570559     * doing this in a C implementation).
    571560     */
    572     uint32_t fEfl = IEMMISC_GET_EFL(pVCpu, pCtx);
     561    uint32_t fEfl = IEMMISC_GET_EFL(pVCpu);
    573562    if (   (fEfl & X86_EFL_VM)
    574563        && X86_EFL_GET_IOPL(fEfl) != 3 )
    575564    {
    576         Assert(pCtx->cr0 & X86_CR0_PE);
     565        Assert(pVCpu->cpum.GstCtx.cr0 & X86_CR0_PE);
    577566        if (   enmEffOpSize != IEMMODE_16BIT
    578             || !(pCtx->cr4 & X86_CR4_VME))
     567            || !(pVCpu->cpum.GstCtx.cr4 & X86_CR4_VME))
    579568            return iemRaiseGeneralProtectionFault0(pVCpu);
    580569        fEfl &= ~X86_EFL_IF;          /* (RF and VM are out of range) */
    … …  
    622611IEM_CIMPL_DEF_1(iemCImpl_popf, IEMMODE, enmEffOpSize)
    623612{
    624     PCPUMCTX        pCtx    = IEM_GET_CTX(pVCpu);
    625     uint32_t const  fEflOld = IEMMISC_GET_EFL(pVCpu, pCtx);
     613    uint32_t const  fEflOld = IEMMISC_GET_EFL(pVCpu);
    626614    VBOXSTRICTRC    rcStrict;
    627615    uint32_t        fEflNew;
    … …  
    672660         */
    673661        else if (   enmEffOpSize == IEMMODE_16BIT
    674                  && (pCtx->cr4 & X86_CR4_VME) )
     662                 && (pVCpu->cpum.GstCtx.cr4 & X86_CR4_VME) )
    675663        {
    676664            uint16_t    u16Value;
    677665            RTUINT64U   TmpRsp;
    678             TmpRsp.u = pCtx->rsp;
     666            TmpRsp.u = pVCpu->cpum.GstCtx.rsp;
    679667            rcStrict = iemMemStackPopU16Ex(pVCpu, &u16Value, &TmpRsp);
    680668            if (rcStrict != VINF_SUCCESS)
    … …  
    693681            fEflNew |= ~(X86_EFL_POPF_BITS & ~(X86_EFL_IOPL | X86_EFL_IF)) & fEflOld;
    694682
    695             pCtx->rsp = TmpRsp.u;
     683            pVCpu->cpum.GstCtx.rsp = TmpRsp.u;
    696684        }
    697685        else
    … …  
    727715                 */
    728716                if (   IEM_GET_TARGET_CPU(pVCpu) == IEMTARGETCPU_286
    729                     && !(pCtx->cr0 & X86_CR0_PE) )
     717                    && !(pVCpu->cpum.GstCtx.cr0 & X86_CR0_PE) )
    730718                    fEflNew &= ~(X86_EFL_NT | X86_EFL_IOPL);
    731719                break;
    … …  
    773761     */
    774762    Assert(fEflNew & RT_BIT_32(1));
    775     IEMMISC_SET_EFL(pVCpu, pCtx, fEflNew);
     763    IEMMISC_SET_EFL(pVCpu, fEflNew);
    776764    iemRegAddToRipAndClearRF(pVCpu, cbInstr);
    777765
    … …  
    789777IEM_CIMPL_DEF_1(iemCImpl_call_16, uint16_t, uNewPC)
    790778{
    791     PCPUMCTX pCtx   = IEM_GET_CTX(pVCpu);
    792     uint16_t uOldPC = pCtx->ip + cbInstr;
    793     if (uNewPC > pCtx->cs.u32Limit)
     779    uint16_t uOldPC = pVCpu->cpum.GstCtx.ip + cbInstr;
     780    if (uNewPC > pVCpu->cpum.GstCtx.cs.u32Limit)
    794781        return iemRaiseGeneralProtectionFault0(pVCpu);
    795782
    … …  
    798785        return rcStrict;
    799786
    800     pCtx->rip = uNewPC;
    801     pCtx->eflags.Bits.u1RF = 0;
     787    pVCpu->cpum.GstCtx.rip = uNewPC;
     788    pVCpu->cpum.GstCtx.eflags.Bits.u1RF = 0;
    802789
    803790#ifndef IEM_WITH_CODE_TLB
    … …  
    816803IEM_CIMPL_DEF_1(iemCImpl_call_rel_16, int16_t, offDisp)
    817804{
    818     PCPUMCTX pCtx   = IEM_GET_CTX(pVCpu);
    819     uint16_t uOldPC = pCtx->ip + cbInstr;
     805    uint16_t uOldPC = pVCpu->cpum.GstCtx.ip + cbInstr;
    820806    uint16_t uNewPC = uOldPC + offDisp;
    821     if (uNewPC > pCtx->cs.u32Limit)
     807    if (uNewPC > pVCpu->cpum.GstCtx.cs.u32Limit)
    822808        return iemRaiseGeneralProtectionFault0(pVCpu);
    823809
    … …  
    826812        return rcStrict;
    827813
    828     pCtx->rip = uNewPC;
    829     pCtx->eflags.Bits.u1RF = 0;
     814    pVCpu->cpum.GstCtx.rip = uNewPC;
     815    pVCpu->cpum.GstCtx.eflags.Bits.u1RF = 0;
    830816
    831817#ifndef IEM_WITH_CODE_TLB
    … …  
    846832IEM_CIMPL_DEF_1(iemCImpl_call_32, uint32_t, uNewPC)
    847833{
    848     PCPUMCTX pCtx   = IEM_GET_CTX(pVCpu);
    849     uint32_t uOldPC = pCtx->eip + cbInstr;
    850     if (uNewPC > pCtx->cs.u32Limit)
     834    uint32_t uOldPC = pVCpu->cpum.GstCtx.eip + cbInstr;
     835    if (uNewPC > pVCpu->cpum.GstCtx.cs.u32Limit)
    851836        return iemRaiseGeneralProtectionFault0(pVCpu);
    852837
    … …  
    859844     * CASM hook for recording interesting indirect calls.
    860845     */
    861     if (   !pCtx->eflags.Bits.u1IF
    862         && (pCtx->cr0 & X86_CR0_PG)
     846    if (   !pVCpu->cpum.GstCtx.eflags.Bits.u1IF
     847        && (pVCpu->cpum.GstCtx.cr0 & X86_CR0_PG)
    863848        && !CSAMIsEnabled(pVCpu->CTX_SUFF(pVM))
    864849        && pVCpu->iem.s.uCpl == 0)
    … …  
    868853            || enmState == EMSTATE_IEM
    869854            || enmState == EMSTATE_REM)
    870             CSAMR3RecordCallAddress(pVCpu->CTX_SUFF(pVM), pCtx->eip);
     855            CSAMR3RecordCallAddress(pVCpu->CTX_SUFF(pVM), pVCpu->cpum.GstCtx.eip);
    871856    }
    872857#endif
    873858
    874     pCtx->rip = uNewPC;
    875     pCtx->eflags.Bits.u1RF = 0;
     859    pVCpu->cpum.GstCtx.rip = uNewPC;
     860    pVCpu->cpum.GstCtx.eflags.Bits.u1RF = 0;
    876861
    877862#ifndef IEM_WITH_CODE_TLB
    … …  
    890875IEM_CIMPL_DEF_1(iemCImpl_call_rel_32, int32_t, offDisp)
    891876{
    892     PCPUMCTX pCtx   = IEM_GET_CTX(pVCpu);
    893     uint32_t uOldPC = pCtx->eip + cbInstr;
     877    uint32_t uOldPC = pVCpu->cpum.GstCtx.eip + cbInstr;
    894878    uint32_t uNewPC = uOldPC + offDisp;
    895     if (uNewPC > pCtx->cs.u32Limit)
     879    if (uNewPC > pVCpu->cpum.GstCtx.cs.u32Limit)
    896880        return iemRaiseGeneralProtectionFault0(pVCpu);
    897881
    … …  
    900884        return rcStrict;
    901885
    902     pCtx->rip = uNewPC;
    903     pCtx->eflags.Bits.u1RF = 0;
     886    pVCpu->cpum.GstCtx.rip = uNewPC;
     887    pVCpu->cpum.GstCtx.eflags.Bits.u1RF = 0;
    904888
    905889#ifndef IEM_WITH_CODE_TLB
    … …  
    920904IEM_CIMPL_DEF_1(iemCImpl_call_64, uint64_t, uNewPC)
    921905{
    922     PCPUMCTX pCtx   = IEM_GET_CTX(pVCpu);
    923     uint64_t uOldPC = pCtx->rip + cbInstr;
     906    uint64_t uOldPC = pVCpu->cpum.GstCtx.rip + cbInstr;
    924907    if (!IEM_IS_CANONICAL(uNewPC))
    925908        return iemRaiseGeneralProtectionFault0(pVCpu);
    … …  
    929912        return rcStrict;
    930913
    931     pCtx->rip = uNewPC;
    932     pCtx->eflags.Bits.u1RF = 0;
     914    pVCpu->cpum.GstCtx.rip = uNewPC;
     915    pVCpu->cpum.GstCtx.eflags.Bits.u1RF = 0;
    933916
    934917#ifndef IEM_WITH_CODE_TLB
    … …  
    947930IEM_CIMPL_DEF_1(iemCImpl_call_rel_64, int64_t, offDisp)
    948931{
    949     PCPUMCTX pCtx   = IEM_GET_CTX(pVCpu);
    950     uint64_t uOldPC = pCtx->rip + cbInstr;
     932    uint64_t uOldPC = pVCpu->cpum.GstCtx.rip + cbInstr;
    951933    uint64_t uNewPC = uOldPC + offDisp;
    952934    if (!IEM_IS_CANONICAL(uNewPC))
    … …  
    957939        return rcStrict;
    958940
    959     pCtx->rip = uNewPC;
    960     pCtx->eflags.Bits.u1RF = 0;
     941    pVCpu->cpum.GstCtx.rip = uNewPC;
     942    pVCpu->cpum.GstCtx.eflags.Bits.u1RF = 0;
    961943
    962944#ifndef IEM_WITH_CODE_TLB
    … …  
    987969           || pDesc->Legacy.Gate.u4Type == X86_SEL_TYPE_SYS_386_TSS_AVAIL);
    988970    RT_NOREF_PV(enmEffOpSize);
    989     PCPUMCTX pCtx = IEM_GET_CTX(pVCpu);
    990     IEM_CTX_ASSERT(pCtx, IEM_CPUMCTX_EXTRN_XCPT_MASK);
     971    IEM_CTX_ASSERT(pVCpu, IEM_CPUMCTX_EXTRN_XCPT_MASK);
    991972
    992973    if (   pDesc->Legacy.Gate.u2Dpl < pVCpu->iem.s.uCpl
    … …  
    1007988    }
    1008989
    1009     uint32_t uNextEip = pCtx->eip + cbInstr;
    1010     return iemTaskSwitch(pVCpu, pCtx, enmBranch == IEMBRANCH_JUMP ? IEMTASKSWITCH_JUMP : IEMTASKSWITCH_CALL,
     990    uint32_t uNextEip = pVCpu->cpum.GstCtx.eip + cbInstr;
     991    return iemTaskSwitch(pVCpu, enmBranch == IEMBRANCH_JUMP ? IEMTASKSWITCH_JUMP : IEMTASKSWITCH_CALL,
    1011992                         uNextEip, 0 /* fFlags */, 0 /* uErr */, 0 /* uCr2 */, uSel, pDesc);
    1012993#endif
    … …  
    10301011    Assert(enmBranch == IEMBRANCH_JUMP || enmBranch == IEMBRANCH_CALL);
    10311012    RT_NOREF_PV(enmEffOpSize);
    1032     PCPUMCTX pCtx = IEM_GET_CTX(pVCpu);
    1033     IEM_CTX_ASSERT(pCtx, IEM_CPUMCTX_EXTRN_XCPT_MASK);
     1013    IEM_CTX_ASSERT(pVCpu, IEM_CPUMCTX_EXTRN_XCPT_MASK);
    10341014
    10351015    if (   pDesc->Legacy.Gate.u2Dpl < pVCpu->iem.s.uCpl
    … …  
    10781058    }
    10791059
    1080     uint32_t uNextEip = pCtx->eip + cbInstr;
    1081     return iemTaskSwitch(pVCpu, pCtx, enmBranch == IEMBRANCH_JUMP ? IEMTASKSWITCH_JUMP : IEMTASKSWITCH_CALL,
     1060    uint32_t uNextEip = pVCpu->cpum.GstCtx.eip + cbInstr;
     1061    return iemTaskSwitch(pVCpu, enmBranch == IEMBRANCH_JUMP ? IEMTASKSWITCH_JUMP : IEMTASKSWITCH_CALL,
    10821062                         uNextEip, 0 /* fFlags */, 0 /* uErr */, 0 /* uCr2 */, uSelTss, &TssDesc);
    10831063#endif
    … …  
    11011081#else
    11021082    RT_NOREF_PV(enmEffOpSize);
    1103     PCPUMCTX pCtx = IEM_GET_CTX(pVCpu);
    1104     IEM_CTX_ASSERT(pCtx, IEM_CPUMCTX_EXTRN_XCPT_MASK);
     1083    IEM_CTX_ASSERT(pVCpu, IEM_CPUMCTX_EXTRN_XCPT_MASK);
    11051084
    11061085    /* NB: Far jumps can only do intra-privilege transfers. Far calls support
    … …  
    12671246
    12681247        /* commit */
    1269         pCtx->rip         = uNewRip;
    1270         pCtx->cs.Sel      = uNewCS & X86_SEL_MASK_OFF_RPL;
    1271         pCtx->cs.Sel     |= pVCpu->iem.s.uCpl; /** @todo is this right for conforming segs? or in general? */
    1272         pCtx->cs.ValidSel = pCtx->cs.Sel;
    1273         pCtx->cs.fFlags   = CPUMSELREG_FLAGS_VALID;
    1274         pCtx->cs.Attr.u   = X86DESC_GET_HID_ATTR(&DescCS.Legacy);
    1275         pCtx->cs.u32Limit = cbLimit;
    1276         pCtx->cs.u64Base  = u64Base;
    1277         pVCpu->iem.s.enmCpuMode = iemCalcCpuMode(pCtx);
     1248        pVCpu->cpum.GstCtx.rip         = uNewRip;
     1249        pVCpu->cpum.GstCtx.cs.Sel      = uNewCS & X86_SEL_MASK_OFF_RPL;
     1250        pVCpu->cpum.GstCtx.cs.Sel     |= pVCpu->iem.s.uCpl; /** @todo is this right for conforming segs? or in general? */
     1251        pVCpu->cpum.GstCtx.cs.ValidSel = pVCpu->cpum.GstCtx.cs.Sel;
     1252        pVCpu->cpum.GstCtx.cs.fFlags   = CPUMSELREG_FLAGS_VALID;
     1253        pVCpu->cpum.GstCtx.cs.Attr.u   = X86DESC_GET_HID_ATTR(&DescCS.Legacy);
     1254        pVCpu->cpum.GstCtx.cs.u32Limit = cbLimit;
     1255        pVCpu->cpum.GstCtx.cs.u64Base  = u64Base;
     1256        pVCpu->iem.s.enmCpuMode = iemCalcCpuMode(pVCpu);
    12781257    }
    12791258    else
    … …  
    13031282             * Determine new SS:rSP from the TSS.
    13041283             */
    1305             Assert(!pCtx->tr.Attr.n.u1DescType);
     1284            Assert(!pVCpu->cpum.GstCtx.tr.Attr.n.u1DescType);
    13061285
    13071286            /* Figure out where the new stack pointer is stored in the TSS. */
    … …  
    13091288            if (!IEM_IS_LONG_MODE(pVCpu))
    13101289            {
    1311                 if (pCtx->tr.Attr.n.u4Type == X86_SEL_TYPE_SYS_386_TSS_BUSY)
     1290                if (pVCpu->cpum.GstCtx.tr.Attr.n.u4Type == X86_SEL_TYPE_SYS_386_TSS_BUSY)
    13121291                {
    13131292                    offNewStack = RT_OFFSETOF(X86TSS32, esp0) + uNewCSDpl * 8;
    … …  
    13161295                else
    13171296                {
    1318                     Assert(pCtx->tr.Attr.n.u4Type == X86_SEL_TYPE_SYS_286_TSS_BUSY);
     1297                    Assert(pVCpu->cpum.GstCtx.tr.Attr.n.u4Type == X86_SEL_TYPE_SYS_286_TSS_BUSY);
    13191298                    offNewStack = RT_OFFSETOF(X86TSS16, sp0) + uNewCSDpl * 4;
    13201299                    cbNewStack  = RT_SIZEOFMEMB(X86TSS16, sp0) + RT_SIZEOFMEMB(X86TSS16, ss0);
    … …  
    13231302            else
    13241303            {
    1325                 Assert(pCtx->tr.Attr.n.u4Type == AMD64_SEL_TYPE_SYS_TSS_BUSY);
     1304                Assert(pVCpu->cpum.GstCtx.tr.Attr.n.u4Type == AMD64_SEL_TYPE_SYS_TSS_BUSY);
    13261305                offNewStack = RT_OFFSETOF(X86TSS64, rsp0) + uNewCSDpl * RT_SIZEOFMEMB(X86TSS64, rsp0);
    13271306                cbNewStack  = RT_SIZEOFMEMB(X86TSS64, rsp0);
    … …  
    13291308
    13301309            /* Check against TSS limit. */
    1331             if ((uint16_t)(offNewStack + cbNewStack - 1) > pCtx->tr.u32Limit)
    1332             {
    1333                 Log(("BranchCallGate inner stack past TSS limit - %u > %u -> #TS(TSS)\n", offNewStack + cbNewStack - 1, pCtx->tr.u32Limit));
    1334                 return iemRaiseTaskSwitchFaultBySelector(pVCpu, pCtx->tr.Sel);
    1335             }
    1336 
    1337             GCPtrTSS = pCtx->tr.u64Base + offNewStack;
     1310            if ((uint16_t)(offNewStack + cbNewStack - 1) > pVCpu->cpum.GstCtx.tr.u32Limit)
     1311            {
     1312                Log(("BranchCallGate inner stack past TSS limit - %u > %u -> #TS(TSS)\n", offNewStack + cbNewStack - 1, pVCpu->cpum.GstCtx.tr.u32Limit));
     1313                return iemRaiseTaskSwitchFaultBySelector(pVCpu, pVCpu->cpum.GstCtx.tr.Sel);
     1314            }
     1315
     1316            GCPtrTSS = pVCpu->cpum.GstCtx.tr.u64Base + offNewStack;
    13381317            rcStrict = iemMemMap(pVCpu, &uPtrTSS.pv, cbNewStack, UINT8_MAX, GCPtrTSS, IEM_ACCESS_SYS_R);
    13391318            if (rcStrict != VINF_SUCCESS)
    … …  
    13451324            if (!IEM_IS_LONG_MODE(pVCpu))
    13461325            {
    1347                 if (pCtx->tr.Attr.n.u4Type == X86_SEL_TYPE_SYS_386_TSS_BUSY)
     1326                if (pVCpu->cpum.GstCtx.tr.Attr.n.u4Type == X86_SEL_TYPE_SYS_386_TSS_BUSY)
    13481327                {
    13491328                    uNewRsp = uPtrTSS.pu32[0];
    … …  
    13521331                else
    13531332                {
    1354                     Assert(pCtx->tr.Attr.n.u4Type == X86_SEL_TYPE_SYS_286_TSS_BUSY);
     1333                    Assert(pVCpu->cpum.GstCtx.tr.Attr.n.u4Type == X86_SEL_TYPE_SYS_286_TSS_BUSY);
    13551334                    uNewRsp = uPtrTSS.pu16[0];
    13561335                    uNewSS  = uPtrTSS.pu16[1];
    … …  
    13591338            else
    13601339            {
    1361                 Assert(pCtx->tr.Attr.n.u4Type == AMD64_SEL_TYPE_SYS_TSS_BUSY);
     1340                Assert(pVCpu->cpum.GstCtx.tr.Attr.n.u4Type == AMD64_SEL_TYPE_SYS_TSS_BUSY);
    13621341                /* SS will be a NULL selector, but that's valid. */
    13631342                uNewRsp = uPtrTSS.pu64[0];
    … …  
    14531432
    14541433            /* Remember the old SS:rSP and their linear address. */
    1455             uOldSS  = pCtx->ss.Sel;
    1456             uOldRsp = pCtx->ss.Attr.n.u1DefBig ? pCtx->rsp : pCtx->sp;
    1457 
    1458             GCPtrParmWds = pCtx->ss.u64Base + uOldRsp;
     1434            uOldSS  = pVCpu->cpum.GstCtx.ss.Sel;
     1435            uOldRsp = pVCpu->cpum.GstCtx.ss.Attr.n.u1DefBig ? pVCpu->cpum.GstCtx.rsp : pVCpu->cpum.GstCtx.sp;
     1436
     1437            GCPtrParmWds = pVCpu->cpum.GstCtx.ss.u64Base + uOldRsp;
    14591438
    14601439            /* HACK ALERT! Probe if the write to the new stack will succeed. May #SS(NewSS)
    … …  
    14791458
    14801459            /* Commit new SS:rSP. */
    1481             pCtx->ss.Sel      = uNewSS;
    1482             pCtx->ss.ValidSel = uNewSS;
    1483             pCtx->ss.Attr.u   = X86DESC_GET_HID_ATTR(&DescSS.Legacy);
    1484             pCtx->ss.u32Limit = X86DESC_LIMIT_G(&DescSS.Legacy);
    1485             pCtx->ss.u64Base  = X86DESC_BASE(&DescSS.Legacy);
    1486             pCtx->ss.fFlags   = CPUMSELREG_FLAGS_VALID;
    1487             pCtx->rsp         = uNewRsp;
     1460            pVCpu->cpum.GstCtx.ss.Sel      = uNewSS;
     1461            pVCpu->cpum.GstCtx.ss.ValidSel = uNewSS;
     1462            pVCpu->cpum.GstCtx.ss.Attr.u   = X86DESC_GET_HID_ATTR(&DescSS.Legacy);
     1463            pVCpu->cpum.GstCtx.ss.u32Limit = X86DESC_LIMIT_G(&DescSS.Legacy);
     1464            pVCpu->cpum.GstCtx.ss.u64Base  = X86DESC_BASE(&DescSS.Legacy);
     1465            pVCpu->cpum.GstCtx.ss.fFlags   = CPUMSELREG_FLAGS_VALID;
     1466            pVCpu->cpum.GstCtx.rsp         = uNewRsp;
    14881467            pVCpu->iem.s.uCpl = uNewCSDpl;
    1489             Assert(CPUMSELREG_ARE_HIDDEN_PARTS_VALID(pVCpu, &pCtx->ss));
     1468            Assert(CPUMSELREG_ARE_HIDDEN_PARTS_VALID(pVCpu, &pVCpu->cpum.GstCtx.ss));
    14901469            CPUMSetChangedFlags(pVCpu, CPUM_CHANGED_HIDDEN_SEL_REGS);
    14911470
    … …  
    15021481                {
    15031482                    /* Push the old CS:rIP. */
    1504                     uPtrRet.pu32[0] = pCtx->eip + cbInstr;
    1505                     uPtrRet.pu32[1] = pCtx->cs.Sel; /** @todo Testcase: What is written to the high word when pushing CS? */
     1483                    uPtrRet.pu32[0] = pVCpu->cpum.GstCtx.eip + cbInstr;
     1484                    uPtrRet.pu32[1] = pVCpu->cpum.GstCtx.cs.Sel; /** @todo Testcase: What is written to the high word when pushing CS? */
    15061485
    15071486                    if (cbWords)
    … …  
    15371516
    15381517                    /* Push the old CS:rIP. */
    1539                     uPtrRet.pu16[0] = pCtx->ip + cbInstr;
    1540                     uPtrRet.pu16[1] = pCtx->cs.Sel;
     1518                    uPtrRet.pu16[0] = pVCpu->cpum.GstCtx.ip + cbInstr;
     1519                    uPtrRet.pu16[1] = pVCpu->cpum.GstCtx.cs.Sel;
    15411520
    15421521                    if (cbWords)
    … …  
    15731552
    15741553                /* For 64-bit gates, no parameters are copied. Just push old SS:rSP and CS:rIP. */
    1575                 uPtrRet.pu64[0] = pCtx->rip + cbInstr;
    1576                 uPtrRet.pu64[1] = pCtx->cs.Sel; /** @todo Testcase: What is written to the high words when pushing CS? */
     1554                uPtrRet.pu64[0] = pVCpu->cpum.GstCtx.rip + cbInstr;
     1555                uPtrRet.pu64[1] = pVCpu->cpum.GstCtx.cs.Sel; /** @todo Testcase: What is written to the high words when pushing CS? */
    15771556                uPtrRet.pu64[2] = uOldRsp;
    15781557                uPtrRet.pu64[3] = uOldSS;       /** @todo Testcase: What is written to the high words when pushing SS? */
    … …  
    16281607
    16291608            /* Commit new CS:rIP. */
    1630             pCtx->rip         = uNewRip;
    1631             pCtx->cs.Sel      = uNewCS & X86_SEL_MASK_OFF_RPL;
    1632             pCtx->cs.Sel     |= pVCpu->iem.s.uCpl;
    1633             pCtx->cs.ValidSel = pCtx->cs.Sel;
    1634             pCtx->cs.fFlags   = CPUMSELREG_FLAGS_VALID;
    1635             pCtx->cs.Attr.u   = X86DESC_GET_HID_ATTR(&DescCS.Legacy);
    1636             pCtx->cs.u32Limit = cbLimit;
    1637             pCtx->cs.u64Base  = u64Base;
    1638             pVCpu->iem.s.enmCpuMode = iemCalcCpuMode(pCtx);
     1609            pVCpu->cpum.GstCtx.rip         = uNewRip;
     1610            pVCpu->cpum.GstCtx.cs.Sel      = uNewCS & X86_SEL_MASK_OFF_RPL;
     1611            pVCpu->cpum.GstCtx.cs.Sel     |= pVCpu->iem.s.uCpl;
     1612            pVCpu->cpum.GstCtx.cs.ValidSel = pVCpu->cpum.GstCtx.cs.Sel;
     1613            pVCpu->cpum.GstCtx.cs.fFlags   = CPUMSELREG_FLAGS_VALID;
     1614            pVCpu->cpum.GstCtx.cs.Attr.u   = X86DESC_GET_HID_ATTR(&DescCS.Legacy);
     1615            pVCpu->cpum.GstCtx.cs.u32Limit = cbLimit;
     1616            pVCpu->cpum.GstCtx.cs.u64Base  = u64Base;
     1617            pVCpu->iem.s.enmCpuMode = iemCalcCpuMode(pVCpu);
    16391618        }
    16401619        else
    … …  
    16981677                if (pDesc->Legacy.Gate.u4Type == X86_SEL_TYPE_SYS_386_CALL_GATE)
    16991678                {
    1700                     uPtrRet.pu32[0] = pCtx->eip + cbInstr;
    1701                     uPtrRet.pu32[1] = pCtx->cs.Sel; /** @todo Testcase: What is written to the high word when pushing CS? */
     1679                    uPtrRet.pu32[0] = pVCpu->cpum.GstCtx.eip + cbInstr;
     1680                    uPtrRet.pu32[1] = pVCpu->cpum.GstCtx.cs.Sel; /** @todo Testcase: What is written to the high word when pushing CS? */
    17021681                }
    17031682                else
    17041683                {
    17051684                    Assert(pDesc->Legacy.Gate.u4Type == X86_SEL_TYPE_SYS_286_CALL_GATE);
    1706                     uPtrRet.pu16[0] = pCtx->ip + cbInstr;
    1707                     uPtrRet.pu16[1] = pCtx->cs.Sel;
     1685                    uPtrRet.pu16[0] = pVCpu->cpum.GstCtx.ip + cbInstr;
     1686                    uPtrRet.pu16[1] = pVCpu->cpum.GstCtx.cs.Sel;
    17081687                }
    17091688            }
    … …  
    17111690            {
    17121691                Assert(pDesc->Legacy.Gate.u4Type == AMD64_SEL_TYPE_SYS_CALL_GATE);
    1713                 uPtrRet.pu64[0] = pCtx->rip + cbInstr;
    1714                 uPtrRet.pu64[1] = pCtx->cs.Sel; /** @todo Testcase: What is written to the high words when pushing CS? */
     1692                uPtrRet.pu64[0] = pVCpu->cpum.GstCtx.rip + cbInstr;
     1693                uPtrRet.pu64[1] = pVCpu->cpum.GstCtx.cs.Sel; /** @todo Testcase: What is written to the high words when pushing CS? */
    17151694            }
    17161695
    … …  
    17201699
    17211700            /* commit */
    1722             pCtx->rip         = uNewRip;
    1723             pCtx->cs.Sel      = uNewCS & X86_SEL_MASK_OFF_RPL;
    1724             pCtx->cs.Sel     |= pVCpu->iem.s.uCpl;
    1725             pCtx->cs.ValidSel = pCtx->cs.Sel;
    1726             pCtx->cs.fFlags   = CPUMSELREG_FLAGS_VALID;
    1727             pCtx->cs.Attr.u   = X86DESC_GET_HID_ATTR(&DescCS.Legacy);
    1728             pCtx->cs.u32Limit = cbLimit;
    1729             pCtx->cs.u64Base  = u64Base;
    1730             pVCpu->iem.s.enmCpuMode  = iemCalcCpuMode(pCtx);
    1731         }
    1732     }
    1733     pCtx->eflags.Bits.u1RF = 0;
     1701            pVCpu->cpum.GstCtx.rip         = uNewRip;
     1702            pVCpu->cpum.GstCtx.cs.Sel      = uNewCS & X86_SEL_MASK_OFF_RPL;
     1703            pVCpu->cpum.GstCtx.cs.Sel     |= pVCpu->iem.s.uCpl;
     1704            pVCpu->cpum.GstCtx.cs.ValidSel = pVCpu->cpum.GstCtx.cs.Sel;
     1705            pVCpu->cpum.GstCtx.cs.fFlags   = CPUMSELREG_FLAGS_VALID;
     1706            pVCpu->cpum.GstCtx.cs.Attr.u   = X86DESC_GET_HID_ATTR(&DescCS.Legacy);
     1707            pVCpu->cpum.GstCtx.cs.u32Limit = cbLimit;
     1708            pVCpu->cpum.GstCtx.cs.u64Base  = u64Base;
     1709            pVCpu->iem.s.enmCpuMode  = iemCalcCpuMode(pVCpu);
     1710        }
     1711    }
     1712    pVCpu->cpum.GstCtx.eflags.Bits.u1RF = 0;
    17341713
    17351714    /* Flush the prefetch buffer. */
    … …  
    17561735    Assert(enmBranch == IEMBRANCH_JUMP || enmBranch == IEMBRANCH_CALL);
    17571736    Assert((uSel & X86_SEL_MASK_OFF_RPL));
    1758     IEM_CTX_IMPORT_RET(pVCpu, IEM_GET_CTX(pVCpu), IEM_CPUMCTX_EXTRN_XCPT_MASK);
     1737    IEM_CTX_IMPORT_RET(pVCpu, IEM_CPUMCTX_EXTRN_XCPT_MASK);
    17591738
    17601739    if (IEM_IS_LONG_MODE(pVCpu))
    … …  
    18161795IEM_CIMPL_DEF_3(iemCImpl_FarJmp, uint16_t, uSel, uint64_t, offSeg, IEMMODE, enmEffOpSize)
    18171796{
    1818     PCPUMCTX pCtx = IEM_GET_CTX(pVCpu);
    18191797    NOREF(cbInstr);
    18201798    Assert(offSeg <= UINT32_MAX);
    … …  
    18351813    {
    18361814        Assert(enmEffOpSize == IEMMODE_16BIT || enmEffOpSize == IEMMODE_32BIT);
    1837         if (offSeg > pCtx->cs.u32Limit)
     1815        if (offSeg > pVCpu->cpum.GstCtx.cs.u32Limit)
    18381816        {
    18391817            Log(("iemCImpl_FarJmp: 16-bit limit\n"));
    … …  
    18421820
    18431821        if (enmEffOpSize == IEMMODE_16BIT) /** @todo WRONG, must pass this. */
    1844             pCtx->rip       = offSeg;
     1822            pVCpu->cpum.GstCtx.rip       = offSeg;
    18451823        else
    1846             pCtx->rip       = offSeg & UINT16_MAX;
    1847         pCtx->cs.Sel        = uSel;
    1848         pCtx->cs.ValidSel   = uSel;
    1849         pCtx->cs.fFlags     = CPUMSELREG_FLAGS_VALID;
    1850         pCtx->cs.u64Base    = (uint32_t)uSel << 4;
    1851         pCtx->eflags.Bits.u1RF = 0;
     1824            pVCpu->cpum.GstCtx.rip       = offSeg & UINT16_MAX;
     1825        pVCpu->cpum.GstCtx.cs.Sel        = uSel;
     1826        pVCpu->cpum.GstCtx.cs.ValidSel   = uSel;
     1827        pVCpu->cpum.GstCtx.cs.fFlags     = CPUMSELREG_FLAGS_VALID;
     1828        pVCpu->cpum.GstCtx.cs.u64Base    = (uint32_t)uSel << 4;
     1829        pVCpu->cpum.GstCtx.eflags.Bits.u1RF = 0;
    18521830        return VINF_SUCCESS;
    18531831    }
    … …  
    19571935
    19581936    /* commit */
    1959     pCtx->rip = offSeg;
    1960     pCtx->cs.Sel         = uSel & X86_SEL_MASK_OFF_RPL;
    1961     pCtx->cs.Sel        |= pVCpu->iem.s.uCpl; /** @todo is this right for conforming segs? or in general? */
    1962     pCtx->cs.ValidSel    = pCtx->cs.Sel;
    1963     pCtx->cs.fFlags      = CPUMSELREG_FLAGS_VALID;
    1964     pCtx->cs.Attr.u      = X86DESC_GET_HID_ATTR(&Desc.Legacy);
    1965     pCtx->cs.u32Limit    = cbLimit;
    1966     pCtx->cs.u64Base     = u64Base;
    1967     pVCpu->iem.s.enmCpuMode  = iemCalcCpuMode(pCtx);
    1968     pCtx->eflags.Bits.u1RF = 0;
     1937    pVCpu->cpum.GstCtx.rip = offSeg;
     1938    pVCpu->cpum.GstCtx.cs.Sel         = uSel & X86_SEL_MASK_OFF_RPL;
     1939    pVCpu->cpum.GstCtx.cs.Sel        |= pVCpu->iem.s.uCpl; /** @todo is this right for conforming segs? or in general? */
     1940    pVCpu->cpum.GstCtx.cs.ValidSel    = pVCpu->cpum.GstCtx.cs.Sel;
     1941    pVCpu->cpum.GstCtx.cs.fFlags      = CPUMSELREG_FLAGS_VALID;
     1942    pVCpu->cpum.GstCtx.cs.Attr.u      = X86DESC_GET_HID_ATTR(&Desc.Legacy);
     1943    pVCpu->cpum.GstCtx.cs.u32Limit    = cbLimit;
     1944    pVCpu->cpum.GstCtx.cs.u64Base     = u64Base;
     1945    pVCpu->iem.s.enmCpuMode  = iemCalcCpuMode(pVCpu);
     1946    pVCpu->cpum.GstCtx.eflags.Bits.u1RF = 0;
    19691947    /** @todo check if the hidden bits are loaded correctly for 64-bit
    19701948     *        mode.  */
    … …  
    19921970IEM_CIMPL_DEF_3(iemCImpl_callf, uint16_t, uSel, uint64_t, offSeg, IEMMODE, enmEffOpSize)
    19931971{
    1994     PCPUMCTX        pCtx = IEM_GET_CTX(pVCpu);
    19951972    VBOXSTRICTRC    rcStrict;
    19961973    uint64_t        uNewRsp;
    … …  
    20201997        if (enmEffOpSize == IEMMODE_16BIT)
    20211998        {
    2022             uPtrRet.pu16[0] = pCtx->ip + cbInstr;
    2023             uPtrRet.pu16[1] = pCtx->cs.Sel;
     1999            uPtrRet.pu16[0] = pVCpu->cpum.GstCtx.ip + cbInstr;
     2000            uPtrRet.pu16[1] = pVCpu->cpum.GstCtx.cs.Sel;
    20242001        }
    20252002        else
    20262003        {
    2027             uPtrRet.pu32[0] = pCtx->eip + cbInstr;
    2028             uPtrRet.pu16[2] = pCtx->cs.Sel;
     2004            uPtrRet.pu32[0] = pVCpu->cpum.GstCtx.eip + cbInstr;
     2005            uPtrRet.pu16[2] = pVCpu->cpum.GstCtx.cs.Sel;
    20292006        }
    20302007        rcStrict = iemMemStackPushCommitSpecial(pVCpu, uPtrRet.pv, uNewRsp);
    … …  
    20332010
    20342011        /* Branch. */
    2035         pCtx->rip           = offSeg;
    2036         pCtx->cs.Sel        = uSel;
    2037         pCtx->cs.ValidSel   = uSel;
    2038         pCtx->cs.fFlags     = CPUMSELREG_FLAGS_VALID;
    2039         pCtx->cs.u64Base    = (uint32_t)uSel << 4;
    2040         pCtx->eflags.Bits.u1RF = 0;
     2012        pVCpu->cpum.GstCtx.rip           = offSeg;
     2013        pVCpu->cpum.GstCtx.cs.Sel        = uSel;
     2014        pVCpu->cpum.GstCtx.cs.ValidSel   = uSel;
     2015        pVCpu->cpum.GstCtx.cs.fFlags     = CPUMSELREG_FLAGS_VALID;
     2016        pVCpu->cpum.GstCtx.cs.u64Base    = (uint32_t)uSel << 4;
     2017        pVCpu->cpum.GstCtx.eflags.Bits.u1RF = 0;
    20412018        return VINF_SUCCESS;
    20422019    }
    … …  
    21662143    if (enmEffOpSize == IEMMODE_16BIT)
    21672144    {
    2168         uPtrRet.pu16[0] = pCtx->ip + cbInstr;
    2169         uPtrRet.pu16[1] = pCtx->cs.Sel;
     2145        uPtrRet.pu16[0] = pVCpu->cpum.GstCtx.ip + cbInstr;
     2146        uPtrRet.pu16[1] = pVCpu->cpum.GstCtx.cs.Sel;
    21702147    }
    21712148    else if (enmEffOpSize == IEMMODE_32BIT)
    21722149    {
    2173         uPtrRet.pu32[0] = pCtx->eip + cbInstr;
    2174         uPtrRet.pu32[1] = pCtx->cs.Sel; /** @todo Testcase: What is written to the high word when callf is pushing CS? */
     2150        uPtrRet.pu32[0] = pVCpu->cpum.GstCtx.eip + cbInstr;
     2151        uPtrRet.pu32[1] = pVCpu->cpum.GstCtx.cs.Sel; /** @todo Testcase: What is written to the high word when callf is pushing CS? */
    21752152    }
    21762153    else
    21772154    {
    2178         uPtrRet.pu64[0] = pCtx->rip + cbInstr;
    2179         uPtrRet.pu64[1] = pCtx->cs.Sel; /** @todo Testcase: What is written to the high words when callf is pushing CS? */
     2155        uPtrRet.pu64[0] = pVCpu->cpum.GstCtx.rip + cbInstr;
     2156        uPtrRet.pu64[1] = pVCpu->cpum.GstCtx.cs.Sel; /** @todo Testcase: What is written to the high words when callf is pushing CS? */
    21802157    }
    21812158    rcStrict = iemMemStackPushCommitSpecial(pVCpu, uPtrRet.pv, uNewRsp);
    … …  
    21842161
    21852162    /* commit */
    2186     pCtx->rip = offSeg;
    2187     pCtx->cs.Sel         = uSel & X86_SEL_MASK_OFF_RPL;
    2188     pCtx->cs.Sel        |= pVCpu->iem.s.uCpl;
    2189     pCtx->cs.ValidSel    = pCtx->cs.Sel;
    2190     pCtx->cs.fFlags      = CPUMSELREG_FLAGS_VALID;
    2191     pCtx->cs.Attr.u      = X86DESC_GET_HID_ATTR(&Desc.Legacy);
    2192     pCtx->cs.u32Limit    = cbLimit;
    2193     pCtx->cs.u64Base     = u64Base;
    2194     pVCpu->iem.s.enmCpuMode  = iemCalcCpuMode(pCtx);
    2195     pCtx->eflags.Bits.u1RF = 0;
     2163    pVCpu->cpum.GstCtx.rip = offSeg;
     2164    pVCpu->cpum.GstCtx.cs.Sel         = uSel & X86_SEL_MASK_OFF_RPL;
     2165    pVCpu->cpum.GstCtx.cs.Sel        |= pVCpu->iem.s.uCpl;
     2166    pVCpu->cpum.GstCtx.cs.ValidSel    = pVCpu->cpum.GstCtx.cs.Sel;
     2167    pVCpu->cpum.GstCtx.cs.fFlags      = CPUMSELREG_FLAGS_VALID;
     2168    pVCpu->cpum.GstCtx.cs.Attr.u      = X86DESC_GET_HID_ATTR(&Desc.Legacy);
     2169    pVCpu->cpum.GstCtx.cs.u32Limit    = cbLimit;
     2170    pVCpu->cpum.GstCtx.cs.u64Base     = u64Base;
     2171    pVCpu->iem.s.enmCpuMode  = iemCalcCpuMode(pVCpu);
     2172    pVCpu->cpum.GstCtx.eflags.Bits.u1RF = 0;
    21962173    /** @todo check if the hidden bits are loaded correctly for 64-bit
    21972174     *        mode.  */
    … …  
    22162193IEM_CIMPL_DEF_2(iemCImpl_retf, IEMMODE, enmEffOpSize, uint16_t, cbPop)
    22172194{
    2218     PCPUMCTX        pCtx = IEM_GET_CTX(pVCpu);
    22192195    VBOXSTRICTRC    rcStrict;
    22202196    RTCPTRUNION     uPtrFrame;
    … …  
    22652241        /** @todo Intel pseudo code only does the limit check for 16-bit
    22662242         *        operands, AMD does not make any distinction. What is right? */
    2267         if (uNewRip > pCtx->cs.u32Limit)
     2243        if (uNewRip > pVCpu->cpum.GstCtx.cs.u32Limit)
    22682244            return iemRaiseSelectorBounds(pVCpu, X86_SREG_CS, IEM_ACCESS_INSTRUCTION);
    22692245
    22702246        /* commit the operation. */
    2271         pCtx->rsp           = uNewRsp;
    2272         pCtx->rip           = uNewRip;
    2273         pCtx->cs.Sel        = uNewCs;
    2274         pCtx->cs.ValidSel   = uNewCs;
    2275         pCtx->cs.fFlags     = CPUMSELREG_FLAGS_VALID;
    2276         pCtx->cs.u64Base    = (uint32_t)uNewCs << 4;
    2277         pCtx->eflags.Bits.u1RF = 0;
     2247        pVCpu->cpum.GstCtx.rsp           = uNewRsp;
     2248        pVCpu->cpum.GstCtx.rip           = uNewRip;
     2249        pVCpu->cpum.GstCtx.cs.Sel        = uNewCs;
     2250        pVCpu->cpum.GstCtx.cs.ValidSel   = uNewCs;
     2251        pVCpu->cpum.GstCtx.cs.fFlags     = CPUMSELREG_FLAGS_VALID;
     2252        pVCpu->cpum.GstCtx.cs.u64Base    = (uint32_t)uNewCs << 4;
     2253        pVCpu->cpum.GstCtx.eflags.Bits.u1RF = 0;
    22782254        if (cbPop)
    2279             iemRegAddToRsp(pVCpu, pCtx, cbPop);
     2255            iemRegAddToRsp(pVCpu, cbPop);
    22802256        return VINF_SUCCESS;
    22812257    }
    … …  
    22902266    }
    22912267
    2292     IEM_CTX_IMPORT_RET(pVCpu, pCtx, CPUMCTX_EXTRN_SREG_MASK | CPUMCTX_EXTRN_GDTR | CPUMCTX_EXTRN_LDTR);
     2268    IEM_CTX_IMPORT_RET(pVCpu, CPUMCTX_EXTRN_SREG_MASK | CPUMCTX_EXTRN_GDTR | CPUMCTX_EXTRN_LDTR);
    22932269
    22942270    /* Fetch the descriptor. */
    … …  
    25062482        /* commit */
    25072483        if (enmEffOpSize == IEMMODE_16BIT)
    2508             pCtx->rip           = uNewRip & UINT16_MAX; /** @todo Testcase: When exactly does this occur? With call it happens prior to the limit check according to Intel... */
     2484            pVCpu->cpum.GstCtx.rip           = uNewRip & UINT16_MAX; /** @todo Testcase: When exactly does this occur? With call it happens prior to the limit check according to Intel... */
    25092485        else
    2510             pCtx->rip           = uNewRip;
    2511         pCtx->cs.Sel            = uNewCs;
    2512         pCtx->cs.ValidSel       = uNewCs;
    2513         pCtx->cs.fFlags         = CPUMSELREG_FLAGS_VALID;
    2514         pCtx->cs.Attr.u         = X86DESC_GET_HID_ATTR(&DescCs.Legacy);
    2515         pCtx->cs.u32Limit       = cbLimitCs;
    2516         pCtx->cs.u64Base        = u64Base;
    2517         pVCpu->iem.s.enmCpuMode     = iemCalcCpuMode(pCtx);
    2518         pCtx->ss.Sel            = uNewOuterSs;
    2519         pCtx->ss.ValidSel       = uNewOuterSs;
    2520         pCtx->ss.fFlags         = CPUMSELREG_FLAGS_VALID;
    2521         pCtx->ss.Attr.u         = X86DESC_GET_HID_ATTR(&DescSs.Legacy);
    2522         pCtx->ss.u32Limit       = cbLimitSs;
     2486            pVCpu->cpum.GstCtx.rip           = uNewRip;
     2487        pVCpu->cpum.GstCtx.cs.Sel            = uNewCs;
     2488        pVCpu->cpum.GstCtx.cs.ValidSel       = uNewCs;
     2489        pVCpu->cpum.GstCtx.cs.fFlags         = CPUMSELREG_FLAGS_VALID;
     2490        pVCpu->cpum.GstCtx.cs.Attr.u         = X86DESC_GET_HID_ATTR(&DescCs.Legacy);
     2491        pVCpu->cpum.GstCtx.cs.u32Limit       = cbLimitCs;
     2492        pVCpu->cpum.GstCtx.cs.u64Base        = u64Base;
     2493        pVCpu->iem.s.enmCpuMode     = iemCalcCpuMode(pVCpu);
     2494        pVCpu->cpum.GstCtx.ss.Sel            = uNewOuterSs;
     2495        pVCpu->cpum.GstCtx.ss.ValidSel       = uNewOuterSs;
     2496        pVCpu->cpum.GstCtx.ss.fFlags         = CPUMSELREG_FLAGS_VALID;
     2497        pVCpu->cpum.GstCtx.ss.Attr.u         = X86DESC_GET_HID_ATTR(&DescSs.Legacy);
     2498        pVCpu->cpum.GstCtx.ss.u32Limit       = cbLimitSs;
    25232499        if (pVCpu->iem.s.enmCpuMode == IEMMODE_64BIT)
    2524             pCtx->ss.u64Base    = 0;
     2500            pVCpu->cpum.GstCtx.ss.u64Base    = 0;
    25252501        else
    2526             pCtx->ss.u64Base    = X86DESC_BASE(&DescSs.Legacy);
    2527         if (!pCtx->ss.Attr.n.u1DefBig)
    2528             pCtx->sp            = (uint16_t)uNewOuterRsp;
     2502            pVCpu->cpum.GstCtx.ss.u64Base    = X86DESC_BASE(&DescSs.Legacy);
     2503        if (!pVCpu->cpum.GstCtx.ss.Attr.n.u1DefBig)
     2504            pVCpu->cpum.GstCtx.sp            = (uint16_t)uNewOuterRsp;
    25292505        else
    2530             pCtx->rsp           = uNewOuterRsp;
     2506            pVCpu->cpum.GstCtx.rsp           = uNewOuterRsp;
    25312507
    25322508        pVCpu->iem.s.uCpl           = (uNewCs & X86_SEL_RPL);
    2533         iemHlpAdjustSelectorForNewCpl(pVCpu, uNewCs & X86_SEL_RPL, &pCtx->ds);
    2534         iemHlpAdjustSelectorForNewCpl(pVCpu, uNewCs & X86_SEL_RPL, &pCtx->es);
    2535         iemHlpAdjustSelectorForNewCpl(pVCpu, uNewCs & X86_SEL_RPL, &pCtx->fs);
    2536         iemHlpAdjustSelectorForNewCpl(pVCpu, uNewCs & X86_SEL_RPL, &pCtx->gs);
     2509        iemHlpAdjustSelectorForNewCpl(pVCpu, uNewCs & X86_SEL_RPL, &pVCpu->cpum.GstCtx.ds);
     2510        iemHlpAdjustSelectorForNewCpl(pVCpu, uNewCs & X86_SEL_RPL, &pVCpu->cpum.GstCtx.es);
     2511        iemHlpAdjustSelectorForNewCpl(pVCpu, uNewCs & X86_SEL_RPL, &pVCpu->cpum.GstCtx.fs);
     2512        iemHlpAdjustSelectorForNewCpl(pVCpu, uNewCs & X86_SEL_RPL, &pVCpu->cpum.GstCtx.gs);
    25372513
    25382514        /** @todo check if the hidden bits are loaded correctly for 64-bit
    … …  
    25402516
    25412517        if (cbPop)
    2542             iemRegAddToRsp(pVCpu, pCtx, cbPop);
    2543         pCtx->eflags.Bits.u1RF = 0;
     2518            iemRegAddToRsp(pVCpu, cbPop);
     2519        pVCpu->cpum.GstCtx.eflags.Bits.u1RF = 0;
    25442520
    25452521        /* Done! */
    … …  
    25922568
    25932569        /* commit */
    2594         if (!pCtx->ss.Attr.n.u1DefBig)
    2595             pCtx->sp        = (uint16_t)uNewRsp;
     2570        if (!pVCpu->cpum.GstCtx.ss.Attr.n.u1DefBig)
     2571            pVCpu->cpum.GstCtx.sp        = (uint16_t)uNewRsp;
    25962572        else
    2597             pCtx->rsp       = uNewRsp;
     2573            pVCpu->cpum.GstCtx.rsp       = uNewRsp;
    25982574        if (enmEffOpSize == IEMMODE_16BIT)
    2599             pCtx->rip       = uNewRip & UINT16_MAX; /** @todo Testcase: When exactly does this occur? With call it happens prior to the limit check according to Intel... */
     2575            pVCpu->cpum.GstCtx.rip       = uNewRip & UINT16_MAX; /** @todo Testcase: When exactly does this occur? With call it happens prior to the limit check according to Intel... */
    26002576        else
    2601             pCtx->rip       = uNewRip;
    2602         pCtx->cs.Sel        = uNewCs;
    2603         pCtx->cs.ValidSel   = uNewCs;
    2604         pCtx->cs.fFlags     = CPUMSELREG_FLAGS_VALID;
    2605         pCtx->cs.Attr.u     = X86DESC_GET_HID_ATTR(&DescCs.Legacy);
    2606         pCtx->cs.u32Limit   = cbLimitCs;
    2607         pCtx->cs.u64Base    = u64Base;
     2577            pVCpu->cpum.GstCtx.rip       = uNewRip;
     2578        pVCpu->cpum.GstCtx.cs.Sel        = uNewCs;
     2579        pVCpu->cpum.GstCtx.cs.ValidSel   = uNewCs;
     2580        pVCpu->cpum.GstCtx.cs.fFlags     = CPUMSELREG_FLAGS_VALID;
     2581        pVCpu->cpum.GstCtx.cs.Attr.u     = X86DESC_GET_HID_ATTR(&DescCs.Legacy);
     2582        pVCpu->cpum.GstCtx.cs.u32Limit   = cbLimitCs;
     2583        pVCpu->cpum.GstCtx.cs.u64Base    = u64Base;
    26082584        /** @todo check if the hidden bits are loaded correctly for 64-bit
    26092585         *        mode.  */
    2610         pVCpu->iem.s.enmCpuMode = iemCalcCpuMode(pCtx);
     2586        pVCpu->iem.s.enmCpuMode = iemCalcCpuMode(pVCpu);
    26112587        if (cbPop)
    2612             iemRegAddToRsp(pVCpu, pCtx, cbPop);
    2613         pCtx->eflags.Bits.u1RF = 0;
     2588            iemRegAddToRsp(pVCpu, cbPop);
     2589        pVCpu->cpum.GstCtx.eflags.Bits.u1RF = 0;
    26142590    }
    26152591
    … …  
    26362612IEM_CIMPL_DEF_2(iemCImpl_retn, IEMMODE, enmEffOpSize, uint16_t, cbPop)
    26372613{
    2638     PCPUMCTX        pCtx = IEM_GET_CTX(pVCpu);
    26392614    NOREF(cbInstr);
    26402615
    … …  
    26432618    RTUINT64U       NewRip;
    26442619    RTUINT64U       NewRsp;
    2645     NewRsp.u = pCtx->rsp;
     2620    NewRsp.u = pVCpu->cpum.GstCtx.rsp;
    26462621
    26472622    switch (enmEffOpSize)
    … …  
    26682643    if (enmEffOpSize != IEMMODE_64BIT)
    26692644    {
    2670         if (NewRip.DWords.dw0 > pCtx->cs.u32Limit)
    2671         {
    2672             Log(("retn newrip=%llx - out of bounds (%x) -> #GP\n", NewRip.u, pCtx->cs.u32Limit));
     2645        if (NewRip.DWords.dw0 > pVCpu->cpum.GstCtx.cs.u32Limit)
     2646        {
     2647            Log(("retn newrip=%llx - out of bounds (%x) -> #GP\n", NewRip.u, pVCpu->cpum.GstCtx.cs.u32Limit));
    26732648            return iemRaiseSelectorBounds(pVCpu, X86_SREG_CS, IEM_ACCESS_INSTRUCTION);
    26742649        }
    … …  
    26852660    /* Apply cbPop */
    26862661    if (cbPop)
    2687         iemRegAddToRspEx(pVCpu, pCtx, &NewRsp, cbPop);
     2662        iemRegAddToRspEx(pVCpu, &NewRsp, cbPop);
    26882663
    26892664    /* Commit it. */
    2690     pCtx->rip = NewRip.u;
    2691     pCtx->rsp = NewRsp.u;
    2692     pCtx->eflags.Bits.u1RF = 0;
     2665    pVCpu->cpum.GstCtx.rip = NewRip.u;
     2666    pVCpu->cpum.GstCtx.rsp = NewRsp.u;
     2667    pVCpu->cpum.GstCtx.eflags.Bits.u1RF = 0;
    26932668
    26942669    /* Flush the prefetch buffer. */
    … …  
    27112686IEM_CIMPL_DEF_3(iemCImpl_enter, IEMMODE, enmEffOpSize, uint16_t, cbFrame, uint8_t, cParameters)
    27122687{
    2713     PCPUMCTX        pCtx = IEM_GET_CTX(pVCpu);
    2714 
    27152688    /* Push RBP, saving the old value in TmpRbp. */
    2716     RTUINT64U       NewRsp; NewRsp.u = pCtx->rsp;
    2717     RTUINT64U       TmpRbp; TmpRbp.u = pCtx->rbp;
     2689    RTUINT64U       NewRsp; NewRsp.u = pVCpu->cpum.GstCtx.rsp;
     2690    RTUINT64U       TmpRbp; TmpRbp.u = pVCpu->cpum.GstCtx.rbp;
    27182691    RTUINT64U       NewRbp;
    27192692    VBOXSTRICTRC    rcStrict;
    … …  
    27442717        {
    27452718            case IEMMODE_16BIT:
    2746                 if (pCtx->ss.Attr.n.u1DefBig)
     2719                if (pVCpu->cpum.GstCtx.ss.Attr.n.u1DefBig)
    27472720                    TmpRbp.DWords.dw0 -= 2;
    27482721                else
    … …  
    27592732
    27602733            case IEMMODE_32BIT:
    2761                 if (pCtx->ss.Attr.n.u1DefBig)
     2734                if (pVCpu->cpum.GstCtx.ss.Attr.n.u1DefBig)
    27622735                    TmpRbp.DWords.dw0 -= 4;
    27632736                else
    … …  
    28032776
    28042777    /* Recalc RSP. */
    2805     iemRegSubFromRspEx(pVCpu, pCtx, &NewRsp, cbFrame);
     2778    iemRegSubFromRspEx(pVCpu, &NewRsp, cbFrame);
    28062779
    28072780    /** @todo Should probe write access at the new RSP according to AMD. */
    28082781
    28092782    /* Commit it. */
    2810     pCtx->rbp = NewRbp.u;
    2811     pCtx->rsp = NewRsp.u;
     2783    pVCpu->cpum.GstCtx.rbp = NewRbp.u;
     2784    pVCpu->cpum.GstCtx.rsp = NewRsp.u;
    28122785    iemRegAddToRipAndClearRF(pVCpu, cbInstr);
    28132786
    … …  
    28272800IEM_CIMPL_DEF_1(iemCImpl_leave, IEMMODE, enmEffOpSize)
    28282801{
    2829     PCPUMCTX        pCtx = IEM_GET_CTX(pVCpu);
    2830 
    28312802    /* Calculate the intermediate RSP from RBP and the stack attributes. */
    28322803    RTUINT64U       NewRsp;
    28332804    if (pVCpu->iem.s.enmCpuMode == IEMMODE_64BIT)
    2834         NewRsp.u = pCtx->rbp;
    2835     else if (pCtx->ss.Attr.n.u1DefBig)
    2836         NewRsp.u = pCtx->ebp;
     2805        NewRsp.u = pVCpu->cpum.GstCtx.rbp;
     2806    else if (pVCpu->cpum.GstCtx.ss.Attr.n.u1DefBig)
     2807        NewRsp.u = pVCpu->cpum.GstCtx.ebp;
    28372808    else
    28382809    {
    28392810        /** @todo Check that LEAVE actually preserve the high EBP bits. */
    2840         NewRsp.u = pCtx->rsp;
    2841         NewRsp.Words.w0 = pCtx->bp;
     2811        NewRsp.u = pVCpu->cpum.GstCtx.rsp;
     2812        NewRsp.Words.w0 = pVCpu->cpum.GstCtx.bp;
    28422813    }
    28432814
    … …  
    28482819    {
    28492820        case IEMMODE_16BIT:
    2850             NewRbp.u = pCtx->rbp;
     2821            NewRbp.u = pVCpu->cpum.GstCtx.rbp;
    28512822            rcStrict = iemMemStackPopU16Ex(pVCpu, &NewRbp.Words.w0, &NewRsp);
    28522823            break;
    … …  
    28652836
    28662837    /* Commit it. */
    2867     pCtx->rbp = NewRbp.u;
    2868     pCtx->rsp = NewRsp.u;
     2838    pVCpu->cpum.GstCtx.rbp = NewRbp.u;
     2839    pVCpu->cpum.GstCtx.rsp = NewRsp.u;
    28692840    iemRegAddToRipAndClearRF(pVCpu, cbInstr);
    28702841
    … …  
    28982869IEM_CIMPL_DEF_1(iemCImpl_iret_real_v8086, IEMMODE, enmEffOpSize)
    28992870{
    2900     PCPUMCTX  pCtx  = IEM_GET_CTX(pVCpu);
    29012871    X86EFLAGS Efl;
    2902     Efl.u = IEMMISC_GET_EFL(pVCpu, pCtx);
     2872    Efl.u = IEMMISC_GET_EFL(pVCpu);
    29032873    NOREF(cbInstr);
    29042874
    … …  
    29082878    if (   Efl.Bits.u1VM
    29092879        && Efl.Bits.u2IOPL != 3
    2910         && !(pCtx->cr4 & X86_CR4_VME))
     2880        && !(pVCpu->cpum.GstCtx.cr4 & X86_CR4_VME))
    29112881        return iemRaiseGeneralProtectionFault0(pVCpu);
    29122882
    … …  
    29732943    /** @todo Only the AMD pseudo code check the limit here, what's
    29742944     *        right? */
    2975     if (uNewEip > pCtx->cs.u32Limit)
     2945    if (uNewEip > pVCpu->cpum.GstCtx.cs.u32Limit)
    29762946        return iemRaiseSelectorBounds(pVCpu, X86_SREG_CS, IEM_ACCESS_INSTRUCTION);
    29772947
    … …  
    30082978#ifdef DBGFTRACE_ENABLED
    30092979    RTTraceBufAddMsgF(pVCpu->CTX_SUFF(pVM)->CTX_SUFF(hTraceBuf), "iret/rm %04x:%04x -> %04x:%04x %x %04llx",
    3010                       pCtx->cs.Sel, pCtx->eip, uNewCs, uNewEip, uNewFlags, uNewRsp);
     2980                      pVCpu->cpum.GstCtx.cs.Sel, pVCpu->cpum.GstCtx.eip, uNewCs, uNewEip, uNewFlags, uNewRsp);
    30112981#endif
    3012     pCtx->rsp           = uNewRsp;
    3013     pCtx->rip           = uNewEip;
    3014     pCtx->cs.Sel        = uNewCs;
    3015     pCtx->cs.ValidSel   = uNewCs;
    3016     pCtx->cs.fFlags     = CPUMSELREG_FLAGS_VALID;
    3017     pCtx->cs.u64Base    = (uint32_t)uNewCs << 4;
     2982    pVCpu->cpum.GstCtx.rsp           = uNewRsp;
     2983    pVCpu->cpum.GstCtx.rip           = uNewEip;
     2984    pVCpu->cpum.GstCtx.cs.Sel        = uNewCs;
     2985    pVCpu->cpum.GstCtx.cs.ValidSel   = uNewCs;
     2986    pVCpu->cpum.GstCtx.cs.fFlags     = CPUMSELREG_FLAGS_VALID;
     2987    pVCpu->cpum.GstCtx.cs.u64Base    = (uint32_t)uNewCs << 4;
    30182988    /** @todo do we load attribs and limit as well? */
    30192989    Assert(uNewFlags & X86_EFL_1);
    3020     IEMMISC_SET_EFL(pVCpu, pCtx, uNewFlags);
     2990    IEMMISC_SET_EFL(pVCpu, uNewFlags);
    30212991
    30222992    /* Flush the prefetch buffer. */
    … …  
    30533023 * Implements iret for protected mode returning to V8086 mode.
    30543024 *
    3055  * @param   pCtx            Pointer to the CPU context.
    30563025 * @param   uNewEip         The new EIP.
    30573026 * @param   uNewCs          The new CS.
    … …  
    30613030 * @note    This can only be a 32-bit iret du to the X86_EFL_VM position.
    30623031 */
    3063 IEM_CIMPL_DEF_5(iemCImpl_iret_prot_v8086, PCPUMCTX, pCtx, uint32_t, uNewEip, uint16_t, uNewCs,
    3064                 uint32_t, uNewFlags, uint64_t, uNewRsp)
     3032IEM_CIMPL_DEF_4(iemCImpl_iret_prot_v8086, uint32_t, uNewEip, uint16_t, uNewCs, uint32_t, uNewFlags, uint64_t, uNewRsp)
    30653033{
    30663034    RT_NOREF_PV(cbInstr);
    3067     IEM_CTX_IMPORT_RET(pVCpu, pCtx, CPUMCTX_EXTRN_SREG_MASK);
     3035    IEM_CTX_IMPORT_RET(pVCpu, CPUMCTX_EXTRN_SREG_MASK);
    30683036
    30693037    /*
    … …  
    30923060#ifdef DBGFTRACE_ENABLED
    30933061    RTTraceBufAddMsgF(pVCpu->CTX_SUFF(pVM)->CTX_SUFF(hTraceBuf), "iret/p/v %04x:%08x -> %04x:%04x %x %04x:%04x",
    3094                       pCtx->cs.Sel, pCtx->eip, uNewCs, uNewEip, uNewFlags, uNewSs, uNewEsp);
     3062                      pVCpu->cpum.GstCtx.cs.Sel, pVCpu->cpum.GstCtx.eip, uNewCs, uNewEip, uNewFlags, uNewSs, uNewEsp);
    30953063#endif
    3096     Log7(("iemCImpl_iret_prot_v8086: %04x:%08x -> %04x:%04x %x %04x:%04x\n", pCtx->cs.Sel, pCtx->eip, uNewCs, uNewEip, uNewFlags, uNewSs, uNewEsp));
    3097 
    3098     IEMMISC_SET_EFL(pVCpu, pCtx, uNewFlags);
    3099     iemCImplCommonV8086LoadSeg(&pCtx->cs, uNewCs);
    3100     iemCImplCommonV8086LoadSeg(&pCtx->ss, uNewSs);
    3101     iemCImplCommonV8086LoadSeg(&pCtx->es, uNewEs);
    3102     iemCImplCommonV8086LoadSeg(&pCtx->ds, uNewDs);
    3103     iemCImplCommonV8086LoadSeg(&pCtx->fs, uNewFs);
    3104     iemCImplCommonV8086LoadSeg(&pCtx->gs, uNewGs);
    3105     pCtx->rip      = (uint16_t)uNewEip;
    3106     pCtx->rsp      = uNewEsp; /** @todo check this out! */
     3064    Log7(("iemCImpl_iret_prot_v8086: %04x:%08x -> %04x:%04x %x %04x:%04x\n", pVCpu->cpum.GstCtx.cs.Sel, pVCpu->cpum.GstCtx.eip, uNewCs, uNewEip, uNewFlags, uNewSs, uNewEsp));
     3065
     3066    IEMMISC_SET_EFL(pVCpu, uNewFlags);
     3067    iemCImplCommonV8086LoadSeg(&pVCpu->cpum.GstCtx.cs, uNewCs);
     3068    iemCImplCommonV8086LoadSeg(&pVCpu->cpum.GstCtx.ss, uNewSs);
     3069    iemCImplCommonV8086LoadSeg(&pVCpu->cpum.GstCtx.es, uNewEs);
     3070    iemCImplCommonV8086LoadSeg(&pVCpu->cpum.GstCtx.ds, uNewDs);
     3071    iemCImplCommonV8086LoadSeg(&pVCpu->cpum.GstCtx.fs, uNewFs);
     3072    iemCImplCommonV8086LoadSeg(&pVCpu->cpum.GstCtx.gs, uNewGs);
     3073    pVCpu->cpum.GstCtx.rip      = (uint16_t)uNewEip;
     3074    pVCpu->cpum.GstCtx.rsp      = uNewEsp; /** @todo check this out! */
    31073075    pVCpu->iem.s.uCpl  = 3;
    31083076
    … …  
    31353103     */
    31363104    RTSEL        uSelRet;
    3137     PCPUMCTX     pCtx = IEM_GET_CTX(pVCpu);
    3138     VBOXSTRICTRC rcStrict = iemMemFetchSysU16(pVCpu, &uSelRet, UINT8_MAX, pCtx->tr.u64Base);
     3105    VBOXSTRICTRC rcStrict = iemMemFetchSysU16(pVCpu, &uSelRet, UINT8_MAX, pVCpu->cpum.GstCtx.tr.u64Base);
    31393106    if (rcStrict != VINF_SUCCESS)
    31403107        return rcStrict;
    … …  
    31733140    }
    31743141
    3175     uint32_t uNextEip = pCtx->eip + cbInstr;
    3176     return iemTaskSwitch(pVCpu, pCtx, IEMTASKSWITCH_IRET, uNextEip, 0 /* fFlags */, 0 /* uErr */,
     3142    uint32_t uNextEip = pVCpu->cpum.GstCtx.eip + cbInstr;
     3143    return iemTaskSwitch(pVCpu, IEMTASKSWITCH_IRET, uNextEip, 0 /* fFlags */, 0 /* uErr */,
    31773144                         0 /* uCr2 */, uSelRet, &TssDesc);
    31783145#endif
    … …  
    31873154IEM_CIMPL_DEF_1(iemCImpl_iret_prot, IEMMODE, enmEffOpSize)
    31883155{
    3189     PCPUMCTX pCtx = IEM_GET_CTX(pVCpu);
    31903156    NOREF(cbInstr);
    31913157    Assert(enmEffOpSize == IEMMODE_32BIT || enmEffOpSize == IEMMODE_16BIT);
    … …  
    31943160     * Nested task return.
    31953161     */
    3196     if (pCtx->eflags.Bits.u1NT)
     3162    if (pVCpu->cpum.GstCtx.eflags.Bits.u1NT)
    31973163        return IEM_CIMPL_CALL_1(iemCImpl_iret_prot_NestedTask, enmEffOpSize);
    31983164
    … …  
    32423208    {
    32433209        Assert(enmEffOpSize == IEMMODE_32BIT);
    3244         return IEM_CIMPL_CALL_5(iemCImpl_iret_prot_v8086, pCtx, uNewEip, uNewCs, uNewFlags, uNewRsp);
     3210        return IEM_CIMPL_CALL_4(iemCImpl_iret_prot_v8086, uNewEip, uNewCs, uNewFlags, uNewRsp);
    32453211    }
    32463212
    … …  
    32843250            if (   pVCpu->iem.s.uCpl == 0
    32853251                && (   !EMIsRawRing1Enabled(pVM)
    3286                     || pCtx->cs.Sel == (uNewCs & X86_SEL_MASK_OFF_RPL)) )
     3252                    || pVCpu->cpum.GstCtx.cs.Sel == (uNewCs & X86_SEL_MASK_OFF_RPL)) )
    32873253            {
    32883254                Log(("iret: Ring-0 compression fix: uNewCS=%#x -> %#x\n", uNewCs, uNewCs & X86_SEL_MASK_OFF_RPL));
    … …  
    34513417        if (pVCpu->iem.s.uCpl == 0)
    34523418            fEFlagsMask |= X86_EFL_IF | X86_EFL_IOPL | X86_EFL_VIF | X86_EFL_VIP; /* VM is 0 */
    3453         else if (pVCpu->iem.s.uCpl <= pCtx->eflags.Bits.u2IOPL)
     3419        else if (pVCpu->iem.s.uCpl <= pVCpu->cpum.GstCtx.eflags.Bits.u2IOPL)
    34543420            fEFlagsMask |= X86_EFL_IF;
    34553421        if (IEM_GET_TARGET_CPU(pVCpu) <= IEMTARGETCPU_386)
    34563422            fEFlagsMask &= ~(X86_EFL_AC | X86_EFL_ID | X86_EFL_VIF | X86_EFL_VIP);
    3457         uint32_t fEFlagsNew = IEMMISC_GET_EFL(pVCpu, pCtx);
     3423        uint32_t fEFlagsNew = IEMMISC_GET_EFL(pVCpu);
    34583424        fEFlagsNew         &= ~fEFlagsMask;
    34593425        fEFlagsNew         |= uNewFlags & fEFlagsMask;
    34603426#ifdef DBGFTRACE_ENABLED
    34613427        RTTraceBufAddMsgF(pVCpu->CTX_SUFF(pVM)->CTX_SUFF(hTraceBuf), "iret/%up%u %04x:%08x -> %04x:%04x %x %04x:%04x",
    3462                           pVCpu->iem.s.uCpl, uNewCs & X86_SEL_RPL, pCtx->cs.Sel, pCtx->eip,
     3428                          pVCpu->iem.s.uCpl, uNewCs & X86_SEL_RPL, pVCpu->cpum.GstCtx.cs.Sel, pVCpu->cpum.GstCtx.eip,
    34633429                          uNewCs, uNewEip, uNewFlags,  uNewSS, uNewESP);
    34643430#endif
    34653431
    3466         IEMMISC_SET_EFL(pVCpu, pCtx, fEFlagsNew);
    3467         pCtx->rip           = uNewEip;
    3468         pCtx->cs.Sel        = uNewCs;
    3469         pCtx->cs.ValidSel   = uNewCs;
    3470         pCtx->cs.fFlags     = CPUMSELREG_FLAGS_VALID;
    3471         pCtx->cs.Attr.u     = X86DESC_GET_HID_ATTR(&DescCS.Legacy);
    3472         pCtx->cs.u32Limit   = cbLimitCS;
    3473         pCtx->cs.u64Base    = X86DESC_BASE(&DescCS.Legacy);
    3474         pVCpu->iem.s.enmCpuMode = iemCalcCpuMode(pCtx);
    3475 
    3476         pCtx->ss.Sel        = uNewSS;
    3477         pCtx->ss.ValidSel   = uNewSS;
    3478         pCtx->ss.fFlags     = CPUMSELREG_FLAGS_VALID;
    3479         pCtx->ss.Attr.u     = X86DESC_GET_HID_ATTR(&DescSS.Legacy);
    3480         pCtx->ss.u32Limit   = cbLimitSs;
    3481         pCtx->ss.u64Base    = X86DESC_BASE(&DescSS.Legacy);
    3482         if (!pCtx->ss.Attr.n.u1DefBig)
    3483             pCtx->sp        = (uint16_t)uNewESP;
     3432        IEMMISC_SET_EFL(pVCpu, fEFlagsNew);
     3433        pVCpu->cpum.GstCtx.rip           = uNewEip;
     3434        pVCpu->cpum.GstCtx.cs.Sel        = uNewCs;
     3435        pVCpu->cpum.GstCtx.cs.ValidSel   = uNewCs;
     3436        pVCpu->cpum.GstCtx.cs.fFlags     = CPUMSELREG_FLAGS_VALID;
     3437        pVCpu->cpum.GstCtx.cs.Attr.u     = X86DESC_GET_HID_ATTR(&DescCS.Legacy);
     3438        pVCpu->cpum.GstCtx.cs.u32Limit   = cbLimitCS;
     3439        pVCpu->cpum.GstCtx.cs.u64Base    = X86DESC_BASE(&DescCS.Legacy);
     3440        pVCpu->iem.s.enmCpuMode = iemCalcCpuMode(pVCpu);
     3441
     3442        pVCpu->cpum.GstCtx.ss.Sel        = uNewSS;
     3443        pVCpu->cpum.GstCtx.ss.ValidSel   = uNewSS;
     3444        pVCpu->cpum.GstCtx.ss.fFlags     = CPUMSELREG_FLAGS_VALID;
     3445        pVCpu->cpum.GstCtx.ss.Attr.u     = X86DESC_GET_HID_ATTR(&DescSS.Legacy);
     3446        pVCpu->cpum.GstCtx.ss.u32Limit   = cbLimitSs;
     3447        pVCpu->cpum.GstCtx.ss.u64Base    = X86DESC_BASE(&DescSS.Legacy);
     3448        if (!pVCpu->cpum.GstCtx.ss.Attr.n.u1DefBig)
     3449            pVCpu->cpum.GstCtx.sp        = (uint16_t)uNewESP;
    34843450        else
    3485             pCtx->rsp       = uNewESP;
     3451            pVCpu->cpum.GstCtx.rsp       = uNewESP;
    34863452
    34873453        pVCpu->iem.s.uCpl       = uNewCs & X86_SEL_RPL;
    3488         iemHlpAdjustSelectorForNewCpl(pVCpu, uNewCs & X86_SEL_RPL, &pCtx->ds);
    3489         iemHlpAdjustSelectorForNewCpl(pVCpu, uNewCs & X86_SEL_RPL, &pCtx->es);
    3490         iemHlpAdjustSelectorForNewCpl(pVCpu, uNewCs & X86_SEL_RPL, &pCtx->fs);
    3491         iemHlpAdjustSelectorForNewCpl(pVCpu, uNewCs & X86_SEL_RPL, &pCtx->gs);
     3454        iemHlpAdjustSelectorForNewCpl(pVCpu, uNewCs & X86_SEL_RPL, &pVCpu->cpum.GstCtx.ds);
     3455        iemHlpAdjustSelectorForNewCpl(pVCpu, uNewCs & X86_SEL_RPL, &pVCpu->cpum.GstCtx.es);
     3456        iemHlpAdjustSelectorForNewCpl(pVCpu, uNewCs & X86_SEL_RPL, &pVCpu->cpum.GstCtx.fs);
     3457        iemHlpAdjustSelectorForNewCpl(pVCpu, uNewCs & X86_SEL_RPL, &pVCpu->cpum.GstCtx.gs);
    34923458
    34933459        /* Done! */
    … …  
    35193485
    35203486        X86EFLAGS NewEfl;
    3521         NewEfl.u = IEMMISC_GET_EFL(pVCpu, pCtx);
     3487        NewEfl.u = IEMMISC_GET_EFL(pVCpu);
    35223488        uint32_t fEFlagsMask = X86_EFL_CF | X86_EFL_PF | X86_EFL_AF | X86_EFL_ZF | X86_EFL_SF
    35233489                             | X86_EFL_TF | X86_EFL_DF | X86_EFL_OF | X86_EFL_NT;
    … …  
    35343500#ifdef DBGFTRACE_ENABLED
    35353501        RTTraceBufAddMsgF(pVCpu->CTX_SUFF(pVM)->CTX_SUFF(hTraceBuf), "iret/%up %04x:%08x -> %04x:%04x %x %04x:%04llx",
    3536                           pVCpu->iem.s.uCpl, pCtx->cs.Sel, pCtx->eip,
    3537                           uNewCs, uNewEip, uNewFlags, pCtx->ss.Sel, uNewRsp);
     3502                          pVCpu->iem.s.uCpl, pVCpu->cpum.GstCtx.cs.Sel, pVCpu->cpum.GstCtx.eip,
     3503                          uNewCs, uNewEip, uNewFlags, pVCpu->cpum.GstCtx.ss.Sel, uNewRsp);
    35383504#endif
    35393505
    3540         IEMMISC_SET_EFL(pVCpu, pCtx, NewEfl.u);
    3541         pCtx->rip           = uNewEip;
    3542         pCtx->cs.Sel        = uNewCs;
    3543         pCtx->cs.ValidSel   = uNewCs;
    3544         pCtx->cs.fFlags     = CPUMSELREG_FLAGS_VALID;
    3545         pCtx->cs.Attr.u     = X86DESC_GET_HID_ATTR(&DescCS.Legacy);
    3546         pCtx->cs.u32Limit   = cbLimitCS;
    3547         pCtx->cs.u64Base    = X86DESC_BASE(&DescCS.Legacy);
    3548         pVCpu->iem.s.enmCpuMode = iemCalcCpuMode(pCtx);
    3549         if (!pCtx->ss.Attr.n.u1DefBig)
    3550             pCtx->sp        = (uint16_t)uNewRsp;
     3506        IEMMISC_SET_EFL(pVCpu, NewEfl.u);
     3507        pVCpu->cpum.GstCtx.rip           = uNewEip;
     3508        pVCpu->cpum.GstCtx.cs.Sel        = uNewCs;
     3509        pVCpu->cpum.GstCtx.cs.ValidSel   = uNewCs;
     3510        pVCpu->cpum.GstCtx.cs.fFlags     = CPUMSELREG_FLAGS_VALID;
     3511        pVCpu->cpum.GstCtx.cs.Attr.u     = X86DESC_GET_HID_ATTR(&DescCS.Legacy);
     3512        pVCpu->cpum.GstCtx.cs.u32Limit   = cbLimitCS;
     3513        pVCpu->cpum.GstCtx.cs.u64Base    = X86DESC_BASE(&DescCS.Legacy);
     3514        pVCpu->iem.s.enmCpuMode = iemCalcCpuMode(pVCpu);
     3515        if (!pVCpu->cpum.GstCtx.ss.Attr.n.u1DefBig)
     3516            pVCpu->cpum.GstCtx.sp        = (uint16_t)uNewRsp;
    35513517        else
    3552             pCtx->rsp       = uNewRsp;
     3518            pVCpu->cpum.GstCtx.rsp       = uNewRsp;
    35533519        /* Done! */
    35543520    }
    … …  
    35723538IEM_CIMPL_DEF_1(iemCImpl_iret_64bit, IEMMODE, enmEffOpSize)
    35733539{
    3574     PCPUMCTX pCtx = IEM_GET_CTX(pVCpu);
    35753540    NOREF(cbInstr);
    35763541
    … …  
    35783543     * Nested task return is not supported in long mode.
    35793544     */
    3580     if (pCtx->eflags.Bits.u1NT)
    3581     {
    3582         Log(("iretq with NT=1 (eflags=%#x) -> #GP(0)\n", pCtx->eflags.u));
     3545    if (pVCpu->cpum.GstCtx.eflags.Bits.u1NT)
     3546    {
     3547        Log(("iretq with NT=1 (eflags=%#x) -> #GP(0)\n", pVCpu->cpum.GstCtx.eflags.u));
    35833548        return iemRaiseGeneralProtectionFault0(pVCpu);
    35843549    }
    … …  
    38093774    if (pVCpu->iem.s.uCpl == 0)
    38103775        fEFlagsMask |= X86_EFL_IF | X86_EFL_IOPL | X86_EFL_VIF | X86_EFL_VIP; /* VM is ignored */
    3811     else if (pVCpu->iem.s.uCpl <= pCtx->eflags.Bits.u2IOPL)
     3776    else if (pVCpu->iem.s.uCpl <= pVCpu->cpum.GstCtx.eflags.Bits.u2IOPL)
    38123777        fEFlagsMask |= X86_EFL_IF;
    3813     uint32_t fEFlagsNew = IEMMISC_GET_EFL(pVCpu, pCtx);
     3778    uint32_t fEFlagsNew = IEMMISC_GET_EFL(pVCpu);
    38143779    fEFlagsNew         &= ~fEFlagsMask;
    38153780    fEFlagsNew         |= uNewFlags & fEFlagsMask;
    38163781#ifdef DBGFTRACE_ENABLED
    38173782    RTTraceBufAddMsgF(pVCpu->CTX_SUFF(pVM)->CTX_SUFF(hTraceBuf), "iret/%ul%u %08llx -> %04x:%04llx %llx %04x:%04llx",
    3818                       pVCpu->iem.s.uCpl, uNewCpl, pCtx->rip, uNewCs, uNewRip, uNewFlags, uNewSs, uNewRsp);
     3783                      pVCpu->iem.s.uCpl, uNewCpl, pVCpu->cpum.GstCtx.rip, uNewCs, uNewRip, uNewFlags, uNewSs, uNewRsp);
    38193784#endif
    38203785
    3821     IEMMISC_SET_EFL(pVCpu, pCtx, fEFlagsNew);
    3822     pCtx->rip           = uNewRip;
    3823     pCtx->cs.Sel        = uNewCs;
    3824     pCtx->cs.ValidSel   = uNewCs;
    3825     pCtx->cs.fFlags     = CPUMSELREG_FLAGS_VALID;
    3826     pCtx->cs.Attr.u     = X86DESC_GET_HID_ATTR(&DescCS.Legacy);
    3827     pCtx->cs.u32Limit   = cbLimitCS;
    3828     pCtx->cs.u64Base    = X86DESC_BASE(&DescCS.Legacy);
    3829     pVCpu->iem.s.enmCpuMode = iemCalcCpuMode(pCtx);
    3830     if (pCtx->cs.Attr.n.u1Long || pCtx->cs.Attr.n.u1DefBig)
    3831         pCtx->rsp       = uNewRsp;
     3786    IEMMISC_SET_EFL(pVCpu, fEFlagsNew);
     3787    pVCpu->cpum.GstCtx.rip           = uNewRip;
     3788    pVCpu->cpum.GstCtx.cs.Sel        = uNewCs;
     3789    pVCpu->cpum.GstCtx.cs.ValidSel   = uNewCs;
     3790    pVCpu->cpum.GstCtx.cs.fFlags     = CPUMSELREG_FLAGS_VALID;
     3791    pVCpu->cpum.GstCtx.cs.Attr.u     = X86DESC_GET_HID_ATTR(&DescCS.Legacy);
     3792    pVCpu->cpum.GstCtx.cs.u32Limit   = cbLimitCS;
     3793    pVCpu->cpum.GstCtx.cs.u64Base    = X86DESC_BASE(&DescCS.Legacy);
     3794    pVCpu->iem.s.enmCpuMode = iemCalcCpuMode(pVCpu);
     3795    if (pVCpu->cpum.GstCtx.cs.Attr.n.u1Long || pVCpu->cpum.GstCtx.cs.Attr.n.u1DefBig)
     3796        pVCpu->cpum.GstCtx.rsp       = uNewRsp;
    38323797    else
    3833         pCtx->sp        = (uint16_t)uNewRsp;
    3834     pCtx->ss.Sel        = uNewSs;
    3835     pCtx->ss.ValidSel   = uNewSs;
     3798        pVCpu->cpum.GstCtx.sp        = (uint16_t)uNewRsp;
     3799    pVCpu->cpum.GstCtx.ss.Sel        = uNewSs;
     3800    pVCpu->cpum.GstCtx.ss.ValidSel   = uNewSs;
    38363801    if (!(uNewSs & X86_SEL_MASK_OFF_RPL))
    38373802    {
    3838         pCtx->ss.fFlags     = CPUMSELREG_FLAGS_VALID;
    3839         pCtx->ss.Attr.u     = X86DESCATTR_UNUSABLE | (uNewCpl << X86DESCATTR_DPL_SHIFT);
    3840         pCtx->ss.u32Limit   = UINT32_MAX;
    3841         pCtx->ss.u64Base    = 0;
     3803        pVCpu->cpum.GstCtx.ss.fFlags     = CPUMSELREG_FLAGS_VALID;
     3804        pVCpu->cpum.GstCtx.ss.Attr.u     = X86DESCATTR_UNUSABLE | (uNewCpl << X86DESCATTR_DPL_SHIFT);
     3805        pVCpu->cpum.GstCtx.ss.u32Limit   = UINT32_MAX;
     3806        pVCpu->cpum.GstCtx.ss.u64Base    = 0;
    38423807        Log2(("iretq new SS: NULL\n"));
    38433808    }
    38443809    else
    38453810    {
    3846         pCtx->ss.fFlags     = CPUMSELREG_FLAGS_VALID;
    3847         pCtx->ss.Attr.u     = X86DESC_GET_HID_ATTR(&DescSS.Legacy);
    3848         pCtx->ss.u32Limit   = cbLimitSs;
    3849         pCtx->ss.u64Base    = X86DESC_BASE(&DescSS.Legacy);
    3850         Log2(("iretq new SS: base=%#RX64 lim=%#x attr=%#x\n", pCtx->ss.u64Base, pCtx->ss.u32Limit, pCtx->ss.Attr.u));
     3811        pVCpu->cpum.GstCtx.ss.fFlags     = CPUMSELREG_FLAGS_VALID;
     3812        pVCpu->cpum.GstCtx.ss.Attr.u     = X86DESC_GET_HID_ATTR(&DescSS.Legacy);
     3813        pVCpu->cpum.GstCtx.ss.u32Limit   = cbLimitSs;
     3814        pVCpu->cpum.GstCtx.ss.u64Base    = X86DESC_BASE(&DescSS.Legacy);
     3815        Log2(("iretq new SS: base=%#RX64 lim=%#x attr=%#x\n", pVCpu->cpum.GstCtx.ss.u64Base, pVCpu->cpum.GstCtx.ss.u32Limit, pVCpu->cpum.GstCtx.ss.Attr.u));
    38513816    }
    38523817
    … …  
    38543819    {
    38553820        pVCpu->iem.s.uCpl = uNewCpl;
    3856         iemHlpAdjustSelectorForNewCpl(pVCpu, uNewCpl, &pCtx->ds);
    3857         iemHlpAdjustSelectorForNewCpl(pVCpu, uNewCpl, &pCtx->es);
    3858         iemHlpAdjustSelectorForNewCpl(pVCpu, uNewCpl, &pCtx->fs);
    3859         iemHlpAdjustSelectorForNewCpl(pVCpu, uNewCpl, &pCtx->gs);
     3821        iemHlpAdjustSelectorForNewCpl(pVCpu, uNewCpl, &pVCpu->cpum.GstCtx.ds);
     3822        iemHlpAdjustSelectorForNewCpl(pVCpu, uNewCpl, &pVCpu->cpum.GstCtx.es);
     3823        iemHlpAdjustSelectorForNewCpl(pVCpu, uNewCpl, &pVCpu->cpum.GstCtx.fs);
     3824        iemHlpAdjustSelectorForNewCpl(pVCpu, uNewCpl, &pVCpu->cpum.GstCtx.gs);
    38603825    }
    38613826
    … …  
    39003865    if (IEM_IS_REAL_OR_V86_MODE(pVCpu))
    39013866        return IEM_CIMPL_CALL_1(iemCImpl_iret_real_v8086, enmEffOpSize);
    3902     IEM_CTX_IMPORT_RET(pVCpu, IEM_GET_CTX(pVCpu), CPUMCTX_EXTRN_SREG_MASK | CPUMCTX_EXTRN_GDTR | CPUMCTX_EXTRN_LDTR);
     3867    IEM_CTX_IMPORT_RET(pVCpu, CPUMCTX_EXTRN_SREG_MASK | CPUMCTX_EXTRN_GDTR | CPUMCTX_EXTRN_LDTR);
    39033868    if (pVCpu->iem.s.enmCpuMode == IEMMODE_64BIT)
    39043869        return IEM_CIMPL_CALL_1(iemCImpl_iret_64bit, enmEffOpSize);
    … …  
    39143879IEM_CIMPL_DEF_0(iemCImpl_syscall)
    39153880{
    3916     PCPUMCTX pCtx = IEM_GET_CTX(pVCpu);
    3917 
    39183881    /*
    39193882     * Check preconditions.
    … …  
    39233886     * hardware.
    39243887     */
    3925     if (!(pCtx->msrEFER & MSR_K6_EFER_SCE))
     3888    if (!(pVCpu->cpum.GstCtx.msrEFER & MSR_K6_EFER_SCE))
    39263889    {
    39273890        Log(("syscall: Not enabled in EFER -> #UD\n"));
    39283891        return iemRaiseUndefinedOpcode(pVCpu);
    39293892    }
    3930     if (!(pCtx->cr0 & X86_CR0_PE))
     3893    if (!(pVCpu->cpum.GstCtx.cr0 & X86_CR0_PE))
    39313894    {
    39323895        Log(("syscall: Protected mode is required -> #GP(0)\n"));
    39333896        return iemRaiseGeneralProtectionFault0(pVCpu);
    39343897    }
    3935     if (IEM_IS_GUEST_CPU_INTEL(pVCpu) && !CPUMIsGuestInLongModeEx(pCtx))
     3898    if (IEM_IS_GUEST_CPU_INTEL(pVCpu) && !CPUMIsGuestInLongModeEx(IEM_GET_CTX(pVCpu)))
    39363899    {
    39373900        Log(("syscall: Only available in long mode on intel -> #UD\n"));
    … …  
    39393902    }
    39403903
    3941     IEM_CTX_IMPORT_RET(pVCpu, pCtx, CPUMCTX_EXTRN_SYSCALL_MSRS);
     3904    IEM_CTX_IMPORT_RET(pVCpu, CPUMCTX_EXTRN_SYSCALL_MSRS);
    39423905
    39433906    /** @todo verify RPL ignoring and CS=0xfff8 (i.e. SS == 0). */
    39443907    /** @todo what about LDT selectors? Shouldn't matter, really. */
    3945     uint16_t uNewCs = (pCtx->msrSTAR >> MSR_K6_STAR_SYSCALL_CS_SS_SHIFT) & X86_SEL_MASK_OFF_RPL;
     3908    uint16_t uNewCs = (pVCpu->cpum.GstCtx.msrSTAR >> MSR_K6_STAR_SYSCALL_CS_SS_SHIFT) & X86_SEL_MASK_OFF_RPL;
    39463909    uint16_t uNewSs = uNewCs + 8;
    39473910    if (uNewCs == 0 || uNewSs == 0)
    … …  
    39523915
    39533916    /* Long mode and legacy mode differs. */
    3954     if (CPUMIsGuestInLongModeEx(pCtx))
    3955     {
    3956         uint64_t uNewRip = pVCpu->iem.s.enmCpuMode == IEMMODE_64BIT ? pCtx->msrLSTAR : pCtx-> msrCSTAR;
     3917    if (CPUMIsGuestInLongModeEx(IEM_GET_CTX(pVCpu)))
     3918    {
     3919        uint64_t uNewRip = pVCpu->iem.s.enmCpuMode == IEMMODE_64BIT ? pVCpu->cpum.GstCtx.msrLSTAR : pVCpu->cpum.GstCtx. msrCSTAR;
    39573920
    39583921        /* This test isn't in the docs, but I'm not trusting the guys writing
    … …  
    39673930         * Commit it.
    39683931         */
    3969         Log(("syscall: %04x:%016RX64 [efl=%#llx] -> %04x:%016RX64\n", pCtx->cs, pCtx->rip, pCtx->rflags.u, uNewCs, uNewRip));
    3970         pCtx->rcx           = pCtx->rip + cbInstr;
    3971         pCtx->rip           = uNewRip;
    3972 
    3973         pCtx->rflags.u     &= ~X86_EFL_RF;
    3974         pCtx->r11           = pCtx->rflags.u;
    3975         pCtx->rflags.u     &= ~pCtx->msrSFMASK;
    3976         pCtx->rflags.u     |= X86_EFL_1;
    3977 
    3978         pCtx->cs.Attr.u     = X86DESCATTR_P | X86DESCATTR_G | X86DESCATTR_L | X86DESCATTR_DT | X86_SEL_TYPE_ER_ACC;
    3979         pCtx->ss.Attr.u     = X86DESCATTR_P | X86DESCATTR_G | X86DESCATTR_L | X86DESCATTR_DT | X86_SEL_TYPE_RW_ACC;
     3932        Log(("syscall: %04x:%016RX64 [efl=%#llx] -> %04x:%016RX64\n", pVCpu->cpum.GstCtx.cs, pVCpu->cpum.GstCtx.rip, pVCpu->cpum.GstCtx.rflags.u, uNewCs, uNewRip));
     3933        pVCpu->cpum.GstCtx.rcx           = pVCpu->cpum.GstCtx.rip + cbInstr;
     3934        pVCpu->cpum.GstCtx.rip           = uNewRip;
     3935
     3936        pVCpu->cpum.GstCtx.rflags.u     &= ~X86_EFL_RF;
     3937        pVCpu->cpum.GstCtx.r11           = pVCpu->cpum.GstCtx.rflags.u;
     3938        pVCpu->cpum.GstCtx.rflags.u     &= ~pVCpu->cpum.GstCtx.msrSFMASK;
     3939        pVCpu->cpum.GstCtx.rflags.u     |= X86_EFL_1;
     3940
     3941        pVCpu->cpum.GstCtx.cs.Attr.u     = X86DESCATTR_P | X86DESCATTR_G | X86DESCATTR_L | X86DESCATTR_DT | X86_SEL_TYPE_ER_ACC;
     3942        pVCpu->cpum.GstCtx.ss.Attr.u     = X86DESCATTR_P | X86DESCATTR_G | X86DESCATTR_L | X86DESCATTR_DT | X86_SEL_TYPE_RW_ACC;
    39803943    }
    39813944    else
    … …  
    39853948         */
    39863949        Log(("syscall: %04x:%08RX32 [efl=%#x] -> %04x:%08RX32\n",
    3987              pCtx->cs, pCtx->eip, pCtx->eflags.u, uNewCs, (uint32_t)(pCtx->msrSTAR & MSR_K6_STAR_SYSCALL_EIP_MASK)));
    3988         pCtx->rcx           = pCtx->eip + cbInstr;
    3989         pCtx->rip           = pCtx->msrSTAR & MSR_K6_STAR_SYSCALL_EIP_MASK;
    3990         pCtx->rflags.u     &= ~(X86_EFL_VM | X86_EFL_IF | X86_EFL_RF);
    3991 
    3992         pCtx->cs.Attr.u     = X86DESCATTR_P | X86DESCATTR_G | X86DESCATTR_D | X86DESCATTR_DT | X86_SEL_TYPE_ER_ACC;
    3993         pCtx->ss.Attr.u     = X86DESCATTR_P | X86DESCATTR_G | X86DESCATTR_D | X86DESCATTR_DT | X86_SEL_TYPE_RW_ACC;
    3994     }
    3995     pCtx->cs.Sel        = uNewCs;
    3996     pCtx->cs.ValidSel   = uNewCs;
    3997     pCtx->cs.u64Base    = 0;
    3998     pCtx->cs.u32Limit   = UINT32_MAX;
    3999     pCtx->cs.fFlags     = CPUMSELREG_FLAGS_VALID;
    4000 
    4001     pCtx->ss.Sel        = uNewSs;
    4002     pCtx->ss.ValidSel   = uNewSs;
    4003     pCtx->ss.u64Base    = 0;
    4004     pCtx->ss.u32Limit   = UINT32_MAX;
    4005     pCtx->ss.fFlags     = CPUMSELREG_FLAGS_VALID;
     3950             pVCpu->cpum.GstCtx.cs, pVCpu->cpum.GstCtx.eip, pVCpu->cpum.GstCtx.eflags.u, uNewCs, (uint32_t)(pVCpu->cpum.GstCtx.msrSTAR & MSR_K6_STAR_SYSCALL_EIP_MASK)));
     3951        pVCpu->cpum.GstCtx.rcx           = pVCpu->cpum.GstCtx.eip + cbInstr;
     3952        pVCpu->cpum.GstCtx.rip           = pVCpu->cpum.GstCtx.msrSTAR & MSR_K6_STAR_SYSCALL_EIP_MASK;
     3953        pVCpu->cpum.GstCtx.rflags.u     &= ~(X86_EFL_VM | X86_EFL_IF | X86_EFL_RF);
     3954
     3955        pVCpu->cpum.GstCtx.cs.Attr.u     = X86DESCATTR_P | X86DESCATTR_G | X86DESCATTR_D | X86DESCATTR_DT | X86_SEL_TYPE_ER_ACC;
     3956        pVCpu->cpum.GstCtx.ss.Attr.u     = X86DESCATTR_P | X86DESCATTR_G | X86DESCATTR_D | X86DESCATTR_DT | X86_SEL_TYPE_RW_ACC;
     3957    }
     3958    pVCpu->cpum.GstCtx.cs.Sel        = uNewCs;
     3959    pVCpu->cpum.GstCtx.cs.ValidSel   = uNewCs;
     3960    pVCpu->cpum.GstCtx.cs.u64Base    = 0;
     3961    pVCpu->cpum.GstCtx.cs.u32Limit   = UINT32_MAX;
     3962    pVCpu->cpum.GstCtx.cs.fFlags     = CPUMSELREG_FLAGS_VALID;
     3963
     3964    pVCpu->cpum.GstCtx.ss.Sel        = uNewSs;
     3965    pVCpu->cpum.GstCtx.ss.ValidSel   = uNewSs;
     3966    pVCpu->cpum.GstCtx.ss.u64Base    = 0;
     3967    pVCpu->cpum.GstCtx.ss.u32Limit   = UINT32_MAX;
     3968    pVCpu->cpum.GstCtx.ss.fFlags     = CPUMSELREG_FLAGS_VALID;
    40063969
    40073970    /* Flush the prefetch buffer. */
    … …  
    40233986{
    40243987    RT_NOREF_PV(cbInstr);
    4025     PCPUMCTX pCtx = IEM_GET_CTX(pVCpu);
    40263988
    40273989    /*
    … …  
    40323994     * hardware.
    40333995     */
    4034     if (!(pCtx->msrEFER & MSR_K6_EFER_SCE))
     3996    if (!(pVCpu->cpum.GstCtx.msrEFER & MSR_K6_EFER_SCE))
    40353997    {
    40363998        Log(("sysret: Not enabled in EFER -> #UD\n"));
    40373999        return iemRaiseUndefinedOpcode(pVCpu);
    40384000    }
    4039     if (IEM_IS_GUEST_CPU_INTEL(pVCpu) && !CPUMIsGuestInLongModeEx(pCtx))
     4001    if (IEM_IS_GUEST_CPU_INTEL(pVCpu) && !CPUMIsGuestInLongModeEx(IEM_GET_CTX(pVCpu)))
    40404002    {
    40414003        Log(("sysret: Only available in long mode on intel -> #UD\n"));
    40424004        return iemRaiseUndefinedOpcode(pVCpu);
    40434005    }
    4044     if (!(pCtx->cr0 & X86_CR0_PE))
     4006    if (!(pVCpu->cpum.GstCtx.cr0 & X86_CR0_PE))
    40454007    {
    40464008        Log(("sysret: Protected mode is required -> #GP(0)\n"));
    … …  
    40534015    }
    40544016
    4055     IEM_CTX_IMPORT_RET(pVCpu, pCtx, CPUMCTX_EXTRN_SYSCALL_MSRS);
     4017    IEM_CTX_IMPORT_RET(pVCpu, CPUMCTX_EXTRN_SYSCALL_MSRS);
    40564018
    40574019    /** @todo Does SYSRET verify CS != 0 and SS != 0? Neither is valid in ring-3. */
    4058     uint16_t uNewCs = (pCtx->msrSTAR >> MSR_K6_STAR_SYSRET_CS_SS_SHIFT) & X86_SEL_MASK_OFF_RPL;
     4020    uint16_t uNewCs = (pVCpu->cpum.GstCtx.msrSTAR >> MSR_K6_STAR_SYSRET_CS_SS_SHIFT) & X86_SEL_MASK_OFF_RPL;
    40594021    uint16_t uNewSs = uNewCs + 8;
    40604022    if (pVCpu->iem.s.enmEffOpSize == IEMMODE_64BIT)
    … …  
    40694031     * Commit it.
    40704032     */
    4071     if (CPUMIsGuestInLongModeEx(pCtx))
     4033    if (CPUMIsGuestInLongModeEx(IEM_GET_CTX(pVCpu)))
    40724034    {
    40734035        if (pVCpu->iem.s.enmEffOpSize == IEMMODE_64BIT)
    40744036        {
    40754037            Log(("sysret: %04x:%016RX64 [efl=%#llx] -> %04x:%016RX64 [r11=%#llx]\n",
    4076                  pCtx->cs, pCtx->rip, pCtx->rflags.u, uNewCs, pCtx->rcx, pCtx->r11));
     4038                 pVCpu->cpum.GstCtx.cs, pVCpu->cpum.GstCtx.rip, pVCpu->cpum.GstCtx.rflags.u, uNewCs, pVCpu->cpum.GstCtx.rcx, pVCpu->cpum.GstCtx.r11));
    40774039            /* Note! We disregard intel manual regarding the RCX cananonical
    40784040                     check, ask intel+xen why AMD doesn't do it. */
    4079             pCtx->rip       = pCtx->rcx;
    4080             pCtx->cs.Attr.u = X86DESCATTR_P | X86DESCATTR_G | X86DESCATTR_L | X86DESCATTR_DT | X86_SEL_TYPE_ER_ACC
     4041            pVCpu->cpum.GstCtx.rip       = pVCpu->cpum.GstCtx.rcx;
     4042            pVCpu->cpum.GstCtx.cs.Attr.u = X86DESCATTR_P | X86DESCATTR_G | X86DESCATTR_L | X86DESCATTR_DT | X86_SEL_TYPE_ER_ACC
    40814043                            | (3 << X86DESCATTR_DPL_SHIFT);
    40824044        }
    … …  
    40844046        {
    40854047            Log(("sysret: %04x:%016RX64 [efl=%#llx] -> %04x:%08RX32 [r11=%#llx]\n",
    4086                  pCtx->cs, pCtx->rip, pCtx->rflags.u, uNewCs, pCtx->ecx, pCtx->r11));
    4087             pCtx->rip       = pCtx->ecx;
    4088             pCtx->cs.Attr.u = X86DESCATTR_P | X86DESCATTR_G | X86DESCATTR_D | X86DESCATTR_DT | X86_SEL_TYPE_ER_ACC
     4048                 pVCpu->cpum.GstCtx.cs, pVCpu->cpum.GstCtx.rip, pVCpu->cpum.GstCtx.rflags.u, uNewCs, pVCpu->cpum.GstCtx.ecx, pVCpu->cpum.GstCtx.r11));
     4049            pVCpu->cpum.GstCtx.rip       = pVCpu->cpum.GstCtx.ecx;
     4050            pVCpu->cpum.GstCtx.cs.Attr.u = X86DESCATTR_P | X86DESCATTR_G | X86DESCATTR_D | X86DESCATTR_DT | X86_SEL_TYPE_ER_ACC
    40894051                            | (3 << X86DESCATTR_DPL_SHIFT);
    40904052        }
    40914053        /** @todo testcase: See what kind of flags we can make SYSRET restore and
    40924054         *        what it really ignores. RF and VM are hinted at being zero, by AMD. */
    4093         pCtx->rflags.u      = pCtx->r11 & (X86_EFL_POPF_BITS | X86_EFL_VIF | X86_EFL_VIP);
    4094         pCtx->rflags.u     |= X86_EFL_1;
     4055        pVCpu->cpum.GstCtx.rflags.u      = pVCpu->cpum.GstCtx.r11 & (X86_EFL_POPF_BITS | X86_EFL_VIF | X86_EFL_VIP);
     4056        pVCpu->cpum.GstCtx.rflags.u     |= X86_EFL_1;
    40954057    }
    40964058    else
    40974059    {
    4098         Log(("sysret: %04x:%08RX32 [efl=%#x] -> %04x:%08RX32\n", pCtx->cs, pCtx->eip, pCtx->eflags.u, uNewCs, pCtx->ecx));
    4099         pCtx->rip           = pCtx->rcx;
    4100         pCtx->rflags.u     |= X86_EFL_IF;
    4101         pCtx->cs.Attr.u     = X86DESCATTR_P | X86DESCATTR_G | X86DESCATTR_D | X86DESCATTR_DT | X86_SEL_TYPE_ER_ACC
     4060        Log(("sysret: %04x:%08RX32 [efl=%#x] -> %04x:%08RX32\n", pVCpu->cpum.GstCtx.cs, pVCpu->cpum.GstCtx.eip, pVCpu->cpum.GstCtx.eflags.u, uNewCs, pVCpu->cpum.GstCtx.ecx));
     4061        pVCpu->cpum.GstCtx.rip           = pVCpu->cpum.GstCtx.rcx;
     4062        pVCpu->cpum.GstCtx.rflags.u     |= X86_EFL_IF;
     4063        pVCpu->cpum.GstCtx.cs.Attr.u     = X86DESCATTR_P | X86DESCATTR_G | X86DESCATTR_D | X86DESCATTR_DT | X86_SEL_TYPE_ER_ACC
    41024064                            | (3 << X86DESCATTR_DPL_SHIFT);
    41034065    }
    4104     pCtx->cs.Sel        = uNewCs | 3;
    4105     pCtx->cs.ValidSel   = uNewCs | 3;
    4106     pCtx->cs.u64Base    = 0;
    4107     pCtx->cs.u32Limit   = UINT32_MAX;
    4108     pCtx->cs.fFlags     = CPUMSELREG_FLAGS_VALID;
    4109 
    4110     pCtx->ss.Sel        = uNewSs | 3;
    4111     pCtx->ss.ValidSel   = uNewSs | 3;
    4112     pCtx->ss.fFlags     = CPUMSELREG_FLAGS_VALID;
     4066    pVCpu->cpum.GstCtx.cs.Sel        = uNewCs | 3;
     4067    pVCpu->cpum.GstCtx.cs.ValidSel   = uNewCs | 3;
     4068    pVCpu->cpum.GstCtx.cs.u64Base    = 0;
     4069    pVCpu->cpum.GstCtx.cs.u32Limit   = UINT32_MAX;
     4070    pVCpu->cpum.GstCtx.cs.fFlags     = CPUMSELREG_FLAGS_VALID;
     4071
     4072    pVCpu->cpum.GstCtx.ss.Sel        = uNewSs | 3;
     4073    pVCpu->cpum.GstCtx.ss.ValidSel   = uNewSs | 3;
     4074    pVCpu->cpum.GstCtx.ss.fFlags     = CPUMSELREG_FLAGS_VALID;
    41134075    /* The SS hidden bits remains unchanged says AMD. To that I say "Yeah, right!". */
    4114     pCtx->ss.Attr.u    |= (3 << X86DESCATTR_DPL_SHIFT);
     4076    pVCpu->cpum.GstCtx.ss.Attr.u    |= (3 << X86DESCATTR_DPL_SHIFT);
    41154077    /** @todo Testcase: verify that SS.u1Long and SS.u1DefBig are left unchanged
    41164078     *        on sysret. */
    … …  
    41354097IEM_CIMPL_DEF_2(iemCImpl_LoadSReg, uint8_t, iSegReg, uint16_t, uSel)
    41364098{
    4137     PCPUMCTX        pCtx = IEM_GET_CTX(pVCpu);
    4138     IEM_CTX_IMPORT_RET(pVCpu, pCtx, CPUMCTX_EXTRN_SREG_FROM_IDX(iSegReg));
     4099    IEM_CTX_IMPORT_RET(pVCpu, CPUMCTX_EXTRN_SREG_FROM_IDX(iSegReg));
    41394100    uint16_t       *pSel = iemSRegRef(pVCpu, iSegReg);
    41404101    PCPUMSELREGHID  pHid = iemSRegGetHid(pVCpu, iSegReg);
    … …  
    43244285    {
    43254286        if (iSegReg == X86_SREG_SS)
    4326         {
    4327             PCPUMCTX pCtx = IEM_GET_CTX(pVCpu);
    4328             EMSetInhibitInterruptsPC(pVCpu, pCtx->rip);
    4329         }
     4287            EMSetInhibitInterruptsPC(pVCpu, pVCpu->cpum.GstCtx.rip);
    43304288    }
    43314289    return rcStrict;
    … …  
    43414299IEM_CIMPL_DEF_2(iemCImpl_pop_Sreg, uint8_t, iSegReg, IEMMODE, enmEffOpSize)
    43424300{
    4343     PCPUMCTX        pCtx = IEM_GET_CTX(pVCpu);
    43444301    VBOXSTRICTRC    rcStrict;
    43454302
    … …  
    43484305     */
    43494306    RTUINT64U TmpRsp;
    4350     TmpRsp.u = pCtx->rsp;
     4307    TmpRsp.u = pVCpu->cpum.GstCtx.rsp;
    43514308    switch (enmEffOpSize)
    43524309    {
    … …  
    43854342    if (rcStrict == VINF_SUCCESS)
    43864343    {
    4387         pCtx->rsp = TmpRsp.u;
     4344        pVCpu->cpum.GstCtx.rsp = TmpRsp.u;
    43884345        if (iSegReg == X86_SREG_SS)
    4389             EMSetInhibitInterruptsPC(pVCpu, pCtx->rip);
     4346            EMSetInhibitInterruptsPC(pVCpu, pVCpu->cpum.GstCtx.rip);
    43904347    }
    43914348    return rcStrict;
    … …  
    44034360                IEMMODE,  enmEffOpSize)
    44044361{
    4405     /*PCPUMCTX        pCtx = IEM_GET_CTX(pVCpu);*/
    4406     VBOXSTRICTRC    rcStrict;
    4407 
    44084362    /*
    44094363     * Use iemCImpl_LoadSReg to do the tricky segment register loading.
    … …  
    44114365    /** @todo verify and test that mov, pop and lXs works the segment
    44124366     *        register loading in the exact same way. */
    4413     rcStrict = IEM_CIMPL_CALL_2(iemCImpl_LoadSReg, iSegReg, uSel);
     4367    VBOXSTRICTRC rcStrict = IEM_CIMPL_CALL_2(iemCImpl_LoadSReg, iSegReg, uSel);
    44144368    if (rcStrict == VINF_SUCCESS)
    44154369    {
    … …  
    44544408
    44554409    /* Within the table limits? */
    4456     PCPUMCTX pCtx = IEM_GET_CTX(pVCpu);
    44574410    RTGCPTR GCPtrBase;
    44584411    if (uSel & X86_SEL_LDT)
    44594412    {
    4460         IEM_CTX_IMPORT_RET(pVCpu, pCtx, CPUMCTX_EXTRN_LDTR);
    4461         if (   !pCtx->ldtr.Attr.n.u1Present
    4462             || (uSel | X86_SEL_RPL_LDT) > pCtx->ldtr.u32Limit )
     4413        IEM_CTX_IMPORT_RET(pVCpu, CPUMCTX_EXTRN_LDTR);
     4414        if (   !pVCpu->cpum.GstCtx.ldtr.Attr.n.u1Present
     4415            || (uSel | X86_SEL_RPL_LDT) > pVCpu->cpum.GstCtx.ldtr.u32Limit )
    44634416            return VINF_IEM_SELECTOR_NOT_OK;
    4464         GCPtrBase = pCtx->ldtr.u64Base;
     4417        GCPtrBase = pVCpu->cpum.GstCtx.ldtr.u64Base;
    44654418    }
    44664419    else
    44674420    {
    4468         IEM_CTX_IMPORT_RET(pVCpu, pCtx, CPUMCTX_EXTRN_GDTR);
    4469         if ((uSel | X86_SEL_RPL_LDT) > pCtx->gdtr.cbGdt)
     4421        IEM_CTX_IMPORT_RET(pVCpu, CPUMCTX_EXTRN_GDTR);
     4422        if ((uSel | X86_SEL_RPL_LDT) > pVCpu->cpum.GstCtx.gdtr.cbGdt)
    44704423            return VINF_IEM_SELECTOR_NOT_OK;
    4471         GCPtrBase = pCtx->gdtr.pGdt;
     4424        GCPtrBase = pVCpu->cpum.GstCtx.gdtr.pGdt;
    44724425    }
    44734426
    … …  
    44804433        if (!fAllowSysDesc)
    44814434            return VINF_IEM_SELECTOR_NOT_OK;
    4482         if (CPUMIsGuestInLongModeEx(pCtx))
     4435        if (CPUMIsGuestInLongModeEx(IEM_GET_CTX(pVCpu)))
    44834436        {
    44844437            rcStrict = iemMemFetchSysU64(pVCpu, &pDesc->Long.au64[1], UINT8_MAX, GCPtrBase + (uSel & X86_SEL_MASK) + 8);
    … …  
    47314684    }
    47324685
    4733     PCPUMCTX pCtx = IEM_GET_CTX(pVCpu);
    4734     IEM_CTX_IMPORT_RET(pVCpu, pCtx, CPUMCTX_EXTRN_GDTR);
    4735     VBOXSTRICTRC rcStrict = iemMemStoreDataXdtr(pVCpu, pCtx->gdtr.cbGdt, pCtx->gdtr.pGdt, iEffSeg, GCPtrEffDst);
     4686    IEM_CTX_IMPORT_RET(pVCpu, CPUMCTX_EXTRN_GDTR);
     4687    VBOXSTRICTRC rcStrict = iemMemStoreDataXdtr(pVCpu, pVCpu->cpum.GstCtx.gdtr.cbGdt, pVCpu->cpum.GstCtx.gdtr.pGdt, iEffSeg, GCPtrEffDst);
    47364688    if (rcStrict == VINF_SUCCESS)
    47374689        iemRegAddToRipAndClearRF(pVCpu, cbInstr);
    … …  
    48044756    }
    48054757
    4806     PCPUMCTX pCtx = IEM_GET_CTX(pVCpu);
    4807     IEM_CTX_IMPORT_RET(pVCpu, pCtx, CPUMCTX_EXTRN_IDTR);
    4808     VBOXSTRICTRC rcStrict = iemMemStoreDataXdtr(pVCpu, pCtx->idtr.cbIdt, pCtx->idtr.pIdt, iEffSeg, GCPtrEffDst);
     4758    IEM_CTX_IMPORT_RET(pVCpu, CPUMCTX_EXTRN_IDTR);
     4759    VBOXSTRICTRC rcStrict = iemMemStoreDataXdtr(pVCpu, pVCpu->cpum.GstCtx.idtr.cbIdt, pVCpu->cpum.GstCtx.idtr.pIdt, iEffSeg, GCPtrEffDst);
    48094760    if (rcStrict == VINF_SUCCESS)
    48104761        iemRegAddToRipAndClearRF(pVCpu, cbInstr);
    … …  
    48204771IEM_CIMPL_DEF_1(iemCImpl_lldt, uint16_t, uNewLdt)
    48214772{
    4822     PCPUMCTX pCtx = IEM_GET_CTX(pVCpu);
    4823 
    48244773    /*
    48254774     * Check preconditions.
    … …  
    48554804
    48564805        Log(("lldt %04x: Loading NULL selector.\n", uNewLdt));
    4857         pCtx->fExtrn &= ~CPUMCTX_EXTRN_LDTR;
     4806        pVCpu->cpum.GstCtx.fExtrn &= ~CPUMCTX_EXTRN_LDTR;
    48584807        CPUMSetGuestLDTR(pVCpu, uNewLdt);
    4859         pCtx->ldtr.ValidSel = uNewLdt;
    4860         pCtx->ldtr.fFlags   = CPUMSELREG_FLAGS_VALID;
     4808        pVCpu->cpum.GstCtx.ldtr.ValidSel = uNewLdt;
     4809        pVCpu->cpum.GstCtx.ldtr.fFlags   = CPUMSELREG_FLAGS_VALID;
    48614810        if (IEM_IS_GUEST_CPU_AMD(pVCpu))
    48624811        {
    48634812            /* AMD-V seems to leave the base and limit alone. */
    4864             pCtx->ldtr.Attr.u = X86DESCATTR_UNUSABLE;
     4813            pVCpu->cpum.GstCtx.ldtr.Attr.u = X86DESCATTR_UNUSABLE;
    48654814        }
    48664815        else
    48674816        {
    48684817            /* VT-x (Intel 3960x) seems to be doing the following. */
    4869             pCtx->ldtr.Attr.u   = X86DESCATTR_UNUSABLE | X86DESCATTR_G | X86DESCATTR_D;
    4870             pCtx->ldtr.u64Base  = 0;
    4871             pCtx->ldtr.u32Limit = UINT32_MAX;
     4818            pVCpu->cpum.GstCtx.ldtr.Attr.u   = X86DESCATTR_UNUSABLE | X86DESCATTR_G | X86DESCATTR_D;
     4819            pVCpu->cpum.GstCtx.ldtr.u64Base  = 0;
     4820            pVCpu->cpum.GstCtx.ldtr.u32Limit = UINT32_MAX;
    48724821        }
    48734822
    … …  
    48794828     * Read the descriptor.
    48804829     */
    4881     IEM_CTX_IMPORT_RET(pVCpu, pCtx, CPUMCTX_EXTRN_LDTR | CPUMCTX_EXTRN_GDTR);
     4830    IEM_CTX_IMPORT_RET(pVCpu, CPUMCTX_EXTRN_LDTR | CPUMCTX_EXTRN_GDTR);
    48824831    IEMSELDESC Desc;
    48834832    VBOXSTRICTRC rcStrict = iemMemFetchSelDesc(pVCpu, &Desc, uNewLdt, X86_XCPT_GP); /** @todo Correct exception? */
    … …  
    49354884/** @todo check if the actual value is loaded or if the RPL is dropped */
    49364885    CPUMSetGuestLDTR(pVCpu, uNewLdt & X86_SEL_MASK_OFF_RPL);
    4937     pCtx->ldtr.ValidSel = uNewLdt & X86_SEL_MASK_OFF_RPL;
    4938     pCtx->ldtr.fFlags   = CPUMSELREG_FLAGS_VALID;
    4939     pCtx->ldtr.Attr.u   = X86DESC_GET_HID_ATTR(&Desc.Legacy);
    4940     pCtx->ldtr.u32Limit = X86DESC_LIMIT_G(&Desc.Legacy);
    4941     pCtx->ldtr.u64Base  = u64Base;
     4886    pVCpu->cpum.GstCtx.ldtr.ValidSel = uNewLdt & X86_SEL_MASK_OFF_RPL;
     4887    pVCpu->cpum.GstCtx.ldtr.fFlags   = CPUMSELREG_FLAGS_VALID;
     4888    pVCpu->cpum.GstCtx.ldtr.Attr.u   = X86DESC_GET_HID_ATTR(&Desc.Legacy);
     4889    pVCpu->cpum.GstCtx.ldtr.u32Limit = X86DESC_LIMIT_G(&Desc.Legacy);
     4890    pVCpu->cpum.GstCtx.ldtr.u64Base  = u64Base;
    49424891
    49434892    iemRegAddToRipAndClearRF(pVCpu, cbInstr);
    … …  
    49534902IEM_CIMPL_DEF_1(iemCImpl_ltr, uint16_t, uNewTr)
    49544903{
    4955     PCPUMCTX pCtx = IEM_GET_CTX(pVCpu);
    4956 
    49574904    /*
    49584905     * Check preconditions.
    … …  
    49884935     * Read the descriptor.
    49894936     */
    4990     IEM_CTX_IMPORT_RET(pVCpu, pCtx, CPUMCTX_EXTRN_LDTR | CPUMCTX_EXTRN_GDTR | CPUMCTX_EXTRN_TR);
     4937    IEM_CTX_IMPORT_RET(pVCpu, CPUMCTX_EXTRN_LDTR | CPUMCTX_EXTRN_GDTR | CPUMCTX_EXTRN_TR);
    49914938    IEMSELDESC Desc;
    49924939    VBOXSTRICTRC rcStrict = iemMemFetchSelDesc(pVCpu, &Desc, uNewTr, X86_XCPT_GP); /** @todo Correct exception? */
    … …  
    50404987     */
    50414988    void *pvDesc;
    5042     rcStrict = iemMemMap(pVCpu, &pvDesc, 8, UINT8_MAX, pCtx->gdtr.pGdt + (uNewTr & X86_SEL_MASK_OFF_RPL), IEM_ACCESS_DATA_RW);
     4989    rcStrict = iemMemMap(pVCpu, &pvDesc, 8, UINT8_MAX, pVCpu->cpum.GstCtx.gdtr.pGdt + (uNewTr & X86_SEL_MASK_OFF_RPL), IEM_ACCESS_DATA_RW);
    50434990    if (rcStrict != VINF_SUCCESS)
    50444991        return rcStrict;
    … …  
    50605007/** @todo check if the actual value is loaded or if the RPL is dropped */
    50615008    CPUMSetGuestTR(pVCpu, uNewTr & X86_SEL_MASK_OFF_RPL);
    5062     pCtx->tr.ValidSel = uNewTr & X86_SEL_MASK_OFF_RPL;
    5063     pCtx->tr.fFlags   = CPUMSELREG_FLAGS_VALID;
    5064     pCtx->tr.Attr.u   = X86DESC_GET_HID_ATTR(&Desc.Legacy);
    5065     pCtx->tr.u32Limit = X86DESC_LIMIT_G(&Desc.Legacy);
    5066     pCtx->tr.u64Base  = u64Base;
     5009    pVCpu->cpum.GstCtx.tr.ValidSel = uNewTr & X86_SEL_MASK_OFF_RPL;
     5010    pVCpu->cpum.GstCtx.tr.fFlags   = CPUMSELREG_FLAGS_VALID;
     5011    pVCpu->cpum.GstCtx.tr.Attr.u   = X86DESC_GET_HID_ATTR(&Desc.Legacy);
     5012    pVCpu->cpum.GstCtx.tr.u32Limit = X86DESC_LIMIT_G(&Desc.Legacy);
     5013    pVCpu->cpum.GstCtx.tr.u64Base  = u64Base;
    50675014
    50685015    iemRegAddToRipAndClearRF(pVCpu, cbInstr);
    … …  
    50795026IEM_CIMPL_DEF_2(iemCImpl_mov_Rd_Cd, uint8_t, iGReg, uint8_t, iCrReg)
    50805027{
    5081     PCPUMCTX pCtx = IEM_GET_CTX(pVCpu);
    50825028    if (pVCpu->iem.s.uCpl != 0)
    50835029        return iemRaiseGeneralProtectionFault0(pVCpu);
    5084     Assert(!pCtx->eflags.Bits.u1VM);
     5030    Assert(!pVCpu->cpum.GstCtx.eflags.Bits.u1VM);
    50855031
    50865032    if (IEM_IS_SVM_READ_CR_INTERCEPT_SET(pVCpu, iCrReg))
    … …  
    50965042    {
    50975043        case 0:
    5098             IEM_CTX_ASSERT(pCtx, CPUMCTX_EXTRN_CR0);
    5099             crX = pCtx->cr0;
     5044            IEM_CTX_ASSERT(pVCpu, CPUMCTX_EXTRN_CR0);
     5045            crX = pVCpu->cpum.GstCtx.cr0;
    51005046            if (IEM_GET_TARGET_CPU(pVCpu) <= IEMTARGETCPU_386)
    51015047                crX |= UINT32_C(0x7fffffe0); /* All reserved CR0 flags are set on a 386, just like MSW on 286. */
    51025048            break;
    51035049        case 2:
    5104             IEM_CTX_IMPORT_RET(pVCpu, pCtx, CPUMCTX_EXTRN_CR2);
    5105             crX = pCtx->cr2;
     5050            IEM_CTX_IMPORT_RET(pVCpu, CPUMCTX_EXTRN_CR2);
     5051            crX = pVCpu->cpum.GstCtx.cr2;
    51065052            break;
    51075053        case 3:
    5108             IEM_CTX_ASSERT(pCtx, CPUMCTX_EXTRN_CR3);
    5109             crX = pCtx->cr3;
     5054            IEM_CTX_ASSERT(pVCpu, CPUMCTX_EXTRN_CR3);
     5055            crX = pVCpu->cpum.GstCtx.cr3;
    51105056            break;
    51115057        case 4:
    5112             IEM_CTX_ASSERT(pCtx, CPUMCTX_EXTRN_CR4);
    5113             crX = pCtx->cr4;
     5058            IEM_CTX_ASSERT(pVCpu, CPUMCTX_EXTRN_CR4);
     5059            crX = pVCpu->cpum.GstCtx.cr4;
    51145060            break;
    51155061        case 8:
    51165062        {
    5117             IEM_CTX_ASSERT(pCtx, CPUMCTX_EXTRN_APIC_TPR);
     5063            IEM_CTX_ASSERT(pVCpu, CPUMCTX_EXTRN_APIC_TPR);
    51185064#ifdef VBOX_WITH_NESTED_HWVIRT_SVM
    5119             if (CPUMIsGuestInSvmNestedHwVirtMode(pCtx))
    5120             {
    5121                 PCSVMVMCBCTRL pVmcbCtrl = &pCtx->hwvirt.svm.CTX_SUFF(pVmcb)->ctrl;
    5122                 if (CPUMIsGuestSvmVirtIntrMasking(pVCpu, pCtx))
     5065            if (CPUMIsGuestInSvmNestedHwVirtMode(IEM_GET_CTX(pVCpu)))
     5066            {
     5067                PCSVMVMCBCTRL pVmcbCtrl = &pVCpu->cpum.GstCtx.hwvirt.svm.CTX_SUFF(pVmcb)->ctrl;
     5068                if (CPUMIsGuestSvmVirtIntrMasking(pVCpu, IEM_GET_CTX(pVCpu)))
    51235069                {
    51245070                    crX = pVmcbCtrl->IntCtrl.n.u8VTPR & 0xf;
    … …  
    51605106IEM_CIMPL_DEF_4(iemCImpl_load_CrX, uint8_t, iCrReg, uint64_t, uNewCrX, IEMACCESSCRX, enmAccessCrX, uint8_t, iGReg)
    51615107{
    5162     PCPUMCTX        pCtx  = IEM_GET_CTX(pVCpu);
    51635108    VBOXSTRICTRC    rcStrict;
    51645109    int             rc;
    … …  
    51785123             * Perform checks.
    51795124             */
    5180             IEM_CTX_ASSERT(pCtx, CPUMCTX_EXTRN_CR0);
    5181             pCtx->fExtrn &= ~CPUMCTX_EXTRN_LDTR;
    5182 
    5183             uint64_t const uOldCrX = pCtx->cr0;
     5125            IEM_CTX_ASSERT(pVCpu, CPUMCTX_EXTRN_CR0);
     5126            pVCpu->cpum.GstCtx.fExtrn &= ~CPUMCTX_EXTRN_LDTR;
     5127
     5128            uint64_t const uOldCrX = pVCpu->cpum.GstCtx.cr0;
    51845129            uint32_t const fValid  = X86_CR0_PE | X86_CR0_MP | X86_CR0_EM | X86_CR0_TS
    51855130                                   | X86_CR0_ET | X86_CR0_NE | X86_CR0_WP | X86_CR0_AM
    … …  
    52215166
    52225167            if (   !(uNewCrX & X86_CR0_PG)
    5223                 && (pCtx->cr4 & X86_CR4_PCIDE))
     5168                && (pVCpu->cpum.GstCtx.cr4 & X86_CR4_PCIDE))
    52245169            {
    52255170                Log(("Trying to clear CR0.PG while leaving CR4.PCID set\n"));
    … …  
    52305175            if (    (uNewCrX & X86_CR0_PG)
    52315176                && !(uOldCrX & X86_CR0_PG)
    5232                 &&  (pCtx->msrEFER & MSR_K6_EFER_LME) )
    5233             {
    5234                 if (!(pCtx->cr4 & X86_CR4_PAE))
     5177                &&  (pVCpu->cpum.GstCtx.msrEFER & MSR_K6_EFER_LME) )
     5178            {
     5179                if (!(pVCpu->cpum.GstCtx.cr4 & X86_CR4_PAE))
    52355180                {
    52365181                    Log(("Trying to enabled long mode paging without CR4.PAE set\n"));
    52375182                    return iemRaiseGeneralProtectionFault0(pVCpu);
    52385183                }
    5239                 if (pCtx->cs.Attr.n.u1Long)
     5184                if (pVCpu->cpum.GstCtx.cs.Attr.n.u1Long)
    52405185                {
    52415186                    Log(("Trying to enabled long mode paging with a long CS descriptor loaded.\n"));
    … …  
    52725217             */
    52735218            CPUMSetGuestCR0(pVCpu, uNewCrX);
    5274             Assert(pCtx->cr0 == uNewCrX);
     5219            Assert(pVCpu->cpum.GstCtx.cr0 == uNewCrX);
    52755220
    52765221            /*
    … …  
    52785223             */
    52795224            if (   (uNewCrX & X86_CR0_PG) != (uOldCrX & X86_CR0_PG)
    5280                 && (pCtx->msrEFER & MSR_K6_EFER_LME) )
    5281             {
    5282                 uint64_t NewEFER = pCtx->msrEFER;
     5225                && (pVCpu->cpum.GstCtx.msrEFER & MSR_K6_EFER_LME) )
     5226            {
     5227                uint64_t NewEFER = pVCpu->cpum.GstCtx.msrEFER;
    52835228                if (uNewCrX & X86_CR0_PG)
    52845229                    NewEFER |= MSR_K6_EFER_LMA;
    … …  
    52875232
    52885233                CPUMSetGuestEFER(pVCpu, NewEFER);
    5289                 Assert(pCtx->msrEFER == NewEFER);
     5234                Assert(pVCpu->cpum.GstCtx.msrEFER == NewEFER);
    52905235            }
    52915236
    … …  
    52965241                !=  (uOldCrX & (X86_CR0_PG | X86_CR0_WP | X86_CR0_PE)) )
    52975242            {
    5298                 rc = PGMFlushTLB(pVCpu, pCtx->cr3, true /* global */);
     5243                rc = PGMFlushTLB(pVCpu, pVCpu->cpum.GstCtx.cr3, true /* global */);
    52995244                AssertRCReturn(rc, rc);
    53005245                /* ignore informational status codes */
    53015246            }
    5302             rcStrict = PGMChangeMode(pVCpu, pCtx->cr0, pCtx->cr4, pCtx->msrEFER);
     5247            rcStrict = PGMChangeMode(pVCpu, pVCpu->cpum.GstCtx.cr0, pVCpu->cpum.GstCtx.cr4, pVCpu->cpum.GstCtx.msrEFER);
    53035248
    53045249#ifdef IN_RC
    … …  
    53235268                IEM_RETURN_SVM_CRX_VMEXIT(pVCpu, SVM_EXIT_WRITE_CR2, enmAccessCrX, iGReg);
    53245269            }
    5325             pCtx->cr2 = uNewCrX;
    5326             pCtx->fExtrn &= ~CPUMCTX_EXTRN_CR2;
     5270            pVCpu->cpum.GstCtx.cr2 = uNewCrX;
     5271            pVCpu->cpum.GstCtx.fExtrn &= ~CPUMCTX_EXTRN_CR2;
    53275272            rcStrict  = VINF_SUCCESS;
    53285273            break;
    … …  
    53405285        case 3:
    53415286        {
    5342             IEM_CTX_ASSERT(pCtx, CPUMCTX_EXTRN_CR3);
     5287            IEM_CTX_ASSERT(pVCpu, CPUMCTX_EXTRN_CR3);
    53435288
    53445289            /* clear bit 63 from the source operand and indicate no invalidations are required. */
    5345             if (   (pCtx->cr4 & X86_CR4_PCIDE)
     5290            if (   (pVCpu->cpum.GstCtx.cr4 & X86_CR4_PCIDE)
    53465291                && (uNewCrX & RT_BIT_64(63)))
    53475292            {
    … …  
    53615306
    53625307            uint64_t fValid;
    5363             if (   (pCtx->cr4 & X86_CR4_PAE)
    5364                 && (pCtx->msrEFER & MSR_K6_EFER_LME))
     5308            if (   (pVCpu->cpum.GstCtx.cr4 & X86_CR4_PAE)
     5309                && (pVCpu->cpum.GstCtx.msrEFER & MSR_K6_EFER_LME))
    53655310                fValid = UINT64_C(0x000fffffffffffff);
    53665311            else
    … …  
    53885333
    53895334            /* Inform PGM. */
    5390             if (pCtx->cr0 & X86_CR0_PG)
    5391             {
    5392                 rc = PGMFlushTLB(pVCpu, pCtx->cr3, !(pCtx->cr4 & X86_CR4_PGE));
     5335            if (pVCpu->cpum.GstCtx.cr0 & X86_CR0_PG)
     5336            {
     5337                rc = PGMFlushTLB(pVCpu, pVCpu->cpum.GstCtx.cr3, !(pVCpu->cpum.GstCtx.cr4 & X86_CR4_PGE));
    53935338                AssertRCReturn(rc, rc);
    53945339                /* ignore informational status codes */
    … …  
    54045349        case 4:
    54055350        {
    5406             IEM_CTX_ASSERT(pCtx, CPUMCTX_EXTRN_CR4);
    5407             uint64_t const uOldCrX = pCtx->cr4;
     5351            IEM_CTX_ASSERT(pVCpu, CPUMCTX_EXTRN_CR4);
     5352            uint64_t const uOldCrX = pVCpu->cpum.GstCtx.cr4;
    54085353
    54095354            /** @todo Shouldn't this look at the guest CPUID bits to determine
    … …  
    54325377
    54335378            bool const fPcide    = ((uNewCrX ^ uOldCrX) & X86_CR4_PCIDE) && (uNewCrX & X86_CR4_PCIDE);
    5434             bool const fLongMode = CPUMIsGuestInLongModeEx(pCtx);
     5379            bool const fLongMode = CPUMIsGuestInLongModeEx(IEM_GET_CTX(pVCpu));
    54355380
    54365381            /* PCIDE check. */
    54375382            if (   fPcide
    54385383                && (   !fLongMode
    5439                     || (pCtx->cr3 & UINT64_C(0xfff))))
    5440             {
    5441                 Log(("Trying to set PCIDE with invalid PCID or outside long mode. Pcid=%#x\n", (pCtx->cr3 & UINT64_C(0xfff))));
     5384                    || (pVCpu->cpum.GstCtx.cr3 & UINT64_C(0xfff))))
     5385            {
     5386                Log(("Trying to set PCIDE with invalid PCID or outside long mode. Pcid=%#x\n", (pVCpu->cpum.GstCtx.cr3 & UINT64_C(0xfff))));
    54425387                return iemRaiseGeneralProtectionFault0(pVCpu);
    54435388            }
    … …  
    54645409            rc = CPUMSetGuestCR4(pVCpu, uNewCrX);
    54655410            AssertRCSuccessReturn(rc, rc);
    5466             Assert(pCtx->cr4 == uNewCrX);
     5411            Assert(pVCpu->cpum.GstCtx.cr4 == uNewCrX);
    54675412
    54685413            /*
    … …  
    54835428            if ((uNewCrX ^ uOldCrX) & (X86_CR4_PSE | X86_CR4_PAE | X86_CR4_PGE | X86_CR4_PCIDE /* | X86_CR4_SMEP */))
    54845429            {
    5485                 rc = PGMFlushTLB(pVCpu, pCtx->cr3, true /* global */);
     5430                rc = PGMFlushTLB(pVCpu, pVCpu->cpum.GstCtx.cr3, true /* global */);
    54865431                AssertRCReturn(rc, rc);
    54875432                /* ignore informational status codes */
    54885433            }
    5489             rcStrict = PGMChangeMode(pVCpu, pCtx->cr0, pCtx->cr4, pCtx->msrEFER);
     5434            rcStrict = PGMChangeMode(pVCpu, pVCpu->cpum.GstCtx.cr0, pVCpu->cpum.GstCtx.cr4, pVCpu->cpum.GstCtx.msrEFER);
    54905435            break;
    54915436        }
    … …  
    54965441        case 8:
    54975442        {
    5498             IEM_CTX_ASSERT(pCtx, CPUMCTX_EXTRN_APIC_TPR);
     5443            IEM_CTX_ASSERT(pVCpu, CPUMCTX_EXTRN_APIC_TPR);
    54995444            if (uNewCrX & ~(uint64_t)0xf)
    55005445            {
    … …  
    55045449
    55055450#ifdef VBOX_WITH_NESTED_HWVIRT_SVM
    5506             if (CPUMIsGuestInSvmNestedHwVirtMode(pCtx))
     5451            if (CPUMIsGuestInSvmNestedHwVirtMode(IEM_GET_CTX(pVCpu)))
    55075452            {
    55085453                if (IEM_IS_SVM_WRITE_CR_INTERCEPT_SET(pVCpu, /*cr*/ 8))
    … …  
    55135458                }
    55145459
    5515                 PSVMVMCBCTRL pVmcbCtrl = &pCtx->hwvirt.svm.CTX_SUFF(pVmcb)->ctrl;
     5460                PSVMVMCBCTRL pVmcbCtrl = &pVCpu->cpum.GstCtx.hwvirt.svm.CTX_SUFF(pVmcb)->ctrl;
    55165461                pVmcbCtrl->IntCtrl.n.u8VTPR = uNewCrX;
    5517                 if (CPUMIsGuestSvmVirtIntrMasking(pVCpu, pCtx))
     5462                if (CPUMIsGuestSvmVirtIntrMasking(pVCpu, IEM_GET_CTX(pVCpu)))
    55185463                {
    55195464                    rcStrict = VINF_SUCCESS;
    … …  
    55765521IEM_CIMPL_DEF_1(iemCImpl_lmsw, uint16_t, u16NewMsw)
    55775522{
    5578     PCPUMCTX pCtx = IEM_GET_CTX(pVCpu);
    5579 
    55805523    if (pVCpu->iem.s.uCpl != 0)
    55815524        return iemRaiseGeneralProtectionFault0(pVCpu);
    5582     Assert(!pCtx->eflags.Bits.u1VM);
     5525    Assert(!pVCpu->cpum.GstCtx.eflags.Bits.u1VM);
    55835526
    55845527    /*
    55855528     * Compose the new CR0 value and call common worker.
    55865529     */
    5587     IEM_CTX_ASSERT(pCtx, CPUMCTX_EXTRN_CR0);
    5588     uint64_t uNewCr0 = pCtx->cr0     & ~(X86_CR0_MP | X86_CR0_EM | X86_CR0_TS);
     5530    IEM_CTX_ASSERT(pVCpu, CPUMCTX_EXTRN_CR0);
     5531    uint64_t uNewCr0 = pVCpu->cpum.GstCtx.cr0     & ~(X86_CR0_MP | X86_CR0_EM | X86_CR0_TS);
    55895532    uNewCr0 |= u16NewMsw & (X86_CR0_PE | X86_CR0_MP | X86_CR0_EM | X86_CR0_TS);
    55905533    return IEM_CIMPL_CALL_4(iemCImpl_load_CrX, /*cr*/ 0, uNewCr0, IEMACCESSCRX_LMSW, UINT8_MAX /* iGReg */);
    … …  
    56005543        return iemRaiseGeneralProtectionFault0(pVCpu);
    56015544
    5602     PCPUMCTX pCtx = IEM_GET_CTX(pVCpu);
    5603     IEM_CTX_ASSERT(pCtx, CPUMCTX_EXTRN_CR0);
    5604     uint64_t uNewCr0 = pCtx->cr0;
     5545    IEM_CTX_ASSERT(pVCpu, CPUMCTX_EXTRN_CR0);
     5546    uint64_t uNewCr0 = pVCpu->cpum.GstCtx.cr0;
    56055547    uNewCr0 &= ~X86_CR0_TS;
    56065548    return IEM_CIMPL_CALL_4(iemCImpl_load_CrX, /*cr*/ 0, uNewCr0, IEMACCESSCRX_CLTS, UINT8_MAX /* iGReg */);
    … …  
    56165558IEM_CIMPL_DEF_2(iemCImpl_mov_Rd_Dd, uint8_t, iGReg, uint8_t, iDrReg)
    56175559{
    5618     PCPUMCTX pCtx = IEM_GET_CTX(pVCpu);
    5619 
    56205560    /*
    56215561     * Check preconditions.
    … …  
    56255565    if (pVCpu->iem.s.uCpl != 0)
    56265566        return iemRaiseGeneralProtectionFault0(pVCpu);
    5627     Assert(!pCtx->eflags.Bits.u1VM);
    5628     IEM_CTX_ASSERT(pCtx, CPUMCTX_EXTRN_DR7 | CPUMCTX_EXTRN_CR0);
     5567    Assert(!pVCpu->cpum.GstCtx.eflags.Bits.u1VM);
     5568    IEM_CTX_ASSERT(pVCpu, CPUMCTX_EXTRN_DR7 | CPUMCTX_EXTRN_CR0);
    56295569
    56305570    if (   (iDrReg == 4 || iDrReg == 5)
    5631         && (pCtx->cr4 & X86_CR4_DE) )
     5571        && (pVCpu->cpum.GstCtx.cr4 & X86_CR4_DE) )
    56325572    {
    56335573        Log(("mov r%u,dr%u: CR4.DE=1 -> #GP(0)\n", iGReg, iDrReg));
    … …  
    56365576
    56375577    /* Raise #DB if general access detect is enabled. */
    5638     if (pCtx->dr[7] & X86_DR7_GD)
     5578    if (pVCpu->cpum.GstCtx.dr[7] & X86_DR7_GD)
    56395579    {
    56405580        Log(("mov r%u,dr%u: DR7.GD=1 -> #DB\n", iGReg, iDrReg));
    … …  
    56495589    {
    56505590        case 0:
    5651             IEM_CTX_IMPORT_RET(pVCpu, pCtx, CPUMCTX_EXTRN_DR0_DR3);
    5652             drX = pCtx->dr[0];
     5591            IEM_CTX_IMPORT_RET(pVCpu, CPUMCTX_EXTRN_DR0_DR3);
     5592            drX = pVCpu->cpum.GstCtx.dr[0];
    56535593            break;
    56545594        case 1:
    5655             IEM_CTX_IMPORT_RET(pVCpu, pCtx, CPUMCTX_EXTRN_DR0_DR3);
    5656             drX = pCtx->dr[1];
     5595            IEM_CTX_IMPORT_RET(pVCpu, CPUMCTX_EXTRN_DR0_DR3);
     5596            drX = pVCpu->cpum.GstCtx.dr[1];
    56575597            break;
    56585598        case 2:
    5659             IEM_CTX_IMPORT_RET(pVCpu, pCtx, CPUMCTX_EXTRN_DR0_DR3);
    5660             drX = pCtx->dr[2];
     5599            IEM_CTX_IMPORT_RET(pVCpu, CPUMCTX_EXTRN_DR0_DR3);
     5600            drX = pVCpu->cpum.GstCtx.dr[2];
    56615601            break;
    56625602        case 3:
    5663             IEM_CTX_IMPORT_RET(pVCpu, pCtx, CPUMCTX_EXTRN_DR0_DR3);
    5664             drX = pCtx->dr[3];
     5603            IEM_CTX_IMPORT_RET(pVCpu, CPUMCTX_EXTRN_DR0_DR3);
     5604            drX = pVCpu->cpum.GstCtx.dr[3];
    56655605            break;
    56665606        case 6:
    56675607        case 4:
    5668             IEM_CTX_IMPORT_RET(pVCpu, pCtx, CPUMCTX_EXTRN_DR6);
    5669             drX = pCtx->dr[6];
     5608            IEM_CTX_IMPORT_RET(pVCpu, CPUMCTX_EXTRN_DR6);
     5609            drX = pVCpu->cpum.GstCtx.dr[6];
    56705610            drX |= X86_DR6_RA1_MASK;
    56715611            drX &= ~X86_DR6_RAZ_MASK;
    … …  
    56735613        case 7:
    56745614        case 5:
    5675             IEM_CTX_ASSERT(pCtx, CPUMCTX_EXTRN_DR7);
    5676             drX = pCtx->dr[7];
     5615            IEM_CTX_ASSERT(pVCpu, CPUMCTX_EXTRN_DR7);
     5616            drX = pVCpu->cpum.GstCtx.dr[7];
    56775617            drX |=X86_DR7_RA1_MASK;
    56785618            drX &= ~X86_DR7_RAZ_MASK;
    … …  
    57115651IEM_CIMPL_DEF_2(iemCImpl_mov_Dd_Rd, uint8_t, iDrReg, uint8_t, iGReg)
    57125652{
    5713     PCPUMCTX pCtx = IEM_GET_CTX(pVCpu);
    5714 
    57155653    /*
    57165654     * Check preconditions.
    … …  
    57185656    if (pVCpu->iem.s.uCpl != 0)
    57195657        return iemRaiseGeneralProtectionFault0(pVCpu);
    5720     Assert(!pCtx->eflags.Bits.u1VM);
    5721     IEM_CTX_ASSERT(pCtx, CPUMCTX_EXTRN_DR7 | CPUMCTX_EXTRN_CR4);
     5658    Assert(!pVCpu->cpum.GstCtx.eflags.Bits.u1VM);
     5659    IEM_CTX_ASSERT(pVCpu, CPUMCTX_EXTRN_DR7 | CPUMCTX_EXTRN_CR4);
    57225660
    57235661    if (iDrReg == 4 || iDrReg == 5)
    57245662    {
    5725         if (pCtx->cr4 & X86_CR4_DE)
     5663        if (pVCpu->cpum.GstCtx.cr4 & X86_CR4_DE)
    57265664        {
    57275665            Log(("mov dr%u,r%u: CR4.DE=1 -> #GP(0)\n", iDrReg, iGReg));
    … …  
    57345672    /** @todo is \#DB/DR7.GD raised before any reserved high bits in DR7/DR6
    57355673     *        \#GP? */
    5736     if (pCtx->dr[7] & X86_DR7_GD)
     5674    if (pVCpu->cpum.GstCtx.dr[7] & X86_DR7_GD)
    57375675    {
    57385676        Log(("mov dr%u,r%u: DR7.GD=1 -> #DB\n", iDrReg, iGReg));
    … …  
    58005738     */
    58015739    if (iDrReg < 4)
    5802         IEM_CTX_IMPORT_RET(pVCpu, pCtx, CPUMCTX_EXTRN_DR0_DR3);
     5740        IEM_CTX_IMPORT_RET(pVCpu, CPUMCTX_EXTRN_DR0_DR3);
    58035741    else if (iDrReg == 6)
    5804         IEM_CTX_IMPORT_RET(pVCpu, pCtx, CPUMCTX_EXTRN_DR6);
     5742        IEM_CTX_IMPORT_RET(pVCpu, CPUMCTX_EXTRN_DR6);
    58055743
    58065744    int rc = CPUMSetGuestDRx(pVCpu, iDrReg, uNewDrX);
    … …  
    58245762        return iemRaiseGeneralProtectionFault0(pVCpu);
    58255763    Assert(!IEM_GET_CTX(pVCpu)->eflags.Bits.u1VM);
    5826     IEM_CTX_ASSERT(IEM_GET_CTX(pVCpu), CPUMCTX_EXTRN_CR0 | CPUMCTX_EXTRN_CR3 | CPUMCTX_EXTRN_CR4 | CPUMCTX_EXTRN_EFER);
     5764    IEM_CTX_ASSERT(pVCpu, CPUMCTX_EXTRN_CR0 | CPUMCTX_EXTRN_CR3 | CPUMCTX_EXTRN_CR4 | CPUMCTX_EXTRN_EFER);
    58275765
    58285766    if (IEM_IS_SVM_CTRL_INTERCEPT_SET(pVCpu, SVM_CTRL_INTERCEPT_INVLPG))
    … …  
    58775815        return iemRaiseGeneralProtectionFault0(pVCpu);
    58785816    }
    5879     IEM_CTX_ASSERT(IEM_GET_CTX(pVCpu), CPUMCTX_EXTRN_CR0 | CPUMCTX_EXTRN_CR3 | CPUMCTX_EXTRN_CR4 | CPUMCTX_EXTRN_EFER);
     5817    IEM_CTX_ASSERT(pVCpu, CPUMCTX_EXTRN_CR0 | CPUMCTX_EXTRN_CR3 | CPUMCTX_EXTRN_CR4 | CPUMCTX_EXTRN_EFER);
    58805818
    58815819    /*
    … …  
    59575895IEM_CIMPL_DEF_0(iemCImpl_rdtsc)
    59585896{
    5959     PCPUMCTX pCtx = IEM_GET_CTX(pVCpu);
    5960 
    59615897    /*
    59625898     * Check preconditions.
    … …  
    59655901        return iemRaiseUndefinedOpcode(pVCpu);
    59665902
    5967     IEM_CTX_ASSERT(pCtx, CPUMCTX_EXTRN_CR4);
    5968     if (   (pCtx->cr4 & X86_CR4_TSD)
     5903    IEM_CTX_ASSERT(pVCpu, CPUMCTX_EXTRN_CR4);
     5904    if (   (pVCpu->cpum.GstCtx.cr4 & X86_CR4_TSD)
    59695905        && pVCpu->iem.s.uCpl != 0)
    59705906    {
    … …  
    59875923    uTicks = CPUMApplyNestedGuestTscOffset(pVCpu, uTicks);
    59885924#endif
    5989     pCtx->rax = RT_LO_U32(uTicks);
    5990     pCtx->rdx = RT_HI_U32(uTicks);
     5925    pVCpu->cpum.GstCtx.rax = RT_LO_U32(uTicks);
     5926    pVCpu->cpum.GstCtx.rdx = RT_HI_U32(uTicks);
    59915927    iemRegAddToRipAndClearRF(pVCpu, cbInstr);
    59925928    return VINF_SUCCESS;
    … …  
    59995935IEM_CIMPL_DEF_0(iemCImpl_rdtscp)
    60005936{
    6001     PCPUMCTX pCtx = IEM_GET_CTX(pVCpu);
    6002 
    60035937    /*
    60045938     * Check preconditions.
    … …  
    60075941        return iemRaiseUndefinedOpcode(pVCpu);
    60085942
    6009     IEM_CTX_ASSERT(pCtx, CPUMCTX_EXTRN_CR4);
    6010     if (   (pCtx->cr4 & X86_CR4_TSD)
     5943    IEM_CTX_ASSERT(pVCpu, CPUMCTX_EXTRN_CR4);
     5944    if (   (pVCpu->cpum.GstCtx.cr4 & X86_CR4_TSD)
    60115945        && pVCpu->iem.s.uCpl != 0)
    60125946    {
    … …  
    60265960     * Query the MSR first in case of trips to ring-3.
    60275961     */
    6028     IEM_CTX_IMPORT_RET(pVCpu, pCtx, CPUMCTX_EXTRN_TSC_AUX);
    6029     VBOXSTRICTRC rcStrict = CPUMQueryGuestMsr(pVCpu, MSR_K8_TSC_AUX, &pCtx->rcx);
     5962    IEM_CTX_IMPORT_RET(pVCpu, CPUMCTX_EXTRN_TSC_AUX);
     5963    VBOXSTRICTRC rcStrict = CPUMQueryGuestMsr(pVCpu, MSR_K8_TSC_AUX, &pVCpu->cpum.GstCtx.rcx);
    60305964    if (rcStrict == VINF_SUCCESS)
    60315965    {
    60325966        /* Low dword of the TSC_AUX msr only. */
    6033         pCtx->rcx &= UINT32_C(0xffffffff);
     5967        pVCpu->cpum.GstCtx.rcx &= UINT32_C(0xffffffff);
    60345968
    60355969        uint64_t uTicks = TMCpuTickGet(pVCpu);
    … …  
    60375971        uTicks = CPUMApplyNestedGuestTscOffset(pVCpu, uTicks);
    60385972#endif
    6039         pCtx->rax = RT_LO_U32(uTicks);
    6040         pCtx->rdx = RT_HI_U32(uTicks);
     5973        pVCpu->cpum.GstCtx.rax = RT_LO_U32(uTicks);
     5974        pVCpu->cpum.GstCtx.rdx = RT_HI_U32(uTicks);
    60415975        iemRegAddToRipAndClearRF(pVCpu, cbInstr);
    60425976    }
    … …  
    60505984IEM_CIMPL_DEF_0(iemCImpl_rdpmc)
    60515985{
    6052     PCPUMCTX pCtx = IEM_GET_CTX(pVCpu);
    6053     IEM_CTX_ASSERT(pCtx, CPUMCTX_EXTRN_CR4);
     5986    IEM_CTX_ASSERT(pVCpu, CPUMCTX_EXTRN_CR4);
    60545987
    60555988    if (   pVCpu->iem.s.uCpl != 0
    6056         && !(pCtx->cr4 & X86_CR4_PCE))
     5989        && !(pVCpu->cpum.GstCtx.cr4 & X86_CR4_PCE))
    60575990        return iemRaiseGeneralProtectionFault0(pVCpu);
    60585991
    … …  
    60766009IEM_CIMPL_DEF_0(iemCImpl_rdmsr)
    60776010{
    6078     PCPUMCTX pCtx = IEM_GET_CTX(pVCpu);
    6079 
    60806011    /*
    60816012     * Check preconditions.
    … …  
    60946025    if (IEM_IS_SVM_CTRL_INTERCEPT_SET(pVCpu, SVM_CTRL_INTERCEPT_MSR_PROT))
    60956026    {
    6096         rcStrict = iemSvmHandleMsrIntercept(pVCpu, pCtx, pCtx->ecx, false /* fWrite */);
     6027        rcStrict = iemSvmHandleMsrIntercept(pVCpu, pVCpu->cpum.GstCtx.ecx, false /* fWrite */);
    60976028        if (rcStrict == VINF_SVM_VMEXIT)
    60986029            return VINF_SUCCESS;
    60996030        if (rcStrict != VINF_HM_INTERCEPT_NOT_ACTIVE)
    61006031        {
    6101             Log(("IEM: SVM intercepted rdmsr(%#x) failed. rc=%Rrc\n", pCtx->ecx, VBOXSTRICTRC_VAL(rcStrict)));
     6032            Log(("IEM: SVM intercepted rdmsr(%#x) failed. rc=%Rrc\n", pVCpu->cpum.GstCtx.ecx, VBOXSTRICTRC_VAL(rcStrict)));
    61026033            return rcStrict;
    61036034        }
    … …  
    61056036#endif
    61066037
    6107     IEM_CTX_IMPORT_RET(pVCpu, pCtx, CPUMCTX_EXTRN_ALL_MSRS);
    6108 
    6109     rcStrict = CPUMQueryGuestMsr(pVCpu, pCtx->ecx, &uValue.u);
     6038    IEM_CTX_IMPORT_RET(pVCpu, CPUMCTX_EXTRN_ALL_MSRS);
     6039
     6040    rcStrict = CPUMQueryGuestMsr(pVCpu, pVCpu->cpum.GstCtx.ecx, &uValue.u);
    61106041    if (rcStrict == VINF_SUCCESS)
    61116042    {
    6112         pCtx->rax = uValue.s.Lo;
    6113         pCtx->rdx = uValue.s.Hi;
     6043        pVCpu->cpum.GstCtx.rax = uValue.s.Lo;
     6044        pVCpu->cpum.GstCtx.rdx = uValue.s.Hi;
    61146045
    61156046        iemRegAddToRipAndClearRF(pVCpu, cbInstr);
    … …  
    61216052    if (rcStrict == VINF_CPUM_R3_MSR_READ)
    61226053    {
    6123         Log(("IEM: rdmsr(%#x) -> ring-3\n", pCtx->ecx));
     6054        Log(("IEM: rdmsr(%#x) -> ring-3\n", pVCpu->cpum.GstCtx.ecx));
    61246055        return rcStrict;
    61256056    }
    … …  
    61286059    static uint32_t s_cTimes = 0;
    61296060    if (s_cTimes++ < 10)
    6130         LogRel(("IEM: rdmsr(%#x) -> #GP(0)\n", pCtx->ecx));
     6061        LogRel(("IEM: rdmsr(%#x) -> #GP(0)\n", pVCpu->cpum.GstCtx.ecx));
    61316062    else
    61326063#endif
    6133         Log(("IEM: rdmsr(%#x) -> #GP(0)\n", pCtx->ecx));
     6064        Log(("IEM: rdmsr(%#x) -> #GP(0)\n", pVCpu->cpum.GstCtx.ecx));
    61346065    AssertMsgReturn(rcStrict == VERR_CPUM_RAISE_GP_0, ("%Rrc\n", VBOXSTRICTRC_VAL(rcStrict)), VERR_IPE_UNEXPECTED_STATUS);
    61356066    return iemRaiseGeneralProtectionFault0(pVCpu);
    … …  
    61426073IEM_CIMPL_DEF_0(iemCImpl_wrmsr)
    61436074{
    6144     PCPUMCTX pCtx = IEM_GET_CTX(pVCpu);
    6145 
    61466075    /*
    61476076     * Check preconditions.
    … …  
    61566085     */
    61576086    RTUINT64U uValue;
    6158     uValue.s.Lo = pCtx->eax;
    6159     uValue.s.Hi = pCtx->edx;
     6087    uValue.s.Lo = pVCpu->cpum.GstCtx.eax;
     6088    uValue.s.Hi = pVCpu->cpum.GstCtx.edx;
    61606089
    61616090    VBOXSTRICTRC rcStrict;
    … …  
    61636092    if (IEM_IS_SVM_CTRL_INTERCEPT_SET(pVCpu, SVM_CTRL_INTERCEPT_MSR_PROT))
    61646093    {
    6165         rcStrict = iemSvmHandleMsrIntercept(pVCpu, pCtx, pCtx->ecx, true /* fWrite */);
     6094        rcStrict = iemSvmHandleMsrIntercept(pVCpu, pVCpu->cpum.GstCtx.ecx, true /* fWrite */);
    61666095        if (rcStrict == VINF_SVM_VMEXIT)
    61676096            return VINF_SUCCESS;
    61686097        if (rcStrict != VINF_HM_INTERCEPT_NOT_ACTIVE)
    61696098        {
    6170             Log(("IEM: SVM intercepted rdmsr(%#x) failed. rc=%Rrc\n", pCtx->ecx, VBOXSTRICTRC_VAL(rcStrict)));
     6099            Log(("IEM: SVM intercepted rdmsr(%#x) failed. rc=%Rrc\n", pVCpu->cpum.GstCtx.ecx, VBOXSTRICTRC_VAL(rcStrict)));
    61716100            return rcStrict;
    61726101        }
    … …  
    61746103#endif
    61756104
    6176     IEM_CTX_IMPORT_RET(pVCpu, pCtx, CPUMCTX_EXTRN_ALL_MSRS);
    6177 
    6178     rcStrict = CPUMSetGuestMsr(pVCpu, pCtx->ecx, uValue.u);
     6105    IEM_CTX_IMPORT_RET(pVCpu, CPUMCTX_EXTRN_ALL_MSRS);
     6106
     6107    rcStrict = CPUMSetGuestMsr(pVCpu, pVCpu->cpum.GstCtx.ecx, uValue.u);
    61796108    if (rcStrict == VINF_SUCCESS)
    61806109    {
    … …  
    61876116    if (rcStrict == VINF_CPUM_R3_MSR_WRITE)
    61886117    {
    6189         Log(("IEM: wrmsr(%#x) -> ring-3\n", pCtx->ecx));
     6118        Log(("IEM: wrmsr(%#x) -> ring-3\n", pVCpu->cpum.GstCtx.ecx));
    61906119        return rcStrict;
    61916120    }
    … …  
    61946123    static uint32_t s_cTimes = 0;
    61956124    if (s_cTimes++ < 10)
    6196         LogRel(("IEM: wrmsr(%#x,%#x`%08x) -> #GP(0)\n", pCtx->ecx, uValue.s.Hi, uValue.s.Lo));
     6125        LogRel(("IEM: wrmsr(%#x,%#x`%08x) -> #GP(0)\n", pVCpu->cpum.GstCtx.ecx, uValue.s.Hi, uValue.s.Lo));
    61976126    else
    61986127#endif
    6199         Log(("IEM: wrmsr(%#x,%#x`%08x) -> #GP(0)\n", pCtx->ecx, uValue.s.Hi, uValue.s.Lo));
     6128        Log(("IEM: wrmsr(%#x,%#x`%08x) -> #GP(0)\n", pVCpu->cpum.GstCtx.ecx, uValue.s.Hi, uValue.s.Lo));
    62006129    AssertMsgReturn(rcStrict == VERR_CPUM_RAISE_GP_0, ("%Rrc\n", VBOXSTRICTRC_VAL(rcStrict)), VERR_IPE_UNEXPECTED_STATUS);
    62016130    return iemRaiseGeneralProtectionFault0(pVCpu);
    … …  
    62116140IEM_CIMPL_DEF_2(iemCImpl_in, uint16_t, u16Port, uint8_t, cbReg)
    62126141{
    6213     PCPUMCTX pCtx = IEM_GET_CTX(pVCpu);
    6214 
    62156142    /*
    62166143     * CPL check
    62176144     */
    6218     VBOXSTRICTRC rcStrict = iemHlpCheckPortIOPermission(pVCpu, pCtx, u16Port, cbReg);
     6145    VBOXSTRICTRC rcStrict = iemHlpCheckPortIOPermission(pVCpu, u16Port, cbReg);
    62196146    if (rcStrict != VINF_SUCCESS)
    62206147        return rcStrict;
    … …  
    62566183        switch (cbReg)
    62576184        {
    6258             case 1: pCtx->al  = (uint8_t)u32Value;  break;
    6259             case 2: pCtx->ax  = (uint16_t)u32Value; break;
    6260             case 4: pCtx->rax = u32Value;           break;
     6185            case 1: pVCpu->cpum.GstCtx.al  = (uint8_t)u32Value;  break;
     6186            case 2: pVCpu->cpum.GstCtx.ax  = (uint16_t)u32Value; break;
     6187            case 4: pVCpu->cpum.GstCtx.rax = u32Value;           break;
    62616188            default: AssertFailedReturn(VERR_IEM_IPE_3);
    62626189        }
    … …  
    62706197         * Check for I/O breakpoints.
    62716198         */
    6272         uint32_t const uDr7 = pCtx->dr[7];
     6199        uint32_t const uDr7 = pVCpu->cpum.GstCtx.dr[7];
    62736200        if (RT_UNLIKELY(   (   (uDr7 & X86_DR7_ENABLED_MASK)
    62746201                            && X86_DR7_ANY_RW_IO(uDr7)
    6275                             && (pCtx->cr4 & X86_CR4_DE))
     6202                            && (pVCpu->cpum.GstCtx.cr4 & X86_CR4_DE))
    62766203                        || DBGFBpIsHwIoArmed(pVCpu->CTX_SUFF(pVM))))
    62776204        {
    6278             IEM_CTX_IMPORT_RET(pVCpu, pCtx, CPUMCTX_EXTRN_DR0_DR3 | CPUMCTX_EXTRN_DR6);
    6279             rcStrict = DBGFBpCheckIo(pVCpu->CTX_SUFF(pVM), pVCpu, pCtx, u16Port, cbReg);
     6205            IEM_CTX_IMPORT_RET(pVCpu, CPUMCTX_EXTRN_DR0_DR3 | CPUMCTX_EXTRN_DR6);
     6206            rcStrict = DBGFBpCheckIo(pVCpu->CTX_SUFF(pVM), pVCpu, IEM_GET_CTX(pVCpu), u16Port, cbReg);
    62806207            if (rcStrict == VINF_EM_RAW_GUEST_TRAP)
    62816208                rcStrict = iemRaiseDebugException(pVCpu);
    … …  
    63066233IEM_CIMPL_DEF_2(iemCImpl_out, uint16_t, u16Port, uint8_t, cbReg)
    63076234{
    6308     PCPUMCTX pCtx = IEM_GET_CTX(pVCpu);
    6309 
    63106235    /*
    63116236     * CPL check
    63126237     */
    6313     VBOXSTRICTRC rcStrict = iemHlpCheckPortIOPermission(pVCpu, pCtx, u16Port, cbReg);
     6238    VBOXSTRICTRC rcStrict = iemHlpCheckPortIOPermission(pVCpu, u16Port, cbReg);
    63146239    if (rcStrict != VINF_SUCCESS)
    63156240        return rcStrict;
    … …  
    63486273    switch (cbReg)
    63496274    {
    6350         case 1: u32Value = pCtx->al;  break;
    6351         case 2: u32Value = pCtx->ax;  break;
    6352         case 4: u32Value = pCtx->eax; break;
     6275        case 1: u32Value = pVCpu->cpum.GstCtx.al;  break;
     6276        case 2: u32Value = pVCpu->cpum.GstCtx.ax;  break;
     6277        case 4: u32Value = pVCpu->cpum.GstCtx.eax; break;
    63536278        default: AssertFailedReturn(VERR_IEM_IPE_4);
    63546279    }
    … …  
    63656290         * Check for I/O breakpoints.
    63666291         */
    6367         uint32_t const uDr7 = pCtx->dr[7];
     6292        uint32_t const uDr7 = pVCpu->cpum.GstCtx.dr[7];
    63686293        if (RT_UNLIKELY(   (   (uDr7 & X86_DR7_ENABLED_MASK)
    63696294                            && X86_DR7_ANY_RW_IO(uDr7)
    6370                             && (pCtx->cr4 & X86_CR4_DE))
     6295                            && (pVCpu->cpum.GstCtx.cr4 & X86_CR4_DE))
    63716296                        || DBGFBpIsHwIoArmed(pVCpu->CTX_SUFF(pVM))))
    63726297        {
    6373             IEM_CTX_IMPORT_RET(pVCpu, pCtx, CPUMCTX_EXTRN_DR0_DR3 | CPUMCTX_EXTRN_DR6);
    6374             rcStrict = DBGFBpCheckIo(pVCpu->CTX_SUFF(pVM), pVCpu, pCtx, u16Port, cbReg);
     6298            IEM_CTX_IMPORT_RET(pVCpu, CPUMCTX_EXTRN_DR0_DR3 | CPUMCTX_EXTRN_DR6);
     6299            rcStrict = DBGFBpCheckIo(pVCpu->CTX_SUFF(pVM), pVCpu, IEM_GET_CTX(pVCpu), u16Port, cbReg);
    63756300            if (rcStrict == VINF_EM_RAW_GUEST_TRAP)
    63766301                rcStrict = iemRaiseDebugException(pVCpu);
    … …  
    63976322IEM_CIMPL_DEF_0(iemCImpl_cli)
    63986323{
    6399     PCPUMCTX        pCtx    = IEM_GET_CTX(pVCpu);
    6400     uint32_t        fEfl    = IEMMISC_GET_EFL(pVCpu, pCtx);
     6324    uint32_t        fEfl    = IEMMISC_GET_EFL(pVCpu);
    64016325    uint32_t const  fEflOld = fEfl;
    64026326
    6403     IEM_CTX_ASSERT(pCtx, CPUMCTX_EXTRN_CR0 | CPUMCTX_EXTRN_CR4);
    6404     if (pCtx->cr0 & X86_CR0_PE)
     6327    IEM_CTX_ASSERT(pVCpu, CPUMCTX_EXTRN_CR0 | CPUMCTX_EXTRN_CR4);
     6328    if (pVCpu->cpum.GstCtx.cr0 & X86_CR0_PE)
    64056329    {
    64066330        uint8_t const uIopl = X86_EFL_GET_IOPL(fEfl);
    … …  
    64106334                fEfl &= ~X86_EFL_IF;
    64116335            else if (   pVCpu->iem.s.uCpl == 3
    6412                      && (pCtx->cr4 & X86_CR4_PVI) )
     6336                     && (pVCpu->cpum.GstCtx.cr4 & X86_CR4_PVI) )
    64136337                fEfl &= ~X86_EFL_VIF;
    64146338            else
    … …  
    64196343            fEfl &= ~X86_EFL_IF;
    64206344        else if (   uIopl < 3
    6421                  && (pCtx->cr4 & X86_CR4_VME) )
     6345                 && (pVCpu->cpum.GstCtx.cr4 & X86_CR4_VME) )
    64226346            fEfl &= ~X86_EFL_VIF;
    64236347        else
    … …  
    64296353
    64306354    /* Commit. */
    6431     IEMMISC_SET_EFL(pVCpu, pCtx, fEfl);
     6355    IEMMISC_SET_EFL(pVCpu, fEfl);
    64326356    iemRegAddToRipAndClearRF(pVCpu, cbInstr);
    64336357    Log2(("CLI: %#x -> %#x\n", fEflOld, fEfl)); NOREF(fEflOld);
    … …  
    64416365IEM_CIMPL_DEF_0(iemCImpl_sti)
    64426366{
    6443     PCPUMCTX        pCtx    = IEM_GET_CTX(pVCpu);
    6444     uint32_t        fEfl    = IEMMISC_GET_EFL(pVCpu, pCtx);
     6367    uint32_t        fEfl    = IEMMISC_GET_EFL(pVCpu);
    64456368    uint32_t const  fEflOld = fEfl;
    64466369
    6447     IEM_CTX_ASSERT(pCtx, CPUMCTX_EXTRN_CR0 | CPUMCTX_EXTRN_CR4);
    6448     if (pCtx->cr0 & X86_CR0_PE)
     6370    IEM_CTX_ASSERT(pVCpu, CPUMCTX_EXTRN_CR0 | CPUMCTX_EXTRN_CR4);
     6371    if (pVCpu->cpum.GstCtx.cr0 & X86_CR0_PE)
    64496372    {
    64506373        uint8_t const uIopl = X86_EFL_GET_IOPL(fEfl);
    … …  
    64546377                fEfl |= X86_EFL_IF;
    64556378            else if (   pVCpu->iem.s.uCpl == 3
    6456                      && (pCtx->cr4 & X86_CR4_PVI)
     6379                     && (pVCpu->cpum.GstCtx.cr4 & X86_CR4_PVI)
    64576380                     && !(fEfl & X86_EFL_VIP) )
    64586381                fEfl |= X86_EFL_VIF;
    … …  
    64646387            fEfl |= X86_EFL_IF;
    64656388        else if (   uIopl < 3
    6466                  && (pCtx->cr4 & X86_CR4_VME)
     6389                 && (pVCpu->cpum.GstCtx.cr4 & X86_CR4_VME)
    64676390                 && !(fEfl & X86_EFL_VIP) )
    64686391            fEfl |= X86_EFL_VIF;
    … …  
    64756398
    64766399    /* Commit. */
    6477     IEMMISC_SET_EFL(pVCpu, pCtx, fEfl);
     6400    IEMMISC_SET_EFL(pVCpu, fEfl);
    64786401    iemRegAddToRipAndClearRF(pVCpu, cbInstr);
    64796402    if (!(fEflOld & X86_EFL_IF) && (fEfl & X86_EFL_IF))
    6480         EMSetInhibitInterruptsPC(pVCpu, pCtx->rip);
     6403        EMSetInhibitInterruptsPC(pVCpu, pVCpu->cpum.GstCtx.rip);
    64816404    Log2(("STI: %#x -> %#x\n", fEflOld, fEfl));
    64826405    return VINF_SUCCESS;
    … …  
    65266449     * Gather the operands and validate them.
    65276450     */
    6528     PCPUMCTX pCtx       = IEM_GET_CTX(pVCpu);
    6529     RTGCPTR  GCPtrMem   = pVCpu->iem.s.enmCpuMode == IEMMODE_64BIT ? pCtx->rax : pCtx->eax;
    6530     uint32_t uEcx       = pCtx->ecx;
    6531     uint32_t uEdx       = pCtx->edx;
     6451    RTGCPTR  GCPtrMem   = pVCpu->iem.s.enmCpuMode == IEMMODE_64BIT ? pVCpu->cpum.GstCtx.rax : pVCpu->cpum.GstCtx.eax;
     6452    uint32_t uEcx       = pVCpu->cpum.GstCtx.ecx;
     6453    uint32_t uEdx       = pVCpu->cpum.GstCtx.edx;
    65326454/** @todo Test whether EAX or ECX is processed first, i.e. do we get \#PF or
    65336455 *        \#GP first. */
    … …  
    65576479     * Call EM to prepare the monitor/wait.
    65586480     */
    6559     rcStrict = EMMonitorWaitPrepare(pVCpu, pCtx->rax, pCtx->rcx, pCtx->rdx, GCPhysMem);
     6481    rcStrict = EMMonitorWaitPrepare(pVCpu, pVCpu->cpum.GstCtx.rax, pVCpu->cpum.GstCtx.rcx, pVCpu->cpum.GstCtx.rdx, GCPhysMem);
    65606482    Assert(rcStrict == VINF_SUCCESS);
    65616483
    … …  
    65896511     * Gather the operands and validate them.
    65906512     */
    6591     PCPUMCTX pCtx = IEM_GET_CTX(pVCpu);
    6592     uint32_t uEax = pCtx->eax;
    6593     uint32_t uEcx = pCtx->ecx;
     6513    uint32_t uEax = pVCpu->cpum.GstCtx.eax;
     6514    uint32_t uEcx = pVCpu->cpum.GstCtx.ecx;
    65946515    if (uEcx != 0)
    65956516    {
    … …  
    66576578     * Do the job.
    66586579     */
    6659     PCPUMCTX pCtx = IEM_GET_CTX(pVCpu);
    6660     IEM_CTX_IMPORT_RET(pVCpu, pCtx, CPUMCTX_EXTRN_OTHER_MSRS);
    6661     uint64_t uOtherGsBase = pCtx->msrKERNELGSBASE;
    6662     pCtx->msrKERNELGSBASE = pCtx->gs.u64Base;
    6663     pCtx->gs.u64Base = uOtherGsBase;
     6580    IEM_CTX_IMPORT_RET(pVCpu, CPUMCTX_EXTRN_OTHER_MSRS);
     6581    uint64_t uOtherGsBase = pVCpu->cpum.GstCtx.msrKERNELGSBASE;
     6582    pVCpu->cpum.GstCtx.msrKERNELGSBASE = pVCpu->cpum.GstCtx.gs.u64Base;
     6583    pVCpu->cpum.GstCtx.gs.u64Base = uOtherGsBase;
    66646584
    66656585    iemRegAddToRipAndClearRF(pVCpu, cbInstr);
    … …  
    66736593IEM_CIMPL_DEF_0(iemCImpl_cpuid)
    66746594{
    6675     PCPUMCTX pCtx = IEM_GET_CTX(pVCpu);
    6676 
    66776595    if (IEM_IS_SVM_CTRL_INTERCEPT_SET(pVCpu, SVM_CTRL_INTERCEPT_CPUID))
    66786596    {
    … …  
    66826600    }
    66836601
    6684     IEM_CTX_IMPORT_RET(pVCpu, pCtx, CPUMCTX_EXTRN_ALL_MSRS);
    6685     CPUMGetGuestCpuId(pVCpu, pCtx->eax, pCtx->ecx, &pCtx->eax, &pCtx->ebx, &pCtx->ecx, &pCtx->edx);
    6686     pCtx->rax &= UINT32_C(0xffffffff);
    6687     pCtx->rbx &= UINT32_C(0xffffffff);
    6688     pCtx->rcx &= UINT32_C(0xffffffff);
    6689     pCtx->rdx &= UINT32_C(0xffffffff);
     6602    IEM_CTX_IMPORT_RET(pVCpu, CPUMCTX_EXTRN_ALL_MSRS);
     6603    CPUMGetGuestCpuId(pVCpu, pVCpu->cpum.GstCtx.eax, pVCpu->cpum.GstCtx.ecx, &pVCpu->cpum.GstCtx.eax, &pVCpu->cpum.GstCtx.ebx, &pVCpu->cpum.GstCtx.ecx, &pVCpu->cpum.GstCtx.edx);
     6604    pVCpu->cpum.GstCtx.rax &= UINT32_C(0xffffffff);
     6605    pVCpu->cpum.GstCtx.rbx &= UINT32_C(0xffffffff);
     6606    pVCpu->cpum.GstCtx.rcx &= UINT32_C(0xffffffff);
     6607    pVCpu->cpum.GstCtx.rdx &= UINT32_C(0xffffffff);
    66906608
    66916609    iemRegAddToRipAndClearRF(pVCpu, cbInstr);
    … …  
    67016619IEM_CIMPL_DEF_1(iemCImpl_aad, uint8_t, bImm)
    67026620{
    6703     PCPUMCTX pCtx = IEM_GET_CTX(pVCpu);
    6704 
    6705     uint16_t const ax = pCtx->ax;
     6621    uint16_t const ax = pVCpu->cpum.GstCtx.ax;
    67066622    uint8_t const  al = (uint8_t)ax + (uint8_t)(ax >> 8) * bImm;
    6707     pCtx->ax = al;
     6623    pVCpu->cpum.GstCtx.ax = al;
    67086624    iemHlpUpdateArithEFlagsU8(pVCpu, al,
    67096625                              X86_EFL_SF | X86_EFL_ZF | X86_EFL_PF,
    … …  
    67226638IEM_CIMPL_DEF_1(iemCImpl_aam, uint8_t, bImm)
    67236639{
    6724     PCPUMCTX pCtx = IEM_GET_CTX(pVCpu);
    67256640    Assert(bImm != 0); /* #DE on 0 is handled in the decoder. */
    67266641
    6727     uint16_t const ax = pCtx->ax;
     6642    uint16_t const ax = pVCpu->cpum.GstCtx.ax;
    67286643    uint8_t const  al = (uint8_t)ax % bImm;
    67296644    uint8_t const  ah = (uint8_t)ax / bImm;
    6730     pCtx->ax = (ah << 8) + al;
     6645    pVCpu->cpum.GstCtx.ax = (ah << 8) + al;
    67316646    iemHlpUpdateArithEFlagsU8(pVCpu, al,
    67326647                              X86_EFL_SF | X86_EFL_ZF | X86_EFL_PF,
    … …  
    67436658IEM_CIMPL_DEF_0(iemCImpl_daa)
    67446659{
    6745     PCPUMCTX pCtx = IEM_GET_CTX(pVCpu);
    6746 
    6747     uint8_t const  al       = pCtx->al;
    6748     bool const     fCarry   = pCtx->eflags.Bits.u1CF;
    6749 
    6750     if (   pCtx->eflags.Bits.u1AF
     6660    uint8_t const  al       = pVCpu->cpum.GstCtx.al;
     6661    bool const     fCarry   = pVCpu->cpum.GstCtx.eflags.Bits.u1CF;
     6662
     6663    if (   pVCpu->cpum.GstCtx.eflags.Bits.u1AF
    67516664        || (al & 0xf) >= 10)
    67526665    {
    6753         pCtx->al = al + 6;
    6754         pCtx->eflags.Bits.u1AF = 1;
     6666        pVCpu->cpum.GstCtx.al = al + 6;
     6667        pVCpu->cpum.GstCtx.eflags.Bits.u1AF = 1;
    67556668    }
    67566669    else
    6757         pCtx->eflags.Bits.u1AF = 0;
     6670        pVCpu->cpum.GstCtx.eflags.Bits.u1AF = 0;
    67586671
    67596672    if (al >= 0x9a || fCarry)
    67606673    {
    6761         pCtx->al += 0x60;
    6762         pCtx->eflags.Bits.u1CF = 1;
     6674        pVCpu->cpum.GstCtx.al += 0x60;
     6675        pVCpu->cpum.GstCtx.eflags.Bits.u1CF = 1;
    67636676    }
    67646677    else
    6765         pCtx->eflags.Bits.u1CF = 0;
    6766 
    6767     iemHlpUpdateArithEFlagsU8(pVCpu, pCtx->al, X86_EFL_SF | X86_EFL_ZF | X86_EFL_PF, X86_EFL_OF);
     6678        pVCpu->cpum.GstCtx.eflags.Bits.u1CF = 0;
     6679
     6680    iemHlpUpdateArithEFlagsU8(pVCpu, pVCpu->cpum.GstCtx.al, X86_EFL_SF | X86_EFL_ZF | X86_EFL_PF, X86_EFL_OF);
    67686681    iemRegAddToRipAndClearRF(pVCpu, cbInstr);
    67696682    return VINF_SUCCESS;
    … …  
    67766689IEM_CIMPL_DEF_0(iemCImpl_das)
    67776690{
    6778     PCPUMCTX pCtx = IEM_GET_CTX(pVCpu);
    6779 
    6780     uint8_t const  uInputAL = pCtx->al;
    6781     bool const     fCarry   = pCtx->eflags.Bits.u1CF;
    6782 
    6783     if (   pCtx->eflags.Bits.u1AF
     6691    uint8_t const  uInputAL = pVCpu->cpum.GstCtx.al;
     6692    bool const     fCarry   = pVCpu->cpum.GstCtx.eflags.Bits.u1CF;
     6693
     6694    if (   pVCpu->cpum.GstCtx.eflags.Bits.u1AF
    67846695        || (uInputAL & 0xf) >= 10)
    67856696    {
    6786         pCtx->eflags.Bits.u1AF = 1;
     6697        pVCpu->cpum.GstCtx.eflags.Bits.u1AF = 1;
    67876698        if (uInputAL < 6)
    6788             pCtx->eflags.Bits.u1CF = 1;
    6789         pCtx->al = uInputAL - 6;
     6699            pVCpu->cpum.GstCtx.eflags.Bits.u1CF = 1;
     6700        pVCpu->cpum.GstCtx.al = uInputAL - 6;
    67906701    }
    67916702    else
    67926703    {
    6793         pCtx->eflags.Bits.u1AF = 0;
    6794         pCtx->eflags.Bits.u1CF = 0;
     6704        pVCpu->cpum.GstCtx.eflags.Bits.u1AF = 0;
     6705        pVCpu->cpum.GstCtx.eflags.Bits.u1CF = 0;
    67956706    }
    67966707
    67976708    if (uInputAL >= 0x9a || fCarry)
    67986709    {
    6799         pCtx->al -= 0x60;
    6800         pCtx->eflags.Bits.u1CF = 1;
    6801     }
    6802 
    6803     iemHlpUpdateArithEFlagsU8(pVCpu, pCtx->al, X86_EFL_SF | X86_EFL_ZF | X86_EFL_PF, X86_EFL_OF);
     6710        pVCpu->cpum.GstCtx.al -= 0x60;
     6711        pVCpu->cpum.GstCtx.eflags.Bits.u1CF = 1;
     6712    }
     6713
     6714    iemHlpUpdateArithEFlagsU8(pVCpu, pVCpu->cpum.GstCtx.al, X86_EFL_SF | X86_EFL_ZF | X86_EFL_PF, X86_EFL_OF);
    68046715    iemRegAddToRipAndClearRF(pVCpu, cbInstr);
    68056716    return VINF_SUCCESS;
    … …  
    68126723IEM_CIMPL_DEF_0(iemCImpl_aaa)
    68136724{
    6814     PCPUMCTX pCtx = IEM_GET_CTX(pVCpu);
    6815 
    68166725    if (IEM_IS_GUEST_CPU_AMD(pVCpu))
    68176726    {
    6818         if (   pCtx->eflags.Bits.u1AF
    6819             || (pCtx->ax & 0xf) >= 10)
    6820         {
    6821             iemAImpl_add_u16(&pCtx->ax, 0x106, &pCtx->eflags.u32);
    6822             pCtx->eflags.Bits.u1AF = 1;
    6823             pCtx->eflags.Bits.u1CF = 1;
     6727        if (   pVCpu->cpum.GstCtx.eflags.Bits.u1AF
     6728            || (pVCpu->cpum.GstCtx.ax & 0xf) >= 10)
     6729        {
     6730            iemAImpl_add_u16(&pVCpu->cpum.GstCtx.ax, 0x106, &pVCpu->cpum.GstCtx.eflags.u32);
     6731            pVCpu->cpum.GstCtx.eflags.Bits.u1AF = 1;
     6732            pVCpu->cpum.GstCtx.eflags.Bits.u1CF = 1;
    68246733        }
    68256734        else
    68266735        {
    6827             iemHlpUpdateArithEFlagsU16(pVCpu, pCtx->ax, X86_EFL_SF | X86_EFL_ZF | X86_EFL_PF, X86_EFL_OF);
    6828             pCtx->eflags.Bits.u1AF = 0;
    6829             pCtx->eflags.Bits.u1CF = 0;
    6830         }
    6831         pCtx->ax &= UINT16_C(0xff0f);
     6736            iemHlpUpdateArithEFlagsU16(pVCpu, pVCpu->cpum.GstCtx.ax, X86_EFL_SF | X86_EFL_ZF | X86_EFL_PF, X86_EFL_OF);
     6737            pVCpu->cpum.GstCtx.eflags.Bits.u1AF = 0;
     6738            pVCpu->cpum.GstCtx.eflags.Bits.u1CF = 0;
     6739        }
     6740        pVCpu->cpum.GstCtx.ax &= UINT16_C(0xff0f);
    68326741    }
    68336742    else
    68346743    {
    6835         if (   pCtx->eflags.Bits.u1AF
    6836             || (pCtx->ax & 0xf) >= 10)
    6837         {
    6838             pCtx->ax += UINT16_C(0x106);
    6839             pCtx->eflags.Bits.u1AF = 1;
    6840             pCtx->eflags.Bits.u1CF = 1;
     6744        if (   pVCpu->cpum.GstCtx.eflags.Bits.u1AF
     6745            || (pVCpu->cpum.GstCtx.ax & 0xf) >= 10)
     6746        {
     6747            pVCpu->cpum.GstCtx.ax += UINT16_C(0x106);
     6748            pVCpu->cpum.GstCtx.eflags.Bits.u1AF = 1;
     6749            pVCpu->cpum.GstCtx.eflags.Bits.u1CF = 1;
    68416750        }
    68426751        else
    68436752        {
    6844             pCtx->eflags.Bits.u1AF = 0;
    6845             pCtx->eflags.Bits.u1CF = 0;
    6846         }
    6847         pCtx->ax &= UINT16_C(0xff0f);
    6848         iemHlpUpdateArithEFlagsU8(pVCpu, pCtx->al, X86_EFL_SF | X86_EFL_ZF | X86_EFL_PF, X86_EFL_OF);
     6753            pVCpu->cpum.GstCtx.eflags.Bits.u1AF = 0;
     6754            pVCpu->cpum.GstCtx.eflags.Bits.u1CF = 0;
     6755        }
     6756        pVCpu->cpum.GstCtx.ax &= UINT16_C(0xff0f);
     6757        iemHlpUpdateArithEFlagsU8(pVCpu, pVCpu->cpum.GstCtx.al, X86_EFL_SF | X86_EFL_ZF | X86_EFL_PF, X86_EFL_OF);
    68496758    }
    68506759
    … …  
    68596768IEM_CIMPL_DEF_0(iemCImpl_aas)
    68606769{
    6861     PCPUMCTX pCtx = IEM_GET_CTX(pVCpu);
    6862 
    68636770    if (IEM_IS_GUEST_CPU_AMD(pVCpu))
    68646771    {
    6865         if (   pCtx->eflags.Bits.u1AF
    6866             || (pCtx->ax & 0xf) >= 10)
    6867         {
    6868             iemAImpl_sub_u16(&pCtx->ax, 0x106, &pCtx->eflags.u32);
    6869             pCtx->eflags.Bits.u1AF = 1;
    6870             pCtx->eflags.Bits.u1CF = 1;
     6772        if (   pVCpu->cpum.GstCtx.eflags.Bits.u1AF
     6773            || (pVCpu->cpum.GstCtx.ax & 0xf) >= 10)
     6774        {
     6775            iemAImpl_sub_u16(&pVCpu->cpum.GstCtx.ax, 0x106, &pVCpu->cpum.GstCtx.eflags.u32);
     6776            pVCpu->cpum.GstCtx.eflags.Bits.u1AF = 1;
     6777            pVCpu->cpum.GstCtx.eflags.Bits.u1CF = 1;
    68716778        }
    68726779        else
    68736780        {
    6874             iemHlpUpdateArithEFlagsU16(pVCpu, pCtx->ax, X86_EFL_SF | X86_EFL_ZF | X86_EFL_PF, X86_EFL_OF);
    6875             pCtx->eflags.Bits.u1AF = 0;
    6876             pCtx->eflags.Bits.u1CF = 0;
    6877         }
    6878         pCtx->ax &= UINT16_C(0xff0f);
     6781            iemHlpUpdateArithEFlagsU16(pVCpu, pVCpu->cpum.GstCtx.ax, X86_EFL_SF | X86_EFL_ZF | X86_EFL_PF, X86_EFL_OF);
     6782            pVCpu->cpum.GstCtx.eflags.Bits.u1AF = 0;
     6783            pVCpu->cpum.GstCtx.eflags.Bits.u1CF = 0;
     6784        }
     6785        pVCpu->cpum.GstCtx.ax &= UINT16_C(0xff0f);
    68796786    }
    68806787    else
    68816788    {
    6882         if (   pCtx->eflags.Bits.u1AF
    6883             || (pCtx->ax & 0xf) >= 10)
    6884         {
    6885             pCtx->ax -= UINT16_C(0x106);
    6886             pCtx->eflags.Bits.u1AF = 1;
    6887             pCtx->eflags.Bits.u1CF = 1;
     6789        if (   pVCpu->cpum.GstCtx.eflags.Bits.u1AF
     6790            || (pVCpu->cpum.GstCtx.ax & 0xf) >= 10)
     6791        {
     6792            pVCpu->cpum.GstCtx.ax -= UINT16_C(0x106);
     6793            pVCpu->cpum.GstCtx.eflags.Bits.u1AF = 1;
     6794            pVCpu->cpum.GstCtx.eflags.Bits.u1CF = 1;
    68886795        }
    68896796        else
    68906797        {
    6891             pCtx->eflags.Bits.u1AF = 0;
    6892             pCtx->eflags.Bits.u1CF = 0;
    6893         }
    6894         pCtx->ax &= UINT16_C(0xff0f);
    6895         iemHlpUpdateArithEFlagsU8(pVCpu, pCtx->al, X86_EFL_SF | X86_EFL_ZF | X86_EFL_PF, X86_EFL_OF);
     6798            pVCpu->cpum.GstCtx.eflags.Bits.u1AF = 0;
     6799            pVCpu->cpum.GstCtx.eflags.Bits.u1CF = 0;
     6800        }
     6801        pVCpu->cpum.GstCtx.ax &= UINT16_C(0xff0f);
     6802        iemHlpUpdateArithEFlagsU8(pVCpu, pVCpu->cpum.GstCtx.al, X86_EFL_SF | X86_EFL_ZF | X86_EFL_PF, X86_EFL_OF);
    68966803    }
    68976804
    … …  
    69906897IEM_CIMPL_DEF_0(iemCImpl_xgetbv)
    69916898{
    6992     PCPUMCTX pCtx = IEM_GET_CTX(pVCpu);
    6993     IEM_CTX_ASSERT(pCtx, CPUMCTX_EXTRN_CR4);
    6994     if (pCtx->cr4 & X86_CR4_OSXSAVE)
    6995     {
    6996         uint32_t uEcx = pCtx->ecx;
     6899    IEM_CTX_ASSERT(pVCpu, CPUMCTX_EXTRN_CR4);
     6900    if (pVCpu->cpum.GstCtx.cr4 & X86_CR4_OSXSAVE)
     6901    {
     6902        uint32_t uEcx = pVCpu->cpum.GstCtx.ecx;
    69976903        switch (uEcx)
    69986904        {
    … …  
    70066912
    70076913        }
    7008         IEM_CTX_IMPORT_RET(pVCpu, pCtx, CPUMCTX_EXTRN_XCRx);
    7009         pCtx->rax = RT_LO_U32(pCtx->aXcr[uEcx]);
    7010         pCtx->rdx = RT_HI_U32(pCtx->aXcr[uEcx]);
     6914        IEM_CTX_IMPORT_RET(pVCpu, CPUMCTX_EXTRN_XCRx);
     6915        pVCpu->cpum.GstCtx.rax = RT_LO_U32(pVCpu->cpum.GstCtx.aXcr[uEcx]);
     6916        pVCpu->cpum.GstCtx.rdx = RT_HI_U32(pVCpu->cpum.GstCtx.aXcr[uEcx]);
    70116917
    70126918        iemRegAddToRipAndClearRF(pVCpu, cbInstr);
    … …  
    70236929IEM_CIMPL_DEF_0(iemCImpl_xsetbv)
    70246930{
    7025     PCPUMCTX pCtx = IEM_GET_CTX(pVCpu);
    7026     if (pCtx->cr4 & X86_CR4_OSXSAVE)
     6931    if (pVCpu->cpum.GstCtx.cr4 & X86_CR4_OSXSAVE)
    70276932    {
    70286933        if (IEM_IS_SVM_CTRL_INTERCEPT_SET(pVCpu, SVM_CTRL_INTERCEPT_XSETBV))
    … …  
    70356940        if (pVCpu->iem.s.uCpl == 0)
    70366941        {
    7037             IEM_CTX_IMPORT_RET(pVCpu, pCtx, CPUMCTX_EXTRN_XCRx);
    7038 
    7039             uint32_t uEcx = pCtx->ecx;
    7040             uint64_t uNewValue = RT_MAKE_U64(pCtx->eax, pCtx->edx);
     6942            IEM_CTX_IMPORT_RET(pVCpu, CPUMCTX_EXTRN_XCRx);
     6943
     6944            uint32_t uEcx = pVCpu->cpum.GstCtx.ecx;
     6945            uint64_t uNewValue = RT_MAKE_U64(pVCpu->cpum.GstCtx.eax, pVCpu->cpum.GstCtx.edx);
    70416946            switch (uEcx)
    70426947            {
    … …  
    71267031        if (rcStrict == VINF_SUCCESS)
    71277032        {
    7128             PCPUMCTX pCtx = IEM_GET_CTX(pVCpu);
    7129             pCtx->eflags.u = *pEFlags; /* IEM_MC_COMMIT_EFLAGS */
     7033            pVCpu->cpum.GstCtx.eflags.u = *pEFlags; /* IEM_MC_COMMIT_EFLAGS */
    71307034            if (!(*pEFlags & X86_EFL_ZF))
    71317035            {
    7132                 pCtx->rax = pu128RaxRdx->s.Lo;
    7133                 pCtx->rdx = pu128RaxRdx->s.Hi;
     7036                pVCpu->cpum.GstCtx.rax = pu128RaxRdx->s.Lo;
     7037                pVCpu->cpum.GstCtx.rdx = pu128RaxRdx->s.Hi;
    71347038            }
    71357039            iemRegAddToRipAndClearRF(pVCpu, cbInstr);
    … …  
    71837087IEM_CIMPL_DEF_1(iemCImpl_finit, bool, fCheckXcpts)
    71847088{
    7185     PCPUMCTX pCtx = IEM_GET_CTX(pVCpu);
    7186     IEM_CTX_ASSERT(pCtx, CPUMCTX_EXTRN_CR0 | CPUMCTX_EXTRN_X87);
    7187 
    7188     if (pCtx->cr0 & (X86_CR0_EM | X86_CR0_TS))
     7089    IEM_CTX_ASSERT(pVCpu, CPUMCTX_EXTRN_CR0 | CPUMCTX_EXTRN_X87);
     7090
     7091    if (pVCpu->cpum.GstCtx.cr0 & (X86_CR0_EM | X86_CR0_TS))
    71897092        return iemRaiseDeviceNotAvailable(pVCpu);
    71907093
    … …  
    71947097     */
    71957098
    7196     PX86XSAVEAREA pXState = pCtx->CTX_SUFF(pXState);
     7099    PX86XSAVEAREA pXState = pVCpu->cpum.GstCtx.CTX_SUFF(pXState);
    71977100    pXState->x87.FCW   = 0x37f;
    71987101    pXState->x87.FSW   = 0;
    … …  
    72217124IEM_CIMPL_DEF_3(iemCImpl_fxsave, uint8_t, iEffSeg, RTGCPTR, GCPtrEff, IEMMODE, enmEffOpSize)
    72227125{
    7223     PCPUMCTX pCtx = IEM_GET_CTX(pVCpu);
    7224     IEM_CTX_ASSERT(pCtx, CPUMCTX_EXTRN_CR0 | CPUMCTX_EXTRN_X87 | CPUMCTX_EXTRN_SSE_AVX);
     7126    IEM_CTX_ASSERT(pVCpu, CPUMCTX_EXTRN_CR0 | CPUMCTX_EXTRN_X87 | CPUMCTX_EXTRN_SSE_AVX);
    72257127
    72267128    /*
    72277129     * Raise exceptions.
    72287130     */
    7229     if (pCtx->cr0 & X86_CR0_EM)
     7131    if (pVCpu->cpum.GstCtx.cr0 & X86_CR0_EM)
    72307132        return iemRaiseUndefinedOpcode(pVCpu);
    7231     if (pCtx->cr0 & (X86_CR0_TS | X86_CR0_EM))
     7133    if (pVCpu->cpum.GstCtx.cr0 & (X86_CR0_TS | X86_CR0_EM))
    72327134        return iemRaiseDeviceNotAvailable(pVCpu);
    72337135    if (GCPtrEff & 15)
    … …  
    72357137        /** @todo CPU/VM detection possible! \#AC might not be signal for
    72367138         * all/any misalignment sizes, intel says its an implementation detail. */
    7237         if (   (pCtx->cr0 & X86_CR0_AM)
    7238             && pCtx->eflags.Bits.u1AC
     7139        if (   (pVCpu->cpum.GstCtx.cr0 & X86_CR0_AM)
     7140            && pVCpu->cpum.GstCtx.eflags.Bits.u1AC
    72397141            && pVCpu->iem.s.uCpl == 3)
    72407142            return iemRaiseAlignmentCheckException(pVCpu);
    … …  
    72507152        return rcStrict;
    72517153    PX86FXSTATE  pDst = (PX86FXSTATE)pvMem512;
    7252     PCX86FXSTATE pSrc = &pCtx->CTX_SUFF(pXState)->x87;
     7154    PCX86FXSTATE pSrc = &pVCpu->cpum.GstCtx.CTX_SUFF(pXState)->x87;
    72537155
    72547156    /*
    … …  
    72957197
    72967198    /* XMM registers. */
    7297     if (   !(pCtx->msrEFER & MSR_K6_EFER_FFXSR)
     7199    if (   !(pVCpu->cpum.GstCtx.msrEFER & MSR_K6_EFER_FFXSR)
    72987200        || pVCpu->iem.s.enmCpuMode != IEMMODE_64BIT
    72997201        || pVCpu->iem.s.uCpl != 0)
    … …  
    73267228IEM_CIMPL_DEF_3(iemCImpl_fxrstor, uint8_t, iEffSeg, RTGCPTR, GCPtrEff, IEMMODE, enmEffOpSize)
    73277229{
    7328     PCPUMCTX pCtx = IEM_GET_CTX(pVCpu);
    7329     IEM_CTX_ASSERT(pCtx, CPUMCTX_EXTRN_CR0 | CPUMCTX_EXTRN_X87 | CPUMCTX_EXTRN_SSE_AVX);
     7230    IEM_CTX_ASSERT(pVCpu, CPUMCTX_EXTRN_CR0 | CPUMCTX_EXTRN_X87 | CPUMCTX_EXTRN_SSE_AVX);
    73307231
    73317232    /*
    73327233     * Raise exceptions.
    73337234     */
    7334     if (pCtx->cr0 & X86_CR0_EM)
     7235    if (pVCpu->cpum.GstCtx.cr0 & X86_CR0_EM)
    73357236        return iemRaiseUndefinedOpcode(pVCpu);
    7336     if (pCtx->cr0 & (X86_CR0_TS | X86_CR0_EM))
     7237    if (pVCpu->cpum.GstCtx.cr0 & (X86_CR0_TS | X86_CR0_EM))
    73377238        return iemRaiseDeviceNotAvailable(pVCpu);
    73387239    if (GCPtrEff & 15)
    … …  
    73407241        /** @todo CPU/VM detection possible! \#AC might not be signal for
    73417242         * all/any misalignment sizes, intel says its an implementation detail. */
    7342         if (   (pCtx->cr0 & X86_CR0_AM)
    7343             && pCtx->eflags.Bits.u1AC
     7243        if (   (pVCpu->cpum.GstCtx.cr0 & X86_CR0_AM)
     7244            && pVCpu->cpum.GstCtx.eflags.Bits.u1AC
    73447245            && pVCpu->iem.s.uCpl == 3)
    73457246            return iemRaiseAlignmentCheckException(pVCpu);
    … …  
    73557256        return rcStrict;
    73567257    PCX86FXSTATE pSrc = (PCX86FXSTATE)pvMem512;
    7357     PX86FXSTATE  pDst = &pCtx->CTX_SUFF(pXState)->x87;
     7258    PX86FXSTATE  pDst = &pVCpu->cpum.GstCtx.CTX_SUFF(pXState)->x87;
    73587259
    73597260    /*
    … …  
    74107311
    74117312    /* XMM registers. */
    7412     if (   !(pCtx->msrEFER & MSR_K6_EFER_FFXSR)
     7313    if (   !(pVCpu->cpum.GstCtx.msrEFER & MSR_K6_EFER_FFXSR)
    74137314        || pVCpu->iem.s.enmCpuMode != IEMMODE_64BIT
    74147315        || pVCpu->iem.s.uCpl != 0)
    … …  
    74417342IEM_CIMPL_DEF_3(iemCImpl_xsave, uint8_t, iEffSeg, RTGCPTR, GCPtrEff, IEMMODE, enmEffOpSize)
    74427343{
    7443     PCPUMCTX pCtx = IEM_GET_CTX(pVCpu);
    7444     IEM_CTX_ASSERT(pCtx, CPUMCTX_EXTRN_CR0 | CPUMCTX_EXTRN_X87 | CPUMCTX_EXTRN_SSE_AVX | CPUMCTX_EXTRN_OTHER_XSAVE | CPUMCTX_EXTRN_XCRx);
     7344    IEM_CTX_ASSERT(pVCpu, CPUMCTX_EXTRN_CR0 | CPUMCTX_EXTRN_X87 | CPUMCTX_EXTRN_SSE_AVX | CPUMCTX_EXTRN_OTHER_XSAVE | CPUMCTX_EXTRN_XCRx);
    74457345
    74467346    /*
    74477347     * Raise exceptions.
    74487348     */
    7449     if (!(pCtx->cr4 & X86_CR4_OSXSAVE))
     7349    if (!(pVCpu->cpum.GstCtx.cr4 & X86_CR4_OSXSAVE))
    74507350        return iemRaiseUndefinedOpcode(pVCpu);
    7451     if (pCtx->cr0 & X86_CR0_TS)
     7351    if (pVCpu->cpum.GstCtx.cr0 & X86_CR0_TS)
    74527352        return iemRaiseDeviceNotAvailable(pVCpu);
    74537353    if (GCPtrEff & 63)
    … …  
    74557355        /** @todo CPU/VM detection possible! \#AC might not be signal for
    74567356         * all/any misalignment sizes, intel says its an implementation detail. */
    7457         if (   (pCtx->cr0 & X86_CR0_AM)
    7458             && pCtx->eflags.Bits.u1AC
     7357        if (   (pVCpu->cpum.GstCtx.cr0 & X86_CR0_AM)
     7358            && pVCpu->cpum.GstCtx.eflags.Bits.u1AC
    74597359            && pVCpu->iem.s.uCpl == 3)
    74607360            return iemRaiseAlignmentCheckException(pVCpu);
    … …  
    74657365     * Calc the requested mask
    74667366     */
    7467     uint64_t const fReqComponents = RT_MAKE_U64(pCtx->eax, pCtx->edx) & pCtx->aXcr[0];
     7367    uint64_t const fReqComponents = RT_MAKE_U64(pVCpu->cpum.GstCtx.eax, pVCpu->cpum.GstCtx.edx) & pVCpu->cpum.GstCtx.aXcr[0];
    74687368    AssertLogRelReturn(!(fReqComponents & ~(XSAVE_C_X87 | XSAVE_C_SSE | XSAVE_C_YMM)), VERR_IEM_ASPECT_NOT_IMPLEMENTED);
    7469     uint64_t const fXInUse        = pCtx->aXcr[0];
     7369    uint64_t const fXInUse        = pVCpu->cpum.GstCtx.aXcr[0];
    74707370
    74717371/** @todo figure out the exact protocol for the memory access.  Currently we
    … …  
    74837383        return rcStrict;
    74847384    PX86FXSTATE  pDst = (PX86FXSTATE)pvMem512;
    7485     PCX86FXSTATE pSrc = &pCtx->CTX_SUFF(pXState)->x87;
     7385    PCX86FXSTATE pSrc = &pVCpu->cpum.GstCtx.CTX_SUFF(pXState)->x87;
    74867386
    74877387    /* The header.  */
    … …  
    75577457    {
    75587458        /** @todo testcase: xsave64 vs xsave32 wrt XSAVE_C_YMM. */
    7559         AssertLogRelReturn(pCtx->aoffXState[XSAVE_C_YMM_BIT] != UINT16_MAX, VERR_IEM_IPE_9);
    7560         PCX86XSAVEYMMHI pCompSrc = CPUMCTX_XSAVE_C_PTR(pCtx, XSAVE_C_YMM_BIT, PCX86XSAVEYMMHI);
     7459        AssertLogRelReturn(pVCpu->cpum.GstCtx.aoffXState[XSAVE_C_YMM_BIT] != UINT16_MAX, VERR_IEM_IPE_9);
     7460        PCX86XSAVEYMMHI pCompSrc = CPUMCTX_XSAVE_C_PTR(IEM_GET_CTX(pVCpu), XSAVE_C_YMM_BIT, PCX86XSAVEYMMHI);
    75617461        PX86XSAVEYMMHI  pCompDst;
    7562         rcStrict = iemMemMap(pVCpu, (void **)&pCompDst, sizeof(*pCompDst), iEffSeg, GCPtrEff + pCtx->aoffXState[XSAVE_C_YMM_BIT],
     7462        rcStrict = iemMemMap(pVCpu, (void **)&pCompDst, sizeof(*pCompDst), iEffSeg, GCPtrEff + pVCpu->cpum.GstCtx.aoffXState[XSAVE_C_YMM_BIT],
    75637463                             IEM_ACCESS_DATA_W | IEM_ACCESS_PARTIAL_WRITE);
    75647464        if (rcStrict != VINF_SUCCESS)
    … …  
    75987498IEM_CIMPL_DEF_3(iemCImpl_xrstor, uint8_t, iEffSeg, RTGCPTR, GCPtrEff, IEMMODE, enmEffOpSize)
    75997499{
    7600     PCPUMCTX pCtx = IEM_GET_CTX(pVCpu);
    7601     IEM_CTX_ASSERT(pCtx, CPUMCTX_EXTRN_CR0 | CPUMCTX_EXTRN_X87 | CPUMCTX_EXTRN_SSE_AVX | CPUMCTX_EXTRN_OTHER_XSAVE | CPUMCTX_EXTRN_XCRx);
     7500    IEM_CTX_ASSERT(pVCpu, CPUMCTX_EXTRN_CR0 | CPUMCTX_EXTRN_X87 | CPUMCTX_EXTRN_SSE_AVX | CPUMCTX_EXTRN_OTHER_XSAVE | CPUMCTX_EXTRN_XCRx);
    76027501
    76037502    /*
    76047503     * Raise exceptions.
    76057504     */
    7606     if (!(pCtx->cr4 & X86_CR4_OSXSAVE))
     7505    if (!(pVCpu->cpum.GstCtx.cr4 & X86_CR4_OSXSAVE))
    76077506        return iemRaiseUndefinedOpcode(pVCpu);
    7608     if (pCtx->cr0 & X86_CR0_TS)
     7507    if (pVCpu->cpum.GstCtx.cr0 & X86_CR0_TS)
    76097508        return iemRaiseDeviceNotAvailable(pVCpu);
    76107509    if (GCPtrEff & 63)
    … …  
    76127511        /** @todo CPU/VM detection possible! \#AC might not be signal for
    76137512         * all/any misalignment sizes, intel says its an implementation detail. */
    7614         if (   (pCtx->cr0 & X86_CR0_AM)
    7615             && pCtx->eflags.Bits.u1AC
     7513        if (   (pVCpu->cpum.GstCtx.cr0 & X86_CR0_AM)
     7514            && pVCpu->cpum.GstCtx.eflags.Bits.u1AC
    76167515            && pVCpu->iem.s.uCpl == 3)
    76177516            return iemRaiseAlignmentCheckException(pVCpu);
    … …  
    76337532        return rcStrict;
    76347533    PCX86FXSTATE pSrc = (PCX86FXSTATE)pvMem512;
    7635     PX86FXSTATE  pDst = &pCtx->CTX_SUFF(pXState)->x87;
     7534    PX86FXSTATE  pDst = &pVCpu->cpum.GstCtx.CTX_SUFF(pXState)->x87;
    76367535
    76377536    /*
    76387537     * Calc the requested mask
    76397538     */
    7640     PX86XSAVEHDR  pHdrDst = &pCtx->CTX_SUFF(pXState)->Hdr;
     7539    PX86XSAVEHDR  pHdrDst = &pVCpu->cpum.GstCtx.CTX_SUFF(pXState)->Hdr;
    76417540    PCX86XSAVEHDR pHdrSrc;
    76427541    rcStrict = iemMemMap(pVCpu, (void **)&pHdrSrc, sizeof(&pHdrSrc), iEffSeg, GCPtrEff + 512, IEM_ACCESS_DATA_R);
    … …  
    76447543        return rcStrict;
    76457544
    7646     uint64_t const fReqComponents = RT_MAKE_U64(pCtx->eax, pCtx->edx) & pCtx->aXcr[0];
     7545    uint64_t const fReqComponents = RT_MAKE_U64(pVCpu->cpum.GstCtx.eax, pVCpu->cpum.GstCtx.edx) & pVCpu->cpum.GstCtx.aXcr[0];
    76477546    AssertLogRelReturn(!(fReqComponents & ~(XSAVE_C_X87 | XSAVE_C_SSE | XSAVE_C_YMM)), VERR_IEM_ASPECT_NOT_IMPLEMENTED);
    7648     //uint64_t const fXInUse        = pCtx->aXcr[0];
     7547    //uint64_t const fXInUse        = pVCpu->cpum.GstCtx.aXcr[0];
    76497548    uint64_t const fRstorMask     = pHdrSrc->bmXState;
    76507549    uint64_t const fCompMask      = pHdrSrc->bmXComp;
    … …  
    77567655    if (fReqComponents & XSAVE_C_YMM)
    77577656    {
    7758         AssertLogRelReturn(pCtx->aoffXState[XSAVE_C_YMM_BIT] != UINT16_MAX, VERR_IEM_IPE_9);
    7759         PX86XSAVEYMMHI  pCompDst = CPUMCTX_XSAVE_C_PTR(pCtx, XSAVE_C_YMM_BIT, PX86XSAVEYMMHI);
     7657        AssertLogRelReturn(pVCpu->cpum.GstCtx.aoffXState[XSAVE_C_YMM_BIT] != UINT16_MAX, VERR_IEM_IPE_9);
     7658        PX86XSAVEYMMHI  pCompDst = CPUMCTX_XSAVE_C_PTR(IEM_GET_CTX(pVCpu), XSAVE_C_YMM_BIT, PX86XSAVEYMMHI);
    77607659
    77617660        if (fRstorMask & XSAVE_C_YMM)
    … …  
    77647663            PCX86XSAVEYMMHI pCompSrc;
    77657664            rcStrict = iemMemMap(pVCpu, (void **)&pCompSrc, sizeof(*pCompDst),
    7766                                  iEffSeg, GCPtrEff + pCtx->aoffXState[XSAVE_C_YMM_BIT], IEM_ACCESS_DATA_R);
     7665                                 iEffSeg, GCPtrEff + pVCpu->cpum.GstCtx.aoffXState[XSAVE_C_YMM_BIT], IEM_ACCESS_DATA_R);
    77677666            if (rcStrict != VINF_SUCCESS)
    77687667                return rcStrict;
    … …  
    78037702IEM_CIMPL_DEF_2(iemCImpl_stmxcsr, uint8_t, iEffSeg, RTGCPTR, GCPtrEff)
    78047703{
    7805     PCPUMCTX pCtx = IEM_GET_CTX(pVCpu);
    7806     IEM_CTX_ASSERT(pCtx, CPUMCTX_EXTRN_CR0 | CPUMCTX_EXTRN_X87 | CPUMCTX_EXTRN_SSE_AVX);
     7704    IEM_CTX_ASSERT(pVCpu, CPUMCTX_EXTRN_CR0 | CPUMCTX_EXTRN_X87 | CPUMCTX_EXTRN_SSE_AVX);
    78077705
    78087706    /*
    78097707     * Raise exceptions.
    78107708     */
    7811     if (   !(pCtx->cr0 & X86_CR0_EM)
    7812         && (pCtx->cr4 & X86_CR4_OSFXSR))
    7813     {
    7814         if (!(pCtx->cr0 & X86_CR0_TS))
     7709    if (   !(pVCpu->cpum.GstCtx.cr0 & X86_CR0_EM)
     7710        && (pVCpu->cpum.GstCtx.cr4 & X86_CR4_OSFXSR))
     7711    {
     7712        if (!(pVCpu->cpum.GstCtx.cr0 & X86_CR0_TS))
    78157713        {
    78167714            /*
    78177715             * Do the job.
    78187716             */
    7819             VBOXSTRICTRC rcStrict = iemMemStoreDataU32(pVCpu, iEffSeg, GCPtrEff, pCtx->CTX_SUFF(pXState)->x87.MXCSR);
     7717            VBOXSTRICTRC rcStrict = iemMemStoreDataU32(pVCpu, iEffSeg, GCPtrEff, pVCpu->cpum.GstCtx.CTX_SUFF(pXState)->x87.MXCSR);
    78207718            if (rcStrict == VINF_SUCCESS)
    78217719            {
    … …  
    78387736IEM_CIMPL_DEF_2(iemCImpl_vstmxcsr, uint8_t, iEffSeg, RTGCPTR, GCPtrEff)
    78397737{
    7840     PCPUMCTX pCtx = IEM_GET_CTX(pVCpu);
    7841     IEM_CTX_ASSERT(pCtx, CPUMCTX_EXTRN_CR0 | CPUMCTX_EXTRN_X87 | CPUMCTX_EXTRN_SSE_AVX | CPUMCTX_EXTRN_XCRx);
     7738    IEM_CTX_ASSERT(pVCpu, CPUMCTX_EXTRN_CR0 | CPUMCTX_EXTRN_X87 | CPUMCTX_EXTRN_SSE_AVX | CPUMCTX_EXTRN_XCRx);
    78427739
    78437740    /*
    … …  
    78457742     */
    78467743    if (   (   !IEM_IS_GUEST_CPU_AMD(pVCpu)
    7847             ? (pCtx->aXcr[0] & (XSAVE_C_SSE | XSAVE_C_YMM)) == (XSAVE_C_SSE | XSAVE_C_YMM)
    7848             : !(pCtx->cr0 & X86_CR0_EM)) /* AMD Jaguar CPU (f0x16,m0,s1) behaviour */
    7849         && (pCtx->cr4 & X86_CR4_OSXSAVE))
    7850     {
    7851         if (!(pCtx->cr0 & X86_CR0_TS))
     7744            ? (pVCpu->cpum.GstCtx.aXcr[0] & (XSAVE_C_SSE | XSAVE_C_YMM)) == (XSAVE_C_SSE | XSAVE_C_YMM)
     7745            : !(pVCpu->cpum.GstCtx.cr0 & X86_CR0_EM)) /* AMD Jaguar CPU (f0x16,m0,s1) behaviour */
     7746        && (pVCpu->cpum.GstCtx.cr4 & X86_CR4_OSXSAVE))
     7747    {
     7748        if (!(pVCpu->cpum.GstCtx.cr0 & X86_CR0_TS))
    78527749        {
    78537750            /*
    78547751             * Do the job.
    78557752             */
    7856             VBOXSTRICTRC rcStrict = iemMemStoreDataU32(pVCpu, iEffSeg, GCPtrEff, pCtx->CTX_SUFF(pXState)->x87.MXCSR);
     7753            VBOXSTRICTRC rcStrict = iemMemStoreDataU32(pVCpu, iEffSeg, GCPtrEff, pVCpu->cpum.GstCtx.CTX_SUFF(pXState)->x87.MXCSR);
    78577754            if (rcStrict == VINF_SUCCESS)
    78587755            {
    … …  
    78757772IEM_CIMPL_DEF_2(iemCImpl_ldmxcsr, uint8_t, iEffSeg, RTGCPTR, GCPtrEff)
    78767773{
    7877     PCPUMCTX pCtx = IEM_GET_CTX(pVCpu);
    7878     IEM_CTX_ASSERT(pCtx, CPUMCTX_EXTRN_CR0 | CPUMCTX_EXTRN_X87 | CPUMCTX_EXTRN_SSE_AVX);
     7774    IEM_CTX_ASSERT(pVCpu, CPUMCTX_EXTRN_CR0 | CPUMCTX_EXTRN_X87 | CPUMCTX_EXTRN_SSE_AVX);
    78797775
    78807776    /*
    … …  
    78837779    /** @todo testcase - order of LDMXCSR faults.  Does \#PF, \#GP and \#SS
    78847780     *        happen after or before \#UD and \#EM? */
    7885     if (   !(pCtx->cr0 & X86_CR0_EM)
    7886         && (pCtx->cr4 & X86_CR4_OSFXSR))
    7887     {
    7888         if (!(pCtx->cr0 & X86_CR0_TS))
     7781    if (   !(pVCpu->cpum.GstCtx.cr0 & X86_CR0_EM)
     7782        && (pVCpu->cpum.GstCtx.cr4 & X86_CR4_OSFXSR))
     7783    {
     7784        if (!(pVCpu->cpum.GstCtx.cr0 & X86_CR0_TS))
    78897785        {
    78907786            /*
    … …  
    78987794                if (!(fNewMxCsr & ~fMxCsrMask))
    78997795                {
    7900                     pCtx->CTX_SUFF(pXState)->x87.MXCSR = fNewMxCsr;
     7796                    pVCpu->cpum.GstCtx.CTX_SUFF(pXState)->x87.MXCSR = fNewMxCsr;
    79017797                    iemRegAddToRipAndClearRF(pVCpu, cbInstr);
    79027798                    return VINF_SUCCESS;
    … …  
    79177813 * Commmon routine for fnstenv and fnsave.
    79187814 *
    7919  * @param   uPtr                Where to store the state.
    7920  * @param   pCtx                The CPU context.
    7921  */
    7922 static void iemCImplCommonFpuStoreEnv(PVMCPU pVCpu, IEMMODE enmEffOpSize, RTPTRUNION uPtr, PCCPUMCTX pCtx)
    7923 {
    7924     IEM_CTX_ASSERT(pCtx, CPUMCTX_EXTRN_CR0 | CPUMCTX_EXTRN_X87);
    7925     PCX86FXSTATE pSrcX87 = &pCtx->CTX_SUFF(pXState)->x87;
     7815 * @param   pVCpu           The cross context virtual CPU structure of the calling thread.
     7816 * @param   enmEffOpSize    The effective operand size.
     7817 * @param   uPtr            Where to store the state.
     7818 */
     7819static void iemCImplCommonFpuStoreEnv(PVMCPU pVCpu, IEMMODE enmEffOpSize, RTPTRUNION uPtr)
     7820{
     7821    IEM_CTX_ASSERT(pVCpu, CPUMCTX_EXTRN_CR0 | CPUMCTX_EXTRN_X87);
     7822    PCX86FXSTATE pSrcX87 = &pVCpu->cpum.GstCtx.CTX_SUFF(pXState)->x87;
    79267823    if (enmEffOpSize == IEMMODE_16BIT)
    79277824    {
    … …  
    79817878 * Commmon routine for fldenv and frstor
    79827879 *
     7880 * @param   pVCpu           The cross context virtual CPU structure of the calling thread.
     7881 * @param   enmEffOpSize    The effective operand size.
    79837882 * @param   uPtr                Where to store the state.
    7984  * @param   pCtx                The CPU context.
    7985  */
    7986 static void iemCImplCommonFpuRestoreEnv(PVMCPU pVCpu, IEMMODE enmEffOpSize, RTCPTRUNION uPtr, PCPUMCTX pCtx)
    7987 {
    7988     IEM_CTX_ASSERT(pCtx, CPUMCTX_EXTRN_CR0 | CPUMCTX_EXTRN_X87);
    7989     PX86FXSTATE pDstX87 = &pCtx->CTX_SUFF(pXState)->x87;
     7883 */
     7884static void iemCImplCommonFpuRestoreEnv(PVMCPU pVCpu, IEMMODE enmEffOpSize, RTCPTRUNION uPtr)
     7885{
     7886    IEM_CTX_ASSERT(pVCpu, CPUMCTX_EXTRN_CR0 | CPUMCTX_EXTRN_X87);
     7887    PX86FXSTATE pDstX87 = &pVCpu->cpum.GstCtx.CTX_SUFF(pXState)->x87;
    79907888    if (enmEffOpSize == IEMMODE_16BIT)
    79917889    {
    … …  
    80597957IEM_CIMPL_DEF_3(iemCImpl_fnstenv, IEMMODE, enmEffOpSize, uint8_t, iEffSeg, RTGCPTR, GCPtrEffDst)
    80607958{
    8061     PCPUMCTX     pCtx = IEM_GET_CTX(pVCpu);
    80627959    RTPTRUNION   uPtr;
    80637960    VBOXSTRICTRC rcStrict = iemMemMap(pVCpu, &uPtr.pv, enmEffOpSize == IEMMODE_16BIT ? 14 : 28,
    … …  
    80667963        return rcStrict;
    80677964
    8068     iemCImplCommonFpuStoreEnv(pVCpu, enmEffOpSize, uPtr, pCtx);
     7965    iemCImplCommonFpuStoreEnv(pVCpu, enmEffOpSize, uPtr);
    80697966
    80707967    rcStrict = iemMemCommitAndUnmap(pVCpu, uPtr.pv, IEM_ACCESS_DATA_W | IEM_ACCESS_PARTIAL_WRITE);
    … …  
    80867983IEM_CIMPL_DEF_3(iemCImpl_fnsave, IEMMODE, enmEffOpSize, uint8_t, iEffSeg, RTGCPTR, GCPtrEffDst)
    80877984{
    8088     PCPUMCTX     pCtx = IEM_GET_CTX(pVCpu);
    8089     IEM_CTX_ASSERT(pCtx, CPUMCTX_EXTRN_CR0 | CPUMCTX_EXTRN_X87);
     7985    IEM_CTX_ASSERT(pVCpu, CPUMCTX_EXTRN_CR0 | CPUMCTX_EXTRN_X87);
    80907986
    80917987    RTPTRUNION   uPtr;
    … …  
    80957991        return rcStrict;
    80967992
    8097     PX86FXSTATE pFpuCtx = &pCtx->CTX_SUFF(pXState)->x87;
    8098     iemCImplCommonFpuStoreEnv(pVCpu, enmEffOpSize, uPtr, pCtx);
     7993    PX86FXSTATE pFpuCtx = &pVCpu->cpum.GstCtx.CTX_SUFF(pXState)->x87;
     7994    iemCImplCommonFpuStoreEnv(pVCpu, enmEffOpSize, uPtr);
    80997995    PRTFLOAT80U paRegs = (PRTFLOAT80U)(uPtr.pu8 + (enmEffOpSize == IEMMODE_16BIT ? 14 : 28));
    81007996    for (uint32_t i = 0; i < RT_ELEMENTS(pFpuCtx->aRegs); i++)
    … …  
    81398035IEM_CIMPL_DEF_3(iemCImpl_fldenv, IEMMODE, enmEffOpSize, uint8_t, iEffSeg, RTGCPTR, GCPtrEffSrc)
    81408036{
    8141     PCPUMCTX     pCtx = IEM_GET_CTX(pVCpu);
    81428037    RTCPTRUNION  uPtr;
    81438038    VBOXSTRICTRC rcStrict = iemMemMap(pVCpu, (void **)&uPtr.pv, enmEffOpSize == IEMMODE_16BIT ? 14 : 28,
    … …  
    81468041        return rcStrict;
    81478042
    8148     iemCImplCommonFpuRestoreEnv(pVCpu, enmEffOpSize, uPtr, pCtx);
     8043    iemCImplCommonFpuRestoreEnv(pVCpu, enmEffOpSize, uPtr);
    81498044
    81508045    rcStrict = iemMemCommitAndUnmap(pVCpu, (void *)uPtr.pv, IEM_ACCESS_DATA_R);
    … …  
    81668061IEM_CIMPL_DEF_3(iemCImpl_frstor, IEMMODE, enmEffOpSize, uint8_t, iEffSeg, RTGCPTR, GCPtrEffSrc)
    81678062{
    8168     PCPUMCTX     pCtx = IEM_GET_CTX(pVCpu);
    81698063    RTCPTRUNION  uPtr;
    81708064    VBOXSTRICTRC rcStrict = iemMemMap(pVCpu, (void **)&uPtr.pv, enmEffOpSize == IEMMODE_16BIT ? 94 : 108,
    … …  
    81738067        return rcStrict;
    81748068
    8175     PX86FXSTATE pFpuCtx = &pCtx->CTX_SUFF(pXState)->x87;
    8176     iemCImplCommonFpuRestoreEnv(pVCpu, enmEffOpSize, uPtr, pCtx);
     8069    PX86FXSTATE pFpuCtx = &pVCpu->cpum.GstCtx.CTX_SUFF(pXState)->x87;
     8070    iemCImplCommonFpuRestoreEnv(pVCpu, enmEffOpSize, uPtr);
    81778071    PCRTFLOAT80U paRegs = (PCRTFLOAT80U)(uPtr.pu8 + (enmEffOpSize == IEMMODE_16BIT ? 14 : 28));
    81788072    for (uint32_t i = 0; i < RT_ELEMENTS(pFpuCtx->aRegs); i++)
    … …  
    82018095IEM_CIMPL_DEF_1(iemCImpl_fldcw, uint16_t, u16Fcw)
    82028096{
    8203     PCPUMCTX pCtx = IEM_GET_CTX(pVCpu);
    8204     IEM_CTX_ASSERT(pCtx, CPUMCTX_EXTRN_CR0 | CPUMCTX_EXTRN_X87);
     8097    IEM_CTX_ASSERT(pVCpu, CPUMCTX_EXTRN_CR0 | CPUMCTX_EXTRN_X87);
    82058098
    82068099    /** @todo Testcase: Check what happens when trying to load X86_FCW_PC_RSVD. */
    … …  
    82098102    /** @todo Testcase: Test that it raises and loweres the FPU exception bits
    82108103     *        according to FSW. (This is was is currently implemented.) */
    8211     PX86FXSTATE pFpuCtx = &pCtx->CTX_SUFF(pXState)->x87;
     8104    PX86FXSTATE pFpuCtx = &pVCpu->cpum.GstCtx.CTX_SUFF(pXState)->x87;
    82128105    pFpuCtx->FCW = u16Fcw & ~X86_FCW_ZERO_MASK;
    82138106    iemFpuRecalcExceptionStatus(pFpuCtx);
    … …  
    82288121IEM_CIMPL_DEF_1(iemCImpl_fxch_underflow, uint8_t, iStReg)
    82298122{
    8230     PCPUMCTX pCtx = IEM_GET_CTX(pVCpu);
    8231     IEM_CTX_ASSERT(pCtx, CPUMCTX_EXTRN_CR0 | CPUMCTX_EXTRN_X87);
    8232 
    8233     PX86FXSTATE pFpuCtx = &pCtx->CTX_SUFF(pXState)->x87;
     8123    IEM_CTX_ASSERT(pVCpu, CPUMCTX_EXTRN_CR0 | CPUMCTX_EXTRN_X87);
     8124
     8125    PX86FXSTATE pFpuCtx = &pVCpu->cpum.GstCtx.CTX_SUFF(pXState)->x87;
    82348126    unsigned const iReg1 = X86_FSW_TOP_GET(pFpuCtx->FSW);
    82358127    unsigned const iReg2 = (iReg1 + iStReg) & X86_FSW_TOP_SMASK;
    … …  
    82648156    }
    82658157
    8266     iemFpuUpdateOpcodeAndIpWorker(pVCpu, pCtx, pFpuCtx);
     8158    iemFpuUpdateOpcodeAndIpWorker(pVCpu, pFpuCtx);
    82678159    iemHlpUsedFpu(pVCpu);
    82688160    iemRegAddToRipAndClearRF(pVCpu, cbInstr);
    … …  
    82788170IEM_CIMPL_DEF_3(iemCImpl_fcomi_fucomi, uint8_t, iStReg, PFNIEMAIMPLFPUR80EFL, pfnAImpl, bool, fPop)
    82798171{
    8280     PCPUMCTX pCtx = IEM_GET_CTX(pVCpu);
    82818172    Assert(iStReg < 8);
    8282     IEM_CTX_ASSERT(pCtx, CPUMCTX_EXTRN_CR0 | CPUMCTX_EXTRN_X87);
     8173    IEM_CTX_ASSERT(pVCpu, CPUMCTX_EXTRN_CR0 | CPUMCTX_EXTRN_X87);
    82838174
    82848175    /*
    82858176     * Raise exceptions.
    82868177     */
    8287     if (pCtx->cr0 & (X86_CR0_EM | X86_CR0_TS))
     8178    if (pVCpu->cpum.GstCtx.cr0 & (X86_CR0_EM | X86_CR0_TS))
    82888179        return iemRaiseDeviceNotAvailable(pVCpu);
    82898180
    8290     PX86FXSTATE pFpuCtx = &pCtx->CTX_SUFF(pXState)->x87;
     8181    PX86FXSTATE pFpuCtx = &pVCpu->cpum.GstCtx.CTX_SUFF(pXState)->x87;
    82918182    uint16_t u16Fsw = pFpuCtx->FSW;
    82928183    if (u16Fsw & X86_FSW_ES)
    … …  
    83088199            || (pFpuCtx->FCW & X86_FCW_IM) )
    83098200        {
    8310             pCtx->eflags.u &= ~(X86_EFL_OF | X86_EFL_SF | X86_EFL_AF | X86_EFL_ZF | X86_EFL_PF | X86_EFL_CF);
    8311             pCtx->eflags.u |= pCtx->eflags.u & (X86_EFL_ZF | X86_EFL_PF | X86_EFL_CF);
     8201            pVCpu->cpum.GstCtx.eflags.u &= ~(X86_EFL_OF | X86_EFL_SF | X86_EFL_AF | X86_EFL_ZF | X86_EFL_PF | X86_EFL_CF);
     8202            pVCpu->cpum.GstCtx.eflags.u |= pVCpu->cpum.GstCtx.eflags.u & (X86_EFL_ZF | X86_EFL_PF | X86_EFL_CF);
    83128203        }
    83138204    }
    … …  
    83178208        pFpuCtx->FSW &= ~X86_FSW_C1;
    83188209        pFpuCtx->FSW |= X86_FSW_IE | X86_FSW_SF;
    8319         pCtx->eflags.u &= ~(X86_EFL_OF | X86_EFL_SF | X86_EFL_AF | X86_EFL_ZF | X86_EFL_PF | X86_EFL_CF);
    8320         pCtx->eflags.u |= X86_EFL_ZF | X86_EFL_PF | X86_EFL_CF;
     8210        pVCpu->cpum.GstCtx.eflags.u &= ~(X86_EFL_OF | X86_EFL_SF | X86_EFL_AF | X86_EFL_ZF | X86_EFL_PF | X86_EFL_CF);
     8211        pVCpu->cpum.GstCtx.eflags.u |= X86_EFL_ZF | X86_EFL_PF | X86_EFL_CF;
    83218212    }
    83228213    else
    … …  
    83388229    }
    83398230
    8340     iemFpuUpdateOpcodeAndIpWorker(pVCpu, pCtx, pFpuCtx);
     8231    iemFpuUpdateOpcodeAndIpWorker(pVCpu, pFpuCtx);
    83418232    iemHlpUsedFpu(pVCpu);
    83428233    iemRegAddToRipAndClearRF(pVCpu, cbInstr);

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

    r72493 r72496  
    166166    }
    167167
    168     IEM_CTX_IMPORT_RET(pVCpu, pCtx, CPUMCTX_EXTRN_SREG_FROM_IDX(iEffSeg) | CPUMCTX_EXTRN_ES);
     168    IEM_CTX_IMPORT_RET(pVCpu, CPUMCTX_EXTRN_SREG_FROM_IDX(iEffSeg) | CPUMCTX_EXTRN_ES);
    169169
    170170    PCCPUMSELREGHID pSrc1Hid     = iemSRegGetHid(pVCpu, iEffSeg);
    … …  
    337337    }
    338338
    339     IEM_CTX_IMPORT_RET(pVCpu, pCtx, CPUMCTX_EXTRN_SREG_FROM_IDX(iEffSeg) | CPUMCTX_EXTRN_ES);
     339    IEM_CTX_IMPORT_RET(pVCpu, CPUMCTX_EXTRN_SREG_FROM_IDX(iEffSeg) | CPUMCTX_EXTRN_ES);
    340340
    341341    PCCPUMSELREGHID pSrc1Hid = iemSRegGetHid(pVCpu, iEffSeg);
    … …  
    508508    }
    509509
    510     IEM_CTX_IMPORT_RET(pVCpu, pCtx, CPUMCTX_EXTRN_ES);
     510    IEM_CTX_IMPORT_RET(pVCpu, CPUMCTX_EXTRN_ES);
    511511    uint64_t        uBaseAddr;
    512512    VBOXSTRICTRC rcStrict = iemMemSegCheckReadAccessEx(pVCpu, iemSRegUpdateHid(pVCpu, &pCtx->es), X86_SREG_ES, &uBaseAddr);
    … …  
    641641    }
    642642
    643     IEM_CTX_IMPORT_RET(pVCpu, pCtx, CPUMCTX_EXTRN_ES);
     643    IEM_CTX_IMPORT_RET(pVCpu, CPUMCTX_EXTRN_ES);
    644644    uint64_t        uBaseAddr;
    645645    VBOXSTRICTRC rcStrict = iemMemSegCheckReadAccessEx(pVCpu, iemSRegUpdateHid(pVCpu, &pCtx->es), X86_SREG_ES, &uBaseAddr);
    … …  
    775775    }
    776776
    777     IEM_CTX_IMPORT_RET(pVCpu, pCtx, CPUMCTX_EXTRN_SREG_FROM_IDX(iEffSeg) | CPUMCTX_EXTRN_ES);
     777    IEM_CTX_IMPORT_RET(pVCpu, CPUMCTX_EXTRN_SREG_FROM_IDX(iEffSeg) | CPUMCTX_EXTRN_ES);
    778778
    779779    PCCPUMSELREGHID pSrcHid = iemSRegGetHid(pVCpu, iEffSeg);
    … …  
    936936    }
    937937
    938     IEM_CTX_IMPORT_RET(pVCpu, pCtx, CPUMCTX_EXTRN_ES);
     938    IEM_CTX_IMPORT_RET(pVCpu, CPUMCTX_EXTRN_ES);
    939939
    940940    uint64_t        uBaseAddr;
    … …  
    10711071    }
    10721072
    1073     IEM_CTX_IMPORT_RET(pVCpu, pCtx, CPUMCTX_EXTRN_SREG_FROM_IDX(iEffSeg));
     1073    IEM_CTX_IMPORT_RET(pVCpu, CPUMCTX_EXTRN_SREG_FROM_IDX(iEffSeg));
    10741074    PCCPUMSELREGHID pSrcHid = iemSRegGetHid(pVCpu, iEffSeg);
    10751075    uint64_t        uBaseAddr;
    … …  
    12071207    if (!fIoChecked)
    12081208    {
    1209         rcStrict = iemHlpCheckPortIOPermission(pVCpu, pCtx, pCtx->dx, OP_SIZE / 8);
     1209        rcStrict = iemHlpCheckPortIOPermission(pVCpu, pCtx->dx, OP_SIZE / 8);
    12101210        if (rcStrict != VINF_SUCCESS)
    12111211            return rcStrict;
    … …  
    12691269    PCPUMCTX    pCtx  = IEM_GET_CTX(pVCpu);
    12701270
    1271     IEM_CTX_IMPORT_RET(pVCpu, pCtx, CPUMCTX_EXTRN_ES | CPUMCTX_EXTRN_TR);
     1271    IEM_CTX_IMPORT_RET(pVCpu, CPUMCTX_EXTRN_ES | CPUMCTX_EXTRN_TR);
    12721272
    12731273    /*
    … …  
    12791279    {
    12801280/** @todo check if this is too early for ecx=0. */
    1281         rcStrict = iemHlpCheckPortIOPermission(pVCpu, pCtx, u16Port, OP_SIZE / 8);
     1281        rcStrict = iemHlpCheckPortIOPermission(pVCpu, u16Port, OP_SIZE / 8);
    12821282        if (rcStrict != VINF_SUCCESS)
    12831283            return rcStrict;
    … …  
    14781478    if (!fIoChecked)
    14791479    {
    1480         rcStrict = iemHlpCheckPortIOPermission(pVCpu, pCtx, pCtx->dx, OP_SIZE / 8);
     1480        rcStrict = iemHlpCheckPortIOPermission(pVCpu, pCtx->dx, OP_SIZE / 8);
    14811481        if (rcStrict != VINF_SUCCESS)
    14821482            return rcStrict;
    … …  
    15381538    {
    15391539/** @todo check if this is too early for ecx=0. */
    1540         rcStrict = iemHlpCheckPortIOPermission(pVCpu, pCtx, u16Port, OP_SIZE / 8);
     1540        rcStrict = iemHlpCheckPortIOPermission(pVCpu, u16Port, OP_SIZE / 8);
    15411541        if (rcStrict != VINF_SUCCESS)
    15421542            return rcStrict;

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

    r72469 r72496  
    5858 * @returns Strict VBox status code.
    5959 * @param   pVCpu       The cross context virtual CPU structure.
    60  * @param   pCtx        The guest-CPU context.
    61  */
    62 DECLINLINE(VBOXSTRICTRC) iemSvmWorldSwitch(PVMCPU pVCpu, PCPUMCTX pCtx)
     60 */
     61DECLINLINE(VBOXSTRICTRC) iemSvmWorldSwitch(PVMCPU pVCpu)
    6362{
    6463    /*
    … …  
    6766     * see comment in iemMemPageTranslateAndCheckAccess().
    6867     */
    69     int rc = PGMChangeMode(pVCpu, pCtx->cr0 | X86_CR0_PE, pCtx->cr4, pCtx->msrEFER);
     68    int rc = PGMChangeMode(pVCpu, pVCpu->cpum.GstCtx.cr0 | X86_CR0_PE, pVCpu->cpum.GstCtx.cr4, pVCpu->cpum.GstCtx.msrEFER);
    7069# ifdef IN_RING3
    7170    Assert(rc != VINF_PGM_CHANGE_MODE);
    … …  
    8281    if (rc == VINF_SUCCESS)
    8382    {
    84         rc = PGMFlushTLB(pVCpu, pCtx->cr3, true);
     83        rc = PGMFlushTLB(pVCpu, pVCpu->cpum.GstCtx.cr3, true);
    8584        AssertRCReturn(rc, rc);
    8685    }
    … …  
    101100 *
    102101 * @param   pVCpu       The cross context virtual CPU structure.
    103  * @param   pCtx        The guest-CPU context.
    104102 * @param   uExitCode   The exit code.
    105103 * @param   uExitInfo1  The exit info. 1 field.
    106104 * @param   uExitInfo2  The exit info. 2 field.
    107105 */
    108 IEM_STATIC VBOXSTRICTRC iemSvmVmexit(PVMCPU pVCpu, PCPUMCTX pCtx, uint64_t uExitCode, uint64_t uExitInfo1, uint64_t uExitInfo2)
     106IEM_STATIC VBOXSTRICTRC iemSvmVmexit(PVMCPU pVCpu, uint64_t uExitCode, uint64_t uExitInfo1, uint64_t uExitInfo2)
    109107{
    110108    VBOXSTRICTRC rcStrict;
    111     if (   CPUMIsGuestInSvmNestedHwVirtMode(pCtx)
     109    if (   CPUMIsGuestInSvmNestedHwVirtMode(IEM_GET_CTX(pVCpu))
    112110        || uExitCode == SVM_EXIT_INVALID)
    113111    {
    114         LogFlow(("iemSvmVmexit: CS:RIP=%04x:%08RX64 uExitCode=%#RX64 uExitInfo1=%#RX64 uExitInfo2=%#RX64\n", pCtx->cs.Sel,
    115                  pCtx->rip, uExitCode, uExitInfo1, uExitInfo2));
     112        LogFlow(("iemSvmVmexit: CS:RIP=%04x:%08RX64 uExitCode=%#RX64 uExitInfo1=%#RX64 uExitInfo2=%#RX64\n", pVCpu->cpum.GstCtx.cs.Sel,
     113                 pVCpu->cpum.GstCtx.rip, uExitCode, uExitInfo1, uExitInfo2));
    116114
    117115        /*
    118116         * Disable the global interrupt flag to prevent interrupts during the 'atomic' world switch.
    119117         */
    120         pCtx->hwvirt.fGif = false;
    121 
    122         Assert(CPUMSELREG_ARE_HIDDEN_PARTS_VALID(pVCpu, &pCtx->es));
    123         Assert(CPUMSELREG_ARE_HIDDEN_PARTS_VALID(pVCpu, &pCtx->cs));
    124         Assert(CPUMSELREG_ARE_HIDDEN_PARTS_VALID(pVCpu, &pCtx->ss));
    125         Assert(CPUMSELREG_ARE_HIDDEN_PARTS_VALID(pVCpu, &pCtx->ds));
     118        pVCpu->cpum.GstCtx.hwvirt.fGif = false;
     119
     120        Assert(CPUMSELREG_ARE_HIDDEN_PARTS_VALID(pVCpu, &pVCpu->cpum.GstCtx.es));
     121        Assert(CPUMSELREG_ARE_HIDDEN_PARTS_VALID(pVCpu, &pVCpu->cpum.GstCtx.cs));
     122        Assert(CPUMSELREG_ARE_HIDDEN_PARTS_VALID(pVCpu, &pVCpu->cpum.GstCtx.ss));
     123        Assert(CPUMSELREG_ARE_HIDDEN_PARTS_VALID(pVCpu, &pVCpu->cpum.GstCtx.ds));
    126124
    127125        /*
    … …  
    132130        PSVMVMCB       pVmcbMem;
    133131        PGMPAGEMAPLOCK PgLockMem;
    134         PSVMVMCBCTRL   pVmcbCtrl = &pCtx->hwvirt.svm.CTX_SUFF(pVmcb)->ctrl;
    135         rcStrict = iemMemPageMap(pVCpu, pCtx->hwvirt.svm.GCPhysVmcb, IEM_ACCESS_DATA_RW, (void **)&pVmcbMem, &PgLockMem);
     132        PSVMVMCBCTRL   pVmcbCtrl = &pVCpu->cpum.GstCtx.hwvirt.svm.CTX_SUFF(pVmcb)->ctrl;
     133        rcStrict = iemMemPageMap(pVCpu, pVCpu->cpum.GstCtx.hwvirt.svm.GCPhysVmcb, IEM_ACCESS_DATA_RW, (void **)&pVmcbMem, &PgLockMem);
    136134        if (rcStrict == VINF_SUCCESS)
    137135        {
    … …  
    141139             * writing the VMCB back to guest memory.
    142140             */
    143             HMSvmNstGstVmExitNotify(pVCpu, pCtx);
     141            HMSvmNstGstVmExitNotify(pVCpu, IEM_GET_CTX(pVCpu));
    144142
    145143            /*
    … …  
    147145             */
    148146            PSVMVMCBSTATESAVE pVmcbMemState = &pVmcbMem->guest;
    149             HMSVM_SEG_REG_COPY_TO_VMCB(pCtx, pVmcbMemState, ES, es);
    150             HMSVM_SEG_REG_COPY_TO_VMCB(pCtx, pVmcbMemState, CS, cs);
    151             HMSVM_SEG_REG_COPY_TO_VMCB(pCtx, pVmcbMemState, SS, ss);
    152             HMSVM_SEG_REG_COPY_TO_VMCB(pCtx, pVmcbMemState, DS, ds);
    153             pVmcbMemState->GDTR.u32Limit   = pCtx->gdtr.cbGdt;
    154             pVmcbMemState->GDTR.u64Base    = pCtx->gdtr.pGdt;
    155             pVmcbMemState->IDTR.u32Limit   = pCtx->idtr.cbIdt;
    156             pVmcbMemState->IDTR.u64Base    = pCtx->idtr.pIdt;
    157             pVmcbMemState->u64EFER         = pCtx->msrEFER;
    158             pVmcbMemState->u64CR4          = pCtx->cr4;
    159             pVmcbMemState->u64CR3          = pCtx->cr3;
    160             pVmcbMemState->u64CR2          = pCtx->cr2;
    161             pVmcbMemState->u64CR0          = pCtx->cr0;
     147            HMSVM_SEG_REG_COPY_TO_VMCB(IEM_GET_CTX(pVCpu), pVmcbMemState, ES, es);
     148            HMSVM_SEG_REG_COPY_TO_VMCB(IEM_GET_CTX(pVCpu), pVmcbMemState, CS, cs);
     149            HMSVM_SEG_REG_COPY_TO_VMCB(IEM_GET_CTX(pVCpu), pVmcbMemState, SS, ss);
     150            HMSVM_SEG_REG_COPY_TO_VMCB(IEM_GET_CTX(pVCpu), pVmcbMemState, DS, ds);
     151            pVmcbMemState->GDTR.u32Limit   = pVCpu->cpum.GstCtx.gdtr.cbGdt;
     152            pVmcbMemState->GDTR.u64Base    = pVCpu->cpum.GstCtx.gdtr.pGdt;
     153            pVmcbMemState->IDTR.u32Limit   = pVCpu->cpum.GstCtx.idtr.cbIdt;
     154            pVmcbMemState->IDTR.u64Base    = pVCpu->cpum.GstCtx.idtr.pIdt;
     155            pVmcbMemState->u64EFER         = pVCpu->cpum.GstCtx.msrEFER;
     156            pVmcbMemState->u64CR4          = pVCpu->cpum.GstCtx.cr4;
     157            pVmcbMemState->u64CR3          = pVCpu->cpum.GstCtx.cr3;
     158            pVmcbMemState->u64CR2          = pVCpu->cpum.GstCtx.cr2;
     159            pVmcbMemState->u64CR0          = pVCpu->cpum.GstCtx.cr0;
    162160            /** @todo Nested paging. */
    163             pVmcbMemState->u64RFlags       = pCtx->rflags.u64;
    164             pVmcbMemState->u64RIP          = pCtx->rip;
    165             pVmcbMemState->u64RSP          = pCtx->rsp;
    166             pVmcbMemState->u64RAX          = pCtx->rax;
    167             pVmcbMemState->u64DR7          = pCtx->dr[7];
    168             pVmcbMemState->u64DR6          = pCtx->dr[6];
    169             pVmcbMemState->u8CPL           = pCtx->ss.Attr.n.u2Dpl;   /* See comment in CPUMGetGuestCPL(). */
    170             Assert(CPUMGetGuestCPL(pVCpu) == pCtx->ss.Attr.n.u2Dpl);
    171             if (CPUMIsGuestSvmNestedPagingEnabled(pVCpu, pCtx))
    172                 pVmcbMemState->u64PAT = pCtx->msrPAT;
     161            pVmcbMemState->u64RFlags       = pVCpu->cpum.GstCtx.rflags.u64;
     162            pVmcbMemState->u64RIP          = pVCpu->cpum.GstCtx.rip;
     163            pVmcbMemState->u64RSP          = pVCpu->cpum.GstCtx.rsp;
     164            pVmcbMemState->u64RAX          = pVCpu->cpum.GstCtx.rax;
     165            pVmcbMemState->u64DR7          = pVCpu->cpum.GstCtx.dr[7];
     166            pVmcbMemState->u64DR6          = pVCpu->cpum.GstCtx.dr[6];
     167            pVmcbMemState->u8CPL           = pVCpu->cpum.GstCtx.ss.Attr.n.u2Dpl;   /* See comment in CPUMGetGuestCPL(). */
     168            Assert(CPUMGetGuestCPL(pVCpu) == pVCpu->cpum.GstCtx.ss.Attr.n.u2Dpl);
     169            if (CPUMIsGuestSvmNestedPagingEnabled(pVCpu, IEM_GET_CTX(pVCpu)))
     170                pVmcbMemState->u64PAT = pVCpu->cpum.GstCtx.msrPAT;
    173171
    174172            /*
    … …  
    192190
    193191            if (   VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_INHIBIT_INTERRUPTS)          /* Interrupt shadow. */
    194                 && EMGetInhibitInterruptsPC(pVCpu) == pCtx->rip)
     192                && EMGetInhibitInterruptsPC(pVCpu) == pVCpu->cpum.GstCtx.rip)
    195193            {
    196194                pVmcbMemCtrl->IntShadow.n.u1IntShadow = 1;
    197195                VMCPU_FF_CLEAR(pVCpu, VMCPU_FF_INHIBIT_INTERRUPTS);
    198                 LogFlow(("iemSvmVmexit: Interrupt shadow till %#RX64\n", pCtx->rip));
     196                LogFlow(("iemSvmVmexit: Interrupt shadow till %#RX64\n", pVCpu->cpum.GstCtx.rip));
    199197            }
    200198            else
    … …  
    255253            pVmcbMemCtrl->EventInject.n.u1Valid = 0;
    256254
    257             iemMemPageUnmap(pVCpu, pCtx->hwvirt.svm.GCPhysVmcb, IEM_ACCESS_DATA_RW, pVmcbMem, &PgLockMem);
     255            iemMemPageUnmap(pVCpu, pVCpu->cpum.GstCtx.hwvirt.svm.GCPhysVmcb, IEM_ACCESS_DATA_RW, pVmcbMem, &PgLockMem);
    258256        }
    259257
    … …  
    266264         */
    267265        memset(pVmcbCtrl, 0, sizeof(*pVmcbCtrl));
    268         Assert(!CPUMIsGuestInSvmNestedHwVirtMode(pCtx));
     266        Assert(!CPUMIsGuestInSvmNestedHwVirtMode(IEM_GET_CTX(pVCpu)));
    269267
    270268        /*
    271269         * Restore the subset of force-flags that were preserved.
    272270         */
    273         if (pCtx->hwvirt.fLocalForcedActions)
    274         {
    275             VMCPU_FF_SET(pVCpu, pCtx->hwvirt.fLocalForcedActions);
    276             pCtx->hwvirt.fLocalForcedActions = 0;
     271        if (pVCpu->cpum.GstCtx.hwvirt.fLocalForcedActions)
     272        {
     273            VMCPU_FF_SET(pVCpu, pVCpu->cpum.GstCtx.hwvirt.fLocalForcedActions);
     274            pVCpu->cpum.GstCtx.hwvirt.fLocalForcedActions = 0;
    277275        }
    278276
    … …  
    285283             * Reload the guest's "host state".
    286284             */
    287             CPUMSvmVmExitRestoreHostState(pVCpu, pCtx);
     285            CPUMSvmVmExitRestoreHostState(pVCpu, IEM_GET_CTX(pVCpu));
    288286
    289287            /*
    290288             * Update PGM, IEM and others of a world-switch.
    291289             */
    292             rcStrict = iemSvmWorldSwitch(pVCpu, pCtx);
     290            rcStrict = iemSvmWorldSwitch(pVCpu);
    293291            if (rcStrict == VINF_SUCCESS)
    294292                rcStrict = VINF_SVM_VMEXIT;
    … …  
    304302        else
    305303        {
    306             AssertMsgFailed(("iemSvmVmexit: Mapping VMCB at %#RGp failed. rc=%Rrc\n", pCtx->hwvirt.svm.GCPhysVmcb, VBOXSTRICTRC_VAL(rcStrict)));
     304            AssertMsgFailed(("iemSvmVmexit: Mapping VMCB at %#RGp failed. rc=%Rrc\n", pVCpu->cpum.GstCtx.hwvirt.svm.GCPhysVmcb, VBOXSTRICTRC_VAL(rcStrict)));
    307305            rcStrict = VERR_SVM_VMEXIT_FAILED;
    308306        }
    … …  
    334332 *
    335333 * @param   pVCpu               The cross context virtual CPU structure.
    336  * @param   pCtx                Pointer to the guest-CPU context.
    337334 * @param   cbInstr             The length of the VMRUN instruction.
    338335 * @param   GCPhysVmcb          Guest physical address of the VMCB to run.
    339336 */
    340 IEM_STATIC VBOXSTRICTRC iemSvmVmrun(PVMCPU pVCpu, PCPUMCTX pCtx, uint8_t cbInstr, RTGCPHYS GCPhysVmcb)
     337IEM_STATIC VBOXSTRICTRC iemSvmVmrun(PVMCPU pVCpu, uint8_t cbInstr, RTGCPHYS GCPhysVmcb)
    341338{
    342339    LogFlow(("iemSvmVmrun\n"));
    … …  
    345342     * Cache the physical address of the VMCB for #VMEXIT exceptions.
    346343     */
    347     pCtx->hwvirt.svm.GCPhysVmcb = GCPhysVmcb;
     344    pVCpu->cpum.GstCtx.hwvirt.svm.GCPhysVmcb = GCPhysVmcb;
    348345
    349346    /*
    350347     * Save the host state.
    351348     */
    352     CPUMSvmVmRunSaveHostState(pCtx, cbInstr);
     349    CPUMSvmVmRunSaveHostState(IEM_GET_CTX(pVCpu), cbInstr);
    353350
    354351    /*
    … …  
    356353     */
    357354    PVM pVM = pVCpu->CTX_SUFF(pVM);
    358     int rc = PGMPhysSimpleReadGCPhys(pVM, pCtx->hwvirt.svm.CTX_SUFF(pVmcb), GCPhysVmcb, sizeof(SVMVMCB));
     355    int rc = PGMPhysSimpleReadGCPhys(pVM, pVCpu->cpum.GstCtx.hwvirt.svm.CTX_SUFF(pVmcb), GCPhysVmcb, sizeof(SVMVMCB));
    359356    if (RT_SUCCESS(rc))
    360357    {
    … …  
    371368         * typically enter hardware-assisted SVM soon anyway, see @bugref{7243#c113}.
    372369         */
    373         PSVMVMCBCTRL      pVmcbCtrl   = &pCtx->hwvirt.svm.CTX_SUFF(pVmcb)->ctrl;
    374         PSVMVMCBSTATESAVE pVmcbNstGst = &pCtx->hwvirt.svm.CTX_SUFF(pVmcb)->guest;
     370        PSVMVMCBCTRL      pVmcbCtrl   = &pVCpu->cpum.GstCtx.hwvirt.svm.CTX_SUFF(pVmcb)->ctrl;
     371        PSVMVMCBSTATESAVE pVmcbNstGst = &pVCpu->cpum.GstCtx.hwvirt.svm.CTX_SUFF(pVmcb)->guest;
    375372
    376373        RT_ZERO(pVmcbCtrl->u8Reserved0);
    … …  
    399396         */
    400397        /* VMRUN must always be intercepted. */
    401         if (!CPUMIsGuestSvmCtrlInterceptSet(pVCpu, pCtx, SVM_CTRL_INTERCEPT_VMRUN))
     398        if (!CPUMIsGuestSvmCtrlInterceptSet(pVCpu, IEM_GET_CTX(pVCpu), SVM_CTRL_INTERCEPT_VMRUN))
    402399        {
    403400            Log(("iemSvmVmrun: VMRUN instruction not intercepted -> #VMEXIT\n"));
    404             return iemSvmVmexit(pVCpu, pCtx, SVM_EXIT_INVALID, 0 /* uExitInfo1 */, 0 /* uExitInfo2 */);
     401            return iemSvmVmexit(pVCpu, SVM_EXIT_INVALID, 0 /* uExitInfo1 */, 0 /* uExitInfo2 */);
    405402        }
    406403
    … …  
    449446        {
    450447            Log(("iemSvmVmrun: Guest ASID is invalid -> #VMEXIT\n"));
    451             return iemSvmVmexit(pVCpu, pCtx, SVM_EXIT_INVALID, 0 /* uExitInfo1 */, 0 /* uExitInfo2 */);
     448            return iemSvmVmexit(pVCpu, SVM_EXIT_INVALID, 0 /* uExitInfo1 */, 0 /* uExitInfo2 */);
    452449        }
    453450
    … …  
    476473        {
    477474            Log(("iemSvmVmrun: Flush-by-ASID not supported -> #VMEXIT\n"));
    478             return iemSvmVmexit(pVCpu, pCtx, SVM_EXIT_INVALID, 0 /* uExitInfo1 */, 0 /* uExitInfo2 */);
     475            return iemSvmVmexit(pVCpu, SVM_EXIT_INVALID, 0 /* uExitInfo1 */, 0 /* uExitInfo2 */);
    479476        }
    480477
    … …  
    487484        {
    488485            Log(("iemSvmVmrun: IO bitmap physaddr invalid. GCPhysIOBitmap=%#RX64 -> #VMEXIT\n", GCPhysIOBitmap));
    489             return iemSvmVmexit(pVCpu, pCtx, SVM_EXIT_INVALID, 0 /* uExitInfo1 */, 0 /* uExitInfo2 */);
     486            return iemSvmVmexit(pVCpu, SVM_EXIT_INVALID, 0 /* uExitInfo1 */, 0 /* uExitInfo2 */);
    490487        }
    491488
    … …  
    497494        {
    498495            Log(("iemSvmVmrun: MSR bitmap physaddr invalid. GCPhysMsrBitmap=%#RX64 -> #VMEXIT\n", GCPhysMsrBitmap));
    499             return iemSvmVmexit(pVCpu, pCtx, SVM_EXIT_INVALID, 0 /* uExitInfo1 */, 0 /* uExitInfo2 */);
     496            return iemSvmVmexit(pVCpu, SVM_EXIT_INVALID, 0 /* uExitInfo1 */, 0 /* uExitInfo2 */);
    500497        }
    501498
    … …  
    505502        {
    506503            Log(("iemSvmVmrun: CR0 no-write through with cache disabled. CR0=%#RX64 -> #VMEXIT\n", pVmcbNstGst->u64CR0));
    507             return iemSvmVmexit(pVCpu, pCtx, SVM_EXIT_INVALID, 0 /* uExitInfo1 */, 0 /* uExitInfo2 */);
     504            return iemSvmVmexit(pVCpu, SVM_EXIT_INVALID, 0 /* uExitInfo1 */, 0 /* uExitInfo2 */);
    508505        }
    509506        if (pVmcbNstGst->u64CR0 >> 32)
    510507        {
    511508            Log(("iemSvmVmrun: CR0 reserved bits set. CR0=%#RX64 -> #VMEXIT\n", pVmcbNstGst->u64CR0));
    512             return iemSvmVmexit(pVCpu, pCtx, SVM_EXIT_INVALID, 0 /* uExitInfo1 */, 0 /* uExitInfo2 */);
     509            return iemSvmVmexit(pVCpu, SVM_EXIT_INVALID, 0 /* uExitInfo1 */, 0 /* uExitInfo2 */);
    513510        }
    514511        /** @todo Implement all reserved bits/illegal combinations for CR3, CR4. */
    … …  
    520517            Log(("iemSvmVmrun: DR6 and/or DR7 reserved bits set. DR6=%#RX64 DR7=%#RX64 -> #VMEXIT\n", pVmcbNstGst->u64DR6,
    521518                 pVmcbNstGst->u64DR6));
    522             return iemSvmVmexit(pVCpu, pCtx, SVM_EXIT_INVALID, 0 /* uExitInfo1 */, 0 /* uExitInfo2 */);
     519            return iemSvmVmexit(pVCpu, SVM_EXIT_INVALID, 0 /* uExitInfo1 */, 0 /* uExitInfo2 */);
    523520        }
    524521
    … …  
    533530        {
    534531            Log(("iemSvmVmrun: PAT invalid. u64PAT=%#RX64 -> #VMEXIT\n", pVmcbNstGst->u64PAT));
    535             return iemSvmVmexit(pVCpu, pCtx, SVM_EXIT_INVALID, 0 /* uExitInfo1 */, 0 /* uExitInfo2 */);
     532            return iemSvmVmexit(pVCpu, SVM_EXIT_INVALID, 0 /* uExitInfo1 */, 0 /* uExitInfo2 */);
    536533        }
    537534
    … …  
    539536         * Copy the IO permission bitmap into the cache.
    540537         */
    541         Assert(pCtx->hwvirt.svm.CTX_SUFF(pvIoBitmap));
    542         rc = PGMPhysSimpleReadGCPhys(pVM, pCtx->hwvirt.svm.CTX_SUFF(pvIoBitmap), GCPhysIOBitmap,
     538        Assert(pVCpu->cpum.GstCtx.hwvirt.svm.CTX_SUFF(pvIoBitmap));
     539        rc = PGMPhysSimpleReadGCPhys(pVM, pVCpu->cpum.GstCtx.hwvirt.svm.CTX_SUFF(pvIoBitmap), GCPhysIOBitmap,
    543540                                     SVM_IOPM_PAGES * X86_PAGE_4K_SIZE);
    544541        if (RT_FAILURE(rc))
    545542        {
    546543            Log(("iemSvmVmrun: Failed reading the IO permission bitmap at %#RGp. rc=%Rrc\n", GCPhysIOBitmap, rc));
    547             return iemSvmVmexit(pVCpu, pCtx, SVM_EXIT_INVALID, 0 /* uExitInfo1 */, 0 /* uExitInfo2 */);
     544            return iemSvmVmexit(pVCpu, SVM_EXIT_INVALID, 0 /* uExitInfo1 */, 0 /* uExitInfo2 */);
    548545        }
    549546
    … …  
    551548         * Copy the MSR permission bitmap into the cache.
    552549         */
    553         Assert(pCtx->hwvirt.svm.CTX_SUFF(pvMsrBitmap));
    554         rc = PGMPhysSimpleReadGCPhys(pVM, pCtx->hwvirt.svm.CTX_SUFF(pvMsrBitmap), GCPhysMsrBitmap,
     550        Assert(pVCpu->cpum.GstCtx.hwvirt.svm.CTX_SUFF(pvMsrBitmap));
     551        rc = PGMPhysSimpleReadGCPhys(pVM, pVCpu->cpum.GstCtx.hwvirt.svm.CTX_SUFF(pvMsrBitmap), GCPhysMsrBitmap,
    555552                                     SVM_MSRPM_PAGES * X86_PAGE_4K_SIZE);
    556553        if (RT_FAILURE(rc))
    557554        {
    558555            Log(("iemSvmVmrun: Failed reading the MSR permission bitmap at %#RGp. rc=%Rrc\n", GCPhysMsrBitmap, rc));
    559             return iemSvmVmexit(pVCpu, pCtx, SVM_EXIT_INVALID, 0 /* uExitInfo1 */, 0 /* uExitInfo2 */);
     556            return iemSvmVmexit(pVCpu, SVM_EXIT_INVALID, 0 /* uExitInfo1 */, 0 /* uExitInfo2 */);
    560557        }
    561558
    … …  
    567564         * the state, we restore the guest-CPU context state on the \#VMEXIT anyway.
    568565         */
    569         HMSVM_SEG_REG_COPY_FROM_VMCB(pCtx, pVmcbNstGst, ES, es);
    570         HMSVM_SEG_REG_COPY_FROM_VMCB(pCtx, pVmcbNstGst, CS, cs);
    571         HMSVM_SEG_REG_COPY_FROM_VMCB(pCtx, pVmcbNstGst, SS, ss);
    572         HMSVM_SEG_REG_COPY_FROM_VMCB(pCtx, pVmcbNstGst, DS, ds);
     566        HMSVM_SEG_REG_COPY_FROM_VMCB(IEM_GET_CTX(pVCpu), pVmcbNstGst, ES, es);
     567        HMSVM_SEG_REG_COPY_FROM_VMCB(IEM_GET_CTX(pVCpu), pVmcbNstGst, CS, cs);
     568        HMSVM_SEG_REG_COPY_FROM_VMCB(IEM_GET_CTX(pVCpu), pVmcbNstGst, SS, ss);
     569        HMSVM_SEG_REG_COPY_FROM_VMCB(IEM_GET_CTX(pVCpu), pVmcbNstGst, DS, ds);
    573570
    574571        /** @todo Segment attribute overrides by VMRUN. */
    … …  
    580577         * We shall thus adjust both CS.DPL and SS.DPL here.
    581578         */
    582         pCtx->cs.Attr.n.u2Dpl = pCtx->ss.Attr.n.u2Dpl = pVmcbNstGst->u8CPL;
    583         if (CPUMIsGuestInV86ModeEx(pCtx))
    584             pCtx->cs.Attr.n.u2Dpl = pCtx->ss.Attr.n.u2Dpl = 3;
    585         if (CPUMIsGuestInRealModeEx(pCtx))
    586             pCtx->cs.Attr.n.u2Dpl = pCtx->ss.Attr.n.u2Dpl = 0;
    587         Assert(CPUMSELREG_ARE_HIDDEN_PARTS_VALID(pVCpu, &pCtx->ss));
     579        pVCpu->cpum.GstCtx.cs.Attr.n.u2Dpl = pVCpu->cpum.GstCtx.ss.Attr.n.u2Dpl = pVmcbNstGst->u8CPL;
     580        if (CPUMIsGuestInV86ModeEx(IEM_GET_CTX(pVCpu)))
     581            pVCpu->cpum.GstCtx.cs.Attr.n.u2Dpl = pVCpu->cpum.GstCtx.ss.Attr.n.u2Dpl = 3;
     582        if (CPUMIsGuestInRealModeEx(IEM_GET_CTX(pVCpu)))
     583            pVCpu->cpum.GstCtx.cs.Attr.n.u2Dpl = pVCpu->cpum.GstCtx.ss.Attr.n.u2Dpl = 0;
     584        Assert(CPUMSELREG_ARE_HIDDEN_PARTS_VALID(pVCpu, &pVCpu->cpum.GstCtx.ss));
    588585
    589586        /*
    … …  
    600597        {
    601598            Log(("iemSvmVmrun: EFER invalid uOldEfer=%#RX64 -> #VMEXIT\n", pVmcbNstGst->u64EFER));
    602             return iemSvmVmexit(pVCpu, pCtx, SVM_EXIT_INVALID, 0 /* uExitInfo1 */, 0 /* uExitInfo2 */);
     599            return iemSvmVmexit(pVCpu, SVM_EXIT_INVALID, 0 /* uExitInfo1 */, 0 /* uExitInfo2 */);
    603600        }
    604601
    … …  
    611608        bool const fProtMode                = RT_BOOL(pVmcbNstGst->u64CR0 & X86_CR0_PE);
    612609        bool const fLongModeWithPaging      = fLongModeEnabled && fPaging;
    613         bool const fLongModeConformCS       = pCtx->cs.Attr.n.u1Long && pCtx->cs.Attr.n.u1DefBig;
     610        bool const fLongModeConformCS       = pVCpu->cpum.GstCtx.cs.Attr.n.u1Long && pVCpu->cpum.GstCtx.cs.Attr.n.u1DefBig;
    614611        /* Adjust EFER.LMA (this is normally done by the CPU when system software writes CR0). */
    615612        if (fLongModeWithPaging)
    … …  
    626623        {
    627624            Log(("iemSvmVmrun: EFER invalid. uValidEfer=%#RX64 -> #VMEXIT\n", uValidEfer));
    628             return iemSvmVmexit(pVCpu, pCtx, SVM_EXIT_INVALID, 0 /* uExitInfo1 */, 0 /* uExitInfo2 */);
     625            return iemSvmVmexit(pVCpu, SVM_EXIT_INVALID, 0 /* uExitInfo1 */, 0 /* uExitInfo2 */);
    629626        }
    630627
    … …  
    645642         *     nested-guest.
    646643         */
    647         pCtx->hwvirt.fLocalForcedActions = pVCpu->fLocalForcedActions & VMCPU_FF_BLOCK_NMIS;
     644        pVCpu->cpum.GstCtx.hwvirt.fLocalForcedActions = pVCpu->fLocalForcedActions & VMCPU_FF_BLOCK_NMIS;
    648645        VMCPU_FF_CLEAR(pVCpu, VMCPU_FF_BLOCK_NMIS);
    649646
    … …  
    653650        if (pVM->cpum.ro.GuestFeatures.fSvmPauseFilter)
    654651        {
    655             pCtx->hwvirt.svm.cPauseFilter = pVmcbCtrl->u16PauseFilterCount;
     652            pVCpu->cpum.GstCtx.hwvirt.svm.cPauseFilter = pVmcbCtrl->u16PauseFilterCount;
    656653            if (pVM->cpum.ro.GuestFeatures.fSvmPauseFilterThreshold)
    657                 pCtx->hwvirt.svm.cPauseFilterThreshold = pVmcbCtrl->u16PauseFilterCount;
     654                pVCpu->cpum.GstCtx.hwvirt.svm.cPauseFilterThreshold = pVmcbCtrl->u16PauseFilterCount;
    658655        }
    659656
    … …  
    684681         * Copy the remaining guest state from the VMCB to the guest-CPU context.
    685682         */
    686         pCtx->gdtr.cbGdt = pVmcbNstGst->GDTR.u32Limit;
    687         pCtx->gdtr.pGdt  = pVmcbNstGst->GDTR.u64Base;
    688         pCtx->idtr.cbIdt = pVmcbNstGst->IDTR.u32Limit;
    689         pCtx->idtr.pIdt  = pVmcbNstGst->IDTR.u64Base;
     683        pVCpu->cpum.GstCtx.gdtr.cbGdt = pVmcbNstGst->GDTR.u32Limit;
     684        pVCpu->cpum.GstCtx.gdtr.pGdt  = pVmcbNstGst->GDTR.u64Base;
     685        pVCpu->cpum.GstCtx.idtr.cbIdt = pVmcbNstGst->IDTR.u32Limit;
     686        pVCpu->cpum.GstCtx.idtr.pIdt  = pVmcbNstGst->IDTR.u64Base;
    690687        CPUMSetGuestCR0(pVCpu, pVmcbNstGst->u64CR0);
    691688        CPUMSetGuestCR4(pVCpu, pVmcbNstGst->u64CR4);
    692         pCtx->cr3        = pVmcbNstGst->u64CR3;
    693         pCtx->cr2        = pVmcbNstGst->u64CR2;
    694         pCtx->dr[6]      = pVmcbNstGst->u64DR6;
    695         pCtx->dr[7]      = pVmcbNstGst->u64DR7;
    696         pCtx->rflags.u64 = pVmcbNstGst->u64RFlags;
    697         pCtx->rax        = pVmcbNstGst->u64RAX;
    698         pCtx->rsp        = pVmcbNstGst->u64RSP;
    699         pCtx->rip        = pVmcbNstGst->u64RIP;
    700         CPUMSetGuestMsrEferNoCheck(pVCpu, pCtx->msrEFER, uValidEfer);
     689        pVCpu->cpum.GstCtx.cr3        = pVmcbNstGst->u64CR3;
     690        pVCpu->cpum.GstCtx.cr2        = pVmcbNstGst->u64CR2;
     691        pVCpu->cpum.GstCtx.dr[6]      = pVmcbNstGst->u64DR6;
     692        pVCpu->cpum.GstCtx.dr[7]      = pVmcbNstGst->u64DR7;
     693        pVCpu->cpum.GstCtx.rflags.u64 = pVmcbNstGst->u64RFlags;
     694        pVCpu->cpum.GstCtx.rax        = pVmcbNstGst->u64RAX;
     695        pVCpu->cpum.GstCtx.rsp        = pVmcbNstGst->u64RSP;
     696        pVCpu->cpum.GstCtx.rip        = pVmcbNstGst->u64RIP;
     697        CPUMSetGuestMsrEferNoCheck(pVCpu, pVCpu->cpum.GstCtx.msrEFER, uValidEfer);
    701698        if (pVmcbCtrl->NestedPagingCtrl.n.u1NestedPaging)
    702             pCtx->msrPAT = pVmcbNstGst->u64PAT;
     699            pVCpu->cpum.GstCtx.msrPAT = pVmcbNstGst->u64PAT;
    703700
    704701        /* Mask DR6, DR7 bits mandatory set/clear bits. */
    705         pCtx->dr[6] &= ~(X86_DR6_RAZ_MASK | X86_DR6_MBZ_MASK);
    706         pCtx->dr[6] |= X86_DR6_RA1_MASK;
    707         pCtx->dr[7] &= ~(X86_DR7_RAZ_MASK | X86_DR7_MBZ_MASK);
    708         pCtx->dr[7] |= X86_DR7_RA1_MASK;
     702        pVCpu->cpum.GstCtx.dr[6] &= ~(X86_DR6_RAZ_MASK | X86_DR6_MBZ_MASK);
     703        pVCpu->cpum.GstCtx.dr[6] |= X86_DR6_RA1_MASK;
     704        pVCpu->cpum.GstCtx.dr[7] &= ~(X86_DR7_RAZ_MASK | X86_DR7_MBZ_MASK);
     705        pVCpu->cpum.GstCtx.dr[7] |= X86_DR7_RA1_MASK;
    709706
    710707        /*
    … …  
    719716         * Update PGM, IEM and others of a world-switch.
    720717         */
    721         VBOXSTRICTRC rcStrict = iemSvmWorldSwitch(pVCpu, pCtx);
     718        VBOXSTRICTRC rcStrict = iemSvmWorldSwitch(pVCpu);
    722719        if (rcStrict == VINF_SUCCESS)
    723720        { /* likely */ }
    … …  
    736733         * Clear global interrupt flags to allow interrupts in the guest.
    737734         */
    738         pCtx->hwvirt.fGif = true;
     735        pVCpu->cpum.GstCtx.hwvirt.fGif = true;
    739736
    740737        /*
    … …  
    742739         */
    743740        PCSVMEVENT pEventInject = &pVmcbCtrl->EventInject;
    744         pCtx->hwvirt.svm.fInterceptEvents = !pEventInject->n.u1Valid;
     741        pVCpu->cpum.GstCtx.hwvirt.svm.fInterceptEvents = !pEventInject->n.u1Valid;
    745742        if (pEventInject->n.u1Valid)
    746743        {
    … …  
    753750            {
    754751                Log(("iemSvmVmrun: Invalid event type =%#x -> #VMEXIT\n", (uint8_t)pEventInject->n.u3Type));
    755                 return iemSvmVmexit(pVCpu, pCtx, SVM_EXIT_INVALID, 0 /* uExitInfo1 */, 0 /* uExitInfo2 */);
     752                return iemSvmVmexit(pVCpu, SVM_EXIT_INVALID, 0 /* uExitInfo1 */, 0 /* uExitInfo2 */);
    756753            }
    757754            if (pEventInject->n.u3Type == SVM_EVENT_EXCEPTION)
    … …  
    761758                {
    762759                    Log(("iemSvmVmrun: Invalid vector for hardware exception. uVector=%#x -> #VMEXIT\n", uVector));
    763                     return iemSvmVmexit(pVCpu, pCtx, SVM_EXIT_INVALID, 0 /* uExitInfo1 */, 0 /* uExitInfo2 */);
     760                    return iemSvmVmexit(pVCpu, SVM_EXIT_INVALID, 0 /* uExitInfo1 */, 0 /* uExitInfo2 */);
    764761                }
    765762                if (   uVector == X86_XCPT_BR
    766                     && CPUMIsGuestInLongModeEx(pCtx))
     763                    && CPUMIsGuestInLongModeEx(IEM_GET_CTX(pVCpu)))
    767764                {
    768765                    Log(("iemSvmVmrun: Cannot inject #BR when not in long mode -> #VMEXIT\n"));
    769                     return iemSvmVmexit(pVCpu, pCtx, SVM_EXIT_INVALID, 0 /* uExitInfo1 */, 0 /* uExitInfo2 */);
     766                    return iemSvmVmexit(pVCpu, SVM_EXIT_INVALID, 0 /* uExitInfo1 */, 0 /* uExitInfo2 */);
    770767                }
    771768                /** @todo any others? */
    … …  
    794791             *        below. */
    795792            LogFlow(("iemSvmVmrun: Injecting event: %04x:%08RX64 vec=%#x type=%d uErr=%u cr2=%#RX64 cr3=%#RX64 efer=%#RX64\n",
    796                      pCtx->cs.Sel, pCtx->rip, uVector, enmType, uErrorCode, pCtx->cr2, pCtx->cr3, pCtx->msrEFER));
     793                     pVCpu->cpum.GstCtx.cs.Sel, pVCpu->cpum.GstCtx.rip, uVector, enmType, uErrorCode, pVCpu->cpum.GstCtx.cr2, pVCpu->cpum.GstCtx.cr3, pVCpu->cpum.GstCtx.msrEFER));
    797794
    798795            /*
    … …  
    806803            if (   enmType == TRPM_TRAP
    807804                && uVector == X86_XCPT_PF)
    808                 TRPMSetFaultAddress(pVCpu, pCtx->cr2);
     805                TRPMSetFaultAddress(pVCpu, pVCpu->cpum.GstCtx.cr2);
    809806        }
    810807        else
    811808            LogFlow(("iemSvmVmrun: Entering nested-guest: %04x:%08RX64 cr0=%#RX64 cr3=%#RX64 cr4=%#RX64 efer=%#RX64 efl=%#x\n",
    812                      pCtx->cs.Sel, pCtx->rip, pCtx->cr0, pCtx->cr3, pCtx->cr4, pCtx->msrEFER, pCtx->rflags.u64));
     809                     pVCpu->cpum.GstCtx.cs.Sel, pVCpu->cpum.GstCtx.rip, pVCpu->cpum.GstCtx.cr0, pVCpu->cpum.GstCtx.cr3, pVCpu->cpum.GstCtx.cr4, pVCpu->cpum.GstCtx.msrEFER, pVCpu->cpum.GstCtx.rflags.u64));
    813810
    814811        LogFlow(("iemSvmVmrun: returns %d\n", VBOXSTRICTRC_VAL(rcStrict)));
    … …  
    843840 * @returns VBox strict status code.
    844841 * @param   pVCpu       The cross context virtual CPU structure of the calling thread.
    845  * @param   pCtx        Pointer to the guest-CPU context.
    846842 * @param   u8Vector    The interrupt or exception vector.
    847843 * @param   fFlags      The exception flags (see IEM_XCPT_FLAGS_XXX).
    … …  
    849845 * @param   uCr2        The CR2 value in case of a \#PF exception.
    850846 */
    851 IEM_STATIC VBOXSTRICTRC iemHandleSvmEventIntercept(PVMCPU pVCpu, PCPUMCTX pCtx, uint8_t u8Vector, uint32_t fFlags, uint32_t uErr,
    852                                                    uint64_t uCr2)
    853 {
    854     Assert(CPUMIsGuestInSvmNestedHwVirtMode(pCtx));
     847IEM_STATIC VBOXSTRICTRC iemHandleSvmEventIntercept(PVMCPU pVCpu, uint8_t u8Vector, uint32_t fFlags, uint32_t uErr, uint64_t uCr2)
     848{
     849    Assert(CPUMIsGuestInSvmNestedHwVirtMode(IEM_GET_CTX(pVCpu)));
    855850
    856851    /*
    … …  
    892887            && !(uErr & X86_TRAP_PF_ID))
    893888        {
    894             PSVMVMCBCTRL  pVmcbCtrl = &pCtx->hwvirt.svm.CTX_SUFF(pVmcb)->ctrl;
     889            PSVMVMCBCTRL  pVmcbCtrl = &pVCpu->cpum.GstCtx.hwvirt.svm.CTX_SUFF(pVmcb)->ctrl;
    895890# ifdef IEM_WITH_CODE_TLB
    896891            uint8_t const *pbInstrBuf = pVCpu->iem.s.pbInstrBuf;
    … …  
    910905            IEM_SVM_UPDATE_NRIP(pVCpu);
    911906        Log2(("iemHandleSvmNstGstEventIntercept: Xcpt intercept u32InterceptXcpt=%#RX32 u8Vector=%#x "
    912               "uExitInfo1=%#RX64 uExitInfo2=%#RX64 -> #VMEXIT\n", pCtx->hwvirt.svm.CTX_SUFF(pVmcb)->ctrl.u32InterceptXcpt,
     907              "uExitInfo1=%#RX64 uExitInfo2=%#RX64 -> #VMEXIT\n", pVCpu->cpum.GstCtx.hwvirt.svm.CTX_SUFF(pVmcb)->ctrl.u32InterceptXcpt,
    913908              u8Vector, uExitInfo1, uExitInfo2));
    914909        IEM_RETURN_SVM_VMEXIT(pVCpu, SVM_EXIT_XCPT_0 + u8Vector, uExitInfo1, uExitInfo2);
    … …  
    965960
    966961    SVMIOIOEXITINFO IoExitInfo;
    967     PCPUMCTX pCtx = IEM_GET_CTX(pVCpu);
    968     void *pvIoBitmap = pCtx->hwvirt.svm.CTX_SUFF(pvIoBitmap);
     962    void *pvIoBitmap = pVCpu->cpum.GstCtx.hwvirt.svm.CTX_SUFF(pvIoBitmap);
    969963    bool const fIntercept = HMSvmIsIOInterceptActive(pvIoBitmap, u16Port, enmIoType, cbReg, cAddrSizeBits, iEffSeg, fRep, fStrIo,
    970964                                                     &IoExitInfo);
    … …  
    973967        Log3(("iemSvmHandleIOIntercept: u16Port=%#x (%u) -> #VMEXIT\n", u16Port, u16Port));
    974968        IEM_SVM_UPDATE_NRIP(pVCpu);
    975         return iemSvmVmexit(pVCpu, pCtx, SVM_EXIT_IOIO, IoExitInfo.u, pCtx->rip + cbInstr);
     969        return iemSvmVmexit(pVCpu, SVM_EXIT_IOIO, IoExitInfo.u, pVCpu->cpum.GstCtx.rip + cbInstr);
    976970    }
    977971
    … …  
    996990 *
    997991 * @param   pVCpu       The cross context virtual CPU structure.
    998  * @param   pCtx        The guest-CPU context.
    999992 * @param   idMsr       The MSR being accessed in the nested-guest.
    1000993 * @param   fWrite      Whether this is an MSR write access, @c false implies an
    … …  
    1002995 * @param   cbInstr     The length of the MSR read/write instruction in bytes.
    1003996 */
    1004 IEM_STATIC VBOXSTRICTRC iemSvmHandleMsrIntercept(PVMCPU pVCpu, PCPUMCTX pCtx, uint32_t idMsr, bool fWrite)
     997IEM_STATIC VBOXSTRICTRC iemSvmHandleMsrIntercept(PVMCPU pVCpu, uint32_t idMsr, bool fWrite)
    1005998{
    1006999    /*
    10071000     * Check if any MSRs are being intercepted.
    10081001     */
    1009     Assert(CPUMIsGuestSvmCtrlInterceptSet(pVCpu, pCtx, SVM_CTRL_INTERCEPT_MSR_PROT));
    1010     Assert(CPUMIsGuestInSvmNestedHwVirtMode(pCtx));
     1002    Assert(CPUMIsGuestSvmCtrlInterceptSet(pVCpu, IEM_GET_CTX(pVCpu), SVM_CTRL_INTERCEPT_MSR_PROT));
     1003    Assert(CPUMIsGuestInSvmNestedHwVirtMode(IEM_GET_CTX(pVCpu)));
    10111004
    10121005    uint64_t const uExitInfo1 = fWrite ? SVM_EXIT1_MSR_WRITE : SVM_EXIT1_MSR_READ;
    … …  
    10281021         * Check if the bit is set, if so, trigger a #VMEXIT.
    10291022         */
    1030         uint8_t *pbMsrpm = (uint8_t *)pCtx->hwvirt.svm.CTX_SUFF(pvMsrBitmap);
     1023        uint8_t *pbMsrpm = (uint8_t *)pVCpu->cpum.GstCtx.hwvirt.svm.CTX_SUFF(pvMsrBitmap);
    10311024        pbMsrpm += offMsrpm;
    10321025        if (*pbMsrpm & RT_BIT(uMsrpmBit))
    10331026        {
    10341027            IEM_SVM_UPDATE_NRIP(pVCpu);
    1035             return iemSvmVmexit(pVCpu, pCtx, SVM_EXIT_MSR, uExitInfo1, 0 /* uExitInfo2 */);
     1028            return iemSvmVmexit(pVCpu, SVM_EXIT_MSR, uExitInfo1, 0 /* uExitInfo2 */);
    10361029        }
    10371030    }
    … …  
    10421035         */
    10431036        Log(("iemSvmHandleMsrIntercept: Invalid/out-of-range MSR %#RX32 fWrite=%RTbool -> #VMEXIT\n", idMsr, fWrite));
    1044         return iemSvmVmexit(pVCpu, pCtx, SVM_EXIT_MSR, uExitInfo1, 0 /* uExitInfo2 */);
     1037        return iemSvmVmexit(pVCpu, SVM_EXIT_MSR, uExitInfo1, 0 /* uExitInfo2 */);
    10451038    }
    10461039    return VINF_HM_INTERCEPT_NOT_ACTIVE;
    … …  
    10591052# else
    10601053    LogFlow(("iemCImpl_vmrun\n"));
    1061     PCPUMCTX pCtx = IEM_GET_CTX(pVCpu);
    10621054    IEM_SVM_INSTR_COMMON_CHECKS(pVCpu, vmrun);
    10631055
    10641056    /** @todo Check effective address size using address size prefix. */
    1065     RTGCPHYS const GCPhysVmcb = pVCpu->iem.s.enmCpuMode == IEMMODE_64BIT ? pCtx->rax : pCtx->eax;
     1057    RTGCPHYS const GCPhysVmcb = pVCpu->iem.s.enmCpuMode == IEMMODE_64BIT ? pVCpu->cpum.GstCtx.rax : pVCpu->cpum.GstCtx.eax;
    10661058    if (   (GCPhysVmcb & X86_PAGE_4K_OFFSET_MASK)
    10671059        || !PGMPhysIsGCPhysNormal(pVCpu->CTX_SUFF(pVM), GCPhysVmcb))
    … …  
    10771069    }
    10781070
    1079     VBOXSTRICTRC rcStrict = iemSvmVmrun(pVCpu, pCtx, cbInstr, GCPhysVmcb);
     1071    VBOXSTRICTRC rcStrict = iemSvmVmrun(pVCpu, cbInstr, GCPhysVmcb);
    10801072    if (rcStrict == VERR_SVM_VMEXIT_FAILED)
    10811073    {
    1082         Assert(!CPUMIsGuestInSvmNestedHwVirtMode(pCtx));
     1074        Assert(!CPUMIsGuestInSvmNestedHwVirtMode(IEM_GET_CTX(pVCpu)));
    10831075        rcStrict = VINF_EM_TRIPLE_FAULT;
    10841076    }
    … …  
    11611153# else
    11621154    LogFlow(("iemCImpl_vmload\n"));
    1163     PCPUMCTX pCtx = IEM_GET_CTX(pVCpu);
    11641155    IEM_SVM_INSTR_COMMON_CHECKS(pVCpu, vmload);
    11651156
    11661157    /** @todo Check effective address size using address size prefix. */
    1167     RTGCPHYS const GCPhysVmcb = pVCpu->iem.s.enmCpuMode == IEMMODE_64BIT ? pCtx->rax : pCtx->eax;
     1158    RTGCPHYS const GCPhysVmcb = pVCpu->iem.s.enmCpuMode == IEMMODE_64BIT ? pVCpu->cpum.GstCtx.rax : pVCpu->cpum.GstCtx.eax;
    11681159    if (   (GCPhysVmcb & X86_PAGE_4K_OFFSET_MASK)
    11691160        || !PGMPhysIsGCPhysNormal(pVCpu->CTX_SUFF(pVM), GCPhysVmcb))
    … …  
    11851176    {
    11861177        LogFlow(("vmload: Loading VMCB at %#RGp enmEffAddrMode=%d\n", GCPhysVmcb, pVCpu->iem.s.enmEffAddrMode));
    1187         HMSVM_SEG_REG_COPY_FROM_VMCB(pCtx, &VmcbNstGst, FS, fs);
    1188         HMSVM_SEG_REG_COPY_FROM_VMCB(pCtx, &VmcbNstGst, GS, gs);
    1189         HMSVM_SEG_REG_COPY_FROM_VMCB(pCtx, &VmcbNstGst, TR, tr);
    1190         HMSVM_SEG_REG_COPY_FROM_VMCB(pCtx, &VmcbNstGst, LDTR, ldtr);
    1191 
    1192         pCtx->msrKERNELGSBASE = VmcbNstGst.u64KernelGSBase;
    1193         pCtx->msrSTAR         = VmcbNstGst.u64STAR;
    1194         pCtx->msrLSTAR        = VmcbNstGst.u64LSTAR;
    1195         pCtx->msrCSTAR        = VmcbNstGst.u64CSTAR;
    1196         pCtx->msrSFMASK       = VmcbNstGst.u64SFMASK;
    1197 
    1198         pCtx->SysEnter.cs     = VmcbNstGst.u64SysEnterCS;
    1199         pCtx->SysEnter.esp    = VmcbNstGst.u64SysEnterESP;
    1200         pCtx->SysEnter.eip    = VmcbNstGst.u64SysEnterEIP;
     1178        HMSVM_SEG_REG_COPY_FROM_VMCB(IEM_GET_CTX(pVCpu), &VmcbNstGst, FS, fs);
     1179        HMSVM_SEG_REG_COPY_FROM_VMCB(IEM_GET_CTX(pVCpu), &VmcbNstGst, GS, gs);
     1180        HMSVM_SEG_REG_COPY_FROM_VMCB(IEM_GET_CTX(pVCpu), &VmcbNstGst, TR, tr);
     1181        HMSVM_SEG_REG_COPY_FROM_VMCB(IEM_GET_CTX(pVCpu), &VmcbNstGst, LDTR, ldtr);
     1182
     1183        pVCpu->cpum.GstCtx.msrKERNELGSBASE = VmcbNstGst.u64KernelGSBase;
     1184        pVCpu->cpum.GstCtx.msrSTAR         = VmcbNstGst.u64STAR;
     1185        pVCpu->cpum.GstCtx.msrLSTAR        = VmcbNstGst.u64LSTAR;
     1186        pVCpu->cpum.GstCtx.msrCSTAR        = VmcbNstGst.u64CSTAR;
     1187        pVCpu->cpum.GstCtx.msrSFMASK       = VmcbNstGst.u64SFMASK;
     1188
     1189        pVCpu->cpum.GstCtx.SysEnter.cs     = VmcbNstGst.u64SysEnterCS;
     1190        pVCpu->cpum.GstCtx.SysEnter.esp    = VmcbNstGst.u64SysEnterESP;
     1191        pVCpu->cpum.GstCtx.SysEnter.eip    = VmcbNstGst.u64SysEnterEIP;
    12011192
    12021193        iemRegAddToRipAndClearRF(pVCpu, cbInstr);
    … …  
    12171208# else
    12181209    LogFlow(("iemCImpl_vmsave\n"));
    1219     PCPUMCTX pCtx = IEM_GET_CTX(pVCpu);
    12201210    IEM_SVM_INSTR_COMMON_CHECKS(pVCpu, vmsave);
    12211211
    12221212    /** @todo Check effective address size using address size prefix. */
    1223     RTGCPHYS const GCPhysVmcb = pVCpu->iem.s.enmCpuMode == IEMMODE_64BIT ? pCtx->rax : pCtx->eax;
     1213    RTGCPHYS const GCPhysVmcb = pVCpu->iem.s.enmCpuMode == IEMMODE_64BIT ? pVCpu->cpum.GstCtx.rax : pVCpu->cpum.GstCtx.eax;
    12241214    if (   (GCPhysVmcb & X86_PAGE_4K_OFFSET_MASK)
    12251215        || !PGMPhysIsGCPhysNormal(pVCpu->CTX_SUFF(pVM), GCPhysVmcb))
    … …  
    12411231    {
    12421232        LogFlow(("vmsave: Saving VMCB at %#RGp enmEffAddrMode=%d\n", GCPhysVmcb, pVCpu->iem.s.enmEffAddrMode));
    1243         HMSVM_SEG_REG_COPY_TO_VMCB(pCtx, &VmcbNstGst, FS, fs);
    1244         HMSVM_SEG_REG_COPY_TO_VMCB(pCtx, &VmcbNstGst, GS, gs);
    1245         HMSVM_SEG_REG_COPY_TO_VMCB(pCtx, &VmcbNstGst, TR, tr);
    1246         HMSVM_SEG_REG_COPY_TO_VMCB(pCtx, &VmcbNstGst, LDTR, ldtr);
    1247 
    1248         VmcbNstGst.u64KernelGSBase  = pCtx->msrKERNELGSBASE;
    1249         VmcbNstGst.u64STAR          = pCtx->msrSTAR;
    1250         VmcbNstGst.u64LSTAR         = pCtx->msrLSTAR;
    1251         VmcbNstGst.u64CSTAR         = pCtx->msrCSTAR;
    1252         VmcbNstGst.u64SFMASK        = pCtx->msrSFMASK;
    1253 
    1254         VmcbNstGst.u64SysEnterCS    = pCtx->SysEnter.cs;
    1255         VmcbNstGst.u64SysEnterESP   = pCtx->SysEnter.esp;
    1256         VmcbNstGst.u64SysEnterEIP   = pCtx->SysEnter.eip;
     1233        HMSVM_SEG_REG_COPY_TO_VMCB(IEM_GET_CTX(pVCpu), &VmcbNstGst, FS, fs);
     1234        HMSVM_SEG_REG_COPY_TO_VMCB(IEM_GET_CTX(pVCpu), &VmcbNstGst, GS, gs);
     1235        HMSVM_SEG_REG_COPY_TO_VMCB(IEM_GET_CTX(pVCpu), &VmcbNstGst, TR, tr);
     1236        HMSVM_SEG_REG_COPY_TO_VMCB(IEM_GET_CTX(pVCpu), &VmcbNstGst, LDTR, ldtr);
     1237
     1238        VmcbNstGst.u64KernelGSBase  = pVCpu->cpum.GstCtx.msrKERNELGSBASE;
     1239        VmcbNstGst.u64STAR          = pVCpu->cpum.GstCtx.msrSTAR;
     1240        VmcbNstGst.u64LSTAR         = pVCpu->cpum.GstCtx.msrLSTAR;
     1241        VmcbNstGst.u64CSTAR         = pVCpu->cpum.GstCtx.msrCSTAR;
     1242        VmcbNstGst.u64SFMASK        = pVCpu->cpum.GstCtx.msrSFMASK;
     1243
     1244        VmcbNstGst.u64SysEnterCS    = pVCpu->cpum.GstCtx.SysEnter.cs;
     1245        VmcbNstGst.u64SysEnterESP   = pVCpu->cpum.GstCtx.SysEnter.esp;
     1246        VmcbNstGst.u64SysEnterEIP   = pVCpu->cpum.GstCtx.SysEnter.eip;
    12571247
    12581248        rcStrict = PGMPhysSimpleWriteGCPhys(pVCpu->CTX_SUFF(pVM), GCPhysVmcb + RT_OFFSETOF(SVMVMCB, guest), &VmcbNstGst,
    … …  
    12761266# else
    12771267    LogFlow(("iemCImpl_clgi\n"));
    1278     PCPUMCTX pCtx = IEM_GET_CTX(pVCpu);
    12791268    IEM_SVM_INSTR_COMMON_CHECKS(pVCpu, clgi);
    12801269    if (IEM_IS_SVM_CTRL_INTERCEPT_SET(pVCpu, SVM_CTRL_INTERCEPT_CLGI))
    … …  
    12841273    }
    12851274
    1286     pCtx->hwvirt.fGif = false;
     1275    pVCpu->cpum.GstCtx.hwvirt.fGif = false;
    12871276    iemRegAddToRipAndClearRF(pVCpu, cbInstr);
    12881277
    … …  
    13061295# else
    13071296    LogFlow(("iemCImpl_stgi\n"));
    1308     PCPUMCTX pCtx = IEM_GET_CTX(pVCpu);
    13091297    IEM_SVM_INSTR_COMMON_CHECKS(pVCpu, stgi);
    13101298    if (IEM_IS_SVM_CTRL_INTERCEPT_SET(pVCpu, SVM_CTRL_INTERCEPT_STGI))
    … …  
    13141302    }
    13151303
    1316     pCtx->hwvirt.fGif = true;
     1304    pVCpu->cpum.GstCtx.hwvirt.fGif = true;
    13171305    iemRegAddToRipAndClearRF(pVCpu, cbInstr);
    13181306
    … …  
    13311319IEM_CIMPL_DEF_0(iemCImpl_invlpga)
    13321320{
    1333     PCPUMCTX pCtx = IEM_GET_CTX(pVCpu);
    13341321    /** @todo Check effective address size using address size prefix. */
    1335     RTGCPTR  const GCPtrPage = pVCpu->iem.s.enmCpuMode == IEMMODE_64BIT ? pCtx->rax : pCtx->eax;
     1322    RTGCPTR  const GCPtrPage = pVCpu->iem.s.enmCpuMode == IEMMODE_64BIT ? pVCpu->cpum.GstCtx.rax : pVCpu->cpum.GstCtx.eax;
    13361323    /** @todo PGM needs virtual ASID support. */
    13371324# if 0
    1338     uint32_t const uAsid     = pCtx->ecx;
     1325    uint32_t const uAsid     = pVCpu->cpum.GstCtx.ecx;
    13391326# endif
    13401327

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

    r72209 r72496  
    42654265    /* Calc effective address with modified ESP. */
    42664266/** @todo testcase */
    4267     PCPUMCTX        pCtx     = IEM_GET_CTX(pVCpu);
    42684267    RTGCPTR         GCPtrEff;
    42694268    VBOXSTRICTRC    rcStrict;
    … …  
    42814280    /* Perform the operation - this should be CImpl. */
    42824281    RTUINT64U TmpRsp;
    4283     TmpRsp.u = pCtx->rsp;
     4282    TmpRsp.u = pVCpu->cpum.GstCtx.rsp;
    42844283    switch (pVCpu->iem.s.enmEffOpSize)
    42854284    {
    … …  
    43154314    if (rcStrict == VINF_SUCCESS)
    43164315    {
    4317         pCtx->rsp = TmpRsp.u;
     4316        pVCpu->cpum.GstCtx.rsp = TmpRsp.u;
    43184317        iemRegUpdateRipAndClearRF(pVCpu);
    43194318    }
    … …  
    44614460        {
    44624461            /* TSC based pause-filter thresholding. */
    4463             PCPUMCTX pCtx = IEM_GET_CTX(pVCpu);
    44644462            if (   IEM_GET_GUEST_CPU_FEATURES(pVCpu)->fSvmPauseFilterThreshold
    4465                 && pCtx->hwvirt.svm.cPauseFilterThreshold > 0)
     4463/** @todo r=bird: You're mixing decoding and implementation here!!  pVCpu->cpum.GstCtx.hwvirt.svm.cPauseFilterThreshold can be
     4464 *  modified by the guest and you cannot have a compile time check on it like this.  Ditto for pVCpu->cpum.GstCtx.hwvirt.svm.cPauseFilter below.
     4465 *  You need to move this into IEMAllCImpl.cpp.h!
     4466 */
     4467                && pVCpu->cpum.GstCtx.hwvirt.svm.cPauseFilterThreshold > 0)
    44664468            {
    44674469                uint64_t const uTick = TMCpuTickGet(pVCpu);
    4468                 if (uTick - pCtx->hwvirt.svm.uPrevPauseTick > pCtx->hwvirt.svm.cPauseFilterThreshold)
    4469                     pCtx->hwvirt.svm.cPauseFilter = IEM_GET_SVM_PAUSE_FILTER_COUNT(pVCpu);
    4470                 pCtx->hwvirt.svm.uPrevPauseTick = uTick;
     4470                if (uTick - pVCpu->cpum.GstCtx.hwvirt.svm.uPrevPauseTick > pVCpu->cpum.GstCtx.hwvirt.svm.cPauseFilterThreshold)
     4471                    pVCpu->cpum.GstCtx.hwvirt.svm.cPauseFilter = IEM_GET_SVM_PAUSE_FILTER_COUNT(pVCpu);
     4472                pVCpu->cpum.GstCtx.hwvirt.svm.uPrevPauseTick = uTick;
    44714473            }
    44724474
    44734475            /* Simple pause-filter counter. */
    4474             if (pCtx->hwvirt.svm.cPauseFilter > 0)
     4476            if (pVCpu->cpum.GstCtx.hwvirt.svm.cPauseFilter > 0)
    44754477            {
    4476                 --pCtx->hwvirt.svm.cPauseFilter;
     4478                --pVCpu->cpum.GstCtx.hwvirt.svm.cPauseFilter;
    44774479                fCheckIntercept = false;
    44784480            }

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

    r72495 r72496  
    636636/** @def IEM_CTX_ASSERT
    637637 * Asserts that the @a a_fExtrnMbz is present in the CPU context.
    638  * @param   a_pCtx          The CPUMCTX structure.
     638 * @param   a_pVCpu         The cross context virtual CPU structure of the calling thread.
    639639 * @param   a_fExtrnMbz     The mask of CPUMCTX_EXTRN_XXX flags that must be zero.
    640640 */
    641 #define IEM_CTX_ASSERT(a_pCtx, a_fExtrnMbz)     Assert(!((a_pCtx)->fExtrn & (a_fExtrnMbz)))
     641#define IEM_CTX_ASSERT(a_pVCpu, a_fExtrnMbz)     Assert(!((a_pVCpu)->cpum.GstCtx.fExtrn & (a_fExtrnMbz)))
    642642
    643643/** @def IEM_CTX_IMPORT_RET
    … …  
    648648 * Returns on import failure.
    649649 *
    650  * @param   a_pVCpu         The cross context virtual CPU structure.
    651  * @param   a_pCtx          The CPUMCTX structure.
     650 * @param   a_pVCpu         The cross context virtual CPU structure of the calling thread.
    652651 * @param   a_fExtrnImport  The mask of CPUMCTX_EXTRN_XXX flags to import.
    653652 */
    654 #define IEM_CTX_IMPORT_RET(a_pVCpu, a_pCtx, a_fExtrnImport) \
     653#define IEM_CTX_IMPORT_RET(a_pVCpu, a_fExtrnImport) \
    655654    do { \
    656         if (!((a_pCtx)->fExtrn & (a_fExtrnImport))) \
     655        if (!((a_pVCpu)->cpum.GstCtx.fExtrn & (a_fExtrnImport))) \
    657656        { /* likely */ } \
    658657        else \
    … …  
    668667 * Will call the keep to import the bits as needed.
    669668 *
    670  * @param   a_pVCpu         The cross context virtual CPU structure.
    671  * @param   a_pCtx          The CPUMCTX structure.
     669 * @param   a_pVCpu         The cross context virtual CPU structure of the calling thread.
    672670 * @param   a_fExtrnImport  The mask of CPUMCTX_EXTRN_XXX flags to import.
    673671 */
    674 #define IEM_CTX_IMPORT_NORET(a_pVCpu, a_pCtx, a_fExtrnImport) \
     672#define IEM_CTX_IMPORT_NORET(a_pVCpu, a_fExtrnImport) \
    675673    do { \
    676         if (!((a_pCtx)->fExtrn & (a_fExtrnImport))) \
     674        if (!((a_pVCpu)->cpum.GstCtx.fExtrn & (a_fExtrnImport))) \
    677675        { /* likely */ } \
    678676        else \
    … …  
    690688 * Jumps on import failure.
    691689 *
    692  * @param   a_pVCpu         The cross context virtual CPU structure.
    693  * @param   a_pCtx          The CPUMCTX structure.
     690 * @param   a_pVCpu         The cross context virtual CPU structure of the calling thread.
    694691 * @param   a_fExtrnImport  The mask of CPUMCTX_EXTRN_XXX flags to import.
    695692 */
    696 #define IEM_CTX_IMPORT_JMP(a_pVCpu, a_pCtx, a_fExtrnImport) \
     693#define IEM_CTX_IMPORT_JMP(a_pVCpu, a_fExtrnImport) \
    697694    do { \
    698         if (!((a_pCtx)->fExtrn & (a_fExtrnImport))) \
     695        if (!((a_pVCpu)->cpum.GstCtx.fExtrn & (a_fExtrnImport))) \
    699696        { /* likely */ } \
    700697        else \
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