VirtualBox

Ignore:
Timestamp:
Jul 6, 2022 10:26:10 AM (3 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
152149
Message:

ValKit/bs3-cpu-instr-3: Reworked the memory operand stuff to use an electric fence buffer in paged modes. Also, do the aligned AC test using strict operand alignmentent. bugref:9898

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r95525 r95526  
    123123*   Global Variables                                                                                                             *
    124124*********************************************************************************************************************************/
    125 static bool g_fGlobalInitialized    = false;
     125static bool g_afTypeSupports[T_MAX] = { false, false, false, false, false, false, false, false, false };
    126126static bool g_fAmdMisalignedSse     = false;
    127 static bool g_afTypeSupports[T_MAX] = { false, false, false, false, false, false, false, false, false };
     127
     128/** Size of g_pbBuf - at least three pages. */
     129static uint32_t         g_cbBuf;
     130/** Buffer of g_cbBuf size. */
     131static uint8_t BS3_FAR *g_pbBuf;
    128132
    129133/** Exception type \#4 test configurations. */
    … …  
    432436                                            PCBS3CPUINSTR3_CONFIG_T paConfigs, unsigned cConfigs)
    433437{
    434     const char BS3_FAR * const  pszMode = Bs3GetModeName(bMode);
    435438    BS3REGCTX                   Ctx;
    436439    BS3TRAPFRAME                TrapFrame;
    437     uint8_t                     bRing = BS3_MODE_IS_V86(bMode) ? 3 : 0;
     440    const char BS3_FAR * const  pszMode = Bs3GetModeName(bMode);
     441    uint8_t                     bRing   = BS3_MODE_IS_V86(bMode) ? 3 : 0;
     442    uint8_t BS3_FAR            *pbBuf   = g_pbBuf;
     443    uint32_t                    cbBuf   = g_cbBuf;
    438444    PBS3EXTCTX                  pExtCtxOut;
    439445    PBS3EXTCTX                  pExtCtx = bs3CpuInstr3AllocExtCtxs(&pExtCtxOut);
    … …  
    451457    bs3CpuInstr3SetupSseAndAvx(&Ctx, pExtCtx);
    452458    //Bs3TestPrintf("FTW=%#x mm1/st1=%.16Rhxs\n",  pExtCtx->Ctx.x87.FTW, &pExtCtx->Ctx.x87.aRegs[1]);
     459
     460    /*
     461     * Prep the buffer for tail guard if we're in paging mode.
     462     */
     463    if (BS3_MODE_IS_PAGED(bMode))
     464    {
     465        Bs3PagingProtectPtr(&pbBuf[0], X86_PAGE_SIZE, 0, X86_PTE_P);
     466        Bs3PagingProtectPtr(&pbBuf[cbBuf - X86_PAGE_SIZE], X86_PAGE_SIZE, 0, X86_PTE_P);
     467        pbBuf += X86_PAGE_SIZE;
     468        cbBuf -= X86_PAGE_SIZE * 2;
     469    }
    453470
    454471    /*
    … …  
    479496                uint8_t const   cbOperand   = paTests[iTest].enmType < T_128BITS ? 64/8
    480497                                            : paTests[iTest].enmType < T_256BITS ? 128/8 : 256/8;
    481                 uint8_t const   cbAlign     = RT_MIN(cbOperand, 16);
     498                uint8_t const   cbMemOp     = cbOperand;
     499                PRTUINT256U     puMemOp     = (PRTUINT256U)&pbBuf[cbBuf - cbMemOp - !paConfigs[iCfg].fAligned];
    482500                uint8_t         bXcptExpect = !g_afTypeSupports[paTests[iTest].enmType] ? X86_XCPT_UD
    483501                                            : fMmxInstr ? paConfigs[iCfg].bXcptMmx
    … …  
    486504                uint16_t        idTestStep  = bRing * 10000 + iCfg * 100 + iTest * 10;
    487505                unsigned        iVal;
    488                 uint8_t         abPadding[sizeof(RTUINT256U) * 2];
    489                 unsigned const  offPadding  = (BS3_FP_OFF(&abPadding[sizeof(RTUINT256U)]) & ~(size_t)(cbAlign - 1))
    490                                             - BS3_FP_OFF(&abPadding[0]);
    491                 PRTUINT256U     puMemOp     = (PRTUINT256U)&abPadding[offPadding - !paConfigs[iCfg].fAligned];
    492                 BS3_ASSERT((uint8_t BS3_FAR *)puMemOp - &abPadding[0] <= sizeof(RTUINT256U));
    493506
    494507                /* If testing unaligned memory accesses, skip register-only tests.  This allows
    … …  
    524537                    {
    525538                        BS3_ASSERT(paTests[iTest].enmRm == RM_MEM);
    526                         Bs3MemSet(puMemOp, 0xcc, sizeof(*puMemOp));
     539                        Bs3MemSet(puMemOp, 0xcc, cbMemOp);
    527540                        if (bXcptExpect == X86_XCPT_DB)
    528541                            uMemOpExpect = paValues[iVal].uDstOut;
    529542                        else
    530                             uMemOpExpect = *puMemOp;
     543                            Bs3MemSet(&uMemOpExpect, 0xcc, sizeof(uMemOpExpect));
    531544                    }
    532545                    else if (fMmxInstr)
    … …  
    537550                    {
    538551                        BS3_ASSERT(paTests[iTest].enmRm == RM_MEM);
    539                         *puMemOp = paValues[iVal].uSrc1;
     552                        Bs3MemCpy(puMemOp, &paValues[iVal].uSrc1, cbMemOp);
    540553                        if (paTests[iTest].iRegDst == UINT8_MAX)
    541554                            BS3_ASSERT(fSseInstr);
    … …  
    555568                        BS3_ASSERT(paTests[iTest].enmRm == RM_MEM);
    556569                        BS3_ASSERT(paTests[iTest].iRegDst != UINT8_MAX && paTests[iTest].iRegSrc1 != UINT8_MAX);
    557                         *puMemOp = uMemOpExpect = paValues[iVal].uSrc2;
     570                        Bs3MemCpy(puMemOp, &paValues[iVal].uSrc2, cbMemOp);
    558571                        uMemOpExpect = paValues[iVal].uSrc2;
    559572                    }
    … …  
    615628
    616629                    if (   paTests[iTest].enmRm == RM_MEM
    617                         && Bs3MemCmp(puMemOp, &uMemOpExpect, cbOperand) != 0)
    618                         Bs3TestFailedF("Expected uMemOp %*.Rhxs, got %*.Rhxs", cbOperand, &uMemOpExpect, cbOperand, puMemOp);
     630                        && Bs3MemCmp(puMemOp, &uMemOpExpect, cbMemOp) != 0)
     631                        Bs3TestFailedF("Expected uMemOp %*.Rhxs, got %*.Rhxs", cbMemOp, &uMemOpExpect, cbMemOp, puMemOp);
    619632
    620633                    if (cErrors != Bs3TestSubErrorCount())
    … …  
    649662     * Cleanup.
    650663     */
     664    if (BS3_MODE_IS_PAGED(bMode))
     665    {
     666        Bs3PagingProtectPtr(&pbBuf[-X86_PAGE_SIZE], X86_PAGE_SIZE, 0, X86_PTE_P);
     667        Bs3PagingProtectPtr(&pbBuf[cbBuf], X86_PAGE_SIZE, 0, X86_PTE_P);
     668    }
    651669    bs3CpuInstr3FreeExtCtxs(pExtCtx, pExtCtxOut);
    652670    return 0;
    … …  
    32763294                                            PCBS3CPUINSTR3_CONFIG_T paConfigs, unsigned cConfigs)
    32773295{
    3278     const char BS3_FAR * const  pszMode = Bs3GetModeName(bMode);
    32793296    BS3REGCTX                   Ctx;
    32803297    BS3TRAPFRAME                TrapFrame;
    3281     uint8_t                     bRing = BS3_MODE_IS_V86(bMode) ? 3 : 0;
     3298    const char BS3_FAR * const  pszMode = Bs3GetModeName(bMode);
     3299    uint8_t BS3_FAR            *pbBuf   = g_pbBuf;
     3300    uint32_t                    cbBuf   = g_cbBuf;
     3301    uint8_t                     bRing   = BS3_MODE_IS_V86(bMode) ? 3 : 0;
    32823302    PBS3EXTCTX                  pExtCtxOut;
    32833303    PBS3EXTCTX                  pExtCtx = bs3CpuInstr3AllocExtCtxs(&pExtCtxOut);
    … …  
    32973317
    32983318    /*
     3319     * Prep the buffer for tail guard if we're in paging mode.
     3320     */
     3321    if (BS3_MODE_IS_PAGED(bMode))
     3322    {
     3323        Bs3PagingProtectPtr(&pbBuf[0], X86_PAGE_SIZE, 0, X86_PTE_P);
     3324        Bs3PagingProtectPtr(&pbBuf[cbBuf - X86_PAGE_SIZE], X86_PAGE_SIZE, 0, X86_PTE_P);
     3325        pbBuf += X86_PAGE_SIZE;
     3326        cbBuf -= X86_PAGE_SIZE * 2;
     3327    }
     3328
     3329    /*
    32993330     * Run the tests in all rings since alignment issues may behave
    33003331     * differently in ring-3 compared to ring-0.
    … …  
    33063337        {
    33073338            unsigned                    iTest;
     3339            bool const                  fCfgAlignCheck = paConfigs[iCfg].fAlignCheck;
     3340            bool const                  fCfgAligned    = paConfigs[iCfg].fAligned;
    33083341            BS3CPUINSTR3_CONFIG_SAVED_T SavedCfg;
    33093342            if (!bs3CpuInstr3ConfigReconfigure(&SavedCfg, &Ctx, pExtCtx, &paConfigs[iCfg], bMode))
    … …  
    33233356                uint8_t const   cbOperand   = paTests[iTest].enmType < T_128BITS ? 64/8
    33243357                                            : paTests[iTest].enmType < T_256BITS ? 128/8 : 256/8;
     3358                uint8_t const   cbMemOp     = cbOperand;
    33253359                uint8_t const   cbAlign     = RT_MIN(cbOperand, 16);
     3360                PRTUINT256U     puMemOp     = (PRTUINT256U)&pbBuf[cbBuf - cbMemOp
     3361                                                                  - (fCfgAligned && fCfgAlignCheck ? cbAlign : !fCfgAligned)];
    33263362                uint8_t         bXcptExpect =    !g_afTypeSupports[paTests[iTest].enmType]
    33273363                                              || paTests[iTest].fInvalidEncoding ? X86_XCPT_UD
    … …  
    33333369                uint16_t        idTestStep  = bRing * 10000 + iCfg * 100 + iTest * 10;
    33343370                unsigned        iVal;
    3335                 uint8_t         abPadding[sizeof(RTUINT256U) * 2];
    3336                 unsigned const  offPadding  = (BS3_FP_OFF(&abPadding[sizeof(RTUINT256U)]) & ~(size_t)(cbAlign - 1))
    3337                                             - BS3_FP_OFF(&abPadding[0]);
    3338                 PRTUINT256U     puMemOp     = (PRTUINT256U)&abPadding[offPadding - !paConfigs[iCfg].fAligned];
    3339                 BS3_ASSERT((uint8_t BS3_FAR *)puMemOp - &abPadding[0] <= sizeof(RTUINT256U));
    33403371
    33413372                /* If testing unaligned memory accesses, skip register-only tests.  This allows
    … …  
    33713402                    {
    33723403                        BS3_ASSERT(paTests[iTest].enmRm == RM_MEM);
    3373                         Bs3MemSet(puMemOp, 0xcc, sizeof(*puMemOp));
    3374                         uMemOpExpect = *puMemOp;
     3404                        Bs3MemSet(puMemOp, 0xcc, cbMemOp);
     3405                        Bs3MemSet(&uMemOpExpect, 0xcc, sizeof(uMemOpExpect));
    33753406                        if (bXcptExpect == X86_XCPT_DB)
    33763407                            switch (paTests[iTest].cbDst)
    … …  
    33893420                        BS3_ASSERT(paTests[iTest].enmRm == RM_MEM);
    33903421                        BS3_ASSERT(paTests[iTest].iRegDst != UINT8_MAX);
    3391                         *puMemOp = uMemOpExpect = paValues[iVal].uSrc;
     3422                        Bs3MemCpy(puMemOp, &paValues[iVal].uSrc, cbMemOp);
    33923423                        uMemOpExpect = paValues[iVal].uSrc;
    33933424                    }
    … …  
    34413472                    if (   paTests[iTest].enmRm == RM_MEM
    34423473                        && Bs3MemCmp(puMemOp, &uMemOpExpect, cbOperand) != 0)
    3443                         Bs3TestFailedF("Expected uMemOp %*.Rhxs, got %*.Rhxs", cbOperand, &uMemOpExpect, cbOperand, puMemOp);
     3474                        Bs3TestFailedF("Expected uMemOp %*.Rhxs, got %*.Rhxs", cbMemOp, &uMemOpExpect, cbMemOp, puMemOp);
    34443475
    34453476                    if (cErrors != Bs3TestSubErrorCount())
    … …  
    34743505     * Cleanup.
    34753506     */
     3507    if (BS3_MODE_IS_PAGED(bMode))
     3508    {
     3509        Bs3PagingProtectPtr(&pbBuf[-X86_PAGE_SIZE], X86_PAGE_SIZE, 0, X86_PTE_P);
     3510        Bs3PagingProtectPtr(&pbBuf[cbBuf], X86_PAGE_SIZE, 0, X86_PTE_P);
     3511    }
    34763512    bs3CpuInstr3FreeExtCtxs(pExtCtx, pExtCtxOut);
    34773513    return 0;
    … …  
    35843620                                            PCBS3CPUINSTR3_CONFIG_T paConfigs, unsigned cConfigs, uint8_t cbMaxAlign)
    35853621{
    3586     const char BS3_FAR * const  pszMode = Bs3GetModeName(bMode);
    35873622    BS3REGCTX                   Ctx;
    35883623    BS3TRAPFRAME                TrapFrame;
     3624    const char BS3_FAR * const  pszMode = Bs3GetModeName(bMode);
     3625    uint8_t BS3_FAR            *pbBuf   = g_pbBuf;
     3626    uint32_t                    cbBuf   = g_cbBuf;
    35893627    uint8_t                     bRing   = BS3_MODE_IS_V86(bMode) ? 3 : 0;
    35903628    PBS3EXTCTX                  pExtCtxOut;
    … …  
    36043642
    36053643    /*
     3644     * Prep the buffer for tail guard if we're in paging mode.
     3645     */
     3646    if (BS3_MODE_IS_PAGED(bMode))
     3647    {
     3648        Bs3PagingProtectPtr(&pbBuf[0], X86_PAGE_SIZE, 0, X86_PTE_P);
     3649        Bs3PagingProtectPtr(&pbBuf[cbBuf - X86_PAGE_SIZE], X86_PAGE_SIZE, 0, X86_PTE_P);
     3650        pbBuf += X86_PAGE_SIZE;
     3651        cbBuf -= X86_PAGE_SIZE * 2;
     3652    }
     3653
     3654    /*
    36063655     * Run the tests in all rings since alignment issues may behave
    36073656     * differently in ring-3 compared to ring-0.
    … …  
    36133662        {
    36143663            unsigned                    iTest;
     3664            bool const                  fCfgAlignCheck = paConfigs[iCfg].fAlignCheck;
     3665            bool const                  fCfgAligned    = paConfigs[iCfg].fAligned;
    36153666            BS3CPUINSTR3_CONFIG_SAVED_T SavedCfg;
    36163667            if (!bs3CpuInstr3ConfigReconfigure(&SavedCfg, &Ctx, pExtCtx, &paConfigs[iCfg], bMode))
    … …  
    36303681                uint8_t const   cbOperand   = paTests[iTest].enmType < T_128BITS ? 64/8
    36313682                                            : paTests[iTest].enmType < T_256BITS ? 128/8 : 256/8;
     3683                uint8_t const   cbMemOp     = cbOperand;
    36323684                uint8_t const   cbAlign     = RT_MIN(cbOperand, !cbMaxAlign ? 16 : cbMaxAlign);
     3685                PRTUINT256U     puMemOp     = (PRTUINT256U)&pbBuf[cbBuf - cbMemOp
     3686                                                                  - (fCfgAligned && fCfgAlignCheck ? cbAlign : !fCfgAligned)];
    36333687                uint8_t         bXcptExpect = !g_afTypeSupports[paTests[iTest].enmType] ? X86_XCPT_UD
    36343688                                            : fMmxInstr ? paConfigs[iCfg].bXcptMmx
    … …  
    36373691                uint16_t        idTestStep  = bRing * 10000 + iCfg * 100 + iTest * 10;
    36383692                unsigned        iVal;
    3639                 uint8_t         abPadding[sizeof(RTUINT256U) * 2];
    3640                 unsigned const  offPadding  = (BS3_FP_OFF(&abPadding[sizeof(RTUINT256U)]) & ~(size_t)(cbAlign - 1))
    3641                                             - BS3_FP_OFF(&abPadding[0]);
    3642                 PRTUINT256U     puMemOp     = (PRTUINT256U)&abPadding[offPadding - !paConfigs[iCfg].fAligned];
    3643                 BS3_ASSERT((uint8_t BS3_FAR *)puMemOp - &abPadding[0] <= sizeof(RTUINT256U));
    36443693
    36453694                /* If testing unaligned memory accesses, skip register-only tests.  This allows
    … …  
    36753724                    {
    36763725                        BS3_ASSERT(paTests[iTest].enmRm == RM_MEM);
    3677                         Bs3MemSet(puMemOp, 0xcc, sizeof(*puMemOp));
     3726                        Bs3MemSet(puMemOp, 0xcc, cbMemOp);
    36783727                        if (bXcptExpect == X86_XCPT_DB)
    36793728                            uMemOpExpect = paValues[iVal].uDstOut;
    36803729                        else
    3681                             uMemOpExpect = *puMemOp;
     3730                            Bs3MemSet(&uMemOpExpect, 0xcc, sizeof(uMemOpExpect));
    36823731                    }
    36833732                    else if (fMmxInstr)
    … …  
    36893738                        BS3_ASSERT(paTests[iTest].enmRm == RM_MEM);
    36903739                        BS3_ASSERT(paTests[iTest].iRegDst != UINT8_MAX);
    3691                         *puMemOp = uMemOpExpect = paValues[iVal].uSrc;
     3740                        Bs3MemCpy(puMemOp, &paValues[iVal].uSrc, cbMemOp);
    36923741                        uMemOpExpect = paValues[iVal].uSrc;
    36933742                    }
    … …  
    37483797
    37493798                    if (   paTests[iTest].enmRm == RM_MEM
    3750                         && Bs3MemCmp(puMemOp, &uMemOpExpect, cbOperand) != 0)
    3751                         Bs3TestFailedF("Expected uMemOp %*.Rhxs, got %*.Rhxs", cbOperand, &uMemOpExpect, cbOperand, puMemOp);
     3799                        && Bs3MemCmp(puMemOp, &uMemOpExpect, cbMemOp) != 0)
     3800                        Bs3TestFailedF("Expected uMemOp %*.Rhxs, got %*.Rhxs", cbMemOp, &uMemOpExpect, cbMemOp, puMemOp);
    37523801
    37533802                    if (cErrors != Bs3TestSubErrorCount())
    … …  
    37823831     * Cleanup.
    37833832     */
     3833    if (BS3_MODE_IS_PAGED(bMode))
     3834    {
     3835        Bs3PagingProtectPtr(&pbBuf[-X86_PAGE_SIZE], X86_PAGE_SIZE, 0, X86_PTE_P);
     3836        Bs3PagingProtectPtr(&pbBuf[cbBuf], X86_PAGE_SIZE, 0, X86_PTE_P);
     3837    }
    37843838    bs3CpuInstr3FreeExtCtxs(pExtCtx, pExtCtxOut);
    37853839    return 0;
    … …  
    44964550
    44974551    /*
    4498      * Do the tests.
     4552     * Allocate a buffer for testing.
    44994553     */
    4500     Bs3TestDoModesByOne_pe32(g_aTests, RT_ELEMENTS(g_aTests), BS3TESTMODEBYONEENTRY_F_REAL_MODE_READY);
     4554    g_cbBuf = X86_PAGE_SIZE * 4;
     4555    g_pbBuf = (uint8_t BS3_FAR *)Bs3MemAlloc(BS3MEMKIND_REAL, g_cbBuf);
     4556    if (g_pbBuf)
     4557    {
     4558        /*
     4559         * Do the tests.
     4560         */
     4561        Bs3TestDoModesByOne_pe32(g_aTests, RT_ELEMENTS(g_aTests), BS3TESTMODEBYONEENTRY_F_REAL_MODE_READY);
     4562    }
     4563    else
     4564        Bs3TestFailed("Failed to allocate 16K buffer");
    45014565
    45024566    Bs3TestTerm();
Note: See TracChangeset for help on using the changeset viewer.

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