VirtualBox

Ignore:
Timestamp:
Mar 15, 2024 2:09:47 PM (11 months ago)
Author:
vboxsync
Message:

ValKit/bs3-cpu-instr-3: Introducing BS3_THRESHOLD_NATIVE_RECOMPILER and applying it to bs3-cpu-instr-3. bugref:10614

Location:
trunk/src/VBox/ValidationKit/bootsectors
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/VBox/ValidationKit/bootsectors/bs3-cpu-instr-3.c32

    r103751 r103867  
    574574#undef  BS3_SKIPIT_DO_ARGS
    575575
    576 #if defined(BS3_SKIPIT_DO_SKIP)
    577 uint32_t BS3_ASMrdtsc_lo();
    578 #pragma aux BS3_ASMrdtsc_lo = \
    579     ".586" \
    580     "rdtsc" \
    581     modify [edx eax] value [eax];
    582 
    583 DECLINLINE(uint32_t) bs3CpuInstr3_SimpleRand()
     576#ifndef BS3_SKIPIT_DO_SKIP
     577# define BS3_SKIPIT(bRing, iCfg, iTest, iVal, iVariant) (false)
     578#else
     579# include <iprt/asm-amd64-x86.h>
     580/** @todo port to 32-bit watcom: iprt/asm-math.h */
     581
     582DECLINLINE(uint32_t) bs3CpuInstr3_SimpleRand(void)
    584583{
    585584    /*
     
    594593     */
    595594    static uint32_t s_uSeedMemory = 0;
    596 
    597     RTUINT64U uProduct;
    598     uint32_t uHiMod, uLoMod;
    599 
    600595    if (!s_uSeedMemory)
    601         s_uSeedMemory = BS3_ASMrdtsc_lo();
    602 
    603     uProduct.u = (uint64_t)s_uSeedMemory * 16807;
    604     /*
    605      * This piece-wise modulus operation is vastly faster
    606      * than openwatcom's built-in 64-div-32 routine!
    607      *
    608      * Math:    high longword's effect % INT32_MAX
    609      *       = (high longword * 2^32) % INT32_MAX
    610      *       = (high longword * (2^32 - 2 * INT32_MAX)) % INT32_MAX
    611      *       = (high longword * 2) % INT32_MAX
    612      *       = (high longword * 2), since uProduct is a 'small' 64-bit value
    613      *              (high longword of a 32-bit-value * 16807, a 15-bit value)
    614      */
    615     uHiMod = uProduct.au32[1] * 2;
    616     uLoMod = uProduct.au32[0] % INT32_MAX;
    617     s_uSeedMemory = (uHiMod + uLoMod) % INT32_MAX;
     596        s_uSeedMemory = (uint32_t)ASMReadTSC();
     597
     598# if 0 /* see Runtime/common/rand/randparkmiller.cpp - unfortunately the two mul+div wrappers haven't been ported to watcom speak */
     599    s_uSeedMemory = ASMModU64ByU32RetU32(ASMMult2xU32RetU64(s_uSeedMemory, 16807), INT32_MAX);
     600# else
     601    {
     602        RTUINT64U uProduct;
     603        uint32_t uHiMod, uLoMod;
     604        uProduct.u = (uint64_t)s_uSeedMemory * 16807;
     605        /*
     606         * This piece-wise modulus operation is vastly faster
     607         * than openwatcom's built-in 64-div-32 routine!
     608         *
     609         * Math:    high longword's effect % INT32_MAX
     610         *       = (high longword * 2^32) % INT32_MAX
     611         *       = (high longword * (2^32 - 2 * INT32_MAX)) % INT32_MAX
     612         *       = (high longword * 2) % INT32_MAX
     613         *       = (high longword * 2), since uProduct is a 'small' 64-bit value
     614         *              (high longword of a 32-bit-value * 16807, a 15-bit value)
     615         */
     616        uHiMod = uProduct.au32[1] * 2;
     617        uLoMod = uProduct.au32[0] % INT32_MAX;
     618        s_uSeedMemory = (uHiMod + uLoMod) % INT32_MAX;
     619    }
     620# endif
    618621    return s_uSeedMemory;
    619622}
    620 #endif /* BS3_SKIPIT_DO_SKIP */
    621623
    622624static unsigned g_cSeen, g_cSkipped;
    623625
    624 static void bs3CpuInstr3_ShowTallies()
     626static void bs3CpuInstr3_ShowTallies(void)
    625627{
    626628    Bs3TestPrintf("Micro-tests %d: tested %d / skipped %d\n", g_cSeen, g_cSeen - g_cSkipped, g_cSkipped);
    627629}
    628630
    629 #if defined(BS3_SKIPIT_DO_ARGS)
    630 # define BS3_SKIPIT(bRing, iCfg, iTest, iVal, iVariant) bs3CpuInstr3_SkipIt(bRing, iCfg, iTest, iVal, iVariant)
    631 static unsigned bs3CpuInstr3_SkipIt(uint8_t bRing, unsigned iCfg, unsigned iTest, unsigned iVal, unsigned iVariant)
    632 #else
    633 # define BS3_SKIPIT(bRing, iCfg, iTest, iVal, iVariant) bs3CpuInstr3_SkipIt()
    634 static unsigned bs3CpuInstr3_SkipIt()
    635 #endif
     631# ifdef BS3_SKIPIT_DO_ARGS
     632#  define BS3_SKIPIT(bRing, iCfg, iTest, iVal, iVariant) bs3CpuInstr3_SkipIt(bRing, iCfg, iTest, iVal, iVariant)
     633static bool bs3CpuInstr3_SkipIt(uint8_t bRing, unsigned iCfg, unsigned iTest, unsigned iVal, unsigned iVariant)
     634# else
     635#  define BS3_SKIPIT(bRing, iCfg, iTest, iVal, iVariant) bs3CpuInstr3_SkipIt()
     636static bool bs3CpuInstr3_SkipIt(void)
     637# endif
    636638{
    637639    static unsigned s_uTimes = 0;
    638     unsigned uRet;
    639 
    640     ++g_cSeen;
    641 #if !defined(BS3_SKIPIT_DO_SKIP)
    642     return (uRet = s_uTimes);
    643 #else
     640    bool fSkip;
     641
    644642    /* Cache calls to the relatively expensive random routine */
    645     if (!s_uTimes) {
     643    if (!s_uTimes)
    646644        s_uTimes = bs3CpuInstr3_SimpleRand() % (BS3_SKIPIT_AVG_SKIP * 2 + 1) + 1;
    647     }
    648     uRet = (--s_uTimes > 0);
    649     if (uRet)
     645    fSkip = --s_uTimes > 0;
     646    if (fSkip)
    650647        ++g_cSkipped;
    651     if (g_cSeen % 25000 == 0)
     648
     649    if (++g_cSeen % 25000 == 0)
    652650        bs3CpuInstr3_ShowTallies();
    653     return uRet;
    654 #endif /* !BS3_SKIPIT_DO_SKIP */
     651    return fSkip;
    655652}
     653
     654#endif /* BS3_SKIPIT_DO_SKIP */
     655
    656656
    657657/*
     
    754754                                            : BS3_MODE_IS_RM_OR_V86(bMode) ? X86_XCPT_UD : paConfigs[iCfg].bXcptAvx;
    755755                uint16_t        idTestStep  = bRing * 10000 + iCfg * 100 + iTest * 10;
     756                unsigned        cRecompRuns = 0;
    756757                unsigned        iVal;
    757758
     
    775776                 * Iterate the test values and do the actual testing.
    776777                 */
    777                 for (iVal = 0; iVal < cValues; iVal++, idTestStep++)
    778                 {
    779                     uint16_t   cErrors;
    780                     uint16_t   uSavedFtw = 0xff;
    781                     RTUINT256U uMemOpExpect;
    782 
    783                     if (BS3_SKIPIT(bRing, iCfg, iTest, iVal, 0)) continue;
    784                     /*
    785                      * Set up the context and some expectations.
    786                      */
    787                     /* dest */
    788                     if (paTests[iTest].iRegDst == UINT8_MAX)
     778                while (cRecompRuns < BS3_THRESHOLD_NATIVE_RECOMPILER * 2)
     779                    for (iVal = 0; iVal < cValues; iVal++, idTestStep++)
    789780                    {
    790                         BS3_ASSERT(paTests[iTest].enmRm >= RM_MEM);
    791                         Bs3MemSet(puMemOp, 0xcc, cbMemOp);
    792                         if (bXcptExpect == X86_XCPT_DB)
    793                             uMemOpExpect = paValues[iVal].uDstOut;
     781                        uint16_t   cErrors;
     782                        uint16_t   uSavedFtw = 0xff;
     783                        RTUINT256U uMemOpExpect;
     784
     785                        if (BS3_SKIPIT(bRing, iCfg, iTest, iVal, 0)) continue;
     786                        cRecompRuns++;
     787
     788                        /*
     789                         * Set up the context and some expectations.
     790                         */
     791                        /* dest */
     792                        if (paTests[iTest].iRegDst == UINT8_MAX)
     793                        {
     794                            BS3_ASSERT(paTests[iTest].enmRm >= RM_MEM);
     795                            Bs3MemSet(puMemOp, 0xcc, cbMemOp);
     796                            if (bXcptExpect == X86_XCPT_DB)
     797                                uMemOpExpect = paValues[iVal].uDstOut;
     798                            else
     799                                Bs3MemSet(&uMemOpExpect, 0xcc, sizeof(uMemOpExpect));
     800                        }
     801                        else if (fMmxInstr)
     802                            Bs3ExtCtxSetMm(pExtCtx, paTests[iTest].iRegSrc2, ~paValues[iVal].uDstOut.QWords.qw0, BS3EXTCTXTOPMM_ZERO);
     803
     804                        /* source #1 (/ destination for MMX and SSE) */
     805                        if (paTests[iTest].iRegSrc1 == UINT8_MAX)
     806                        {
     807                            BS3_ASSERT(paTests[iTest].enmRm >= RM_MEM);
     808                            Bs3MemCpy(puMemOp, &paValues[iVal].uSrc1, cbMemOp);
     809                            if (paTests[iTest].iRegDst == UINT8_MAX)
     810                                BS3_ASSERT(fSseInstr);
     811                            else
     812                                uMemOpExpect = paValues[iVal].uSrc1;
     813                        }
     814                        else if (fMmxInstr)
     815                            Bs3ExtCtxSetMm(pExtCtx, paTests[iTest].iRegSrc1, paValues[iVal].uSrc1.QWords.qw0, BS3EXTCTXTOPMM_ZERO);
     816                        else if (fSseInstr)
     817                            Bs3ExtCtxSetXmm(pExtCtx, paTests[iTest].iRegSrc1, &paValues[iVal].uSrc1.DQWords.dqw0);
    794818                        else
    795                             Bs3MemSet(&uMemOpExpect, 0xcc, sizeof(uMemOpExpect));
     819                            Bs3ExtCtxSetYmm(pExtCtx, paTests[iTest].iRegSrc1, &paValues[iVal].uSrc1, 32);
     820
     821                        /* source #2 */
     822                        if (paTests[iTest].iRegSrc2 == UINT8_MAX)
     823                        {
     824                            BS3_ASSERT(paTests[iTest].enmRm >= RM_MEM);
     825                            BS3_ASSERT(paTests[iTest].iRegDst != UINT8_MAX && paTests[iTest].iRegSrc1 != UINT8_MAX);
     826                            Bs3MemCpy(puMemOp, &paValues[iVal].uSrc2, cbMemOp);
     827                            uMemOpExpect = paValues[iVal].uSrc2;
     828                        }
     829                        else if (fMmxInstr)
     830                            Bs3ExtCtxSetMm(pExtCtx, paTests[iTest].iRegSrc2, paValues[iVal].uSrc2.QWords.qw0, BS3EXTCTXTOPMM_ZERO);
     831                        else if (fSseInstr)
     832                            Bs3ExtCtxSetXmm(pExtCtx, paTests[iTest].iRegSrc2, &paValues[iVal].uSrc2.DQWords.dqw0);
     833                        else
     834                            Bs3ExtCtxSetYmm(pExtCtx, paTests[iTest].iRegSrc2, &paValues[iVal].uSrc2, 32);
     835
     836                        /* Memory pointer. */
     837                        if (paTests[iTest].enmRm >= RM_MEM)
     838                        {
     839                            BS3_ASSERT(   paTests[iTest].iRegDst  == UINT8_MAX
     840                                       || paTests[iTest].iRegSrc1 == UINT8_MAX
     841                                       || paTests[iTest].iRegSrc2 == UINT8_MAX);
     842                            Bs3RegCtxSetGrpSegFromCurPtr(&Ctx, &Ctx.rbx, &Ctx.fs, puMemOp);
     843                        }
     844
     845                        /*
     846                         * Execute.
     847                         */
     848                        Bs3TrapSetJmpAndRestoreWithExtCtxAndRm(&Ctx, pExtCtx, &TrapFrame, pExtCtxOut);
     849
     850                        /*
     851                         * Check the result:
     852                         */
     853                        cErrors = Bs3TestSubErrorCount();
     854
     855                        if (fMmxInstr && bXcptExpect == X86_XCPT_DB)
     856                        {
     857                            uSavedFtw = Bs3ExtCtxGetAbridgedFtw(pExtCtx);
     858                            Bs3ExtCtxSetAbridgedFtw(pExtCtx, 0xff); /* Observed on 10980xe after pxor mm1, mm2. */
     859                        }
     860                        if (bXcptExpect == X86_XCPT_DB && paTests[iTest].iRegDst != UINT8_MAX)
     861                        {
     862                            if (fMmxInstr)
     863                                Bs3ExtCtxSetMm(pExtCtx, paTests[iTest].iRegDst, paValues[iVal].uDstOut.QWords.qw0, BS3EXTCTXTOPMM_SET);
     864                            else if (fSseInstr)
     865                                Bs3ExtCtxSetXmm(pExtCtx, paTests[iTest].iRegDst, &paValues[iVal].uDstOut.DQWords.dqw0);
     866                            else
     867                                Bs3ExtCtxSetYmm(pExtCtx, paTests[iTest].iRegDst, &paValues[iVal].uDstOut, cbOperand);
     868                        }
     869    #if defined(DEBUG_aeichner) /** @todo Necessary kludge on a i7-1068NG7. */
     870                        if (   pExtCtx->enmMethod == BS3EXTCTXMETHOD_XSAVE
     871                            && pExtCtx->Ctx.x.Hdr.bmXState == 0x7
     872                            && pExtCtxOut->Ctx.x.Hdr.bmXState == 0x3)
     873                            pExtCtxOut->Ctx.x.Hdr.bmXState = 0x7;
     874    #endif
     875                        Bs3TestCheckExtCtx(pExtCtxOut, pExtCtx, 0 /*fFlags*/, pszMode, idTestStep);
     876
     877                        if (TrapFrame.bXcpt != bXcptExpect)
     878                            Bs3TestFailedF("Expected bXcpt = %#x, got %#x", bXcptExpect, TrapFrame.bXcpt);
     879
     880                        /* Kludge! Looks like EFLAGS.AC is cleared when raising #GP in real mode on the 10980XE. WEIRD! */
     881                        if (bMode == BS3_MODE_RM && (Ctx.rflags.u32 & X86_EFL_AC))
     882                        {
     883                            if (TrapFrame.Ctx.rflags.u32 & X86_EFL_AC)
     884                                Bs3TestFailedF("Expected EFLAGS.AC to be cleared (bXcpt=%d)", TrapFrame.bXcpt);
     885                            TrapFrame.Ctx.rflags.u32 |= X86_EFL_AC;
     886                        }
     887                        Bs3TestCheckRegCtxEx(&TrapFrame.Ctx, &Ctx, bXcptExpect == X86_XCPT_DB ? cbInstr + 1 : 0, 0,
     888                                             bXcptExpect == X86_XCPT_DB || BS3_MODE_IS_16BIT_SYS(bMode) ? 0 : X86_EFL_RF,
     889                                             pszMode, idTestStep);
     890
     891                        if (   paTests[iTest].enmRm >= RM_MEM
     892                            && Bs3MemCmp(puMemOp, &uMemOpExpect, cbMemOp) != 0)
     893                            Bs3TestFailedF("Expected uMemOp %.*Rhxs, got %.*Rhxs", cbMemOp, &uMemOpExpect, cbMemOp, puMemOp);
     894
     895                        if (cErrors != Bs3TestSubErrorCount())
     896                        {
     897                            if (paConfigs[iCfg].fAligned)
     898                                Bs3TestFailedF("ring-%d/cfg#%u/test#%u/value#%u failed (bXcptExpect=%#x)",
     899                                               bRing, iCfg, iTest, iVal, bXcptExpect);
     900                            else
     901                                Bs3TestFailedF("ring-%d/cfg#%u/test#%u/value#%u failed (bXcptExpect=%#x, puMemOp=%p, EFLAGS=%#RX32, CR0=%#RX32)",
     902                                               bRing, iCfg, iTest, iVal, bXcptExpect, puMemOp, TrapFrame.Ctx.rflags.u32, TrapFrame.Ctx.cr0);
     903                            Bs3TestPrintf("\n");
     904                        }
     905
     906                        if (uSavedFtw != 0xff)
     907                            Bs3ExtCtxSetAbridgedFtw(pExtCtx, uSavedFtw);
    796908                    }
    797                     else if (fMmxInstr)
    798                         Bs3ExtCtxSetMm(pExtCtx, paTests[iTest].iRegSrc2, ~paValues[iVal].uDstOut.QWords.qw0, BS3EXTCTXTOPMM_ZERO);
    799 
    800                     /* source #1 (/ destination for MMX and SSE) */
    801                     if (paTests[iTest].iRegSrc1 == UINT8_MAX)
    802                     {
    803                         BS3_ASSERT(paTests[iTest].enmRm >= RM_MEM);
    804                         Bs3MemCpy(puMemOp, &paValues[iVal].uSrc1, cbMemOp);
    805                         if (paTests[iTest].iRegDst == UINT8_MAX)
    806                             BS3_ASSERT(fSseInstr);
    807                         else
    808                             uMemOpExpect = paValues[iVal].uSrc1;
    809                     }
    810                     else if (fMmxInstr)
    811                         Bs3ExtCtxSetMm(pExtCtx, paTests[iTest].iRegSrc1, paValues[iVal].uSrc1.QWords.qw0, BS3EXTCTXTOPMM_ZERO);
    812                     else if (fSseInstr)
    813                         Bs3ExtCtxSetXmm(pExtCtx, paTests[iTest].iRegSrc1, &paValues[iVal].uSrc1.DQWords.dqw0);
    814                     else
    815                         Bs3ExtCtxSetYmm(pExtCtx, paTests[iTest].iRegSrc1, &paValues[iVal].uSrc1, 32);
    816 
    817                     /* source #2 */
    818                     if (paTests[iTest].iRegSrc2 == UINT8_MAX)
    819                     {
    820                         BS3_ASSERT(paTests[iTest].enmRm >= RM_MEM);
    821                         BS3_ASSERT(paTests[iTest].iRegDst != UINT8_MAX && paTests[iTest].iRegSrc1 != UINT8_MAX);
    822                         Bs3MemCpy(puMemOp, &paValues[iVal].uSrc2, cbMemOp);
    823                         uMemOpExpect = paValues[iVal].uSrc2;
    824                     }
    825                     else if (fMmxInstr)
    826                         Bs3ExtCtxSetMm(pExtCtx, paTests[iTest].iRegSrc2, paValues[iVal].uSrc2.QWords.qw0, BS3EXTCTXTOPMM_ZERO);
    827                     else if (fSseInstr)
    828                         Bs3ExtCtxSetXmm(pExtCtx, paTests[iTest].iRegSrc2, &paValues[iVal].uSrc2.DQWords.dqw0);
    829                     else
    830                         Bs3ExtCtxSetYmm(pExtCtx, paTests[iTest].iRegSrc2, &paValues[iVal].uSrc2, 32);
    831 
    832                     /* Memory pointer. */
    833                     if (paTests[iTest].enmRm >= RM_MEM)
    834                     {
    835                         BS3_ASSERT(   paTests[iTest].iRegDst  == UINT8_MAX
    836                                    || paTests[iTest].iRegSrc1 == UINT8_MAX
    837                                    || paTests[iTest].iRegSrc2 == UINT8_MAX);
    838                         Bs3RegCtxSetGrpSegFromCurPtr(&Ctx, &Ctx.rbx, &Ctx.fs, puMemOp);
    839                     }
    840 
    841                     /*
    842                      * Execute.
    843                      */
    844                     Bs3TrapSetJmpAndRestoreWithExtCtxAndRm(&Ctx, pExtCtx, &TrapFrame, pExtCtxOut);
    845 
    846                     /*
    847                      * Check the result:
    848                      */
    849                     cErrors = Bs3TestSubErrorCount();
    850 
    851                     if (fMmxInstr && bXcptExpect == X86_XCPT_DB)
    852                     {
    853                         uSavedFtw = Bs3ExtCtxGetAbridgedFtw(pExtCtx);
    854                         Bs3ExtCtxSetAbridgedFtw(pExtCtx, 0xff); /* Observed on 10980xe after pxor mm1, mm2. */
    855                     }
    856                     if (bXcptExpect == X86_XCPT_DB && paTests[iTest].iRegDst != UINT8_MAX)
    857                     {
    858                         if (fMmxInstr)
    859                             Bs3ExtCtxSetMm(pExtCtx, paTests[iTest].iRegDst, paValues[iVal].uDstOut.QWords.qw0, BS3EXTCTXTOPMM_SET);
    860                         else if (fSseInstr)
    861                             Bs3ExtCtxSetXmm(pExtCtx, paTests[iTest].iRegDst, &paValues[iVal].uDstOut.DQWords.dqw0);
    862                         else
    863                             Bs3ExtCtxSetYmm(pExtCtx, paTests[iTest].iRegDst, &paValues[iVal].uDstOut, cbOperand);
    864                     }
    865 #if defined(DEBUG_aeichner) /** @todo Necessary kludge on a i7-1068NG7. */
    866                     if (   pExtCtx->enmMethod == BS3EXTCTXMETHOD_XSAVE
    867                         && pExtCtx->Ctx.x.Hdr.bmXState == 0x7
    868                         && pExtCtxOut->Ctx.x.Hdr.bmXState == 0x3)
    869                         pExtCtxOut->Ctx.x.Hdr.bmXState = 0x7;
    870 #endif
    871                     Bs3TestCheckExtCtx(pExtCtxOut, pExtCtx, 0 /*fFlags*/, pszMode, idTestStep);
    872 
    873                     if (TrapFrame.bXcpt != bXcptExpect)
    874                         Bs3TestFailedF("Expected bXcpt = %#x, got %#x", bXcptExpect, TrapFrame.bXcpt);
    875 
    876                     /* Kludge! Looks like EFLAGS.AC is cleared when raising #GP in real mode on the 10980XE. WEIRD! */
    877                     if (bMode == BS3_MODE_RM && (Ctx.rflags.u32 & X86_EFL_AC))
    878                     {
    879                         if (TrapFrame.Ctx.rflags.u32 & X86_EFL_AC)
    880                             Bs3TestFailedF("Expected EFLAGS.AC to be cleared (bXcpt=%d)", TrapFrame.bXcpt);
    881                         TrapFrame.Ctx.rflags.u32 |= X86_EFL_AC;
    882                     }
    883                     Bs3TestCheckRegCtxEx(&TrapFrame.Ctx, &Ctx, bXcptExpect == X86_XCPT_DB ? cbInstr + 1 : 0, 0,
    884                                          bXcptExpect == X86_XCPT_DB || BS3_MODE_IS_16BIT_SYS(bMode) ? 0 : X86_EFL_RF,
    885                                          pszMode, idTestStep);
    886 
    887                     if (   paTests[iTest].enmRm >= RM_MEM
    888                         && Bs3MemCmp(puMemOp, &uMemOpExpect, cbMemOp) != 0)
    889                         Bs3TestFailedF("Expected uMemOp %.*Rhxs, got %.*Rhxs", cbMemOp, &uMemOpExpect, cbMemOp, puMemOp);
    890 
    891                     if (cErrors != Bs3TestSubErrorCount())
    892                     {
    893                         if (paConfigs[iCfg].fAligned)
    894                             Bs3TestFailedF("ring-%d/cfg#%u/test#%u/value#%u failed (bXcptExpect=%#x)",
    895                                            bRing, iCfg, iTest, iVal, bXcptExpect);
    896                         else
    897                             Bs3TestFailedF("ring-%d/cfg#%u/test#%u/value#%u failed (bXcptExpect=%#x, puMemOp=%p, EFLAGS=%#RX32, CR0=%#RX32)",
    898                                            bRing, iCfg, iTest, iVal, bXcptExpect, puMemOp, TrapFrame.Ctx.rflags.u32, TrapFrame.Ctx.cr0);
    899                         Bs3TestPrintf("\n");
    900                     }
    901 
    902                     if (uSavedFtw != 0xff)
    903                         Bs3ExtCtxSetAbridgedFtw(pExtCtx, uSavedFtw);
    904                 }
    905909            }
    906910
     
    92289232                                            : RT_BIT_64(paTests[iTest].cBitsGprValMask) - 1;
    92299233                uint16_t        idTestStep  = bRing * 10000 + iCfg * 100 + iTest * 10;
     9234                unsigned        cRecompRuns = 0;
    92309235                unsigned        iVal;
    92319236
     
    92499254                 * Iterate the test values and do the actual testing.
    92509255                 */
    9251                 for (iVal = 0; iVal < cValues; iVal++, idTestStep++)
    9252                 {
    9253                     uint16_t   cErrors;
    9254                     uint16_t   uSavedFtw = 0xff;
    9255                     RTUINT256U uMemOpExpect;
    9256 
    9257                     if (BS3_SKIPIT(bRing, iCfg, iTest, iVal, 0)) continue;
    9258                     /*
    9259                      * Set up the context and some expectations.
    9260                      */
    9261                     if (fGprDst)
     9256                while (cRecompRuns < BS3_THRESHOLD_NATIVE_RECOMPILER * 2)
     9257                    for (iVal = 0; iVal < cValues; iVal++, idTestStep++)
    92629258                    {
    9263                         /* dest - gpr/mem */
    9264                         if (paTests[iTest].iGprReg == UINT8_MAX)
     9259                        uint16_t   cErrors;
     9260                        uint16_t   uSavedFtw = 0xff;
     9261                        RTUINT256U uMemOpExpect;
     9262
     9263                        if (BS3_SKIPIT(bRing, iCfg, iTest, iVal, 0)) continue;
     9264                        cRecompRuns++;
     9265
     9266                        /*
     9267                         * Set up the context and some expectations.
     9268                         */
     9269                        if (fGprDst)
    92659270                        {
    9266                             BS3_ASSERT(paTests[iTest].enmRm >= RM_MEM);
    9267                             Bs3MemSet(puMemOp, 0xcc, cbMemOp);
    9268                             if (bXcptExpect != X86_XCPT_DB)
    9269                                 Bs3MemSet(&uMemOpExpect, 0xcc, sizeof(uMemOpExpect));
    9270                             else
     9271                            /* dest - gpr/mem */
     9272                            if (paTests[iTest].iGprReg == UINT8_MAX)
    92719273                            {
    9272                                 Bs3MemSet(&uMemOpExpect, 0xaa, sizeof(uMemOpExpect));
    9273                                 switch (paTests[iTest].cbGpr)
     9274                                BS3_ASSERT(paTests[iTest].enmRm >= RM_MEM);
     9275                                Bs3MemSet(puMemOp, 0xcc, cbMemOp);
     9276                                if (bXcptExpect != X86_XCPT_DB)
     9277                                    Bs3MemSet(&uMemOpExpect, 0xcc, sizeof(uMemOpExpect));
     9278                                else
    92749279                                {
    9275                                     case 1: uMemOpExpect.au8[0]  = (uint8_t) (paValues[iVal].uGpr & fGprValMask); break;
    9276                                     case 2: uMemOpExpect.au16[0] = (uint16_t)(paValues[iVal].uGpr & fGprValMask); break;
    9277                                     case 4: uMemOpExpect.au32[0] = (uint32_t)(paValues[iVal].uGpr & fGprValMask); break;
    9278                                     case 8: uMemOpExpect.au64[0] =           (paValues[iVal].uGpr & fGprValMask); break;
    9279                                     default: BS3_ASSERT(0);
     9280                                    Bs3MemSet(&uMemOpExpect, 0xaa, sizeof(uMemOpExpect));
     9281                                    switch (paTests[iTest].cbGpr)
     9282                                    {
     9283                                        case 1: uMemOpExpect.au8[0]  = (uint8_t) (paValues[iVal].uGpr & fGprValMask); break;
     9284                                        case 2: uMemOpExpect.au16[0] = (uint16_t)(paValues[iVal].uGpr & fGprValMask); break;
     9285                                        case 4: uMemOpExpect.au32[0] = (uint32_t)(paValues[iVal].uGpr & fGprValMask); break;
     9286                                        case 8: uMemOpExpect.au64[0] =           (paValues[iVal].uGpr & fGprValMask); break;
     9287                                        default: BS3_ASSERT(0);
     9288                                    }
    92809289                                }
    92819290                            }
     9291                            else
     9292                                Bs3RegCtxSetGpr(&Ctx, paTests[iTest].iGprReg, UINT64_C(0xcccccccccccccccc),
     9293                                                BS3_MODE_IS_64BIT_CODE(bMode) ? 8 : 4); /* we only restore 63:32 when bMode==LM64 */
     9294
     9295                            /* source - media/mem */
     9296                            if (paTests[iTest].iMediaReg == UINT8_MAX)
     9297                            {
     9298                                BS3_ASSERT(paTests[iTest].enmRm >= RM_MEM);
     9299                                BS3_ASSERT(paTests[iTest].iGprReg != UINT8_MAX);
     9300                                Bs3MemCpy(puMemOp, &paValues[iVal].uMedia, cbMemOp);
     9301                                uMemOpExpect = paValues[iVal].uMedia;
     9302                            }
     9303                            else if (fMmxInstr)
     9304                                Bs3ExtCtxSetMm(pExtCtx, paTests[iTest].iMediaReg, paValues[iVal].uMedia.QWords.qw0, BS3EXTCTXTOPMM_ZERO);
     9305                            else if (fSseInstr)
     9306                                Bs3ExtCtxSetXmm(pExtCtx, paTests[iTest].iMediaReg, &paValues[iVal].uMedia.DQWords.dqw0);
     9307                            else
     9308                                Bs3ExtCtxSetYmm(pExtCtx, paTests[iTest].iMediaReg, &paValues[iVal].uMedia, 32);
    92829309                        }
    92839310                        else
    9284                             Bs3RegCtxSetGpr(&Ctx, paTests[iTest].iGprReg, UINT64_C(0xcccccccccccccccc),
    9285                                             BS3_MODE_IS_64BIT_CODE(bMode) ? 8 : 4); /* we only restore 63:32 when bMode==LM64 */
    9286 
    9287                         /* source - media/mem */
    9288                         if (paTests[iTest].iMediaReg == UINT8_MAX)
    92899311                        {
    9290                             BS3_ASSERT(paTests[iTest].enmRm >= RM_MEM);
    9291                             BS3_ASSERT(paTests[iTest].iGprReg != UINT8_MAX);
    9292                             Bs3MemCpy(puMemOp, &paValues[iVal].uMedia, cbMemOp);
    9293                             uMemOpExpect = paValues[iVal].uMedia;
     9312                            /* dest - media */
     9313                            if (paTests[iTest].iMediaReg == UINT8_MAX)
     9314                            {
     9315                                BS3_ASSERT(paTests[iTest].enmRm >= RM_MEM);
     9316                                Bs3MemSet(puMemOp, 0xcc, cbMemOp);
     9317                                if (bXcptExpect == X86_XCPT_DB)
     9318                                    uMemOpExpect = paValues[iVal].uMedia;
     9319                                else
     9320                                    Bs3MemSet(&uMemOpExpect, 0xcc, sizeof(uMemOpExpect));
     9321                            }
     9322
     9323                            /* source - gpr/mem */
     9324                            if (paTests[iTest].iGprReg == UINT8_MAX)
     9325                            {
     9326                                BS3_ASSERT(paTests[iTest].enmRm >= RM_MEM);
     9327                                Bs3MemSet(&uMemOpExpect, 0xcc, sizeof(uMemOpExpect));
     9328                                if (bXcptExpect == X86_XCPT_DB)
     9329                                    switch (paTests[iTest].cbGpr)
     9330                                    {
     9331                                        case 1: uMemOpExpect.au8[0]  = (uint8_t) (paValues[iVal].uGpr & fGprValMask); break;
     9332                                        case 2: uMemOpExpect.au16[0] = (uint16_t)(paValues[iVal].uGpr & fGprValMask); break;
     9333                                        case 4: uMemOpExpect.au32[0] = (uint32_t)(paValues[iVal].uGpr & fGprValMask); break;
     9334                                        case 8: uMemOpExpect.au64[0] =           (paValues[iVal].uGpr & fGprValMask); break;
     9335                                        default: BS3_ASSERT(0);
     9336                                    }
     9337                                Bs3MemCpy(puMemOp, &uMemOpExpect, cbMemOp);
     9338                            }
     9339                            else
     9340                                Bs3RegCtxSetGpr(&Ctx, paTests[iTest].iGprReg, paValues[iVal].uGpr & fGprValMask, paTests[iTest].cbGpr);
    92949341                        }
    9295                         else if (fMmxInstr)
    9296                             Bs3ExtCtxSetMm(pExtCtx, paTests[iTest].iMediaReg, paValues[iVal].uMedia.QWords.qw0, BS3EXTCTXTOPMM_ZERO);
    9297                         else if (fSseInstr)
    9298                             Bs3ExtCtxSetXmm(pExtCtx, paTests[iTest].iMediaReg, &paValues[iVal].uMedia.DQWords.dqw0);
    9299                         else
    9300                             Bs3ExtCtxSetYmm(pExtCtx, paTests[iTest].iMediaReg, &paValues[iVal].uMedia, 32);
     9342
     9343                        /* Memory pointer. */
     9344                        if (paTests[iTest].enmRm >= RM_MEM)
     9345                        {
     9346                            BS3_ASSERT(paTests[iTest].iGprReg == UINT8_MAX || paTests[iTest].iMediaReg == UINT8_MAX);
     9347                            Bs3RegCtxSetGrpSegFromCurPtr(&Ctx, &Ctx.rbx, &Ctx.fs, puMemOp);
     9348                        }
     9349
     9350                        /*
     9351                         * Execute.
     9352                         */
     9353                        Bs3TrapSetJmpAndRestoreWithExtCtxAndRm(&Ctx, pExtCtx, &TrapFrame, pExtCtxOut);
     9354
     9355                        /*
     9356                         * Check the result:
     9357                         */
     9358                        cErrors = Bs3TestSubErrorCount();
     9359
     9360                        if (fMmxInstr && bXcptExpect == X86_XCPT_DB)
     9361                        {
     9362                            uSavedFtw = Bs3ExtCtxGetAbridgedFtw(pExtCtx);
     9363                            Bs3ExtCtxSetAbridgedFtw(pExtCtx, 0xff);
     9364                        }
     9365                        if (!fGprDst && bXcptExpect == X86_XCPT_DB && paTests[iTest].iMediaReg != UINT8_MAX)
     9366                        {
     9367                            if (fMmxInstr)
     9368                                Bs3ExtCtxSetMm(pExtCtx, paTests[iTest].iMediaReg, paValues[iVal].uMedia.QWords.qw0, BS3EXTCTXTOPMM_SET);
     9369                            else if (fSseInstr)
     9370                                Bs3ExtCtxSetXmm(pExtCtx, paTests[iTest].iMediaReg, &paValues[iVal].uMedia.DQWords.dqw0);
     9371                            else
     9372                                Bs3ExtCtxSetYmm(pExtCtx, paTests[iTest].iMediaReg, &paValues[iVal].uMedia, 32);
     9373                        }
     9374                        Bs3TestCheckExtCtx(pExtCtxOut, pExtCtx, 0 /*fFlags*/, pszMode, idTestStep);
     9375
     9376                        if (TrapFrame.bXcpt != bXcptExpect)
     9377                            Bs3TestFailedF("Expected bXcpt = %#x, got %#x", bXcptExpect, TrapFrame.bXcpt);
     9378
     9379                        if (fGprDst && bXcptExpect == X86_XCPT_DB && paTests[iTest].iGprReg != UINT8_MAX)
     9380                            Bs3RegCtxSetGpr(&Ctx, paTests[iTest].iGprReg, paValues[iVal].uGpr & fGprValMask,
     9381                                            paTests[iTest].cbGpr >= 4 ? 8 : paTests[iTest].cbGpr);
     9382                        /* Kludge! Looks like EFLAGS.AC is cleared when raising #GP in real mode on the 10980XE. WEIRD! */
     9383                        if (bMode == BS3_MODE_RM && (Ctx.rflags.u32 & X86_EFL_AC))
     9384                        {
     9385                            if (TrapFrame.Ctx.rflags.u32 & X86_EFL_AC)
     9386                                Bs3TestFailedF("Expected EFLAGS.AC to be cleared (bXcpt=%d)", TrapFrame.bXcpt);
     9387                            TrapFrame.Ctx.rflags.u32 |= X86_EFL_AC;
     9388                        }
     9389                        Bs3TestCheckRegCtxEx(&TrapFrame.Ctx, &Ctx, bXcptExpect == X86_XCPT_DB ? cbInstr + 1 : 0, 0,
     9390                                             bXcptExpect == X86_XCPT_DB || BS3_MODE_IS_16BIT_SYS(bMode) ? 0 : X86_EFL_RF,
     9391                                             pszMode, idTestStep);
     9392
     9393                        if (   paTests[iTest].enmRm >= RM_MEM
     9394                            && Bs3MemCmp(puMemOp, &uMemOpExpect, cbMemOp) != 0)
     9395                            Bs3TestFailedF("Expected uMemOp %.*Rhxs, got %.*Rhxs", cbMemOp, &uMemOpExpect, cbMemOp, puMemOp);
     9396
     9397                        if (cErrors != Bs3TestSubErrorCount())
     9398                        {
     9399                            if (paConfigs[iCfg].fAligned)
     9400                                Bs3TestFailedF("ring-%d/cfg#%u/test#%u/value#%u failed (bXcptExpect=%#x)",
     9401                                               bRing, iCfg, iTest, iVal, bXcptExpect);
     9402                            else
     9403                                Bs3TestFailedF("ring-%d/cfg#%u/test#%u/value#%u failed (bXcptExpect=%#x, puMemOp=%p, EFLAGS=%#RX32, CR0=%#RX32)",
     9404                                               bRing, iCfg, iTest, iVal, bXcptExpect, puMemOp, TrapFrame.Ctx.rflags.u32, TrapFrame.Ctx.cr0);
     9405                            Bs3TestPrintf("\n");
     9406                        }
     9407
     9408                        if (uSavedFtw != 0xff)
     9409                            Bs3ExtCtxSetAbridgedFtw(pExtCtx, uSavedFtw);
    93019410                    }
    9302                     else
    9303                     {
    9304                         /* dest - media */
    9305                         if (paTests[iTest].iMediaReg == UINT8_MAX)
    9306                         {
    9307                             BS3_ASSERT(paTests[iTest].enmRm >= RM_MEM);
    9308                             Bs3MemSet(puMemOp, 0xcc, cbMemOp);
    9309                             if (bXcptExpect == X86_XCPT_DB)
    9310                                 uMemOpExpect = paValues[iVal].uMedia;
    9311                             else
    9312                                 Bs3MemSet(&uMemOpExpect, 0xcc, sizeof(uMemOpExpect));
    9313                         }
    9314 
    9315                         /* source - gpr/mem */
    9316                         if (paTests[iTest].iGprReg == UINT8_MAX)
    9317                         {
    9318                             BS3_ASSERT(paTests[iTest].enmRm >= RM_MEM);
    9319                             Bs3MemSet(&uMemOpExpect, 0xcc, sizeof(uMemOpExpect));
    9320                             if (bXcptExpect == X86_XCPT_DB)
    9321                                 switch (paTests[iTest].cbGpr)
    9322                                 {
    9323                                     case 1: uMemOpExpect.au8[0]  = (uint8_t) (paValues[iVal].uGpr & fGprValMask); break;
    9324                                     case 2: uMemOpExpect.au16[0] = (uint16_t)(paValues[iVal].uGpr & fGprValMask); break;
    9325                                     case 4: uMemOpExpect.au32[0] = (uint32_t)(paValues[iVal].uGpr & fGprValMask); break;
    9326                                     case 8: uMemOpExpect.au64[0] =           (paValues[iVal].uGpr & fGprValMask); break;
    9327                                     default: BS3_ASSERT(0);
    9328                                 }
    9329                             Bs3MemCpy(puMemOp, &uMemOpExpect, cbMemOp);
    9330                         }
    9331                         else
    9332                             Bs3RegCtxSetGpr(&Ctx, paTests[iTest].iGprReg, paValues[iVal].uGpr & fGprValMask, paTests[iTest].cbGpr);
    9333                     }
    9334 
    9335                     /* Memory pointer. */
    9336                     if (paTests[iTest].enmRm >= RM_MEM)
    9337                     {
    9338                         BS3_ASSERT(paTests[iTest].iGprReg == UINT8_MAX || paTests[iTest].iMediaReg == UINT8_MAX);
    9339                         Bs3RegCtxSetGrpSegFromCurPtr(&Ctx, &Ctx.rbx, &Ctx.fs, puMemOp);
    9340                     }
    9341 
    9342                     /*
    9343                      * Execute.
    9344                      */
    9345                     Bs3TrapSetJmpAndRestoreWithExtCtxAndRm(&Ctx, pExtCtx, &TrapFrame, pExtCtxOut);
    9346 
    9347                     /*
    9348                      * Check the result:
    9349                      */
    9350                     cErrors = Bs3TestSubErrorCount();
    9351 
    9352                     if (fMmxInstr && bXcptExpect == X86_XCPT_DB)
    9353                     {
    9354                         uSavedFtw = Bs3ExtCtxGetAbridgedFtw(pExtCtx);
    9355                         Bs3ExtCtxSetAbridgedFtw(pExtCtx, 0xff);
    9356                     }
    9357                     if (!fGprDst && bXcptExpect == X86_XCPT_DB && paTests[iTest].iMediaReg != UINT8_MAX)
    9358                     {
    9359                         if (fMmxInstr)
    9360                             Bs3ExtCtxSetMm(pExtCtx, paTests[iTest].iMediaReg, paValues[iVal].uMedia.QWords.qw0, BS3EXTCTXTOPMM_SET);
    9361                         else if (fSseInstr)
    9362                             Bs3ExtCtxSetXmm(pExtCtx, paTests[iTest].iMediaReg, &paValues[iVal].uMedia.DQWords.dqw0);
    9363                         else
    9364                             Bs3ExtCtxSetYmm(pExtCtx, paTests[iTest].iMediaReg, &paValues[iVal].uMedia, 32);
    9365                     }
    9366                     Bs3TestCheckExtCtx(pExtCtxOut, pExtCtx, 0 /*fFlags*/, pszMode, idTestStep);
    9367 
    9368                     if (TrapFrame.bXcpt != bXcptExpect)
    9369                         Bs3TestFailedF("Expected bXcpt = %#x, got %#x", bXcptExpect, TrapFrame.bXcpt);
    9370 
    9371                     if (fGprDst && bXcptExpect == X86_XCPT_DB && paTests[iTest].iGprReg != UINT8_MAX)
    9372                         Bs3RegCtxSetGpr(&Ctx, paTests[iTest].iGprReg, paValues[iVal].uGpr & fGprValMask,
    9373                                         paTests[iTest].cbGpr >= 4 ? 8 : paTests[iTest].cbGpr);
    9374                     /* Kludge! Looks like EFLAGS.AC is cleared when raising #GP in real mode on the 10980XE. WEIRD! */
    9375                     if (bMode == BS3_MODE_RM && (Ctx.rflags.u32 & X86_EFL_AC))
    9376                     {
    9377                         if (TrapFrame.Ctx.rflags.u32 & X86_EFL_AC)
    9378                             Bs3TestFailedF("Expected EFLAGS.AC to be cleared (bXcpt=%d)", TrapFrame.bXcpt);
    9379                         TrapFrame.Ctx.rflags.u32 |= X86_EFL_AC;
    9380                     }
    9381                     Bs3TestCheckRegCtxEx(&TrapFrame.Ctx, &Ctx, bXcptExpect == X86_XCPT_DB ? cbInstr + 1 : 0, 0,
    9382                                          bXcptExpect == X86_XCPT_DB || BS3_MODE_IS_16BIT_SYS(bMode) ? 0 : X86_EFL_RF,
    9383                                          pszMode, idTestStep);
    9384 
    9385                     if (   paTests[iTest].enmRm >= RM_MEM
    9386                         && Bs3MemCmp(puMemOp, &uMemOpExpect, cbMemOp) != 0)
    9387                         Bs3TestFailedF("Expected uMemOp %.*Rhxs, got %.*Rhxs", cbMemOp, &uMemOpExpect, cbMemOp, puMemOp);
    9388 
    9389                     if (cErrors != Bs3TestSubErrorCount())
    9390                     {
    9391                         if (paConfigs[iCfg].fAligned)
    9392                             Bs3TestFailedF("ring-%d/cfg#%u/test#%u/value#%u failed (bXcptExpect=%#x)",
    9393                                            bRing, iCfg, iTest, iVal, bXcptExpect);
    9394                         else
    9395                             Bs3TestFailedF("ring-%d/cfg#%u/test#%u/value#%u failed (bXcptExpect=%#x, puMemOp=%p, EFLAGS=%#RX32, CR0=%#RX32)",
    9396                                            bRing, iCfg, iTest, iVal, bXcptExpect, puMemOp, TrapFrame.Ctx.rflags.u32, TrapFrame.Ctx.cr0);
    9397                         Bs3TestPrintf("\n");
    9398                     }
    9399 
    9400                     if (uSavedFtw != 0xff)
    9401                         Bs3ExtCtxSetAbridgedFtw(pExtCtx, uSavedFtw);
    9402                 }
    94039411            }
    94049412
     
    99029910                                            : BS3_MODE_IS_RM_OR_V86(bMode) ? X86_XCPT_UD : paConfigs[iCfg].bXcptAvx;
    99039911                uint16_t        idTestStep  = bRing * 10000 + iCfg * 100 + iTest * 10;
     9912                unsigned        cRecompRuns = 0;
    99049913                unsigned        iVal;
    99059914
     
    99239932                 * Iterate the test values and do the actual testing.
    99249933                 */
    9925                 for (iVal = 0; iVal < cValues; iVal++, idTestStep++)
    9926                 {
    9927                     uint16_t   cErrors;
    9928                     uint16_t   uSavedFtw = 0xff;
    9929                     RTUINT256U uMemOpExpect;
    9930 
    9931                     if (BS3_SKIPIT(bRing, iCfg, iTest, iVal, 0)) continue;
    9932                     /*
    9933                      * Set up the context and some expectations.
    9934                      */
    9935                     /* dest */
    9936                     if (paTests[iTest].iRegDst == UINT8_MAX)
     9934                while (cRecompRuns < BS3_THRESHOLD_NATIVE_RECOMPILER * 2)
     9935                    for (iVal = 0; iVal < cValues; iVal++, idTestStep++)
    99379936                    {
    9938                         BS3_ASSERT(paTests[iTest].enmRm >= RM_MEM);
    9939                         Bs3MemSet(puMemOp, 0xcc, cbMemOp);
    9940                         if (bXcptExpect == X86_XCPT_DB)
    9941                             uMemOpExpect = paValues[iVal].uDstOut;
     9937                        uint16_t   cErrors;
     9938                        uint16_t   uSavedFtw = 0xff;
     9939                        RTUINT256U uMemOpExpect;
     9940
     9941                        if (BS3_SKIPIT(bRing, iCfg, iTest, iVal, 0)) continue;
     9942                        cRecompRuns++;
     9943
     9944                        /*
     9945                         * Set up the context and some expectations.
     9946                         */
     9947                        /* dest */
     9948                        if (paTests[iTest].iRegDst == UINT8_MAX)
     9949                        {
     9950                            BS3_ASSERT(paTests[iTest].enmRm >= RM_MEM);
     9951                            Bs3MemSet(puMemOp, 0xcc, cbMemOp);
     9952                            if (bXcptExpect == X86_XCPT_DB)
     9953                                uMemOpExpect = paValues[iVal].uDstOut;
     9954                            else
     9955                                Bs3MemSet(&uMemOpExpect, 0xcc, sizeof(uMemOpExpect));
     9956                        }
     9957                        else if (fMmxInstr)
     9958                            Bs3ExtCtxSetMm(pExtCtx, paTests[iTest].iRegSrc, ~paValues[iVal].uDstOut.QWords.qw0, BS3EXTCTXTOPMM_ZERO);
     9959
     9960                        /* source */
     9961                        if (paTests[iTest].iRegSrc == UINT8_MAX)
     9962                        {
     9963                            BS3_ASSERT(paTests[iTest].enmRm >= RM_MEM);
     9964                            BS3_ASSERT(paTests[iTest].iRegDst != UINT8_MAX);
     9965                            Bs3MemCpy(puMemOp, &paValues[iVal].uSrc, cbMemOp);
     9966                            uMemOpExpect = paValues[iVal].uSrc;
     9967                        }
     9968                        else if (fMmxInstr)
     9969                            Bs3ExtCtxSetMm(pExtCtx, paTests[iTest].iRegSrc, paValues[iVal].uSrc.QWords.qw0, BS3EXTCTXTOPMM_ZERO);
     9970                        else if (fSseInstr)
     9971                            Bs3ExtCtxSetXmm(pExtCtx, paTests[iTest].iRegSrc, &paValues[iVal].uSrc.DQWords.dqw0);
    99429972                        else
    9943                             Bs3MemSet(&uMemOpExpect, 0xcc, sizeof(uMemOpExpect));
     9973                            Bs3ExtCtxSetYmm(pExtCtx, paTests[iTest].iRegSrc, &paValues[iVal].uSrc, 32);
     9974
     9975                        /* Memory pointer. */
     9976                        if (paTests[iTest].enmRm >= RM_MEM)
     9977                        {
     9978                            BS3_ASSERT(   paTests[iTest].iRegDst == UINT8_MAX
     9979                                       || paTests[iTest].iRegSrc == UINT8_MAX);
     9980                            Bs3RegCtxSetGrpSegFromCurPtr(&Ctx, &Ctx.rbx, &Ctx.fs, puMemOp);
     9981                        }
     9982
     9983                        /*
     9984                         * Execute.
     9985                         */
     9986                        Bs3TrapSetJmpAndRestoreWithExtCtxAndRm(&Ctx, pExtCtx, &TrapFrame, pExtCtxOut);
     9987
     9988                        /*
     9989                         * Check the result:
     9990                         */
     9991                        cErrors = Bs3TestSubErrorCount();
     9992
     9993                        if (bXcptExpect == X86_XCPT_DB && fMmxInstr)
     9994                        {
     9995                            uSavedFtw = Bs3ExtCtxGetAbridgedFtw(pExtCtx);
     9996                            Bs3ExtCtxSetAbridgedFtw(pExtCtx, 0xff);
     9997                        }
     9998                        if (bXcptExpect == X86_XCPT_DB && paTests[iTest].iRegDst != UINT8_MAX)
     9999                        {
     10000                            if (fMmxInstr)
     10001                                Bs3ExtCtxSetMm(pExtCtx, paTests[iTest].iRegDst, paValues[iVal].uDstOut.QWords.qw0, BS3EXTCTXTOPMM_SET);
     10002                            else if (fSseInstr)
     10003                                Bs3ExtCtxSetXmm(pExtCtx, paTests[iTest].iRegDst, &paValues[iVal].uDstOut.DQWords.dqw0);
     10004                            else
     10005                                Bs3ExtCtxSetYmm(pExtCtx, paTests[iTest].iRegDst, &paValues[iVal].uDstOut, cbOperand);
     10006                        }
     10007
     10008                        Bs3TestCheckExtCtx(pExtCtxOut, pExtCtx, 0 /*fFlags*/, pszMode, idTestStep);
     10009
     10010                        if (TrapFrame.bXcpt != bXcptExpect)
     10011                            Bs3TestFailedF("Expected bXcpt = %#x, got %#x", bXcptExpect, TrapFrame.bXcpt);
     10012
     10013                        /* Kludge! Looks like EFLAGS.AC is cleared when raising #GP in real mode on the 10980XE. WEIRD! */
     10014                        if (bMode == BS3_MODE_RM && (Ctx.rflags.u32 & X86_EFL_AC))
     10015                        {
     10016                            if (TrapFrame.Ctx.rflags.u32 & X86_EFL_AC)
     10017                                Bs3TestFailedF("Expected EFLAGS.AC to be cleared (bXcpt=%d)", TrapFrame.bXcpt);
     10018                            TrapFrame.Ctx.rflags.u32 |= X86_EFL_AC;
     10019                        }
     10020                        Bs3TestCheckRegCtxEx(&TrapFrame.Ctx, &Ctx, bXcptExpect == X86_XCPT_DB ? cbInstr + 1 : 0, 0,
     10021                                             bXcptExpect == X86_XCPT_DB || BS3_MODE_IS_16BIT_SYS(bMode) ? 0 : X86_EFL_RF,
     10022                                             pszMode, idTestStep);
     10023
     10024                        if (   paTests[iTest].enmRm >= RM_MEM
     10025                            && Bs3MemCmp(puMemOp, &uMemOpExpect, cbMemOp) != 0)
     10026                            Bs3TestFailedF("Expected uMemOp %.*Rhxs, got %.*Rhxs", cbMemOp, &uMemOpExpect, cbMemOp, puMemOp);
     10027
     10028                        if (cErrors != Bs3TestSubErrorCount())
     10029                        {
     10030                            if (paConfigs[iCfg].fAligned)
     10031                                Bs3TestFailedF("ring-%d/cfg#%u/test#%u/value#%u failed (bXcptExpect=%#x)",
     10032                                               bRing, iCfg, iTest, iVal, bXcptExpect);
     10033                            else
     10034                                Bs3TestFailedF("ring-%d/cfg#%u/test#%u/value#%u failed (bXcptExpect=%#x, puMemOp=%p, EFLAGS=%#RX32, CR0=%#RX32)",
     10035                                               bRing, iCfg, iTest, iVal, bXcptExpect, puMemOp, TrapFrame.Ctx.rflags.u32, TrapFrame.Ctx.cr0);
     10036                            Bs3TestPrintf("\n");
     10037                        }
     10038
     10039                        if (uSavedFtw != 0xff)
     10040                            Bs3ExtCtxSetAbridgedFtw(pExtCtx, uSavedFtw);
    994410041                    }
    9945                     else if (fMmxInstr)
    9946                         Bs3ExtCtxSetMm(pExtCtx, paTests[iTest].iRegSrc, ~paValues[iVal].uDstOut.QWords.qw0, BS3EXTCTXTOPMM_ZERO);
    9947 
    9948                     /* source */
    9949                     if (paTests[iTest].iRegSrc == UINT8_MAX)
    9950                     {
    9951                         BS3_ASSERT(paTests[iTest].enmRm >= RM_MEM);
    9952                         BS3_ASSERT(paTests[iTest].iRegDst != UINT8_MAX);
    9953                         Bs3MemCpy(puMemOp, &paValues[iVal].uSrc, cbMemOp);
    9954                         uMemOpExpect = paValues[iVal].uSrc;
    9955                     }
    9956                     else if (fMmxInstr)
    9957                         Bs3ExtCtxSetMm(pExtCtx, paTests[iTest].iRegSrc, paValues[iVal].uSrc.QWords.qw0, BS3EXTCTXTOPMM_ZERO);
    9958                     else if (fSseInstr)
    9959                         Bs3ExtCtxSetXmm(pExtCtx, paTests[iTest].iRegSrc, &paValues[iVal].uSrc.DQWords.dqw0);
    9960                     else
    9961                         Bs3ExtCtxSetYmm(pExtCtx, paTests[iTest].iRegSrc, &paValues[iVal].uSrc, 32);
    9962 
    9963                     /* Memory pointer. */
    9964                     if (paTests[iTest].enmRm >= RM_MEM)
    9965                     {
    9966                         BS3_ASSERT(   paTests[iTest].iRegDst == UINT8_MAX
    9967                                    || paTests[iTest].iRegSrc == UINT8_MAX);
    9968                         Bs3RegCtxSetGrpSegFromCurPtr(&Ctx, &Ctx.rbx, &Ctx.fs, puMemOp);
    9969                     }
    9970 
    9971                     /*
    9972                      * Execute.
    9973                      */
    9974                     Bs3TrapSetJmpAndRestoreWithExtCtxAndRm(&Ctx, pExtCtx, &TrapFrame, pExtCtxOut);
    9975 
    9976                     /*
    9977                      * Check the result:
    9978                      */
    9979                     cErrors = Bs3TestSubErrorCount();
    9980 
    9981                     if (bXcptExpect == X86_XCPT_DB && fMmxInstr)
    9982                     {
    9983                         uSavedFtw = Bs3ExtCtxGetAbridgedFtw(pExtCtx);
    9984                         Bs3ExtCtxSetAbridgedFtw(pExtCtx, 0xff);
    9985                     }
    9986                     if (bXcptExpect == X86_XCPT_DB && paTests[iTest].iRegDst != UINT8_MAX)
    9987                     {
    9988                         if (fMmxInstr)
    9989                             Bs3ExtCtxSetMm(pExtCtx, paTests[iTest].iRegDst, paValues[iVal].uDstOut.QWords.qw0, BS3EXTCTXTOPMM_SET);
    9990                         else if (fSseInstr)
    9991                             Bs3ExtCtxSetXmm(pExtCtx, paTests[iTest].iRegDst, &paValues[iVal].uDstOut.DQWords.dqw0);
    9992                         else
    9993                             Bs3ExtCtxSetYmm(pExtCtx, paTests[iTest].iRegDst, &paValues[iVal].uDstOut, cbOperand);
    9994                     }
    9995 
    9996                     Bs3TestCheckExtCtx(pExtCtxOut, pExtCtx, 0 /*fFlags*/, pszMode, idTestStep);
    9997 
    9998                     if (TrapFrame.bXcpt != bXcptExpect)
    9999                         Bs3TestFailedF("Expected bXcpt = %#x, got %#x", bXcptExpect, TrapFrame.bXcpt);
    10000 
    10001                     /* Kludge! Looks like EFLAGS.AC is cleared when raising #GP in real mode on the 10980XE. WEIRD! */
    10002                     if (bMode == BS3_MODE_RM && (Ctx.rflags.u32 & X86_EFL_AC))
    10003                     {
    10004                         if (TrapFrame.Ctx.rflags.u32 & X86_EFL_AC)
    10005                             Bs3TestFailedF("Expected EFLAGS.AC to be cleared (bXcpt=%d)", TrapFrame.bXcpt);
    10006                         TrapFrame.Ctx.rflags.u32 |= X86_EFL_AC;
    10007                     }
    10008                     Bs3TestCheckRegCtxEx(&TrapFrame.Ctx, &Ctx, bXcptExpect == X86_XCPT_DB ? cbInstr + 1 : 0, 0,
    10009                                          bXcptExpect == X86_XCPT_DB || BS3_MODE_IS_16BIT_SYS(bMode) ? 0 : X86_EFL_RF,
    10010                                          pszMode, idTestStep);
    10011 
    10012                     if (   paTests[iTest].enmRm >= RM_MEM
    10013                         && Bs3MemCmp(puMemOp, &uMemOpExpect, cbMemOp) != 0)
    10014                         Bs3TestFailedF("Expected uMemOp %.*Rhxs, got %.*Rhxs", cbMemOp, &uMemOpExpect, cbMemOp, puMemOp);
    10015 
    10016                     if (cErrors != Bs3TestSubErrorCount())
    10017                     {
    10018                         if (paConfigs[iCfg].fAligned)
    10019                             Bs3TestFailedF("ring-%d/cfg#%u/test#%u/value#%u failed (bXcptExpect=%#x)",
    10020                                            bRing, iCfg, iTest, iVal, bXcptExpect);
    10021                         else
    10022                             Bs3TestFailedF("ring-%d/cfg#%u/test#%u/value#%u failed (bXcptExpect=%#x, puMemOp=%p, EFLAGS=%#RX32, CR0=%#RX32)",
    10023                                            bRing, iCfg, iTest, iVal, bXcptExpect, puMemOp, TrapFrame.Ctx.rflags.u32, TrapFrame.Ctx.cr0);
    10024                         Bs3TestPrintf("\n");
    10025                     }
    10026 
    10027                     if (uSavedFtw != 0xff)
    10028                         Bs3ExtCtxSetAbridgedFtw(pExtCtx, uSavedFtw);
    10029                 }
    1003010042            }
    1003110043
     
    1210712119                                            : BS3_MODE_IS_RM_OR_V86(bMode) ? X86_XCPT_UD : paConfigs[iCfg].bXcptAvx;
    1210812120                uint16_t        idTestStep  = bRing * 10000 + iCfg * 100 + iTest * 10;
     12121                unsigned        cRecompRuns = 0;
    1210912122                unsigned        iVal;
    1211012123
     
    1212812141                 * Iterate the test values and do the actual testing.
    1212912142                 */
    12130                 for (iVal = 0; iVal < cValues; iVal++, idTestStep++)
    12131                 {
    12132                     unsigned       iEflVariation;
    12133                     uint32_t const fSavedEfl = Ctx.rflags.u32;
    12134                     for (iEflVariation = 0; iEflVariation < 2; iEflVariation++)
     12143                while (cRecompRuns < BS3_THRESHOLD_NATIVE_RECOMPILER * 2)
     12144                    for (iVal = 0; iVal < cValues; iVal++, idTestStep++)
    1213512145                    {
    12136                         uint16_t   cErrors;
    12137                         uint16_t   uSavedFtw = 0xff;
    12138                         RTUINT256U uMemOpExpect;
    12139 
    12140                         if (BS3_SKIPIT(bRing, iCfg, iTest, iVal, iEflVariation)) continue;
    12141                         /*
    12142                          * Set up the context and some expectations.
    12143                          */
    12144                         /* eflags */
    12145                         if (iEflVariation)
    12146                             Ctx.rflags.u32 = fSavedEfl | X86_EFL_STATUS_BITS;
    12147                         else
    12148                             Ctx.rflags.u32 = fSavedEfl & ~X86_EFL_STATUS_BITS;
    12149 
    12150                         /* source1 */
    12151                         if (paTests[iTest].iRegSrc1 == UINT8_MAX)
     12146                        unsigned       iEflVariation;
     12147                        uint32_t const fSavedEfl = Ctx.rflags.u32;
     12148                        for (iEflVariation = 0; iEflVariation < 2; iEflVariation++)
    1215212149                        {
    12153                             BS3_ASSERT(paTests[iTest].enmRm >= RM_MEM);
    12154                             BS3_ASSERT(paTests[iTest].iRegSrc2 != UINT8_MAX);
    12155                             Bs3MemCpy(puMemOp, &paValues[iVal].uSrc1, cbMemOp);
    12156                             uMemOpExpect = paValues[iVal].uSrc1;
     12150                            uint16_t   cErrors;
     12151                            uint16_t   uSavedFtw = 0xff;
     12152                            RTUINT256U uMemOpExpect;
     12153
     12154                            if (BS3_SKIPIT(bRing, iCfg, iTest, iVal, iEflVariation)) continue;
     12155                            cRecompRuns++;
     12156
     12157                            /*
     12158                             * Set up the context and some expectations.
     12159                             */
     12160                            /* eflags */
     12161                            if (iEflVariation)
     12162                                Ctx.rflags.u32 = fSavedEfl | X86_EFL_STATUS_BITS;
     12163                            else
     12164                                Ctx.rflags.u32 = fSavedEfl & ~X86_EFL_STATUS_BITS;
     12165
     12166                            /* source1 */
     12167                            if (paTests[iTest].iRegSrc1 == UINT8_MAX)
     12168                            {
     12169                                BS3_ASSERT(paTests[iTest].enmRm >= RM_MEM);
     12170                                BS3_ASSERT(paTests[iTest].iRegSrc2 != UINT8_MAX);
     12171                                Bs3MemCpy(puMemOp, &paValues[iVal].uSrc1, cbMemOp);
     12172                                uMemOpExpect = paValues[iVal].uSrc1;
     12173                            }
     12174                            else if (fMmxInstr)
     12175                                Bs3ExtCtxSetMm(pExtCtx, paTests[iTest].iRegSrc1, paValues[iVal].uSrc1.QWords.qw0, BS3EXTCTXTOPMM_ZERO);
     12176                            else if (fSseInstr)
     12177                                Bs3ExtCtxSetXmm(pExtCtx, paTests[iTest].iRegSrc1, &paValues[iVal].uSrc1.DQWords.dqw0);
     12178                            else
     12179                                Bs3ExtCtxSetYmm(pExtCtx, paTests[iTest].iRegSrc1, &paValues[iVal].uSrc1, 32);
     12180
     12181                            /* source2 */
     12182                            if (paTests[iTest].iRegSrc2 == UINT8_MAX)
     12183                            {
     12184                                BS3_ASSERT(paTests[iTest].enmRm >= RM_MEM);
     12185                                BS3_ASSERT(paTests[iTest].iRegSrc1 != UINT8_MAX);
     12186                                Bs3MemCpy(puMemOp, &paValues[iVal].uSrc2, cbMemOp);
     12187                                uMemOpExpect = paValues[iVal].uSrc2;
     12188                            }
     12189                            else if (fMmxInstr)
     12190                                Bs3ExtCtxSetMm(pExtCtx, paTests[iTest].iRegSrc2, paValues[iVal].uSrc2.QWords.qw0, BS3EXTCTXTOPMM_ZERO);
     12191                            else if (fSseInstr)
     12192                                Bs3ExtCtxSetXmm(pExtCtx, paTests[iTest].iRegSrc2, &paValues[iVal].uSrc2.DQWords.dqw0);
     12193                            else
     12194                                Bs3ExtCtxSetYmm(pExtCtx, paTests[iTest].iRegSrc2, &paValues[iVal].uSrc2, 32);
     12195
     12196                            /* Memory pointer. */
     12197                            if (paTests[iTest].enmRm >= RM_MEM)
     12198                            {
     12199                                BS3_ASSERT(   paTests[iTest].iRegSrc1 == UINT8_MAX
     12200                                           || paTests[iTest].iRegSrc2 == UINT8_MAX);
     12201                                Bs3RegCtxSetGrpSegFromCurPtr(&Ctx, &Ctx.rbx, &Ctx.fs, puMemOp);
     12202                            }
     12203
     12204                            /*
     12205                             * Execute.
     12206                             */
     12207                            Bs3TrapSetJmpAndRestoreWithExtCtxAndRm(&Ctx, pExtCtx, &TrapFrame, pExtCtxOut);
     12208
     12209                            /*
     12210                             * Check the result:
     12211                             */
     12212                            cErrors = Bs3TestSubErrorCount();
     12213
     12214                            if (bXcptExpect == X86_XCPT_DB && fMmxInstr)
     12215                            {
     12216                                uSavedFtw = Bs3ExtCtxGetAbridgedFtw(pExtCtx);
     12217                                Bs3ExtCtxSetAbridgedFtw(pExtCtx, 0xff);
     12218                            }
     12219                            Bs3TestCheckExtCtx(pExtCtxOut, pExtCtx, 0 /*fFlags*/, pszMode, idTestStep);
     12220
     12221                            if (TrapFrame.bXcpt != bXcptExpect)
     12222                                Bs3TestFailedF("Expected bXcpt = %#x, got %#x", bXcptExpect, TrapFrame.bXcpt);
     12223
     12224                            /* Kludge! Looks like EFLAGS.AC is cleared when raising #GP in real mode on the 10980XE. WEIRD! */
     12225                            if (bMode == BS3_MODE_RM && (Ctx.rflags.u32 & X86_EFL_AC))
     12226                            {
     12227                                if (TrapFrame.Ctx.rflags.u32 & X86_EFL_AC)
     12228                                    Bs3TestFailedF("Expected EFLAGS.AC to be cleared (bXcpt=%d)", TrapFrame.bXcpt);
     12229                                TrapFrame.Ctx.rflags.u32 |= X86_EFL_AC;
     12230                            }
     12231                            if (bXcptExpect == X86_XCPT_DB)
     12232                                Ctx.rflags.u32 = (Ctx.rflags.u32 & ~fEflCheck) | paValues[iVal].afEflOut[idxEflOut];
     12233                            Bs3TestCheckRegCtxEx(&TrapFrame.Ctx, &Ctx, bXcptExpect == X86_XCPT_DB ? cbInstr + 1 : 0, 0,
     12234                                                 bXcptExpect == X86_XCPT_DB || BS3_MODE_IS_16BIT_SYS(bMode) ? 0 : X86_EFL_RF,
     12235                                                 pszMode, idTestStep);
     12236
     12237                            if (   paTests[iTest].enmRm >= RM_MEM
     12238                                && Bs3MemCmp(puMemOp, &uMemOpExpect, cbMemOp) != 0)
     12239                                Bs3TestFailedF("Expected uMemOp %.*Rhxs, got %.*Rhxs", cbMemOp, &uMemOpExpect, cbMemOp, puMemOp);
     12240
     12241                            if (cErrors != Bs3TestSubErrorCount())
     12242                            {
     12243                                if (paConfigs[iCfg].fAligned)
     12244                                    Bs3TestFailedF("ring-%d/cfg#%u/test#%u/value#%u/efl#%u failed (bXcptExpect=%#x)",
     12245                                                   bRing, iCfg, iTest, iVal, iEflVariation, bXcptExpect);
     12246                                else
     12247                                    Bs3TestFailedF("ring-%d/cfg#%u/test#%u/value#%u/efl#%u failed (bXcptExpect=%#x, puMemOp=%p, EFLAGS=%#RX32, CR0=%#RX32)",
     12248                                                   bRing, iCfg, iTest, iVal, iEflVariation, bXcptExpect,
     12249                                                   puMemOp, TrapFrame.Ctx.rflags.u32, TrapFrame.Ctx.cr0);
     12250                                Bs3TestPrintf("\n");
     12251                            }
     12252
     12253                            if (uSavedFtw != 0xff)
     12254                                Bs3ExtCtxSetAbridgedFtw(pExtCtx, uSavedFtw);
    1215712255                        }
    12158                         else if (fMmxInstr)
    12159                             Bs3ExtCtxSetMm(pExtCtx, paTests[iTest].iRegSrc1, paValues[iVal].uSrc1.QWords.qw0, BS3EXTCTXTOPMM_ZERO);
    12160                         else if (fSseInstr)
    12161                             Bs3ExtCtxSetXmm(pExtCtx, paTests[iTest].iRegSrc1, &paValues[iVal].uSrc1.DQWords.dqw0);
    12162                         else
    12163                             Bs3ExtCtxSetYmm(pExtCtx, paTests[iTest].iRegSrc1, &paValues[iVal].uSrc1, 32);
    12164 
    12165                         /* source2 */
    12166                         if (paTests[iTest].iRegSrc2 == UINT8_MAX)
    12167                         {
    12168                             BS3_ASSERT(paTests[iTest].enmRm >= RM_MEM);
    12169                             BS3_ASSERT(paTests[iTest].iRegSrc1 != UINT8_MAX);
    12170                             Bs3MemCpy(puMemOp, &paValues[iVal].uSrc2, cbMemOp);
    12171                             uMemOpExpect = paValues[iVal].uSrc2;
    12172                         }
    12173                         else if (fMmxInstr)
    12174                             Bs3ExtCtxSetMm(pExtCtx, paTests[iTest].iRegSrc2, paValues[iVal].uSrc2.QWords.qw0, BS3EXTCTXTOPMM_ZERO);
    12175                         else if (fSseInstr)
    12176                             Bs3ExtCtxSetXmm(pExtCtx, paTests[iTest].iRegSrc2, &paValues[iVal].uSrc2.DQWords.dqw0);
    12177                         else
    12178                             Bs3ExtCtxSetYmm(pExtCtx, paTests[iTest].iRegSrc2, &paValues[iVal].uSrc2, 32);
    12179 
    12180                         /* Memory pointer. */
    12181                         if (paTests[iTest].enmRm >= RM_MEM)
    12182                         {
    12183                             BS3_ASSERT(   paTests[iTest].iRegSrc1 == UINT8_MAX
    12184                                        || paTests[iTest].iRegSrc2 == UINT8_MAX);
    12185                             Bs3RegCtxSetGrpSegFromCurPtr(&Ctx, &Ctx.rbx, &Ctx.fs, puMemOp);
    12186                         }
    12187 
    12188                         /*
    12189                          * Execute.
    12190                          */
    12191                         Bs3TrapSetJmpAndRestoreWithExtCtxAndRm(&Ctx, pExtCtx, &TrapFrame, pExtCtxOut);
    12192 
    12193                         /*
    12194                          * Check the result:
    12195                          */
    12196                         cErrors = Bs3TestSubErrorCount();
    12197 
    12198                         if (bXcptExpect == X86_XCPT_DB && fMmxInstr)
    12199                         {
    12200                             uSavedFtw = Bs3ExtCtxGetAbridgedFtw(pExtCtx);
    12201                             Bs3ExtCtxSetAbridgedFtw(pExtCtx, 0xff);
    12202                         }
    12203                         Bs3TestCheckExtCtx(pExtCtxOut, pExtCtx, 0 /*fFlags*/, pszMode, idTestStep);
    12204 
    12205                         if (TrapFrame.bXcpt != bXcptExpect)
    12206                             Bs3TestFailedF("Expected bXcpt = %#x, got %#x", bXcptExpect, TrapFrame.bXcpt);
    12207 
    12208                         /* Kludge! Looks like EFLAGS.AC is cleared when raising #GP in real mode on the 10980XE. WEIRD! */
    12209                         if (bMode == BS3_MODE_RM && (Ctx.rflags.u32 & X86_EFL_AC))
    12210                         {
    12211                             if (TrapFrame.Ctx.rflags.u32 & X86_EFL_AC)
    12212                                 Bs3TestFailedF("Expected EFLAGS.AC to be cleared (bXcpt=%d)", TrapFrame.bXcpt);
    12213                             TrapFrame.Ctx.rflags.u32 |= X86_EFL_AC;
    12214                         }
    12215                         if (bXcptExpect == X86_XCPT_DB)
    12216                             Ctx.rflags.u32 = (Ctx.rflags.u32 & ~fEflCheck) | paValues[iVal].afEflOut[idxEflOut];
    12217                         Bs3TestCheckRegCtxEx(&TrapFrame.Ctx, &Ctx, bXcptExpect == X86_XCPT_DB ? cbInstr + 1 : 0, 0,
    12218                                              bXcptExpect == X86_XCPT_DB || BS3_MODE_IS_16BIT_SYS(bMode) ? 0 : X86_EFL_RF,
    12219                                              pszMode, idTestStep);
    12220 
    12221                         if (   paTests[iTest].enmRm >= RM_MEM
    12222                             && Bs3MemCmp(puMemOp, &uMemOpExpect, cbMemOp) != 0)
    12223                             Bs3TestFailedF("Expected uMemOp %.*Rhxs, got %.*Rhxs", cbMemOp, &uMemOpExpect, cbMemOp, puMemOp);
    12224 
    12225                         if (cErrors != Bs3TestSubErrorCount())
    12226                         {
    12227                             if (paConfigs[iCfg].fAligned)
    12228                                 Bs3TestFailedF("ring-%d/cfg#%u/test#%u/value#%u/efl#%u failed (bXcptExpect=%#x)",
    12229                                                bRing, iCfg, iTest, iVal, iEflVariation, bXcptExpect);
    12230                             else
    12231                                 Bs3TestFailedF("ring-%d/cfg#%u/test#%u/value#%u/efl#%u failed (bXcptExpect=%#x, puMemOp=%p, EFLAGS=%#RX32, CR0=%#RX32)",
    12232                                                bRing, iCfg, iTest, iVal, iEflVariation, bXcptExpect,
    12233                                                puMemOp, TrapFrame.Ctx.rflags.u32, TrapFrame.Ctx.cr0);
    12234                             Bs3TestPrintf("\n");
    12235                         }
    12236 
    12237                         if (uSavedFtw != 0xff)
    12238                             Bs3ExtCtxSetAbridgedFtw(pExtCtx, uSavedFtw);
     12256                        Ctx.rflags.u32 = fSavedEfl;
    1223912257                    }
    12240                     Ctx.rflags.u32 = fSavedEfl;
    12241                 }
    1224212258            }
    1224312259
     
    1243312449                                            : BS3_MODE_IS_RM_OR_V86(bMode) ? X86_XCPT_UD : paConfigs[iCfg].bXcptAvx;
    1243412450                uint16_t        idTestStep  = bRing * 10000 + iCfg * 100 + iTest * 10;
     12451                unsigned        cRecompRuns = 0;
    1243512452                unsigned        iVal;
    1243612453
     
    1245412471                 * Iterate the test values and do the actual testing.
    1245512472                 */
    12456                 for (iVal = 0; iVal < cValues; iVal++, idTestStep++)
    12457                 {
    12458                     uint16_t   cErrors;
    12459                     uint16_t   uSavedFtw = 0xff;
    12460                     RTUINT256U uMemOpExpect;
    12461 
    12462                     if (BS3_SKIPIT(bRing, iCfg, iTest, iVal, 0)) continue;
    12463                     /*
    12464                      * Set up the context and some expectations.
    12465                      */
    12466                     /* dest */
    12467                     if (paTests[iTest].iRegDst == UINT8_MAX)
     12473                while (cRecompRuns < BS3_THRESHOLD_NATIVE_RECOMPILER * 2)
     12474                    for (iVal = 0; iVal < cValues; iVal++, idTestStep++)
    1246812475                    {
    12469                         BS3_ASSERT(paTests[iTest].enmRm >= RM_MEM);
    12470                         Bs3MemSet(puMemOp, 0xcc, cbMemOp);
    12471                         if (bXcptExpect == X86_XCPT_DB)
    12472                             uMemOpExpect = paValues[iVal].uDstOut;
     12476                        uint16_t   cErrors;
     12477                        uint16_t   uSavedFtw = 0xff;
     12478                        RTUINT256U uMemOpExpect;
     12479
     12480                        if (BS3_SKIPIT(bRing, iCfg, iTest, iVal, 0)) continue;
     12481                        cRecompRuns++;
     12482
     12483                        /*
     12484                         * Set up the context and some expectations.
     12485                         */
     12486                        /* dest */
     12487                        if (paTests[iTest].iRegDst == UINT8_MAX)
     12488                        {
     12489                            BS3_ASSERT(paTests[iTest].enmRm >= RM_MEM);
     12490                            Bs3MemSet(puMemOp, 0xcc, cbMemOp);
     12491                            if (bXcptExpect == X86_XCPT_DB)
     12492                                uMemOpExpect = paValues[iVal].uDstOut;
     12493                            else
     12494                                Bs3MemSet(&uMemOpExpect, 0xcc, sizeof(uMemOpExpect));
     12495                        }
     12496                        else if (fMmxInstr)
     12497                            Bs3ExtCtxSetMm(pExtCtx, paTests[iTest].iRegSrc2, ~paValues[iVal].uDstOut.QWords.qw0, BS3EXTCTXTOPMM_ZERO);
     12498
     12499                        /* source #1 (/ destination for MMX and SSE) */
     12500                        if (paTests[iTest].iRegSrc1 == UINT8_MAX)
     12501                        {
     12502                            BS3_ASSERT(paTests[iTest].enmRm >= RM_MEM);
     12503                            Bs3MemCpy(puMemOp, &paValues[iVal].uSrc1, cbMemOp);
     12504                            if (paTests[iTest].iRegDst == UINT8_MAX)
     12505                                BS3_ASSERT(fSseInstr);
     12506                            else
     12507                                uMemOpExpect = paValues[iVal].uSrc1;
     12508                        }
     12509                        else if (fMmxInstr)
     12510                            Bs3ExtCtxSetMm(pExtCtx, paTests[iTest].iRegSrc1, paValues[iVal].uSrc1.QWords.qw0, BS3EXTCTXTOPMM_ZERO);
     12511                        else if (fSseInstr)
     12512                            Bs3ExtCtxSetXmm(pExtCtx, paTests[iTest].iRegSrc1, &paValues[iVal].uSrc1.DQWords.dqw0);
    1247312513                        else
    12474                             Bs3MemSet(&uMemOpExpect, 0xcc, sizeof(uMemOpExpect));
     12514                            Bs3ExtCtxSetYmm(pExtCtx, paTests[iTest].iRegSrc1, &paValues[iVal].uSrc1, 32);
     12515
     12516                        /* source #2 */
     12517                        if (paTests[iTest].iRegSrc2 == UINT8_MAX)
     12518                        {
     12519                            BS3_ASSERT(paTests[iTest].enmRm >= RM_MEM);
     12520                            BS3_ASSERT(paTests[iTest].iRegDst != UINT8_MAX && paTests[iTest].iRegSrc1 != UINT8_MAX);
     12521                            Bs3MemCpy(puMemOp, &paValues[iVal].uSrc2, cbMemOp);
     12522                            uMemOpExpect = paValues[iVal].uSrc2;
     12523                        }
     12524                        else if (fMmxInstr)
     12525                            Bs3ExtCtxSetMm(pExtCtx, paTests[iTest].iRegSrc2, paValues[iVal].uSrc2.QWords.qw0, BS3EXTCTXTOPMM_ZERO);
     12526                        else if (fSseInstr)
     12527                            Bs3ExtCtxSetXmm(pExtCtx, paTests[iTest].iRegSrc2, &paValues[iVal].uSrc2.DQWords.dqw0);
     12528                        else
     12529                            Bs3ExtCtxSetYmm(pExtCtx, paTests[iTest].iRegSrc2, &paValues[iVal].uSrc2, 32);
     12530
     12531                        /* source #3 */
     12532                        if (paTests[iTest].iRegSrc3 == UINT8_MAX)
     12533                        {
     12534                            BS3_ASSERT(paTests[iTest].enmRm >= RM_MEM);
     12535                            BS3_ASSERT(paTests[iTest].iRegDst != UINT8_MAX && paTests[iTest].iRegSrc1 != UINT8_MAX);
     12536                            Bs3MemCpy(puMemOp, &paValues[iVal].uSrc3, cbMemOp);
     12537                            uMemOpExpect = paValues[iVal].uSrc3;
     12538                        }
     12539                        else if (fMmxInstr)
     12540                            Bs3ExtCtxSetMm(pExtCtx, paTests[iTest].iRegSrc3, paValues[iVal].uSrc3.QWords.qw0, BS3EXTCTXTOPMM_ZERO);
     12541                        else if (fSseInstr)
     12542                            Bs3ExtCtxSetXmm(pExtCtx, paTests[iTest].iRegSrc3, &paValues[iVal].uSrc3.DQWords.dqw0);
     12543                        else
     12544                            Bs3ExtCtxSetYmm(pExtCtx, paTests[iTest].iRegSrc3, &paValues[iVal].uSrc3, 32);
     12545
     12546                        /* Memory pointer. */
     12547                        if (paTests[iTest].enmRm >= RM_MEM)
     12548                        {
     12549                            BS3_ASSERT(   paTests[iTest].iRegDst  == UINT8_MAX
     12550                                       || paTests[iTest].iRegSrc1 == UINT8_MAX
     12551                                       || paTests[iTest].iRegSrc2 == UINT8_MAX
     12552                                       || paTests[iTest].iRegSrc3 == UINT8_MAX);
     12553                            Bs3RegCtxSetGrpSegFromCurPtr(&Ctx, &Ctx.rbx, &Ctx.fs, puMemOp);
     12554                        }
     12555
     12556                        /*
     12557                         * Execute.
     12558                         */
     12559                        Bs3TrapSetJmpAndRestoreWithExtCtxAndRm(&Ctx, pExtCtx, &TrapFrame, pExtCtxOut);
     12560
     12561                        /*
     12562                         * Check the result:
     12563                         */
     12564                        cErrors = Bs3TestSubErrorCount();
     12565
     12566                        if (fMmxInstr && bXcptExpect == X86_XCPT_DB)
     12567                        {
     12568                            uSavedFtw = Bs3ExtCtxGetAbridgedFtw(pExtCtx);
     12569                            Bs3ExtCtxSetAbridgedFtw(pExtCtx, 0xff); /* Observed on 10980xe after pxor mm1, mm2. */
     12570                        }
     12571                        if (bXcptExpect == X86_XCPT_DB && paTests[iTest].iRegDst != UINT8_MAX)
     12572                        {
     12573                            if (fMmxInstr)
     12574                                Bs3ExtCtxSetMm(pExtCtx, paTests[iTest].iRegDst, paValues[iVal].uDstOut.QWords.qw0, BS3EXTCTXTOPMM_SET);
     12575                            else if (fSseInstr)
     12576                                Bs3ExtCtxSetXmm(pExtCtx, paTests[iTest].iRegDst, &paValues[iVal].uDstOut.DQWords.dqw0);
     12577                            else
     12578                                Bs3ExtCtxSetYmm(pExtCtx, paTests[iTest].iRegDst, &paValues[iVal].uDstOut, cbOperand);
     12579                        }
     12580#if defined(DEBUG_aeichner) /** @todo Necessary kludge on a i7-1068NG7. */
     12581                        if (   pExtCtx->enmMethod == BS3EXTCTXMETHOD_XSAVE
     12582                            && pExtCtx->Ctx.x.Hdr.bmXState == 0x7
     12583                            && pExtCtxOut->Ctx.x.Hdr.bmXState == 0x3)
     12584                            pExtCtxOut->Ctx.x.Hdr.bmXState = 0x7;
     12585#endif
     12586                        Bs3TestCheckExtCtx(pExtCtxOut, pExtCtx, 0 /*fFlags*/, pszMode, idTestStep);
     12587
     12588                        if (TrapFrame.bXcpt != bXcptExpect)
     12589                            Bs3TestFailedF("Expected bXcpt = %#x, got %#x", bXcptExpect, TrapFrame.bXcpt);
     12590
     12591                        /* Kludge! Looks like EFLAGS.AC is cleared when raising #GP in real mode on the 10980XE. WEIRD! */
     12592                        if (bMode == BS3_MODE_RM && (Ctx.rflags.u32 & X86_EFL_AC))
     12593                        {
     12594                            if (TrapFrame.Ctx.rflags.u32 & X86_EFL_AC)
     12595                                Bs3TestFailedF("Expected EFLAGS.AC to be cleared (bXcpt=%d)", TrapFrame.bXcpt);
     12596                            TrapFrame.Ctx.rflags.u32 |= X86_EFL_AC;
     12597                        }
     12598                        Bs3TestCheckRegCtxEx(&TrapFrame.Ctx, &Ctx, bXcptExpect == X86_XCPT_DB ? cbInstr + 1 : 0, 0,
     12599                                             bXcptExpect == X86_XCPT_DB || BS3_MODE_IS_16BIT_SYS(bMode) ? 0 : X86_EFL_RF,
     12600                                             pszMode, idTestStep);
     12601
     12602                        if (   paTests[iTest].enmRm >= RM_MEM
     12603                            && Bs3MemCmp(puMemOp, &uMemOpExpect, cbMemOp) != 0)
     12604                            Bs3TestFailedF("Expected uMemOp %.*Rhxs, got %.*Rhxs", cbMemOp, &uMemOpExpect, cbMemOp, puMemOp);
     12605
     12606                        if (cErrors != Bs3TestSubErrorCount())
     12607                        {
     12608                            if (paConfigs[iCfg].fAligned)
     12609                                Bs3TestFailedF("ring-%d/cfg#%u/test#%u/value#%u failed (bXcptExpect=%#x)",
     12610                                               bRing, iCfg, iTest, iVal, bXcptExpect);
     12611                            else
     12612                                Bs3TestFailedF("ring-%d/cfg#%u/test#%u/value#%u failed (bXcptExpect=%#x, puMemOp=%p, EFLAGS=%#RX32, CR0=%#RX32)",
     12613                                               bRing, iCfg, iTest, iVal, bXcptExpect, puMemOp, TrapFrame.Ctx.rflags.u32, TrapFrame.Ctx.cr0);
     12614                            Bs3TestPrintf("\n");
     12615                        }
     12616
     12617                        if (uSavedFtw != 0xff)
     12618                            Bs3ExtCtxSetAbridgedFtw(pExtCtx, uSavedFtw);
    1247512619                    }
    12476                     else if (fMmxInstr)
    12477                         Bs3ExtCtxSetMm(pExtCtx, paTests[iTest].iRegSrc2, ~paValues[iVal].uDstOut.QWords.qw0, BS3EXTCTXTOPMM_ZERO);
    12478 
    12479                     /* source #1 (/ destination for MMX and SSE) */
    12480                     if (paTests[iTest].iRegSrc1 == UINT8_MAX)
    12481                     {
    12482                         BS3_ASSERT(paTests[iTest].enmRm >= RM_MEM);
    12483                         Bs3MemCpy(puMemOp, &paValues[iVal].uSrc1, cbMemOp);
    12484                         if (paTests[iTest].iRegDst == UINT8_MAX)
    12485                             BS3_ASSERT(fSseInstr);
    12486                         else
    12487                             uMemOpExpect = paValues[iVal].uSrc1;
    12488                     }
    12489                     else if (fMmxInstr)
    12490                         Bs3ExtCtxSetMm(pExtCtx, paTests[iTest].iRegSrc1, paValues[iVal].uSrc1.QWords.qw0, BS3EXTCTXTOPMM_ZERO);
    12491                     else if (fSseInstr)
    12492                         Bs3ExtCtxSetXmm(pExtCtx, paTests[iTest].iRegSrc1, &paValues[iVal].uSrc1.DQWords.dqw0);
    12493                     else
    12494                         Bs3ExtCtxSetYmm(pExtCtx, paTests[iTest].iRegSrc1, &paValues[iVal].uSrc1, 32);
    12495 
    12496                     /* source #2 */
    12497                     if (paTests[iTest].iRegSrc2 == UINT8_MAX)
    12498                     {
    12499                         BS3_ASSERT(paTests[iTest].enmRm >= RM_MEM);
    12500                         BS3_ASSERT(paTests[iTest].iRegDst != UINT8_MAX && paTests[iTest].iRegSrc1 != UINT8_MAX);
    12501                         Bs3MemCpy(puMemOp, &paValues[iVal].uSrc2, cbMemOp);
    12502                         uMemOpExpect = paValues[iVal].uSrc2;
    12503                     }
    12504                     else if (fMmxInstr)
    12505                         Bs3ExtCtxSetMm(pExtCtx, paTests[iTest].iRegSrc2, paValues[iVal].uSrc2.QWords.qw0, BS3EXTCTXTOPMM_ZERO);
    12506                     else if (fSseInstr)
    12507                         Bs3ExtCtxSetXmm(pExtCtx, paTests[iTest].iRegSrc2, &paValues[iVal].uSrc2.DQWords.dqw0);
    12508                     else
    12509                         Bs3ExtCtxSetYmm(pExtCtx, paTests[iTest].iRegSrc2, &paValues[iVal].uSrc2, 32);
    12510 
    12511                     /* source #3 */
    12512                     if (paTests[iTest].iRegSrc3 == UINT8_MAX)
    12513                     {
    12514                         BS3_ASSERT(paTests[iTest].enmRm >= RM_MEM);
    12515                         BS3_ASSERT(paTests[iTest].iRegDst != UINT8_MAX && paTests[iTest].iRegSrc1 != UINT8_MAX);
    12516                         Bs3MemCpy(puMemOp, &paValues[iVal].uSrc3, cbMemOp);
    12517                         uMemOpExpect = paValues[iVal].uSrc3;
    12518                     }
    12519                     else if (fMmxInstr)
    12520                         Bs3ExtCtxSetMm(pExtCtx, paTests[iTest].iRegSrc3, paValues[iVal].uSrc3.QWords.qw0, BS3EXTCTXTOPMM_ZERO);
    12521                     else if (fSseInstr)
    12522                         Bs3ExtCtxSetXmm(pExtCtx, paTests[iTest].iRegSrc3, &paValues[iVal].uSrc3.DQWords.dqw0);
    12523                     else
    12524                         Bs3ExtCtxSetYmm(pExtCtx, paTests[iTest].iRegSrc3, &paValues[iVal].uSrc3, 32);
    12525 
    12526                     /* Memory pointer. */
    12527                     if (paTests[iTest].enmRm >= RM_MEM)
    12528                     {
    12529                         BS3_ASSERT(   paTests[iTest].iRegDst  == UINT8_MAX
    12530                                    || paTests[iTest].iRegSrc1 == UINT8_MAX
    12531                                    || paTests[iTest].iRegSrc2 == UINT8_MAX
    12532                                    || paTests[iTest].iRegSrc3 == UINT8_MAX);
    12533                         Bs3RegCtxSetGrpSegFromCurPtr(&Ctx, &Ctx.rbx, &Ctx.fs, puMemOp);
    12534                     }
    12535 
    12536                     /*
    12537                      * Execute.
    12538                      */
    12539                     Bs3TrapSetJmpAndRestoreWithExtCtxAndRm(&Ctx, pExtCtx, &TrapFrame, pExtCtxOut);
    12540 
    12541                     /*
    12542                      * Check the result:
    12543                      */
    12544                     cErrors = Bs3TestSubErrorCount();
    12545 
    12546                     if (fMmxInstr && bXcptExpect == X86_XCPT_DB)
    12547                     {
    12548                         uSavedFtw = Bs3ExtCtxGetAbridgedFtw(pExtCtx);
    12549                         Bs3ExtCtxSetAbridgedFtw(pExtCtx, 0xff); /* Observed on 10980xe after pxor mm1, mm2. */
    12550                     }
    12551                     if (bXcptExpect == X86_XCPT_DB && paTests[iTest].iRegDst != UINT8_MAX)
    12552                     {
    12553                         if (fMmxInstr)
    12554                             Bs3ExtCtxSetMm(pExtCtx, paTests[iTest].iRegDst, paValues[iVal].uDstOut.QWords.qw0, BS3EXTCTXTOPMM_SET);
    12555                         else if (fSseInstr)
    12556                             Bs3ExtCtxSetXmm(pExtCtx, paTests[iTest].iRegDst, &paValues[iVal].uDstOut.DQWords.dqw0);
    12557                         else
    12558                             Bs3ExtCtxSetYmm(pExtCtx, paTests[iTest].iRegDst, &paValues[iVal].uDstOut, cbOperand);
    12559                     }
    12560 #if defined(DEBUG_aeichner) /** @todo Necessary kludge on a i7-1068NG7. */
    12561                     if (   pExtCtx->enmMethod == BS3EXTCTXMETHOD_XSAVE
    12562                         && pExtCtx->Ctx.x.Hdr.bmXState == 0x7
    12563                         && pExtCtxOut->Ctx.x.Hdr.bmXState == 0x3)
    12564                         pExtCtxOut->Ctx.x.Hdr.bmXState = 0x7;
    12565 #endif
    12566                     Bs3TestCheckExtCtx(pExtCtxOut, pExtCtx, 0 /*fFlags*/, pszMode, idTestStep);
    12567 
    12568                     if (TrapFrame.bXcpt != bXcptExpect)
    12569                         Bs3TestFailedF("Expected bXcpt = %#x, got %#x", bXcptExpect, TrapFrame.bXcpt);
    12570 
    12571                     /* Kludge! Looks like EFLAGS.AC is cleared when raising #GP in real mode on the 10980XE. WEIRD! */
    12572                     if (bMode == BS3_MODE_RM && (Ctx.rflags.u32 & X86_EFL_AC))
    12573                     {
    12574                         if (TrapFrame.Ctx.rflags.u32 & X86_EFL_AC)
    12575                             Bs3TestFailedF("Expected EFLAGS.AC to be cleared (bXcpt=%d)", TrapFrame.bXcpt);
    12576                         TrapFrame.Ctx.rflags.u32 |= X86_EFL_AC;
    12577                     }
    12578                     Bs3TestCheckRegCtxEx(&TrapFrame.Ctx, &Ctx, bXcptExpect == X86_XCPT_DB ? cbInstr + 1 : 0, 0,
    12579                                          bXcptExpect == X86_XCPT_DB || BS3_MODE_IS_16BIT_SYS(bMode) ? 0 : X86_EFL_RF,
    12580                                          pszMode, idTestStep);
    12581 
    12582                     if (   paTests[iTest].enmRm >= RM_MEM
    12583                         && Bs3MemCmp(puMemOp, &uMemOpExpect, cbMemOp) != 0)
    12584                         Bs3TestFailedF("Expected uMemOp %.*Rhxs, got %.*Rhxs", cbMemOp, &uMemOpExpect, cbMemOp, puMemOp);
    12585 
    12586                     if (cErrors != Bs3TestSubErrorCount())
    12587                     {
    12588                         if (paConfigs[iCfg].fAligned)
    12589                             Bs3TestFailedF("ring-%d/cfg#%u/test#%u/value#%u failed (bXcptExpect=%#x)",
    12590                                            bRing, iCfg, iTest, iVal, bXcptExpect);
    12591                         else
    12592                             Bs3TestFailedF("ring-%d/cfg#%u/test#%u/value#%u failed (bXcptExpect=%#x, puMemOp=%p, EFLAGS=%#RX32, CR0=%#RX32)",
    12593                                            bRing, iCfg, iTest, iVal, bXcptExpect, puMemOp, TrapFrame.Ctx.rflags.u32, TrapFrame.Ctx.cr0);
    12594                         Bs3TestPrintf("\n");
    12595                     }
    12596 
    12597                     if (uSavedFtw != 0xff)
    12598                         Bs3ExtCtxSetAbridgedFtw(pExtCtx, uSavedFtw);
    12599                 }
    1260012620            }
    1260112621
     
    1299713017                                            : RT_BIT_64(paTests[iTest].cBitsGprValMask) - 1;
    1299813018                uint16_t        idTestStep  = bRing * 10000 + iCfg * 100 + iTest * 10;
     13019                unsigned        cRecompRuns = 0;
    1299913020                unsigned        iVal;
    1300013021
     
    1301813039                 * Iterate the test values and do the actual testing.
    1301913040                 */
    13020                 for (iVal = 0; iVal < cValues; iVal++, idTestStep++)
    13021                 {
    13022                     uint16_t   cErrors;
    13023                     uint16_t   uSavedFtw = 0xff;
    13024                     RTUINT256U uMemOpExpect;
    13025 
    13026                     if (BS3_SKIPIT(bRing, iCfg, iTest, iVal, 0)) continue;
    13027                     /*
    13028                      * Set up the context and some expectations.
    13029                      */
    13030                     /* source - media */
    13031                     BS3_ASSERT(paTests[iTest].iMediaRegSrc != UINT8_MAX);
    13032                     if (fMmxInstr)
    13033                         Bs3ExtCtxSetMm(pExtCtx, paTests[iTest].iMediaRegSrc, paValues[iVal].uMediaSrc.QWords.qw0, BS3EXTCTXTOPMM_ZERO);
    13034                     else if (fSseInstr)
    13035                         Bs3ExtCtxSetXmm(pExtCtx, paTests[iTest].iMediaRegSrc, &paValues[iVal].uMediaSrc.DQWords.dqw0);
    13036                     else
    13037                         Bs3ExtCtxSetYmm(pExtCtx, paTests[iTest].iMediaRegSrc, &paValues[iVal].uMediaSrc, 32);
    13038 
    13039                     /* source - gpr/mem */
    13040                     if (paTests[iTest].iGprReg == UINT8_MAX)
     13041                while (cRecompRuns < BS3_THRESHOLD_NATIVE_RECOMPILER * 2)
     13042                    for (iVal = 0; iVal < cValues; iVal++, idTestStep++)
    1304113043                    {
    13042                         BS3_ASSERT(paTests[iTest].enmRm >= RM_MEM);
    13043                         Bs3MemSet(&uMemOpExpect, 0xcc, sizeof(uMemOpExpect));
     13044                        uint16_t   cErrors;
     13045                        uint16_t   uSavedFtw = 0xff;
     13046                        RTUINT256U uMemOpExpect;
     13047
     13048                        if (BS3_SKIPIT(bRing, iCfg, iTest, iVal, 0)) continue;
     13049                        /*
     13050                         * Set up the context and some expectations.
     13051                         */
     13052                        /* source - media */
     13053                        BS3_ASSERT(paTests[iTest].iMediaRegSrc != UINT8_MAX);
     13054                        if (fMmxInstr)
     13055                            Bs3ExtCtxSetMm(pExtCtx, paTests[iTest].iMediaRegSrc, paValues[iVal].uMediaSrc.QWords.qw0, BS3EXTCTXTOPMM_ZERO);
     13056                        else if (fSseInstr)
     13057                            Bs3ExtCtxSetXmm(pExtCtx, paTests[iTest].iMediaRegSrc, &paValues[iVal].uMediaSrc.DQWords.dqw0);
     13058                        else
     13059                            Bs3ExtCtxSetYmm(pExtCtx, paTests[iTest].iMediaRegSrc, &paValues[iVal].uMediaSrc, 32);
     13060
     13061                        /* source - gpr/mem */
     13062                        if (paTests[iTest].iGprReg == UINT8_MAX)
     13063                        {
     13064                            BS3_ASSERT(paTests[iTest].enmRm >= RM_MEM);
     13065                            Bs3MemSet(&uMemOpExpect, 0xcc, sizeof(uMemOpExpect));
     13066                            if (bXcptExpect == X86_XCPT_DB)
     13067                                switch (paTests[iTest].cbGpr)
     13068                                {
     13069                                    case 1: uMemOpExpect.au8[0]  = (uint8_t) (paValues[iVal].uGpr & fGprValMask); break;
     13070                                    case 2: uMemOpExpect.au16[0] = (uint16_t)(paValues[iVal].uGpr & fGprValMask); break;
     13071                                    case 4: uMemOpExpect.au32[0] = (uint32_t)(paValues[iVal].uGpr & fGprValMask); break;
     13072                                    case 8: uMemOpExpect.au64[0] =           (paValues[iVal].uGpr & fGprValMask); break;
     13073                                    default: BS3_ASSERT(0);
     13074                                }
     13075                            Bs3MemCpy(puMemOp, &uMemOpExpect, cbMemOp);
     13076                        }
     13077                        else
     13078                            Bs3RegCtxSetGpr(&Ctx, paTests[iTest].iGprReg, paValues[iVal].uGpr & fGprValMask, paTests[iTest].cbGpr);
     13079
     13080                        /* Memory pointer. */
     13081                        if (paTests[iTest].enmRm >= RM_MEM)
     13082                        {
     13083                            BS3_ASSERT(paTests[iTest].iGprReg == UINT8_MAX || paTests[iTest].iMediaRegSrc == UINT8_MAX);
     13084                            Bs3RegCtxSetGrpSegFromCurPtr(&Ctx, &Ctx.rbx, &Ctx.fs, puMemOp);
     13085                        }
     13086
     13087                        /*
     13088                         * Execute.
     13089                         */
     13090                        Bs3TrapSetJmpAndRestoreWithExtCtxAndRm(&Ctx, pExtCtx, &TrapFrame, pExtCtxOut);
     13091
     13092                        /*
     13093                         * Check the result:
     13094                         */
     13095                        cErrors = Bs3TestSubErrorCount();
     13096
     13097                        if (fMmxInstr && bXcptExpect == X86_XCPT_DB)
     13098                        {
     13099                            uSavedFtw = Bs3ExtCtxGetAbridgedFtw(pExtCtx);
     13100                            Bs3ExtCtxSetAbridgedFtw(pExtCtx, 0xff);
     13101                        }
     13102
    1304413103                        if (bXcptExpect == X86_XCPT_DB)
    13045                             switch (paTests[iTest].cbGpr)
    13046                             {
    13047                                 case 1: uMemOpExpect.au8[0]  = (uint8_t) (paValues[iVal].uGpr & fGprValMask); break;
    13048                                 case 2: uMemOpExpect.au16[0] = (uint16_t)(paValues[iVal].uGpr & fGprValMask); break;
    13049                                 case 4: uMemOpExpect.au32[0] = (uint32_t)(paValues[iVal].uGpr & fGprValMask); break;
    13050                                 case 8: uMemOpExpect.au64[0] =           (paValues[iVal].uGpr & fGprValMask); break;
    13051                                 default: BS3_ASSERT(0);
    13052                             }
    13053                         Bs3MemCpy(puMemOp, &uMemOpExpect, cbMemOp);
     13104                        {
     13105                            if (fMmxInstr)
     13106                                Bs3ExtCtxSetMm(pExtCtx, paTests[iTest].iMediaRegDst, paValues[iVal].uMediaDst.QWords.qw0, BS3EXTCTXTOPMM_SET);
     13107                            else if (fSseInstr)
     13108                                Bs3ExtCtxSetXmm(pExtCtx, paTests[iTest].iMediaRegDst, &paValues[iVal].uMediaDst.DQWords.dqw0);
     13109                            else
     13110                                Bs3ExtCtxSetYmm(pExtCtx, paTests[iTest].iMediaRegDst, &paValues[iVal].uMediaDst, 32);
     13111                        }
     13112
     13113                        Bs3TestCheckExtCtx(pExtCtxOut, pExtCtx, 0 /*fFlags*/, pszMode, idTestStep);
     13114
     13115                        if (TrapFrame.bXcpt != bXcptExpect)
     13116                            Bs3TestFailedF("Expected bXcpt = %#x, got %#x", bXcptExpect, TrapFrame.bXcpt);
     13117
     13118                        /* Kludge! Looks like EFLAGS.AC is cleared when raising #GP in real mode on the 10980XE. WEIRD! */
     13119                        if (bMode == BS3_MODE_RM && (Ctx.rflags.u32 & X86_EFL_AC))
     13120                        {
     13121                            if (TrapFrame.Ctx.rflags.u32 & X86_EFL_AC)
     13122                                Bs3TestFailedF("Expected EFLAGS.AC to be cleared (bXcpt=%d)", TrapFrame.bXcpt);
     13123                            TrapFrame.Ctx.rflags.u32 |= X86_EFL_AC;
     13124                        }
     13125                        Bs3TestCheckRegCtxEx(&TrapFrame.Ctx, &Ctx, bXcptExpect == X86_XCPT_DB ? cbInstr + 1 : 0, 0,
     13126                                             bXcptExpect == X86_XCPT_DB || BS3_MODE_IS_16BIT_SYS(bMode) ? 0 : X86_EFL_RF,
     13127                                             pszMode, idTestStep);
     13128
     13129                        if (   paTests[iTest].enmRm >= RM_MEM
     13130                            && Bs3MemCmp(puMemOp, &uMemOpExpect, cbMemOp) != 0)
     13131                            Bs3TestFailedF("Expected uMemOp %.*Rhxs, got %.*Rhxs", cbMemOp, &uMemOpExpect, cbMemOp, puMemOp);
     13132
     13133                        if (cErrors != Bs3TestSubErrorCount())
     13134                        {
     13135                            if (paConfigs[iCfg].fAligned)
     13136                                Bs3TestFailedF("ring-%d/cfg#%u/test#%u/value#%u failed (bXcptExpect=%#x)",
     13137                                               bRing, iCfg, iTest, iVal, bXcptExpect);
     13138                            else
     13139                                Bs3TestFailedF("ring-%d/cfg#%u/test#%u/value#%u failed (bXcptExpect=%#x, puMemOp=%p, EFLAGS=%#RX32, CR0=%#RX32)",
     13140                                               bRing, iCfg, iTest, iVal, bXcptExpect, puMemOp, TrapFrame.Ctx.rflags.u32, TrapFrame.Ctx.cr0);
     13141                            Bs3TestPrintf("\n");
     13142                        }
     13143
     13144                        if (uSavedFtw != 0xff)
     13145                            Bs3ExtCtxSetAbridgedFtw(pExtCtx, uSavedFtw);
    1305413146                    }
    13055                     else
    13056                         Bs3RegCtxSetGpr(&Ctx, paTests[iTest].iGprReg, paValues[iVal].uGpr & fGprValMask, paTests[iTest].cbGpr);
    13057 
    13058                     /* Memory pointer. */
    13059                     if (paTests[iTest].enmRm >= RM_MEM)
    13060                     {
    13061                         BS3_ASSERT(paTests[iTest].iGprReg == UINT8_MAX || paTests[iTest].iMediaRegSrc == UINT8_MAX);
    13062                         Bs3RegCtxSetGrpSegFromCurPtr(&Ctx, &Ctx.rbx, &Ctx.fs, puMemOp);
    13063                     }
    13064 
    13065                     /*
    13066                      * Execute.
    13067                      */
    13068                     Bs3TrapSetJmpAndRestoreWithExtCtxAndRm(&Ctx, pExtCtx, &TrapFrame, pExtCtxOut);
    13069 
    13070                     /*
    13071                      * Check the result:
    13072                      */
    13073                     cErrors = Bs3TestSubErrorCount();
    13074 
    13075                     if (fMmxInstr && bXcptExpect == X86_XCPT_DB)
    13076                     {
    13077                         uSavedFtw = Bs3ExtCtxGetAbridgedFtw(pExtCtx);
    13078                         Bs3ExtCtxSetAbridgedFtw(pExtCtx, 0xff);
    13079                     }
    13080 
    13081                     if (bXcptExpect == X86_XCPT_DB)
    13082                     {
    13083                         if (fMmxInstr)
    13084                             Bs3ExtCtxSetMm(pExtCtx, paTests[iTest].iMediaRegDst, paValues[iVal].uMediaDst.QWords.qw0, BS3EXTCTXTOPMM_SET);
    13085                         else if (fSseInstr)
    13086                             Bs3ExtCtxSetXmm(pExtCtx, paTests[iTest].iMediaRegDst, &paValues[iVal].uMediaDst.DQWords.dqw0);
    13087                         else
    13088                             Bs3ExtCtxSetYmm(pExtCtx, paTests[iTest].iMediaRegDst, &paValues[iVal].uMediaDst, 32);
    13089                     }
    13090 
    13091                     Bs3TestCheckExtCtx(pExtCtxOut, pExtCtx, 0 /*fFlags*/, pszMode, idTestStep);
    13092 
    13093                     if (TrapFrame.bXcpt != bXcptExpect)
    13094                         Bs3TestFailedF("Expected bXcpt = %#x, got %#x", bXcptExpect, TrapFrame.bXcpt);
    13095 
    13096                     /* Kludge! Looks like EFLAGS.AC is cleared when raising #GP in real mode on the 10980XE. WEIRD! */
    13097                     if (bMode == BS3_MODE_RM && (Ctx.rflags.u32 & X86_EFL_AC))
    13098                     {
    13099                         if (TrapFrame.Ctx.rflags.u32 & X86_EFL_AC)
    13100                             Bs3TestFailedF("Expected EFLAGS.AC to be cleared (bXcpt=%d)", TrapFrame.bXcpt);
    13101                         TrapFrame.Ctx.rflags.u32 |= X86_EFL_AC;
    13102                     }
    13103                     Bs3TestCheckRegCtxEx(&TrapFrame.Ctx, &Ctx, bXcptExpect == X86_XCPT_DB ? cbInstr + 1 : 0, 0,
    13104                                          bXcptExpect == X86_XCPT_DB || BS3_MODE_IS_16BIT_SYS(bMode) ? 0 : X86_EFL_RF,
    13105                                          pszMode, idTestStep);
    13106 
    13107                     if (   paTests[iTest].enmRm >= RM_MEM
    13108                         && Bs3MemCmp(puMemOp, &uMemOpExpect, cbMemOp) != 0)
    13109                         Bs3TestFailedF("Expected uMemOp %.*Rhxs, got %.*Rhxs", cbMemOp, &uMemOpExpect, cbMemOp, puMemOp);
    13110 
    13111                     if (cErrors != Bs3TestSubErrorCount())
    13112                     {
    13113                         if (paConfigs[iCfg].fAligned)
    13114                             Bs3TestFailedF("ring-%d/cfg#%u/test#%u/value#%u failed (bXcptExpect=%#x)",
    13115                                            bRing, iCfg, iTest, iVal, bXcptExpect);
    13116                         else
    13117                             Bs3TestFailedF("ring-%d/cfg#%u/test#%u/value#%u failed (bXcptExpect=%#x, puMemOp=%p, EFLAGS=%#RX32, CR0=%#RX32)",
    13118                                            bRing, iCfg, iTest, iVal, bXcptExpect, puMemOp, TrapFrame.Ctx.rflags.u32, TrapFrame.Ctx.cr0);
    13119                         Bs3TestPrintf("\n");
    13120                     }
    13121 
    13122                     if (uSavedFtw != 0xff)
    13123                         Bs3ExtCtxSetAbridgedFtw(pExtCtx, uSavedFtw);
    13124                 }
    1312513147            }
    1312613148
     
    1357113593         */
    1357213594        Bs3TestDoModesByOne_pe32(g_aTests, RT_ELEMENTS(g_aTests), BS3TESTMODEBYONEENTRY_F_REAL_MODE_READY);
     13595#ifdef BS3_SKIPIT_DO_SKIP
    1357313596        bs3CpuInstr3_ShowTallies();
     13597#endif
    1357413598    }
    1357513599    else
  • trunk/src/VBox/ValidationKit/bootsectors/bs3kit/bs3kit.h

    r103602 r103867  
    195195 *
    196196 * @{ */
     197
     198/** Test repetitions necessary to make sure of engaging native recompilation.
     199 * @note See iemTbCacheLookup() for the actual constant. */
     200#define BS3_THRESHOLD_NATIVE_RECOMPILER     18
     201
    197202
    198203/** @name Execution modes.
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