VirtualBox

Changeset 96724 in vbox for trunk/src/VBox


Ignore:
Timestamp:
Sep 14, 2022 7:19:54 AM (2 years ago)
Author:
vboxsync
Message:

VMM/testcase/tstIEMAImpl: Implement basic cvttsd2si testcase, ​bugref:9898

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

Legend:

Unmodified
Added
Removed

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

    r96682 r96724  
    280280        tstIEMAImplDataSseBinary-cvtsd2ss_u128_r64.bin \
    281281        tstIEMAImplDataSseBinary-sqrtss_u128_r32.bin \
    282         tstIEMAImplDataSseBinary-sqrtsd_u128_r64.bin
     282        tstIEMAImplDataSseBinary-sqrtsd_u128_r64.bin \
     283        tstIEMAImplDataSseBinary-cvttsd2si_i32_r64.bin \
     284        tstIEMAImplDataSseBinary-cvttsd2si_i64_r64.bin
    283285
    284286tstIEMAImpl_TEMPLATE  = VBOXR3TSTEXE

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

    r96682 r96724  
    52435243
    52445244
     5245/*
     5246 * SSE operations converting single double-precision floating point values to signed double-word integers (cvttsd2si and friends).
     5247 */
     5248TYPEDEF_SUBTEST_TYPE(SSE_BINARY_I32_R64_T, SSE_BINARY_I32_R64_TEST_T, PFNIEMAIMPLSSEF2I32U64);
     5249
     5250static const SSE_BINARY_I32_R64_T g_aSseBinaryI32R64[] =
     5251{
     5252    ENTRY_BIN(cvttsd2si_i32_r64),
     5253};
     5254
     5255#ifdef TSTIEMAIMPL_WITH_GENERATOR
     5256static RTEXITCODE SseBinaryI32R64Generate(const char *pszDataFileFmt, uint32_t cTests)
     5257{
     5258    cTests = RT_MAX(192, cTests); /* there are 144 standard input variations */
     5259
     5260    static struct { RTFLOAT64U Val; } const s_aSpecials[] =
     5261    {
     5262        { RTFLOAT64U_INIT_C(0, 8388607, RTFLOAT64U_EXP_MAX - 1) },
     5263          /** @todo More specials. */
     5264    };
     5265
     5266    X86FXSTATE State;
     5267    RT_ZERO(State);
     5268    uint32_t cMinNormalPairs       = (cTests - 144) / 4;
     5269    for (size_t iFn = 0; iFn < RT_ELEMENTS(g_aSseBinaryI32R64); iFn++)
     5270    {
     5271        PFNIEMAIMPLSSEF2I32U64 const pfn = g_aSseBinaryI32R64[iFn].pfnNative ? g_aSseBinaryI32R64[iFn].pfnNative : g_aSseBinaryI32R64[iFn].pfn;
     5272
     5273        PRTSTREAM pStrmOut = NULL;
     5274        int rc = RTStrmOpenF("wb", &pStrmOut, pszDataFileFmt, g_aSseBinaryI32R64[iFn].pszName);
     5275        if (RT_FAILURE(rc))
     5276        {
     5277            RTMsgError("Failed to open data file for %s for writing: %Rrc", g_aSseBinaryI32R64[iFn].pszName, rc);
     5278            return RTEXITCODE_FAILURE;
     5279        }
     5280
     5281        uint32_t cNormalInputPairs  = 0;
     5282        for (uint32_t iTest = 0; iTest < cTests + RT_ELEMENTS(s_aSpecials); iTest += 1)
     5283        {
     5284            SSE_BINARY_I32_R64_TEST_T TestData; RT_ZERO(TestData);
     5285
     5286            TestData.r64ValIn = iTest < cTests ? RandR64Src(iTest) : s_aSpecials[iTest - cTests].Val;
     5287
     5288            if (RTFLOAT64U_IS_NORMAL(&TestData.r64ValIn))
     5289                cNormalInputPairs++;
     5290            else if (cNormalInputPairs < cMinNormalPairs && iTest + cMinNormalPairs >= cTests && iTest < cTests)
     5291            {
     5292                iTest -= 1;
     5293                continue;
     5294            }
     5295
     5296            uint32_t const fMxcsr = RandMxcsr() & X86_MXCSR_XCPT_FLAGS;
     5297            for (uint16_t iRounding = 0; iRounding < 4; iRounding++)
     5298                for (uint8_t iDaz = 0; iDaz < 2; iDaz++)
     5299                    for (uint8_t iFz = 0; iFz < 2; iFz++)
     5300                    {
     5301                        State.MXCSR = (fMxcsr & ~X86_MXCSR_RC_MASK)
     5302                                    | (iRounding  << X86_MXCSR_RC_SHIFT)
     5303                                    | (iDaz ? X86_MXCSR_DAZ : 0)
     5304                                    | (iFz  ? X86_MXCSR_FZ  : 0)
     5305                                    | X86_MXCSR_XCPT_MASK;
     5306                        uint32_t fMxcsrM; int32_t i32OutM;
     5307                        pfn(&State, &fMxcsrM, &i32OutM, &TestData.r64ValIn.u);
     5308                        TestData.fMxcsrIn  = State.MXCSR;
     5309                        TestData.fMxcsrOut = fMxcsrM;
     5310                        TestData.i32ValOut = i32OutM;
     5311                        RTStrmWrite(pStrmOut, &TestData, sizeof(TestData));
     5312
     5313                        State.MXCSR = State.MXCSR & ~X86_MXCSR_XCPT_MASK;
     5314                        uint32_t fMxcsrU; int32_t i32OutU;
     5315                        pfn(&State, &fMxcsrU, &i32OutU, &TestData.r64ValIn.u);
     5316                        TestData.fMxcsrIn  = State.MXCSR;
     5317                        TestData.fMxcsrOut = fMxcsrU;
     5318                        TestData.i32ValOut = i32OutU;
     5319                        RTStrmWrite(pStrmOut, &TestData, sizeof(TestData));
     5320
     5321                        uint16_t fXcpt = (fMxcsrM | fMxcsrU) & X86_MXCSR_XCPT_FLAGS;
     5322                        if (fXcpt)
     5323                        {
     5324                            State.MXCSR = (State.MXCSR & ~X86_MXCSR_XCPT_MASK) | fXcpt;
     5325                            uint32_t fMxcsr1; int32_t i32Out1;
     5326                            pfn(&State, &fMxcsr1, &i32Out1, &TestData.r64ValIn.u);
     5327                            TestData.fMxcsrIn  = State.MXCSR;
     5328                            TestData.fMxcsrOut = fMxcsr1;
     5329                            TestData.i32ValOut = i32Out1;
     5330                            RTStrmWrite(pStrmOut, &TestData, sizeof(TestData));
     5331
     5332                            if (((fMxcsr1 & X86_MXCSR_XCPT_FLAGS) & fXcpt) != (fMxcsr1 & X86_MXCSR_XCPT_FLAGS))
     5333                            {
     5334                                fXcpt |= fMxcsr1 & X86_MXCSR_XCPT_FLAGS;
     5335                                State.MXCSR = (State.MXCSR & ~X86_MXCSR_XCPT_MASK) | (fXcpt << X86_MXCSR_XCPT_MASK_SHIFT);
     5336                                uint32_t fMxcsr2; int32_t i32Out2;
     5337                                pfn(&State, &fMxcsr2, &i32Out2, &TestData.r64ValIn.u);
     5338                                TestData.fMxcsrIn  = State.MXCSR;
     5339                                TestData.fMxcsrOut = fMxcsr2;
     5340                                TestData.i32ValOut = i32Out2;
     5341                                RTStrmWrite(pStrmOut, &TestData, sizeof(TestData));
     5342                            }
     5343                            if (!RT_IS_POWER_OF_TWO(fXcpt))
     5344                                for (uint16_t fUnmasked = 1; fUnmasked <= X86_MXCSR_PE; fUnmasked <<= 1)
     5345                                    if (fUnmasked & fXcpt)
     5346                                    {
     5347                                        State.MXCSR = (State.MXCSR & ~X86_MXCSR_XCPT_MASK) | ((fXcpt & ~fUnmasked) << X86_MXCSR_XCPT_MASK_SHIFT);
     5348                                        uint32_t fMxcsr3; int32_t i32Out3;
     5349                                        pfn(&State, &fMxcsr3, &i32Out3, &TestData.r64ValIn.u);
     5350                                        TestData.fMxcsrIn  = State.MXCSR;
     5351                                        TestData.fMxcsrOut = fMxcsr3;
     5352                                        TestData.i32ValOut = i32Out3;
     5353                                        RTStrmWrite(pStrmOut, &TestData, sizeof(TestData));
     5354                                    }
     5355                        }
     5356                    }
     5357        }
     5358        rc = RTStrmClose(pStrmOut);
     5359        if (RT_FAILURE(rc))
     5360        {
     5361            RTMsgError("Failed to close data file for %s: %Rrc", g_aSseBinaryI32R64[iFn].pszName, rc);
     5362            return RTEXITCODE_FAILURE;
     5363        }
     5364    }
     5365
     5366    return RTEXITCODE_SUCCESS;
     5367}
     5368#endif
     5369
     5370
     5371static void SseBinaryI32R64Test(void)
     5372{
     5373    X86FXSTATE State;
     5374    RT_ZERO(State);
     5375    for (size_t iFn = 0; iFn < RT_ELEMENTS(g_aSseBinaryI32R64); iFn++)
     5376    {
     5377        if (!SubTestAndCheckIfEnabled(g_aSseBinaryI32R64[iFn].pszName))
     5378            continue;
     5379
     5380        uint32_t const                           cTests  = *g_aSseBinaryI32R64[iFn].pcTests;
     5381        SSE_BINARY_I32_R64_TEST_T const * const  paTests = g_aSseBinaryI32R64[iFn].paTests;
     5382        PFNIEMAIMPLSSEF2I32U64                   pfn     = g_aSseBinaryI32R64[iFn].pfn;
     5383        uint32_t const                           cVars   = COUNT_VARIATIONS(g_aSseBinaryI32R64[iFn]);
     5384        if (!cTests) RTTestSkipped(g_hTest, "no tests");
     5385        for (uint32_t iVar = 0; iVar < cVars; iVar++)
     5386        {
     5387            for (uint32_t iTest = 0; iTest < cTests / sizeof(SSE_BINARY_I32_R64_TEST_T); iTest++)
     5388            {
     5389                uint32_t fMxcsr = 0;
     5390                int32_t i32Dst = 0;
     5391
     5392                State.MXCSR = paTests[iTest].fMxcsrIn;
     5393                pfn(&State, &fMxcsr, &i32Dst, &paTests[iTest].r64ValIn.u);
     5394                if (   fMxcsr != paTests[iTest].fMxcsrOut
     5395                    || i32Dst != paTests[iTest].i32ValOut)
     5396                    RTTestFailed(g_hTest, "#%04u%s: mxcsr=%#08x in1=%s\n"
     5397                                          "%s               -> mxcsr=%#08x    %RI32\n"
     5398                                          "%s               expected %#08x    %RI32%s%s (%s)\n",
     5399                                 iTest, iVar ? "/n" : "", paTests[iTest].fMxcsrIn,
     5400                                 FormatR64(&paTests[iTest].r64ValIn),
     5401                                 iVar ? "  " : "", fMxcsr, i32Dst,
     5402                                 iVar ? "  " : "", paTests[iTest].fMxcsrOut, paTests[iTest].i32ValOut,
     5403                                 MxcsrDiff(fMxcsr, paTests[iTest].fMxcsrOut),
     5404                                   i32Dst != paTests[iTest].i32ValOut
     5405                                 ? " - val" : "",
     5406                                 FormatMxcsr(paTests[iTest].fMxcsrIn) );
     5407            }
     5408        }
     5409    }
     5410}
     5411
     5412
     5413/*
     5414 * SSE operations converting single double-precision floating point values to signed quad-word integers (cvttsd2si and friends).
     5415 */
     5416TYPEDEF_SUBTEST_TYPE(SSE_BINARY_I64_R64_T, SSE_BINARY_I64_R64_TEST_T, PFNIEMAIMPLSSEF2I64U64);
     5417
     5418static const SSE_BINARY_I64_R64_T g_aSseBinaryI64R64[] =
     5419{
     5420    ENTRY_BIN(cvttsd2si_i64_r64),
     5421};
     5422
     5423#ifdef TSTIEMAIMPL_WITH_GENERATOR
     5424static RTEXITCODE SseBinaryI64R64Generate(const char *pszDataFileFmt, uint32_t cTests)
     5425{
     5426    cTests = RT_MAX(192, cTests); /* there are 144 standard input variations */
     5427
     5428    static struct { RTFLOAT64U Val; } const s_aSpecials[] =
     5429    {
     5430        { RTFLOAT64U_INIT_C(0, 8388607, RTFLOAT64U_EXP_MAX - 1) },
     5431          /** @todo More specials. */
     5432    };
     5433
     5434    X86FXSTATE State;
     5435    RT_ZERO(State);
     5436    uint32_t cMinNormalPairs       = (cTests - 144) / 4;
     5437    for (size_t iFn = 0; iFn < RT_ELEMENTS(g_aSseBinaryI64R64); iFn++)
     5438    {
     5439        PFNIEMAIMPLSSEF2I64U64 const pfn = g_aSseBinaryI64R64[iFn].pfnNative ? g_aSseBinaryI64R64[iFn].pfnNative : g_aSseBinaryI64R64[iFn].pfn;
     5440
     5441        PRTSTREAM pStrmOut = NULL;
     5442        int rc = RTStrmOpenF("wb", &pStrmOut, pszDataFileFmt, g_aSseBinaryI64R64[iFn].pszName);
     5443        if (RT_FAILURE(rc))
     5444        {
     5445            RTMsgError("Failed to open data file for %s for writing: %Rrc", g_aSseBinaryI64R64[iFn].pszName, rc);
     5446            return RTEXITCODE_FAILURE;
     5447        }
     5448
     5449        uint32_t cNormalInputPairs  = 0;
     5450        for (uint32_t iTest = 0; iTest < cTests + RT_ELEMENTS(s_aSpecials); iTest += 1)
     5451        {
     5452            SSE_BINARY_I64_R64_TEST_T TestData; RT_ZERO(TestData);
     5453
     5454            TestData.r64ValIn = iTest < cTests ? RandR64Src(iTest) : s_aSpecials[iTest - cTests].Val;
     5455
     5456            if (RTFLOAT64U_IS_NORMAL(&TestData.r64ValIn))
     5457                cNormalInputPairs++;
     5458            else if (cNormalInputPairs < cMinNormalPairs && iTest + cMinNormalPairs >= cTests && iTest < cTests)
     5459            {
     5460                iTest -= 1;
     5461                continue;
     5462            }
     5463
     5464            uint32_t const fMxcsr = RandMxcsr() & X86_MXCSR_XCPT_FLAGS;
     5465            for (uint16_t iRounding = 0; iRounding < 4; iRounding++)
     5466                for (uint8_t iDaz = 0; iDaz < 2; iDaz++)
     5467                    for (uint8_t iFz = 0; iFz < 2; iFz++)
     5468                    {
     5469                        State.MXCSR = (fMxcsr & ~X86_MXCSR_RC_MASK)
     5470                                    | (iRounding  << X86_MXCSR_RC_SHIFT)
     5471                                    | (iDaz ? X86_MXCSR_DAZ : 0)
     5472                                    | (iFz  ? X86_MXCSR_FZ  : 0)
     5473                                    | X86_MXCSR_XCPT_MASK;
     5474                        uint32_t fMxcsrM; int64_t i64OutM;
     5475                        pfn(&State, &fMxcsrM, &i64OutM, &TestData.r64ValIn.u);
     5476                        TestData.fMxcsrIn  = State.MXCSR;
     5477                        TestData.fMxcsrOut = fMxcsrM;
     5478                        TestData.i64ValOut = i64OutM;
     5479                        RTStrmWrite(pStrmOut, &TestData, sizeof(TestData));
     5480
     5481                        State.MXCSR = State.MXCSR & ~X86_MXCSR_XCPT_MASK;
     5482                        uint32_t fMxcsrU; int64_t i64OutU;
     5483                        pfn(&State, &fMxcsrU, &i64OutU, &TestData.r64ValIn.u);
     5484                        TestData.fMxcsrIn  = State.MXCSR;
     5485                        TestData.fMxcsrOut = fMxcsrU;
     5486                        TestData.i64ValOut = i64OutU;
     5487                        RTStrmWrite(pStrmOut, &TestData, sizeof(TestData));
     5488
     5489                        uint16_t fXcpt = (fMxcsrM | fMxcsrU) & X86_MXCSR_XCPT_FLAGS;
     5490                        if (fXcpt)
     5491                        {
     5492                            State.MXCSR = (State.MXCSR & ~X86_MXCSR_XCPT_MASK) | fXcpt;
     5493                            uint32_t fMxcsr1; int64_t i64Out1;
     5494                            pfn(&State, &fMxcsr1, &i64Out1, &TestData.r64ValIn.u);
     5495                            TestData.fMxcsrIn  = State.MXCSR;
     5496                            TestData.fMxcsrOut = fMxcsr1;
     5497                            TestData.i64ValOut = i64Out1;
     5498                            RTStrmWrite(pStrmOut, &TestData, sizeof(TestData));
     5499
     5500                            if (((fMxcsr1 & X86_MXCSR_XCPT_FLAGS) & fXcpt) != (fMxcsr1 & X86_MXCSR_XCPT_FLAGS))
     5501                            {
     5502                                fXcpt |= fMxcsr1 & X86_MXCSR_XCPT_FLAGS;
     5503                                State.MXCSR = (State.MXCSR & ~X86_MXCSR_XCPT_MASK) | (fXcpt << X86_MXCSR_XCPT_MASK_SHIFT);
     5504                                uint32_t fMxcsr2; int64_t i64Out2;
     5505                                pfn(&State, &fMxcsr2, &i64Out2, &TestData.r64ValIn.u);
     5506                                TestData.fMxcsrIn  = State.MXCSR;
     5507                                TestData.fMxcsrOut = fMxcsr2;
     5508                                TestData.i64ValOut = i64Out2;
     5509                                RTStrmWrite(pStrmOut, &TestData, sizeof(TestData));
     5510                            }
     5511                            if (!RT_IS_POWER_OF_TWO(fXcpt))
     5512                                for (uint16_t fUnmasked = 1; fUnmasked <= X86_MXCSR_PE; fUnmasked <<= 1)
     5513                                    if (fUnmasked & fXcpt)
     5514                                    {
     5515                                        State.MXCSR = (State.MXCSR & ~X86_MXCSR_XCPT_MASK) | ((fXcpt & ~fUnmasked) << X86_MXCSR_XCPT_MASK_SHIFT);
     5516                                        uint32_t fMxcsr3; int64_t i64Out3;
     5517                                        pfn(&State, &fMxcsr3, &i64Out3, &TestData.r64ValIn.u);
     5518                                        TestData.fMxcsrIn  = State.MXCSR;
     5519                                        TestData.fMxcsrOut = fMxcsr3;
     5520                                        TestData.i64ValOut = i64Out3;
     5521                                        RTStrmWrite(pStrmOut, &TestData, sizeof(TestData));
     5522                                    }
     5523                        }
     5524                    }
     5525        }
     5526        rc = RTStrmClose(pStrmOut);
     5527        if (RT_FAILURE(rc))
     5528        {
     5529            RTMsgError("Failed to close data file for %s: %Rrc", g_aSseBinaryI64R64[iFn].pszName, rc);
     5530            return RTEXITCODE_FAILURE;
     5531        }
     5532    }
     5533
     5534    return RTEXITCODE_SUCCESS;
     5535}
     5536#endif
     5537
     5538
     5539static void SseBinaryI64R64Test(void)
     5540{
     5541    X86FXSTATE State;
     5542    RT_ZERO(State);
     5543    for (size_t iFn = 0; iFn < RT_ELEMENTS(g_aSseBinaryI64R64); iFn++)
     5544    {
     5545        if (!SubTestAndCheckIfEnabled(g_aSseBinaryI64R64[iFn].pszName))
     5546            continue;
     5547
     5548        uint32_t const                           cTests  = *g_aSseBinaryI64R64[iFn].pcTests;
     5549        SSE_BINARY_I64_R64_TEST_T const * const  paTests = g_aSseBinaryI64R64[iFn].paTests;
     5550        PFNIEMAIMPLSSEF2I64U64                   pfn     = g_aSseBinaryI64R64[iFn].pfn;
     5551        uint32_t const                           cVars   = COUNT_VARIATIONS(g_aSseBinaryI32R64[iFn]);
     5552        if (!cTests) RTTestSkipped(g_hTest, "no tests");
     5553        for (uint32_t iVar = 0; iVar < cVars; iVar++)
     5554        {
     5555            for (uint32_t iTest = 0; iTest < cTests / sizeof(SSE_BINARY_I64_R64_TEST_T); iTest++)
     5556            {
     5557                uint32_t fMxcsr = 0;
     5558                int64_t i64Dst = 0;
     5559
     5560                State.MXCSR = paTests[iTest].fMxcsrIn;
     5561                pfn(&State, &fMxcsr, &i64Dst, &paTests[iTest].r64ValIn.u);
     5562                if (   fMxcsr != paTests[iTest].fMxcsrOut
     5563                    || i64Dst != paTests[iTest].i64ValOut)
     5564                    RTTestFailed(g_hTest, "#%04u%s: mxcsr=%#08x in1=%s\n"
     5565                                          "%s               -> mxcsr=%#08x    %RI64\n"
     5566                                          "%s               expected %#08x    %RI64%s%s (%s)\n",
     5567                                 iTest, iVar ? "/n" : "", paTests[iTest].fMxcsrIn,
     5568                                 FormatR64(&paTests[iTest].r64ValIn),
     5569                                 iVar ? "  " : "", fMxcsr, i64Dst,
     5570                                 iVar ? "  " : "", paTests[iTest].fMxcsrOut, paTests[iTest].i64ValOut,
     5571                                 MxcsrDiff(fMxcsr, paTests[iTest].fMxcsrOut),
     5572                                   i64Dst != paTests[iTest].i64ValOut
     5573                                 ? " - val" : "",
     5574                                 FormatMxcsr(paTests[iTest].fMxcsrIn) );
     5575            }
     5576        }
     5577    }
     5578}
     5579
     5580
    52455581
    52465582int main(int argc, char **argv)
    … …  
    55855921            if (rcExit == RTEXITCODE_SUCCESS)
    55865922                rcExit = SseBinaryU128R64Generate(pszDataFileFmt, cTests);
     5923            if (rcExit == RTEXITCODE_SUCCESS)
     5924                rcExit = SseBinaryI32R64Generate(pszDataFileFmt, cTests);
     5925            if (rcExit == RTEXITCODE_SUCCESS)
     5926                rcExit = SseBinaryI64R64Generate(pszDataFileFmt, cTests);
    55875927            if (rcExit != RTEXITCODE_SUCCESS)
    55885928                return rcExit;
    … …  
    56846024                SseBinaryU128R32Test();
    56856025                SseBinaryU128R64Test();
     6026                SseBinaryI32R64Test();
     6027                SseBinaryI64R64Test();
    56866028            }
    56876029        }

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

    r96682 r96724  
    384384    RTFLOAT64U              r64Val2;
    385385} SSE_BINARY_U128_R64_TEST_T;
     386
     387typedef struct SSE_BINARY_I32_R64_TEST_T
     388{
     389    uint32_t                fMxcsrIn;
     390    uint32_t                fMxcsrOut;
     391    uint32_t                u32Padding;
     392    int32_t                 i32ValOut;
     393    RTFLOAT64U              r64ValIn;
     394} SSE_BINARY_I32_R64_TEST_T;
     395
     396typedef struct SSE_BINARY_I64_R64_TEST_T
     397{
     398    uint32_t                fMxcsrIn;
     399    uint32_t                fMxcsrOut;
     400    int64_t                 i64ValOut;
     401    RTFLOAT64U              r64ValIn;
     402} SSE_BINARY_I64_R64_TEST_T;
    386403
    387404/** @} */
    … …  
    803820TSTIEM_DECLARE_TEST_ARRAY_BIN(SseBinary,    SSE_BINARY_U128_R64_TEST_T, sqrtsd_u128_r64          );
    804821
     822TSTIEM_DECLARE_TEST_ARRAY_BIN(SseBinary,    SSE_BINARY_I32_R64_TEST_T,  cvttsd2si_i32_r64        );
     823TSTIEM_DECLARE_TEST_ARRAY_BIN(SseBinary,    SSE_BINARY_I64_R64_TEST_T,  cvttsd2si_i64_r64        );
     824
    805825RT_C_DECLS_END
    806826

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

    r96682 r96724  
    101101IEM_TEST_DATA cvtsd2ss_u128_r64, "tstIEMAImplDataSseBinary-cvtsd2ss_u128_r64.bin"
    102102IEM_TEST_DATA sqrtsd_u128_r64,   "tstIEMAImplDataSseBinary-sqrtsd_u128_r64.bin"
     103
     104IEM_TEST_DATA cvttsd2si_i32_r64, "tstIEMAImplDataSseBinary-cvttsd2si_i32_r64.bin"
     105
     106IEM_TEST_DATA cvttsd2si_i64_r64, "tstIEMAImplDataSseBinary-cvttsd2si_i64_r64.bin"

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

    r96682 r96724  
    9999IEM_TEST_DATA cvtsd2ss_u128_r64,    "tstIEMAImplDataSseBinary-cvtsd2ss_u128_r64.bin"
    100100IEM_TEST_DATA sqrtsd_u128_r64,      "tstIEMAImplDataSseBinary-sqrtsd_u128_r64.bin"
     101
     102IEM_TEST_DATA cvttsd2si_i32_r64,    "tstIEMAImplDataSseBinary-cvttsd2si_i32_r64.bin"
     103
     104IEM_TEST_DATA cvttsd2si_i64_r64,    "tstIEMAImplDataSseBinary-cvttsd2si_i64_r64.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