VirtualBox

Changeset 96917 in vbox for trunk/src/VBox/VMM/testcase


Ignore:
Timestamp:
Sep 28, 2022 12:53:47 PM (3 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
153828
Message:

VMM/testcase/tstIEMAImpl: Implement basic cvtpd2pi/cvttpd2pi 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

    r96797 r96917  
    310310        tstIEMAImplDataSseConvert-cvtdq2pd_u128.bin \
    311311        tstIEMAImplDataSseConvert-cvtpd2dq_u128.bin \
    312         tstIEMAImplDataSseConvert-cvttpd2dq_u128.bin
     312        tstIEMAImplDataSseConvert-cvttpd2dq_u128.bin \
     313        tstIEMAImplDataSseConvert-cvtpd2pi_u128.bin \
     314        tstIEMAImplDataSseConvert-cvttpd2pi_u128.bin
    313315
    314316tstIEMAImpl_TEMPLATE  = VBOXR3TSTEXE

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

    r96846 r96917  
    80788078
    80798079
     8080/*
     8081 * Convert SSE operations converting double-precision floating point values to signed double-word values.
     8082 */
     8083TYPEDEF_SUBTEST_TYPE(SSE_CONVERT_MM_XMM_T, SSE_CONVERT_MM_XMM_TEST_T, PFNIEMAIMPLMXCSRU64U128);
     8084
     8085static const SSE_CONVERT_MM_XMM_T g_aSseConvertMmXmm[] =
     8086{
     8087    ENTRY_BIN(cvtpd2pi_u128),
     8088    ENTRY_BIN(cvttpd2pi_u128)
     8089};
     8090
     8091#ifdef TSTIEMAIMPL_WITH_GENERATOR
     8092static RTEXITCODE SseConvertMmXmmGenerate(const char *pszDataFileFmt, uint32_t cTests)
     8093{
     8094    cTests = RT_MAX(192, cTests); /* there are 144 standard input variations */
     8095
     8096    static struct { RTFLOAT64U aVal1[2]; } const s_aSpecials[] =
     8097    {
     8098        { { RTFLOAT64U_INIT_ZERO(0), RTFLOAT64U_INIT_ZERO(0) } },
     8099        { { RTFLOAT64U_INIT_ZERO(1), RTFLOAT64U_INIT_ZERO(1) } },
     8100        { { RTFLOAT64U_INIT_INF(0),  RTFLOAT64U_INIT_INF(0)  } },
     8101        { { RTFLOAT64U_INIT_INF(1),  RTFLOAT64U_INIT_INF(1)  } }
     8102          /** @todo More specials. */
     8103    };
     8104
     8105    X86FXSTATE State;
     8106    RT_ZERO(State);
     8107    uint32_t cMinNormalPairs       = (cTests - 144) / 4;
     8108    for (size_t iFn = 0; iFn < RT_ELEMENTS(g_aSseConvertMmXmm); iFn++)
     8109    {
     8110        PFNIEMAIMPLMXCSRU64U128 const pfn = g_aSseConvertMmXmm[iFn].pfnNative ? g_aSseConvertMmXmm[iFn].pfnNative : g_aSseConvertMmXmm[iFn].pfn;
     8111
     8112        PRTSTREAM pStrmOut = NULL;
     8113        int rc = RTStrmOpenF("wb", &pStrmOut, pszDataFileFmt, g_aSseConvertMmXmm[iFn].pszName);
     8114        if (RT_FAILURE(rc))
     8115        {
     8116            RTMsgError("Failed to open data file for %s for writing: %Rrc", g_aSseConvertMmXmm[iFn].pszName, rc);
     8117            return RTEXITCODE_FAILURE;
     8118        }
     8119
     8120        uint32_t cNormalInputPairs  = 0;
     8121        for (uint32_t iTest = 0; iTest < cTests + RT_ELEMENTS(s_aSpecials); iTest += 1)
     8122        {
     8123            SSE_CONVERT_MM_XMM_TEST_T TestData; RT_ZERO(TestData);
     8124
     8125            TestData.InVal.ar64[0] = iTest < cTests ? RandR64Src(iTest) : s_aSpecials[iTest - cTests].aVal1[0];
     8126            TestData.InVal.ar64[1] = iTest < cTests ? RandR64Src(iTest) : s_aSpecials[iTest - cTests].aVal1[1];
     8127
     8128            if (   RTFLOAT64U_IS_NORMAL(&TestData.InVal.ar64[0])
     8129                && RTFLOAT64U_IS_NORMAL(&TestData.InVal.ar64[1]))
     8130                cNormalInputPairs++;
     8131            else if (cNormalInputPairs < cMinNormalPairs && iTest + cMinNormalPairs >= cTests && iTest < cTests)
     8132            {
     8133                iTest -= 1;
     8134                continue;
     8135            }
     8136
     8137            uint32_t const fMxcsr = RandMxcsr() & X86_MXCSR_XCPT_FLAGS;
     8138            for (uint16_t iRounding = 0; iRounding < 4; iRounding++)
     8139                for (uint8_t iDaz = 0; iDaz < 2; iDaz++)
     8140                    for (uint8_t iFz = 0; iFz < 2; iFz++)
     8141                    {
     8142                        uint32_t fMxcsrIn = (fMxcsr & ~X86_MXCSR_RC_MASK)
     8143                                          | (iRounding  << X86_MXCSR_RC_SHIFT)
     8144                                          | (iDaz ? X86_MXCSR_DAZ : 0)
     8145                                          | (iFz  ? X86_MXCSR_FZ  : 0)
     8146                                          | X86_MXCSR_XCPT_MASK;
     8147                        uint32_t fMxcsrM  = fMxcsrIn;
     8148                        uint64_t u64ResM;
     8149                        pfn(&fMxcsrM, &u64ResM, &TestData.InVal);
     8150                        TestData.fMxcsrIn   = fMxcsrIn;
     8151                        TestData.fMxcsrOut  = fMxcsrM;
     8152                        TestData.OutVal.u   = u64ResM;
     8153                        RTStrmWrite(pStrmOut, &TestData, sizeof(TestData));
     8154
     8155                        fMxcsrIn &= ~X86_MXCSR_XCPT_MASK;
     8156                        uint32_t fMxcsrU  = fMxcsrIn;
     8157                        uint64_t u64ResU;
     8158                        pfn(&fMxcsrU, &u64ResU, &TestData.InVal);
     8159                        TestData.fMxcsrIn   = fMxcsrIn;
     8160                        TestData.fMxcsrOut  = fMxcsrU;
     8161                        TestData.OutVal.u   = u64ResU;
     8162                        RTStrmWrite(pStrmOut, &TestData, sizeof(TestData));
     8163
     8164                        uint16_t fXcpt = (fMxcsrM | fMxcsrU) & X86_MXCSR_XCPT_FLAGS;
     8165                        if (fXcpt)
     8166                        {
     8167                            fMxcsrIn = (fMxcsrIn & ~X86_MXCSR_XCPT_MASK) | fXcpt;
     8168                            uint32_t fMxcsr1  = fMxcsrIn;
     8169                            uint64_t u64Res1;
     8170                            pfn(&fMxcsr1, &u64Res1, &TestData.InVal);
     8171                            TestData.fMxcsrIn   = fMxcsrIn;
     8172                            TestData.fMxcsrOut  = fMxcsr1;
     8173                            TestData.OutVal.u   = u64Res1;
     8174                            RTStrmWrite(pStrmOut, &TestData, sizeof(TestData));
     8175
     8176                            if (((fMxcsr1 & X86_MXCSR_XCPT_FLAGS) & fXcpt) != (fMxcsr1 & X86_MXCSR_XCPT_FLAGS))
     8177                            {
     8178                                fXcpt |= fMxcsr1 & X86_MXCSR_XCPT_FLAGS;
     8179                                fMxcsrIn = (fMxcsrIn & ~X86_MXCSR_XCPT_MASK) | (fXcpt << X86_MXCSR_XCPT_MASK_SHIFT);
     8180                                uint32_t fMxcsr2  = fMxcsrIn;
     8181                                uint64_t u64Res2;
     8182                                pfn(&fMxcsr2, &u64Res2, &TestData.InVal);
     8183                                TestData.fMxcsrIn   = fMxcsrIn;
     8184                                TestData.fMxcsrOut  = fMxcsr2;
     8185                                TestData.OutVal.u   = u64Res2;
     8186                                RTStrmWrite(pStrmOut, &TestData, sizeof(TestData));
     8187                            }
     8188                            if (!RT_IS_POWER_OF_TWO(fXcpt))
     8189                                for (uint16_t fUnmasked = 1; fUnmasked <= X86_MXCSR_PE; fUnmasked <<= 1)
     8190                                    if (fUnmasked & fXcpt)
     8191                                    {
     8192                                        fMxcsrIn = (fMxcsrIn & ~X86_MXCSR_XCPT_MASK) | ((fXcpt & ~fUnmasked) << X86_MXCSR_XCPT_MASK_SHIFT);
     8193                                        uint32_t fMxcsr3  = fMxcsrIn;
     8194                                        uint64_t u64Res3;
     8195                                        pfn(&fMxcsr3, &u64Res3, &TestData.InVal);
     8196                                        TestData.fMxcsrIn   = fMxcsrIn;
     8197                                        TestData.fMxcsrOut  = fMxcsr3;
     8198                                        TestData.OutVal.u   = u64Res3;
     8199                                        RTStrmWrite(pStrmOut, &TestData, sizeof(TestData));
     8200                                    }
     8201                        }
     8202                    }
     8203        }
     8204        rc = RTStrmClose(pStrmOut);
     8205        if (RT_FAILURE(rc))
     8206        {
     8207            RTMsgError("Failed to close data file for %s: %Rrc", g_aSseConvertMmXmm[iFn].pszName, rc);
     8208            return RTEXITCODE_FAILURE;
     8209        }
     8210    }
     8211
     8212    return RTEXITCODE_SUCCESS;
     8213}
     8214#endif
     8215
     8216static void SseConvertMmXmmTest(void)
     8217{
     8218    X86FXSTATE State;
     8219    RT_ZERO(State);
     8220
     8221    for (size_t iFn = 0; iFn < RT_ELEMENTS(g_aSseConvertMmXmm); iFn++)
     8222    {
     8223        if (!SubTestAndCheckIfEnabled(g_aSseConvertMmXmm[iFn].pszName))
     8224            continue;
     8225
     8226        uint32_t const                          cTests  = *g_aSseConvertMmXmm[iFn].pcTests;
     8227        SSE_CONVERT_MM_XMM_TEST_T const * const paTests = g_aSseConvertMmXmm[iFn].paTests;
     8228        PFNIEMAIMPLMXCSRU64U128                 pfn     = g_aSseConvertMmXmm[iFn].pfn;
     8229        uint32_t const                          cVars   = COUNT_VARIATIONS(g_aSseConvertMmXmm[iFn]);
     8230        if (!cTests) RTTestSkipped(g_hTest, "no tests");
     8231        for (uint32_t iVar = 0; iVar < cVars; iVar++)
     8232        {
     8233            for (uint32_t iTest = 0; iTest < cTests / sizeof(*paTests); iTest++)
     8234            {
     8235                RTUINT64U ValOut;
     8236                uint32_t fMxcsr = paTests[iTest].fMxcsrIn;
     8237                pfn(&fMxcsr, &ValOut.u, &paTests[iTest].InVal);
     8238                if (   fMxcsr != paTests[iTest].fMxcsrOut
     8239                    || ValOut.ai32[0] != paTests[iTest].OutVal.ai32[0]
     8240                    || ValOut.ai32[1] != paTests[iTest].OutVal.ai32[1])
     8241                    RTTestFailed(g_hTest, "#%04u%s: mxcsr=%#08x in1=%s'%s\n"
     8242                                          "%s               -> mxcsr=%#08x    %RI32'%RI32\n"
     8243                                          "%s               expected %#08x    %RI32'%RI32%s%s (%s)\n",
     8244                                 iTest, iVar ? "/n" : "", paTests[iTest].fMxcsrIn,
     8245                                 FormatR64(&paTests[iTest].InVal.ar64[0]), FormatR64(&paTests[iTest].InVal.ar64[1]),
     8246                                 iVar ? "  " : "", fMxcsr, ValOut.ai32[0], ValOut.ai32[1],
     8247                                 iVar ? "  " : "", paTests[iTest].fMxcsrOut,
     8248                                 paTests[iTest].OutVal.ai32[0], paTests[iTest].OutVal.ai32[1],
     8249                                 MxcsrDiff(fMxcsr, paTests[iTest].fMxcsrOut),
     8250                                   (   ValOut.ai32[0] != paTests[iTest].OutVal.ai32[0]
     8251                                    || ValOut.ai32[1] != paTests[iTest].OutVal.ai32[1])
     8252                                 ? " - val" : "",
     8253                                 FormatMxcsr(paTests[iTest].fMxcsrIn));
     8254            }
     8255        }
     8256    }
     8257}
     8258
     8259
    80808260
    80818261int main(int argc, char **argv)
    … …  
    84718651            if (rcExit == RTEXITCODE_SUCCESS)
    84728652                rcExit = SseConvertXmmR64I32Generate(pszDataFileFmtConv, cTests);
     8653            if (rcExit == RTEXITCODE_SUCCESS)
     8654                rcExit = SseConvertMmXmmGenerate(pszDataFileFmtConv, cTests);
    84738655            if (rcExit != RTEXITCODE_SUCCESS)
    84748656                return rcExit;
    … …  
    85938775                SseConvertXmmI32R64Test();
    85948776                SseConvertXmmR64I32Test();
     8777                SseConvertMmXmmTest();
    85958778            }
    85968779        }

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

    r96797 r96917  
    493493    X86XMMREG               OutVal;
    494494} SSE_CONVERT_XMM_TEST_T;
     495
     496typedef struct SSE_CONVERT_MM_XMM_TEST_T
     497{
     498    uint32_t                fMxcsrIn;
     499    uint32_t                fMxcsrOut;
     500    RTUINT64U               OutVal;
     501    X86XMMREG               InVal;
     502} SSE_CONVERT_MM_XMM_TEST_T;
    495503
    496504/** @} */
    … …  
    953961TSTIEM_DECLARE_TEST_ARRAY_BIN(SseConvert,   SSE_CONVERT_XMM_TEST_T,         cvtpd2dq_u128        );
    954962
     963TSTIEM_DECLARE_TEST_ARRAY_BIN(SseConvert,   SSE_CONVERT_MM_XMM_TEST_T,      cvtpd2pi_u128        );
     964TSTIEM_DECLARE_TEST_ARRAY_BIN(SseConvert,   SSE_CONVERT_MM_XMM_TEST_T,      cvttpd2pi_u128       );
     965
    955966RT_C_DECLS_END
    956967

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

    r96797 r96917  
    142142IEM_TEST_DATA cvtpd2dq_u128,        "tstIEMAImplDataSseConvert-cvtpd2dq_u128.bin"
    143143IEM_TEST_DATA cvttpd2dq_u128,       "tstIEMAImplDataSseConvert-cvttpd2dq_u128.bin"
     144
     145IEM_TEST_DATA cvtpd2pi_u128,        "tstIEMAImplDataSseConvert-cvtpd2pi_u128.bin"
     146IEM_TEST_DATA cvttpd2pi_u128,       "tstIEMAImplDataSseConvert-cvttpd2pi_u128.bin"

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

    r96797 r96917  
    140140IEM_TEST_DATA cvtpd2dq_u128,        "tstIEMAImplDataSseConvert-cvtpd2dq_u128.bin"
    141141IEM_TEST_DATA cvttpd2dq_u128,       "tstIEMAImplDataSseConvert-cvttpd2dq_u128.bin"
     142
     143IEM_TEST_DATA cvtpd2pi_u128,        "tstIEMAImplDataSseConvert-cvtpd2pi_u128.bin"
     144IEM_TEST_DATA cvttpd2pi_u128,       "tstIEMAImplDataSseConvert-cvttpd2pi_u128.bin"
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