VirtualBox

Changeset 96732 in vbox


Ignore:
Timestamp:
Sep 14, 2022 9:21:31 AM (3 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
153619
Message:

VMM/testcase/tstIEMAImpl: Implement basic cvttss2si/cvtss2si testcases, ​bugref:9898

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

Legend:

Unmodified
Added
Removed

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

    r96727 r96732  
    284284        tstIEMAImplDataSseBinary-cvtsd2si_i32_r64.bin \
    285285        tstIEMAImplDataSseBinary-cvttsd2si_i64_r64.bin \
    286         tstIEMAImplDataSseBinary-cvtsd2si_i64_r64.bin
     286        tstIEMAImplDataSseBinary-cvtsd2si_i64_r64.bin \
     287        tstIEMAImplDataSseBinary-cvttss2si_i32_r32.bin \
     288        tstIEMAImplDataSseBinary-cvtss2si_i32_r32.bin \
     289        tstIEMAImplDataSseBinary-cvttss2si_i64_r32.bin \
     290        tstIEMAImplDataSseBinary-cvtss2si_i64_r32.bin
    287291
    288292tstIEMAImpl_TEMPLATE  = VBOXR3TSTEXE

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

    r96727 r96732  
    55815581
    55825582
     5583/*
     5584 * SSE operations converting single single-precision floating point values to signed double-word integers (cvttss2si and friends).
     5585 */
     5586TYPEDEF_SUBTEST_TYPE(SSE_BINARY_I32_R32_T, SSE_BINARY_I32_R32_TEST_T, PFNIEMAIMPLSSEF2I32U32);
     5587
     5588static const SSE_BINARY_I32_R32_T g_aSseBinaryI32R32[] =
     5589{
     5590    ENTRY_BIN(cvttss2si_i32_r32),
     5591    ENTRY_BIN(cvtss2si_i32_r32),
     5592};
     5593
     5594#ifdef TSTIEMAIMPL_WITH_GENERATOR
     5595static RTEXITCODE SseBinaryI32R32Generate(const char *pszDataFileFmt, uint32_t cTests)
     5596{
     5597    cTests = RT_MAX(192, cTests); /* there are 144 standard input variations */
     5598
     5599    static struct { RTFLOAT32U Val; } const s_aSpecials[] =
     5600    {
     5601        { RTFLOAT32U_INIT_C(0, 8388607, RTFLOAT32U_EXP_MAX - 1) },
     5602          /** @todo More specials. */
     5603    };
     5604
     5605    X86FXSTATE State;
     5606    RT_ZERO(State);
     5607    uint32_t cMinNormalPairs       = (cTests - 144) / 4;
     5608    for (size_t iFn = 0; iFn < RT_ELEMENTS(g_aSseBinaryI32R32); iFn++)
     5609    {
     5610        PFNIEMAIMPLSSEF2I32U32 const pfn = g_aSseBinaryI32R32[iFn].pfnNative ? g_aSseBinaryI32R32[iFn].pfnNative : g_aSseBinaryI32R32[iFn].pfn;
     5611
     5612        PRTSTREAM pStrmOut = NULL;
     5613        int rc = RTStrmOpenF("wb", &pStrmOut, pszDataFileFmt, g_aSseBinaryI32R32[iFn].pszName);
     5614        if (RT_FAILURE(rc))
     5615        {
     5616            RTMsgError("Failed to open data file for %s for writing: %Rrc", g_aSseBinaryI32R32[iFn].pszName, rc);
     5617            return RTEXITCODE_FAILURE;
     5618        }
     5619
     5620        uint32_t cNormalInputPairs  = 0;
     5621        for (uint32_t iTest = 0; iTest < cTests + RT_ELEMENTS(s_aSpecials); iTest += 1)
     5622        {
     5623            SSE_BINARY_I32_R32_TEST_T TestData; RT_ZERO(TestData);
     5624
     5625            TestData.r32ValIn = iTest < cTests ? RandR32Src(iTest) : s_aSpecials[iTest - cTests].Val;
     5626
     5627            if (RTFLOAT32U_IS_NORMAL(&TestData.r32ValIn))
     5628                cNormalInputPairs++;
     5629            else if (cNormalInputPairs < cMinNormalPairs && iTest + cMinNormalPairs >= cTests && iTest < cTests)
     5630            {
     5631                iTest -= 1;
     5632                continue;
     5633            }
     5634
     5635            uint32_t const fMxcsr = RandMxcsr() & X86_MXCSR_XCPT_FLAGS;
     5636            for (uint16_t iRounding = 0; iRounding < 4; iRounding++)
     5637                for (uint8_t iDaz = 0; iDaz < 2; iDaz++)
     5638                    for (uint8_t iFz = 0; iFz < 2; iFz++)
     5639                    {
     5640                        State.MXCSR = (fMxcsr & ~X86_MXCSR_RC_MASK)
     5641                                    | (iRounding  << X86_MXCSR_RC_SHIFT)
     5642                                    | (iDaz ? X86_MXCSR_DAZ : 0)
     5643                                    | (iFz  ? X86_MXCSR_FZ  : 0)
     5644                                    | X86_MXCSR_XCPT_MASK;
     5645                        uint32_t fMxcsrM; int32_t i32OutM;
     5646                        pfn(&State, &fMxcsrM, &i32OutM, &TestData.r32ValIn.u);
     5647                        TestData.fMxcsrIn  = State.MXCSR;
     5648                        TestData.fMxcsrOut = fMxcsrM;
     5649                        TestData.i32ValOut = i32OutM;
     5650                        RTStrmWrite(pStrmOut, &TestData, sizeof(TestData));
     5651
     5652                        State.MXCSR = State.MXCSR & ~X86_MXCSR_XCPT_MASK;
     5653                        uint32_t fMxcsrU; int32_t i32OutU;
     5654                        pfn(&State, &fMxcsrU, &i32OutU, &TestData.r32ValIn.u);
     5655                        TestData.fMxcsrIn  = State.MXCSR;
     5656                        TestData.fMxcsrOut = fMxcsrU;
     5657                        TestData.i32ValOut = i32OutU;
     5658                        RTStrmWrite(pStrmOut, &TestData, sizeof(TestData));
     5659
     5660                        uint16_t fXcpt = (fMxcsrM | fMxcsrU) & X86_MXCSR_XCPT_FLAGS;
     5661                        if (fXcpt)
     5662                        {
     5663                            State.MXCSR = (State.MXCSR & ~X86_MXCSR_XCPT_MASK) | fXcpt;
     5664                            uint32_t fMxcsr1; int32_t i32Out1;
     5665                            pfn(&State, &fMxcsr1, &i32Out1, &TestData.r32ValIn.u);
     5666                            TestData.fMxcsrIn  = State.MXCSR;
     5667                            TestData.fMxcsrOut = fMxcsr1;
     5668                            TestData.i32ValOut = i32Out1;
     5669                            RTStrmWrite(pStrmOut, &TestData, sizeof(TestData));
     5670
     5671                            if (((fMxcsr1 & X86_MXCSR_XCPT_FLAGS) & fXcpt) != (fMxcsr1 & X86_MXCSR_XCPT_FLAGS))
     5672                            {
     5673                                fXcpt |= fMxcsr1 & X86_MXCSR_XCPT_FLAGS;
     5674                                State.MXCSR = (State.MXCSR & ~X86_MXCSR_XCPT_MASK) | (fXcpt << X86_MXCSR_XCPT_MASK_SHIFT);
     5675                                uint32_t fMxcsr2; int32_t i32Out2;
     5676                                pfn(&State, &fMxcsr2, &i32Out2, &TestData.r32ValIn.u);
     5677                                TestData.fMxcsrIn  = State.MXCSR;
     5678                                TestData.fMxcsrOut = fMxcsr2;
     5679                                TestData.i32ValOut = i32Out2;
     5680                                RTStrmWrite(pStrmOut, &TestData, sizeof(TestData));
     5681                            }
     5682                            if (!RT_IS_POWER_OF_TWO(fXcpt))
     5683                                for (uint16_t fUnmasked = 1; fUnmasked <= X86_MXCSR_PE; fUnmasked <<= 1)
     5684                                    if (fUnmasked & fXcpt)
     5685                                    {
     5686                                        State.MXCSR = (State.MXCSR & ~X86_MXCSR_XCPT_MASK) | ((fXcpt & ~fUnmasked) << X86_MXCSR_XCPT_MASK_SHIFT);
     5687                                        uint32_t fMxcsr3; int32_t i32Out3;
     5688                                        pfn(&State, &fMxcsr3, &i32Out3, &TestData.r32ValIn.u);
     5689                                        TestData.fMxcsrIn  = State.MXCSR;
     5690                                        TestData.fMxcsrOut = fMxcsr3;
     5691                                        TestData.i32ValOut = i32Out3;
     5692                                        RTStrmWrite(pStrmOut, &TestData, sizeof(TestData));
     5693                                    }
     5694                        }
     5695                    }
     5696        }
     5697        rc = RTStrmClose(pStrmOut);
     5698        if (RT_FAILURE(rc))
     5699        {
     5700            RTMsgError("Failed to close data file for %s: %Rrc", g_aSseBinaryI32R32[iFn].pszName, rc);
     5701            return RTEXITCODE_FAILURE;
     5702        }
     5703    }
     5704
     5705    return RTEXITCODE_SUCCESS;
     5706}
     5707#endif
     5708
     5709
     5710static void SseBinaryI32R32Test(void)
     5711{
     5712    X86FXSTATE State;
     5713    RT_ZERO(State);
     5714    for (size_t iFn = 0; iFn < RT_ELEMENTS(g_aSseBinaryI32R32); iFn++)
     5715    {
     5716        if (!SubTestAndCheckIfEnabled(g_aSseBinaryI32R32[iFn].pszName))
     5717            continue;
     5718
     5719        uint32_t const                           cTests  = *g_aSseBinaryI32R32[iFn].pcTests;
     5720        SSE_BINARY_I32_R32_TEST_T const * const  paTests = g_aSseBinaryI32R32[iFn].paTests;
     5721        PFNIEMAIMPLSSEF2I32U32                   pfn     = g_aSseBinaryI32R32[iFn].pfn;
     5722        uint32_t const                           cVars   = COUNT_VARIATIONS(g_aSseBinaryI32R32[iFn]);
     5723        if (!cTests) RTTestSkipped(g_hTest, "no tests");
     5724        for (uint32_t iVar = 0; iVar < cVars; iVar++)
     5725        {
     5726            for (uint32_t iTest = 0; iTest < cTests / sizeof(SSE_BINARY_I32_R32_TEST_T); iTest++)
     5727            {
     5728                uint32_t fMxcsr = 0;
     5729                int32_t i32Dst = 0;
     5730
     5731                State.MXCSR = paTests[iTest].fMxcsrIn;
     5732                pfn(&State, &fMxcsr, &i32Dst, &paTests[iTest].r32ValIn.u);
     5733                if (   fMxcsr != paTests[iTest].fMxcsrOut
     5734                    || i32Dst != paTests[iTest].i32ValOut)
     5735                    RTTestFailed(g_hTest, "#%04u%s: mxcsr=%#08x in1=%s\n"
     5736                                          "%s               -> mxcsr=%#08x    %RI32\n"
     5737                                          "%s               expected %#08x    %RI32%s%s (%s)\n",
     5738                                 iTest, iVar ? "/n" : "", paTests[iTest].fMxcsrIn,
     5739                                 FormatR32(&paTests[iTest].r32ValIn),
     5740                                 iVar ? "  " : "", fMxcsr, i32Dst,
     5741                                 iVar ? "  " : "", paTests[iTest].fMxcsrOut, paTests[iTest].i32ValOut,
     5742                                 MxcsrDiff(fMxcsr, paTests[iTest].fMxcsrOut),
     5743                                   i32Dst != paTests[iTest].i32ValOut
     5744                                 ? " - val" : "",
     5745                                 FormatMxcsr(paTests[iTest].fMxcsrIn) );
     5746            }
     5747        }
     5748    }
     5749}
     5750
     5751
     5752/*
     5753 * SSE operations converting single single-precision floating point values to signed quad-word integers (cvttss2si and friends).
     5754 */
     5755TYPEDEF_SUBTEST_TYPE(SSE_BINARY_I64_R32_T, SSE_BINARY_I64_R32_TEST_T, PFNIEMAIMPLSSEF2I64U32);
     5756
     5757static const SSE_BINARY_I64_R32_T g_aSseBinaryI64R32[] =
     5758{
     5759    ENTRY_BIN(cvttss2si_i64_r32),
     5760    ENTRY_BIN(cvtss2si_i64_r32),
     5761};
     5762
     5763#ifdef TSTIEMAIMPL_WITH_GENERATOR
     5764static RTEXITCODE SseBinaryI64R32Generate(const char *pszDataFileFmt, uint32_t cTests)
     5765{
     5766    cTests = RT_MAX(192, cTests); /* there are 144 standard input variations */
     5767
     5768    static struct { RTFLOAT32U Val; } const s_aSpecials[] =
     5769    {
     5770        { RTFLOAT32U_INIT_C(0, 8388607, RTFLOAT32U_EXP_MAX - 1) },
     5771          /** @todo More specials. */
     5772    };
     5773
     5774    X86FXSTATE State;
     5775    RT_ZERO(State);
     5776    uint32_t cMinNormalPairs       = (cTests - 144) / 4;
     5777    for (size_t iFn = 0; iFn < RT_ELEMENTS(g_aSseBinaryI64R32); iFn++)
     5778    {
     5779        PFNIEMAIMPLSSEF2I64U32 const pfn = g_aSseBinaryI64R32[iFn].pfnNative ? g_aSseBinaryI64R32[iFn].pfnNative : g_aSseBinaryI64R32[iFn].pfn;
     5780
     5781        PRTSTREAM pStrmOut = NULL;
     5782        int rc = RTStrmOpenF("wb", &pStrmOut, pszDataFileFmt, g_aSseBinaryI64R32[iFn].pszName);
     5783        if (RT_FAILURE(rc))
     5784        {
     5785            RTMsgError("Failed to open data file for %s for writing: %Rrc", g_aSseBinaryI64R32[iFn].pszName, rc);
     5786            return RTEXITCODE_FAILURE;
     5787        }
     5788
     5789        uint32_t cNormalInputPairs  = 0;
     5790        for (uint32_t iTest = 0; iTest < cTests + RT_ELEMENTS(s_aSpecials); iTest += 1)
     5791        {
     5792            SSE_BINARY_I64_R32_TEST_T TestData; RT_ZERO(TestData);
     5793
     5794            TestData.r32ValIn = iTest < cTests ? RandR32Src(iTest) : s_aSpecials[iTest - cTests].Val;
     5795
     5796            if (RTFLOAT32U_IS_NORMAL(&TestData.r32ValIn))
     5797                cNormalInputPairs++;
     5798            else if (cNormalInputPairs < cMinNormalPairs && iTest + cMinNormalPairs >= cTests && iTest < cTests)
     5799            {
     5800                iTest -= 1;
     5801                continue;
     5802            }
     5803
     5804            uint32_t const fMxcsr = RandMxcsr() & X86_MXCSR_XCPT_FLAGS;
     5805            for (uint16_t iRounding = 0; iRounding < 4; iRounding++)
     5806                for (uint8_t iDaz = 0; iDaz < 2; iDaz++)
     5807                    for (uint8_t iFz = 0; iFz < 2; iFz++)
     5808                    {
     5809                        State.MXCSR = (fMxcsr & ~X86_MXCSR_RC_MASK)
     5810                                    | (iRounding  << X86_MXCSR_RC_SHIFT)
     5811                                    | (iDaz ? X86_MXCSR_DAZ : 0)
     5812                                    | (iFz  ? X86_MXCSR_FZ  : 0)
     5813                                    | X86_MXCSR_XCPT_MASK;
     5814                        uint32_t fMxcsrM; int64_t i64OutM;
     5815                        pfn(&State, &fMxcsrM, &i64OutM, &TestData.r32ValIn.u);
     5816                        TestData.fMxcsrIn  = State.MXCSR;
     5817                        TestData.fMxcsrOut = fMxcsrM;
     5818                        TestData.i64ValOut = i64OutM;
     5819                        RTStrmWrite(pStrmOut, &TestData, sizeof(TestData));
     5820
     5821                        State.MXCSR = State.MXCSR & ~X86_MXCSR_XCPT_MASK;
     5822                        uint32_t fMxcsrU; int64_t i64OutU;
     5823                        pfn(&State, &fMxcsrU, &i64OutU, &TestData.r32ValIn.u);
     5824                        TestData.fMxcsrIn  = State.MXCSR;
     5825                        TestData.fMxcsrOut = fMxcsrU;
     5826                        TestData.i64ValOut = i64OutU;
     5827                        RTStrmWrite(pStrmOut, &TestData, sizeof(TestData));
     5828
     5829                        uint16_t fXcpt = (fMxcsrM | fMxcsrU) & X86_MXCSR_XCPT_FLAGS;
     5830                        if (fXcpt)
     5831                        {
     5832                            State.MXCSR = (State.MXCSR & ~X86_MXCSR_XCPT_MASK) | fXcpt;
     5833                            uint32_t fMxcsr1; int64_t i64Out1;
     5834                            pfn(&State, &fMxcsr1, &i64Out1, &TestData.r32ValIn.u);
     5835                            TestData.fMxcsrIn  = State.MXCSR;
     5836                            TestData.fMxcsrOut = fMxcsr1;
     5837                            TestData.i64ValOut = i64Out1;
     5838                            RTStrmWrite(pStrmOut, &TestData, sizeof(TestData));
     5839
     5840                            if (((fMxcsr1 & X86_MXCSR_XCPT_FLAGS) & fXcpt) != (fMxcsr1 & X86_MXCSR_XCPT_FLAGS))
     5841                            {
     5842                                fXcpt |= fMxcsr1 & X86_MXCSR_XCPT_FLAGS;
     5843                                State.MXCSR = (State.MXCSR & ~X86_MXCSR_XCPT_MASK) | (fXcpt << X86_MXCSR_XCPT_MASK_SHIFT);
     5844                                uint32_t fMxcsr2; int64_t i64Out2;
     5845                                pfn(&State, &fMxcsr2, &i64Out2, &TestData.r32ValIn.u);
     5846                                TestData.fMxcsrIn  = State.MXCSR;
     5847                                TestData.fMxcsrOut = fMxcsr2;
     5848                                TestData.i64ValOut = i64Out2;
     5849                                RTStrmWrite(pStrmOut, &TestData, sizeof(TestData));
     5850                            }
     5851                            if (!RT_IS_POWER_OF_TWO(fXcpt))
     5852                                for (uint16_t fUnmasked = 1; fUnmasked <= X86_MXCSR_PE; fUnmasked <<= 1)
     5853                                    if (fUnmasked & fXcpt)
     5854                                    {
     5855                                        State.MXCSR = (State.MXCSR & ~X86_MXCSR_XCPT_MASK) | ((fXcpt & ~fUnmasked) << X86_MXCSR_XCPT_MASK_SHIFT);
     5856                                        uint32_t fMxcsr3; int64_t i64Out3;
     5857                                        pfn(&State, &fMxcsr3, &i64Out3, &TestData.r32ValIn.u);
     5858                                        TestData.fMxcsrIn  = State.MXCSR;
     5859                                        TestData.fMxcsrOut = fMxcsr3;
     5860                                        TestData.i64ValOut = i64Out3;
     5861                                        RTStrmWrite(pStrmOut, &TestData, sizeof(TestData));
     5862                                    }
     5863                        }
     5864                    }
     5865        }
     5866        rc = RTStrmClose(pStrmOut);
     5867        if (RT_FAILURE(rc))
     5868        {
     5869            RTMsgError("Failed to close data file for %s: %Rrc", g_aSseBinaryI64R32[iFn].pszName, rc);
     5870            return RTEXITCODE_FAILURE;
     5871        }
     5872    }
     5873
     5874    return RTEXITCODE_SUCCESS;
     5875}
     5876#endif
     5877
     5878
     5879static void SseBinaryI64R32Test(void)
     5880{
     5881    X86FXSTATE State;
     5882    RT_ZERO(State);
     5883    for (size_t iFn = 0; iFn < RT_ELEMENTS(g_aSseBinaryI64R32); iFn++)
     5884    {
     5885        if (!SubTestAndCheckIfEnabled(g_aSseBinaryI64R32[iFn].pszName))
     5886            continue;
     5887
     5888        uint32_t const                           cTests  = *g_aSseBinaryI64R32[iFn].pcTests;
     5889        SSE_BINARY_I64_R32_TEST_T const * const  paTests = g_aSseBinaryI64R32[iFn].paTests;
     5890        PFNIEMAIMPLSSEF2I64U32                   pfn     = g_aSseBinaryI64R32[iFn].pfn;
     5891        uint32_t const                           cVars   = COUNT_VARIATIONS(g_aSseBinaryI64R32[iFn]);
     5892        if (!cTests) RTTestSkipped(g_hTest, "no tests");
     5893        for (uint32_t iVar = 0; iVar < cVars; iVar++)
     5894        {
     5895            for (uint32_t iTest = 0; iTest < cTests / sizeof(SSE_BINARY_I64_R64_TEST_T); iTest++)
     5896            {
     5897                uint32_t fMxcsr = 0;
     5898                int64_t i64Dst = 0;
     5899
     5900                State.MXCSR = paTests[iTest].fMxcsrIn;
     5901                pfn(&State, &fMxcsr, &i64Dst, &paTests[iTest].r32ValIn.u);
     5902                if (   fMxcsr != paTests[iTest].fMxcsrOut
     5903                    || i64Dst != paTests[iTest].i64ValOut)
     5904                    RTTestFailed(g_hTest, "#%04u%s: mxcsr=%#08x in1=%s\n"
     5905                                          "%s               -> mxcsr=%#08x    %RI64\n"
     5906                                          "%s               expected %#08x    %RI64%s%s (%s)\n",
     5907                                 iTest, iVar ? "/n" : "", paTests[iTest].fMxcsrIn,
     5908                                 FormatR32(&paTests[iTest].r32ValIn),
     5909                                 iVar ? "  " : "", fMxcsr, i64Dst,
     5910                                 iVar ? "  " : "", paTests[iTest].fMxcsrOut, paTests[iTest].i64ValOut,
     5911                                 MxcsrDiff(fMxcsr, paTests[iTest].fMxcsrOut),
     5912                                   i64Dst != paTests[iTest].i64ValOut
     5913                                 ? " - val" : "",
     5914                                 FormatMxcsr(paTests[iTest].fMxcsrIn) );
     5915            }
     5916        }
     5917    }
     5918}
     5919
     5920
    55835921
    55845922int main(int argc, char **argv)
    … …  
    59276265            if (rcExit == RTEXITCODE_SUCCESS)
    59286266                rcExit = SseBinaryI64R64Generate(pszDataFileFmt, cTests);
     6267            if (rcExit == RTEXITCODE_SUCCESS)
     6268                rcExit = SseBinaryI32R32Generate(pszDataFileFmt, cTests);
     6269            if (rcExit == RTEXITCODE_SUCCESS)
     6270                rcExit = SseBinaryI64R32Generate(pszDataFileFmt, cTests);
    59296271            if (rcExit != RTEXITCODE_SUCCESS)
    59306272                return rcExit;
    … …  
    60286370                SseBinaryI32R64Test();
    60296371                SseBinaryI64R64Test();
     6372                SseBinaryI32R32Test();
     6373                SseBinaryI64R32Test();
    60306374            }
    60316375        }

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

    r96727 r96732  
    401401    RTFLOAT64U              r64ValIn;
    402402} SSE_BINARY_I64_R64_TEST_T;
     403
     404typedef struct SSE_BINARY_I32_R32_TEST_T
     405{
     406    uint32_t                fMxcsrIn;
     407    uint32_t                fMxcsrOut;
     408    uint32_t                u32Padding;
     409    int32_t                 i32ValOut;
     410    RTFLOAT32U              r32ValIn;
     411} SSE_BINARY_I32_R32_TEST_T;
     412
     413typedef struct SSE_BINARY_I64_R32_TEST_T
     414{
     415    uint32_t                fMxcsrIn;
     416    uint32_t                fMxcsrOut;
     417    int64_t                 i64ValOut;
     418    RTFLOAT32U              r32ValIn;
     419} SSE_BINARY_I64_R32_TEST_T;
    403420
    404421/** @} */
    … …  
    826843TSTIEM_DECLARE_TEST_ARRAY_BIN(SseBinary,    SSE_BINARY_I64_R64_TEST_T,  cvtsd2si_i64_r64         );
    827844
     845TSTIEM_DECLARE_TEST_ARRAY_BIN(SseBinary,    SSE_BINARY_I32_R32_TEST_T,  cvttss2si_i32_r32        );
     846TSTIEM_DECLARE_TEST_ARRAY_BIN(SseBinary,    SSE_BINARY_I32_R32_TEST_T,  cvtss2si_i32_r32         );
     847
     848TSTIEM_DECLARE_TEST_ARRAY_BIN(SseBinary,    SSE_BINARY_I64_R32_TEST_T,  cvttss2si_i64_r32        );
     849TSTIEM_DECLARE_TEST_ARRAY_BIN(SseBinary,    SSE_BINARY_I64_R32_TEST_T,  cvtss2si_i64_r32         );
     850
    828851RT_C_DECLS_END
    829852

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

    r96727 r96732  
    107107IEM_TEST_DATA cvttsd2si_i64_r64, "tstIEMAImplDataSseBinary-cvttsd2si_i64_r64.bin"
    108108IEM_TEST_DATA cvtsd2si_i64_r64,  "tstIEMAImplDataSseBinary-cvtsd2si_i64_r64.bin"
     109
     110IEM_TEST_DATA cvttss2si_i32_r32, "tstIEMAImplDataSseBinary-cvttss2si_i32_r32.bin"
     111IEM_TEST_DATA cvtss2si_i32_r32,  "tstIEMAImplDataSseBinary-cvtss2si_i32_r32.bin"
     112
     113IEM_TEST_DATA cvttss2si_i64_r32, "tstIEMAImplDataSseBinary-cvttss2si_i64_r32.bin"
     114IEM_TEST_DATA cvtss2si_i64_r32,  "tstIEMAImplDataSseBinary-cvtss2si_i64_r32.bin"

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

    r96727 r96732  
    105105IEM_TEST_DATA cvttsd2si_i64_r64,    "tstIEMAImplDataSseBinary-cvttsd2si_i64_r64.bin"
    106106IEM_TEST_DATA cvtsd2si_i64_r64,     "tstIEMAImplDataSseBinary-cvtsd2si_i64_r64.bin"
     107
     108IEM_TEST_DATA cvttss2si_i32_r32,    "tstIEMAImplDataSseBinary-cvttss2si_i32_r32.bin"
     109IEM_TEST_DATA cvtss2si_i32_r32,     "tstIEMAImplDataSseBinary-cvtss2si_i32_r32.bin"
     110
     111IEM_TEST_DATA cvttss2si_i64_r32,    "tstIEMAImplDataSseBinary-cvttss2si_i64_r32.bin"
     112IEM_TEST_DATA cvtss2si_i64_r32,     "tstIEMAImplDataSseBinary-cvtss2si_i64_r32.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