VirtualBox

Changeset 42165 in vbox


Ignore:
Timestamp:
Jul 16, 2012 1:36:01 PM (13 years ago)
Author:
vboxsync
Message:

CPUMIsGuestIn64BitCode/CPUMIsGuestIn64BitCodeEx changes together with some early lazily loading of hidden selectors (raw-mode).

Location:
trunk
Files:
14 edited

Legend:

Unmodified
Added
Removed

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

    r42025 r42165  
    170170VMMDECL(bool)       CPUMGetGuestCpuIdFeature(PVM pVM, CPUMCPUIDFEATURE enmFeature);
    171171VMMDECL(void)       CPUMSetGuestCtx(PVMCPU pVCpu, const PCPUMCTX pCtx);
     172VMM_INT_DECL(void)  CPUMGuestLazyLoadHiddenCsAndSs(PVMCPU pVCpu);
     173VMM_INT_DECL(void)  CPUMGuestLazyLoadHiddenSelectorReg(PVMCPU pVCpu, PCPUMSELREG pSReg);
    172174/** @} */
    173175
    … …  
    178180VMMDECL(bool)       CPUMIsGuestIn16BitCode(PVMCPU pVCpu);
    179181VMMDECL(bool)       CPUMIsGuestIn32BitCode(PVMCPU pVCpu);
     182VMMDECL(bool)       CPUMIsGuestIn64BitCode(PVMCPU pVCpu);
    180183VMMDECL(bool)       CPUMIsGuestNXEnabled(PVMCPU pVCpu);
    181184VMMDECL(bool)       CPUMIsGuestPageSizeExtEnabled(PVMCPU pVCpu);
    … …  
    236239}
    237240
     241VMM_INT_DECL(bool) CPUMIsGuestIn64BitCodeSlow(PCPUMCTX pCtx);
     242
    238243/**
    239244 * Tests if the guest is running in 64 bits mode or not.
    240245 *
    241246 * @returns true if in 64 bits protected mode, otherwise false.
    242  * @param   pVM     The VM handle.
     247 * @param   pVCpu   The current virtual CPU.
    243248 * @param   pCtx    Current CPU context
    244249 */
    245 DECLINLINE(bool)    CPUMIsGuestIn64BitCode(PVMCPU pVCpu, PCCPUMCTXCORE pCtx)
    246 {
    247     if (!CPUMIsGuestInLongMode(pVCpu))
    248         return false;
    249 
    250     return pCtx->cs.Attr.n.u1Long;
    251 }
    252 
    253 /**
    254  * Tests if the guest is running in 64 bits mode or not.
    255  *
    256  * @returns true if in 64 bits protected mode, otherwise false.
    257  * @param   pVM     The VM handle.
    258  * @param   pCtx    Current CPU context
    259  */
    260 DECLINLINE(bool)    CPUMIsGuestIn64BitCodeEx(PCCPUMCTX pCtx)
     250DECLINLINE(bool)    CPUMIsGuestIn64BitCodeEx(PCPUMCTX pCtx)
    261251{
    262252    if (!(pCtx->msrEFER & MSR_K6_EFER_LMA))
    263253        return false;
    264 
     254    if (!CPUMSELREG_ARE_HIDDEN_PARTS_VALID(&pCtx->cs))
     255        return CPUMIsGuestIn64BitCodeSlow(pCtx);
    265256    return pCtx->cs.Attr.n.u1Long;
    266257}

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

    r41908 r42165  
    7878#define CPUMSELREG_FLAGS_STALE      UINT16_C(0x0002)
    7979/** @} */
     80
     81/** Checks if the hidden parts of the selector register are valid. */
     82#define CPUMSELREG_ARE_HIDDEN_PARTS_VALID(a_pSelReg) (   ((a_pSelReg)->fFlags & CPUMSELREG_FLAGS_VALID) \
     83                                                      && (a_pSelReg)->ValidSel == (a_pSelReg)->Sel )
    8084
    8185/** Old type used for the hidden register part.

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

    r41727 r42165  
    8383VMMDECL(DISCPUMODE) SELMGetCpuModeFromSelector(PVMCPU pVCpu, X86EFLAGS eflags, RTSEL Sel, PCCPUMSELREGHID pHiddenSel);
    8484VMMDECL(int)        SELMGetLDTFromSel(PVM pVM, RTSEL SelLdt, PRTGCPTR ppvLdt, unsigned *pcbLimit);
     85#ifdef VBOX_WITH_RAW_MODE
     86VMM_INT_DECL(void)  SELMLoadHiddenSelectorReg(PVMCPU pVCpu, PCCPUMCTX pCtx, PCPUMSELREG pSReg);
     87#endif
    8588
    8689

  • trunk/src/VBox/Debugger/DBGCEmulateCodeView.cpp

    r41565 r42165  
    958958            PVMCPU pVCpu = VMMGetCpuById(pVM, pDbgc->idCpu);
    959959            if (    pDbgc->fRegCtxGuest
    960                 &&  CPUMIsGuestIn64BitCodeEx(CPUMQueryGuestCtxPtr(pVCpu)))
     960                &&  CPUMIsGuestIn64BitCode(pVCpu))
    961961            {
    962962                pDbgc->DisasmPos.enmType    = DBGCVAR_TYPE_GC_FLAT;
    … …  
    14281428        bool const  f64BitMode = !strcmp(pCmd->pszCmd, "rg64")
    14291429                              || (   !strcmp(pCmd->pszCmd, "rg32")
    1430                                   && CPUMIsGuestIn64BitCodeEx(CPUMQueryGuestCtxPtr(VMMGetCpuById(pVM, pDbgc->idCpu))));
     1430                                  && CPUMIsGuestIn64BitCode(VMMGetCpuById(pVM, pDbgc->idCpu)));
    14311431        char        szDisAndRegs[8192];
    14321432        int         rc;

  • trunk/src/VBox/Debugger/testcase/tstDBGCStubs.cpp

    r41931 r42165  
    376376}
    377377
     378VMMDECL(bool) CPUMIsGuestIn64BitCode(PVMCPU pVCpu)
     379{
     380    return false;
     381}
    378382
    379383

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

    r42034 r42165  
    2727#include <VBox/vmm/pgm.h>
    2828#include <VBox/vmm/mm.h>
     29#if defined(VBOX_WITH_RAW_MODE) && !defined(IN_RING0)
     30# include <VBox/vmm/selm.h>
     31#endif
    2932#include "CPUMInternal.h"
    3033#include <VBox/vmm/vm.h>
    … …  
    4447#if defined(_MSC_VER) && !defined(DEBUG)
    4548# pragma optimize("y", off)
     49#endif
     50
     51
     52/*******************************************************************************
     53*   Defined Constants And Macros                                               *
     54*******************************************************************************/
     55/**
     56 * Converts a CPUMCPU::Guest pointer into a VMCPU pointer.
     57 *
     58 * @returns Pointer to the Virtual CPU.
     59 * @param   a_pGuestCtx     Pointer to the guest context.
     60 */
     61#define CPUM_GUEST_CTX_TO_VMCPU(a_pGuestCtx) RT_FROM_MEMBER(a_pGuestCtx, VMCPU, cpum.s.Guest)
     62
     63/**
     64 * Lazily loads the hidden parts of a selector register when using raw-mode.
     65 */
     66#if defined(VBOX_WITH_RAW_MODE) && !defined(IN_RING0)
     67# define CPUMSELREG_LAZY_LOAD_HIDDEN_PARTS(a_pVCpu, a_pSReg, a_fIsCS) \
     68    do \
     69    { \
     70        if (!CPUMSELREG_ARE_HIDDEN_PARTS_VALID(a_pSReg)) \
     71            cpumGuestLazyLoadHiddenSelectorReg(a_pVCpu, a_pSReg, a_fIsCS); \
     72    } while (0)
     73#else
     74# define CPUMSELREG_LAZY_LOAD_HIDDEN_PARTS(a_pVCpu, a_pSReg, a_fIsCS) \
     75    Assert(CPUMSELREG_ARE_HIDDEN_PARTS_VALID(a_pSReg));
     76#endif
     77
     78
     79
     80#if defined(VBOX_WITH_RAW_MODE) && !defined(IN_RING0)
     81
     82
     83/**
     84 * Does the lazy hidden selector register loading.
     85 *
     86 * @param   pVCpu       The current Virtual CPU.
     87 * @param   pSReg       The selector register to lazily load hidden parts of.
     88 * @param   fIsCS
     89 */
     90static void cpumGuestLazyLoadHiddenSelectorReg(PVMCPU pVCpu, PCPUMSELREG pSReg, bool fIsCS)
     91{
     92    Assert(!CPUMSELREG_ARE_HIDDEN_PARTS_VALID(pSReg));
     93    Assert(!HWACCMIsEnabled(pVCpu->CTX_SUFF(pVM)));
     94
     95    if (pVCpu->cpum.s.Guest.eflags.Bits.u1VM)
     96    {
     97        /* V8086 mode - Tightly controlled environment, no question about the limit or flags. */
     98        pSReg->Attr.u               = 0;
     99        pSReg->Attr.n.u1DescType    = 1; /* code/data segment */
     100        pSReg->Attr.n.u1Present     = 1;
     101        pSReg->Attr.n.u4Type        = fIsCS ? X86_SEL_TYPE_ER_ACC : X86_SEL_TYPE_RW_ACC;
     102        pSReg->u32Limit             = 0x0000ffff;
     103        pSReg->u64Base              = (uint32_t)pSReg->Sel << 4;
     104        pSReg->ValidSel             = pSReg->Sel;
     105        pSReg->fFlags               = CPUMSELREG_FLAGS_VALID;
     106        /** @todo Check what the accessed bit should be (VT-x and AMD-V). */
     107    }
     108    else if (!(pVCpu->cpum.s.Guest.cr0 & X86_CR0_PE))
     109    {
     110        /* Real mode - leave the limit and flags alone here, at least for now. */
     111        pSReg->u64Base              = (uint32_t)pSReg->Sel << 4;
     112        pSReg->ValidSel             = pSReg->Sel;
     113        pSReg->fFlags               = CPUMSELREG_FLAGS_VALID;
     114    }
     115    else
     116    {
     117        /* Protected mode - get it from the selector descriptor tables. */
     118        if (!(pSReg->Sel & X86_SEL_MASK))
     119        {
     120            Assert(!CPUMIsGuestInLongMode(pVCpu));
     121            pSReg->Sel              = 0;
     122            pSReg->u64Base          = 0;
     123            pSReg->u32Limit         = 0;
     124            pSReg->Attr.u           = 0;
     125            pSReg->ValidSel         = 0;
     126            pSReg->fFlags           = CPUMSELREG_FLAGS_VALID;
     127            /** @todo see todo in iemHlpLoadNullDataSelectorProt. */
     128        }
     129        else
     130            SELMLoadHiddenSelectorReg(pVCpu, &pVCpu->cpum.s.Guest, pSReg);
     131    }
     132}
     133
     134
     135/**
     136 * Makes sure the hidden CS and SS selector registers are valid, loading them if
     137 * necessary.
     138 *
     139 * @param   pVCpu               The current virtual CPU.
     140 */
     141VMM_INT_DECL(void) CPUMGuestLazyLoadHiddenCsAndSs(PVMCPU pVCpu)
     142{
     143    CPUMSELREG_LAZY_LOAD_HIDDEN_PARTS(pVCpu, &pVCpu->cpum.s.Guest.cs, true);
     144    CPUMSELREG_LAZY_LOAD_HIDDEN_PARTS(pVCpu, &pVCpu->cpum.s.Guest.ss, false);
     145}
     146
     147
     148/**
     149 * Loads a the hidden parts of a selector register.
     150 *
     151 * @param   pVCpu               The current virtual CPU.
     152 */
     153VMM_INT_DECL(void) CPUMGuestLazyLoadHiddenSelectorReg(PVMCPU pVCpu, PCPUMSELREG pSReg)
     154{
     155    CPUMSELREG_LAZY_LOAD_HIDDEN_PARTS(pVCpu, pSReg, pSReg == &pVCpu->cpum.s.Guest.cs);
     156}
     157
    46158#endif
    47159
    … …  
    22112323
    22122324
     2325/**
     2326 * Tests if the guest is running in 64 bits mode or not.
     2327 *
     2328 * @returns true if in 64 bits protected mode, otherwise false.
     2329 * @param   pVCpu       The current virtual CPU.
     2330 */
     2331VMMDECL(bool) CPUMIsGuestIn64BitCode(PVMCPU pVCpu)
     2332{
     2333    if (!CPUMIsGuestInLongMode(pVCpu))
     2334        return false;
     2335    CPUMSELREG_LAZY_LOAD_HIDDEN_PARTS(pVCpu, &pVCpu->cpum.s.Guest.cs, true);
     2336    return pVCpu->cpum.s.Guest.cs.Attr.n.u1Long;
     2337}
     2338
     2339
     2340/**
     2341 * Helper for CPUMIsGuestIn64BitCodeEx that handles lazy resolving of hidden CS
     2342 * registers.
     2343 *
     2344 * @returns true if in 64 bits protected mode, otherwise false.
     2345 * @param   pCtx        Pointer to the current guest CPU context.
     2346 */
     2347VMM_INT_DECL(bool) CPUMIsGuestIn64BitCodeSlow(PCPUMCTX pCtx)
     2348{
     2349    return CPUMIsGuestIn64BitCode(CPUM_GUEST_CTX_TO_VMCPU(pCtx));
     2350}
     2351
     2352
    22132353#ifndef IN_RING0
    22142354/**
    … …  
    24032543    uint32_t uCpl;
    24042544
     2545#if 1
    24052546    if (CPUMAreHiddenSelRegsValid(pVCpu))
     2547#else
     2548    if (CPUMSELREG_ARE_HIDDEN_PARTS_VALID(&pVCpu->cpum.s.Guest.ss))
     2549#endif
    24062550    {
    24072551        /*
    … …  
    24272571            uCpl = 0;  /* CPL set to 3 for VT-x real-mode emulation. */
    24282572    }
    2429     else if (RT_LIKELY(pVCpu->cpum.s.Guest.cr0 & X86_CR0_PE))
     2573    else if (pVCpu->cpum.s.Guest.cr0 & X86_CR0_PE)
    24302574    {
    2431         if (RT_LIKELY(!pVCpu->cpum.s.Guest.eflags.Bits.u1VM))
     2575        if (!pVCpu->cpum.s.Guest.eflags.Bits.u1VM)
    24322576        {
    24332577            /*

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

    r41965 r42165  
    610610
    611611    Assert(pRegFrame == CPUMGetGuestCtxCore(pVCpu));
    612     Assert(!CPUMIsGuestIn64BitCode(pVCpu, pRegFrame));
     612    Assert(!CPUMIsGuestIn64BitCode(pVCpu));
    613613    /** @todo Rainy day: Test what happens when VERR_EM_INTERPRETER is returned by
    614614     *        this function.  Fear that it may guru on us, thus not converted to
    … …  
    10461046    Assert(pRegFrame == CPUMGetGuestCtxCore(pVCpu));
    10471047
    1048     if (CPUMIsGuestIn64BitCode(pVCpu, pRegFrame))
    1049     {
     1048    if (CPUMIsGuestIn64BitCode(pVCpu))
    10501049        rc = DISFetchReg64(pRegFrame, SrcRegGen, &val);
    1051     }
    10521050    else
    10531051    {
    … …  
    11251123    NOREF(pVM);
    11261124
    1127     if (CPUMIsGuestIn64BitCode(pVCpu, pRegFrame))
     1125    if (CPUMIsGuestIn64BitCode(pVCpu))
    11281126        rc = DISWriteReg64(pRegFrame, DestRegGen, val64);
    11291127    else
    … …  
    11571155    NOREF(pVM);
    11581156
    1159     if (CPUMIsGuestIn64BitCode(pVCpu, pRegFrame))
    1160     {
     1157    if (CPUMIsGuestIn64BitCode(pVCpu))
    11611158        rc = DISFetchReg64(pRegFrame, SrcRegGen, &val);
    1162     }
    11631159    else
    11641160    {
    … …  
    11991195    int rc = CPUMGetGuestDRx(pVCpu, SrcRegDrx, &val64);
    12001196    AssertMsgRCReturn(rc, ("CPUMGetGuestDRx %d failed\n", SrcRegDrx), VERR_EM_INTERPRETER);
    1201     if (CPUMIsGuestIn64BitCode(pVCpu, pRegFrame))
    1202     {
     1197    if (CPUMIsGuestIn64BitCode(pVCpu))
    12031198        rc = DISWriteReg64(pRegFrame, DestRegGen, val64);
    1204     }
    12051199    else
    12061200        rc = DISWriteReg32(pRegFrame, DestRegGen, (uint32_t)val64);
    … …  
    30813075                                                   RTGCPTR pvFault, EMCODETYPE enmCodeType, uint32_t *pcbSize)
    30823076{
     3077    Assert(pRegFrame == CPUMGetGuestCtxCore(pVCpu));
    30833078    Assert(enmCodeType == EMCODETYPE_SUPERVISOR || enmCodeType == EMCODETYPE_ALL);
    30843079    Assert(pcbSize);
    … …  
    31433138     */
    31443139    if (    pDis->Param1.cb > 4
    3145         &&  CPUMIsGuestIn64BitCode(pVCpu, pRegFrame))
     3140        &&  CPUMIsGuestIn64BitCode(pVCpu))
    31463141    {
    31473142        uint32_t uOpCode = pDis->pCurInstr->uOpcode;

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

    r41939 r42165  
    629629    PCPUMCTX pCtx = pIemCpu->CTX_SUFF(pCtx);
    630630
     631    CPUMGuestLazyLoadHiddenCsAndSs(IEMCPU_TO_VMCPU(pIemCpu));
    631632    pIemCpu->uCpl               = CPUMGetGuestCPL(IEMCPU_TO_VMCPU(pIemCpu));
    632633    IEMMODE enmMode = CPUMIsGuestIn64BitCodeEx(pCtx)

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

    r41965 r42165  
    939939    {
    940940#ifndef IN_RC
    941         if (    CPUMIsGuestIn64BitCode(VMMGetCpu(pVM), pRegFrame)
     941        if (    CPUMIsGuestIn64BitCode(VMMGetCpu(pVM))
    942942            &&  pRegFrame->rcx >= _4G)
    943943            return VINF_EM_RAW_EMULATE_INSTR;
    … …  
    20442044    {
    20452045#ifndef IN_RC
    2046         if (    CPUMIsGuestIn64BitCode(pVCpu, pRegFrame)
     2046        if (    CPUMIsGuestIn64BitCode(pVCpu)
    20472047            &&  pRegFrame->rcx >= _4G)
    20482048            return VINF_EM_RAW_EMULATE_INSTR;
    … …  
    22062206    {
    22072207#ifndef IN_RC
    2208         if (    CPUMIsGuestIn64BitCode(pVCpu, pRegFrame)
     2208        if (    CPUMIsGuestIn64BitCode(pVCpu)
    22092209            &&  pRegFrame->rcx >= _4G)
    22102210            return VINF_EM_RAW_EMULATE_INSTR;

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

    r41965 r42165  
    659659
    660660
     661#ifdef VBOX_WITH_RAW_MODE
     662/**
     663 * CPUM helper that loads the hidden selector register from the descriptor table
     664 * when executing with raw-mode.
     665 *
     666 * @remarks This is only used when in legacy protected mode!
     667 *
     668 * @param   pVCpu       Pointer to the current virtual CPU.
     669 * @param   pCtx        The guest CPU context.
     670 * @param   pSReg       The selector register.
     671 *
     672 * @todo    Deal 100% correctly with stale selectors.  What's more evil is
     673 *          invalid page table entries, which isn't impossible to imagine for
     674 *          LDT entries for instance, though unlikely.  Currently, we turn a
     675 *          blind eye to these issues and return the old hidden registers,
     676 *          though we don't set the valid flag, so that we'll try loading them
     677 *          over and over again till we succeed loading something.
     678 */
     679VMM_INT_DECL(void) SELMLoadHiddenSelectorReg(PVMCPU pVCpu, PCCPUMCTX pCtx, PCPUMSELREG pSReg)
     680{
     681    Assert(pCtx->cr0 & X86_CR0_PE);
     682    Assert(!(pCtx->msrEFER & MSR_K6_EFER_LMA));
     683
     684    PVM pVM = pVCpu->CTX_SUFF(pVM);
     685    Assert(pVM->cCpus == 1);
     686
     687    RTSEL const Sel = pSReg->Sel;
     688
     689    /*
     690     * Calculate descriptor table entry address.
     691     */
     692    RTGCPTR GCPtrDesc;
     693    if (!(Sel & X86_SEL_LDT))
     694    {
     695        if ((Sel & X86_SEL_MASK) >= pCtx->gdtr.cbGdt)
     696        {
     697            AssertFailed(); /** @todo count these. */
     698            return;
     699        }
     700        GCPtrDesc = pCtx->gdtr.pGdt + (Sel & X86_SEL_MASK);
     701        /** @todo Desc = pVM->selm.s.CTX_SUFF(paGdt)[Sel >> X86_SEL_SHIFT]; for cases
     702         *        where we don't change it too much. */
     703    }
     704    else
     705    {
     706        if ((Sel & X86_SEL_MASK) >= pCtx->ldtr.u32Limit)
     707        {
     708            AssertFailed(); /** @todo count these. */
     709            return;
     710        }
     711        GCPtrDesc = pCtx->ldtr.u64Base + (Sel & X86_SEL_MASK);
     712    }
     713
     714    /*
     715     * Try read the entry.
     716     */
     717    X86DESC Desc;
     718    int rc = PGMPhysReadGCPtr(pVCpu, &Desc, GCPtrDesc, sizeof(Desc));
     719    if (RT_FAILURE(rc))
     720    {
     721        //RT_ZERO(Desc);
     722        //if (!(Sel & X86_SEL_LDT))
     723        //    Desc = pVM->selm.s.CTX_SUFF(paGdt)[Sel >> X86_SEL_SHIFT];
     724        //if (!Desc.Gen.u1Present)
     725        {
     726            AssertFailed(); /** @todo count these. */
     727            return;
     728        }
     729    }
     730
     731    /*
     732     * Digest it and store the result.
     733     */
     734    if (   !Desc.Gen.u1Present
     735        || !Desc.Gen.u1DescType)
     736    {
     737        AssertFailed(); /** @todo count these. */
     738        return;
     739    }
     740
     741    uint32_t u32Limit = X86DESC_LIMIT(Desc);
     742    if (Desc.Gen.u1Granularity)
     743        u32Limit = (u32Limit << PAGE_SHIFT) | PAGE_OFFSET_MASK;
     744    pSReg->u32Limit = u32Limit;
     745
     746    pSReg->u64Base  = X86DESC_BASE(Desc);
     747    pSReg->Attr.u   = X86DESC_GET_HID_ATTR(Desc);
     748    pSReg->fFlags   = CPUMSELREG_FLAGS_VALID;
     749    pSReg->ValidSel = Sel;
     750}
     751#endif /* VBOX_WITH_RAW_MODE */
     752
     753
    661754/**
    662755 * Validates and converts a GC selector based code address to a flat

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

    r42024 r42165  
    554554                        || !ss_r0
    555555                        || (ss_r0 & X86_SEL_RPL) != ((dpl == 0) ? 1 : dpl)
    556                         || SELMToFlatBySelEx(pVCpu, fakeflags, ss_r0, (RTGCPTR)esp_r0, NULL, SELMTOFLAT_FLAGS_CPL1, (PRTGCPTR)&pTrapStackGC, NULL) != VINF_SUCCESS
     556                        || SELMToFlatBySelEx(pVCpu, fakeflags, ss_r0, (RTGCPTR)esp_r0, NULL, SELMTOFLAT_FLAGS_CPL1,
     557                                             (PRTGCPTR)&pTrapStackGC, NULL) != VINF_SUCCESS
    557558                       )
    558559                    {
    … …  
    568569
    569570                    if (    eflags.Bits.u1VM    /* illegal */
    570                         ||  SELMToFlatBySelEx(pVCpu, fakeflags, ss_r0, (RTGCPTR)esp_r0, NULL, SELMTOFLAT_FLAGS_CPL1, (PRTGCPTR)&pTrapStackGC, NULL) != VINF_SUCCESS)
     571                        ||  SELMToFlatBySelEx(pVCpu, fakeflags, ss_r0, (RTGCPTR)esp_r0, NULL, SELMTOFLAT_FLAGS_CPL1,
     572                                              (PRTGCPTR)&pTrapStackGC, NULL) != VINF_SUCCESS)
    571573                    {
    572574                        AssertMsgFailed(("Invalid stack %04X:%08RX32??? (VM=%d)\n", ss_r0, esp_r0, eflags.Bits.u1VM));

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

    r42157 r42165  
    19331933     * Format the registers.
    19341934     */
    1935     if (CPUMIsGuestIn64BitCode(pVCpu, CPUMCTX2CORE(pCtx)))
     1935    if (CPUMIsGuestIn64BitCode(pVCpu))
    19361936    {
    19371937        Log(("rax=%016RX64 rbx=%016RX64 rcx=%016RX64 rdx=%016RX64\n"

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

    r41800 r42165  
    399399                     == DBGFSELINFO_FLAGS_LONG_MODE
    400400                &&  pSelInfo->cbLimit != ~(RTGCPTR)0
    401                 &&  CPUMIsGuestIn64BitCode(pVCpu, CPUMGetGuestCtxCore(pVCpu)) )
     401                &&  CPUMIsGuestIn64BitCode(pVCpu) )
    402402            {
    403403                pSelInfo->GCPtrBase = 0;
    … …  
    405405            }
    406406            else if (   Sel == 0
    407                      && CPUMIsGuestIn64BitCode(pVCpu, CPUMGetGuestCtxCore(pVCpu)))
     407                     && CPUMIsGuestIn64BitCode(pVCpu))
    408408            {
    409409                pSelInfo->GCPtrBase = 0;

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

    r41965 r42165  
    332332                fAddrMask = UINT16_MAX;
    333333            else if (   CpuMode == CPUMMODE_PROTECTED
    334                      || !CPUMIsGuestIn64BitCode(pVCpu, pCtxCore))
     334                     || !CPUMIsGuestIn64BitCode(pVCpu))
    335335                fAddrMask = UINT32_MAX;
    336336            else
Note: See TracChangeset for help on using the changeset viewer.

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