VirtualBox

Changeset 96922 in vbox for trunk


Ignore:
Timestamp:
Sep 28, 2022 7:23:12 PM (2 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
153833
Message:

VMM/testcase/tstIEMAImpl: Implement basic cvtpi2ps/cvtpi2pd 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

    r96917 r96922  
    312312        tstIEMAImplDataSseConvert-cvttpd2dq_u128.bin \
    313313        tstIEMAImplDataSseConvert-cvtpd2pi_u128.bin \
    314         tstIEMAImplDataSseConvert-cvttpd2pi_u128.bin
     314        tstIEMAImplDataSseConvert-cvttpd2pi_u128.bin \
     315        tstIEMAImplDataSseConvert-cvtpi2ps_u128.bin \
     316        tstIEMAImplDataSseConvert-cvtpi2pd_u128.bin
    315317
    316318tstIEMAImpl_TEMPLATE  = VBOXR3TSTEXE

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

    r96917 r96922  
    81038103    };
    81048104
    8105     X86FXSTATE State;
    8106     RT_ZERO(State);
    81078105    uint32_t cMinNormalPairs       = (cTests - 144) / 4;
    81088106    for (size_t iFn = 0; iFn < RT_ELEMENTS(g_aSseConvertMmXmm); iFn++)
    … …  
    82508248                                   (   ValOut.ai32[0] != paTests[iTest].OutVal.ai32[0]
    82518249                                    || ValOut.ai32[1] != paTests[iTest].OutVal.ai32[1])
     8250                                 ? " - val" : "",
     8251                                 FormatMxcsr(paTests[iTest].fMxcsrIn));
     8252            }
     8253        }
     8254    }
     8255}
     8256
     8257
     8258/*
     8259 * Convert SSE operations converting signed double-word values to double precision floating-point values (probably only cvtpi2pd).
     8260 */
     8261TYPEDEF_SUBTEST_TYPE(SSE_CONVERT_XMM_R64_MM_T, SSE_CONVERT_XMM_MM_TEST_T, PFNIEMAIMPLMXCSRU128U64);
     8262
     8263static const SSE_CONVERT_XMM_R64_MM_T g_aSseConvertXmmR64Mm[] =
     8264{
     8265    ENTRY_BIN(cvtpi2pd_u128)
     8266};
     8267
     8268#ifdef TSTIEMAIMPL_WITH_GENERATOR
     8269static RTEXITCODE SseConvertXmmR64MmGenerate(const char *pszDataFileFmt, uint32_t cTests)
     8270{
     8271    cTests = RT_MAX(192, cTests); /* there are 144 standard input variations */
     8272
     8273    static struct { int32_t aVal[2]; } const s_aSpecials[] =
     8274    {
     8275        { { INT32_MIN, INT32_MIN } },
     8276        { { INT32_MAX, INT32_MAX } }
     8277          /** @todo More specials. */
     8278    };
     8279
     8280    for (size_t iFn = 0; iFn < RT_ELEMENTS(g_aSseConvertXmmR64Mm); iFn++)
     8281    {
     8282        PFNIEMAIMPLMXCSRU128U64 const pfn = g_aSseConvertXmmR64Mm[iFn].pfnNative ? g_aSseConvertXmmR64Mm[iFn].pfnNative : g_aSseConvertXmmR64Mm[iFn].pfn;
     8283
     8284        PRTSTREAM pStrmOut = NULL;
     8285        int rc = RTStrmOpenF("wb", &pStrmOut, pszDataFileFmt, g_aSseConvertXmmR64Mm[iFn].pszName);
     8286        if (RT_FAILURE(rc))
     8287        {
     8288            RTMsgError("Failed to open data file for %s for writing: %Rrc", g_aSseConvertXmmR64Mm[iFn].pszName, rc);
     8289            return RTEXITCODE_FAILURE;
     8290        }
     8291
     8292        for (uint32_t iTest = 0; iTest < cTests + RT_ELEMENTS(s_aSpecials); iTest += 1)
     8293        {
     8294            SSE_CONVERT_XMM_MM_TEST_T TestData; RT_ZERO(TestData);
     8295
     8296            TestData.InVal.ai32[0] = iTest < cTests ? RandI32Src2(iTest) : s_aSpecials[iTest - cTests].aVal[0];
     8297            TestData.InVal.ai32[1] = iTest < cTests ? RandI32Src2(iTest) : s_aSpecials[iTest - cTests].aVal[1];
     8298
     8299            uint32_t const fMxcsr = RandMxcsr() & X86_MXCSR_XCPT_FLAGS;
     8300            for (uint16_t iRounding = 0; iRounding < 4; iRounding++)
     8301                for (uint8_t iDaz = 0; iDaz < 2; iDaz++)
     8302                    for (uint8_t iFz = 0; iFz < 2; iFz++)
     8303                    {
     8304                        uint32_t fMxcsrIn = (fMxcsr & ~X86_MXCSR_RC_MASK)
     8305                                          | (iRounding  << X86_MXCSR_RC_SHIFT)
     8306                                          | (iDaz ? X86_MXCSR_DAZ : 0)
     8307                                          | (iFz  ? X86_MXCSR_FZ  : 0)
     8308                                          | X86_MXCSR_XCPT_MASK;
     8309                        uint32_t fMxcsrM  = fMxcsrIn;
     8310                        pfn(&fMxcsrM, &TestData.OutVal, TestData.InVal.u);
     8311                        TestData.fMxcsrIn   = fMxcsrIn;
     8312                        TestData.fMxcsrOut  = fMxcsrM;
     8313                        RTStrmWrite(pStrmOut, &TestData, sizeof(TestData));
     8314
     8315                        fMxcsrIn &= ~X86_MXCSR_XCPT_MASK;
     8316                        uint32_t fMxcsrU  = fMxcsrIn;
     8317                        pfn(&fMxcsrU, &TestData.OutVal, TestData.InVal.u);
     8318                        TestData.fMxcsrIn   = fMxcsrIn;
     8319                        TestData.fMxcsrOut  = fMxcsrU;
     8320                        RTStrmWrite(pStrmOut, &TestData, sizeof(TestData));
     8321
     8322                        uint16_t fXcpt = (fMxcsrM | fMxcsrU) & X86_MXCSR_XCPT_FLAGS;
     8323                        if (fXcpt)
     8324                        {
     8325                            fMxcsrIn = (fMxcsrIn & ~X86_MXCSR_XCPT_MASK) | fXcpt;
     8326                            uint32_t fMxcsr1  = fMxcsrIn;
     8327                            pfn(&fMxcsr1, &TestData.OutVal, TestData.InVal.u);
     8328                            TestData.fMxcsrIn   = fMxcsrIn;
     8329                            TestData.fMxcsrOut  = fMxcsr1;
     8330                            RTStrmWrite(pStrmOut, &TestData, sizeof(TestData));
     8331
     8332                            if (((fMxcsr1 & X86_MXCSR_XCPT_FLAGS) & fXcpt) != (fMxcsr1 & X86_MXCSR_XCPT_FLAGS))
     8333                            {
     8334                                fXcpt |= fMxcsr1 & X86_MXCSR_XCPT_FLAGS;
     8335                                fMxcsrIn = (fMxcsrIn & ~X86_MXCSR_XCPT_MASK) | (fXcpt << X86_MXCSR_XCPT_MASK_SHIFT);
     8336                                uint32_t fMxcsr2  = fMxcsrIn;
     8337                                pfn(&fMxcsr2, &TestData.OutVal, TestData.InVal.u);
     8338                                TestData.fMxcsrIn   = fMxcsrIn;
     8339                                TestData.fMxcsrOut  = fMxcsr2;
     8340                                RTStrmWrite(pStrmOut, &TestData, sizeof(TestData));
     8341                            }
     8342                            if (!RT_IS_POWER_OF_TWO(fXcpt))
     8343                                for (uint16_t fUnmasked = 1; fUnmasked <= X86_MXCSR_PE; fUnmasked <<= 1)
     8344                                    if (fUnmasked & fXcpt)
     8345                                    {
     8346                                        fMxcsrIn = (fMxcsrIn & ~X86_MXCSR_XCPT_MASK) | ((fXcpt & ~fUnmasked) << X86_MXCSR_XCPT_MASK_SHIFT);
     8347                                        uint32_t fMxcsr3  = fMxcsrIn;
     8348                                        pfn(&fMxcsr3, &TestData.OutVal, TestData.InVal.u);
     8349                                        TestData.fMxcsrIn   = fMxcsrIn;
     8350                                        TestData.fMxcsrOut  = fMxcsr3;
     8351                                        RTStrmWrite(pStrmOut, &TestData, sizeof(TestData));
     8352                                    }
     8353                        }
     8354                    }
     8355        }
     8356        rc = RTStrmClose(pStrmOut);
     8357        if (RT_FAILURE(rc))
     8358        {
     8359            RTMsgError("Failed to close data file for %s: %Rrc", g_aSseConvertXmmR64Mm[iFn].pszName, rc);
     8360            return RTEXITCODE_FAILURE;
     8361        }
     8362    }
     8363
     8364    return RTEXITCODE_SUCCESS;
     8365}
     8366#endif
     8367
     8368static void SseConvertXmmR64MmTest(void)
     8369{
     8370    for (size_t iFn = 0; iFn < RT_ELEMENTS(g_aSseConvertXmmR64Mm); iFn++)
     8371    {
     8372        if (!SubTestAndCheckIfEnabled(g_aSseConvertXmmR64Mm[iFn].pszName))
     8373            continue;
     8374
     8375        uint32_t const                          cTests  = *g_aSseConvertXmmR64Mm[iFn].pcTests;
     8376        SSE_CONVERT_XMM_MM_TEST_T const * const paTests = g_aSseConvertXmmR64Mm[iFn].paTests;
     8377        PFNIEMAIMPLMXCSRU128U64                 pfn     = g_aSseConvertXmmR64Mm[iFn].pfn;
     8378        uint32_t const                          cVars   = COUNT_VARIATIONS(g_aSseConvertXmmR64Mm[iFn]);
     8379        if (!cTests) RTTestSkipped(g_hTest, "no tests");
     8380        for (uint32_t iVar = 0; iVar < cVars; iVar++)
     8381        {
     8382            for (uint32_t iTest = 0; iTest < cTests / sizeof(*paTests); iTest++)
     8383            {
     8384                X86XMMREG ValOut;
     8385                uint32_t fMxcsr = paTests[iTest].fMxcsrIn;
     8386                pfn(&fMxcsr, &ValOut, paTests[iTest].InVal.u);
     8387                if (   fMxcsr != paTests[iTest].fMxcsrOut
     8388                    || !RTFLOAT64U_ARE_IDENTICAL(&ValOut.ar64[0], &paTests[iTest].OutVal.ar64[0])
     8389                    || !RTFLOAT64U_ARE_IDENTICAL(&ValOut.ar64[1], &paTests[iTest].OutVal.ar64[1]))
     8390                    RTTestFailed(g_hTest, "#%04u%s: mxcsr=%#08x in1=%RI32'%RI32\n"
     8391                                          "%s               -> mxcsr=%#08x    %s'%s\n"
     8392                                          "%s               expected %#08x    %s'%s%s%s (%s)\n",
     8393                                 iTest, iVar ? "/n" : "", paTests[iTest].fMxcsrIn,
     8394                                 paTests[iTest].InVal.ai32[0], paTests[iTest].InVal.ai32[1],
     8395                                 iVar ? "  " : "", fMxcsr,
     8396                                 FormatR64(&ValOut.ar64[0]), FormatR64(&ValOut.ar64[1]),
     8397                                 iVar ? "  " : "", paTests[iTest].fMxcsrOut,
     8398                                 FormatR64(&paTests[iTest].OutVal.ar64[0]), FormatR64(&paTests[iTest].OutVal.ar64[1]),
     8399                                 MxcsrDiff(fMxcsr, paTests[iTest].fMxcsrOut),
     8400                                   (   !RTFLOAT64U_ARE_IDENTICAL(&ValOut.ar64[0], &paTests[iTest].OutVal.ar64[0])
     8401                                    || !RTFLOAT64U_ARE_IDENTICAL(&ValOut.ar64[1], &paTests[iTest].OutVal.ar64[1]))
     8402                                 ? " - val" : "",
     8403                                 FormatMxcsr(paTests[iTest].fMxcsrIn));
     8404            }
     8405        }
     8406    }
     8407}
     8408
     8409
     8410/*
     8411 * Convert SSE operations converting signed double-word values to double precision floating-point values (probably only cvtpi2pd).
     8412 */
     8413TYPEDEF_SUBTEST_TYPE(SSE_CONVERT_XMM_R32_MM_T, SSE_CONVERT_XMM_MM_TEST_T, PFNIEMAIMPLMXCSRU128U64);
     8414
     8415static const SSE_CONVERT_XMM_R32_MM_T g_aSseConvertXmmR32Mm[] =
     8416{
     8417    ENTRY_BIN(cvtpi2ps_u128)
     8418};
     8419
     8420#ifdef TSTIEMAIMPL_WITH_GENERATOR
     8421static RTEXITCODE SseConvertXmmR32MmGenerate(const char *pszDataFileFmt, uint32_t cTests)
     8422{
     8423    cTests = RT_MAX(192, cTests); /* there are 144 standard input variations */
     8424
     8425    static struct { int32_t aVal[2]; } const s_aSpecials[] =
     8426    {
     8427        { { INT32_MIN, INT32_MIN } },
     8428        { { INT32_MAX, INT32_MAX } }
     8429          /** @todo More specials. */
     8430    };
     8431
     8432    for (size_t iFn = 0; iFn < RT_ELEMENTS(g_aSseConvertXmmR32Mm); iFn++)
     8433    {
     8434        PFNIEMAIMPLMXCSRU128U64 const pfn = g_aSseConvertXmmR32Mm[iFn].pfnNative ? g_aSseConvertXmmR32Mm[iFn].pfnNative : g_aSseConvertXmmR32Mm[iFn].pfn;
     8435
     8436        PRTSTREAM pStrmOut = NULL;
     8437        int rc = RTStrmOpenF("wb", &pStrmOut, pszDataFileFmt, g_aSseConvertXmmR32Mm[iFn].pszName);
     8438        if (RT_FAILURE(rc))
     8439        {
     8440            RTMsgError("Failed to open data file for %s for writing: %Rrc", g_aSseConvertXmmR32Mm[iFn].pszName, rc);
     8441            return RTEXITCODE_FAILURE;
     8442        }
     8443
     8444        for (uint32_t iTest = 0; iTest < cTests + RT_ELEMENTS(s_aSpecials); iTest += 1)
     8445        {
     8446            SSE_CONVERT_XMM_MM_TEST_T TestData; RT_ZERO(TestData);
     8447
     8448            TestData.InVal.ai32[0] = iTest < cTests ? RandI32Src2(iTest) : s_aSpecials[iTest - cTests].aVal[0];
     8449            TestData.InVal.ai32[1] = iTest < cTests ? RandI32Src2(iTest) : s_aSpecials[iTest - cTests].aVal[1];
     8450
     8451            uint32_t const fMxcsr = RandMxcsr() & X86_MXCSR_XCPT_FLAGS;
     8452            for (uint16_t iRounding = 0; iRounding < 4; iRounding++)
     8453                for (uint8_t iDaz = 0; iDaz < 2; iDaz++)
     8454                    for (uint8_t iFz = 0; iFz < 2; iFz++)
     8455                    {
     8456                        uint32_t fMxcsrIn = (fMxcsr & ~X86_MXCSR_RC_MASK)
     8457                                          | (iRounding  << X86_MXCSR_RC_SHIFT)
     8458                                          | (iDaz ? X86_MXCSR_DAZ : 0)
     8459                                          | (iFz  ? X86_MXCSR_FZ  : 0)
     8460                                          | X86_MXCSR_XCPT_MASK;
     8461                        uint32_t fMxcsrM  = fMxcsrIn;
     8462                        pfn(&fMxcsrM, &TestData.OutVal, TestData.InVal.u);
     8463                        TestData.fMxcsrIn   = fMxcsrIn;
     8464                        TestData.fMxcsrOut  = fMxcsrM;
     8465                        RTStrmWrite(pStrmOut, &TestData, sizeof(TestData));
     8466
     8467                        fMxcsrIn &= ~X86_MXCSR_XCPT_MASK;
     8468                        uint32_t fMxcsrU  = fMxcsrIn;
     8469                        pfn(&fMxcsrU, &TestData.OutVal, TestData.InVal.u);
     8470                        TestData.fMxcsrIn   = fMxcsrIn;
     8471                        TestData.fMxcsrOut  = fMxcsrU;
     8472                        RTStrmWrite(pStrmOut, &TestData, sizeof(TestData));
     8473
     8474                        uint16_t fXcpt = (fMxcsrM | fMxcsrU) & X86_MXCSR_XCPT_FLAGS;
     8475                        if (fXcpt)
     8476                        {
     8477                            fMxcsrIn = (fMxcsrIn & ~X86_MXCSR_XCPT_MASK) | fXcpt;
     8478                            uint32_t fMxcsr1  = fMxcsrIn;
     8479                            pfn(&fMxcsr1, &TestData.OutVal, TestData.InVal.u);
     8480                            TestData.fMxcsrIn   = fMxcsrIn;
     8481                            TestData.fMxcsrOut  = fMxcsr1;
     8482                            RTStrmWrite(pStrmOut, &TestData, sizeof(TestData));
     8483
     8484                            if (((fMxcsr1 & X86_MXCSR_XCPT_FLAGS) & fXcpt) != (fMxcsr1 & X86_MXCSR_XCPT_FLAGS))
     8485                            {
     8486                                fXcpt |= fMxcsr1 & X86_MXCSR_XCPT_FLAGS;
     8487                                fMxcsrIn = (fMxcsrIn & ~X86_MXCSR_XCPT_MASK) | (fXcpt << X86_MXCSR_XCPT_MASK_SHIFT);
     8488                                uint32_t fMxcsr2  = fMxcsrIn;
     8489                                pfn(&fMxcsr2, &TestData.OutVal, TestData.InVal.u);
     8490                                TestData.fMxcsrIn   = fMxcsrIn;
     8491                                TestData.fMxcsrOut  = fMxcsr2;
     8492                                RTStrmWrite(pStrmOut, &TestData, sizeof(TestData));
     8493                            }
     8494                            if (!RT_IS_POWER_OF_TWO(fXcpt))
     8495                                for (uint16_t fUnmasked = 1; fUnmasked <= X86_MXCSR_PE; fUnmasked <<= 1)
     8496                                    if (fUnmasked & fXcpt)
     8497                                    {
     8498                                        fMxcsrIn = (fMxcsrIn & ~X86_MXCSR_XCPT_MASK) | ((fXcpt & ~fUnmasked) << X86_MXCSR_XCPT_MASK_SHIFT);
     8499                                        uint32_t fMxcsr3  = fMxcsrIn;
     8500                                        pfn(&fMxcsr3, &TestData.OutVal, TestData.InVal.u);
     8501                                        TestData.fMxcsrIn   = fMxcsrIn;
     8502                                        TestData.fMxcsrOut  = fMxcsr3;
     8503                                        RTStrmWrite(pStrmOut, &TestData, sizeof(TestData));
     8504                                    }
     8505                        }
     8506                    }
     8507        }
     8508        rc = RTStrmClose(pStrmOut);
     8509        if (RT_FAILURE(rc))
     8510        {
     8511            RTMsgError("Failed to close data file for %s: %Rrc", g_aSseConvertXmmR32Mm[iFn].pszName, rc);
     8512            return RTEXITCODE_FAILURE;
     8513        }
     8514    }
     8515
     8516    return RTEXITCODE_SUCCESS;
     8517}
     8518#endif
     8519
     8520static void SseConvertXmmR32MmTest(void)
     8521{
     8522    for (size_t iFn = 0; iFn < RT_ELEMENTS(g_aSseConvertXmmR32Mm); iFn++)
     8523    {
     8524        if (!SubTestAndCheckIfEnabled(g_aSseConvertXmmR32Mm[iFn].pszName))
     8525            continue;
     8526
     8527        uint32_t const                          cTests  = *g_aSseConvertXmmR32Mm[iFn].pcTests;
     8528        SSE_CONVERT_XMM_MM_TEST_T const * const paTests = g_aSseConvertXmmR32Mm[iFn].paTests;
     8529        PFNIEMAIMPLMXCSRU128U64                 pfn     = g_aSseConvertXmmR32Mm[iFn].pfn;
     8530        uint32_t const                          cVars   = COUNT_VARIATIONS(g_aSseConvertXmmR32Mm[iFn]);
     8531        if (!cTests) RTTestSkipped(g_hTest, "no tests");
     8532        for (uint32_t iVar = 0; iVar < cVars; iVar++)
     8533        {
     8534            for (uint32_t iTest = 0; iTest < cTests / sizeof(*paTests); iTest++)
     8535            {
     8536                X86XMMREG ValOut;
     8537                uint32_t fMxcsr = paTests[iTest].fMxcsrIn;
     8538                pfn(&fMxcsr, &ValOut, paTests[iTest].InVal.u);
     8539                if (   fMxcsr != paTests[iTest].fMxcsrOut
     8540                    || !RTFLOAT32U_ARE_IDENTICAL(&ValOut.ar32[0], &paTests[iTest].OutVal.ar32[0])
     8541                    || !RTFLOAT32U_ARE_IDENTICAL(&ValOut.ar32[1], &paTests[iTest].OutVal.ar32[1]))
     8542                    RTTestFailed(g_hTest, "#%04u%s: mxcsr=%#08x in1=%RI32'%RI32\n"
     8543                                          "%s               -> mxcsr=%#08x    %s'%s\n"
     8544                                          "%s               expected %#08x    %s'%s%s%s (%s)\n",
     8545                                 iTest, iVar ? "/n" : "", paTests[iTest].fMxcsrIn,
     8546                                 paTests[iTest].InVal.ai32[0], paTests[iTest].InVal.ai32[1],
     8547                                 iVar ? "  " : "", fMxcsr,
     8548                                 FormatR32(&ValOut.ar32[0]), FormatR32(&ValOut.ar32[1]),
     8549                                 iVar ? "  " : "", paTests[iTest].fMxcsrOut,
     8550                                 FormatR32(&paTests[iTest].OutVal.ar32[0]), FormatR32(&paTests[iTest].OutVal.ar32[1]),
     8551                                 MxcsrDiff(fMxcsr, paTests[iTest].fMxcsrOut),
     8552                                   (   !RTFLOAT32U_ARE_IDENTICAL(&ValOut.ar32[0], &paTests[iTest].OutVal.ar32[0])
     8553                                    || !RTFLOAT32U_ARE_IDENTICAL(&ValOut.ar32[1], &paTests[iTest].OutVal.ar32[1]))
    82528554                                 ? " - val" : "",
    82538555                                 FormatMxcsr(paTests[iTest].fMxcsrIn));
    … …  
    86538955            if (rcExit == RTEXITCODE_SUCCESS)
    86548956                rcExit = SseConvertMmXmmGenerate(pszDataFileFmtConv, cTests);
     8957            if (rcExit == RTEXITCODE_SUCCESS)
     8958                rcExit = SseConvertXmmR32MmGenerate(pszDataFileFmtConv, cTests);
     8959            if (rcExit == RTEXITCODE_SUCCESS)
     8960                rcExit = SseConvertXmmR64MmGenerate(pszDataFileFmtConv, cTests);
    86558961            if (rcExit != RTEXITCODE_SUCCESS)
    86568962                return rcExit;
    … …  
    87769082                SseConvertXmmR64I32Test();
    87779083                SseConvertMmXmmTest();
     9084                SseConvertXmmR32MmTest();
     9085                SseConvertXmmR64MmTest();
    87789086            }
    87799087        }

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

    r96917 r96922  
    501501    X86XMMREG               InVal;
    502502} SSE_CONVERT_MM_XMM_TEST_T;
     503
     504typedef struct SSE_CONVERT_XMM_MM_TEST_T
     505{
     506    uint32_t                fMxcsrIn;
     507    uint32_t                fMxcsrOut;
     508    RTUINT64U               InVal;
     509    X86XMMREG               OutVal;
     510} SSE_CONVERT_XMM_MM_TEST_T;
    503511
    504512/** @} */
    … …  
    964972TSTIEM_DECLARE_TEST_ARRAY_BIN(SseConvert,   SSE_CONVERT_MM_XMM_TEST_T,      cvttpd2pi_u128       );
    965973
     974TSTIEM_DECLARE_TEST_ARRAY_BIN(SseConvert,   SSE_CONVERT_XMM_MM_TEST_T,      cvtpi2ps_u128        );
     975TSTIEM_DECLARE_TEST_ARRAY_BIN(SseConvert,   SSE_CONVERT_XMM_MM_TEST_T,      cvtpi2pd_u128        );
     976
    966977RT_C_DECLS_END
    967978

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

    r96917 r96922  
    145145IEM_TEST_DATA cvtpd2pi_u128,        "tstIEMAImplDataSseConvert-cvtpd2pi_u128.bin"
    146146IEM_TEST_DATA cvttpd2pi_u128,       "tstIEMAImplDataSseConvert-cvttpd2pi_u128.bin"
     147
     148IEM_TEST_DATA cvtpi2ps_u128,        "tstIEMAImplDataSseConvert-cvtpi2ps_u128.bin"
     149IEM_TEST_DATA cvtpi2pd_u128,        "tstIEMAImplDataSseConvert-cvtpi2pd_u128.bin"

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

    r96917 r96922  
    143143IEM_TEST_DATA cvtpd2pi_u128,        "tstIEMAImplDataSseConvert-cvtpd2pi_u128.bin"
    144144IEM_TEST_DATA cvttpd2pi_u128,       "tstIEMAImplDataSseConvert-cvttpd2pi_u128.bin"
     145
     146IEM_TEST_DATA cvtpi2ps_u128,        "tstIEMAImplDataSseConvert-cvtpi2ps_u128.bin"
     147IEM_TEST_DATA cvtpi2pd_u128,        "tstIEMAImplDataSseConvert-cvtpi2pd_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