VirtualBox

Changeset 96931 in vbox


Ignore:
Timestamp:
Sep 29, 2022 9:55:49 AM (2 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
153842
Message:

VMM/testcase/tstIEMAImpl: Implement basic cvtps2pi/cvttps2pi testcases, bugref:9898

Location:
trunk/src/VBox/VMM/testcase
Files:
2 added
5 edited

Legend:

Unmodified
Added
Removed

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

    r96922 r96931  
    314314        tstIEMAImplDataSseConvert-cvttpd2pi_u128.bin \
    315315        tstIEMAImplDataSseConvert-cvtpi2ps_u128.bin \
    316         tstIEMAImplDataSseConvert-cvtpi2pd_u128.bin
     316        tstIEMAImplDataSseConvert-cvtpi2pd_u128.bin \
     317        tstIEMAImplDataSseConvert-cvtps2pi_u128.bin \
     318        tstIEMAImplDataSseConvert-cvttps2pi_u128.bin
    317319
    318320tstIEMAImpl_TEMPLATE  = VBOXR3TSTEXE

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

    r96922 r96931  
    85608560
    85618561
     8562/*
     8563 * Convert SSE operations converting single-precision floating point values to signed double-word values.
     8564 */
     8565TYPEDEF_SUBTEST_TYPE(SSE_CONVERT_MM_I32_XMM_R32_T, SSE_CONVERT_MM_R32_TEST_T, PFNIEMAIMPLMXCSRU64U64);
     8566
     8567static const SSE_CONVERT_MM_I32_XMM_R32_T g_aSseConvertMmI32XmmR32[] =
     8568{
     8569    ENTRY_BIN(cvtps2pi_u128),
     8570    ENTRY_BIN(cvttps2pi_u128)
     8571};
     8572
     8573#ifdef TSTIEMAIMPL_WITH_GENERATOR
     8574static RTEXITCODE SseConvertMmI32XmmR32Generate(const char *pszDataFileFmt, uint32_t cTests)
     8575{
     8576    cTests = RT_MAX(192, cTests); /* there are 144 standard input variations */
     8577
     8578    static struct { RTFLOAT32U aVal1[2]; } const s_aSpecials[] =
     8579    {
     8580        { { RTFLOAT32U_INIT_ZERO(0), RTFLOAT32U_INIT_ZERO(0)  } },
     8581        { { RTFLOAT32U_INIT_ZERO(1), RTFLOAT32U_INIT_ZERO(1)  } },
     8582        { { RTFLOAT32U_INIT_INF(0),  RTFLOAT32U_INIT_INF(0)   } },
     8583        { { RTFLOAT32U_INIT_INF(1),  RTFLOAT32U_INIT_INF(1)   } }
     8584          /** @todo More specials. */
     8585    };
     8586
     8587    uint32_t cMinNormalPairs       = (cTests - 144) / 4;
     8588    for (size_t iFn = 0; iFn < RT_ELEMENTS(g_aSseConvertMmI32XmmR32); iFn++)
     8589    {
     8590        PFNIEMAIMPLMXCSRU64U64 const pfn = g_aSseConvertMmI32XmmR32[iFn].pfnNative ? g_aSseConvertMmI32XmmR32[iFn].pfnNative : g_aSseConvertMmI32XmmR32[iFn].pfn;
     8591
     8592        PRTSTREAM pStrmOut = NULL;
     8593        int rc = RTStrmOpenF("wb", &pStrmOut, pszDataFileFmt, g_aSseConvertMmI32XmmR32[iFn].pszName);
     8594        if (RT_FAILURE(rc))
     8595        {
     8596            RTMsgError("Failed to open data file for %s for writing: %Rrc", g_aSseConvertMmI32XmmR32[iFn].pszName, rc);
     8597            return RTEXITCODE_FAILURE;
     8598        }
     8599
     8600        uint32_t cNormalInputPairs  = 0;
     8601        for (uint32_t iTest = 0; iTest < cTests + RT_ELEMENTS(s_aSpecials); iTest += 1)
     8602        {
     8603            SSE_CONVERT_MM_R32_TEST_T TestData; RT_ZERO(TestData);
     8604
     8605            TestData.ar32InVal[0] = iTest < cTests ? RandR32Src(iTest) : s_aSpecials[iTest - cTests].aVal1[0];
     8606            TestData.ar32InVal[1] = iTest < cTests ? RandR32Src(iTest) : s_aSpecials[iTest - cTests].aVal1[1];
     8607
     8608            if (   RTFLOAT32U_IS_NORMAL(&TestData.ar32InVal[0])
     8609                && RTFLOAT32U_IS_NORMAL(&TestData.ar32InVal[1]))
     8610                cNormalInputPairs++;
     8611            else if (cNormalInputPairs < cMinNormalPairs && iTest + cMinNormalPairs >= cTests && iTest < cTests)
     8612            {
     8613                iTest -= 1;
     8614                continue;
     8615            }
     8616
     8617            RTFLOAT64U TestVal;
     8618            TestVal.au32[0] = TestData.ar32InVal[0].u;
     8619            TestVal.au32[1] = TestData.ar32InVal[1].u;
     8620
     8621            uint32_t const fMxcsr = RandMxcsr() & X86_MXCSR_XCPT_FLAGS;
     8622            for (uint16_t iRounding = 0; iRounding < 4; iRounding++)
     8623                for (uint8_t iDaz = 0; iDaz < 2; iDaz++)
     8624                    for (uint8_t iFz = 0; iFz < 2; iFz++)
     8625                    {
     8626                        uint32_t fMxcsrIn = (fMxcsr & ~X86_MXCSR_RC_MASK)
     8627                                          | (iRounding  << X86_MXCSR_RC_SHIFT)
     8628                                          | (iDaz ? X86_MXCSR_DAZ : 0)
     8629                                          | (iFz  ? X86_MXCSR_FZ  : 0)
     8630                                          | X86_MXCSR_XCPT_MASK;
     8631                        uint32_t fMxcsrM  = fMxcsrIn;
     8632                        uint64_t u64ResM;
     8633                        pfn(&fMxcsrM, &u64ResM, TestVal.u);
     8634                        TestData.fMxcsrIn  = fMxcsrIn;
     8635                        TestData.fMxcsrOut = fMxcsrM;
     8636                        TestData.OutVal.u  = u64ResM;
     8637                        RTStrmWrite(pStrmOut, &TestData, sizeof(TestData));
     8638
     8639                        fMxcsrIn &= ~X86_MXCSR_XCPT_MASK;
     8640                        uint32_t fMxcsrU  = fMxcsrIn;
     8641                        uint64_t u64ResU;
     8642                        pfn(&fMxcsrU, &u64ResU, TestVal.u);
     8643                        TestData.fMxcsrIn  = fMxcsrIn;
     8644                        TestData.fMxcsrOut = fMxcsrU;
     8645                        TestData.OutVal.u  = u64ResU;
     8646                        RTStrmWrite(pStrmOut, &TestData, sizeof(TestData));
     8647
     8648                        uint16_t fXcpt = (fMxcsrM | fMxcsrU) & X86_MXCSR_XCPT_FLAGS;
     8649                        if (fXcpt)
     8650                        {
     8651                            fMxcsrIn = (fMxcsrIn & ~X86_MXCSR_XCPT_MASK) | fXcpt;
     8652                            uint32_t fMxcsr1  = fMxcsrIn;
     8653                            uint64_t u64Res1;
     8654                            pfn(&fMxcsr1, &u64Res1, TestVal.u);
     8655                            TestData.fMxcsrIn  = fMxcsrIn;
     8656                            TestData.fMxcsrOut = fMxcsr1;
     8657                            TestData.OutVal.u  = u64Res1;
     8658                            RTStrmWrite(pStrmOut, &TestData, sizeof(TestData));
     8659
     8660                            if (((fMxcsr1 & X86_MXCSR_XCPT_FLAGS) & fXcpt) != (fMxcsr1 & X86_MXCSR_XCPT_FLAGS))
     8661                            {
     8662                                fXcpt |= fMxcsr1 & X86_MXCSR_XCPT_FLAGS;
     8663                                fMxcsrIn = (fMxcsrIn & ~X86_MXCSR_XCPT_MASK) | (fXcpt << X86_MXCSR_XCPT_MASK_SHIFT);
     8664                                uint32_t fMxcsr2  = fMxcsrIn;
     8665                                uint64_t u64Res2;
     8666                                pfn(&fMxcsr2, &u64Res2, TestVal.u);
     8667                                TestData.fMxcsrIn  = fMxcsrIn;
     8668                                TestData.fMxcsrOut = fMxcsr2;
     8669                                TestData.OutVal.u  = u64Res2;
     8670                                RTStrmWrite(pStrmOut, &TestData, sizeof(TestData));
     8671                            }
     8672                            if (!RT_IS_POWER_OF_TWO(fXcpt))
     8673                                for (uint16_t fUnmasked = 1; fUnmasked <= X86_MXCSR_PE; fUnmasked <<= 1)
     8674                                    if (fUnmasked & fXcpt)
     8675                                    {
     8676                                        fMxcsrIn = (fMxcsrIn & ~X86_MXCSR_XCPT_MASK) | ((fXcpt & ~fUnmasked) << X86_MXCSR_XCPT_MASK_SHIFT);
     8677                                        uint32_t fMxcsr3  = fMxcsrIn;
     8678                                        uint64_t u64Res3;
     8679                                        pfn(&fMxcsr3, &u64Res3, TestVal.u);
     8680                                        TestData.fMxcsrIn  = fMxcsrIn;
     8681                                        TestData.fMxcsrOut = fMxcsr3;
     8682                                        TestData.OutVal.u  = u64Res3;
     8683                                        RTStrmWrite(pStrmOut, &TestData, sizeof(TestData));
     8684                                    }
     8685                        }
     8686                    }
     8687        }
     8688        rc = RTStrmClose(pStrmOut);
     8689        if (RT_FAILURE(rc))
     8690        {
     8691            RTMsgError("Failed to close data file for %s: %Rrc", g_aSseConvertMmI32XmmR32[iFn].pszName, rc);
     8692            return RTEXITCODE_FAILURE;
     8693        }
     8694    }
     8695
     8696    return RTEXITCODE_SUCCESS;
     8697}
     8698#endif
     8699
     8700static void SseConvertMmI32XmmR32Test(void)
     8701{
     8702    X86FXSTATE State;
     8703    RT_ZERO(State);
     8704
     8705    for (size_t iFn = 0; iFn < RT_ELEMENTS(g_aSseConvertMmI32XmmR32); iFn++)
     8706    {
     8707        if (!SubTestAndCheckIfEnabled(g_aSseConvertMmI32XmmR32[iFn].pszName))
     8708            continue;
     8709
     8710        uint32_t const                          cTests  = *g_aSseConvertMmI32XmmR32[iFn].pcTests;
     8711        SSE_CONVERT_MM_R32_TEST_T const * const paTests = g_aSseConvertMmI32XmmR32[iFn].paTests;
     8712        PFNIEMAIMPLMXCSRU64U64                  pfn     = g_aSseConvertMmI32XmmR32[iFn].pfn;
     8713        uint32_t const                          cVars   = COUNT_VARIATIONS(g_aSseConvertMmI32XmmR32[iFn]);
     8714        if (!cTests) RTTestSkipped(g_hTest, "no tests");
     8715        for (uint32_t iVar = 0; iVar < cVars; iVar++)
     8716        {
     8717            for (uint32_t iTest = 0; iTest < cTests / sizeof(*paTests); iTest++)
     8718            {
     8719                RTUINT64U ValOut;
     8720                RTUINT64U ValIn;
     8721
     8722                ValIn.au32[0] = paTests[iTest].ar32InVal[0].u;
     8723                ValIn.au32[1] = paTests[iTest].ar32InVal[1].u;
     8724
     8725                uint32_t fMxcsr = paTests[iTest].fMxcsrIn;
     8726                pfn(&fMxcsr, &ValOut.u, ValIn.u);
     8727                if (   fMxcsr != paTests[iTest].fMxcsrOut
     8728                    || ValOut.ai32[0] != paTests[iTest].OutVal.ai32[0]
     8729                    || ValOut.ai32[1] != paTests[iTest].OutVal.ai32[1])
     8730                    RTTestFailed(g_hTest, "#%04u%s: mxcsr=%#08x in1=%s'%s \n"
     8731                                          "%s               -> mxcsr=%#08x    %RI32'%RI32\n"
     8732                                          "%s               expected %#08x    %RI32'%RI32%s%s (%s)\n",
     8733                                 iTest, iVar ? "/n" : "", paTests[iTest].fMxcsrIn,
     8734                                 FormatR32(&paTests[iTest].ar32InVal[0]), FormatR32(&paTests[iTest].ar32InVal[1]),
     8735                                 iVar ? "  " : "", fMxcsr,
     8736                                 ValOut.ai32[0], ValOut.ai32[1],
     8737                                 iVar ? "  " : "", paTests[iTest].fMxcsrOut,
     8738                                 paTests[iTest].OutVal.ai32[0], paTests[iTest].OutVal.ai32[1],
     8739                                 MxcsrDiff(fMxcsr, paTests[iTest].fMxcsrOut),
     8740                                   (   ValOut.ai32[0] != paTests[iTest].OutVal.ai32[0]
     8741                                    || ValOut.ai32[1] != paTests[iTest].OutVal.ai32[1])
     8742                                 ? " - val" : "",
     8743                                 FormatMxcsr(paTests[iTest].fMxcsrIn));
     8744            }
     8745        }
     8746    }
     8747}
     8748
     8749
    85628750
    85638751int main(int argc, char **argv)
    … …  
    89599147            if (rcExit == RTEXITCODE_SUCCESS)
    89609148                rcExit = SseConvertXmmR64MmGenerate(pszDataFileFmtConv, cTests);
     9149            if (rcExit == RTEXITCODE_SUCCESS)
     9150                rcExit = SseConvertMmI32XmmR32Generate(pszDataFileFmtConv, cTests);
    89619151            if (rcExit != RTEXITCODE_SUCCESS)
    89629152                return rcExit;
    … …  
    90849274                SseConvertXmmR32MmTest();
    90859275                SseConvertXmmR64MmTest();
     9276                SseConvertMmI32XmmR32Test();
    90869277            }
    90879278        }

  • trunk/src/VBox/VMM/testcase/tstIEMAImpl.h

    r96922 r96931  
    509509    X86XMMREG               OutVal;
    510510} SSE_CONVERT_XMM_MM_TEST_T;
     511
     512typedef struct SSE_CONVERT_MM_R32_TEST_T
     513{
     514    uint32_t                fMxcsrIn;
     515    uint32_t                fMxcsrOut;
     516    RTFLOAT32U              ar32InVal[2];
     517    RTUINT64U               OutVal;
     518} SSE_CONVERT_MM_R32_TEST_T;
    511519
    512520/** @} */
    … …  
    975983TSTIEM_DECLARE_TEST_ARRAY_BIN(SseConvert,   SSE_CONVERT_XMM_MM_TEST_T,      cvtpi2pd_u128        );
    976984
     985TSTIEM_DECLARE_TEST_ARRAY_BIN(SseConvert,   SSE_CONVERT_MM_R32_TEST_T,      cvtps2pi_u128        );
     986TSTIEM_DECLARE_TEST_ARRAY_BIN(SseConvert,   SSE_CONVERT_MM_R32_TEST_T,      cvttps2pi_u128       );
     987
    977988RT_C_DECLS_END
    978989

  • trunk/src/VBox/VMM/testcase/tstIEMAImplDataSseBinary.S

    r96922 r96931  
    148148IEM_TEST_DATA cvtpi2ps_u128,        "tstIEMAImplDataSseConvert-cvtpi2ps_u128.bin"
    149149IEM_TEST_DATA cvtpi2pd_u128,        "tstIEMAImplDataSseConvert-cvtpi2pd_u128.bin"
     150
     151IEM_TEST_DATA cvtps2pi_u128,        "tstIEMAImplDataSseConvert-cvtps2pi_u128.bin"
     152IEM_TEST_DATA cvttps2pi_u128,       "tstIEMAImplDataSseConvert-cvttps2pi_u128.bin"

  • trunk/src/VBox/VMM/testcase/tstIEMAImplDataSseBinary.asm

    r96922 r96931  
    146146IEM_TEST_DATA cvtpi2ps_u128,        "tstIEMAImplDataSseConvert-cvtpi2ps_u128.bin"
    147147IEM_TEST_DATA cvtpi2pd_u128,        "tstIEMAImplDataSseConvert-cvtpi2pd_u128.bin"
     148
     149IEM_TEST_DATA cvtps2pi_u128,        "tstIEMAImplDataSseConvert-cvtps2pi_u128.bin"
     150IEM_TEST_DATA cvttps2pi_u128,       "tstIEMAImplDataSseConvert-cvttps2pi_u128.bin"
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