VirtualBox

Changeset 96327 in vbox


Ignore:
Timestamp:
Aug 19, 2022 9:14:09 AM (3 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
153141
Message:

VMM/testcase/tstIEMAImpl: Use binary files to store the test data for SSE tests as the source gets far too big to be handled efficiently by the compiler, bugref:9898

Location:
trunk/src/VBox/VMM/testcase
Files:
6 added
3 edited

Legend:

Unmodified
Added
Removed

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

    r96248 r96327  
    249249        $(tstIEMAImpl_0_OUTDIR)/tstIEMAImplDataFpuOther.cpp \
    250250        $(tstIEMAImpl_0_OUTDIR)/tstIEMAImplDataFpuOther-Amd.cpp \
    251         $(tstIEMAImpl_0_OUTDIR)/tstIEMAImplDataFpuOther-Intel.cpp \
    252         $(tstIEMAImpl_0_OUTDIR)/tstIEMAImplDataSseBinary.cpp
     251        $(tstIEMAImpl_0_OUTDIR)/tstIEMAImplDataFpuOther-Intel.cpp
    253252tstIEMAImpl_SOURCES   = \
    254253        tstIEMAImpl.cpp \
    255254        ../VMMAll/IEMAllAImplC.cpp \
    256255        $(tstIEMAImpl_CLEAN)
     256tstIEMAImpl_SOURCES.x86   += tstIEMAImplDataSseBinary.asm
     257tstIEMAImpl_SOURCES.amd64 += tstIEMAImplDataSseBinary.asm
     258tstIEMAImplDataSseBinary.asm_DEPS = \
     259        tstIEMAImplDataSseBinary-addps_u128.bin \
     260        tstIEMAImplDataSseBinary-mulps_u128.bin \
     261        tstIEMAImplDataSseBinary-subps_u128.bin \
     262        tstIEMAImplDataSseBinary-addpd_u128.bin \
     263        tstIEMAImplDataSseBinary-mulpd_u128.bin \
     264        tstIEMAImplDataSseBinary-subpd_u128.bin
     265
     266tstIEMAImpl_SOURCES.arm64 += tstIEMAImplDataSseBinary.S
     267tstIEMAImplDataSseBinary.S_DEPS   = \
     268        tstIEMAImplDataSseBinary-addps_u128.bin \
     269        tstIEMAImplDataSseBinary-mulps_u128.bin \
     270        tstIEMAImplDataSseBinary-subps_u128.bin \
     271        tstIEMAImplDataSseBinary-addpd_u128.bin \
     272        tstIEMAImplDataSseBinary-mulpd_u128.bin \
     273        tstIEMAImplDataSseBinary-subpd_u128.bin
    257274$(call KB_FN_DO_PASS0_ON_TARGET,tstIEMAImpl)
    258275
    … …  
    267284        ../VMMAll/IEMAllAImplC.cpp \
    268285        $(tstIEMAImpl_CLEAN)
     286tstIEMAImplAsm_SOURCES.x86   += tstIEMAImplDataSseBinary.asm
     287tstIEMAImplAsm_SOURCES.amd64 += tstIEMAImplDataSseBinary.asm
     288tstIEMAImplDataSseBinary.asm_DEPS = \
     289        tstIEMAImplDataSseBinary-addps_u128.bin \
     290        tstIEMAImplDataSseBinary-mulps_u128.bin \
     291        tstIEMAImplDataSseBinary-subps_u128.bin \
     292        tstIEMAImplDataSseBinary-addpd_u128.bin \
     293        tstIEMAImplDataSseBinary-mulpd_u128.bin \
     294        tstIEMAImplDataSseBinary-subpd_u128.bin
     295
     296tstIEMAImplAsm_SOURCES.arm64 += tstIEMAImplDataSseBinary.S
     297tstIEMAImplDataSseBinary.S_DEPS   = \
     298        tstIEMAImplDataSseBinary-addps_u128.bin \
     299        tstIEMAImplDataSseBinary-mulps_u128.bin \
     300        tstIEMAImplDataSseBinary-subps_u128.bin \
     301        tstIEMAImplDataSseBinary-addpd_u128.bin \
     302        tstIEMAImplDataSseBinary-mulpd_u128.bin \
     303        tstIEMAImplDataSseBinary-subpd_u128.bin
    269304
    270305## @param 1   The sub-name of the file in question.
    … …  
    297332$(evalcall2 def_tstIEMAImplData_adjust,FpuOther-Amd)
    298333$(evalcall2 def_tstIEMAImplData_adjust,FpuOther-Intel)
    299 $(evalcall2 def_tstIEMAImplData_adjust,SseBinary)
    300334
    301335

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

    r96291 r96327  
    4545    { RT_XSTR(a_Name), iemAImpl_ ## a_Name, NULL, \
    4646      g_aTests_ ## a_Name, &g_cTests_ ## a_Name, \
     47      a_uExtra, IEMTARGETCPU_EFL_BEHAVIOR_NATIVE /* means same for all here */ }
     48
     49#define ENTRY_BIN(a_Name)       ENTRY_EX_BIN(a_Name, 0)
     50#define ENTRY_EX_BIN(a_Name, a_uExtra) \
     51    { RT_XSTR(a_Name), iemAImpl_ ## a_Name, NULL, \
     52      g_aTests_ ## a_Name, &g_cbTests_ ## a_Name, \
    4753      a_uExtra, IEMTARGETCPU_EFL_BEHAVIOR_NATIVE /* means same for all here */ }
    4854
    … …  
    44604466 * Binary SSE operations on packed single precision floating point values.
    44614467 */
    4462 TYPEDEF_SUBTEST_TYPE(SSE_BINARY_R32_T, SSE_BINARY_R32_TEST_T, PFNIEMAIMPLFPSSEF2U128);
     4468TYPEDEF_SUBTEST_TYPE(SSE_BINARY_R32_T, SSE_BINARY_TEST_T, PFNIEMAIMPLFPSSEF2U128);
    44634469
    44644470static const SSE_BINARY_R32_T g_aSseBinaryR32[] =
    44654471{
    4466     ENTRY(addps_u128),
    4467     ENTRY(mulps_u128),
     4472    ENTRY_BIN(addps_u128),
     4473    ENTRY_BIN(mulps_u128),
     4474    ENTRY_BIN(subps_u128),
    44684475};
    44694476
    44704477#ifdef TSTIEMAIMPL_WITH_GENERATOR
    4471 static void SseBinaryR32Generate(PRTSTREAM pOut, PRTSTREAM pOutCpu, uint32_t cTests)
     4478static RTEXITCODE SseBinaryR32Generate(const char *pszDataFileFmt, uint32_t cTests)
    44724479{
    44734480    cTests = RT_MAX(192, cTests); /* there are 144 standard input variations */
    … …  
    44864493    {
    44874494        PFNIEMAIMPLFPSSEF2U128 const pfn = g_aSseBinaryR32[iFn].pfnNative ? g_aSseBinaryR32[iFn].pfnNative : g_aSseBinaryR32[iFn].pfn;
    4488         PRTSTREAM            pOutFn = pOut;
    4489         if (g_aSseBinaryR32[iFn].idxCpuEflFlavour != IEMTARGETCPU_EFL_BEHAVIOR_NATIVE)
     4495
     4496        PRTSTREAM pStrmOut = NULL;
     4497        int rc = RTStrmOpenF("wb", &pStrmOut, pszDataFileFmt, g_aSseBinaryR32[iFn].pszName);
     4498        if (RT_FAILURE(rc))
    44904499        {
    4491             if (g_aSseBinaryR32[iFn].idxCpuEflFlavour != g_idxCpuEflFlavour)
    4492                 continue;
    4493             pOutFn = pOutCpu;
     4500            RTMsgError("Failed to open data file for %s for writing: %Rrc", g_aSseBinaryR32[iFn].pszName, rc);
     4501            return RTEXITCODE_FAILURE;
    44944502        }
    44954503
    4496         GenerateArrayStart(pOutFn, g_aSseBinaryR32[iFn].pszName, "SSE_BINARY_R32_TEST_T");
    4497         uint32_t iTestOutput        = 0;
    44984504        uint32_t cNormalInputPairs  = 0;
    44994505        for (uint32_t iTest = 0; iTest < cTests + RT_ELEMENTS(s_aSpecials); iTest += 1)
    45004506        {
    4501             RTFLOAT32U InVal1_1 = iTest < cTests ? RandR32Src(iTest) : s_aSpecials[iTest - cTests].aVal1[0];
    4502             RTFLOAT32U InVal1_2 = iTest < cTests ? RandR32Src2(iTest) : s_aSpecials[iTest - cTests].aVal2[0];
    4503 
    4504             RTFLOAT32U InVal2_1 = iTest < cTests ? RandR32Src(iTest) : s_aSpecials[iTest - cTests].aVal1[1];
    4505             RTFLOAT32U InVal2_2 = iTest < cTests ? RandR32Src2(iTest) : s_aSpecials[iTest - cTests].aVal2[1];
    4506 
    4507             RTFLOAT32U InVal3_1 = iTest < cTests ? RandR32Src(iTest) : s_aSpecials[iTest - cTests].aVal1[2];
    4508             RTFLOAT32U InVal3_2 = iTest < cTests ? RandR32Src2(iTest) : s_aSpecials[iTest - cTests].aVal2[2];
    4509 
    4510             RTFLOAT32U InVal4_1 = iTest < cTests ? RandR32Src(iTest) : s_aSpecials[iTest - cTests].aVal1[3];
    4511             RTFLOAT32U InVal4_2 = iTest < cTests ? RandR32Src2(iTest) : s_aSpecials[iTest - cTests].aVal2[3];
    4512 
    4513             if (   RTFLOAT32U_IS_NORMAL(&InVal1_1) && RTFLOAT32U_IS_NORMAL(&InVal1_2)
    4514                 && RTFLOAT32U_IS_NORMAL(&InVal2_1) && RTFLOAT32U_IS_NORMAL(&InVal2_2)
    4515                 && RTFLOAT32U_IS_NORMAL(&InVal3_1) && RTFLOAT32U_IS_NORMAL(&InVal3_2)
    4516                 && RTFLOAT32U_IS_NORMAL(&InVal4_1) && RTFLOAT32U_IS_NORMAL(&InVal4_2))
     4507            SSE_BINARY_TEST_T TestData; RT_ZERO(TestData);
     4508
     4509            TestData.InVal1.ar32[0] = iTest < cTests ? RandR32Src(iTest) : s_aSpecials[iTest - cTests].aVal1[0];
     4510            TestData.InVal1.ar32[1] = iTest < cTests ? RandR32Src(iTest) : s_aSpecials[iTest - cTests].aVal1[1];
     4511            TestData.InVal1.ar32[2] = iTest < cTests ? RandR32Src(iTest) : s_aSpecials[iTest - cTests].aVal1[2];
     4512            TestData.InVal1.ar32[3] = iTest < cTests ? RandR32Src(iTest) : s_aSpecials[iTest - cTests].aVal1[3];
     4513
     4514            TestData.InVal2.ar32[0] = iTest < cTests ? RandR32Src2(iTest) : s_aSpecials[iTest - cTests].aVal2[0];
     4515            TestData.InVal2.ar32[1] = iTest < cTests ? RandR32Src2(iTest) : s_aSpecials[iTest - cTests].aVal2[1];
     4516            TestData.InVal2.ar32[2] = iTest < cTests ? RandR32Src2(iTest) : s_aSpecials[iTest - cTests].aVal2[2];
     4517            TestData.InVal2.ar32[3] = iTest < cTests ? RandR32Src2(iTest) : s_aSpecials[iTest - cTests].aVal2[3];
     4518
     4519            if (   RTFLOAT32U_IS_NORMAL(&TestData.InVal1.ar32[0]) && RTFLOAT32U_IS_NORMAL(&TestData.InVal2.ar32[0])
     4520                && RTFLOAT32U_IS_NORMAL(&TestData.InVal1.ar32[1]) && RTFLOAT32U_IS_NORMAL(&TestData.InVal2.ar32[1])
     4521                && RTFLOAT32U_IS_NORMAL(&TestData.InVal1.ar32[2]) && RTFLOAT32U_IS_NORMAL(&TestData.InVal2.ar32[2])
     4522                && RTFLOAT32U_IS_NORMAL(&TestData.InVal1.ar32[3]) && RTFLOAT32U_IS_NORMAL(&TestData.InVal2.ar32[3]))
    45174523                cNormalInputPairs++;
    45184524            else if (cNormalInputPairs < cMinNormalPairs && iTest + cMinNormalPairs >= cTests && iTest < cTests)
    … …  
    45214527                continue;
    45224528            }
    4523 
    4524             X86XMMREG XmmVal1; RT_ZERO(XmmVal1);
    4525             X86XMMREG XmmVal2; RT_ZERO(XmmVal2);
    4526 
    4527             XmmVal1.ar32[0] = InVal1_1;
    4528             XmmVal2.ar32[0] = InVal1_2;
    4529             XmmVal1.ar32[1] = InVal2_1;
    4530             XmmVal2.ar32[1] = InVal2_2;
    4531             XmmVal1.ar32[2] = InVal3_1;
    4532             XmmVal2.ar32[2] = InVal3_2;
    4533             XmmVal1.ar32[3] = InVal4_1;
    4534             XmmVal2.ar32[3] = InVal4_2;
    45354529
    45364530            uint32_t const fMxcsr = RandMxcsr() & X86_MXCSR_XCPT_FLAGS;
    … …  
    45454539                                    | X86_MXCSR_XCPT_MASK;
    45464540                        IEMSSERESULT ResM; RT_ZERO(ResM);
    4547                         pfn(&State, &ResM, &XmmVal1, &XmmVal2);
    4548                         RTStrmPrintf(pOutFn, "    { %#08x, %#08x, { %s, %s, %s, %s }, { %s, %s, %s, %s }, { %s, %s, %s, %s } }, /* #%u/%u/%c/%c/m = #%u */\n",
    4549                                      State.MXCSR, ResM.MXCSR,
    4550                                      GenFormatR32(&XmmVal1.ar32[0]), GenFormatR32(&XmmVal1.ar32[1]),
    4551                                      GenFormatR32(&XmmVal1.ar32[2]), GenFormatR32(&XmmVal1.ar32[3]),
    4552                                      GenFormatR32(&XmmVal2.ar32[0]), GenFormatR32(&XmmVal2.ar32[1]),
    4553                                      GenFormatR32(&XmmVal2.ar32[2]), GenFormatR32(&XmmVal2.ar32[3]),
    4554                                      GenFormatR32(&ResM.uResult.ar32[0]), GenFormatR32(&ResM.uResult.ar32[1]),
    4555                                      GenFormatR32(&ResM.uResult.ar32[2]), GenFormatR32(&ResM.uResult.ar32[3]),
    4556                                      iTest, iRounding,
    4557                                      iDaz ? 'd' : '0', iFz ? 'f' : '0',
    4558                                      iTestOutput++);
     4541                        pfn(&State, &ResM, &TestData.InVal1, &TestData.InVal2);
     4542                        TestData.fMxcsrIn  = State.MXCSR;
     4543                        TestData.fMxcsrOut = ResM.MXCSR;
     4544                        TestData.OutVal    = ResM.uResult;
     4545                        RTStrmWrite(pStrmOut, &TestData, sizeof(TestData));
    45594546
    45604547                        State.MXCSR = State.MXCSR & ~X86_MXCSR_XCPT_MASK;
    45614548                        IEMSSERESULT ResU; RT_ZERO(ResU);
    4562                         pfn(&State, &ResU, &XmmVal1, &XmmVal2);
    4563                         RTStrmPrintf(pOutFn, "    { %#08x, %#08x, { %s, %s, %s, %s }, { %s, %s, %s, %s }, { %s, %s, %s, %s } }, /* #%u/%u/%c/%c/u = #%u */\n",
    4564                                      State.MXCSR, ResU.MXCSR,
    4565                                      GenFormatR32(&XmmVal1.ar32[0]), GenFormatR32(&XmmVal1.ar32[1]),
    4566                                      GenFormatR32(&XmmVal1.ar32[2]), GenFormatR32(&XmmVal1.ar32[3]),
    4567                                      GenFormatR32(&XmmVal2.ar32[0]), GenFormatR32(&XmmVal2.ar32[1]),
    4568                                      GenFormatR32(&XmmVal2.ar32[2]), GenFormatR32(&XmmVal2.ar32[3]),
    4569                                      GenFormatR32(&ResU.uResult.ar32[0]), GenFormatR32(&ResU.uResult.ar32[1]),
    4570                                      GenFormatR32(&ResU.uResult.ar32[2]), GenFormatR32(&ResU.uResult.ar32[3]),
    4571                                      iTest, iRounding,
    4572                                      iDaz ? 'd' : '0', iFz ? 'f' : '0',
    4573                                      iTestOutput++);
     4549                        pfn(&State, &ResU, &TestData.InVal1, &TestData.InVal2);
     4550                        TestData.fMxcsrIn  = State.MXCSR;
     4551                        TestData.fMxcsrOut = ResU.MXCSR;
     4552                        TestData.OutVal    = ResU.uResult;
     4553                        RTStrmWrite(pStrmOut, &TestData, sizeof(TestData));
    45744554
    45754555                        uint16_t fXcpt = (ResM.MXCSR | ResU.MXCSR) & X86_MXCSR_XCPT_FLAGS;
    … …  
    45784558                            State.MXCSR = (State.MXCSR & ~X86_MXCSR_XCPT_MASK) | fXcpt;
    45794559                            IEMSSERESULT Res1; RT_ZERO(Res1);
    4580                             pfn(&State, &Res1, &XmmVal1, &XmmVal2);
    4581                             RTStrmPrintf(pOutFn, "    { %#08x, %#08x, { %s, %s, %s, %s }, { %s, %s, %s, %s }, { %s, %s, %s, %s } }, /* #%u/%u/%c/%c/u = #%u */\n",
    4582                                          State.MXCSR, Res1.MXCSR,
    4583                                          GenFormatR32(&XmmVal1.ar32[0]), GenFormatR32(&XmmVal1.ar32[1]),
    4584                                          GenFormatR32(&XmmVal1.ar32[2]), GenFormatR32(&XmmVal1.ar32[3]),
    4585                                          GenFormatR32(&XmmVal2.ar32[0]), GenFormatR32(&XmmVal2.ar32[1]),
    4586                                          GenFormatR32(&XmmVal2.ar32[2]), GenFormatR32(&XmmVal2.ar32[3]),
    4587                                          GenFormatR32(&Res1.uResult.ar32[0]), GenFormatR32(&Res1.uResult.ar32[1]),
    4588                                          GenFormatR32(&Res1.uResult.ar32[2]), GenFormatR32(&Res1.uResult.ar32[3]),
    4589                                          iTest, iRounding,
    4590                                          iDaz ? 'd' : '0', iFz ? 'f' : '0',
    4591                                          iTestOutput++);
     4560                            pfn(&State, &Res1, &TestData.InVal1, &TestData.InVal2);
     4561                            TestData.fMxcsrIn  = State.MXCSR;
     4562                            TestData.fMxcsrOut = Res1.MXCSR;
     4563                            TestData.OutVal    = Res1.uResult;
     4564                            RTStrmWrite(pStrmOut, &TestData, sizeof(TestData));
     4565
    45924566                            if (((Res1.MXCSR & X86_MXCSR_XCPT_FLAGS) & fXcpt) != (Res1.MXCSR & X86_MXCSR_XCPT_FLAGS))
    45934567                            {
    … …  
    45954569                                State.MXCSR = (State.MXCSR & ~X86_MXCSR_XCPT_MASK) | (fXcpt << X86_MXCSR_XCPT_MASK_SHIFT);
    45964570                                IEMSSERESULT Res2; RT_ZERO(Res2);
    4597                                 pfn(&State, &Res2, &XmmVal1, &XmmVal2);
    4598                                 RTStrmPrintf(pOutFn, "    { %#08x, %#08x, { %s, %s, %s, %s }, { %s, %s, %s, %s }, { %s, %s, %s, %s } }, /* #%u/%u/%c/%c/%#x[!] = #%u */\n",
    4599                                              State.MXCSR, Res2.MXCSR,
    4600                                              GenFormatR32(&XmmVal1.ar32[0]), GenFormatR32(&XmmVal1.ar32[1]),
    4601                                              GenFormatR32(&XmmVal1.ar32[2]), GenFormatR32(&XmmVal1.ar32[3]),
    4602                                              GenFormatR32(&XmmVal2.ar32[0]), GenFormatR32(&XmmVal2.ar32[1]),
    4603                                              GenFormatR32(&XmmVal2.ar32[2]), GenFormatR32(&XmmVal2.ar32[3]),
    4604                                              GenFormatR32(&Res2.uResult.ar32[0]), GenFormatR32(&Res2.uResult.ar32[1]),
    4605                                              GenFormatR32(&Res2.uResult.ar32[2]), GenFormatR32(&Res2.uResult.ar32[3]),
    4606                                              iTest, iRounding,
    4607                                              iDaz ? 'd' : '0', iFz ? 'f' : '0', fXcpt,
    4608                                              iTestOutput++);
     4571                                pfn(&State, &Res2, &TestData.InVal1, &TestData.InVal2);
     4572                                TestData.fMxcsrIn  = State.MXCSR;
     4573                                TestData.fMxcsrOut = Res2.MXCSR;
     4574                                TestData.OutVal    = Res2.uResult;
     4575                                RTStrmWrite(pStrmOut, &TestData, sizeof(TestData));
    46094576                            }
    46104577                            if (!RT_IS_POWER_OF_TWO(fXcpt))
    … …  
    46144581                                        State.MXCSR = (State.MXCSR & ~X86_MXCSR_XCPT_MASK) | ((fXcpt & ~fUnmasked) << X86_MXCSR_XCPT_MASK_SHIFT);
    46154582                                        IEMSSERESULT Res3; RT_ZERO(Res3);
    4616                                         pfn(&State, &Res3, &XmmVal1, &XmmVal2);
    4617                                         RTStrmPrintf(pOutFn, "    { %#08x, %#08x, { %s, %s, %s, %s }, { %s, %s, %s, %s }, { %s, %s, %s, %s } }, /* #%u/%u/%c/%c/u%#x = #%u */\n",
    4618                                                      State.MXCSR, Res3.MXCSR,
    4619                                                      GenFormatR32(&XmmVal1.ar32[0]), GenFormatR32(&XmmVal1.ar32[1]),
    4620                                                      GenFormatR32(&XmmVal1.ar32[2]), GenFormatR32(&XmmVal1.ar32[3]),
    4621                                                      GenFormatR32(&XmmVal2.ar32[0]), GenFormatR32(&XmmVal2.ar32[1]),
    4622                                                      GenFormatR32(&XmmVal2.ar32[2]), GenFormatR32(&XmmVal2.ar32[3]),
    4623                                                      GenFormatR32(&Res3.uResult.ar32[0]), GenFormatR32(&Res3.uResult.ar32[1]),
    4624                                                      GenFormatR32(&Res3.uResult.ar32[2]), GenFormatR32(&Res3.uResult.ar32[3]),
    4625                                                      iTest, iRounding,
    4626                                                      iDaz ? 'd' : '0', iFz ? 'f' : '0', fUnmasked,
    4627                                                      iTestOutput++);
     4583                                        pfn(&State, &Res3, &TestData.InVal1, &TestData.InVal2);
     4584                                        TestData.fMxcsrIn  = State.MXCSR;
     4585                                        TestData.fMxcsrOut = Res3.MXCSR;
     4586                                        TestData.OutVal    = Res3.uResult;
     4587                                        RTStrmWrite(pStrmOut, &TestData, sizeof(TestData));
    46284588                                    }
    46294589                        }
    46304590                    }
    46314591        }
    4632         GenerateArrayEnd(pOutFn, g_aSseBinaryR32[iFn].pszName);
    4633     }
     4592        rc = RTStrmClose(pStrmOut);
     4593        if (RT_FAILURE(rc))
     4594        {
     4595            RTMsgError("Failed to close data file for %s: %Rrc", g_aSseBinaryR32[iFn].pszName, rc);
     4596            return RTEXITCODE_FAILURE;
     4597        }
     4598    }
     4599
     4600    return RTEXITCODE_SUCCESS;
    46344601}
    46354602#endif
    … …  
    46444611            continue;
    46454612
    4646         uint32_t const                      cTests  = *g_aSseBinaryR32[iFn].pcTests;
    4647         SSE_BINARY_R32_TEST_T const * const paTests = g_aSseBinaryR32[iFn].paTests;
    4648         PFNIEMAIMPLFPSSEF2U128              pfn     = g_aSseBinaryR32[iFn].pfn;
    4649         uint32_t const                      cVars   = COUNT_VARIATIONS(g_aSseBinaryR32[iFn]);
     4613        uint32_t const                  cTests  = *g_aSseBinaryR32[iFn].pcTests;
     4614        SSE_BINARY_TEST_T const * const paTests = g_aSseBinaryR32[iFn].paTests;
     4615        PFNIEMAIMPLFPSSEF2U128          pfn     = g_aSseBinaryR32[iFn].pfn;
     4616        uint32_t const                  cVars   = COUNT_VARIATIONS(g_aSseBinaryR32[iFn]);
    46504617        if (!cTests) RTTestSkipped(g_hTest, "no tests");
    46514618        for (uint32_t iVar = 0; iVar < cVars; iVar++)
    46524619        {
    4653             for (uint32_t iTest = 0; iTest < cTests; iTest++)
     4620            for (uint32_t iTest = 0; iTest < cTests / sizeof(SSE_BINARY_TEST_T); iTest++)
    46544621            {
    4655                 X86XMMREG InVal1; RT_ZERO(InVal1);
    4656                 X86XMMREG InVal2; RT_ZERO(InVal2);
    46574622                IEMSSERESULT Res; RT_ZERO(Res);
    46584623
    4659                 InVal1.ar32[0] = paTests[iTest].aInVal1[0];
    4660                 InVal2.ar32[0] = paTests[iTest].aInVal2[0];
    4661                 InVal1.ar32[1] = paTests[iTest].aInVal1[1];
    4662                 InVal2.ar32[1] = paTests[iTest].aInVal2[1];
    4663                 InVal1.ar32[2] = paTests[iTest].aInVal1[2];
    4664                 InVal2.ar32[2] = paTests[iTest].aInVal2[2];
    4665                 InVal1.ar32[3] = paTests[iTest].aInVal1[3];
    4666                 InVal2.ar32[3] = paTests[iTest].aInVal2[3];
    4667 
    46684624                State.MXCSR = paTests[iTest].fMxcsrIn;
    4669                 pfn(&State, &Res, &InVal1, &InVal2);
    4670                 bool fValsIdentical =    RTFLOAT32U_ARE_IDENTICAL(&Res.uResult.ar32[0], &paTests[iTest].aOutVal[0])
    4671                                       && RTFLOAT32U_ARE_IDENTICAL(&Res.uResult.ar32[1], &paTests[iTest].aOutVal[1])
    4672                                       && RTFLOAT32U_ARE_IDENTICAL(&Res.uResult.ar32[2], &paTests[iTest].aOutVal[2])
    4673                                       && RTFLOAT32U_ARE_IDENTICAL(&Res.uResult.ar32[3], &paTests[iTest].aOutVal[3]);
     4625                pfn(&State, &Res, &paTests[iTest].InVal1, &paTests[iTest].InVal2);
     4626                bool fValsIdentical =    RTFLOAT32U_ARE_IDENTICAL(&Res.uResult.ar32[0], &paTests[iTest].OutVal.ar32[0])
     4627                                      && RTFLOAT32U_ARE_IDENTICAL(&Res.uResult.ar32[1], &paTests[iTest].OutVal.ar32[1])
     4628                                      && RTFLOAT32U_ARE_IDENTICAL(&Res.uResult.ar32[2], &paTests[iTest].OutVal.ar32[2])
     4629                                      && RTFLOAT32U_ARE_IDENTICAL(&Res.uResult.ar32[3], &paTests[iTest].OutVal.ar32[3]);
    46744630                if (   Res.MXCSR != paTests[iTest].fMxcsrOut
    46754631                    || !fValsIdentical)
    … …  
    46784634                                          "%s               expected %#08x    %s'%s'%s'%s%s%s (%s)\n",
    46794635                                 iTest, iVar ? "/n" : "", paTests[iTest].fMxcsrIn,
    4680                                  FormatR32(&paTests[iTest].aInVal1[0]), FormatR32(&paTests[iTest].aInVal1[1]),
    4681                                  FormatR32(&paTests[iTest].aInVal1[2]), FormatR32(&paTests[iTest].aInVal1[3]),
    4682                                  FormatR32(&paTests[iTest].aInVal2[0]), FormatR32(&paTests[iTest].aInVal2[1]),
    4683                                  FormatR32(&paTests[iTest].aInVal2[2]), FormatR32(&paTests[iTest].aInVal2[3]),
     4636                                 FormatR32(&paTests[iTest].InVal1.ar32[0]), FormatR32(&paTests[iTest].InVal1.ar32[1]),
     4637                                 FormatR32(&paTests[iTest].InVal1.ar32[2]), FormatR32(&paTests[iTest].InVal1.ar32[3]),
     4638                                 FormatR32(&paTests[iTest].InVal2.ar32[0]), FormatR32(&paTests[iTest].InVal2.ar32[1]),
     4639                                 FormatR32(&paTests[iTest].InVal2.ar32[2]), FormatR32(&paTests[iTest].InVal2.ar32[3]),
    46844640                                 iVar ? "  " : "", Res.MXCSR,
    46854641                                 FormatR32(&Res.uResult.ar32[0]), FormatR32(&Res.uResult.ar32[1]),
    46864642                                 FormatR32(&Res.uResult.ar32[2]), FormatR32(&Res.uResult.ar32[3]),
    46874643                                 iVar ? "  " : "", paTests[iTest].fMxcsrOut,
    4688                                  FormatR32(&paTests[iTest].aOutVal[0]), FormatR32(&paTests[iTest].aOutVal[1]),
    4689                                  FormatR32(&paTests[iTest].aOutVal[2]), FormatR32(&paTests[iTest].aOutVal[3]),
     4644                                 FormatR32(&paTests[iTest].OutVal.ar32[0]), FormatR32(&paTests[iTest].OutVal.ar32[1]),
     4645                                 FormatR32(&paTests[iTest].OutVal.ar32[2]), FormatR32(&paTests[iTest].OutVal.ar32[3]),
    46904646                                 MxcsrDiff(Res.MXCSR, paTests[iTest].fMxcsrOut),
    46914647                                 !fValsIdentical ? " - val" : "",
    … …  
    46984654
    46994655
    4700 
    47014656/*
    47024657 * Binary SSE operations on packed single precision floating point values.
    47034658 */
    4704 TYPEDEF_SUBTEST_TYPE(SSE_BINARY_R64_T, SSE_BINARY_R64_TEST_T, PFNIEMAIMPLFPSSEF2U128);
     4659TYPEDEF_SUBTEST_TYPE(SSE_BINARY_R64_T, SSE_BINARY_TEST_T, PFNIEMAIMPLFPSSEF2U128);
    47054660
    47064661static const SSE_BINARY_R64_T g_aSseBinaryR64[] =
    47074662{
    4708     ENTRY(addpd_u128),
    4709     ENTRY(mulpd_u128),
     4663    ENTRY_BIN(addpd_u128),
     4664    ENTRY_BIN(mulpd_u128),
     4665    ENTRY_BIN(subpd_u128),
    47104666};
    47114667
    47124668#ifdef TSTIEMAIMPL_WITH_GENERATOR
    4713 static void SseBinaryR64Generate(PRTSTREAM pOut, PRTSTREAM pOutCpu, uint32_t cTests)
     4669static RTEXITCODE SseBinaryR64Generate(const char *pszDataFileFmt, uint32_t cTests)
    47144670{
    47154671    cTests = RT_MAX(192, cTests); /* there are 144 standard input variations */
    … …  
    47284684    {
    47294685        PFNIEMAIMPLFPSSEF2U128 const pfn = g_aSseBinaryR64[iFn].pfnNative ? g_aSseBinaryR64[iFn].pfnNative : g_aSseBinaryR64[iFn].pfn;
    4730         PRTSTREAM            pOutFn = pOut;
    4731         if (g_aSseBinaryR64[iFn].idxCpuEflFlavour != IEMTARGETCPU_EFL_BEHAVIOR_NATIVE)
     4686
     4687        PRTSTREAM pStrmOut = NULL;
     4688        int rc = RTStrmOpenF("wb", &pStrmOut, pszDataFileFmt, g_aSseBinaryR64[iFn].pszName);
     4689        if (RT_FAILURE(rc))
    47324690        {
    4733             if (g_aSseBinaryR64[iFn].idxCpuEflFlavour != g_idxCpuEflFlavour)
    4734                 continue;
    4735             pOutFn = pOutCpu;
     4691            RTMsgError("Failed to open data file for %s for writing: %Rrc", g_aSseBinaryR32[iFn].pszName, rc);
     4692            return RTEXITCODE_FAILURE;
    47364693        }
    47374694
    4738         GenerateArrayStart(pOutFn, g_aSseBinaryR64[iFn].pszName, "SSE_BINARY_R64_TEST_T");
    4739         uint32_t iTestOutput        = 0;
    47404695        uint32_t cNormalInputPairs  = 0;
    47414696        for (uint32_t iTest = 0; iTest < cTests + RT_ELEMENTS(s_aSpecials); iTest += 1)
    47424697        {
    4743             RTFLOAT64U InVal1_1 = iTest < cTests ? RandR64Src(iTest) : s_aSpecials[iTest - cTests].aVal1[0];
    4744             RTFLOAT64U InVal1_2 = iTest < cTests ? RandR64Src2(iTest) : s_aSpecials[iTest - cTests].aVal2[0];
    4745             RTFLOAT64U InVal2_1 = iTest < cTests ? RandR64Src(iTest) : s_aSpecials[iTest - cTests].aVal1[1];
    4746             RTFLOAT64U InVal2_2 = iTest < cTests ? RandR64Src2(iTest) : s_aSpecials[iTest - cTests].aVal2[1];
    4747 
    4748             if (   RTFLOAT64U_IS_NORMAL(&InVal1_1) && RTFLOAT64U_IS_NORMAL(&InVal1_2)
    4749                 && RTFLOAT64U_IS_NORMAL(&InVal2_1) && RTFLOAT64U_IS_NORMAL(&InVal2_1))
     4698            SSE_BINARY_TEST_T TestData; RT_ZERO(TestData);
     4699
     4700            TestData.InVal1.ar64[0] = iTest < cTests ? RandR64Src(iTest) : s_aSpecials[iTest - cTests].aVal1[0];
     4701            TestData.InVal1.ar64[1] = iTest < cTests ? RandR64Src(iTest) : s_aSpecials[iTest - cTests].aVal1[0];
     4702            TestData.InVal2.ar64[0] = iTest < cTests ? RandR64Src2(iTest) : s_aSpecials[iTest - cTests].aVal2[0];
     4703            TestData.InVal2.ar64[1] = iTest < cTests ? RandR64Src2(iTest) : s_aSpecials[iTest - cTests].aVal2[0];
     4704
     4705            if (   RTFLOAT64U_IS_NORMAL(&TestData.InVal1.ar64[0]) && RTFLOAT64U_IS_NORMAL(&TestData.InVal1.ar64[1])
     4706                && RTFLOAT64U_IS_NORMAL(&TestData.InVal2.ar64[0]) && RTFLOAT64U_IS_NORMAL(&TestData.InVal2.ar64[1]))
    47504707                cNormalInputPairs++;
    47514708            else if (cNormalInputPairs < cMinNormalPairs && iTest + cMinNormalPairs >= cTests && iTest < cTests)
    … …  
    47544711                continue;
    47554712            }
    4756 
    4757             X86XMMREG XmmVal1; RT_ZERO(XmmVal1);
    4758             X86XMMREG XmmVal2; RT_ZERO(XmmVal2);
    4759 
    4760             XmmVal1.ar64[0] = InVal1_1;
    4761             XmmVal2.ar64[0] = InVal1_2;
    4762             XmmVal1.ar64[1] = InVal2_1;
    4763             XmmVal2.ar64[1] = InVal2_2;
    47644713
    47654714            uint32_t const fMxcsr = RandMxcsr() & X86_MXCSR_XCPT_FLAGS;
    … …  
    47744723                                    | X86_MXCSR_XCPT_MASK;
    47754724                        IEMSSERESULT ResM; RT_ZERO(ResM);
    4776                         pfn(&State, &ResM, &XmmVal1, &XmmVal2);
    4777                         RTStrmPrintf(pOutFn, "    { %#08x, %#08x, { %s, %s }, { %s, %s }, { %s, %s } }, /* #%u/%u/%c/%c/m = #%u */\n",
    4778                                      State.MXCSR, ResM.MXCSR,
    4779                                      GenFormatR64(&XmmVal1.ar64[0]), GenFormatR64(&XmmVal1.ar64[1]),
    4780                                      GenFormatR64(&XmmVal2.ar64[0]), GenFormatR64(&XmmVal2.ar64[1]),
    4781                                      GenFormatR64(&ResM.uResult.ar64[0]), GenFormatR64(&ResM.uResult.ar64[1]),
    4782                                      iTest, iRounding,
    4783                                      iDaz ? 'd' : '0', iFz ? 'f' : '0',
    4784                                      iTestOutput++);
     4725                        pfn(&State, &ResM, &TestData.InVal1, &TestData.InVal2);
     4726                        TestData.fMxcsrIn  = State.MXCSR;
     4727                        TestData.fMxcsrOut = ResM.MXCSR;
     4728                        TestData.OutVal    = ResM.uResult;
     4729                        RTStrmWrite(pStrmOut, &TestData, sizeof(TestData));
    47854730
    47864731                        State.MXCSR = State.MXCSR & ~X86_MXCSR_XCPT_MASK;
    47874732                        IEMSSERESULT ResU; RT_ZERO(ResU);
    4788                         pfn(&State, &ResU, &XmmVal1, &XmmVal2);
    4789                         RTStrmPrintf(pOutFn, "    { %#08x, %#08x, { %s, %s }, { %s, %s }, { %s, %s } }, /* #%u/%u/%c/%c/u = #%u */\n",
    4790                                      State.MXCSR, ResU.MXCSR,
    4791                                      GenFormatR64(&XmmVal1.ar64[0]), GenFormatR64(&XmmVal1.ar64[1]),
    4792                                      GenFormatR64(&XmmVal2.ar64[0]), GenFormatR64(&XmmVal2.ar64[1]),
    4793                                      GenFormatR64(&ResU.uResult.ar64[0]), GenFormatR64(&ResU.uResult.ar64[1]),
    4794                                      iTest, iRounding,
    4795                                      iDaz ? 'd' : '0', iFz ? 'f' : '0',
    4796                                      iTestOutput++);
     4733                        pfn(&State, &ResU, &TestData.InVal1, &TestData.InVal2);
     4734                        TestData.fMxcsrIn  = State.MXCSR;
     4735                        TestData.fMxcsrOut = ResU.MXCSR;
     4736                        TestData.OutVal    = ResU.uResult;
     4737                        RTStrmWrite(pStrmOut, &TestData, sizeof(TestData));
    47974738
    47984739                        uint16_t fXcpt = (ResM.MXCSR | ResU.MXCSR) & X86_MXCSR_XCPT_FLAGS;
    … …  
    48014742                            State.MXCSR = (State.MXCSR & ~X86_MXCSR_XCPT_MASK) | fXcpt;
    48024743                            IEMSSERESULT Res1; RT_ZERO(Res1);
    4803                             pfn(&State, &Res1, &XmmVal1, &XmmVal2);
    4804                             RTStrmPrintf(pOutFn, "    { %#08x, %#08x, { %s, %s }, { %s, %s }, { %s, %s } }, /* #%u/%u/%c/%c/u = #%u */\n",
    4805                                          State.MXCSR, Res1.MXCSR,
    4806                                          GenFormatR64(&XmmVal1.ar64[0]), GenFormatR64(&XmmVal1.ar64[1]),
    4807                                          GenFormatR64(&XmmVal2.ar64[0]), GenFormatR64(&XmmVal2.ar64[1]),
    4808                                          GenFormatR64(&Res1.uResult.ar64[0]), GenFormatR64(&Res1.uResult.ar64[1]),
    4809                                          iTest, iRounding,
    4810                                          iDaz ? 'd' : '0', iFz ? 'f' : '0',
    4811                                          iTestOutput++);
     4744                            pfn(&State, &Res1, &TestData.InVal1, &TestData.InVal2);
     4745                            TestData.fMxcsrIn  = State.MXCSR;
     4746                            TestData.fMxcsrOut = Res1.MXCSR;
     4747                            TestData.OutVal    = Res1.uResult;
     4748                            RTStrmWrite(pStrmOut, &TestData, sizeof(TestData));
     4749
    48124750                            if (((Res1.MXCSR & X86_MXCSR_XCPT_FLAGS) & fXcpt) != (Res1.MXCSR & X86_MXCSR_XCPT_FLAGS))
    48134751                            {
    … …  
    48154753                                State.MXCSR = (State.MXCSR & ~X86_MXCSR_XCPT_MASK) | (fXcpt << X86_MXCSR_XCPT_MASK_SHIFT);
    48164754                                IEMSSERESULT Res2; RT_ZERO(Res2);
    4817                                 pfn(&State, &Res2, &XmmVal1, &XmmVal2);
    4818                                 RTStrmPrintf(pOutFn, "    { %#08x, %#08x, { %s, %s }, { %s, %s }, { %s, %s } }, /* #%u/%u/%c/%c/%#x[!] = #%u */\n",
    4819                                              State.MXCSR, Res2.MXCSR,
    4820                                              GenFormatR64(&XmmVal1.ar64[0]), GenFormatR64(&XmmVal1.ar64[1]),
    4821                                              GenFormatR64(&XmmVal2.ar64[0]), GenFormatR64(&XmmVal2.ar64[1]),
    4822                                              GenFormatR64(&Res2.uResult.ar64[0]), GenFormatR64(&Res2.uResult.ar64[1]),
    4823                                              iTest, iRounding,
    4824                                              iDaz ? 'd' : '0', iFz ? 'f' : '0', fXcpt,
    4825                                              iTestOutput++);
     4755                                pfn(&State, &Res2, &TestData.InVal1, &TestData.InVal2);
     4756                                TestData.fMxcsrIn  = State.MXCSR;
     4757                                TestData.fMxcsrOut = Res2.MXCSR;
     4758                                TestData.OutVal    = Res2.uResult;
     4759                                RTStrmWrite(pStrmOut, &TestData, sizeof(TestData));
    48264760                            }
    48274761                            if (!RT_IS_POWER_OF_TWO(fXcpt))
    … …  
    48314765                                        State.MXCSR = (State.MXCSR & ~X86_MXCSR_XCPT_MASK) | ((fXcpt & ~fUnmasked) << X86_MXCSR_XCPT_MASK_SHIFT);
    48324766                                        IEMSSERESULT Res3; RT_ZERO(Res3);
    4833                                         pfn(&State, &Res3, &XmmVal1, &XmmVal2);
    4834                                         RTStrmPrintf(pOutFn, "    { %#08x, %#08x, { %s, %s }, { %s, %s }, { %s, %s } }, /* #%u/%u/%c/%c/u%#x = #%u */\n",
    4835                                                      State.MXCSR, Res3.MXCSR,
    4836                                                      GenFormatR64(&XmmVal1.ar64[0]), GenFormatR64(&XmmVal1.ar64[1]),
    4837                                                      GenFormatR64(&XmmVal2.ar64[0]), GenFormatR64(&XmmVal2.ar64[1]),
    4838                                                      GenFormatR64(&Res3.uResult.ar64[0]), GenFormatR64(&Res3.uResult.ar64[1]),
    4839                                                      iTest, iRounding,
    4840                                                      iDaz ? 'd' : '0', iFz ? 'f' : '0', fUnmasked,
    4841                                                      iTestOutput++);
     4767                                        pfn(&State, &Res3, &TestData.InVal1, &TestData.InVal2);
     4768                                        TestData.fMxcsrIn  = State.MXCSR;
     4769                                        TestData.fMxcsrOut = Res3.MXCSR;
     4770                                        TestData.OutVal    = Res3.uResult;
     4771                                        RTStrmWrite(pStrmOut, &TestData, sizeof(TestData));
    48424772                                    }
    48434773                        }
    48444774                    }
    48454775        }
    4846         GenerateArrayEnd(pOutFn, g_aSseBinaryR64[iFn].pszName);
    4847     }
     4776        rc = RTStrmClose(pStrmOut);
     4777        if (RT_FAILURE(rc))
     4778        {
     4779            RTMsgError("Failed to close data file for %s: %Rrc", g_aSseBinaryR32[iFn].pszName, rc);
     4780            return RTEXITCODE_FAILURE;
     4781        }
     4782    }
     4783
     4784    return RTEXITCODE_SUCCESS;
    48484785}
    48494786#endif
     4787
    48504788
    48514789static void SseBinaryR64Test(void)
    … …  
    48584796            continue;
    48594797
    4860         uint32_t const                      cTests  = *g_aSseBinaryR64[iFn].pcTests;
    4861         SSE_BINARY_R64_TEST_T const * const paTests = g_aSseBinaryR64[iFn].paTests;
    4862         PFNIEMAIMPLFPSSEF2U128              pfn     = g_aSseBinaryR64[iFn].pfn;
    4863         uint32_t const                      cVars   = COUNT_VARIATIONS(g_aSseBinaryR64[iFn]);
     4798        uint32_t const                  cTests  = *g_aSseBinaryR64[iFn].pcTests;
     4799        SSE_BINARY_TEST_T const * const paTests = g_aSseBinaryR64[iFn].paTests;
     4800        PFNIEMAIMPLFPSSEF2U128          pfn     = g_aSseBinaryR64[iFn].pfn;
     4801        uint32_t const                  cVars   = COUNT_VARIATIONS(g_aSseBinaryR64[iFn]);
    48644802        if (!cTests) RTTestSkipped(g_hTest, "no tests");
    4865         for (uint32_t iVar = 0; iVar < cVars; iVar++)
     4803        for (uint32_t iVar = 0; iVar < cVars / sizeof(SSE_BINARY_TEST_T); iVar++)
    48664804        {
    48674805            for (uint32_t iTest = 0; iTest < cTests; iTest++)
    48684806            {
    4869                 X86XMMREG InVal1; RT_ZERO(InVal1);
    4870                 X86XMMREG InVal2; RT_ZERO(InVal2);
    48714807                IEMSSERESULT Res; RT_ZERO(Res);
    48724808
    4873                 InVal1.ar64[0] = paTests[iTest].aInVal1[0];
    4874                 InVal2.ar64[0] = paTests[iTest].aInVal2[0];
    4875                 InVal1.ar64[1] = paTests[iTest].aInVal1[1];
    4876                 InVal2.ar64[1] = paTests[iTest].aInVal2[1];
    48774809                State.MXCSR = paTests[iTest].fMxcsrIn;
    4878                 pfn(&State, &Res, &InVal1, &InVal2);
     4810                pfn(&State, &Res, &paTests[iTest].InVal1, &paTests[iTest].InVal2);
    48794811                if (   Res.MXCSR != paTests[iTest].fMxcsrOut
    4880                     || !RTFLOAT64U_ARE_IDENTICAL(&Res.uResult.ar64[0], &paTests[iTest].aOutVal[0])
    4881                     || !RTFLOAT64U_ARE_IDENTICAL(&Res.uResult.ar64[1], &paTests[iTest].aOutVal[1]))
     4812                    || !RTFLOAT64U_ARE_IDENTICAL(&Res.uResult.ar64[0], &paTests[iTest].OutVal.ar64[0])
     4813                    || !RTFLOAT64U_ARE_IDENTICAL(&Res.uResult.ar64[1], &paTests[iTest].OutVal.ar64[1]))
    48824814                    RTTestFailed(g_hTest, "#%04u%s: mxcsr=%#08x in1=%s'%s in2=%s'%s\n"
    48834815                                          "%s               -> mxcsr=%#08x    %s'%s\n"
    48844816                                          "%s               expected %#08x    %s'%s%s%s (%s)\n",
    48854817                                 iTest, iVar ? "/n" : "", paTests[iTest].fMxcsrIn,
    4886                                  FormatR64(&paTests[iTest].aInVal1[0]), FormatR64(&paTests[iTest].aInVal1[1]),
    4887                                  FormatR64(&paTests[iTest].aInVal2[0]), FormatR64(&paTests[iTest].aInVal2[1]),
     4818                                 FormatR64(&paTests[iTest].InVal1.ar64[0]), FormatR64(&paTests[iTest].InVal1.ar64[1]),
     4819                                 FormatR64(&paTests[iTest].InVal2.ar64[0]), FormatR64(&paTests[iTest].InVal2.ar64[1]),
    48884820                                 iVar ? "  " : "", Res.MXCSR,
    48894821                                 FormatR64(&Res.uResult.ar64[0]), FormatR64(&Res.uResult.ar64[1]),
    48904822                                 iVar ? "  " : "", paTests[iTest].fMxcsrOut,
    4891                                  FormatR64(&paTests[iTest].aOutVal[0]), FormatR64(&paTests[iTest].aOutVal[1]),
     4823                                 FormatR64(&paTests[iTest].OutVal.ar64[0]), FormatR64(&paTests[iTest].OutVal.ar64[1]),
    48924824                                 MxcsrDiff(Res.MXCSR, paTests[iTest].fMxcsrOut),
    4893                                    (   !RTFLOAT64U_ARE_IDENTICAL(&Res.uResult.ar64[0], &paTests[iTest].aOutVal[0])
    4894                                     || !RTFLOAT64U_ARE_IDENTICAL(&Res.uResult.ar64[1], &paTests[iTest].aOutVal[1]))
     4825                                   (   !RTFLOAT64U_ARE_IDENTICAL(&Res.uResult.ar64[0], &paTests[iTest].OutVal.ar64[0])
     4826                                    || !RTFLOAT64U_ARE_IDENTICAL(&Res.uResult.ar64[1], &paTests[iTest].OutVal.ar64[1]))
    48954827                                 ? " - val" : "",
    48964828                                 FormatMxcsr(paTests[iTest].fMxcsrIn) );
    … …  
    52355167        if (fSseFpBinary)
    52365168        {
    5237             const char *pszDataFile    = fCommonData ? "tstIEMAImplDataSseBinary.cpp" : pszBitBucket;
    5238             PRTSTREAM   pStrmData      = GenerateOpenWithHdr(pszDataFile, szCpuDesc, NULL);
    5239             const char *pszDataCpuFile = pszBitBucket; /*!fCpuData ? pszBitBucket : g_idxCpuEflFlavour == IEMTARGETCPU_EFL_BEHAVIOR_AMD
    5240                                        ? "tstIEMAImplDataSimdBinary-Amd.cpp" : "tstIEMAImplDataSimdBinary-Intel.cpp"; */
    5241             PRTSTREAM   pStrmDataCpu   = GenerateOpenWithHdr(pszDataCpuFile, szCpuDesc, pszCpuType);
    5242             if (!pStrmData || !pStrmDataCpu)
    5243                 return RTEXITCODE_FAILURE;
    5244 
    5245             SseBinaryR32Generate(pStrmData, pStrmDataCpu, cTests);
    5246             SseBinaryR64Generate(pStrmData, pStrmDataCpu, cTests);
    5247 
    5248             RTEXITCODE rcExit = GenerateFooterAndClose(pStrmDataCpu, pszDataCpuFile,
    5249                                                        GenerateFooterAndClose(pStrmData, pszDataFile, RTEXITCODE_SUCCESS));
     5169            const char *pszDataFileFmt = fCommonData ? "tstIEMAImplDataSseBinary-%s.bin" : pszBitBucket;
     5170
     5171            RTEXITCODE rcExit = SseBinaryR32Generate(pszDataFileFmt, cTests);
     5172            if (rcExit == RTEXITCODE_SUCCESS)
     5173                rcExit = SseBinaryR64Generate(pszDataFileFmt, cTests);
    52505174            if (rcExit != RTEXITCODE_SUCCESS)
    52515175                return rcExit;

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

    r96290 r96327  
    2323
    2424#include <iprt/types.h>
     25#include <iprt/x86.h>
    2526
    2627
    … …  
    344345} FPU_UNARY_TWO_R80_TEST_T;
    345346
    346 typedef struct SSE_BINARY_R32_TEST_T
     347typedef struct SSE_BINARY_TEST_T
    347348{
    348349    uint32_t                fMxcsrIn;
    349350    uint32_t                fMxcsrOut;
    350     RTFLOAT32U              aInVal1[4];
    351     RTFLOAT32U              aInVal2[4];
    352     RTFLOAT32U              aOutVal[4];
    353 } SSE_BINARY_R32_TEST_T;
    354 
    355 typedef struct SSE_BINARY_R64_TEST_T
    356 {
    357     uint32_t                fMxcsrIn;
    358     uint32_t                fMxcsrOut;
    359     RTFLOAT64U              aInVal1[2];
    360     RTFLOAT64U              aInVal2[2];
    361     RTFLOAT64U              aOutVal[2];
    362 } SSE_BINARY_R64_TEST_T;
     351    uint32_t                au32Padding[2];
     352    X86XMMREG               InVal1;
     353    X86XMMREG               InVal2;
     354    X86XMMREG               OutVal;
     355} SSE_BINARY_TEST_T;
    363356
    364357/** @} */
    … …  
    369362    extern uint32_t const RT_CONCAT(g_cTests_, a_Instr)  = 0
    370363
     364#define TSTIEM_DEFINE_EMPTY_TEST_ARRAY_BIN(a_Type, a_Instr) \
     365    extern a_Type const  RT_CONCAT(g_aTests_, a_Instr)[] = { {0} }; \
     366    extern uint32_t const RT_CONCAT(g_cbTests_, a_Instr)  = 0
     367
    371368#define TSTIEM_DECLARE_TEST_ARRAY(a_szFile, a_Type, a_Instr) \
    372369    extern a_Type   const RT_CONCAT(g_aTests_, a_Instr)[]; \
    373370    extern uint32_t const RT_CONCAT(g_cTests_, a_Instr)
     371
     372#define TSTIEM_DECLARE_TEST_ARRAY_BIN(a_szFile, a_Type, a_Instr) \
     373    extern a_Type   const RT_CONCAT(g_aTests_, a_Instr)[]; \
     374    extern uint32_t const RT_CONCAT(g_cbTests_, a_Instr)
    374375
    375376TSTIEM_DECLARE_TEST_ARRAY(Int,              BINU8_TEST_T,               add_u8                   );
    … …  
    728729TSTIEM_DECLARE_TEST_ARRAY(FpuOther-Intel,   FPU_UNARY_TWO_R80_TEST_T,   fsincos_r80_r80_intel    );
    729730
    730 TSTIEM_DECLARE_TEST_ARRAY(SseBinary,        SSE_BINARY_R32_TEST_T,      addps_u128               );
    731 TSTIEM_DECLARE_TEST_ARRAY(SseBinary,        SSE_BINARY_R32_TEST_T,      mulps_u128               );
    732 
    733 TSTIEM_DECLARE_TEST_ARRAY(SseBinary,        SSE_BINARY_R64_TEST_T,      addpd_u128               );
    734 TSTIEM_DECLARE_TEST_ARRAY(SseBinary,        SSE_BINARY_R64_TEST_T,      mulpd_u128               );
     731TSTIEM_DECLARE_TEST_ARRAY_BIN(SseBinary,    SSE_BINARY_TEST_T,          addps_u128               );
     732TSTIEM_DECLARE_TEST_ARRAY_BIN(SseBinary,    SSE_BINARY_TEST_T,          mulps_u128               );
     733TSTIEM_DECLARE_TEST_ARRAY_BIN(SseBinary,    SSE_BINARY_TEST_T,          subps_u128               );
     734
     735TSTIEM_DECLARE_TEST_ARRAY_BIN(SseBinary,    SSE_BINARY_TEST_T,          addpd_u128               );
     736TSTIEM_DECLARE_TEST_ARRAY_BIN(SseBinary,    SSE_BINARY_TEST_T,          mulpd_u128               );
     737TSTIEM_DECLARE_TEST_ARRAY_BIN(SseBinary,    SSE_BINARY_TEST_T,          subpd_u128               );
    735738
    736739#endif /* !VMM_INCLUDED_SRC_testcase_tstIEMAImpl_h */
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