VirtualBox

Changeset 42407 in vbox for trunk/src/recompiler


Ignore:
Timestamp:
Jul 26, 2012 11:41:35 AM (13 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
79503
Message:

VMM: Futher work on dealing with hidden segment register, esp. when going stale.

Location:
trunk/src/recompiler
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/recompiler/VBoxRecompiler.c

    r41906 r42407  
    138138static STAMCOUNTER    gStatRefuseRing1or2;
    139139static STAMCOUNTER    gStatRefuseCanExecute;
     140static STAMCOUNTER    gaStatRefuseStale[6];
    140141static STAMCOUNTER    gStatREMGDTChange;
    141142static STAMCOUNTER    gStatREMIDTChange;
    … …  
    390391    STAM_REG(pVM, &gStatRefuseRing1or2,     STAMTYPE_COUNTER, "/REM/Refuse/Ring1or2", STAMUNIT_OCCURENCES,     "Raw mode refused because of ring 1/2 execution");
    391392    STAM_REG(pVM, &gStatRefuseCanExecute,   STAMTYPE_COUNTER, "/REM/Refuse/CanExecuteRaw", STAMUNIT_OCCURENCES,     "Raw mode refused because of cCanExecuteRaw");
     393    STAM_REG(pVM, &gaStatRefuseStale[R_ES], STAMTYPE_COUNTER, "/REM/Refuse/StaleES",  STAMUNIT_OCCURENCES,     "Raw mode refused because of stale ES");
     394    STAM_REG(pVM, &gaStatRefuseStale[R_CS], STAMTYPE_COUNTER, "/REM/Refuse/StaleCS",  STAMUNIT_OCCURENCES,     "Raw mode refused because of stale CS");
     395    STAM_REG(pVM, &gaStatRefuseStale[R_SS], STAMTYPE_COUNTER, "/REM/Refuse/StaleSS",  STAMUNIT_OCCURENCES,     "Raw mode refused because of stale SS");
     396    STAM_REG(pVM, &gaStatRefuseStale[R_DS], STAMTYPE_COUNTER, "/REM/Refuse/StaleDS",  STAMUNIT_OCCURENCES,     "Raw mode refused because of stale DS");
     397    STAM_REG(pVM, &gaStatRefuseStale[R_FS], STAMTYPE_COUNTER, "/REM/Refuse/StaleFS",  STAMUNIT_OCCURENCES,     "Raw mode refused because of stale FS");
     398    STAM_REG(pVM, &gaStatRefuseStale[R_GS], STAMTYPE_COUNTER, "/REM/Refuse/StaleGS",  STAMUNIT_OCCURENCES,     "Raw mode refused because of stale GS");
    392399    STAM_REG(pVM, &gStatFlushTBs,           STAMTYPE_COUNTER, "/REM/FlushTB",         STAMUNIT_OCCURENCES,     "Number of TB flushes");
    393400
    … …  
    568575    STAM_DEREG(pVM, &gStatRefuseRing1or2);
    569576    STAM_DEREG(pVM, &gStatRefuseCanExecute);
     577    STAM_DEREG(pVM, &gaStatRefuseStale[0]);
     578    STAM_DEREG(pVM, &gaStatRefuseStale[1]);
     579    STAM_DEREG(pVM, &gaStatRefuseStale[2]);
     580    STAM_DEREG(pVM, &gaStatRefuseStale[3]);
     581    STAM_DEREG(pVM, &gaStatRefuseStale[4]);
     582    STAM_DEREG(pVM, &gaStatRefuseStale[5]);
    570583    STAM_DEREG(pVM, &gStatFlushTBs);
    571584
    … …  
    16641677    }
    16651678
     1679    /*
     1680     * Stale hidden selectors means raw-mode is unsafe (being very careful).
     1681     */
     1682    if (env->segs[R_CS].fVBoxFlags & CPUMSELREG_FLAGS_STALE)
     1683    {
     1684        Log2(("raw mode refused: stale CS (%#x)\n", env->segs[R_CS].selector));
     1685        STAM_COUNTER_INC(&gaStatRefuseStale[R_CS]);
     1686        return EMSTATE_REM;
     1687    }
     1688    if (env->segs[R_SS].fVBoxFlags & CPUMSELREG_FLAGS_STALE)
     1689    {
     1690        Log2(("raw mode refused: stale SS (%#x)\n", env->segs[R_SS].selector));
     1691        STAM_COUNTER_INC(&gaStatRefuseStale[R_SS]);
     1692        return EMSTATE_REM;
     1693    }
     1694    if (env->segs[R_DS].fVBoxFlags & CPUMSELREG_FLAGS_STALE)
     1695    {
     1696        Log2(("raw mode refused: stale DS (%#x)\n", env->segs[R_DS].selector));
     1697        STAM_COUNTER_INC(&gaStatRefuseStale[R_DS]);
     1698        return EMSTATE_REM;
     1699    }
     1700    if (env->segs[R_ES].fVBoxFlags & CPUMSELREG_FLAGS_STALE)
     1701    {
     1702        Log2(("raw mode refused: stale ES (%#x)\n", env->segs[R_ES].selector));
     1703        STAM_COUNTER_INC(&gaStatRefuseStale[R_ES]);
     1704        return EMSTATE_REM;
     1705    }
     1706    if (env->segs[R_FS].fVBoxFlags & CPUMSELREG_FLAGS_STALE)
     1707    {
     1708        Log2(("raw mode refused: stale FS (%#x)\n", env->segs[R_FS].selector));
     1709        STAM_COUNTER_INC(&gaStatRefuseStale[R_FS]);
     1710        return EMSTATE_REM;
     1711    }
     1712    if (env->segs[R_GS].fVBoxFlags & CPUMSELREG_FLAGS_STALE)
     1713    {
     1714        Log2(("raw mode refused: stale GS (%#x)\n", env->segs[R_GS].selector));
     1715        STAM_COUNTER_INC(&gaStatRefuseStale[R_GS]);
     1716        return EMSTATE_REM;
     1717    }
     1718
    16661719/*    Assert(env->pVCpu && PGMPhysIsA20Enabled(env->pVCpu));*/
    16671720    *piException = EXCP_EXECUTE_RAW;
    … …  
    20422095    register const CPUMCTX *pCtx;
    20432096    register unsigned       fFlags;
    2044     bool                    fHiddenSelRegsValid;
    20452097    unsigned                i;
    20462098    TRPMEVENT               enmType;
    … …  
    20542106    pVM->rem.s.Env.pVCpu = pVCpu;
    20552107    pCtx = pVM->rem.s.pCtx = CPUMQueryGuestCtxPtr(pVCpu);
    2056     fHiddenSelRegsValid = CPUMAreHiddenSelRegsValid(pVCpu); /// @todo move this down and use fFlags.
    20572108
    20582109    Assert(!pVM->rem.s.fInREM);
    … …  
    22772328        if (fFlags & CPUM_CHANGED_LDTR)
    22782329        {
    2279             if (fHiddenSelRegsValid || (pCtx->ldtr.fFlags & CPUMSELREG_FLAGS_VALID))
     2330            if (pCtx->ldtr.fFlags & CPUMSELREG_FLAGS_VALID)
    22802331            {
    22812332                pVM->rem.s.Env.ldt.selector = pCtx->ldtr.Sel;
    … …  
    23072358     * Sync TR unconditionally to make life simpler.
    23082359     */
    2309     pVM->rem.s.Env.tr.selector = pCtx->tr.Sel;
    2310     pVM->rem.s.Env.tr.base     = pCtx->tr.u64Base;
    2311     pVM->rem.s.Env.tr.limit    = pCtx->tr.u32Limit;
    2312     pVM->rem.s.Env.tr.flags    = (pCtx->tr.Attr.u << 8) & 0xFFFFFF;
     2360    pVM->rem.s.Env.tr.selector    = pCtx->tr.Sel;
     2361    pVM->rem.s.Env.tr.newselector = 0;
     2362    pVM->rem.s.Env.tr.fVBoxFlags  = pCtx->tr.fFlags;
     2363    pVM->rem.s.Env.tr.base        = pCtx->tr.u64Base;
     2364    pVM->rem.s.Env.tr.limit       = pCtx->tr.u32Limit;
     2365    pVM->rem.s.Env.tr.flags       = (pCtx->tr.Attr.u << 8) & 0xFFFFFF;
    23132366    /* Note! do_interrupt will fault if the busy flag is still set... */
    2314     pVM->rem.s.Env.tr.flags   &= ~DESC_TSS_BUSY_MASK;
     2367    pVM->rem.s.Env.tr.flags      &= ~DESC_TSS_BUSY_MASK;
    23152368
    23162369    /*
    23172370     * Update selector registers.
     2371     *
    23182372     * This must be done *after* we've synced gdt, ldt and crX registers
    23192373     * since we're reading the GDT/LDT om sync_seg. This will happen with
    23202374     * saved state which takes a quick dip into rawmode for instance.
    2321      */
    2322     /*
    2323      * Stack; Note first check this one as the CPL might have changed. The
    2324      * wrong CPL can cause QEmu to raise an exception in sync_seg!!
    2325      */
    2326 
    2327     if (fHiddenSelRegsValid)
    2328     {
    2329         /* The hidden selector registers are valid in the CPU context. */
    2330         /* Note! QEmu saves the 2nd dword of the descriptor; we should convert the attribute word back! */
    2331 
    2332         /* Set current CPL */
    2333         cpu_x86_set_cpl(&pVM->rem.s.Env, uCpl);
    2334 
    2335         cpu_x86_load_seg_cache(&pVM->rem.s.Env, R_CS, pCtx->cs.Sel, pCtx->cs.u64Base, pCtx->cs.u32Limit, (pCtx->cs.Attr.u << 8) & 0xFFFFFF);
    2336         cpu_x86_load_seg_cache(&pVM->rem.s.Env, R_SS, pCtx->ss.Sel, pCtx->ss.u64Base, pCtx->ss.u32Limit, (pCtx->ss.Attr.u << 8) & 0xFFFFFF);
    2337         cpu_x86_load_seg_cache(&pVM->rem.s.Env, R_DS, pCtx->ds.Sel, pCtx->ds.u64Base, pCtx->ds.u32Limit, (pCtx->ds.Attr.u << 8) & 0xFFFFFF);
    2338         cpu_x86_load_seg_cache(&pVM->rem.s.Env, R_ES, pCtx->es.Sel, pCtx->es.u64Base, pCtx->es.u32Limit, (pCtx->es.Attr.u << 8) & 0xFFFFFF);
    2339         cpu_x86_load_seg_cache(&pVM->rem.s.Env, R_FS, pCtx->fs.Sel, pCtx->fs.u64Base, pCtx->fs.u32Limit, (pCtx->fs.Attr.u << 8) & 0xFFFFFF);
    2340         cpu_x86_load_seg_cache(&pVM->rem.s.Env, R_GS, pCtx->gs.Sel, pCtx->gs.u64Base, pCtx->gs.u32Limit, (pCtx->gs.Attr.u << 8) & 0xFFFFFF);
    2341     }
    2342     else
    2343     {
    2344         /* In 'normal' raw mode we don't have access to the hidden selector registers. */
    2345         /** @todo use hidden registers when possible and make CPUM/someone do the
    2346          *        reading of lazily maintained hidden registers. */
    2347         if (pVM->rem.s.Env.segs[R_SS].selector != pCtx->ss.Sel)
    2348         {
    2349             Log2(("REMR3State: SS changed from %04x to %04x!\n", pVM->rem.s.Env.segs[R_SS].selector, pCtx->ss.Sel));
    2350 
    2351             cpu_x86_set_cpl(&pVM->rem.s.Env, uCpl);
    2352             sync_seg(&pVM->rem.s.Env, R_SS, pCtx->ss.Sel);
    2353 #ifdef VBOX_WITH_STATISTICS
    2354             if (pVM->rem.s.Env.segs[R_SS].newselector)
    2355             {
    2356                 STAM_COUNTER_INC(&gStatSelOutOfSync[R_SS]);
    2357             }
    2358 #endif
    2359         }
    2360         else
    2361             pVM->rem.s.Env.segs[R_SS].newselector = 0;
    2362 
    2363         if (pVM->rem.s.Env.segs[R_ES].selector != pCtx->es.Sel)
    2364         {
    2365             Log2(("REMR3State: ES changed from %04x to %04x!\n", pVM->rem.s.Env.segs[R_ES].selector, pCtx->es.Sel));
    2366             sync_seg(&pVM->rem.s.Env, R_ES, pCtx->es.Sel);
    2367 #ifdef VBOX_WITH_STATISTICS
    2368             if (pVM->rem.s.Env.segs[R_ES].newselector)
    2369             {
    2370                 STAM_COUNTER_INC(&gStatSelOutOfSync[R_ES]);
    2371             }
    2372 #endif
    2373         }
    2374         else
    2375             pVM->rem.s.Env.segs[R_ES].newselector = 0;
    2376 
    2377         if (pVM->rem.s.Env.segs[R_CS].selector != pCtx->cs.Sel)
    2378         {
    2379             Log2(("REMR3State: CS changed from %04x to %04x!\n", pVM->rem.s.Env.segs[R_CS].selector, pCtx->cs.Sel));
    2380             sync_seg(&pVM->rem.s.Env, R_CS, pCtx->cs.Sel);
    2381 #ifdef VBOX_WITH_STATISTICS
    2382             if (pVM->rem.s.Env.segs[R_CS].newselector)
    2383             {
    2384                 STAM_COUNTER_INC(&gStatSelOutOfSync[R_CS]);
    2385             }
    2386 #endif
    2387         }
    2388         else
    2389             pVM->rem.s.Env.segs[R_CS].newselector = 0;
    2390 
    2391         if (pVM->rem.s.Env.segs[R_DS].selector != pCtx->ds.Sel)
    2392         {
    2393             Log2(("REMR3State: DS changed from %04x to %04x!\n", pVM->rem.s.Env.segs[R_DS].selector, pCtx->ds.Sel));
    2394             sync_seg(&pVM->rem.s.Env, R_DS, pCtx->ds.Sel);
    2395 #ifdef VBOX_WITH_STATISTICS
    2396             if (pVM->rem.s.Env.segs[R_DS].newselector)
    2397             {
    2398                 STAM_COUNTER_INC(&gStatSelOutOfSync[R_DS]);
    2399             }
    2400 #endif
    2401         }
    2402         else
    2403             pVM->rem.s.Env.segs[R_DS].newselector = 0;
    2404 
     2375     *
     2376     * CPL/Stack; Note first check this one as the CPL might have changed.
     2377     * The wrong CPL can cause QEmu to raise an exception in sync_seg!!
     2378     */
     2379    cpu_x86_set_cpl(&pVM->rem.s.Env, uCpl);
     2380    /* Note! QEmu saves the 2nd dword of the descriptor; we should convert the attribute word back! */
     2381#define SYNC_IN_SREG(a_pEnv, a_SReg, a_pRemSReg, a_pVBoxSReg) \
     2382        do \
     2383        { \
     2384            if (CPUMSELREG_ARE_HIDDEN_PARTS_VALID(pVCpu, a_pVBoxSReg)) \
     2385            { \
     2386                cpu_x86_load_seg_cache(a_pEnv, R_##a_SReg, \
     2387                                       (a_pVBoxSReg)->Sel, \
     2388                                       (a_pVBoxSReg)->u64Base, \
     2389                                       (a_pVBoxSReg)->u32Limit, \
     2390                                       ((a_pVBoxSReg)->Attr.u << 8) & 0xFFFFFF); \
     2391                (a_pRemSReg)->fVBoxFlags = (a_pVBoxSReg)->fFlags; \
     2392            } \
     2393            /* This only-reload-if-changed stuff is the old approach, we should ditch it. */ \
     2394            else if ((a_pRemSReg)->selector != (a_pVBoxSReg)->Sel) \
     2395            { \
     2396                Log2(("REMR3State: " #a_SReg " changed from %04x to %04x!\n", \
     2397                      (a_pRemSReg)->selector, (a_pVBoxSReg)->Sel)); \
     2398                sync_seg(a_pEnv, R_##a_SReg, (a_pVBoxSReg)->Sel); \
     2399                if ((a_pRemSReg)->newselector) \
     2400                    STAM_COUNTER_INC(&gStatSelOutOfSync[R_##a_SReg]); \
     2401            } \
     2402            else \
     2403                (a_pRemSReg)->newselector = 0; \
     2404        } while (0)
     2405
     2406    SYNC_IN_SREG(&pVM->rem.s.Env, CS, &pVM->rem.s.Env.segs[R_CS], &pCtx->cs);
     2407    SYNC_IN_SREG(&pVM->rem.s.Env, SS, &pVM->rem.s.Env.segs[R_SS], &pCtx->ss);
     2408    SYNC_IN_SREG(&pVM->rem.s.Env, DS, &pVM->rem.s.Env.segs[R_DS], &pCtx->ds);
     2409    SYNC_IN_SREG(&pVM->rem.s.Env, ES, &pVM->rem.s.Env.segs[R_ES], &pCtx->es);
     2410    SYNC_IN_SREG(&pVM->rem.s.Env, FS, &pVM->rem.s.Env.segs[R_FS], &pCtx->fs);
     2411    SYNC_IN_SREG(&pVM->rem.s.Env, GS, &pVM->rem.s.Env.segs[R_GS], &pCtx->gs);
    24052412    /** @todo need to find a way to communicate potential GDT/LDT changes and thread switches. The selector might
    24062413     * be the same but not the base/limit. */
    2407         if (pVM->rem.s.Env.segs[R_FS].selector != pCtx->fs.Sel)
    2408         {
    2409             Log2(("REMR3State: FS changed from %04x to %04x!\n", pVM->rem.s.Env.segs[R_FS].selector, pCtx->fs.Sel));
    2410             sync_seg(&pVM->rem.s.Env, R_FS, pCtx->fs.Sel);
    2411 #ifdef VBOX_WITH_STATISTICS
    2412             if (pVM->rem.s.Env.segs[R_FS].newselector)
    2413             {
    2414                 STAM_COUNTER_INC(&gStatSelOutOfSync[R_FS]);
    2415             }
    2416 #endif
    2417         }
    2418         else
    2419             pVM->rem.s.Env.segs[R_FS].newselector = 0;
    2420 
    2421         if (pVM->rem.s.Env.segs[R_GS].selector != pCtx->gs.Sel)
    2422         {
    2423             Log2(("REMR3State: GS changed from %04x to %04x!\n", pVM->rem.s.Env.segs[R_GS].selector, pCtx->gs.Sel));
    2424             sync_seg(&pVM->rem.s.Env, R_GS, pCtx->gs.Sel);
    2425 #ifdef VBOX_WITH_STATISTICS
    2426             if (pVM->rem.s.Env.segs[R_GS].newselector)
    2427             {
    2428                 STAM_COUNTER_INC(&gStatSelOutOfSync[R_GS]);
    2429             }
    2430 #endif
    2431         }
    2432         else
    2433             pVM->rem.s.Env.segs[R_GS].newselector = 0;
    2434     }
    24352414
    24362415    /*
    … …  
    26832662            /* Qemu and AMD/Intel have different ideas about the busy flag ... */
    26842663        ||  pCtx->tr.Attr.u   != (  (pVM->rem.s.Env.tr.flags >> 8) & 0xF0FF
    2685                                      ? (pVM->rem.s.Env.tr.flags | DESC_TSS_BUSY_MASK) >> 8
    2686                                      : 0)
     2664                                  ? (pVM->rem.s.Env.tr.flags | DESC_TSS_BUSY_MASK) >> 8
     2665                                  : 0)
    26872666        ||  !(pCtx->tr.fFlags & CPUMSELREG_FLAGS_VALID)
    26882667       )
    … …  
    29052884            /* Qemu and AMD/Intel have different ideas about the busy flag ... */
    29062885        ||  pCtx->tr.Attr.u   != (  (pVM->rem.s.Env.tr.flags >> 8) & 0xF0FF
    2907                                      ? (pVM->rem.s.Env.tr.flags | DESC_TSS_BUSY_MASK) >> 8
    2908                                      : 0)
     2886                                  ? (pVM->rem.s.Env.tr.flags | DESC_TSS_BUSY_MASK) >> 8
     2887                                  : 0)
    29092888        ||  !(pCtx->tr.fFlags & CPUMSELREG_FLAGS_VALID)
    29102889       )

  • trunk/src/recompiler/target-i386/cpu.h

    r38319 r42407  
    6565# include <VBox/vmm/vmm.h>
    6666# include <VBox/vmm/stam.h>
     67# include <VBox/vmm/cpumctx.h>
    6768#endif /* VBOX */
    6869
    … …  
    532533typedef struct SegmentCache {
    533534    uint32_t selector;
     535#ifdef VBOX
     536    /** The new selector is saved here when we are unable to sync it before invoking the recompiled code. */
     537    uint16_t newselector;
     538    uint16_t fVBoxFlags;
     539#endif
    534540    target_ulong base;
    535541    uint32_t limit;
    536542    uint32_t flags;
    537 #ifdef VBOX
    538     /** The new selector is saved here when we are unable to sync it before invoking the recompiled code. */
    539     uint32_t newselector;
    540 #endif
    541543} SegmentCache;
    542544
    … …  
    942944    sc->base = base;
    943945    sc->limit = limit;
     946#ifndef VBOX
    944947    sc->flags = flags;
    945 #ifdef VBOX
     948#else
     949    if (flags & DESC_P_MASK)
     950        flags |= DESC_A_MASK;           /* Make sure the A bit is set to avoid trouble. */
     951    sc->flags = flags;
    946952    sc->newselector = 0;
     953    sc->fVBoxFlags  = CPUMSELREG_FLAGS_VALID;
    947954#endif
    948955

  • trunk/src/recompiler/target-i386/op_helper.c

    r39969 r42407  
    254254    sc->limit = get_seg_limit(e1, e2);
    255255    sc->flags = e2;
     256#ifdef VBOX
     257    sc->newselector = 0;
     258    sc->fVBoxFlags  = CPUMSELREG_FLAGS_VALID;
     259#endif
    256260}
    257261
    … …  
    557561    env->tr.limit = tss_limit;
    558562    env->tr.flags = e2 & ~DESC_TSS_BUSY_MASK;
     563#ifdef VBOX
     564    env->tr.fVBoxFlags  = CPUMSELREG_FLAGS_VALID;
     565    env->tr.newselector = 0;
     566#endif
    559567
    560568    if ((type & 8) && (env->cr[0] & CR0_PG_MASK)) {
    … …  
    596604    env->ldt.limit = 0;
    597605    env->ldt.flags = 0;
     606#ifdef VBOX
     607    env->ldt.fVBoxFlags  = CPUMSELREG_FLAGS_VALID;
     608    env->ldt.newselector = 0;
     609#endif
    598610
    599611    /* load the LDT */
    … …  
    19541966    env->ldt.limit = ldl_phys(sm_state + 0x7e74);
    19551967    env->ldt.flags = (lduw_phys(sm_state + 0x7e72) & 0xf0ff) << 8;
     1968#ifdef VBOX
     1969    env->ldt.fVBoxFlags = CPUMSELREG_FLAGS_VALID;
     1970    env->ldt.newselector = 0;
     1971#endif
    19561972
    19571973    env->idt.base = ldq_phys(sm_state + 0x7e88);
    … …  
    19621978    env->tr.limit = ldl_phys(sm_state + 0x7e94);
    19631979    env->tr.flags = (lduw_phys(sm_state + 0x7e92) & 0xf0ff) << 8;
     1980#ifdef VBOX
     1981    env->tr.fVBoxFlags = CPUMSELREG_FLAGS_VALID;
     1982    env->tr.newselector = 0;
     1983#endif
    19641984
    19651985    EAX = ldq_phys(sm_state + 0x7ff8);
    … …  
    20082028    env->tr.limit = ldl_phys(sm_state + 0x7f60);
    20092029    env->tr.flags = (ldl_phys(sm_state + 0x7f5c) & 0xf0ff) << 8;
     2030#ifdef VBOX
     2031    env->tr.fVBoxFlags  = CPUMSELREG_FLAGS_VALID;
     2032    env->tr.newselector = 0;
     2033#endif
    20102034
    20112035    env->ldt.selector = ldl_phys(sm_state + 0x7fc0) & 0xffff;
    … …  
    20132037    env->ldt.limit = ldl_phys(sm_state + 0x7f7c);
    20142038    env->ldt.flags = (ldl_phys(sm_state + 0x7f78) & 0xf0ff) << 8;
     2039#ifdef VBOX
     2040    env->ldt.fVBoxFlags  = CPUMSELREG_FLAGS_VALID;
     2041    env->ldt.newselector = 0;
     2042#endif
    20152043
    20162044    env->gdt.base = ldl_phys(sm_state + 0x7f74);
    … …  
    24482476        env->ldt.base = 0;
    24492477        env->ldt.limit = 0;
     2478#ifdef VBOX
     2479        env->ldt.fVBoxFlags = CPUMSELREG_FLAGS_VALID;
     2480        env->ldt.newselector = 0;
     2481#endif
    24502482    } else {
    24512483        if (selector & 0x4)
    … …  
    25102542        env->tr.limit = 0;
    25112543        env->tr.flags = 0;
     2544#ifdef VBOX
     2545        env->tr.fVBoxFlags  = CPUMSELREG_FLAGS_VALID;
     2546        env->tr.newselector = 0;
     2547#endif
    25122548    } else {
    25132549        if (selector & 0x4)
    … …  
    57245760
    57255761        /* Successful sync. */
    5726         env1->segs[seg_reg].newselector = 0;
     5762        Assert(env1->segs[seg_reg].newselector == 0);
    57275763    }
    57285764    else
    … …  
    57415777                load_segment(&e1, &e2, selector);
    57425778                cpu_x86_load_seg_cache(env, R_CS, selector,
    5743                                get_seg_base(e1, e2),
    5744                                get_seg_limit(e1, e2),
    5745                                e2);
     5779                                       get_seg_base(e1, e2),
     5780                                       get_seg_limit(e1, e2),
     5781                                       e2);
    57465782            }
    57475783            else
    … …  
    57535789
    57545790            /* Successful sync. */
    5755             env1->segs[seg_reg].newselector = 0;
     5791            Assert(env1->segs[seg_reg].newselector == 0);
    57565792        }
    57575793        else
Note: See TracChangeset for help on using the changeset viewer.

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