VirtualBox

儲存庫 vbox 的更動 13960


忽略:
時間撮記:
2008-11-7 下午01:04:45 (16 年 以前)
作者:
vboxsync
訊息:

Moved guest and host CPU contexts into per-VCPU array.

位置:
trunk
檔案:
修改 20 筆資料

圖例:

未更動
新增
刪除

  • trunk/include/VBox/cpum.h

    r13832 r13960  
    891891VMMDECL(void)           CPUMHyperSetCtxCore(PVM pVM, PCPUMCTXCORE pCtxCore);
    892892VMMDECL(PCPUMCTX)       CPUMQueryGuestCtxPtr(PVM pVM);
     893VMMDECL(PCPUMCTX)       CPUMQueryGuestCtxPtrEx(PVM pVM, PVMCPU pVCpu);
    893894VMMDECL(int)            CPUMQueryHyperCtxPtr(PVM pVM, PCPUMCTX *ppCtx);
    894895VMMDECL(PCCPUMCTXCORE)  CPUMGetGuestCtxCore(PVM pVM);
    … …  
    899900VMMDECL(uint32_t)       CPUMRawGetEFlags(PVM pVM, PCPUMCTXCORE pCtxCore);
    900901VMMDECL(void)           CPUMRawSetEFlags(PVM pVM, PCPUMCTXCORE pCtxCore, uint32_t eflags);
    901 VMMDECL(int)            CPUMHandleLazyFPU(PVM pVM);
    902 VMMDECL(int)            CPUMRestoreHostFPUState(PVM pVM);
     902VMMDECL(int)            CPUMHandleLazyFPU(PVM pVM, PVMCPU pVCpu);
     903VMMDECL(int)            CPUMRestoreHostFPUState(PVM pVM, PVMCPU pVCpu);
    903904
    904905/** @name Changed flags
    … …  
    928929VMMDECL(bool)           CPUMIsHostUsingSysEnter(PVM pVM);
    929930VMMDECL(bool)           CPUMIsHostUsingSysCall(PVM pVM);
    930 VMMDECL(bool)           CPUMIsGuestFPUStateActive(PVM pVM);
     931VMMDECL(bool)           CPUMIsGuestFPUStateActive(PVMCPU pVCPU);
    931932VMMDECL(void)           CPUMDeactivateGuestFPUState(PVM pVM);
    932933VMMDECL(bool)           CPUMIsGuestDebugStateActive(PVM pVM);
    … …  
    966967VMMR3DECL(int)          CPUMR3TermCPU(PVM pVM);
    967968VMMR3DECL(void)         CPUMR3Reset(PVM pVM);
    968 VMMR3DECL(int)          CPUMR3QueryGuestCtxRCPtr(PVM pVM, RCPTRTYPE(PCPUMCTX) *ppCtx);
    969969# ifdef DEBUG
    970970VMMR3DECL(void)         CPUMR3SaveEntryCtx(PVM pVM);
    … …  
    10061006 */
    10071007VMMR0DECL(int)          CPUMR0Init(PVM pVM);
    1008 VMMR0DECL(int)          CPUMR0LoadGuestFPU(PVM pVM, PCPUMCTX pCtx);
    1009 VMMR0DECL(int)          CPUMR0SaveGuestFPU(PVM pVM, PCPUMCTX pCtx);
    1010 VMMR0DECL(int)          CPUMR0SaveGuestDebugState(PVM pVM, PCPUMCTX pCtx, bool fDR6);
    1011 VMMR0DECL(int)          CPUMR0LoadGuestDebugState(PVM pVM, PCPUMCTX pCtx, bool fDR6);
     1008VMMR0DECL(int)          CPUMR0LoadGuestFPU(PVM pVM, PVMCPU pVCpu, PCPUMCTX pCtx);
     1009VMMR0DECL(int)          CPUMR0SaveGuestFPU(PVM pVM, PVMCPU pVCpu, PCPUMCTX pCtx);
     1010VMMR0DECL(int)          CPUMR0SaveGuestDebugState(PVM pVM, PVMCPU pVCpu, PCPUMCTX pCtx, bool fDR6);
     1011VMMR0DECL(int)          CPUMR0LoadGuestDebugState(PVM pVM, PVMCPU pVCpu, PCPUMCTX pCtx, bool fDR6);
    10121012
    10131013/** @} */

  • trunk/include/VBox/vm.h

    r13898 r13960  
    107107        struct CPUMCPU      s;
    108108#endif
    109         char                padding[4096];      /* multiple of 32 */
     109        char                padding[2048];      /* multiple of 32 */
    110110    } cpum;
    111111    /** VMM part. */
    … …  
    570570    STAMPROFILEADV      StatSwitcherTSS;
    571571
    572 /** @todo Realign everything on 64 byte boundraries to better match the
     572/** @todo Realign everything on 64 byte boundaries to better match the
    573573 *        cache-line size. */
    574574    /* padding - the unions must be aligned on 32 bytes boundraries. */
    … …  
    581581        struct CPUM s;
    582582#endif
    583         char        padding[4416];      /* multiple of 32 */
     583        char        padding[4096];      /* multiple of 32 */
    584584    } cpum;
    585585

  • trunk/include/VBox/vm.mac

    r13831 r13960  
    9595
    9696    alignb 64
    97     .cpum                 resb 4416
     97    .cpum                 resb 4096
    9898    .vmm                  resb 1024
    9999
    100100endstruc
    101101
     102;;
     103; This is part of  the VMCPU structure.
     104struc VMCPU
     105    .fForcedActions     resd 1
     106    .enmState           resd 1
     107    .pVMR3              RTR3PTR_RES 1
     108    .pVMR0              RTR0PTR_RES 1
     109    .pVMRC              RTRCPTR_RES 1
     110    .idCpu              resd 1
     111
     112    .hNativeThread      RTR0PTR_RES 1
     113
     114    alignb 64
     115
     116    .cpum               resb 2048
     117endstruc
     118
    102119
    103120%endif

  • trunk/src/VBox/VMM/CPUM.cpp

    r13840 r13960  
    129129    /* Hidden selector registers are invalid by default. */
    130130    pVM->cpum.s.fValidHiddenSelRegs  = false;
     131
     132    /* Calculate the offset from CPUM to CPUMCPU for the first CPU. */
     133    pVM->cpum.s.ulOffCPUMCPU = RT_OFFSETOF(VM, aCpus[0].cpum) - RT_OFFSETOF(VM, cpum);
     134    Assert((uintptr_t)&pVM->cpum + pVM->cpum.s.ulOffCPUMCPU == (uintptr_t)&pVM->aCpus[0].cpum);
     135
     136    /* Calculate the offset from CPUMCPU to CPUM. */
     137    for (unsigned i=0;i<pVM->cCPUs;i++)
     138    {
     139        pVM->aCpus[i].cpum.s.ulOffCPUM = RT_OFFSETOF(VM, aCpus[i].cpum) - RT_OFFSETOF(VM, cpum);
     140        Assert((uintptr_t)&pVM->aCpus[i].cpum - pVM->aCpus[i].cpum.s.ulOffCPUM == (uintptr_t)&pVM->cpum);
     141    }
    131142
    132143    /*
    … …  
    628639
    629640/**
    630  * Queries the pointer to the internal CPUMCTX structure
    631  *
    632  * @returns VBox status code.
    633  * @param   pVM         Handle to the virtual machine.
    634  * @param   ppCtx       Receives the CPUMCTX GC pointer when successful.
    635  */
    636 VMMR3DECL(int) CPUMR3QueryGuestCtxRCPtr(PVM pVM, RCPTRTYPE(PCPUMCTX) *ppCtx)
    637 {
    638     LogFlow(("CPUMR3QueryGuestCtxRCPtr\n"));
    639     /*
    640      * Store the address. (Later we might check how's calling, thus the RC.)
    641      */
    642     *ppCtx = VM_RC_ADDR(pVM, &pVM->cpum.s.Guest);
    643     return VINF_SUCCESS;
    644 }
    645 
    646 
    647 /**
    648641 * Terminates the CPUM.
    649642 *
    … …  
    684677VMMR3DECL(void) CPUMR3Reset(PVM pVM)
    685678{
    686     PCPUMCTX pCtx = &pVM->cpum.s.Guest;
    687 
    688     /*
    689      * Initialize everything to ZERO first.
    690      */
    691     uint32_t    fUseFlags =  pVM->cpum.s.fUseFlags & ~CPUM_USED_FPU_SINCE_REM;
    692     memset(pCtx, 0, sizeof(*pCtx));
    693     pVM->cpum.s.fUseFlags   = fUseFlags;
    694 
    695     pCtx->cr0                       = X86_CR0_CD | X86_CR0_NW | X86_CR0_ET;  //0x60000010
    696     pCtx->eip                       = 0x0000fff0;
    697     pCtx->edx                       = 0x00000600;   /* P6 processor */
    698     pCtx->eflags.Bits.u1Reserved0   = 1;
    699 
    700     pCtx->cs                        = 0xf000;
    701     pCtx->csHid.u64Base             = UINT64_C(0xffff0000);
    702     pCtx->csHid.u32Limit            = 0x0000ffff;
    703     pCtx->csHid.Attr.n.u1DescType   = 1; /* code/data segment */
    704     pCtx->csHid.Attr.n.u1Present    = 1;
    705     pCtx->csHid.Attr.n.u4Type       = X86_SEL_TYPE_READ | X86_SEL_TYPE_CODE;
    706 
    707     pCtx->dsHid.u32Limit            = 0x0000ffff;
    708     pCtx->dsHid.Attr.n.u1DescType   = 1; /* code/data segment */
    709     pCtx->dsHid.Attr.n.u1Present    = 1;
    710     pCtx->dsHid.Attr.n.u4Type       = X86_SEL_TYPE_RW;
    711 
    712     pCtx->esHid.u32Limit            = 0x0000ffff;
    713     pCtx->esHid.Attr.n.u1DescType   = 1; /* code/data segment */
    714     pCtx->esHid.Attr.n.u1Present    = 1;
    715     pCtx->esHid.Attr.n.u4Type       = X86_SEL_TYPE_RW;
    716 
    717     pCtx->fsHid.u32Limit            = 0x0000ffff;
    718     pCtx->fsHid.Attr.n.u1DescType   = 1; /* code/data segment */
    719     pCtx->fsHid.Attr.n.u1Present    = 1;
    720     pCtx->fsHid.Attr.n.u4Type       = X86_SEL_TYPE_RW;
    721 
    722     pCtx->gsHid.u32Limit            = 0x0000ffff;
    723     pCtx->gsHid.Attr.n.u1DescType   = 1; /* code/data segment */
    724     pCtx->gsHid.Attr.n.u1Present    = 1;
    725     pCtx->gsHid.Attr.n.u4Type       = X86_SEL_TYPE_RW;
    726 
    727     pCtx->ssHid.u32Limit            = 0x0000ffff;
    728     pCtx->ssHid.Attr.n.u1Present    = 1;
    729     pCtx->ssHid.Attr.n.u1DescType   = 1; /* code/data segment */
    730     pCtx->ssHid.Attr.n.u4Type       = X86_SEL_TYPE_RW;
    731 
    732     pCtx->idtr.cbIdt                = 0xffff;
    733     pCtx->gdtr.cbGdt                = 0xffff;
    734 
    735     pCtx->ldtrHid.u32Limit          = 0xffff;
    736     pCtx->ldtrHid.Attr.n.u1Present  = 1;
    737     pCtx->ldtrHid.Attr.n.u4Type     = X86_SEL_TYPE_SYS_LDT;
    738 
    739     pCtx->trHid.u32Limit            = 0xffff;
    740     pCtx->trHid.Attr.n.u1Present    = 1;
    741     pCtx->trHid.Attr.n.u4Type       = X86_SEL_TYPE_SYS_386_TSS_BUSY;
    742 
    743     pCtx->dr[6]                     = X86_DR6_INIT_VAL;
    744     pCtx->dr[7]                     = X86_DR7_INIT_VAL;
    745 
    746     pCtx->fpu.FTW                   = 0xff;         /* All tags are set, i.e. the regs are empty. */
    747     pCtx->fpu.FCW                   = 0x37f;
    748 
    749     /* Intel 64 and IA-32 Architectures Software Developer's Manual Volume 3A, Table 8-1. IA-32 Processor States Following Power-up, Reset, or INIT */
    750     pCtx->fpu.MXCSR                 = 0x1F80;
    751 
    752     /* Init PAT MSR */
    753     pCtx->msrPAT                    = UINT64_C(0x0007040600070406); /** @todo correct? */
    754 
    755     /* Reset EFER; see AMD64 Architecture Programmer's Manual Volume 2: Table 14-1. Initial Processor State
    756      * The Intel docs don't mention it.
    757      */
    758     pCtx->msrEFER                   = 0;
     679    /* @todo anything different for VCPU > 0? */
     680    for (unsigned i=0;i<pVM->cCPUs;i++)
     681    {
     682        PCPUMCTX pCtx = CPUMQueryGuestCtxPtrEx(pVM, &pVM->aCpus[i]);
     683
     684        /*
     685        * Initialize everything to ZERO first.
     686        */
     687        uint32_t    fUseFlags =  pVM->aCpus[i].cpum.s.fUseFlags & ~CPUM_USED_FPU_SINCE_REM;
     688        memset(pCtx, 0, sizeof(*pCtx));
     689        pVM->aCpus[i].cpum.s.fUseFlags  = fUseFlags;
     690
     691        pCtx->cr0                       = X86_CR0_CD | X86_CR0_NW | X86_CR0_ET;  //0x60000010
     692        pCtx->eip                       = 0x0000fff0;
     693        pCtx->edx                       = 0x00000600;   /* P6 processor */
     694        pCtx->eflags.Bits.u1Reserved0   = 1;
     695
     696        pCtx->cs                        = 0xf000;
     697        pCtx->csHid.u64Base             = UINT64_C(0xffff0000);
     698        pCtx->csHid.u32Limit            = 0x0000ffff;
     699        pCtx->csHid.Attr.n.u1DescType   = 1; /* code/data segment */
     700        pCtx->csHid.Attr.n.u1Present    = 1;
     701        pCtx->csHid.Attr.n.u4Type       = X86_SEL_TYPE_READ | X86_SEL_TYPE_CODE;
     702
     703        pCtx->dsHid.u32Limit            = 0x0000ffff;
     704        pCtx->dsHid.Attr.n.u1DescType   = 1; /* code/data segment */
     705        pCtx->dsHid.Attr.n.u1Present    = 1;
     706        pCtx->dsHid.Attr.n.u4Type       = X86_SEL_TYPE_RW;
     707
     708        pCtx->esHid.u32Limit            = 0x0000ffff;
     709        pCtx->esHid.Attr.n.u1DescType   = 1; /* code/data segment */
     710        pCtx->esHid.Attr.n.u1Present    = 1;
     711        pCtx->esHid.Attr.n.u4Type       = X86_SEL_TYPE_RW;
     712
     713        pCtx->fsHid.u32Limit            = 0x0000ffff;
     714        pCtx->fsHid.Attr.n.u1DescType   = 1; /* code/data segment */
     715        pCtx->fsHid.Attr.n.u1Present    = 1;
     716        pCtx->fsHid.Attr.n.u4Type       = X86_SEL_TYPE_RW;
     717
     718        pCtx->gsHid.u32Limit            = 0x0000ffff;
     719        pCtx->gsHid.Attr.n.u1DescType   = 1; /* code/data segment */
     720        pCtx->gsHid.Attr.n.u1Present    = 1;
     721        pCtx->gsHid.Attr.n.u4Type       = X86_SEL_TYPE_RW;
     722
     723        pCtx->ssHid.u32Limit            = 0x0000ffff;
     724        pCtx->ssHid.Attr.n.u1Present    = 1;
     725        pCtx->ssHid.Attr.n.u1DescType   = 1; /* code/data segment */
     726        pCtx->ssHid.Attr.n.u4Type       = X86_SEL_TYPE_RW;
     727
     728        pCtx->idtr.cbIdt                = 0xffff;
     729        pCtx->gdtr.cbGdt                = 0xffff;
     730
     731        pCtx->ldtrHid.u32Limit          = 0xffff;
     732        pCtx->ldtrHid.Attr.n.u1Present  = 1;
     733        pCtx->ldtrHid.Attr.n.u4Type     = X86_SEL_TYPE_SYS_LDT;
     734
     735        pCtx->trHid.u32Limit            = 0xffff;
     736        pCtx->trHid.Attr.n.u1Present    = 1;
     737        pCtx->trHid.Attr.n.u4Type       = X86_SEL_TYPE_SYS_386_TSS_BUSY;
     738
     739        pCtx->dr[6]                     = X86_DR6_INIT_VAL;
     740        pCtx->dr[7]                     = X86_DR7_INIT_VAL;
     741
     742        pCtx->fpu.FTW                   = 0xff;         /* All tags are set, i.e. the regs are empty. */
     743        pCtx->fpu.FCW                   = 0x37f;
     744
     745        /* Intel 64 and IA-32 Architectures Software Developer's Manual Volume 3A, Table 8-1. IA-32 Processor States Following Power-up, Reset, or INIT */
     746        pCtx->fpu.MXCSR                 = 0x1F80;
     747
     748        /* Init PAT MSR */
     749        pCtx->msrPAT                    = UINT64_C(0x0007040600070406); /** @todo correct? */
     750
     751        /* Reset EFER; see AMD64 Architecture Programmer's Manual Volume 2: Table 14-1. Initial Processor State
     752        * The Intel docs don't mention it.
     753        */
     754        pCtx->msrEFER                   = 0;
     755    }
    759756}
    760757
    … …  
    776773     */
    777774    SSMR3PutMem(pSSM, &pVM->cpum.s.Hyper, sizeof(pVM->cpum.s.Hyper));
    778     SSMR3PutMem(pSSM, &pVM->cpum.s.Guest, sizeof(pVM->cpum.s.Guest));
    779     SSMR3PutU32(pSSM, pVM->cpum.s.fUseFlags);
    780     SSMR3PutU32(pSSM, pVM->cpum.s.fChanged);
     775
     776    for (unsigned i=0;i<pVM->cCPUs;i++)
     777    {
     778        SSMR3PutMem(pSSM, &pVM->aCpus[i].cpum.s.Guest, sizeof(pVM->aCpus[i].cpum.s.Guest));
     779        SSMR3PutU32(pSSM, pVM->aCpus[i].cpum.s.fUseFlags);
     780        SSMR3PutU32(pSSM, pVM->aCpus[i].cpum.s.fChanged);
     781    }
    781782
    782783    SSMR3PutU32(pSSM, RT_ELEMENTS(pVM->cpum.s.aGuestCpuIdStd));
    … …  
    809810{
    810811#define CPUMCTX16_LOADREG(RegName) \
    811         pVM->cpum.s.Guest.RegName = pCpumctx16->RegName;
     812        pVM->aCpus[0].cpum.s.Guest.RegName = pCpumctx16->RegName;
    812813
    813814#define CPUMCTX16_LOADDRXREG(RegName) \
    814         pVM->cpum.s.Guest.dr[RegName] = pCpumctx16->dr##RegName;
     815        pVM->aCpus[0].cpum.s.Guest.dr[RegName] = pCpumctx16->dr##RegName;
    815816
    816817#define CPUMCTX16_LOADHIDREG(RegName) \
    817         pVM->cpum.s.Guest.RegName##Hid.u64Base  = pCpumctx16->RegName##Hid.u32Base; \
    818         pVM->cpum.s.Guest.RegName##Hid.u32Limit = pCpumctx16->RegName##Hid.u32Limit; \
    819         pVM->cpum.s.Guest.RegName##Hid.Attr     = pCpumctx16->RegName##Hid.Attr;
     818        pVM->aCpus[0].cpum.s.Guest.RegName##Hid.u64Base  = pCpumctx16->RegName##Hid.u32Base; \
     819        pVM->aCpus[0].cpum.s.Guest.RegName##Hid.u32Limit = pCpumctx16->RegName##Hid.u32Limit; \
     820        pVM->aCpus[0].cpum.s.Guest.RegName##Hid.Attr     = pCpumctx16->RegName##Hid.Attr;
    820821
    821822#define CPUMCTX16_LOADSEGREG(RegName) \
    822         pVM->cpum.s.Guest.RegName = pCpumctx16->RegName; \
     823        pVM->aCpus[0].cpum.s.Guest.RegName = pCpumctx16->RegName; \
    823824        CPUMCTX16_LOADHIDREG(RegName);
    824825
    825     pVM->cpum.s.Guest.fpu = pCpumctx16->fpu;
     826    pVM->aCpus[0].cpum.s.Guest.fpu = pCpumctx16->fpu;
    826827
    827828    CPUMCTX16_LOADREG(rax);
    … …  
    866867    CPUMCTX16_LOADDRXREG(7);
    867868
    868     pVM->cpum.s.Guest.gdtr.cbGdt   = pCpumctx16->gdtr.cbGdt;
    869     pVM->cpum.s.Guest.gdtr.pGdt    = pCpumctx16->gdtr.pGdt;
    870     pVM->cpum.s.Guest.idtr.cbIdt   = pCpumctx16->idtr.cbIdt;
    871     pVM->cpum.s.Guest.idtr.pIdt    = pCpumctx16->idtr.pIdt;
     869    pVM->aCpus[0].cpum.s.Guest.gdtr.cbGdt   = pCpumctx16->gdtr.cbGdt;
     870    pVM->aCpus[0].cpum.s.Guest.gdtr.pGdt    = pCpumctx16->gdtr.pGdt;
     871    pVM->aCpus[0].cpum.s.Guest.idtr.cbIdt   = pCpumctx16->idtr.cbIdt;
     872    pVM->aCpus[0].cpum.s.Guest.idtr.pIdt    = pCpumctx16->idtr.pIdt;
    872873
    873874    CPUMCTX16_LOADREG(ldtr);
    874875    CPUMCTX16_LOADREG(tr);
    875876
    876     pVM->cpum.s.Guest.SysEnter     = pCpumctx16->SysEnter;
     877    pVM->aCpus[0].cpum.s.Guest.SysEnter     = pCpumctx16->SysEnter;
    877878
    878879    CPUMCTX16_LOADREG(msrEFER);
    … …  
    931932    {
    932933        CPUMCTX_VER1_6 cpumctx16;
    933         memset(&pVM->cpum.s.Guest, 0, sizeof(pVM->cpum.s.Guest));
     934        memset(&pVM->aCpus[0].cpum.s.Guest, 0, sizeof(pVM->aCpus[0].cpum.s.Guest));
    934935        SSMR3GetMem(pSSM, &cpumctx16, sizeof(cpumctx16));
    935936
    936937        /* Save the old cpumctx state into the new one. */
    937938        cpumR3LoadCPUM1_6(pVM, &cpumctx16);
     939
     940        SSMR3GetU32(pSSM, &pVM->aCpus[0].cpum.s.fUseFlags);
     941        SSMR3GetU32(pSSM, &pVM->aCpus[0].cpum.s.fChanged);
    938942    }
    939943    else
    940         SSMR3GetMem(pSSM, &pVM->cpum.s.Guest, sizeof(pVM->cpum.s.Guest));
    941 
    942     SSMR3GetU32(pSSM, &pVM->cpum.s.fUseFlags);
    943     SSMR3GetU32(pSSM, &pVM->cpum.s.fChanged);
     944    {
     945        for (unsigned i=0;i<pVM->cCPUs;i++)
     946        {
     947            SSMR3GetMem(pSSM, &pVM->aCpus[i].cpum.s.Guest, sizeof(pVM->aCpus[i].cpum.s.Guest));
     948            SSMR3GetU32(pSSM, &pVM->aCpus[i].cpum.s.fUseFlags);
     949            SSMR3GetU32(pSSM, &pVM->aCpus[i].cpum.s.fChanged);
     950        }
     951    }
     952
    944953
    945954    uint32_t cElements;
    … …  
    13041313    cpumR3InfoParseArg(pszArgs, &enmType, &pszComment);
    13051314    pHlp->pfnPrintf(pHlp, "Guest CPUM state: %s\n", pszComment);
    1306     cpumR3InfoOne(pVM, &pVM->cpum.s.Guest, CPUMCTX2CORE(&pVM->cpum.s.Guest), pHlp, enmType, "");
     1315    /* @todo SMP */
     1316    PCPUMCTX pCtx = CPUMQueryGuestCtxPtr(pVM);
     1317    cpumR3InfoOne(pVM, pCtx, CPUMCTX2CORE(pCtx), pHlp, enmType, "");
    13071318}
    13081319
    … …  
    13591370     * Format the EFLAGS.
    13601371     */
    1361     PCPUMHOSTCTX pCtx = &pVM->cpum.s.Host;
     1372    /* @todo SMP */
     1373    PCPUMHOSTCTX pCtx = &pVM->aCpus[0].cpum.s.Host;
    13621374#if HC_ARCH_BITS == 32
    13631375    uint32_t efl = pCtx->eflags.u32;
    … …  
    23332345VMMR3DECL(void) CPUMR3SaveEntryCtx(PVM pVM)
    23342346{
    2335     pVM->cpum.s.GuestEntry = pVM->cpum.s.Guest;
     2347    /* @todo SMP */
     2348    pVM->cpum.s.GuestEntry = *CPUMQueryGuestCtxPtr(pVM);
    23362349}
    23372350

  • trunk/src/VBox/VMM/CPUMInternal.h

    r13742 r13960  
    251251{
    252252    /**
    253      * Saved host context. Only valid while inside GC.
    254      * Aligned on a 64-byte boundrary.
    255      */
    256     CPUMHOSTCTX             Host;
    257 
    258     /**
    259253     * Hypervisor context.
    260254     * Aligned on a 64-byte boundrary.
    261255     */
    262256    CPUMCTX                 Hyper;
    263 
    264     /**
    265      * Guest context.
    266      * Aligned on a 64-byte boundrary.
    267      */
    268     CPUMCTX                 Guest;
    269257
    270258    /** Pointer to the current hypervisor core context - R3Ptr. */
    … …  
    275263    RCPTRTYPE(PCPUMCTXCORE) pHyperCoreRC;
    276264
    277     /** Use flags.
    278      * These flags indicates both what is to be used and what have been used.
    279      */
    280     uint32_t                fUseFlags;
    281 
    282     /** Changed flags.
    283      * These flags indicates to REM (and others) which important guest
    284      * registers which has been changed since last time the flags were cleared.
    285      * See the CPUM_CHANGED_* defines for what we keep track of.
    286      */
    287     uint32_t                fChanged;
     265    /* Offset from CPUM to CPUMCPU for the first CPU. */
     266    uint32_t                ulOffCPUMCPU;
    288267
    289268    /** Hidden selector registers state.
    … …  
    333312
    334313    /** Align the next member, and thereby the structure, on a 64-byte boundrary. */
    335     uint8_t                 abPadding2[HC_ARCH_BITS == 32 ? 56 : 44];
     314    uint8_t                 abPadding2[HC_ARCH_BITS == 32 ? 60 : 48];
    336315
    337316    /**
    … …  
    350329{
    351330    /**
     331     * Saved host context. Only valid while inside GC.
     332     * Aligned on a 64-byte boundrary.
     333     */
     334    CPUMHOSTCTX             Host;
     335
     336    /**
    352337     * Guest context.
    353338     * Aligned on a 64-byte boundrary.
    354339     */
    355340    CPUMCTX                 Guest;
    356 } CPUMCPU;
     341
     342    /** Use flags.
     343     * These flags indicates both what is to be used and what has been used.
     344     */
     345    uint32_t                fUseFlags;
     346
     347    /** Changed flags.
     348     * These flags indicates to REM (and others) which important guest
     349     * registers which has been changed since last time the flags were cleared.
     350     * See the CPUM_CHANGED_* defines for what we keep track of.
     351     */
     352    uint32_t                fChanged;
     353
     354    /* Offset to CPUM. (subtract from the pointer to get to CPUM) */
     355    uint32_t                ulOffCPUM;
     356
     357    /* Round to 16 byte size. */
     358    uint32_t                uPadding;
     359} CPUMCPU, *PCPUMCPU;
    357360/** Pointer to the CPUMCPU instance data residing in the shared VMCPU structure. */
    358361typedef CPUMCPU *PCPUMCPU;
    … …  
    360363__BEGIN_DECLS
    361364
    362 DECLASM(int)      CPUMHandleLazyFPUAsm(PCPUM pCPUM);
    363 DECLASM(int)      CPUMRestoreHostFPUStateAsm(PCPUM pCPUM);
     365DECLASM(int)      CPUMHandleLazyFPUAsm(PCPUMCPU pCPUM);
     366DECLASM(int)      CPUMRestoreHostFPUStateAsm(PCPUMCPU pCPUM);
    364367DECLASM(void)     CPUMLoadFPUAsm(PCPUMCTX pCtx);
    365368DECLASM(void)     CPUMSaveFPUAsm(PCPUMCTX pCtx);

  • trunk/src/VBox/VMM/CPUMInternal.mac

    r12657 r13960  
    5050
    5151struc CPUM
     52    ;
     53    ; Hypervisor Context.
     54    ;
     55    alignb 64                           ; the padding
     56    .Hyper.fpu            resb    FPUSTATE_SIZE
     57
     58    .Hyper.edi            resq    1
     59    .Hyper.esi            resq    1
     60    .Hyper.ebp            resq    1
     61    .Hyper.eax            resq    1
     62    .Hyper.ebx            resq    1
     63    .Hyper.edx            resq    1
     64    .Hyper.ecx            resq    1
     65    .Hyper.esp            resq    1
     66    .Hyper.lss_esp        resd    1
     67    .Hyper.ss             resw    1
     68    .Hyper.ssPadding      resw    1
     69    .Hyper.gs             resw    1
     70    .Hyper.gsPadding      resw    1
     71    .Hyper.fs             resw    1
     72    .Hyper.fsPadding      resw    1
     73    .Hyper.es             resw    1
     74    .Hyper.esPadding      resw    1
     75    .Hyper.ds             resw    1
     76    .Hyper.dsPadding      resw    1
     77    .Hyper.cs             resw    1
     78    .Hyper.csPadding      resw    3
     79    .Hyper.eflags         resq    1
     80    .Hyper.eip            resq    1
     81    .Hyper.r8             resq    1
     82    .Hyper.r9             resq    1
     83    .Hyper.r10            resq    1
     84    .Hyper.r11            resq    1
     85    .Hyper.r12            resq    1
     86    .Hyper.r13            resq    1
     87    .Hyper.r14            resq    1
     88    .Hyper.r15            resq    1
     89
     90    .Hyper.esHid.u64Base      resq    1
     91    .Hyper.esHid.u32Limit     resd    1
     92    .Hyper.esHid.Attr         resd    1
     93
     94    .Hyper.csHid.u64Base      resq    1
     95    .Hyper.csHid.u32Limit     resd    1
     96    .Hyper.csHid.Attr         resd    1
     97
     98    .Hyper.ssHid.u64Base      resq    1
     99    .Hyper.ssHid.u32Limit     resd    1
     100    .Hyper.ssHid.Attr         resd    1
     101
     102    .Hyper.dsHid.u64Base      resq    1
     103    .Hyper.dsHid.u32Limit     resd    1
     104    .Hyper.dsHid.Attr         resd    1
     105
     106    .Hyper.fsHid.u64Base      resq    1
     107    .Hyper.fsHid.u32Limit     resd    1
     108    .Hyper.fsHid.Attr         resd    1
     109
     110    .Hyper.gsHid.u64Base      resq    1
     111    .Hyper.gsHid.u32Limit     resd    1
     112    .Hyper.gsHid.Attr         resd    1
     113
     114    .Hyper.cr0            resq    1
     115    .Hyper.cr2            resq    1
     116    .Hyper.cr3            resq    1
     117    .Hyper.cr4            resq    1
     118
     119    .Hyper.dr             resq    8
     120
     121    .Hyper.gdtr           resb    10          ; GDT limit + linear address
     122    .Hyper.gdtrPadding    resw    1
     123    .Hyper.idtr           resb    10          ; IDT limit + linear address
     124    .Hyper.idtrPadding    resw    1
     125    .Hyper.ldtr           resw    1
     126    .Hyper.ldtrPadding    resw    1
     127    .Hyper.tr             resw    1
     128    .Hyper.trPadding      resw    1
     129
     130    .Hyper.SysEnter.cs        resb    8
     131    .Hyper.SysEnter.eip       resb    8
     132    .Hyper.SysEnter.esp       resb    8
     133
     134    .Hyper.msrEFER            resb    8
     135    .Hyper.msrSTAR            resb    8
     136    .Hyper.msrPAT             resb    8
     137    .Hyper.msrLSTAR           resb    8
     138    .Hyper.msrCSTAR           resb    8
     139    .Hyper.msrSFMASK          resb    8
     140    .Hyper.msrKERNELGSBASE    resb    8
     141
     142    .Hyper.ldtrHid.u64Base    resq    1
     143    .Hyper.ldtrHid.u32Limit   resd    1
     144    .Hyper.ldtrHid.Attr       resd    1
     145
     146    .Hyper.trHid.u64Base      resq    1
     147    .Hyper.trHid.u32Limit     resd    1
     148    .Hyper.trHid.Attr         resd    1
     149
     150    ;
     151    ; Other stuff.
     152    ;
     153    alignb 64
     154    ; hypervisor core context.
     155    .pHyperCoreR3         RTR3PTR_RES   1
     156    .pHyperCoreR0         RTR0PTR_RES   1
     157    .pHyperCoreRC         RTRCPTR_RES   1
     158    ;...
     159    .ulOffCPUMCPU         resd    1
     160    .fValidHiddenSelRegs  resd    1
     161
     162    ; CPUID eax=1
     163    .CPUFeatures.edx      resd    1
     164    .CPUFeatures.ecx      resd    1
     165
     166    ; CPUID eax=0x80000001
     167    .CPUFeaturesExt.edx   resd    1
     168    .CPUFeaturesExt.ecx   resd    1
     169
     170    .enmCPUVendor         resd    1
     171
     172    ; CR4 masks
     173    .CR4.AndMask          resd    1
     174    .CR4.OrMask           resd    1
     175    ; entered rawmode?
     176    .fRawEntered          resb    1
     177%if RTHCPTR_CB == 8
     178    .abPadding            resb    7
     179%else
     180    .abPadding            resb    3
     181%endif
     182
     183    ; CPUID leafs
     184    .aGuestCpuIdStd       resb    16*6
     185    .aGuestCpuIdExt       resb    16*10
     186    .aGuestCpuIdCentaur   resb    16*4
     187    .GuestCpuIdDef        resb    16
     188
     189    alignb 64
     190    ; CPUMCTX debug stuff...
     191    .GuestEntry           resb   1024
     192endstruc
     193
     194struc CPUMCPU
    52195    ;
    53196    ; Host context state
    … …  
    160303%endif ; 64-bit
    161304
    162 
    163     ;
    164     ; Hypervisor Context.
    165     ;
    166     alignb 64                           ; the padding
    167     .Hyper.fpu            resb    FPUSTATE_SIZE
    168 
    169     .Hyper.edi            resq    1
    170     .Hyper.esi            resq    1
    171     .Hyper.ebp            resq    1
    172     .Hyper.eax            resq    1
    173     .Hyper.ebx            resq    1
    174     .Hyper.edx            resq    1
    175     .Hyper.ecx            resq    1
    176     .Hyper.esp            resq    1
    177     .Hyper.lss_esp        resd    1
    178     .Hyper.ss             resw    1
    179     .Hyper.ssPadding      resw    1
    180     .Hyper.gs             resw    1
    181     .Hyper.gsPadding      resw    1
    182     .Hyper.fs             resw    1
    183     .Hyper.fsPadding      resw    1
    184     .Hyper.es             resw    1
    185     .Hyper.esPadding      resw    1
    186     .Hyper.ds             resw    1
    187     .Hyper.dsPadding      resw    1
    188     .Hyper.cs             resw    1
    189     .Hyper.csPadding      resw    3
    190     .Hyper.eflags         resq    1
    191     .Hyper.eip            resq    1
    192     .Hyper.r8             resq    1
    193     .Hyper.r9             resq    1
    194     .Hyper.r10            resq    1
    195     .Hyper.r11            resq    1
    196     .Hyper.r12            resq    1
    197     .Hyper.r13            resq    1
    198     .Hyper.r14            resq    1
    199     .Hyper.r15            resq    1
    200 
    201     .Hyper.esHid.u64Base      resq    1
    202     .Hyper.esHid.u32Limit     resd    1
    203     .Hyper.esHid.Attr         resd    1
    204 
    205     .Hyper.csHid.u64Base      resq    1
    206     .Hyper.csHid.u32Limit     resd    1
    207     .Hyper.csHid.Attr         resd    1
    208 
    209     .Hyper.ssHid.u64Base      resq    1
    210     .Hyper.ssHid.u32Limit     resd    1
    211     .Hyper.ssHid.Attr         resd    1
    212 
    213     .Hyper.dsHid.u64Base      resq    1
    214     .Hyper.dsHid.u32Limit     resd    1
    215     .Hyper.dsHid.Attr         resd    1
    216 
    217     .Hyper.fsHid.u64Base      resq    1
    218     .Hyper.fsHid.u32Limit     resd    1
    219     .Hyper.fsHid.Attr         resd    1
    220 
    221     .Hyper.gsHid.u64Base      resq    1
    222     .Hyper.gsHid.u32Limit     resd    1
    223     .Hyper.gsHid.Attr         resd    1
    224 
    225     .Hyper.cr0            resq    1
    226     .Hyper.cr2            resq    1
    227     .Hyper.cr3            resq    1
    228     .Hyper.cr4            resq    1
    229 
    230     .Hyper.dr             resq    8
    231 
    232     .Hyper.gdtr           resb    10          ; GDT limit + linear address
    233     .Hyper.gdtrPadding    resw    1
    234     .Hyper.idtr           resb    10          ; IDT limit + linear address
    235     .Hyper.idtrPadding    resw    1
    236     .Hyper.ldtr           resw    1
    237     .Hyper.ldtrPadding    resw    1
    238     .Hyper.tr             resw    1
    239     .Hyper.trPadding      resw    1
    240 
    241     .Hyper.SysEnter.cs        resb    8
    242     .Hyper.SysEnter.eip       resb    8
    243     .Hyper.SysEnter.esp       resb    8
    244 
    245     .Hyper.msrEFER            resb    8
    246     .Hyper.msrSTAR            resb    8
    247     .Hyper.msrPAT             resb    8
    248     .Hyper.msrLSTAR           resb    8
    249     .Hyper.msrCSTAR           resb    8
    250     .Hyper.msrSFMASK          resb    8
    251     .Hyper.msrKERNELGSBASE    resb    8
    252 
    253     .Hyper.ldtrHid.u64Base    resq    1
    254     .Hyper.ldtrHid.u32Limit   resd    1
    255     .Hyper.ldtrHid.Attr       resd    1
    256 
    257     .Hyper.trHid.u64Base      resq    1
    258     .Hyper.trHid.u32Limit     resd    1
    259     .Hyper.trHid.Attr         resd    1
    260 
    261 
    262305    ;
    263306    ; Guest context state
    … …  
    359402    .Guest.trHid.Attr         resd    1
    360403
    361 
    362     ;
    363     ; Other stuff.
    364     ;
    365     alignb 64
    366     ; hypervisor core context.
    367     .pHyperCoreR3         RTR3PTR_RES   1
    368     .pHyperCoreR0         RTR0PTR_RES   1
    369     .pHyperCoreRC         RTRCPTR_RES   1
    370     ;...
    371404    .fUseFlags            resd    1
    372405    .fChanged             resd    1
    373     .fValidHiddenSelRegs  resd    1
    374 
    375     ; CPUID eax=1
    376     .CPUFeatures.edx      resd    1
    377     .CPUFeatures.ecx      resd    1
    378 
    379     ; CPUID eax=0x80000001
    380     .CPUFeaturesExt.edx   resd    1
    381     .CPUFeaturesExt.ecx   resd    1
    382 
    383     .enmCPUVendor         resd    1
    384 
    385     ; CR4 masks
    386     .CR4.AndMask          resd    1
    387     .CR4.OrMask           resd    1
    388     ; entered rawmode?
    389     .fRawEntered          resb    1
    390 %if RTHCPTR_CB == 8
    391     .abPadding            resb    7
    392 %else
    393     .abPadding            resb    3
    394 %endif
    395 
    396     ; CPUID leafs
    397     .aGuestCpuIdStd       resb    16*6
    398     .aGuestCpuIdExt       resb    16*10
    399     .aGuestCpuIdCentaur   resb    16*4
    400     .GuestCpuIdDef        resb    16
    401 
    402     alignb 64
    403     ; CPUMCTX debug stuff...
    404     .GuestEntry           resb   1024
     406    .ulOffCPUM            resd    1
     407    .uPadding             resd    1   
    405408endstruc
    406409
     410
     411;;
     412; Converts the CPUM pointer to CPUMCPU (for the first VMCPU)
     413; @param   %1   register name
     414%macro CPUMCPU_FROM_CPUM 1
     415    add     %1, [%1 + CPUM.ulOffCPUMCPU]
     416%endmacro
     417
     418;;
     419; Converts the CPUMCPU pointer to CPUM (for the first VMCPU)
     420; @param   %1   register name
     421%macro CPUM_FROM_CPUMCPU 1
     422    sub     %1, [%1 + CPUMCPU.ulOffCPUM]
     423%endmacro

  • trunk/src/VBox/VMM/PATM/PATM.cpp

    r13834 r13960  
    346346
    347347    /* Needed for future patching of sldt/sgdt/sidt/str etc. */
    348     rc = CPUMR3QueryGuestCtxRCPtr(pVM, &pVM->patm.s.pCPUMCtxGC);
    349     AssertRCReturn(rc, rc);
     348    pVM->patm.s.pCPUMCtxGC = VM_RC_ADDR(pVM, CPUMQueryGuestCtxPtr(pVM));
    350349
    351350    Assert(pVM->patm.s.PatchLookupTreeHC);

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

    r13832 r13960  
    4141%define ENABLE_WRITE_PROTECTION 1
    4242
    43 ;; @def CPUM_REG
    44 ; The register which we load the CPUM pointer into.
    45 %ifdef RT_ARCH_AMD64
    46  %define CPUM_REG   rdx
    47 %else
    48  %define CPUM_REG   edx
    49 %endif
    50 
    5143BEGINCODE
    5244
    … …  
    6456; @returns  0 if caller should continue execution.
    6557; @returns  VINF_EM_RAW_GUEST_TRAP if a guest trap should be generated.
    66 ; @param    pCPUM  x86:[esp+4] GCC:rdi MSC:rcx     CPUM pointer
     58; @param    pCPUMCPU  x86:[esp+4] GCC:rdi MSC:rcx     CPUMCPU pointer
    6759;
    6860align 16
    … …  
    10799    mov     xDX, dword [esp + 4]
    108100%endif
    109     test    dword [xDX + CPUM.fUseFlags], CPUM_USED_FPU
     101    test    dword [xDX + CPUMCPU.fUseFlags], CPUM_USED_FPU
    110102    jz      hlfpua_not_loaded
    111103    jmp     hlfpua_to_host
    … …  
    116108align 16
    117109hlfpua_not_loaded:
    118     mov     eax, [xDX + CPUM.Guest.cr0]
     110    mov     eax, [xDX + CPUMCPU.Guest.cr0]
    119111    and     eax, X86_CR0_MP | X86_CR0_EM | X86_CR0_TS
    120112%ifdef RT_ARCH_AMD64
    … …  
    164156%endif
    165157%ifndef RT_ARCH_AMD64
    166     test    dword [xDX + CPUM.CPUFeatures.edx], X86_CPUID_FEATURE_EDX_FXSR
     158    mov     eax, edx
     159    ; Calculate the PCPUM pointer
     160    sub     eax, [edx + CPUMCPU.ulOffCPUM]
     161    test    dword [eax + CPUM.CPUFeatures.edx], X86_CPUID_FEATURE_EDX_FXSR
    167162    jz short hlfpua_no_fxsave
    168163%endif
    169164
    170     fxsave  [xDX + CPUM.Host.fpu]
    171     or      dword [xDX + CPUM.fUseFlags], (CPUM_USED_FPU | CPUM_USED_FPU_SINCE_REM)
    172     fxrstor [xDX + CPUM.Guest.fpu]
     165    fxsave  [xDX + CPUMCPU.Host.fpu]
     166    or      dword [xDX + CPUMCPU.fUseFlags], (CPUM_USED_FPU | CPUM_USED_FPU_SINCE_REM)
     167    fxrstor [xDX + CPUMCPU.Guest.fpu]
    173168hlfpua_finished_switch:
    174169%ifdef IN_RC
    … …  
    182177; legacy support.
    183178hlfpua_no_fxsave:
    184     fnsave  [xDX + CPUM.Host.fpu]
    185     or      dword [xDX + CPUM.fUseFlags], dword (CPUM_USED_FPU | CPUM_USED_FPU_SINCE_REM) ; yasm / nasm
    186     mov     eax, [xDX + CPUM.Guest.fpu]    ; control word
     179    fnsave  [xDX + CPUMCPU.Host.fpu]
     180    or      dword [xDX + CPUMCPU.fUseFlags], dword (CPUM_USED_FPU | CPUM_USED_FPU_SINCE_REM) ; yasm / nasm
     181    mov     eax, [xDX + CPUMCPU.Guest.fpu]    ; control word
    187182    not     eax                                 ; 1 means exception ignored (6 LS bits)
    188183    and     eax, byte 03Fh                      ; 6 LS bits only
    189     test    eax, [xDX + CPUM.Guest.fpu + 4]; status word
     184    test    eax, [xDX + CPUMCPU.Guest.fpu + 4]; status word
    190185    jz short hlfpua_no_exceptions_pending
    191186    ; technically incorrect, but we certainly don't want any exceptions now!!
    192     and     dword [xDX + CPUM.Guest.fpu + 4], ~03Fh
     187    and     dword [xDX + CPUMCPU.Guest.fpu + 4], ~03Fh
    193188hlfpua_no_exceptions_pending:
    194     frstor  [xDX + CPUM.Guest.fpu]
     189    frstor  [xDX + CPUMCPU.Guest.fpu]
    195190    jmp near hlfpua_finished_switch
    196191%endif ; !RT_ARCH_AMD64
    … …  
    211206;
    212207; @returns  0
    213 ; @param    pCPUM  x86:[esp+4] GCC:rdi MSC:rcx     CPUM pointer
     208; @param    pCPUMCPU  x86:[esp+4] GCC:rdi MSC:rcx     CPUMCPU pointer
    214209;
    215210align 16
    … …  
    227222    ; Restore FPU if guest has used it.
    228223    ; Using fxrstor should ensure that we're not causing unwanted exception on the host.
    229     test    dword [xDX + CPUM.fUseFlags], CPUM_USED_FPU
     224    test    dword [xDX + CPUMCPU.fUseFlags], CPUM_USED_FPU
    230225    jz short gth_fpu_no
    231226
    … …  
    235230    mov     cr0, xAX
    236231
    237     fxsave  [xDX + CPUM.Guest.fpu]
    238     fxrstor [xDX + CPUM.Host.fpu]
     232    fxsave  [xDX + CPUMCPU.Guest.fpu]
     233    fxrstor [xDX + CPUMCPU.Host.fpu]
    239234
    240235    mov     cr0, xCX                    ; and restore old CR0 again
    241     and     dword [xDX + CPUM.fUseFlags], ~CPUM_USED_FPU
     236    and     dword [xDX + CPUMCPU.fUseFlags], ~CPUM_USED_FPU
    242237gth_fpu_no:
    243238    xor     eax, eax

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

    r13832 r13960  
    3636#include <iprt/assert.h>
    3737#include <iprt/asm.h>
    38 
     38#ifdef IN_RING3
     39#include <iprt/thread.h>
     40#endif
    3941
    4042/** Disable stack frame pointer generation here. */
    … …  
    404406VMMDECL(PCCPUMCTXCORE) CPUMGetGuestCtxCore(PVM pVM)
    405407{
    406     return CPUMCTX2CORE(&pVM->cpum.s.Guest);
     408    VM_ASSERT_EMT(pVM);
     409    return CPUMCTX2CORE(&pVM->aCpus[VMMGetCpuId(pVM)].cpum.s.Guest);
    407410}
    408411
    … …  
    418421    /** @todo #1410 requires selectors to be checked. (huh? 1410?) */
    419422
    420     PCPUMCTXCORE pCtxCoreDst = CPUMCTX2CORE(&pVM->cpum.s.Guest);
     423    PCPUMCTXCORE pCtxCoreDst = CPUMCTX2CORE(&pVM->aCpus[VMMGetCpuId(pVM)].cpum.s.Guest);
    421424    *pCtxCoreDst = *pCtxCore;
    422425
    … …  
    457460VMMDECL(PCPUMCTX) CPUMQueryGuestCtxPtr(PVM pVM)
    458461{
    459     return &pVM->cpum.s.Guest;
    460 }
    461 
     462    return &pVM->aCpus[VMMGetCpuId(pVM)].cpum.s.Guest;
     463}
     464
     465static PCPUMCPU cpumGetCpumCpu(PVM pVM)
     466{
     467    RTCPUID idCpu = VMMGetCpuId(pVM);
     468
     469    return &pVM->aCpus[idCpu].cpum.s;
     470}
     471
     472VMMDECL(PCPUMCTX) CPUMQueryGuestCtxPtrEx(PVM pVM, PVMCPU pVCpu)
     473{
     474    Assert(pVCpu->idCpu < pVM->cCPUs);
     475    return &pVCpu->cpum.s.Guest;
     476}
    462477
    463478VMMDECL(int) CPUMSetGuestGDTR(PVM pVM, uint32_t addr, uint16_t limit)
    464479{
    465     pVM->cpum.s.Guest.gdtr.cbGdt = limit;
    466     pVM->cpum.s.Guest.gdtr.pGdt  = addr;
    467     pVM->cpum.s.fChanged |= CPUM_CHANGED_GDTR;
     480    PCPUMCPU pCpumCpu = cpumGetCpumCpu(pVM);
     481
     482    pCpumCpu->Guest.gdtr.cbGdt = limit;
     483    pCpumCpu->Guest.gdtr.pGdt  = addr;
     484    pCpumCpu->fChanged |= CPUM_CHANGED_GDTR;
    468485    return VINF_SUCCESS;
    469486}
    … …  
    471488VMMDECL(int) CPUMSetGuestIDTR(PVM pVM, uint32_t addr, uint16_t limit)
    472489{
    473     pVM->cpum.s.Guest.idtr.cbIdt = limit;
    474     pVM->cpum.s.Guest.idtr.pIdt = addr;
    475     pVM->cpum.s.fChanged |= CPUM_CHANGED_IDTR;
     490    PCPUMCPU pCpumCpu = cpumGetCpumCpu(pVM);
     491
     492    pCpumCpu->Guest.idtr.cbIdt = limit;
     493    pCpumCpu->Guest.idtr.pIdt  = addr;
     494    pCpumCpu->fChanged |= CPUM_CHANGED_IDTR;
    476495    return VINF_SUCCESS;
    477496}
    … …  
    479498VMMDECL(int) CPUMSetGuestTR(PVM pVM, uint16_t tr)
    480499{
    481     pVM->cpum.s.Guest.tr = tr;
    482     pVM->cpum.s.fChanged |= CPUM_CHANGED_TR;
     500    PCPUMCPU pCpumCpu = cpumGetCpumCpu(pVM);
     501
     502    pCpumCpu->Guest.tr  = tr;
     503    pCpumCpu->fChanged |= CPUM_CHANGED_TR;
    483504    return VINF_SUCCESS;
    484505}
    … …  
    486507VMMDECL(int) CPUMSetGuestLDTR(PVM pVM, uint16_t ldtr)
    487508{
    488     pVM->cpum.s.Guest.ldtr = ldtr;
    489     pVM->cpum.s.fChanged |= CPUM_CHANGED_LDTR;
     509    PCPUMCPU pCpumCpu = cpumGetCpumCpu(pVM);
     510
     511    pCpumCpu->Guest.ldtr = ldtr;
     512    pCpumCpu->fChanged  |= CPUM_CHANGED_LDTR;
    490513    return VINF_SUCCESS;
    491514}
    … …  
    505528VMMDECL(int) CPUMSetGuestCR0(PVM pVM, uint64_t cr0)
    506529{
     530    PCPUMCPU pCpumCpu = cpumGetCpumCpu(pVM);
     531
    507532#ifdef IN_RC
    508533    /*
    … …  
    510535     * of math stuff.
    511536     */
    512     if (    (cr0                   & (X86_CR0_TS | X86_CR0_EM | X86_CR0_MP))
    513         !=  (pVM->cpum.s.Guest.cr0 & (X86_CR0_TS | X86_CR0_EM | X86_CR0_MP)))
     537    if (    (cr0                 & (X86_CR0_TS | X86_CR0_EM | X86_CR0_MP))
     538        !=  (pCpumCpu->Guest.cr0 & (X86_CR0_TS | X86_CR0_EM | X86_CR0_MP)))
    514539    {
    515         if (!(pVM->cpum.s.fUseFlags & CPUM_USED_FPU))
     540        if (!(pCpumCpu->fUseFlags & CPUM_USED_FPU))
    516541        {
    517542            /*
    … …  
    519544             * and EM should be reflecting the guest EM (it always does this).
    520545             */
    521             if ((cr0 & X86_CR0_EM) != (pVM->cpum.s.Guest.cr0 & X86_CR0_EM))
     546            if ((cr0 & X86_CR0_EM) != (pCpumCpu->Guest.cr0 & X86_CR0_EM))
    522547            {
    523548                uint32_t HyperCR0 = ASMGetCR0();
    524549                AssertMsg((HyperCR0 & (X86_CR0_TS | X86_CR0_MP)) == (X86_CR0_TS | X86_CR0_MP), ("%#x\n", HyperCR0));
    525                 AssertMsg((HyperCR0 & X86_CR0_EM) == (pVM->cpum.s.Guest.cr0 & X86_CR0_EM), ("%#x\n", HyperCR0));
     550                AssertMsg((HyperCR0 & X86_CR0_EM) == (pCpumCpu->Guest.cr0 & X86_CR0_EM), ("%#x\n", HyperCR0));
    526551                HyperCR0 &= ~X86_CR0_EM;
    527552                HyperCR0 |= cr0 & X86_CR0_EM;
    … …  
    534559                uint32_t HyperCR0 = ASMGetCR0();
    535560                AssertMsg((HyperCR0 & (X86_CR0_TS | X86_CR0_MP)) == (X86_CR0_TS | X86_CR0_MP), ("%#x\n", HyperCR0));
    536                 AssertMsg((HyperCR0 & X86_CR0_EM) == (pVM->cpum.s.Guest.cr0 & X86_CR0_EM), ("%#x\n", HyperCR0));
     561                AssertMsg((HyperCR0 & X86_CR0_EM) == (pCpumCpu->Guest.cr0 & X86_CR0_EM), ("%#x\n", HyperCR0));
    537562            }
    538563# endif
    … …  
    545570             */
    546571            uint32_t HyperCR0 = ASMGetCR0();
    547             AssertMsg(     (HyperCR0               & (X86_CR0_TS | X86_CR0_EM | X86_CR0_MP))
    548                       ==   (pVM->cpum.s.Guest.cr0  & (X86_CR0_TS | X86_CR0_EM | X86_CR0_MP)),
    549                       ("%#x %#x\n", HyperCR0, pVM->cpum.s.Guest.cr0));
     572            AssertMsg(     (HyperCR0             & (X86_CR0_TS | X86_CR0_EM | X86_CR0_MP))
     573                      ==   (pCpumCpu->Guest.cr0  & (X86_CR0_TS | X86_CR0_EM | X86_CR0_MP)),
     574                      ("%#x %#x\n", HyperCR0, pCpumCpu->Guest.cr0));
    550575            HyperCR0 &= ~(X86_CR0_TS | X86_CR0_EM | X86_CR0_MP);
    551576            HyperCR0 |= cr0 & (X86_CR0_TS | X86_CR0_EM | X86_CR0_MP);
    … …  
    560585     * The caller is responsible for calling PGM when appropriate.
    561586     */
    562     if (    (cr0                   & (X86_CR0_PG | X86_CR0_WP | X86_CR0_PE))
    563         !=  (pVM->cpum.s.Guest.cr0 & (X86_CR0_PG | X86_CR0_WP | X86_CR0_PE)))
    564         pVM->cpum.s.fChanged |= CPUM_CHANGED_GLOBAL_TLB_FLUSH;
    565     pVM->cpum.s.fChanged |= CPUM_CHANGED_CR0;
    566 
    567     pVM->cpum.s.Guest.cr0 = cr0 | X86_CR0_ET;
     587    if (    (cr0                 & (X86_CR0_PG | X86_CR0_WP | X86_CR0_PE))
     588        !=  (pCpumCpu->Guest.cr0 & (X86_CR0_PG | X86_CR0_WP | X86_CR0_PE)))
     589        pCpumCpu->fChanged |= CPUM_CHANGED_GLOBAL_TLB_FLUSH;
     590    pCpumCpu->fChanged |= CPUM_CHANGED_CR0;
     591
     592    pCpumCpu->Guest.cr0 = cr0 | X86_CR0_ET;
    568593    return VINF_SUCCESS;
    569594}
    … …  
    572597VMMDECL(int) CPUMSetGuestCR2(PVM pVM, uint64_t cr2)
    573598{
    574     pVM->cpum.s.Guest.cr2 = cr2;
     599    PCPUMCPU pCpumCpu = cpumGetCpumCpu(pVM);
     600
     601    pCpumCpu->Guest.cr2 = cr2;
    575602    return VINF_SUCCESS;
    576603}
    … …  
    579606VMMDECL(int) CPUMSetGuestCR3(PVM pVM, uint64_t cr3)
    580607{
    581     pVM->cpum.s.Guest.cr3 = cr3;
    582     pVM->cpum.s.fChanged |= CPUM_CHANGED_CR3;
     608    PCPUMCPU pCpumCpu = cpumGetCpumCpu(pVM);
     609
     610    pCpumCpu->Guest.cr3 = cr3;
     611    pCpumCpu->fChanged |= CPUM_CHANGED_CR3;
    583612    return VINF_SUCCESS;
    584613}
    … …  
    587616VMMDECL(int) CPUMSetGuestCR4(PVM pVM, uint64_t cr4)
    588617{
     618    PCPUMCPU pCpumCpu = cpumGetCpumCpu(pVM);
     619
    589620    if (    (cr4                   & (X86_CR4_PGE | X86_CR4_PAE | X86_CR4_PSE))
    590         !=  (pVM->cpum.s.Guest.cr4 & (X86_CR4_PGE | X86_CR4_PAE | X86_CR4_PSE)))
    591         pVM->cpum.s.fChanged |= CPUM_CHANGED_GLOBAL_TLB_FLUSH;
    592     pVM->cpum.s.fChanged |= CPUM_CHANGED_CR4;
     621        !=  (pCpumCpu->Guest.cr4 & (X86_CR4_PGE | X86_CR4_PAE | X86_CR4_PSE)))
     622        pCpumCpu->fChanged |= CPUM_CHANGED_GLOBAL_TLB_FLUSH;
     623    pCpumCpu->fChanged |= CPUM_CHANGED_CR4;
    593624    if (!CPUMSupportsFXSR(pVM))
    594625        cr4 &= ~X86_CR4_OSFSXR;
    595     pVM->cpum.s.Guest.cr4 = cr4;
     626    pCpumCpu->Guest.cr4 = cr4;
    596627    return VINF_SUCCESS;
    597628}
    … …  
    600631VMMDECL(int) CPUMSetGuestEFlags(PVM pVM, uint32_t eflags)
    601632{
    602     pVM->cpum.s.Guest.eflags.u32 = eflags;
     633    PCPUMCPU pCpumCpu = cpumGetCpumCpu(pVM);
     634
     635    pCpumCpu->Guest.eflags.u32 = eflags;
    603636    return VINF_SUCCESS;
    604637}
    … …  
    607640VMMDECL(int) CPUMSetGuestEIP(PVM pVM, uint32_t eip)
    608641{
    609     pVM->cpum.s.Guest.eip = eip;
     642    PCPUMCPU pCpumCpu = cpumGetCpumCpu(pVM);
     643
     644    pCpumCpu->Guest.eip = eip;
    610645    return VINF_SUCCESS;
    611646}
    … …  
    614649VMMDECL(int) CPUMSetGuestEAX(PVM pVM, uint32_t eax)
    615650{
    616     pVM->cpum.s.Guest.eax = eax;
     651    PCPUMCPU pCpumCpu = cpumGetCpumCpu(pVM);
     652
     653    pCpumCpu->Guest.eax = eax;
    617654    return VINF_SUCCESS;
    618655}
    … …  
    621658VMMDECL(int) CPUMSetGuestEBX(PVM pVM, uint32_t ebx)
    622659{
    623     pVM->cpum.s.Guest.ebx = ebx;
     660    PCPUMCPU pCpumCpu = cpumGetCpumCpu(pVM);
     661
     662    pCpumCpu->Guest.ebx = ebx;
    624663    return VINF_SUCCESS;
    625664}
    … …  
    628667VMMDECL(int) CPUMSetGuestECX(PVM pVM, uint32_t ecx)
    629668{
    630     pVM->cpum.s.Guest.ecx = ecx;
     669    PCPUMCPU pCpumCpu = cpumGetCpumCpu(pVM);
     670
     671    pCpumCpu->Guest.ecx = ecx;
    631672    return VINF_SUCCESS;
    632673}
    … …  
    635676VMMDECL(int) CPUMSetGuestEDX(PVM pVM, uint32_t edx)
    636677{
    637     pVM->cpum.s.Guest.edx = edx;
     678    PCPUMCPU pCpumCpu = cpumGetCpumCpu(pVM);
     679
     680    pCpumCpu->Guest.edx = edx;
    638681    return VINF_SUCCESS;
    639682}
    … …  
    642685VMMDECL(int) CPUMSetGuestESP(PVM pVM, uint32_t esp)
    643686{
    644     pVM->cpum.s.Guest.esp = esp;
     687    PCPUMCPU pCpumCpu = cpumGetCpumCpu(pVM);
     688
     689    pCpumCpu->Guest.esp = esp;
    645690    return VINF_SUCCESS;
    646691}
    … …  
    649694VMMDECL(int) CPUMSetGuestEBP(PVM pVM, uint32_t ebp)
    650695{
    651     pVM->cpum.s.Guest.ebp = ebp;
     696    PCPUMCPU pCpumCpu = cpumGetCpumCpu(pVM);
     697
     698    pCpumCpu->Guest.ebp = ebp;
    652699    return VINF_SUCCESS;
    653700}
    … …  
    656703VMMDECL(int) CPUMSetGuestESI(PVM pVM, uint32_t esi)
    657704{
    658     pVM->cpum.s.Guest.esi = esi;
     705    PCPUMCPU pCpumCpu = cpumGetCpumCpu(pVM);
     706
     707    pCpumCpu->Guest.esi = esi;
    659708    return VINF_SUCCESS;
    660709}
    … …  
    663712VMMDECL(int) CPUMSetGuestEDI(PVM pVM, uint32_t edi)
    664713{
    665     pVM->cpum.s.Guest.edi = edi;
     714    PCPUMCPU pCpumCpu = cpumGetCpumCpu(pVM);
     715
     716    pCpumCpu->Guest.edi = edi;
    666717    return VINF_SUCCESS;
    667718}
    … …  
    670721VMMDECL(int) CPUMSetGuestSS(PVM pVM, uint16_t ss)
    671722{
    672     pVM->cpum.s.Guest.ss = ss;
     723    PCPUMCPU pCpumCpu = cpumGetCpumCpu(pVM);
     724
     725    pCpumCpu->Guest.ss = ss;
    673726    return VINF_SUCCESS;
    674727}
    … …  
    677730VMMDECL(int) CPUMSetGuestCS(PVM pVM, uint16_t cs)
    678731{
    679     pVM->cpum.s.Guest.cs = cs;
     732    PCPUMCPU pCpumCpu = cpumGetCpumCpu(pVM);
     733
     734    pCpumCpu->Guest.cs = cs;
    680735    return VINF_SUCCESS;
    681736}
    … …  
    684739VMMDECL(int) CPUMSetGuestDS(PVM pVM, uint16_t ds)
    685740{
    686     pVM->cpum.s.Guest.ds = ds;
     741    PCPUMCPU pCpumCpu = cpumGetCpumCpu(pVM);
     742
     743    pCpumCpu->Guest.ds = ds;
    687744    return VINF_SUCCESS;
    688745}
    … …  
    691748VMMDECL(int) CPUMSetGuestES(PVM pVM, uint16_t es)
    692749{
    693     pVM->cpum.s.Guest.es = es;
     750    PCPUMCPU pCpumCpu = cpumGetCpumCpu(pVM);
     751
     752    pCpumCpu->Guest.es = es;
    694753    return VINF_SUCCESS;
    695754}
    … …  
    698757VMMDECL(int) CPUMSetGuestFS(PVM pVM, uint16_t fs)
    699758{
    700     pVM->cpum.s.Guest.fs = fs;
     759    PCPUMCPU pCpumCpu = cpumGetCpumCpu(pVM);
     760
     761    pCpumCpu->Guest.fs = fs;
    701762    return VINF_SUCCESS;
    702763}
    … …  
    705766VMMDECL(int) CPUMSetGuestGS(PVM pVM, uint16_t gs)
    706767{
    707     pVM->cpum.s.Guest.gs = gs;
     768    PCPUMCPU pCpumCpu = cpumGetCpumCpu(pVM);
     769
     770    pCpumCpu->Guest.gs = gs;
    708771    return VINF_SUCCESS;
    709772}
    … …  
    712775VMMDECL(void) CPUMSetGuestEFER(PVM pVM, uint64_t val)
    713776{
    714     pVM->cpum.s.Guest.msrEFER = val;
     777    PCPUMCPU pCpumCpu = cpumGetCpumCpu(pVM);
     778
     779    pCpumCpu->Guest.msrEFER = val;
    715780}
    716781
    … …  
    718783VMMDECL(uint64_t)  CPUMGetGuestMsr(PVM pVM, unsigned idMsr)
    719784{
     785    PCPUMCPU pCpumCpu = cpumGetCpumCpu(pVM);
    720786    uint64_t u64 = 0;
    721787
    … …  
    723789    {
    724790        case MSR_IA32_CR_PAT:
    725             u64 = pVM->cpum.s.Guest.msrPAT;
     791            u64 = pCpumCpu->Guest.msrPAT;
    726792            break;
    727793
    728794        case MSR_IA32_SYSENTER_CS:
    729             u64 = pVM->cpum.s.Guest.SysEnter.cs;
     795            u64 = pCpumCpu->Guest.SysEnter.cs;
    730796            break;
    731797
    732798        case MSR_IA32_SYSENTER_EIP:
    733             u64 = pVM->cpum.s.Guest.SysEnter.eip;
     799            u64 = pCpumCpu->Guest.SysEnter.eip;
    734800            break;
    735801
    736802        case MSR_IA32_SYSENTER_ESP:
    737             u64 = pVM->cpum.s.Guest.SysEnter.esp;
     803            u64 = pCpumCpu->Guest.SysEnter.esp;
    738804            break;
    739805
    740806        case MSR_K6_EFER:
    741             u64 = pVM->cpum.s.Guest.msrEFER;
     807            u64 = pCpumCpu->Guest.msrEFER;
    742808            break;
    743809
    744810        case MSR_K8_SF_MASK:
    745             u64 = pVM->cpum.s.Guest.msrSFMASK;
     811            u64 = pCpumCpu->Guest.msrSFMASK;
    746812            break;
    747813
    748814        case MSR_K6_STAR:
    749             u64 = pVM->cpum.s.Guest.msrSTAR;
     815            u64 = pCpumCpu->Guest.msrSTAR;
    750816            break;
    751817
    752818        case MSR_K8_LSTAR:
    753             u64 = pVM->cpum.s.Guest.msrLSTAR;
     819            u64 = pCpumCpu->Guest.msrLSTAR;
    754820            break;
    755821
    756822        case MSR_K8_CSTAR:
    757             u64 = pVM->cpum.s.Guest.msrCSTAR;
     823            u64 = pCpumCpu->Guest.msrCSTAR;
    758824            break;
    759825
    760826        case MSR_K8_KERNEL_GS_BASE:
    761             u64 = pVM->cpum.s.Guest.msrKERNELGSBASE;
     827            u64 = pCpumCpu->Guest.msrKERNELGSBASE;
    762828            break;
    763829
    … …  
    773839VMMDECL(RTGCPTR) CPUMGetGuestIDTR(PVM pVM, uint16_t *pcbLimit)
    774840{
     841    PCPUMCPU pCpumCpu = cpumGetCpumCpu(pVM);
     842
    775843    if (pcbLimit)
    776         *pcbLimit = pVM->cpum.s.Guest.idtr.cbIdt;
    777     return pVM->cpum.s.Guest.idtr.pIdt;
     844        *pcbLimit = pCpumCpu->Guest.idtr.cbIdt;
     845    return pCpumCpu->Guest.idtr.pIdt;
    778846}
    779847
    … …  
    781849VMMDECL(RTSEL) CPUMGetGuestTR(PVM pVM)
    782850{
    783     return pVM->cpum.s.Guest.tr;
     851    PCPUMCPU pCpumCpu = cpumGetCpumCpu(pVM);
     852
     853    return pCpumCpu->Guest.tr;
    784854}
    785855
    … …  
    787857VMMDECL(RTSEL) CPUMGetGuestCS(PVM pVM)
    788858{
    789     return pVM->cpum.s.Guest.cs;
     859    PCPUMCPU pCpumCpu = cpumGetCpumCpu(pVM);
     860
     861    return pCpumCpu->Guest.cs;
    790862}
    791863
    … …  
    793865VMMDECL(RTSEL) CPUMGetGuestDS(PVM pVM)
    794866{
    795     return pVM->cpum.s.Guest.ds;
     867    PCPUMCPU pCpumCpu = cpumGetCpumCpu(pVM);
     868
     869    return pCpumCpu->Guest.ds;
    796870}
    797871
    … …  
    799873VMMDECL(RTSEL) CPUMGetGuestES(PVM pVM)
    800874{
    801     return pVM->cpum.s.Guest.es;
     875    PCPUMCPU pCpumCpu = cpumGetCpumCpu(pVM);
     876
     877    return pCpumCpu->Guest.es;
    802878}
    803879
    … …  
    805881VMMDECL(RTSEL) CPUMGetGuestFS(PVM pVM)
    806882{
    807     return pVM->cpum.s.Guest.fs;
     883    PCPUMCPU pCpumCpu = cpumGetCpumCpu(pVM);
     884
     885    return pCpumCpu->Guest.fs;
    808886}
    809887
    … …  
    811889VMMDECL(RTSEL) CPUMGetGuestGS(PVM pVM)
    812890{
    813     return pVM->cpum.s.Guest.gs;
     891    PCPUMCPU pCpumCpu = cpumGetCpumCpu(pVM);
     892
     893    return pCpumCpu->Guest.gs;
    814894}
    815895
    … …  
    817897VMMDECL(RTSEL) CPUMGetGuestSS(PVM pVM)
    818898{
    819     return pVM->cpum.s.Guest.ss;
     899    PCPUMCPU pCpumCpu = cpumGetCpumCpu(pVM);
     900
     901    return pCpumCpu->Guest.ss;
    820902}
    821903
    … …  
    823905VMMDECL(RTSEL) CPUMGetGuestLDTR(PVM pVM)
    824906{
    825     return pVM->cpum.s.Guest.ldtr;
     907    PCPUMCPU pCpumCpu = cpumGetCpumCpu(pVM);
     908
     909    return pCpumCpu->Guest.ldtr;
    826910}
    827911
    … …  
    829913VMMDECL(uint64_t) CPUMGetGuestCR0(PVM pVM)
    830914{
    831     return pVM->cpum.s.Guest.cr0;
     915    PCPUMCPU pCpumCpu = cpumGetCpumCpu(pVM);
     916
     917    return pCpumCpu->Guest.cr0;
    832918}
    833919
    … …  
    835921VMMDECL(uint64_t) CPUMGetGuestCR2(PVM pVM)
    836922{
    837     return pVM->cpum.s.Guest.cr2;
     923    PCPUMCPU pCpumCpu = cpumGetCpumCpu(pVM);
     924
     925    return pCpumCpu->Guest.cr2;
    838926}
    839927
    … …  
    841929VMMDECL(uint64_t) CPUMGetGuestCR3(PVM pVM)
    842930{
    843     return pVM->cpum.s.Guest.cr3;
     931    PCPUMCPU pCpumCpu = cpumGetCpumCpu(pVM);
     932
     933    return pCpumCpu->Guest.cr3;
    844934}
    845935
    … …  
    847937VMMDECL(uint64_t) CPUMGetGuestCR4(PVM pVM)
    848938{
    849     return pVM->cpum.s.Guest.cr4;
     939    PCPUMCPU pCpumCpu = cpumGetCpumCpu(pVM);
     940
     941    return pCpumCpu->Guest.cr4;
    850942}
    851943
    … …  
    853945VMMDECL(void) CPUMGetGuestGDTR(PVM pVM, PVBOXGDTR pGDTR)
    854946{
    855     *pGDTR = pVM->cpum.s.Guest.gdtr;
     947    PCPUMCPU pCpumCpu = cpumGetCpumCpu(pVM);
     948
     949    *pGDTR = pCpumCpu->Guest.gdtr;
    856950}
    857951
    … …  
    859953VMMDECL(uint32_t) CPUMGetGuestEIP(PVM pVM)
    860954{
    861     return pVM->cpum.s.Guest.eip;
     955    PCPUMCPU pCpumCpu = cpumGetCpumCpu(pVM);
     956
     957    return pCpumCpu->Guest.eip;
    862958}
    863959
    … …  
    865961VMMDECL(uint64_t) CPUMGetGuestRIP(PVM pVM)
    866962{
    867     return pVM->cpum.s.Guest.rip;
     963    PCPUMCPU pCpumCpu = cpumGetCpumCpu(pVM);
     964
     965    return pCpumCpu->Guest.rip;
    868966}
    869967
    … …  
    871969VMMDECL(uint32_t) CPUMGetGuestEAX(PVM pVM)
    872970{
    873     return pVM->cpum.s.Guest.eax;
     971    PCPUMCPU pCpumCpu = cpumGetCpumCpu(pVM);
     972
     973    return pCpumCpu->Guest.eax;
    874974}
    875975
    … …  
    877977VMMDECL(uint32_t) CPUMGetGuestEBX(PVM pVM)
    878978{
    879     return pVM->cpum.s.Guest.ebx;
     979    PCPUMCPU pCpumCpu = cpumGetCpumCpu(pVM);
     980
     981    return pCpumCpu->Guest.ebx;
    880982}
    881983
    … …  
    883985VMMDECL(uint32_t) CPUMGetGuestECX(PVM pVM)
    884986{
    885     return pVM->cpum.s.Guest.ecx;
     987    PCPUMCPU pCpumCpu = cpumGetCpumCpu(pVM);
     988
     989    return pCpumCpu->Guest.ecx;
    886990}
    887991
    … …  
    889993VMMDECL(uint32_t) CPUMGetGuestEDX(PVM pVM)
    890994{
    891     return pVM->cpum.s.Guest.edx;
     995    PCPUMCPU pCpumCpu = cpumGetCpumCpu(pVM);
     996
     997    return pCpumCpu->Guest.edx;
    892998}
    893999
    … …  
    8951001VMMDECL(uint32_t) CPUMGetGuestESI(PVM pVM)
    8961002{
    897     return pVM->cpum.s.Guest.esi;
     1003    PCPUMCPU pCpumCpu = cpumGetCpumCpu(pVM);
     1004
     1005    return pCpumCpu->Guest.esi;
    8981006}
    8991007
    … …  
    9011009VMMDECL(uint32_t) CPUMGetGuestEDI(PVM pVM)
    9021010{
    903     return pVM->cpum.s.Guest.edi;
     1011    PCPUMCPU pCpumCpu = cpumGetCpumCpu(pVM);
     1012
     1013    return pCpumCpu->Guest.edi;
    9041014}
    9051015
    … …  
    9071017VMMDECL(uint32_t) CPUMGetGuestESP(PVM pVM)
    9081018{
    909     return pVM->cpum.s.Guest.esp;
     1019    PCPUMCPU pCpumCpu = cpumGetCpumCpu(pVM);
     1020
     1021    return pCpumCpu->Guest.esp;
    9101022}
    9111023
    … …  
    9131025VMMDECL(uint32_t) CPUMGetGuestEBP(PVM pVM)
    9141026{
    915     return pVM->cpum.s.Guest.ebp;
     1027    PCPUMCPU pCpumCpu = cpumGetCpumCpu(pVM);
     1028
     1029    return pCpumCpu->Guest.ebp;
    9161030}
    9171031
    … …  
    9191033VMMDECL(uint32_t) CPUMGetGuestEFlags(PVM pVM)
    9201034{
    921     return pVM->cpum.s.Guest.eflags.u32;
     1035    PCPUMCPU pCpumCpu = cpumGetCpumCpu(pVM);
     1036
     1037    return pCpumCpu->Guest.eflags.u32;
    9221038}
    9231039
    … …  
    9251041VMMDECL(CPUMSELREGHID *) CPUMGetGuestTRHid(PVM pVM)
    9261042{
    927     return &pVM->cpum.s.Guest.trHid;
     1043    PCPUMCPU pCpumCpu = cpumGetCpumCpu(pVM);
     1044
     1045    return &pCpumCpu->Guest.trHid;
    9281046}
    9291047
    … …  
    9321050VMMDECL(int) CPUMGetGuestCRx(PVM pVM, unsigned iReg, uint64_t *pValue)
    9331051{
     1052    PCPUMCPU pCpumCpu = cpumGetCpumCpu(pVM);
     1053
    9341054    switch (iReg)
    9351055    {
    9361056        case USE_REG_CR0:
    937             *pValue = pVM->cpum.s.Guest.cr0;
     1057            *pValue = pCpumCpu->Guest.cr0;
    9381058            break;
    9391059        case USE_REG_CR2:
    940             *pValue = pVM->cpum.s.Guest.cr2;
     1060            *pValue = pCpumCpu->Guest.cr2;
    9411061            break;
    9421062        case USE_REG_CR3:
    943             *pValue = pVM->cpum.s.Guest.cr3;
     1063            *pValue = pCpumCpu->Guest.cr3;
    9441064            break;
    9451065        case USE_REG_CR4:
    946             *pValue = pVM->cpum.s.Guest.cr4;
     1066            *pValue = pCpumCpu->Guest.cr4;
    9471067            break;
    9481068        default:
    … …  
    9551075VMMDECL(uint64_t) CPUMGetGuestDR0(PVM pVM)
    9561076{
    957     return pVM->cpum.s.Guest.dr[0];
     1077    PCPUMCPU pCpumCpu = cpumGetCpumCpu(pVM);
     1078
     1079    return pCpumCpu->Guest.dr[0];
    9581080}
    9591081
    … …  
    9611083VMMDECL(uint64_t) CPUMGetGuestDR1(PVM pVM)
    9621084{
    963     return pVM->cpum.s.Guest.dr[1];
     1085    PCPUMCPU pCpumCpu = cpumGetCpumCpu(pVM);
     1086
     1087    return pCpumCpu->Guest.dr[1];
    9641088}
    9651089
    … …  
    9671091VMMDECL(uint64_t) CPUMGetGuestDR2(PVM pVM)
    9681092{
    969     return pVM->cpum.s.Guest.dr[2];
     1093    PCPUMCPU pCpumCpu = cpumGetCpumCpu(pVM);
     1094
     1095    return pCpumCpu->Guest.dr[2];
    9701096}
    9711097
    … …  
    9731099VMMDECL(uint64_t) CPUMGetGuestDR3(PVM pVM)
    9741100{
    975     return pVM->cpum.s.Guest.dr[3];
     1101    PCPUMCPU pCpumCpu = cpumGetCpumCpu(pVM);
     1102
     1103    return pCpumCpu->Guest.dr[3];
    9761104}
    9771105
    … …  
    9791107VMMDECL(uint64_t) CPUMGetGuestDR6(PVM pVM)
    9801108{
    981     return pVM->cpum.s.Guest.dr[6];
     1109    PCPUMCPU pCpumCpu = cpumGetCpumCpu(pVM);
     1110
     1111    return pCpumCpu->Guest.dr[6];
    9821112}
    9831113
    … …  
    9851115VMMDECL(uint64_t) CPUMGetGuestDR7(PVM pVM)
    9861116{
    987     return pVM->cpum.s.Guest.dr[7];
     1117    PCPUMCPU pCpumCpu = cpumGetCpumCpu(pVM);
     1118
     1119    return pCpumCpu->Guest.dr[7];
    9881120}
    9891121
    … …  
    9911123VMMDECL(int) CPUMGetGuestDRx(PVM pVM, uint32_t iReg, uint64_t *pValue)
    9921124{
     1125    PCPUMCPU pCpumCpu = cpumGetCpumCpu(pVM);
     1126
    9931127    AssertReturn(iReg <= USE_REG_DR7, VERR_INVALID_PARAMETER);
    9941128    /* DR4 is an alias for DR6, and DR5 is an alias for DR7. */
    9951129    if (iReg == 4 || iReg == 5)
    9961130        iReg += 2;
    997     *pValue = pVM->cpum.s.Guest.dr[iReg];
     1131    *pValue = pCpumCpu->Guest.dr[iReg];
    9981132    return VINF_SUCCESS;
    9991133}
    … …  
    10021136VMMDECL(uint64_t) CPUMGetGuestEFER(PVM pVM)
    10031137{
    1004     return pVM->cpum.s.Guest.msrEFER;
     1138    PCPUMCPU pCpumCpu = cpumGetCpumCpu(pVM);
     1139
     1140    return pCpumCpu->Guest.msrEFER;
    10051141}
    10061142
    … …  
    12881424            break;
    12891425    }
    1290     pVM->cpum.s.fChanged |= CPUM_CHANGED_CPUID;
     1426    PCPUMCPU pCpumCpu = cpumGetCpumCpu(pVM);
     1427
     1428    pCpumCpu->fChanged |= CPUM_CHANGED_CPUID;
    12911429}
    12921430
    … …  
    13751513            break;
    13761514    }
    1377     pVM->cpum.s.fChanged |= CPUM_CHANGED_CPUID;
     1515    PCPUMCPU pCpumCpu = cpumGetCpumCpu(pVM);
     1516    pCpumCpu->fChanged |= CPUM_CHANGED_CPUID;
    13781517}
    13791518
    … …  
    13931532VMMDECL(int) CPUMSetGuestDR0(PVM pVM, uint64_t uDr0)
    13941533{
    1395     pVM->cpum.s.Guest.dr[0] = uDr0;
     1534    PCPUMCPU pCpumCpu = cpumGetCpumCpu(pVM);
     1535
     1536    pCpumCpu->Guest.dr[0] = uDr0;
    13961537    return CPUMRecalcHyperDRx(pVM);
    13971538}
    … …  
    14001541VMMDECL(int) CPUMSetGuestDR1(PVM pVM, uint64_t uDr1)
    14011542{
    1402     pVM->cpum.s.Guest.dr[1] = uDr1;
     1543    PCPUMCPU pCpumCpu = cpumGetCpumCpu(pVM);
     1544
     1545    pCpumCpu->Guest.dr[1] = uDr1;
    14031546    return CPUMRecalcHyperDRx(pVM);
    14041547}
    … …  
    14071550VMMDECL(int) CPUMSetGuestDR2(PVM pVM, uint64_t uDr2)
    14081551{
    1409     pVM->cpum.s.Guest.dr[2] = uDr2;
     1552    PCPUMCPU pCpumCpu = cpumGetCpumCpu(pVM);
     1553
     1554    pCpumCpu->Guest.dr[2] = uDr2;
    14101555    return CPUMRecalcHyperDRx(pVM);
    14111556}
    … …  
    14141559VMMDECL(int) CPUMSetGuestDR3(PVM pVM, uint64_t uDr3)
    14151560{
    1416     pVM->cpum.s.Guest.dr[3] = uDr3;
     1561    PCPUMCPU pCpumCpu = cpumGetCpumCpu(pVM);
     1562
     1563    pCpumCpu->Guest.dr[3] = uDr3;
    14171564    return CPUMRecalcHyperDRx(pVM);
    14181565}
    … …  
    14211568VMMDECL(int) CPUMSetGuestDR6(PVM pVM, uint64_t uDr6)
    14221569{
    1423     pVM->cpum.s.Guest.dr[6] = uDr6;
     1570    PCPUMCPU pCpumCpu = cpumGetCpumCpu(pVM);
     1571
     1572    pCpumCpu->Guest.dr[6] = uDr6;
    14241573    return CPUMRecalcHyperDRx(pVM);
    14251574}
    … …  
    14281577VMMDECL(int) CPUMSetGuestDR7(PVM pVM, uint64_t uDr7)
    14291578{
    1430     pVM->cpum.s.Guest.dr[7] = uDr7;
     1579    PCPUMCPU pCpumCpu = cpumGetCpumCpu(pVM);
     1580
     1581    pCpumCpu->Guest.dr[7] = uDr7;
    14311582    return CPUMRecalcHyperDRx(pVM);
    14321583}
    … …  
    14351586VMMDECL(int) CPUMSetGuestDRx(PVM pVM, uint32_t iReg, uint64_t Value)
    14361587{
     1588    PCPUMCPU pCpumCpu = cpumGetCpumCpu(pVM);
     1589
    14371590    AssertReturn(iReg <= USE_REG_DR7, VERR_INVALID_PARAMETER);
    14381591    /* DR4 is an alias for DR6, and DR5 is an alias for DR7. */
    14391592    if (iReg == 4 || iReg == 5)
    14401593        iReg += 2;
    1441     pVM->cpum.s.Guest.dr[iReg] = Value;
     1594    pCpumCpu->Guest.dr[iReg] = Value;
    14421595    return CPUMRecalcHyperDRx(pVM);
    14431596}
    … …  
    14571610VMMDECL(int) CPUMRecalcHyperDRx(PVM pVM)
    14581611{
     1612    PCPUMCPU pCpumCpu = cpumGetCpumCpu(pVM);
    14591613    /*
    14601614     * Compare the DR7s first.
    … …  
    15421696         */
    15431697#ifdef IN_RC
    1544         if (!(pVM->cpum.s.fUseFlags & CPUM_USE_DEBUG_REGS))
     1698        if (!(pCpumCpu->fUseFlags & CPUM_USE_DEBUG_REGS))
    15451699        {
    15461700            /** @todo save host DBx registers. */
    15471701        }
    15481702#endif
    1549         pVM->cpum.s.fUseFlags |= CPUM_USE_DEBUG_REGS;
     1703        pCpumCpu->fUseFlags |= CPUM_USE_DEBUG_REGS;
    15501704        if (uNewDr3 != pVM->cpum.s.Hyper.dr[3])
    15511705            CPUMSetHyperDR3(pVM, uNewDr3);
    … …  
    15621716    {
    15631717#ifdef IN_RC
    1564         if (pVM->cpum.s.fUseFlags & CPUM_USE_DEBUG_REGS)
     1718        if (pCpumCpu->fUseFlags & CPUM_USE_DEBUG_REGS)
    15651719        {
    15661720            /** @todo restore host DBx registers. */
    15671721        }
    15681722#endif
    1569         pVM->cpum.s.fUseFlags &= ~CPUM_USE_DEBUG_REGS;
     1723        pCpumCpu->fUseFlags &= ~CPUM_USE_DEBUG_REGS;
    15701724    }
    15711725    Log2(("CPUMRecalcHyperDRx: fUseFlags=%#x %RGr %RGr %RGr %RGr  %RGr %RGr\n",
    1572           pVM->cpum.s.fUseFlags, pVM->cpum.s.Hyper.dr[0], pVM->cpum.s.Hyper.dr[1],
     1726          pCpumCpu->fUseFlags, pVM->cpum.s.Hyper.dr[0], pVM->cpum.s.Hyper.dr[1],
    15731727         pVM->cpum.s.Hyper.dr[2], pVM->cpum.s.Hyper.dr[3], pVM->cpum.s.Hyper.dr[6],
    15741728         pVM->cpum.s.Hyper.dr[7]));
    … …  
    15911745VMMDECL(int) CPUMRawEnter(PVM pVM, PCPUMCTXCORE pCtxCore)
    15921746{
     1747    PCPUMCPU pCpumCpu = cpumGetCpumCpu(pVM);
     1748
    15931749    Assert(!pVM->cpum.s.fRawEntered);
    15941750    if (!pCtxCore)
    1595         pCtxCore = CPUMCTX2CORE(&pVM->cpum.s.Guest);
     1751        pCtxCore = CPUMCTX2CORE(&pCpumCpu->Guest);
    15961752
    15971753    /*
    … …  
    16301786                     || pCtxCore->eflags.Bits.u1VM,
    16311787                     ("X86_EFL_IOPL=%d CPL=%d\n", pCtxCore->eflags.Bits.u2IOPL, pCtxCore->ss & X86_SEL_RPL));
    1632     Assert((pVM->cpum.s.Guest.cr0 & (X86_CR0_PG | X86_CR0_WP | X86_CR0_PE)) == (X86_CR0_PG | X86_CR0_PE | X86_CR0_WP));
     1788    Assert((pCpumCpu->Guest.cr0 & (X86_CR0_PG | X86_CR0_WP | X86_CR0_PE)) == (X86_CR0_PG | X86_CR0_PE | X86_CR0_WP));
    16331789    pCtxCore->eflags.u32        |= X86_EFL_IF; /* paranoia */
    16341790
    … …  
    16511807VMMDECL(int) CPUMRawLeave(PVM pVM, PCPUMCTXCORE pCtxCore, int rc)
    16521808{
     1809    PCPUMCPU pCpumCpu = cpumGetCpumCpu(pVM);
     1810
    16531811    /*
    16541812     * Don't leave if we've already left (in GC).
    … …  
    16591817    pVM->cpum.s.fRawEntered = false;
    16601818
    1661     PCPUMCTX pCtx = &pVM->cpum.s.Guest;
     1819    PCPUMCTX pCtx = &pCpumCpu->Guest;
    16621820    if (!pCtxCore)
    16631821        pCtxCore = CPUMCTX2CORE(pCtx);
    … …  
    17641922VMMDECL(unsigned) CPUMGetAndClearChangedFlagsREM(PVM pVM)
    17651923{
    1766     unsigned fFlags = pVM->cpum.s.fChanged;
    1767     pVM->cpum.s.fChanged = 0;
     1924    PCPUMCPU pCpumCpu = cpumGetCpumCpu(pVM);
     1925
     1926    unsigned fFlags = pCpumCpu->fChanged;
     1927    pCpumCpu->fChanged = 0;
    17681928    /** @todo change the switcher to use the fChanged flags. */
    1769     if (pVM->cpum.s.fUseFlags & CPUM_USED_FPU_SINCE_REM)
     1929    if (pCpumCpu->fUseFlags & CPUM_USED_FPU_SINCE_REM)
    17701930    {
    17711931        fFlags |= CPUM_CHANGED_FPU_REM;
    1772         pVM->cpum.s.fUseFlags &= ~CPUM_USED_FPU_SINCE_REM;
     1932        pCpumCpu->fUseFlags &= ~CPUM_USED_FPU_SINCE_REM;
    17731933    }
    17741934    return fFlags;
    … …  
    17831943VMMDECL(void) CPUMSetChangedFlags(PVM pVM, uint32_t fChangedFlags)
    17841944{
    1785     pVM->cpum.s.fChanged |= fChangedFlags;
     1945    PCPUMCPU pCpumCpu = cpumGetCpumCpu(pVM);
     1946
     1947    pCpumCpu->fChanged |= fChangedFlags;
    17861948}
    17871949
    … …  
    18071969VMMDECL(bool) CPUMIsHostUsingSysEnter(PVM pVM)
    18081970{
    1809     return (pVM->cpum.s.fUseFlags & CPUM_USE_SYSENTER) != 0;
     1971    PCPUMCPU pCpumCpu = cpumGetCpumCpu(pVM);
     1972
     1973    return (pCpumCpu->fUseFlags & CPUM_USE_SYSENTER) != 0;
    18101974}
    18111975
    … …  
    18191983VMMDECL(bool) CPUMIsHostUsingSysCall(PVM pVM)
    18201984{
    1821     return (pVM->cpum.s.fUseFlags & CPUM_USE_SYSCALL) != 0;
     1985    PCPUMCPU pCpumCpu = cpumGetCpumCpu(pVM);
     1986
     1987    return (pCpumCpu->fUseFlags & CPUM_USE_SYSCALL) != 0;
    18221988}
    18231989
    … …  
    18291995 * @returns VBox status code.
    18301996 * @param   pVM         VM handle.
    1831  */
    1832 VMMDECL(int) CPUMHandleLazyFPU(PVM pVM)
    1833 {
    1834     return CPUMHandleLazyFPUAsm(&pVM->cpum.s);
     1997 * @param   pVCpu       VMCPU handle
     1998 */
     1999VMMDECL(int) CPUMHandleLazyFPU(PVM pVM, PVMCPU pVCpu)
     2000{
     2001    return CPUMHandleLazyFPUAsm(&pVCpu->cpum.s);
    18352002}
    18362003
    … …  
    18412008 * @returns VBox status code.
    18422009 * @param   pVM         VM handle.
    1843  */
    1844 VMMDECL(int) CPUMRestoreHostFPUState(PVM pVM)
     2010 * @param   pVCpu       VMCPU handle
     2011 */
     2012VMMDECL(int) CPUMRestoreHostFPUState(PVM pVM, PVMCPU pVCpu)
    18452013{
    18462014    Assert(pVM->cpum.s.CPUFeatures.edx.u1FXSR);
    1847     return CPUMRestoreHostFPUStateAsm(&pVM->cpum.s);
     2015    return CPUMRestoreHostFPUStateAsm(&pVCpu->cpum.s);
    18482016}
    18492017
    … …  
    18542022 * @returns true if we did.
    18552023 * @returns false if not.
    1856  * @param   pVM     The VM handle.
    1857  */
    1858 VMMDECL(bool) CPUMIsGuestFPUStateActive(PVM pVM)
    1859 {
    1860     return (pVM->cpum.s.fUseFlags & CPUM_USED_FPU) != 0;
     2024 * @param   pVCpu   The VMCPU handle.
     2025 */
     2026VMMDECL(bool) CPUMIsGuestFPUStateActive(PVMCPU pVCpu)
     2027{
     2028    return (pVCpu->cpum.s.fUseFlags & CPUM_USED_FPU) != 0;
    18612029}
    18622030
    … …  
    18682036VMMDECL(void) CPUMDeactivateGuestFPUState(PVM pVM)
    18692037{
    1870     pVM->cpum.s.fUseFlags &= ~CPUM_USED_FPU;
     2038    PCPUMCPU pCpumCpu = cpumGetCpumCpu(pVM);
     2039
     2040    pCpumCpu->fUseFlags &= ~CPUM_USED_FPU;
    18712041}
    18722042
    … …  
    18802050VMMDECL(bool) CPUMIsGuestDebugStateActive(PVM pVM)
    18812051{
    1882     return (pVM->cpum.s.fUseFlags & CPUM_USE_DEBUG_REGS) != 0;
     2052    PCPUMCPU pCpumCpu = cpumGetCpumCpu(pVM);
     2053
     2054    return (pCpumCpu->fUseFlags & CPUM_USE_DEBUG_REGS) != 0;
    18832055}
    18842056
    … …  
    18922064VMMDECL(void) CPUMDeactivateGuestDebugState(PVM pVM)
    18932065{
    1894     pVM->cpum.s.fUseFlags &= ~CPUM_USE_DEBUG_REGS;
     2066    PCPUMCPU pCpumCpu = cpumGetCpumCpu(pVM);
     2067
     2068    pCpumCpu->fUseFlags &= ~CPUM_USE_DEBUG_REGS;
    18952069}
    18962070
    … …  
    19282102VMMDECL(uint32_t) CPUMGetGuestCPL(PVM pVM, PCPUMCTXCORE pCtxCore)
    19292103{
     2104    PCPUMCPU pCpumCpu = cpumGetCpumCpu(pVM);
    19302105    uint32_t cpl;
    19312106
    … …  
    19392114         * at SS. (ACP2 regression during install after a far call to ring 2)
    19402115         */
    1941         if (RT_LIKELY(pVM->cpum.s.Guest.cr0 & X86_CR0_PE))
     2116        if (RT_LIKELY(pCpumCpu->Guest.cr0 & X86_CR0_PE))
    19422117            cpl = pCtxCore->ssHid.Attr.n.u2Dpl;
    19432118        else
    19442119            cpl = 0;  /* CPL set to 3 for VT-x real-mode emulation. */
    19452120    }
    1946     else if (RT_LIKELY(pVM->cpum.s.Guest.cr0 & X86_CR0_PE))
     2121    else if (RT_LIKELY(pCpumCpu->Guest.cr0 & X86_CR0_PE))
    19472122    {
    19482123        if (RT_LIKELY(!pCtxCore->eflags.Bits.u1VM))
    … …  
    19792154VMMDECL(CPUMMODE) CPUMGetGuestMode(PVM pVM)
    19802155{
     2156    PCPUMCPU pCpumCpu = cpumGetCpumCpu(pVM);
     2157
    19812158    CPUMMODE enmMode;
    1982     if (!(pVM->cpum.s.Guest.cr0 & X86_CR0_PE))
     2159    if (!(pCpumCpu->Guest.cr0 & X86_CR0_PE))
    19832160        enmMode = CPUMMODE_REAL;
    1984     else if (!(pVM->cpum.s.Guest.msrEFER & MSR_K6_EFER_LMA))
     2161    else if (!(pCpumCpu->Guest.msrEFER & MSR_K6_EFER_LMA))
    19852162        enmMode = CPUMMODE_PROTECTED;
    19862163    else

  • trunk/src/VBox/VMM/VMMGC/CPUMGC.cpp

    r8155 r13960  
    6464    if (uUser & CPUM_HANDLER_CTXCORE_IN_EBP)
    6565    {
    66         PCPUMCTXCORE  pGstCtxCore = CPUMCTX2CORE(&pVM->cpum.s.Guest);
     66        PCPUMCTXCORE  pGstCtxCore = (PCPUMCTXCORE)CPUMGetGuestCtxCore(pVM);
    6767        PCCPUMCTXCORE pGstCtxCoreSrc = (PCPUMCTXCORE)pRegFrame->ebp;
    6868        *pGstCtxCore = *pGstCtxCoreSrc;
    … …  
    9090        case CPUM_HANDLER_IRET:
    9191        {
    92             PCPUMCTXCORE  pGstCtxCore = CPUMCTX2CORE(&pVM->cpum.s.Guest);
     92            PCPUMCTXCORE  pGstCtxCore = (PCPUMCTXCORE)CPUMGetGuestCtxCore(pVM);
    9393            uint32_t     *pEsp = (uint32_t *)pRegFrame->esp;
    9494

  • trunk/src/VBox/VMM/VMMGC/CPUMGCA.asm

    r12989 r13960  
    7373    mov     eax, [esp + 4]              ; get argument
    7474    mov     edx, IMP(g_CPUM)
    75 
    76     mov     ecx, [edx + CPUM.Guest.eip]
     75    ; Convert to CPUMCPU pointer
     76    add     edx, [edx + CPUM.ulOffCPUMCPU]
     77
     78    mov     ecx, [edx + CPUMCPU.Guest.eip]
    7779    mov     [eax +  0h], ecx
    78     mov     ecx, [edx + CPUM.Guest.cs]
     80    mov     ecx, [edx + CPUMCPU.Guest.cs]
    7981    mov     [eax +  4h], ecx
    80     mov     ecx, [edx + CPUM.Guest.eflags]
     82    mov     ecx, [edx + CPUMCPU.Guest.eflags]
    8183    mov     [eax +  8h], ecx
    82     mov     ecx, [edx + CPUM.Guest.esp]
     84    mov     ecx, [edx + CPUMCPU.Guest.esp]
    8385    mov     [eax + 0ch], ecx
    84     mov     ecx, [edx + CPUM.Guest.ss]
     86    mov     ecx, [edx + CPUMCPU.Guest.ss]
    8587    mov     [eax + 10h], ecx
    8688
    87     test    dword [edx + CPUM.Guest.eflags], X86_EFL_VM
     89    test    dword [edx + CPUMCPU.Guest.eflags], X86_EFL_VM
    8890    jnz short CPUMGCRestoreInt_V86
    8991
    … …  
    9395    ; todo: potential trouble loading invalid es,fs,gs,ds because
    9496    ;       of a VMM imposed exception?
    95     mov     es,  [edx + CPUM.Guest.es]
    96     mov     fs,  [edx + CPUM.Guest.fs]
    97     mov     gs,  [edx + CPUM.Guest.gs]
    98     mov     esi, [edx + CPUM.Guest.esi]
    99     mov     edi, [edx + CPUM.Guest.edi]
    100     mov     ebp, [edx + CPUM.Guest.ebp]
    101     mov     ebx, [edx + CPUM.Guest.ebx]
    102     mov     ecx, [edx + CPUM.Guest.ecx]
    103     mov     eax, [edx + CPUM.Guest.eax]
    104     push    dword [edx + CPUM.Guest.ds]
    105     mov     edx, [edx + CPUM.Guest.edx]
     97    mov     es,  [edx + CPUMCPU.Guest.es]
     98    mov     fs,  [edx + CPUMCPU.Guest.fs]
     99    mov     gs,  [edx + CPUMCPU.Guest.gs]
     100    mov     esi, [edx + CPUMCPU.Guest.esi]
     101    mov     edi, [edx + CPUMCPU.Guest.edi]
     102    mov     ebp, [edx + CPUMCPU.Guest.ebp]
     103    mov     ebx, [edx + CPUMCPU.Guest.ebx]
     104    mov     ecx, [edx + CPUMCPU.Guest.ecx]
     105    mov     eax, [edx + CPUMCPU.Guest.eax]
     106    push    dword [edx + CPUMCPU.Guest.ds]
     107    mov     edx, [edx + CPUMCPU.Guest.edx]
    106108    pop     ds
    107109
    … …  
    110112CPUMGCRestoreInt_V86:
    111113    ; iret restores ds, es, fs & gs
    112     mov     ecx, [edx + CPUM.Guest.es]
     114    mov     ecx, [edx + CPUMCPU.Guest.es]
    113115    mov     [eax + 14h], ecx
    114     mov     ecx, [edx + CPUM.Guest.ds]
     116    mov     ecx, [edx + CPUMCPU.Guest.ds]
    115117    mov     [eax + 18h], ecx
    116     mov     ecx, [edx + CPUM.Guest.fs]
     118    mov     ecx, [edx + CPUMCPU.Guest.fs]
    117119    mov     [eax + 1Ch], ecx
    118     mov     ecx, [edx + CPUM.Guest.gs]
     120    mov     ecx, [edx + CPUMCPU.Guest.gs]
    119121    mov     [eax + 20h], ecx
    120     mov     esi, [edx + CPUM.Guest.esi]
    121     mov     edi, [edx + CPUM.Guest.edi]
    122     mov     ebp, [edx + CPUM.Guest.ebp]
    123     mov     ebx, [edx + CPUM.Guest.ebx]
    124     mov     ecx, [edx + CPUM.Guest.ecx]
    125     mov     eax, [edx + CPUM.Guest.eax]
    126     mov     edx, [edx + CPUM.Guest.edx]
     122    mov     esi, [edx + CPUMCPU.Guest.esi]
     123    mov     edi, [edx + CPUMCPU.Guest.edi]
     124    mov     ebp, [edx + CPUMCPU.Guest.ebp]
     125    mov     ebx, [edx + CPUMCPU.Guest.ebx]
     126    mov     ecx, [edx + CPUMCPU.Guest.ecx]
     127    mov     eax, [edx + CPUMCPU.Guest.eax]
     128    mov     edx, [edx + CPUMCPU.Guest.edx]
    127129    ret
    128130
    … …  
    250252align 16
    251253BEGINPROC_EXPORTED CPUMGCResumeGuest
     254    ; Convert to CPUMCPU pointer
     255    add     edx, [edx + CPUM.ulOffCPUMCPU]
    252256    ;
    253257    ; Setup iretd
    254258    ;
    255     push    dword [edx + CPUM.Guest.ss]
    256     push    dword [edx + CPUM.Guest.esp]
    257     push    dword [edx + CPUM.Guest.eflags]
    258     push    dword [edx + CPUM.Guest.cs]
    259     push    dword [edx + CPUM.Guest.eip]
     259    push    dword [edx + CPUMCPU.Guest.ss]
     260    push    dword [edx + CPUMCPU.Guest.esp]
     261    push    dword [edx + CPUMCPU.Guest.eflags]
     262    push    dword [edx + CPUMCPU.Guest.cs]
     263    push    dword [edx + CPUMCPU.Guest.eip]
    260264
    261265    ;
    … …  
    263267    ;
    264268    TRPM_NP_GP_HANDLER NAME(cpumGCHandleNPAndGP), CPUM_HANDLER_ES
    265     mov     es,  [edx + CPUM.Guest.es]
     269    mov     es,  [edx + CPUMCPU.Guest.es]
    266270    TRPM_NP_GP_HANDLER NAME(cpumGCHandleNPAndGP), CPUM_HANDLER_FS
    267     mov     fs,  [edx + CPUM.Guest.fs]
     271    mov     fs,  [edx + CPUMCPU.Guest.fs]
    268272    TRPM_NP_GP_HANDLER NAME(cpumGCHandleNPAndGP), CPUM_HANDLER_GS
    269     mov     gs,  [edx + CPUM.Guest.gs]
     273    mov     gs,  [edx + CPUMCPU.Guest.gs]
    270274
    271275%ifdef VBOX_WITH_STATISTICS
    … …  
    296300    ; Continue restore.
    297301    ;
    298     mov     esi, [edx + CPUM.Guest.esi]
    299     mov     edi, [edx + CPUM.Guest.edi]
    300     mov     ebp, [edx + CPUM.Guest.ebp]
    301     mov     ebx, [edx + CPUM.Guest.ebx]
    302     mov     ecx, [edx + CPUM.Guest.ecx]
    303     mov     eax, [edx + CPUM.Guest.eax]
    304     push    dword [edx + CPUM.Guest.ds]
    305     mov     edx, [edx + CPUM.Guest.edx]
     302    mov     esi, [edx + CPUMCPU.Guest.esi]
     303    mov     edi, [edx + CPUMCPU.Guest.edi]
     304    mov     ebp, [edx + CPUMCPU.Guest.ebp]
     305    mov     ebx, [edx + CPUMCPU.Guest.ebx]
     306    mov     ecx, [edx + CPUMCPU.Guest.ecx]
     307    mov     eax, [edx + CPUMCPU.Guest.eax]
     308    push    dword [edx + CPUMCPU.Guest.ds]
     309    mov     edx, [edx + CPUMCPU.Guest.edx]
    306310    TRPM_NP_GP_HANDLER NAME(cpumGCHandleNPAndGP), CPUM_HANDLER_DS
    307311    pop     ds
    … …  
    326330align 16
    327331BEGINPROC_EXPORTED CPUMGCResumeGuestV86
     332    ; Convert to CPUMCPU pointer
     333    add     edx, [edx + CPUM.ulOffCPUMCPU]
    328334    ;
    329335    ; Setup iretd
    330336    ;
    331     push    dword [edx + CPUM.Guest.gs]
    332     push    dword [edx + CPUM.Guest.fs]
    333     push    dword [edx + CPUM.Guest.ds]
    334     push    dword [edx + CPUM.Guest.es]
    335 
    336     push    dword [edx + CPUM.Guest.ss]
    337     push    dword [edx + CPUM.Guest.esp]
    338 
    339     push    dword [edx + CPUM.Guest.eflags]
    340     push    dword [edx + CPUM.Guest.cs]
    341     push    dword [edx + CPUM.Guest.eip]
     337    push    dword [edx + CPUMCPU.Guest.gs]
     338    push    dword [edx + CPUMCPU.Guest.fs]
     339    push    dword [edx + CPUMCPU.Guest.ds]
     340    push    dword [edx + CPUMCPU.Guest.es]
     341
     342    push    dword [edx + CPUMCPU.Guest.ss]
     343    push    dword [edx + CPUMCPU.Guest.esp]
     344
     345    push    dword [edx + CPUMCPU.Guest.eflags]
     346    push    dword [edx + CPUMCPU.Guest.cs]
     347    push    dword [edx + CPUMCPU.Guest.eip]
    342348
    343349    ;
    … …  
    372378    ; Continue restore.
    373379    ;
    374     mov     esi, [edx + CPUM.Guest.esi]
    375     mov     edi, [edx + CPUM.Guest.edi]
    376     mov     ebp, [edx + CPUM.Guest.ebp]
    377     mov     ecx, [edx + CPUM.Guest.ecx]
    378     mov     ebx, [edx + CPUM.Guest.ebx]
    379     mov     eax, [edx + CPUM.Guest.eax]
    380     mov     edx, [edx + CPUM.Guest.edx]
     380    mov     esi, [edx + CPUMCPU.Guest.esi]
     381    mov     edi, [edx + CPUMCPU.Guest.edi]
     382    mov     ebp, [edx + CPUMCPU.Guest.ebp]
     383    mov     ecx, [edx + CPUMCPU.Guest.ecx]
     384    mov     ebx, [edx + CPUMCPU.Guest.ebx]
     385    mov     eax, [edx + CPUMCPU.Guest.eax]
     386    mov     edx, [edx + CPUMCPU.Guest.edx]
    381387
    382388    ; restart execution.

  • trunk/src/VBox/VMM/VMMGC/TRPMGCHandlers.cpp

    r13823 r13960  
    441441
    442442    LogFlow(("TRPMTrap07HandlerGC: eip=%08RX32\n", pRegFrame->eip));
    443     return CPUMHandleLazyFPU(pVM);
     443    return CPUMHandleLazyFPU(pVM, VMMGetCpu(pVM));
    444444}
    445445

  • trunk/src/VBox/VMM/VMMR0/CPUMR0.cpp

    r12989 r13960  
    8282             * Read the MSR and see if it's in use or not.
    8383             */
    84             uint32_t    u32 = ASMRdMsr_Low(MSR_IA32_SYSENTER_CS);
     84            uint32_t u32 = ASMRdMsr_Low(MSR_IA32_SYSENTER_CS);
    8585            if (u32)
    8686            {
    87                 pVM->cpum.s.fUseFlags |= CPUM_USE_SYSENTER;
     87                for (unsigned i=0;i<pVM->cCPUs;i++)
     88                    pVM->aCpus[i].cpum.s.fUseFlags |= CPUM_USE_SYSENTER;
     89
    8890                Log(("CPUMR0Init: host uses sysenter cs=%08x%08x\n", ASMRdMsr_High(MSR_IA32_SYSENTER_CS), u32));
    8991            }
    … …  
    101103    if (u32DR7 & X86_DR7_ENABLED_MASK)
    102104    {
    103         pVM->cpum.s.fUseFlags |= CPUM_USE_DEBUG_REGS_HOST;
     105        for (unsigned i=0;i<pVM->cCPUs;i++)
     106            pVM->aCpus[i].cpum.s.fUseFlags |= CPUM_USE_DEBUG_REGS_HOST;
    104107        Log(("CPUMR0Init: host uses debug registers (dr7=%x)\n", u32DR7));
    105108    }
    … …  
    114117 * @returns VBox status code.
    115118 * @param   pVM         VM handle.
     119 * @param   pVCpu       VMCPU handle.
    116120 * @param   pCtx        CPU context
    117121 */
    118 VMMR0DECL(int) CPUMR0LoadGuestFPU(PVM pVM, PCPUMCTX pCtx)
     122VMMR0DECL(int) CPUMR0LoadGuestFPU(PVM pVM, PVMCPU pVCpu, PCPUMCTX pCtx)
    119123{
    120124    Assert(pVM->cpum.s.CPUFeatures.edx.u1FXSR);
    … …  
    122126
    123127    /* If the FPU state has already been loaded, then it's a guest trap. */
    124     if (pVM->cpum.s.fUseFlags & CPUM_USED_FPU)
     128    if (pVCpu->cpum.s.fUseFlags & CPUM_USED_FPU)
    125129    {
    126130        Assert(    ((pCtx->cr0 & (X86_CR0_MP | X86_CR0_EM | X86_CR0_TS)) == (X86_CR0_MP | X86_CR0_EM | X86_CR0_TS))
    … …  
    177181        {
    178182            ASMWrMsr(MSR_K6_EFER, oldMsrEFERHost & ~MSR_K6_EFER_FFXSR);
    179             pVM->cpum.s.fUseFlags |= CPUM_MANUAL_XMM_RESTORE;
     183            pVCpu->cpum.s.fUseFlags |= CPUM_MANUAL_XMM_RESTORE;
    180184        }
    181185    }
    182186
    183187    /* If we sync the FPU/XMM state on-demand, then we can continue execution as if nothing has happened. */
    184     int rc = CPUMHandleLazyFPU(pVM);
     188    int rc = CPUMHandleLazyFPU(pVM, pVCpu);
    185189    AssertRC(rc);
    186     Assert(CPUMIsGuestFPUStateActive(pVM));
     190    Assert(CPUMIsGuestFPUStateActive(pVCpu));
    187191
    188192    /* Restore EFER MSR */
    189     if (pVM->cpum.s.fUseFlags & CPUM_MANUAL_XMM_RESTORE)
     193    if (pVCpu->cpum.s.fUseFlags & CPUM_MANUAL_XMM_RESTORE)
    190194        ASMWrMsr(MSR_K6_EFER, oldMsrEFERHost);
    191195
    … …  
    199203     * We don't want the guest to be able to trigger floating point/SSE exceptions on the host.
    200204     */
    201     pVM->cpum.s.Host.fpu.FCW = CPUMGetFCW();
     205    pVCpu->cpum.s.Host.fpu.FCW = CPUMGetFCW();
    202206    if (pVM->cpum.s.CPUFeatures.edx.u1SSE)
    203         pVM->cpum.s.Host.fpu.MXCSR = CPUMGetMXCSR();
     207        pVCpu->cpum.s.Host.fpu.MXCSR = CPUMGetMXCSR();
    204208
    205209    CPUMLoadFPUAsm(pCtx);
    … …  
    219223            /* fxrstor doesn't restore the XMM state! */
    220224            CPUMLoadXMMAsm(pCtx);
    221             pVM->cpum.s.fUseFlags |= CPUM_MANUAL_XMM_RESTORE;
     225            pVCpu->cpum.s.fUseFlags |= CPUM_MANUAL_XMM_RESTORE;
    222226        }
    223227    }
    224228#endif /* CPUM_CAN_HANDLE_NM_TRAPS_IN_KERNEL_MODE */
    225229
    226     pVM->cpum.s.fUseFlags |= CPUM_USED_FPU;
     230    pVCpu->cpum.s.fUseFlags |= CPUM_USED_FPU;
    227231    return VINF_SUCCESS;
    228232}
    … …  
    234238 * @returns VBox status code.
    235239 * @param   pVM         VM handle.
     240 * @param   pVCpu       VMCPU handle.
    236241 * @param   pCtx        CPU context
    237242 */
    238 VMMR0DECL(int) CPUMR0SaveGuestFPU(PVM pVM, PCPUMCTX pCtx)
     243VMMR0DECL(int) CPUMR0SaveGuestFPU(PVM pVM, PVMCPU pVCpu, PCPUMCTX pCtx)
    239244{
    240245    Assert(pVM->cpum.s.CPUFeatures.edx.u1FXSR);
    241246    Assert(ASMGetCR4() & X86_CR4_OSFSXR);
    242     AssertReturn((pVM->cpum.s.fUseFlags & CPUM_USED_FPU), VINF_SUCCESS);
     247    AssertReturn((pVCpu->cpum.s.fUseFlags & CPUM_USED_FPU), VINF_SUCCESS);
    243248
    244249#ifndef CPUM_CAN_HANDLE_NM_TRAPS_IN_KERNEL_MODE
    … …  
    246251
    247252    /* Clear MSR_K6_EFER_FFXSR or else we'll be unable to save/restore the XMM state with fxsave/fxrstor. */
    248     if (pVM->cpum.s.fUseFlags & CPUM_MANUAL_XMM_RESTORE)
     253    if (pVCpu->cpum.s.fUseFlags & CPUM_MANUAL_XMM_RESTORE)
    249254    {
    250255        oldMsrEFERHost = ASMRdMsr(MSR_K6_EFER);
    251256        ASMWrMsr(MSR_K6_EFER, oldMsrEFERHost & ~MSR_K6_EFER_FFXSR);
    252257    }
    253     CPUMRestoreHostFPUState(pVM);
     258    CPUMRestoreHostFPUState(pVM, pVCpu);
    254259
    255260    /* Restore EFER MSR */
    256     if (pVM->cpum.s.fUseFlags & CPUM_MANUAL_XMM_RESTORE)
     261    if (pVCpu->cpum.s.fUseFlags & CPUM_MANUAL_XMM_RESTORE)
    257262        ASMWrMsr(MSR_K6_EFER, oldMsrEFERHost | MSR_K6_EFER_FFXSR);
    258263
    259264#else  /* CPUM_CAN_HANDLE_NM_TRAPS_IN_KERNEL_MODE */
    260265    CPUMSaveFPUAsm(pCtx);
    261     if (pVM->cpum.s.fUseFlags & CPUM_MANUAL_XMM_RESTORE)
     266    if (pVCpu->cpum.s.fUseFlags & CPUM_MANUAL_XMM_RESTORE)
    262267    {
    263268        /* fxsave doesn't save the XMM state! */
    … …  
    269274     * We don't want the guest to be able to trigger floating point/SSE exceptions on the host.
    270275     */
    271     CPUMSetFCW(pVM->cpum.s.Host.fpu.FCW);
     276    CPUMSetFCW(pVCpu->cpum.s.Host.fpu.FCW);
    272277    if (pVM->cpum.s.CPUFeatures.edx.u1SSE)
    273         CPUMSetMXCSR(pVM->cpum.s.Host.fpu.MXCSR);
     278        CPUMSetMXCSR(pVCpu->cpum.s.Host.fpu.MXCSR);
    274279#endif /* CPUM_CAN_HANDLE_NM_TRAPS_IN_KERNEL_MODE */
    275280
    276     pVM->cpum.s.fUseFlags &= ~(CPUM_USED_FPU | CPUM_MANUAL_XMM_RESTORE);
     281    pVCpu->cpum.s.fUseFlags &= ~(CPUM_USED_FPU | CPUM_MANUAL_XMM_RESTORE);
    277282    return VINF_SUCCESS;
    278283}
    … …  
    284289 * @returns VBox status code.
    285290 * @param   pVM         VM handle.
     291 * @param   pVCpu       VMCPU handle.
    286292 * @param   pCtx        CPU context
    287293 * @param   fDR6        Include DR6 or not
    288294 */
    289 VMMR0DECL(int) CPUMR0SaveGuestDebugState(PVM pVM, PCPUMCTX pCtx, bool fDR6)
    290 {
    291     Assert(pVM->cpum.s.fUseFlags & CPUM_USE_DEBUG_REGS);
     295VMMR0DECL(int) CPUMR0SaveGuestDebugState(PVM pVM, PVMCPU pVCpu, PCPUMCTX pCtx, bool fDR6)
     296{
     297    Assert(pVCpu->cpum.s.fUseFlags & CPUM_USE_DEBUG_REGS);
    292298
    293299    /* Save the guest's debug state. The caller is responsible for DR7. */
    … …  
    303309     * DR7 contains 0x400 right now.
    304310     */
    305     ASMSetDR0(pVM->cpum.s.Host.dr0);
    306     ASMSetDR1(pVM->cpum.s.Host.dr1);
    307     ASMSetDR2(pVM->cpum.s.Host.dr2);
    308     ASMSetDR3(pVM->cpum.s.Host.dr3);
    309     ASMSetDR6(pVM->cpum.s.Host.dr6);
    310     ASMSetDR7(pVM->cpum.s.Host.dr7);
    311 
    312     pVM->cpum.s.fUseFlags &= ~CPUM_USE_DEBUG_REGS;
     311    ASMSetDR0(pVCpu->cpum.s.Host.dr0);
     312    ASMSetDR1(pVCpu->cpum.s.Host.dr1);
     313    ASMSetDR2(pVCpu->cpum.s.Host.dr2);
     314    ASMSetDR3(pVCpu->cpum.s.Host.dr3);
     315    ASMSetDR6(pVCpu->cpum.s.Host.dr6);
     316    ASMSetDR7(pVCpu->cpum.s.Host.dr7);
     317
     318    pVCpu->cpum.s.fUseFlags &= ~CPUM_USE_DEBUG_REGS;
    313319    return VINF_SUCCESS;
    314320}
    … …  
    320326 * @returns VBox status code.
    321327 * @param   pVM         VM handle.
     328 * @param   pVCpu       VMCPU handle.
    322329 * @param   pCtx        CPU context
    323330 * @param   fDR6        Include DR6 or not
    324331 */
    325 VMMR0DECL(int) CPUMR0LoadGuestDebugState(PVM pVM, PCPUMCTX pCtx, bool fDR6)
     332VMMR0DECL(int) CPUMR0LoadGuestDebugState(PVM pVM, PVMCPU pVCpu, PCPUMCTX pCtx, bool fDR6)
    326333{
    327334    /* Save the host state. */
    328     pVM->cpum.s.Host.dr0 = ASMGetDR0();
    329     pVM->cpum.s.Host.dr1 = ASMGetDR1();
    330     pVM->cpum.s.Host.dr2 = ASMGetDR2();
    331     pVM->cpum.s.Host.dr3 = ASMGetDR3();
    332     pVM->cpum.s.Host.dr6 = ASMGetDR6();
     335    pVCpu->cpum.s.Host.dr0 = ASMGetDR0();
     336    pVCpu->cpum.s.Host.dr1 = ASMGetDR1();
     337    pVCpu->cpum.s.Host.dr2 = ASMGetDR2();
     338    pVCpu->cpum.s.Host.dr3 = ASMGetDR3();
     339    pVCpu->cpum.s.Host.dr6 = ASMGetDR6();
    333340    /** @todo dr7 might already have been changed to 0x400; don't care right now as it's harmless. */
    334     pVM->cpum.s.Host.dr7 = ASMGetDR7();
     341    pVCpu->cpum.s.Host.dr7 = ASMGetDR7();
    335342    /* Make sure DR7 is harmless or else we could trigger breakpoints when restoring dr0-3 (!) */
    336343    ASMSetDR7(X86_DR7_INIT_VAL);
    … …  
    344351        ASMSetDR6(pCtx->dr[6]);
    345352
    346     pVM->cpum.s.fUseFlags |= CPUM_USE_DEBUG_REGS;
    347     return VINF_SUCCESS;
    348 }
    349 
     353    pVCpu->cpum.s.fUseFlags |= CPUM_USE_DEBUG_REGS;
     354    return VINF_SUCCESS;
     355}
     356

  • trunk/src/VBox/VMM/VMMR0/HWACCMR0.cpp

    r13898 r13960  
    889889    ASMAtomicWriteBool(&pCpu->fInUse, true);
    890890
    891     pCtx = CPUMQueryGuestCtxPtr(pVM);
     891    pCtx = CPUMQueryGuestCtxPtrEx(pVM, pVCpu);
    892892
    893893    /* Always load the guest's FPU/XMM state on-demand. */
    … …  
    942942    AssertReturn(!ASMAtomicReadBool(&HWACCMR0Globals.fSuspended), VERR_HWACCM_SUSPEND_PENDING);
    943943
    944     pCtx = CPUMQueryGuestCtxPtr(pVM);
     944    pCtx = CPUMQueryGuestCtxPtrEx(pVM, pVCpu);
    945945
    946946    /* Note:  It's rather tricky with longjmps done by e.g. Log statements or the page fault handler.
    … …  
    949949     */
    950950    /* Save the guest FPU and XMM state if necessary. */
    951     if (CPUMIsGuestFPUStateActive(pVM))
     951    if (CPUMIsGuestFPUStateActive(pVCpu))
    952952    {
    953953        Log2(("CPUMR0SaveGuestFPU\n"));
    954         CPUMR0SaveGuestFPU(pVM, pCtx);
     954        CPUMR0SaveGuestFPU(pVM, pVCpu, pCtx);
    955955
    956956        pVCpu->hwaccm.s.fContextUseFlags |= HWACCM_CHANGED_GUEST_CR0;
    … …  
    989989    Assert(ASMAtomicReadBool(&pCpu->fInUse) == true);
    990990
    991     pCtx = CPUMQueryGuestCtxPtr(pVM);
     991    pCtx = CPUMQueryGuestCtxPtrEx(pVM, pVCpu);
    992992
    993993    return HWACCMR0Globals.pfnRunGuestCode(pVM, pVCpu, pCtx);

  • trunk/src/VBox/VMM/VMMR0/HWSVMR0.cpp

    r13905 r13960  
    608608    {
    609609        val = pCtx->cr0;
    610         if (!CPUMIsGuestFPUStateActive(pVM))
     610        if (!CPUMIsGuestFPUStateActive(pVCpu))
    611611        {
    612612            /* Always use #NM exceptions to load the FPU/XMM state on demand. */
    … …  
    723723
    724724            /* Save the host and load the guest debug state. */
    725             int rc = CPUMR0LoadGuestDebugState(pVM, pCtx, false /* exclude DR6 */);
     725            int rc = CPUMR0LoadGuestDebugState(pVM, pVCpu, pCtx, false /* exclude DR6 */);
    726726            AssertRC(rc);
    727727        }
    … …  
    13291329            /** @todo don't intercept #NM exceptions anymore when we've activated the guest FPU state. */
    13301330            /* If we sync the FPU/XMM state on-demand, then we can continue execution as if nothing has happened. */
    1331             rc = CPUMR0LoadGuestFPU(pVM, pCtx);
     1331            rc = CPUMR0LoadGuestFPU(pVM, pVCpu, pCtx);
    13321332            if (rc == VINF_SUCCESS)
    13331333            {
    1334                 Assert(CPUMIsGuestFPUStateActive(pVM));
     1334                Assert(CPUMIsGuestFPUStateActive(pVCpu));
    13351335                STAM_COUNTER_INC(&pVCpu->hwaccm.s.StatExitShadowNM);
    13361336
    … …  
    17231723
    17241724            /* Save the host and load the guest debug state. */
    1725             rc = CPUMR0LoadGuestDebugState(pVM, pCtx, false /* exclude DR6 */);
     1725            rc = CPUMR0LoadGuestDebugState(pVM, pVCpu, pCtx, false /* exclude DR6 */);
    17261726            AssertRC(rc);
    17271727
    … …  
    17631763
    17641764            /* Save the host and load the guest debug state. */
    1765             rc = CPUMR0LoadGuestDebugState(pVM, pCtx, false /* exclude DR6 */);
     1765            rc = CPUMR0LoadGuestDebugState(pVM, pVCpu, pCtx, false /* exclude DR6 */);
    17661766            AssertRC(rc);
    17671767
    … …  
    20942094    if (CPUMIsGuestDebugStateActive(pVM))
    20952095    {
    2096         CPUMR0SaveGuestDebugState(pVM, pCtx, false /* skip DR6 */);
     2096        CPUMR0SaveGuestDebugState(pVM, pVCpu, pCtx, false /* skip DR6 */);
    20972097
    20982098        /* Intercept all DRx reads and writes again. Changed later on. */

  • trunk/src/VBox/VMM/VMMR0/HWVMXR0.cpp

    r13909 r13960  
    921921
    922922    /* Also catch floating point exceptions as we need to report them to the guest in a different way. */
    923     if (    CPUMIsGuestFPUStateActive(pVM) == true
     923    if (    CPUMIsGuestFPUStateActive(pVCpu) == true
    924924        && !(pCtx->cr0 & X86_CR0_NE)
    925925        && !pVCpu->hwaccm.s.fFPUOldStyleOverride)
    … …  
    11301130        rc  = VMXWriteVMCS(VMX_VMCS_CTRL_CR0_READ_SHADOW,   val);
    11311131        Log2(("Guest CR0-shadow %08x\n", val));
    1132         if (CPUMIsGuestFPUStateActive(pVM) == false)
     1132        if (CPUMIsGuestFPUStateActive(pVCpu) == false)
    11331133        {
    11341134            /* Always use #NM exceptions to load the FPU/XMM state on demand. */
    … …  
    13391339
    13401340            /* Save the host and load the guest debug state. */
    1341             rc = CPUMR0LoadGuestDebugState(pVM, pCtx, true /* include DR6 */);
     1341            rc = CPUMR0LoadGuestDebugState(pVM, pVCpu, pCtx, true /* include DR6 */);
    13421342            AssertRC(rc);
    13431343        }
    … …  
    20812081                /** @todo don't intercept #NM exceptions anymore when we've activated the guest FPU state. */
    20822082                /* If we sync the FPU/XMM state on-demand, then we can continue execution as if nothing has happened. */
    2083                 rc = CPUMR0LoadGuestFPU(pVM, pCtx);
     2083                rc = CPUMR0LoadGuestFPU(pVM, pVCpu, pCtx);
    20842084                if (rc == VINF_SUCCESS)
    20852085                {
    2086                     Assert(CPUMIsGuestFPUStateActive(pVM));
     2086                    Assert(CPUMIsGuestFPUStateActive(pVCpu));
    20872087
    20882088                    STAM_COUNTER_INC(&pVCpu->hwaccm.s.StatExitShadowNM);
    … …  
    25922592
    25932593            /* Save the host and load the guest debug state. */
    2594             rc = CPUMR0LoadGuestDebugState(pVM, pCtx, true /* include DR6 */);
     2594            rc = CPUMR0LoadGuestDebugState(pVM, pVCpu, pCtx, true /* include DR6 */);
    25952595            AssertRC(rc);
    25962596
    … …  
    30283028    if (CPUMIsGuestDebugStateActive(pVM))
    30293029    {
    3030         CPUMR0SaveGuestDebugState(pVM, pCtx, true /* save DR6 */);
     3030        CPUMR0SaveGuestDebugState(pVM, pVCpu, pCtx, true /* save DR6 */);
    30313031
    30323032        /* Enable drx move intercepts again. */

  • trunk/src/VBox/VMM/VMMSwitcher/AMD64ToPAE.asm

    r12602 r13960  
    198198;
    199199; USES/DESTROYS:
    200 ;       - eax, ecx, edx
     200;       - eax, ecx, edx, r8
    201201;
    202202; ASSUMPTION:
    … …  
    206206ALIGNCODE(16)
    207207BEGINPROC vmmR0HostToGuestAsm
     208    ;; Store the offset from CPUM to CPUMCPU in r8
     209    mov     r8, [rdx + CPUM.ulOffCPUMCPU]
     210   
    208211    ;;
    209212    ;; Save CPU host context
    … …  
    211214    ;;
    212215    ; general registers.
    213     ; mov     [rdx + CPUM.Host.rax], rax - scratch
    214     mov     [rdx + CPUM.Host.rbx], rbx
    215     ; mov     [rdx + CPUM.Host.rcx], rcx - scratch
    216     ; mov     [rdx + CPUM.Host.rdx], rdx - scratch
    217     mov     [rdx + CPUM.Host.rdi], rdi
    218     mov     [rdx + CPUM.Host.rsi], rsi
    219     mov     [rdx + CPUM.Host.rsp], rsp
    220     mov     [rdx + CPUM.Host.rbp], rbp
    221     ; mov     [rdx + CPUM.Host.r8 ], r8 - scratch
    222     ; mov     [rdx + CPUM.Host.r9 ], r9 - scratch
    223     mov     [rdx + CPUM.Host.r10], r10
    224     mov     [rdx + CPUM.Host.r11], r11
    225     mov     [rdx + CPUM.Host.r12], r12
    226     mov     [rdx + CPUM.Host.r13], r13
    227     mov     [rdx + CPUM.Host.r14], r14
    228     mov     [rdx + CPUM.Host.r15], r15
     216    ; mov     [rdx + r8 + CPUMCPU.Host.rax], rax - scratch
     217    mov     [rdx + r8 + CPUMCPU.Host.rbx], rbx
     218    ; mov     [rdx + r8 + CPUMCPU.Host.rcx], rcx - scratch
     219    ; mov     [rdx + r8 + CPUMCPU.Host.rdx], rdx - scratch
     220    mov     [rdx + r8 + CPUMCPU.Host.rdi], rdi
     221    mov     [rdx + r8 + CPUMCPU.Host.rsi], rsi
     222    mov     [rdx + r8 + CPUMCPU.Host.rsp], rsp
     223    mov     [rdx + r8 + CPUMCPU.Host.rbp], rbp
     224    ; mov     [rdx + r8 + CPUMCPU.Host.r8 ], r8 - scratch
     225    ; mov     [rdx + r8 + CPUMCPU.Host.r9 ], r9 - scratch
     226    mov     [rdx + r8 + CPUMCPU.Host.r10], r10
     227    mov     [rdx + r8 + CPUMCPU.Host.r11], r11
     228    mov     [rdx + r8 + CPUMCPU.Host.r12], r12
     229    mov     [rdx + r8 + CPUMCPU.Host.r13], r13
     230    mov     [rdx + r8 + CPUMCPU.Host.r14], r14
     231    mov     [rdx + r8 + CPUMCPU.Host.r15], r15
    229232    ; selectors.
    230     mov     [rdx + CPUM.Host.ds], ds
    231     mov     [rdx + CPUM.Host.es], es
    232     mov     [rdx + CPUM.Host.fs], fs
    233     mov     [rdx + CPUM.Host.gs], gs
    234     mov     [rdx + CPUM.Host.ss], ss
     233    mov     [rdx + r8 + CPUMCPU.Host.ds], ds
     234    mov     [rdx + r8 + CPUMCPU.Host.es], es
     235    mov     [rdx + r8 + CPUMCPU.Host.fs], fs
     236    mov     [rdx + r8 + CPUMCPU.Host.gs], gs
     237    mov     [rdx + r8 + CPUMCPU.Host.ss], ss
    235238    ; MSRs
    236239    mov     rbx, rdx
    237240    mov     ecx, MSR_K8_FS_BASE
    238241    rdmsr
    239     mov     [rbx + CPUM.Host.FSbase], eax
    240     mov     [rbx + CPUM.Host.FSbase + 4], edx
     242    mov     [rbx + r8 + CPUMCPU.Host.FSbase], eax
     243    mov     [rbx + r8 + CPUMCPU.Host.FSbase + 4], edx
    241244    mov     ecx, MSR_K8_GS_BASE
    242245    rdmsr
    243     mov     [rbx + CPUM.Host.GSbase], eax
    244     mov     [rbx + CPUM.Host.GSbase + 4], edx
     246    mov     [rbx + r8 + CPUMCPU.Host.GSbase], eax
     247    mov     [rbx + r8 + CPUMCPU.Host.GSbase + 4], edx
    245248    mov     ecx, MSR_K6_EFER
    246249    rdmsr
    247     mov     [rbx + CPUM.Host.efer], eax
    248     mov     [rbx + CPUM.Host.efer + 4], edx
     250    mov     [rbx + r8 + CPUMCPU.Host.efer], eax
     251    mov     [rbx + r8 + CPUMCPU.Host.efer + 4], edx
    249252    mov     ecx, MSR_K6_EFER
    250253    mov     rdx, rbx
    251254    ; special registers.
    252     sldt    [rdx + CPUM.Host.ldtr]
    253     sidt    [rdx + CPUM.Host.idtr]
    254     sgdt    [rdx + CPUM.Host.gdtr]
    255     str     [rdx + CPUM.Host.tr]        ; yasm BUG, generates sldt. YASMCHECK!
     255    sldt    [rdx + r8 + CPUMCPU.Host.ldtr]
     256    sidt    [rdx + r8 + CPUMCPU.Host.idtr]
     257    sgdt    [rdx + r8 + CPUMCPU.Host.gdtr]
     258    str     [rdx + r8 + CPUMCPU.Host.tr]        ; yasm BUG, generates sldt. YASMCHECK!
    256259    ; flags
    257260    pushf
    258     pop     qword [rdx + CPUM.Host.rflags]
     261    pop     qword [rdx + r8 + CPUMCPU.Host.rflags]
    259262
    260263    FIXUP FIX_NO_SYSENTER_JMP, 0, htg_no_sysenter - NAME(Start) ; this will insert a jmp htg_no_sysenter if host doesn't use sysenter.
    … …  
    263266    mov     rbx, rdx                    ; save edx
    264267    rdmsr                               ; edx:eax <- MSR[ecx]
    265     mov     [rbx + CPUM.Host.SysEnter.cs], rax
    266     mov     [rbx + CPUM.Host.SysEnter.cs + 4], rdx
     268    mov     [rbx + r8 + CPUMCPU.Host.SysEnter.cs], rax
     269    mov     [rbx + r8 + CPUMCPU.Host.SysEnter.cs + 4], rdx
    267270    xor     rax, rax                    ; load 0:0 to cause #GP upon sysenter
    268271    xor     rdx, rdx
    … …  
    275278
    276279    ;; handle use flags.
    277     mov     esi, [rdx + CPUM.fUseFlags] ; esi == use flags.
     280    mov     esi, [rdx + r8 + CPUMCPU.fUseFlags] ; esi == use flags.
    278281    and     esi, ~CPUM_USED_FPU   ; Clear CPUM_USED_* flags. ;;@todo FPU check can be optimized to use cr0 flags!
    279     mov     [rdx + CPUM.fUseFlags], esi
     282    mov     [rdx + r8 + CPUMCPU.fUseFlags], esi
    280283
    281284    ; debug registers.
    … …  
    288291    ; control registers.
    289292    mov     rax, cr0
    290     mov     [rdx + CPUM.Host.cr0], rax
    291     ;mov     rax, cr2                   ; assume host os don't suff things in cr2. (safe)
    292     ;mov     [rdx + CPUM.Host.cr2], rax
     293    mov     [rdx + r8 + CPUMCPU.Host.cr0], rax
     294    ;mov     rax, cr2                   ; assume host os don't stuff things in cr2. (safe)
     295    ;mov     [rdx + r8 + CPUMCPU.Host.cr2], rax
    293296    mov     rax, cr3
    294     mov     [rdx + CPUM.Host.cr3], rax
     297    mov     [rdx + r8 + CPUMCPU.Host.cr3], rax
    295298    mov     rax, cr4
    296     mov     [rdx + CPUM.Host.cr4], rax
     299    mov     [rdx + r8 + CPUMCPU.Host.cr4], rax
    297300
    298301    ;;
    … …  
    306309    ;
    307310    and     rax, X86_CR4_MCE | X86_CR4_PSE | X86_CR4_PAE
    308     mov     ecx, [rdx + CPUM.Guest.cr4]
     311    mov     ecx, [rdx + r8 + CPUMCPU.Guest.cr4]
    309312    DEBUG_CHAR('b')                     ; trashes esi
    310     ;; @todo Switcher cleanup: Determin base CR4 during CPUMR0Init / VMMR3SelectSwitcher putting it
     313    ;; @todo Switcher cleanup: Determine base CR4 during CPUMR0Init / VMMR3SelectSwitcher putting it
    311314    ;                          in CPUM.Hyper.cr4 (which isn't currently being used). That should
    312315    ;                          simplify this operation a bit (and improve locality of the data).
    … …  
    322325    DEBUG_CHAR('c')                     ; trashes esi
    323326
    324     mov     eax, [rdx + CPUM.Guest.cr0]
     327    mov     eax, [rdx + r8 + CPUMCPU.Guest.cr0]
    325328    and     eax, X86_CR0_EM
    326329    or      eax, X86_CR0_PE | X86_CR0_PG | X86_CR0_TS | X86_CR0_ET | X86_CR0_NE | X86_CR0_MP
    … …  
    360363DEBUG_S_CHAR('s');
    361364    mov     rax, dr7                    ; not sure, but if I read the docs right this will trap if GD is set. FIXME!!!
    362     mov     [rdx + CPUM.Host.dr7], rax
     365    mov     [rdx + r8 + CPUMCPU.Host.dr7], rax
    363366    xor     eax, eax                    ; clear everything. (bit 12? is read as 1...)
    364367    mov     dr7, rax
    365368    mov     rax, dr6                    ; just in case we save the state register too.
    366     mov     [rdx + CPUM.Host.dr6], rax
     369    mov     [rdx + r8 + CPUMCPU.Host.dr6], rax
    367370    ; save host DR0-3?
    368371    test    esi, CPUM_USE_DEBUG_REGS
    … …  
    370373DEBUG_S_CHAR('S');
    371374    mov     rax, dr0
    372     mov     [rdx + CPUM.Host.dr0], rax
     375    mov     [rdx + r8 + CPUMCPU.Host.dr0], rax
    373376    mov     rbx, dr1
    374     mov     [rdx + CPUM.Host.dr1], rbx
     377    mov     [rdx + r8 + CPUMCPU.Host.dr1], rbx
    375378    mov     rcx, dr2
    376     mov     [rdx + CPUM.Host.dr2], rcx
     379    mov     [rdx + r8 + CPUMCPU.Host.dr2], rcx
    377380    mov     rax, dr3
    378     mov     [rdx + CPUM.Host.dr3], rax
     381    mov     [rdx + r8 + CPUMCPU.Host.dr3], rax
    379382    jmp     htg_debug_regs_no
    380383
    … …  
    472475
    473476    ;; use flags.
    474     mov     esi, [edx + CPUM.fUseFlags]
     477    mov     esi, [edx + CPUM.ulOffCPUMCPU]
     478    mov     esi, [edx + esi + CPUMCPU.fUseFlags]
    475479
    476480    ; debug registers
    … …  
    632636    FIXUP FIX_GC_CPUM_OFF, 1, 0
    633637    mov     edx, 0ffffffffh
    634 
     638    ; Convert to CPUMCPU pointer
     639    add     edx, [edx + CPUM.ulOffCPUMCPU]
     640   
    635641    ; Skip return address (assumes called!)
    636642    lea     esp, [esp + 4]
    … …  
    642648    push    eax                         ; save return code.
    643649    mov     eax, [esp + 4 + CPUMCTXCORE.edi]
    644     mov     [edx + CPUM.Guest.edi], eax
     650    mov     [edx + CPUMCPU.Guest.edi], eax
    645651    mov     eax, [esp + 4 + CPUMCTXCORE.esi]
    646     mov     [edx + CPUM.Guest.esi], eax
     652    mov     [edx + CPUMCPU.Guest.esi], eax
    647653    mov     eax, [esp + 4 + CPUMCTXCORE.ebp]
    648     mov     [edx + CPUM.Guest.ebp], eax
     654    mov     [edx + CPUMCPU.Guest.ebp], eax
    649655    mov     eax, [esp + 4 + CPUMCTXCORE.eax]
    650     mov     [edx + CPUM.Guest.eax], eax
     656    mov     [edx + CPUMCPU.Guest.eax], eax
    651657    mov     eax, [esp + 4 + CPUMCTXCORE.ebx]
    652     mov     [edx + CPUM.Guest.ebx], eax
     658    mov     [edx + CPUMCPU.Guest.ebx], eax
    653659    mov     eax, [esp + 4 + CPUMCTXCORE.edx]
    654     mov     [edx + CPUM.Guest.edx], eax
     660    mov     [edx + CPUMCPU.Guest.edx], eax
    655661    mov     eax, [esp + 4 + CPUMCTXCORE.ecx]
    656     mov     [edx + CPUM.Guest.ecx], eax
     662    mov     [edx + CPUMCPU.Guest.ecx], eax
    657663    mov     eax, [esp + 4 + CPUMCTXCORE.esp]
    658     mov     [edx + CPUM.Guest.esp], eax
     664    mov     [edx + CPUMCPU.Guest.esp], eax
    659665    ; selectors
    660666    mov     eax, [esp + 4 + CPUMCTXCORE.ss]
    661     mov     [edx + CPUM.Guest.ss], eax
     667    mov     [edx + CPUMCPU.Guest.ss], eax
    662668    mov     eax, [esp + 4 + CPUMCTXCORE.gs]
    663     mov     [edx + CPUM.Guest.gs], eax
     669    mov     [edx + CPUMCPU.Guest.gs], eax
    664670    mov     eax, [esp + 4 + CPUMCTXCORE.fs]
    665     mov     [edx + CPUM.Guest.fs], eax
     671    mov     [edx + CPUMCPU.Guest.fs], eax
    666672    mov     eax, [esp + 4 + CPUMCTXCORE.es]
    667     mov     [edx + CPUM.Guest.es], eax
     673    mov     [edx + CPUMCPU.Guest.es], eax
    668674    mov     eax, [esp + 4 + CPUMCTXCORE.ds]
    669     mov     [edx + CPUM.Guest.ds], eax
     675    mov     [edx + CPUMCPU.Guest.ds], eax
    670676    mov     eax, [esp + 4 + CPUMCTXCORE.cs]
    671     mov     [edx + CPUM.Guest.cs], eax
     677    mov     [edx + CPUMCPU.Guest.cs], eax
    672678    ; flags
    673679    mov     eax, [esp + 4 + CPUMCTXCORE.eflags]
    674     mov     [edx + CPUM.Guest.eflags], eax
     680    mov     [edx + CPUMCPU.Guest.eflags], eax
    675681    ; eip
    676682    mov     eax, [esp + 4 + CPUMCTXCORE.eip]
    677     mov     [edx + CPUM.Guest.eip], eax
     683    mov     [edx + CPUMCPU.Guest.eip], eax
    678684    ; jump to common worker code.
    679685    pop     eax                         ; restore return code.
     686    ; Load CPUM into edx again
     687    sub     edx, [edx + CPUMCPU.ulOffCPUM]
    680688
    681689    add     esp, CPUMCTXCORE_size      ; skip CPUMCTXCORE structure
    … …  
    913921
    914922    ; load final cr3
    915     mov     rsi, [rdx + CPUM.Host.cr3]
     923    mov     rsi, [rdx + r8 + CPUMCPU.Host.cr3]
    916924    mov     cr3, rsi
    917925    DEBUG_CHAR('@')
    … …  
    922930    ; Load CPUM pointer into edx
    923931    mov     rdx, [NAME(pCpumHC) wrt rip]
     932    ; Load the CPUMCPU offset.
     933    mov     r8, [rdx + CPUM.ulOffCPUMCPU]
     934   
    924935    ; activate host gdt and idt
    925     lgdt    [rdx + CPUM.Host.gdtr]
     936    lgdt    [rdx + r8 + CPUMCPU.Host.gdtr]
    926937    DEBUG_CHAR('0')
    927     lidt    [rdx + CPUM.Host.idtr]
     938    lidt    [rdx + r8 + CPUMCPU.Host.idtr]
    928939    DEBUG_CHAR('1')
    929940    ; Restore TSS selector; must mark it as not busy before using ltr (!)
    930941%if 1 ; ASSUME that this is supposed to be 'BUSY'. (saves 20-30 ticks on the T42p)
    931     movzx   eax, word [rdx + CPUM.Host.tr]          ; eax <- TR
     942    movzx   eax, word [rdx + r8 + CPUMCPU.Host.tr]          ; eax <- TR
    932943    and     al, 0F8h                                ; mask away TI and RPL bits, get descriptor offset.
    933     add     rax, [rdx + CPUM.Host.gdtr + 2]         ; eax <- GDTR.address + descriptor offset.
     944    add     rax, [rdx + r8 + CPUMCPU.Host.gdtr + 2]         ; eax <- GDTR.address + descriptor offset.
    934945    and     dword [rax + 4], ~0200h                 ; clear busy flag (2nd type2 bit)
    935     ltr     word [rdx + CPUM.Host.tr]
     946    ltr     word [rdx + r8 + CPUMCPU.Host.tr]
    936947%else
    937     movzx   eax, word [rdx + CPUM.Host.tr]          ; eax <- TR
     948    movzx   eax, word [rdx + r8 + CPUMCPU.Host.tr]          ; eax <- TR
    938949    and     al, 0F8h                                ; mask away TI and RPL bits, get descriptor offset.
    939     add     rax, [rdx + CPUM.Host.gdtr + 2]         ; eax <- GDTR.address + descriptor offset.
     950    add     rax, [rdx + r8 + CPUMCPU.Host.gdtr + 2]         ; eax <- GDTR.address + descriptor offset.
    940951    mov     ecx, [rax + 4]                          ; ecx <- 2nd descriptor dword
    941952    mov     ebx, ecx                                ; save orginal value
    942953    and     ecx, ~0200h                             ; clear busy flag (2nd type2 bit)
    943954    mov     [rax + 4], ccx                          ; not using xchg here is paranoia..
    944     ltr     word [rdx + CPUM.Host.tr]
     955    ltr     word [rdx + r8 + CPUMCPU.Host.tr]
    945956    xchg    [rax + 4], ebx                          ; using xchg is paranoia too...
    946957%endif
    947958    ; activate ldt
    948959    DEBUG_CHAR('2')
    949     lldt    [rdx + CPUM.Host.ldtr]
     960    lldt    [rdx + r8 + CPUMCPU.Host.ldtr]
    950961    ; Restore segment registers
    951     mov     eax, [rdx + CPUM.Host.ds]
     962    mov     eax, [rdx + r8 + CPUMCPU.Host.ds]
    952963    mov     ds, eax
    953     mov     eax, [rdx + CPUM.Host.es]
     964    mov     eax, [rdx + r8 + CPUMCPU.Host.es]
    954965    mov     es, eax
    955     mov     eax, [rdx + CPUM.Host.fs]
     966    mov     eax, [rdx + r8 + CPUMCPU.Host.fs]
    956967    mov     fs, eax
    957     mov     eax, [rdx + CPUM.Host.gs]
     968    mov     eax, [rdx + r8 + CPUMCPU.Host.gs]
    958969    mov     gs, eax
    959970    ; restore stack
    960     mov     eax, [rdx + CPUM.Host.ss]
     971    mov     eax, [rdx + r8 + CPUMCPU.Host.ss]
    961972    mov     ss, eax
    962     mov     rsp, [rdx + CPUM.Host.rsp]
     973    mov     rsp, [rdx + r8 + CPUMCPU.Host.rsp]
    963974
    964975    FIXUP FIX_NO_SYSENTER_JMP, 0, gth_sysenter_no - NAME(Start) ; this will insert a jmp gth_sysenter_no if host doesn't use sysenter.
    965976    ; restore MSR_IA32_SYSENTER_CS register.
    966977    mov     ecx, MSR_IA32_SYSENTER_CS
    967     mov     eax, [rdx + CPUM.Host.SysEnter.cs]
    968     mov     ebx, [rdx + CPUM.Host.SysEnter.cs + 4]
     978    mov     eax, [rdx + r8 + CPUMCPU.Host.SysEnter.cs]
     979    mov     ebx, [rdx + r8 + CPUMCPU.Host.SysEnter.cs + 4]
    969980    mov     rbx, rdx                    ; save/load edx
    970981    wrmsr                               ; MSR[ecx] <- edx:eax
    … …  
    979990    ; Restore FPU if guest has used it.
    980991    ; Using fxrstor should ensure that we're not causing unwanted exception on the host.
    981     mov     esi, [rdx + CPUM.fUseFlags] ; esi == use flags.
     992    mov     esi, [rdx + r8 + CPUMCPU.fUseFlags] ; esi == use flags.
    982993    test    esi, CPUM_USED_FPU
    983994    jz short gth_fpu_no
    … …  
    986997    mov     cr0, rcx
    987998
    988     fxsave  [rdx + CPUM.Guest.fpu]
    989     fxrstor [rdx + CPUM.Host.fpu]
     999    fxsave  [rdx + r8 + CPUMCPU.Guest.fpu]
     1000    fxrstor [rdx + r8 + CPUMCPU.Host.fpu]
    9901001    jmp short gth_fpu_no
    9911002
    … …  
    9961007    ; Would've liked to have these highere up in case of crashes, but
    9971008    ; the fpu stuff must be done before we restore cr0.
    998     mov     rcx, [rdx + CPUM.Host.cr4]
     1009    mov     rcx, [rdx + r8 + CPUMCPU.Host.cr4]
    9991010    mov     cr4, rcx
    1000     mov     rcx, [rdx + CPUM.Host.cr0]
     1011    mov     rcx, [rdx + r8 + CPUMCPU.Host.cr0]
    10011012    mov     cr0, rcx
    1002     ;mov     rcx, [rdx + CPUM.Host.cr2] ; assumes this is waste of time.
     1013    ;mov     rcx, [rdx + r8 + CPUMCPU.Host.cr2] ; assumes this is waste of time.
    10031014    ;mov     cr2, rcx
    10041015
    … …  
    10131024    mov     rbx, rdx
    10141025    mov     ecx, MSR_K8_FS_BASE
    1015     mov     eax, [rbx + CPUM.Host.FSbase]
    1016     mov     edx, [rbx + CPUM.Host.FSbase + 4]
     1026    mov     eax, [rbx + r8 + CPUMCPU.Host.FSbase]
     1027    mov     edx, [rbx + r8 + CPUMCPU.Host.FSbase + 4]
    10171028    wrmsr
    10181029    mov     ecx, MSR_K8_GS_BASE
    1019     mov     eax, [rbx + CPUM.Host.GSbase]
    1020     mov     edx, [rbx + CPUM.Host.GSbase + 4]
     1030    mov     eax, [rbx + r8 + CPUMCPU.Host.GSbase]
     1031    mov     edx, [rbx + r8 + CPUMCPU.Host.GSbase + 4]
    10211032    wrmsr
    10221033    mov     ecx, MSR_K6_EFER
    1023     mov     eax, [rbx + CPUM.Host.efer]
    1024     mov     edx, [rbx + CPUM.Host.efer + 4]
     1034    mov     eax, [rbx + r8 + CPUMCPU.Host.efer]
     1035    mov     edx, [rbx + r8 + CPUMCPU.Host.efer + 4]
    10251036    wrmsr
    10261037    mov     rdx, rbx
    … …  
    10291040    ; restore general registers.
    10301041    mov     eax, edi                    ; restore return code. eax = return code !!
    1031     ; mov     rax, [rdx + CPUM.Host.rax] - scratch + return code
    1032     mov     rbx, [rdx + CPUM.Host.rbx]
    1033     ; mov     rcx, [rdx + CPUM.Host.rcx] - scratch
    1034     ; mov     rdx, [rdx + CPUM.Host.rdx] - scratch
    1035     mov     rdi, [rdx + CPUM.Host.rdi]
    1036     mov     rsi, [rdx + CPUM.Host.rsi]
    1037     mov     rsp, [rdx + CPUM.Host.rsp]
    1038     mov     rbp, [rdx + CPUM.Host.rbp]
    1039     ; mov     r8,  [rdx + CPUM.Host.r8 ] - scratch
    1040     ; mov     r9,  [rdx + CPUM.Host.r9 ] - scratch
    1041     mov     r10, [rdx + CPUM.Host.r10]
    1042     mov     r11, [rdx + CPUM.Host.r11]
    1043     mov     r12, [rdx + CPUM.Host.r12]
    1044     mov     r13, [rdx + CPUM.Host.r13]
    1045     mov     r14, [rdx + CPUM.Host.r14]
    1046     mov     r15, [rdx + CPUM.Host.r15]
     1042    ; mov     rax, [rdx + r8 + CPUMCPU.Host.rax] - scratch + return code
     1043    mov     rbx, [rdx + r8 + CPUMCPU.Host.rbx]
     1044    ; mov     rcx, [rdx + r8 + CPUMCPU.Host.rcx] - scratch
     1045    ; mov     rdx, [rdx + r8 + CPUMCPU.Host.rdx] - scratch
     1046    mov     rdi, [rdx + r8 + CPUMCPU.Host.rdi]
     1047    mov     rsi, [rdx + r8 + CPUMCPU.Host.rsi]
     1048    mov     rsp, [rdx + r8 + CPUMCPU.Host.rsp]
     1049    mov     rbp, [rdx + r8 + CPUMCPU.Host.rbp]
     1050    ; mov     r8,  [rdx + r8 + CPUMCPU.Host.r8 ] - scratch
     1051    ; mov     r9,  [rdx + r8 + CPUMCPU.Host.r9 ] - scratch
     1052    mov     r10, [rdx + r8 + CPUMCPU.Host.r10]
     1053    mov     r11, [rdx + r8 + CPUMCPU.Host.r11]
     1054    mov     r12, [rdx + r8 + CPUMCPU.Host.r12]
     1055    mov     r13, [rdx + r8 + CPUMCPU.Host.r13]
     1056    mov     r14, [rdx + r8 + CPUMCPU.Host.r14]
     1057    mov     r15, [rdx + r8 + CPUMCPU.Host.r15]
    10471058
    10481059    ; finally restore flags. (probably not required)
    1049     push    qword [rdx + CPUM.Host.rflags]
     1060    push    qword [rdx + r8 + CPUMCPU.Host.rflags]
    10501061    popf
    10511062
    … …  
    10671078    jz short gth_debug_regs_dr7
    10681079    DEBUG_S_CHAR('r')
    1069     mov     rax, [rdx + CPUM.Host.dr0]
     1080    mov     rax, [rdx + r8 + CPUMCPU.Host.dr0]
    10701081    mov     dr0, rax
    1071     mov     rbx, [rdx + CPUM.Host.dr1]
     1082    mov     rbx, [rdx + r8 + CPUMCPU.Host.dr1]
    10721083    mov     dr1, rbx
    1073     mov     rcx, [rdx + CPUM.Host.dr2]
     1084    mov     rcx, [rdx + r8 + CPUMCPU.Host.dr2]
    10741085    mov     dr2, rcx
    1075     mov     rax, [rdx + CPUM.Host.dr3]
     1086    mov     rax, [rdx + r8 + CPUMCPU.Host.dr3]
    10761087    mov     dr3, rax
    10771088gth_debug_regs_dr7:
    1078     mov     rbx, [rdx + CPUM.Host.dr6]
     1089    mov     rbx, [rdx + r8 + CPUMCPU.Host.dr6]
    10791090    mov     dr6, rbx
    1080     mov     rcx, [rdx + CPUM.Host.dr7]
     1091    mov     rcx, [rdx + r8 + CPUMCPU.Host.dr7]
    10811092    mov     dr7, rcx
    10821093    jmp     gth_debug_regs_no

  • trunk/src/VBox/VMM/VMMSwitcher/PAEand32Bit.mac

    r12602 r13960  
    119119    ;;      Skip eax, edx and ecx as these are not preserved over calls.
    120120    ;;
     121    CPUMCPU_FROM_CPUM(edx)
    121122    ; general registers.
    122     mov     [edx + CPUM.Host.ebx], ebx
    123     mov     [edx + CPUM.Host.edi], edi
    124     mov     [edx + CPUM.Host.esi], esi
    125     mov     [edx + CPUM.Host.esp], esp
    126     mov     [edx + CPUM.Host.ebp], ebp
     123    mov     [edx + CPUMCPU.Host.ebx], ebx
     124    mov     [edx + CPUMCPU.Host.edi], edi
     125    mov     [edx + CPUMCPU.Host.esi], esi
     126    mov     [edx + CPUMCPU.Host.esp], esp
     127    mov     [edx + CPUMCPU.Host.ebp], ebp
    127128    ; selectors.
    128     mov     [edx + CPUM.Host.ds], ds
    129     mov     [edx + CPUM.Host.es], es
    130     mov     [edx + CPUM.Host.fs], fs
    131     mov     [edx + CPUM.Host.gs], gs
    132     mov     [edx + CPUM.Host.ss], ss
     129    mov     [edx + CPUMCPU.Host.ds], ds
     130    mov     [edx + CPUMCPU.Host.es], es
     131    mov     [edx + CPUMCPU.Host.fs], fs
     132    mov     [edx + CPUMCPU.Host.gs], gs
     133    mov     [edx + CPUMCPU.Host.ss], ss
    133134    ; special registers.
    134     sldt    [edx + CPUM.Host.ldtr]
    135     sidt    [edx + CPUM.Host.idtr]
    136     sgdt    [edx + CPUM.Host.gdtr]
    137     str     [edx + CPUM.Host.tr]
     135    sldt    [edx + CPUMCPU.Host.ldtr]
     136    sidt    [edx + CPUMCPU.Host.idtr]
     137    sgdt    [edx + CPUMCPU.Host.gdtr]
     138    str     [edx + CPUMCPU.Host.tr]
    138139    ; flags
    139140    pushfd
    140     pop     dword [edx + CPUM.Host.eflags]
     141    pop     dword [edx + CPUMCPU.Host.eflags]
    141142
    142143    FIXUP FIX_NO_SYSENTER_JMP, 0, htg_no_sysenter - NAME(Start) ; this will insert a jmp htg_no_sysenter if host doesn't use sysenter.
    … …  
    145146    mov     ebx, edx                    ; save edx
    146147    rdmsr                               ; edx:eax <- MSR[ecx]
    147     mov     [ebx + CPUM.Host.SysEnter.cs], eax
    148     mov     [ebx + CPUM.Host.SysEnter.cs + 4], edx
     148    mov     [ebx + CPUMCPU.Host.SysEnter.cs], eax
     149    mov     [ebx + CPUMCPU.Host.SysEnter.cs + 4], edx
    149150    xor     eax, eax                    ; load 0:0 to cause #GP upon sysenter
    150151    xor     edx, edx
    … …  
    157158
    158159    ;; handle use flags.
    159     mov     esi, [edx + CPUM.fUseFlags] ; esi == use flags.
     160    mov     esi, [edx + CPUMCPU.fUseFlags] ; esi == use flags.
    160161    and     esi, ~CPUM_USED_FPU         ; Clear CPUM_USED_* flags. ;;@todo FPU check can be optimized to use cr0 flags!
    161     mov     [edx + CPUM.fUseFlags], esi
     162    mov     [edx + CPUMCPU.fUseFlags], esi
    162163
    163164    ; debug registers.
    … …  
    169170    ; control registers.
    170171    mov     eax, cr0
    171     mov     [edx + CPUM.Host.cr0], eax
     172    mov     [edx + CPUMCPU.Host.cr0], eax
    172173    ;mov     eax, cr2                   ; assume host os don't suff things in cr2. (safe)
    173     ;mov     [edx + CPUM.Host.cr2], eax
     174    ;mov     [edx + CPUMCPU.Host.cr2], eax
    174175    mov     eax, cr3
    175     mov     [edx + CPUM.Host.cr3], eax
     176    mov     [edx + CPUMCPU.Host.cr3], eax
    176177    mov     eax, cr4
    177     mov     [edx + CPUM.Host.cr4], eax
     178    mov     [edx + CPUMCPU.Host.cr4], eax
    178179
    179180    ;;
    … …  
    188189    ;
    189190    and     eax, X86_CR4_MCE | X86_CR4_PSE | X86_CR4_PAE | X86_CR4_VMXE
    190     mov     ecx, [edx + CPUM.Guest.cr4]
     191    mov     ecx, [edx + CPUMCPU.Guest.cr4]
    191192    ;; @todo Switcher cleanup: Determin base CR4 during CPUMR0Init / VMMR3SelectSwitcher putting it
    192193    ;                          in CPUM.Hyper.cr4 (which isn't currently being used). That should
    … …  
    197198    ; FXSAVE support on the host CPU
    198199    ;
     200    CPUM_FROM_CPUMCPU(edx)
    199201    and     ecx, [edx + CPUM.CR4.AndMask]
    200202    or      eax, ecx
    … …  
    202204    mov     cr4, eax
    203205
    204     mov     eax, [edx + CPUM.Guest.cr0]
     206    CPUMCPU_FROM_CPUM(edx)
     207    mov     eax, [edx + CPUMCPU.Guest.cr0]
    205208    and     eax, X86_CR0_EM
    206209    or      eax, X86_CR0_PE | X86_CR0_PG | X86_CR0_TS | X86_CR0_ET | X86_CR0_NE | X86_CR0_MP
    207210    mov     cr0, eax
    208211
     212    CPUM_FROM_CPUMCPU(edx)
    209213    ; Load new gdt so we can do far jump to guest code after cr3 reload.
    210214    lgdt    [edx + CPUM.Hyper.gdtr]
    … …  
    307311    DEBUG_CHAR('7')
    308312
     313    CPUMCPU_FROM_CPUM(edx)
    309314    ;; use flags.
    310     mov     esi, [edx + CPUM.fUseFlags]
     315    mov     esi, [edx + CPUMCPU.fUseFlags]
     316    CPUM_FROM_CPUMCPU(edx)
    311317
    312318    ; debug registers
    … …  
    389395htg_debug_regs_save_dr7and6:
    390396DEBUG_S_CHAR('s');
     397    CPUMCPU_FROM_CPUM(edx)
    391398    mov     eax, dr7                    ; not sure, but if I read the docs right this will trap if GD is set. FIXME!!!
    392     mov     [edx + CPUM.Host.dr7], eax
     399    mov     [edx + CPUMCPU.Host.dr7], eax
    393400    xor     eax, eax                    ; clear everything. (bit 12? is read as 1...)
    394401    mov     dr7, eax
    395402    mov     eax, dr6                    ; just in case we save the state register too.
    396     mov     [edx + CPUM.Host.dr6], eax
     403    mov     [edx + CPUMCPU.Host.dr6], eax
     404    CPUM_FROM_CPUMCPU(edx)
    397405    jmp     htg_debug_regs_no
    398406
    … …  
    404412    DEBUG_S_CHAR('R')
    405413    DEBUG_S_CHAR('x')
     414    CPUMCPU_FROM_CPUM(edx)
    406415    ; save host DR0-3.
    407416    mov     eax, dr0
    408     mov     [edx + CPUM.Host.dr0], eax
     417    mov     [edx + CPUMCPU.Host.dr0], eax
    409418    mov     ebx, dr1
    410     mov     [edx + CPUM.Host.dr1], ebx
     419    mov     [edx + CPUMCPU.Host.dr1], ebx
    411420    mov     ecx, dr2
    412     mov     [edx + CPUM.Host.dr2], ecx
     421    mov     [edx + CPUMCPU.Host.dr2], ecx
    413422    mov     eax, dr3
    414     mov     [edx + CPUM.Host.dr3], eax
     423    mov     [edx + CPUMCPU.Host.dr3], eax
     424    CPUM_FROM_CPUMCPU(edx)
     425   
    415426    ; load hyper DR0-7
    416427    mov     ebx, [edx + CPUM.Hyper.dr]
    … …  
    538549    push    eax
    539550
     551    CPUMCPU_FROM_CPUM(edx)
    540552    mov     eax, [esp + 4 + CPUMCTXCORE.eax]
    541     mov     [edx + CPUM.Guest.eax], eax
     553    mov     [edx + CPUMCPU.Guest.eax], eax
    542554    mov     eax, [esp + 4 + CPUMCTXCORE.ecx]
    543     mov     [edx + CPUM.Guest.ecx], eax
     555    mov     [edx + CPUMCPU.Guest.ecx], eax
    544556    mov     eax, [esp + 4 + CPUMCTXCORE.edx]
    545     mov     [edx + CPUM.Guest.edx], eax
     557    mov     [edx + CPUMCPU.Guest.edx], eax
    546558    mov     eax, [esp + 4 + CPUMCTXCORE.ebx]
    547     mov     [edx + CPUM.Guest.ebx], eax
     559    mov     [edx + CPUMCPU.Guest.ebx], eax
    548560    mov     eax, [esp + 4 + CPUMCTXCORE.esp]
    549     mov     [edx + CPUM.Guest.esp], eax
     561    mov     [edx + CPUMCPU.Guest.esp], eax
    550562    mov     eax, [esp + 4 + CPUMCTXCORE.ebp]
    551     mov     [edx + CPUM.Guest.ebp], eax
     563    mov     [edx + CPUMCPU.Guest.ebp], eax
    552564    mov     eax, [esp + 4 + CPUMCTXCORE.esi]
    553     mov     [edx + CPUM.Guest.esi], eax
     565    mov     [edx + CPUMCPU.Guest.esi], eax
    554566    mov     eax, [esp + 4 + CPUMCTXCORE.edi]
    555     mov     [edx + CPUM.Guest.edi], eax
     567    mov     [edx + CPUMCPU.Guest.edi], eax
    556568    mov     eax, dword [esp + 4 + CPUMCTXCORE.es]
    557     mov     dword [edx + CPUM.Guest.es], eax
     569    mov     dword [edx + CPUMCPU.Guest.es], eax
    558570    mov     eax, dword [esp + 4 + CPUMCTXCORE.cs]
    559     mov     dword [edx + CPUM.Guest.cs], eax
     571    mov     dword [edx + CPUMCPU.Guest.cs], eax
    560572    mov     eax, dword [esp + 4 + CPUMCTXCORE.ss]
    561     mov     dword [edx + CPUM.Guest.ss], eax
     573    mov     dword [edx + CPUMCPU.Guest.ss], eax
    562574    mov     eax, dword [esp + 4 + CPUMCTXCORE.ds]
    563     mov     dword [edx + CPUM.Guest.ds], eax
     575    mov     dword [edx + CPUMCPU.Guest.ds], eax
    564576    mov     eax, dword [esp + 4 + CPUMCTXCORE.fs]
    565     mov     dword [edx + CPUM.Guest.fs], eax
     577    mov     dword [edx + CPUMCPU.Guest.fs], eax
    566578    mov     eax, dword [esp + 4 + CPUMCTXCORE.gs]
    567     mov     dword [edx + CPUM.Guest.gs], eax
     579    mov     dword [edx + CPUMCPU.Guest.gs], eax
    568580    mov     eax, [esp + 4 + CPUMCTXCORE.eflags]
    569     mov     dword [edx + CPUM.Guest.eflags], eax
     581    mov     dword [edx + CPUMCPU.Guest.eflags], eax
    570582    mov     eax, [esp + 4 + CPUMCTXCORE.eip]
    571     mov     dword [edx + CPUM.Guest.eip], eax
     583    mov     dword [edx + CPUMCPU.Guest.eip], eax
    572584    pop     eax
     585    CPUM_FROM_CPUMCPU(edx)
    573586
    574587    add     esp, CPUMCTXCORE_size      ; skip CPUMCTXCORE structure
    … …  
    734747    ;;
    735748    mov     edi, eax                    ; save return code in EDI (careful with COM_DWORD_REG from here on!)
    736     mov     ecx, [edx + CPUM.Host.cr3]
     749    CPUMCPU_FROM_CPUM(edx)
     750    mov     ecx, [edx + CPUMCPU.Host.cr3]
     751    CPUM_FROM_CPUMCPU(edx)
    737752    FIXUP SWITCHER_FIX_INTER_CR3_GC, 1
    738753    mov     eax, 0ffffffffh
    … …  
    803818    FIXUP FIX_HC_CPUM_OFF, 1, 0
    804819    mov     edx, 0ffffffffh
     820    CPUMCPU_FROM_CPUM(edx)
    805821    ; activate host gdt and idt
    806     lgdt    [edx + CPUM.Host.gdtr]
     822    lgdt    [edx + CPUMCPU.Host.gdtr]
    807823    DEBUG_CHAR('0')
    808     lidt    [edx + CPUM.Host.idtr]
     824    lidt    [edx + CPUMCPU.Host.idtr]
    809825    DEBUG_CHAR('1')
    810826    ; Restore TSS selector; must mark it as not busy before using ltr (!)
    811827%if 1 ; ASSUME that this is supposed to be 'BUSY'. (saves 20-30 ticks on the T42p)
    812     movzx   eax, word [edx + CPUM.Host.tr]          ; eax <- TR
     828    movzx   eax, word [edx + CPUMCPU.Host.tr]          ; eax <- TR
    813829    and     al, 0F8h                                ; mask away TI and RPL bits, get descriptor offset.
    814     add     eax, [edx + CPUM.Host.gdtr + 2]         ; eax <- GDTR.address + descriptor offset.
     830    add     eax, [edx + CPUMCPU.Host.gdtr + 2]         ; eax <- GDTR.address + descriptor offset.
    815831    and     dword [eax + 4], ~0200h                 ; clear busy flag (2nd type2 bit)
    816     ltr     word [edx + CPUM.Host.tr]
     832    ltr     word [edx + CPUMCPU.Host.tr]
    817833%else
    818     movzx   eax, word [edx + CPUM.Host.tr]          ; eax <- TR
     834    movzx   eax, word [edx + CPUMCPU.Host.tr]          ; eax <- TR
    819835    and     al, 0F8h                                ; mask away TI and RPL bits, get descriptor offset.
    820     add     eax, [edx + CPUM.Host.gdtr + 2]         ; eax <- GDTR.address + descriptor offset.
     836    add     eax, [edx + CPUMCPU.Host.gdtr + 2]         ; eax <- GDTR.address + descriptor offset.
    821837    mov     ecx, [eax + 4]                          ; ecx <- 2nd descriptor dword
    822838    mov     ebx, ecx                                ; save orginal value
    823839    and     ecx, ~0200h                             ; clear busy flag (2nd type2 bit)
    824840    mov     [eax + 4], ecx                          ; not using xchg here is paranoia..
    825     ltr     word [edx + CPUM.Host.tr]
     841    ltr     word [edx + CPUMCPU.Host.tr]
    826842    xchg    [eax + 4], ebx                          ; using xchg is paranoia too...
    827843%endif
    828844    ; activate ldt
    829845    DEBUG_CHAR('2')
    830     lldt    [edx + CPUM.Host.ldtr]
     846    lldt    [edx + CPUMCPU.Host.ldtr]
    831847    ; Restore segment registers
    832     mov     eax, [edx + CPUM.Host.ds]
     848    mov     eax, [edx + CPUMCPU.Host.ds]
    833849    mov     ds, eax
    834     mov     eax, [edx + CPUM.Host.es]
     850    mov     eax, [edx + CPUMCPU.Host.es]
    835851    mov     es, eax
    836     mov     eax, [edx + CPUM.Host.fs]
     852    mov     eax, [edx + CPUMCPU.Host.fs]
    837853    mov     fs, eax
    838     mov     eax, [edx + CPUM.Host.gs]
     854    mov     eax, [edx + CPUMCPU.Host.gs]
    839855    mov     gs, eax
    840856    ; restore stack
    841     lss     esp, [edx + CPUM.Host.esp]
     857    lss     esp, [edx + CPUMCPU.Host.esp]
    842858
    843859
    … …  
    845861    ; restore MSR_IA32_SYSENTER_CS register.
    846862    mov     ecx, MSR_IA32_SYSENTER_CS
    847     mov     eax, [edx + CPUM.Host.SysEnter.cs]
    848     mov     ebx, [edx + CPUM.Host.SysEnter.cs + 4]
     863    mov     eax, [edx + CPUMCPU.Host.SysEnter.cs]
     864    mov     ebx, [edx + CPUMCPU.Host.SysEnter.cs + 4]
    849865    xchg    edx, ebx                    ; save/load edx
    850866    wrmsr                               ; MSR[ecx] <- edx:eax
    … …  
    859875    ; Restore FPU if guest has used it.
    860876    ; Using fxrstor should ensure that we're not causing unwanted exception on the host.
    861     mov     esi, [edx + CPUM.fUseFlags] ; esi == use flags.
     877    mov     esi, [edx + CPUMCPU.fUseFlags] ; esi == use flags.
    862878    test    esi, CPUM_USED_FPU
    863879    jz near gth_fpu_no
    … …  
    867883
    868884    FIXUP FIX_NO_FXSAVE_JMP, 0, gth_no_fxsave - NAME(Start) ; this will insert a jmp gth_no_fxsave if fxsave isn't supported.
    869     fxsave  [edx + CPUM.Guest.fpu]
    870     fxrstor [edx + CPUM.Host.fpu]
     885    fxsave  [edx + CPUMCPU.Guest.fpu]
     886    fxrstor [edx + CPUMCPU.Host.fpu]
    871887    jmp near gth_fpu_no
    872888
    873889gth_no_fxsave:
    874     fnsave  [edx + CPUM.Guest.fpu]
    875     mov     eax, [edx + CPUM.Host.fpu]     ; control word
     890    fnsave  [edx + CPUMCPU.Guest.fpu]
     891    mov     eax, [edx + CPUMCPU.Host.fpu]     ; control word
    876892    not     eax                            ; 1 means exception ignored (6 LS bits)
    877893    and     eax, byte 03Fh                 ; 6 LS bits only
    878     test    eax, [edx + CPUM.Host.fpu + 4] ; status word
     894    test    eax, [edx + CPUMCPU.Host.fpu + 4] ; status word
    879895    jz      gth_no_exceptions_pending
    880896
    881897    ; technically incorrect, but we certainly don't want any exceptions now!!
    882     and     dword [edx + CPUM.Host.fpu + 4], ~03Fh
     898    and     dword [edx + CPUMCPU.Host.fpu + 4], ~03Fh
    883899
    884900gth_no_exceptions_pending:
    885     frstor  [edx + CPUM.Host.fpu]
     901    frstor  [edx + CPUMCPU.Host.fpu]
    886902    jmp short gth_fpu_no
    887903
    … …  
    892908    ; Would've liked to have these highere up in case of crashes, but
    893909    ; the fpu stuff must be done before we restore cr0.
    894     mov     ecx, [edx + CPUM.Host.cr4]
     910    mov     ecx, [edx + CPUMCPU.Host.cr4]
    895911    mov     cr4, ecx
    896     mov     ecx, [edx + CPUM.Host.cr0]
     912    mov     ecx, [edx + CPUMCPU.Host.cr0]
    897913    mov     cr0, ecx
    898     ;mov     ecx, [edx + CPUM.Host.cr2] ; assumes this is waste of time.
     914    ;mov     ecx, [edx + CPUMCPU.Host.cr2] ; assumes this is waste of time.
    899915    ;mov     cr2, ecx
    900916
    … …  
    908924    ; restore general registers.
    909925    mov     eax, edi                    ; restore return code. eax = return code !!
    910     mov     edi, [edx + CPUM.Host.edi]
    911     mov     esi, [edx + CPUM.Host.esi]
    912     mov     ebx, [edx + CPUM.Host.ebx]
    913     mov     ebp, [edx + CPUM.Host.ebp]
    914     push    dword [edx + CPUM.Host.eflags]
     926    mov     edi, [edx + CPUMCPU.Host.edi]
     927    mov     esi, [edx + CPUMCPU.Host.esi]
     928    mov     ebx, [edx + CPUMCPU.Host.ebx]
     929    mov     ebp, [edx + CPUMCPU.Host.ebp]
     930    push    dword [edx + CPUMCPU.Host.eflags]
    915931    popfd
    916932
    … …  
    930946    jz short gth_debug_regs_dr7
    931947    DEBUG_S_CHAR('r')
    932     mov     eax, [edx + CPUM.Host.dr0]
     948    mov     eax, [edx + CPUMCPU.Host.dr0]
    933949    mov     dr0, eax
    934     mov     ebx, [edx + CPUM.Host.dr1]
     950    mov     ebx, [edx + CPUMCPU.Host.dr1]
    935951    mov     dr1, ebx
    936     mov     ecx, [edx + CPUM.Host.dr2]
     952    mov     ecx, [edx + CPUMCPU.Host.dr2]
    937953    mov     dr2, ecx
    938     mov     eax, [edx + CPUM.Host.dr3]
     954    mov     eax, [edx + CPUMCPU.Host.dr3]
    939955    mov     dr3, eax
    940956gth_debug_regs_dr7:
    941     mov     ebx, [edx + CPUM.Host.dr6]
     957    mov     ebx, [edx + CPUMCPU.Host.dr6]
    942958    mov     dr6, ebx
    943     mov     ecx, [edx + CPUM.Host.dr7]
     959    mov     ecx, [edx + CPUMCPU.Host.dr7]
    944960    mov     dr7, ecx
    945961    jmp     gth_debug_regs_no

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

    r13699 r13960  
    301301               -e '/00[0-9a-fA-F]* [aA] [^_.]*\./!d'       -e 's/\(00[0-9a-fA-F]*\) [aA] \([^.]*\)\.\(.*$$\)/    CHECK_OFF(\2, 0x0\1, \3);/' \
    302302               --output [email protected] [email protected]
    303         $(QUIET)$(SED) -e '/VM_size$$/d' \
     303        $(QUIET)$(SED) -e '/VM_size$$/d' -e '/VMCPU_size$$/d' \
    304304               -e '/00[0-9a-fA-F]* [aA] [^_.]*_size$$/!d'  -e 's/\(00[0-9a-fA-F]*\) [aA] \([^_.]*\)_size/    CHECK_SIZE(\2, 0x0\1);/' \
    305305               --append [email protected] [email protected]

  • trunk/src/VBox/VMM/testcase/tstVMStructSize.cpp

    r13921 r13960  
    164164    CHECK_MEMBER_ALIGNMENT(VM, trpm.s.aIdt, 16);
    165165    CHECK_MEMBER_ALIGNMENT(VM, cpum, 64);
    166     CHECK_MEMBER_ALIGNMENT(VM, cpum.s.Host, 64);
    167     CHECK_MEMBER_ALIGNMENT(VM, cpum.s.Guest, 64);
     166    CHECK_MEMBER_ALIGNMENT(VM, aCpus[0].cpum.s.Host, 64);
     167    CHECK_MEMBER_ALIGNMENT(VM, aCpus[0].cpum.s.Guest, 64);
    168168    CHECK_MEMBER_ALIGNMENT(VM, cpum.s.Hyper, 64);
    169169    CHECK_MEMBER_ALIGNMENT(VM, cpum.s.GuestEntry, 64);
注意: 瀏覽 TracChangeset 來幫助您使用更動檢視器

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