VirtualBox

Changeset 103060 in vbox


Ignore:
Timestamp:
Jan 25, 2024 1:13:11 PM (10 months ago)
Author:
vboxsync
Message:

tstIEMAImpl: Working on converting the C++ data to compressed binary. FP. bugref:9898

Location:
trunk/src/VBox/VMM/testcase
Files:
89 added
1 edited

Legend:

Unmodified
Added
Removed

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

    r103056 r103060  
    10651065}
    10661066
     1067# define GENERATE_BINARY_OPEN(a_pBinOut, a_papszNameFmts, a_Entry) \
     1068        GenerateBinaryOpen((a_pBinOut), a_papszNameFmts[(a_Entry).idxCpuEflFlavour], (a_Entry).pszName)
     1069
    10671070
    10681071static void GenerateBinaryWrite(PIEMBINARYOUTPUT pBinOut, const void *pvData, size_t cbData)
    … …  
    11001103}
    11011104
     1105/* Helper for DumpAll. */
     1106# define DUMP_TEST_ENTRY(a_Entry, a_papszNameFmts) \
     1107    do { \
     1108        AssertReturn(DECOMPRESS_TESTS(a_Entry), RTEXITCODE_FAILURE); \
     1109        IEMBINARYOUTPUT BinOut; \
     1110        AssertReturn(GENERATE_BINARY_OPEN(&BinOut, a_papszNameFmts, (a_Entry)), RTEXITCODE_FAILURE); \
     1111        uint32_t cbTests = (a_Entry).pcTests[0]; \
     1112        if (!(a_Entry).fBinary) \
     1113            cbTests *= sizeof((a_Entry).paTests[0]); \
     1114        GenerateBinaryWrite(&BinOut, (a_Entry).paTests, cbTests); \
     1115        AssertReturn(GenerateBinaryClose(&BinOut), RTEXITCODE_FAILURE); \
     1116    } while (0)
    11021117
    11031118#endif /* TSTIEMAIMPL_WITH_GENERATOR */
    … …  
    12001215                        *ppcTests     = pcTests;
    12011216                        *pfCompressed = false;
     1217                        RTMEM_WILL_LEAK(pcTests);
     1218                        RTMEM_WILL_LEAK(pbDecompressed);
    12021219
    12031220                        pbDecompressed = NULL;
    … …  
    15871604            && g_aBinU ## a_cBits[iFn].idxCpuEflFlavour != g_idxCpuEflFlavour) \
    15881605            continue; \
    1589         AssertReturn(GenerateBinaryOpen(&BinOut, papszNameFmts[g_aBinU ## a_cBits[iFn].idxCpuEflFlavour], \
    1590                                         g_aBinU ## a_cBits[iFn].pszName), RTEXITCODE_FAILURE); \
     1606        AssertReturn(GENERATE_BINARY_OPEN(&BinOut, papszNameFmts, g_aBinU ## a_cBits[iFn]), RTEXITCODE_FAILURE); \
    15911607        for (uint32_t iTest = 0; iTest < cTests; iTest++ ) \
    15921608        { \
    … …  
    16241640{ \
    16251641    for (size_t iFn = 0; iFn < RT_ELEMENTS(g_aBinU ## a_cBits); iFn++) \
    1626     { \
    1627         AssertReturn(DECOMPRESS_TESTS(g_aBinU ## a_cBits[iFn]), RTEXITCODE_FAILURE); \
    1628         IEMBINARYOUTPUT BinOut; \
    1629         AssertReturn(GenerateBinaryOpen(&BinOut, papszNameFmts[g_aBinU ## a_cBits[iFn].idxCpuEflFlavour], \
    1630                                         g_aBinU ## a_cBits[iFn].pszName), RTEXITCODE_FAILURE); \
    1631         size_t cbTests = g_aBinU ## a_cBits[iFn].pcTests[0]; \
    1632         if (!g_aBinU ## a_cBits[iFn].fBinary) \
    1633             cbTests *= sizeof(g_aBinU ## a_cBits[iFn].paTests[0]); \
    1634         GenerateBinaryWrite(&BinOut, g_aBinU ## a_cBits[iFn].paTests, cbTests); \
    1635         AssertReturn(GenerateBinaryClose(&BinOut), RTEXITCODE_FAILURE); \
    1636     } \
     1642        DUMP_TEST_ENTRY(g_aBinU ## a_cBits[iFn], papszNameFmts); \
    16371643    return RTEXITCODE_SUCCESS; \
    16381644}
    … …  
    22482254            continue; \
    22492255        IEMBINARYOUTPUT BinOut; \
    2250         AssertReturn(GenerateBinaryOpen(&BinOut, papszNameFmts[a_aSubTests[iFn].idxCpuEflFlavour], a_aSubTests[iFn].pszName), \
    2251                      RTEXITCODE_FAILURE); \
     2256        AssertReturn(GENERATE_BINARY_OPEN(&BinOut, papszNameFmts, a_aSubTests[iFn]), RTEXITCODE_FAILURE); \
    22522257        for (uint32_t iTest = 0; iTest < cTests; iTest++ ) \
    22532258        { \
    … …  
    22692274{ \
    22702275    for (size_t iFn = 0; iFn < RT_ELEMENTS(a_aSubTests); iFn++) \
    2271     { \
    2272         AssertReturn(DECOMPRESS_TESTS(a_aSubTests[iFn]), RTEXITCODE_FAILURE); \
    2273         IEMBINARYOUTPUT BinOut; \
    2274         AssertReturn(GenerateBinaryOpen(&BinOut, papszNameFmts[a_aSubTests[iFn].idxCpuEflFlavour], a_aSubTests[iFn].pszName), \
    2275                      RTEXITCODE_FAILURE); \
    2276         size_t cbTests = a_aSubTests[iFn].pcTests[0]; \
    2277         if (!a_aSubTests[iFn].fBinary) \
    2278             cbTests *= sizeof(a_aSubTests[iFn].paTests[0]); \
    2279         GenerateBinaryWrite(&BinOut, a_aSubTests[iFn].paTests, cbTests); \
    2280         AssertReturn(GenerateBinaryClose(&BinOut), RTEXITCODE_FAILURE); \
    2281     } \
     2276        DUMP_TEST_ENTRY(a_aSubTests[iFn], papszNameFmts); \
    22822277    return RTEXITCODE_SUCCESS; \
    22832278}
    … …  
    23842379    { \
    23852380        IEMBINARYOUTPUT BinOut; \
    2386         AssertReturn(GenerateBinaryOpen(&BinOut, papszNameFmts[0], g_aUnaryU ## a_cBits[iFn].pszName), RTEXITCODE_FAILURE); \
     2381        AssertReturn(GENERATE_BINARY_OPEN(&BinOut, papszNameFmts, g_aUnaryU ## a_cBits[iFn]), RTEXITCODE_FAILURE); \
    23872382        for (uint32_t iTest = 0; iTest < cTests; iTest++ ) \
    23882383        { \
    … …  
    24042399{ \
    24052400    for (size_t iFn = 0; iFn < RT_ELEMENTS(g_aUnaryU ## a_cBits); iFn++) \
    2406     { \
    2407         AssertReturn(DECOMPRESS_TESTS(g_aUnaryU ## a_cBits[iFn]), RTEXITCODE_FAILURE); \
    2408         IEMBINARYOUTPUT BinOut; \
    2409         AssertReturn(GenerateBinaryOpen(&BinOut, papszNameFmts[0], g_aUnaryU ## a_cBits[iFn].pszName), RTEXITCODE_FAILURE); \
    2410         uint32_t cbTests = g_aUnaryU ## a_cBits[iFn].pcTests[0]; \
    2411         if (!g_aUnaryU ## a_cBits[iFn].fBinary) \
    2412             cbTests *= sizeof(g_aUnaryU ## a_cBits[iFn].paTests[0]); \
    2413         GenerateBinaryWrite(&BinOut, g_aUnaryU ## a_cBits[iFn].paTests, cbTests); \
    2414         AssertReturn(GenerateBinaryClose(&BinOut), RTEXITCODE_FAILURE); \
    2415     } \
     2401        DUMP_TEST_ENTRY(g_aUnaryU ## a_cBits[iFn], papszNameFmts); \
    24162402    return RTEXITCODE_SUCCESS; \
    24172403}
    … …  
    25222508            continue; \
    25232509        IEMBINARYOUTPUT BinOut; \
    2524         AssertReturn(GenerateBinaryOpen(&BinOut, papszNameFmts[a_aSubTests[iFn].idxCpuEflFlavour], a_aSubTests[iFn].pszName), \
    2525                      RTEXITCODE_FAILURE); \
     2510        AssertReturn(GENERATE_BINARY_OPEN(&BinOut, papszNameFmts, a_aSubTests[iFn]), RTEXITCODE_FAILURE); \
    25262511        for (uint32_t iTest = 0; iTest < cTests; iTest++ ) \
    25272512        { \
    … …  
    25492534{ \
    25502535    for (size_t iFn = 0; iFn < RT_ELEMENTS(a_aSubTests); iFn++) \
    2551     { \
    2552         AssertReturn(DECOMPRESS_TESTS(a_aSubTests[iFn]), RTEXITCODE_FAILURE); \
    2553         IEMBINARYOUTPUT BinOut; \
    2554         AssertReturn(GenerateBinaryOpen(&BinOut, papszNameFmts[a_aSubTests[iFn].idxCpuEflFlavour], a_aSubTests[iFn].pszName), \
    2555                      RTEXITCODE_FAILURE); \
    2556         uint32_t cbTests = a_aSubTests[iFn].pcTests[0]; \
    2557         if (!a_aSubTests[iFn].fBinary) \
    2558             cbTests *= sizeof(a_aSubTests[iFn].paTests[0]); \
    2559         GenerateBinaryWrite(&BinOut, a_aSubTests[iFn].paTests, cbTests); \
    2560         AssertReturn(GenerateBinaryClose(&BinOut), RTEXITCODE_FAILURE); \
    2561     } \
     2536            DUMP_TEST_ENTRY(a_aSubTests[iFn], papszNameFmts); \
    25622537    return RTEXITCODE_SUCCESS; \
    25632538}
    … …  
    26982673            continue;
    26992674        IEMBINARYOUTPUT BinOut; \
    2700         AssertReturn(GenerateBinaryOpen(&BinOut, papszNameFmts[g_aMulDivU8[iFn].idxCpuEflFlavour], g_aMulDivU8[iFn].pszName),
    2701                      RTEXITCODE_FAILURE);
     2675        AssertReturn(GENERATE_BINARY_OPEN(&BinOut, papszNameFmts, g_aMulDivU8[iFn]), RTEXITCODE_FAILURE); \
    27022676        for (uint32_t iTest = 0; iTest < cTests; iTest++ )
    27032677        {
    … …  
    27182692{
    27192693    for (size_t iFn = 0; iFn < RT_ELEMENTS(g_aMulDivU8); iFn++)
    2720     {
    2721         AssertReturn(DECOMPRESS_TESTS(g_aMulDivU8[iFn]), RTEXITCODE_FAILURE);
    2722         IEMBINARYOUTPUT BinOut;
    2723         AssertReturn(GenerateBinaryOpen(&BinOut, papszNameFmts[g_aMulDivU8[iFn].idxCpuEflFlavour], g_aMulDivU8[iFn].pszName),
    2724                      RTEXITCODE_FAILURE);
    2725         uint32_t cbTests = g_aMulDivU8[iFn].pcTests[0];
    2726         if (!g_aMulDivU8[iFn].fBinary)
    2727             cbTests *= sizeof(g_aMulDivU8[iFn].paTests[0]);
    2728         GenerateBinaryWrite(&BinOut, g_aMulDivU8[iFn].paTests, cbTests);
    2729         AssertReturn(GenerateBinaryClose(&BinOut), RTEXITCODE_FAILURE);
    2730     }
     2694        DUMP_TEST_ENTRY(g_aMulDivU8[iFn], papszNameFmts);
    27312695    return RTEXITCODE_SUCCESS;
    27322696}
    … …  
    27872751            continue; \
    27882752        IEMBINARYOUTPUT BinOut; \
    2789         AssertReturn(GenerateBinaryOpen(&BinOut, papszNameFmts[a_aSubTests[iFn].idxCpuEflFlavour], a_aSubTests[iFn].pszName), \
    2790                      RTEXITCODE_FAILURE); \
     2753        AssertReturn(GENERATE_BINARY_OPEN(&BinOut, papszNameFmts, a_aSubTests[iFn]), RTEXITCODE_FAILURE); \
    27912754        for (uint32_t iTest = 0; iTest < cTests; iTest++ ) \
    27922755        { \
    … …  
    28092772{ \
    28102773    for (size_t iFn = 0; iFn < RT_ELEMENTS(a_aSubTests); iFn++) \
    2811     { \
    2812         AssertReturn(DECOMPRESS_TESTS(a_aSubTests[iFn]), RTEXITCODE_FAILURE); \
    2813         IEMBINARYOUTPUT BinOut; \
    2814         AssertReturn(GenerateBinaryOpen(&BinOut, papszNameFmts[a_aSubTests[iFn].idxCpuEflFlavour], a_aSubTests[iFn].pszName), \
    2815                      RTEXITCODE_FAILURE); \
    2816         uint32_t cbTests = a_aSubTests[iFn].pcTests[0]; \
    2817         if (!a_aSubTests[iFn].fBinary) \
    2818             cbTests *= sizeof(a_aSubTests[iFn].paTests[0]); \
    2819         GenerateBinaryWrite(&BinOut, a_aSubTests[iFn].paTests, cbTests); \
    2820         AssertReturn(GenerateBinaryClose(&BinOut), RTEXITCODE_FAILURE); \
    2821     } \
     2774        DUMP_TEST_ENTRY(a_aSubTests[iFn], papszNameFmts); \
    28222775    return RTEXITCODE_SUCCESS; \
    28232776}
     2777
    28242778#else
    28252779# define GEN_MULDIV(a_cBits, a_Fmt, a_TestType, a_aSubTests)
    … …  
    29922946
    29932947#ifdef TSTIEMAIMPL_WITH_GENERATOR
    2994 static void FpuLdConstGenerate(PRTSTREAM pOut, uint32_t cTests)
     2948static RTEXITCODE FpuLdConstGenerate(uint32_t cTests, const char * const *papszNameFmts)
    29952949{
    29962950    X86FXSTATE State;
    … …  
    29982952    for (size_t iFn = 0; iFn < RT_ELEMENTS(g_aFpuLdConst); iFn++)
    29992953    {
    3000         GenerateArrayStart(pOut, g_aFpuLdConst[iFn].pszName, "FPU_LD_CONST_TEST_T");
     2954        IEMBINARYOUTPUT BinOut;
     2955        AssertReturn(GENERATE_BINARY_OPEN(&BinOut, papszNameFmts, g_aFpuLdConst[iFn]), RTEXITCODE_FAILURE);
    30012956        for (uint32_t iTest = 0; iTest < cTests; iTest += 4)
    30022957        {
    … …  
    30092964                State.FCW = (State.FCW & ~X86_FCW_RC_MASK) | (iRounding << X86_FCW_RC_SHIFT);
    30102965                g_aFpuLdConst[iFn].pfn(&State, &Res);
    3011                 RTStrmPrintf(pOut, "    { %#06x, %#06x, %#06x, %s }, /* #%u */\n",
    3012                              State.FCW, State.FSW, Res.FSW, GenFormatR80(&Res.r80Result), iTest + iRounding);
     2966                FPU_LD_CONST_TEST_T const Test = { State.FCW, State.FSW, Res.FSW, Res.r80Result };
     2967                GenerateBinaryWrite(&BinOut, &Test, sizeof(Test));
    30132968            }
    30142969        }
    3015         GenerateArrayEnd(pOut, g_aFpuLdConst[iFn].pszName);
    3016     }
     2970        AssertReturn(GenerateBinaryClose(&BinOut), RTEXITCODE_FAILURE);
     2971    }
     2972    return RTEXITCODE_SUCCESS;
     2973}
     2974
     2975static RTEXITCODE FpuLdConstDumpAll(const char * const *papszNameFmts)
     2976{
     2977    for (size_t iFn = 0; iFn < RT_ELEMENTS(g_aFpuLdConst); iFn++)
     2978        DUMP_TEST_ENTRY(g_aFpuLdConst[iFn], papszNameFmts);
     2979    return RTEXITCODE_SUCCESS;
    30172980}
    30182981#endif
    … …  
    30683031#ifdef TSTIEMAIMPL_WITH_GENERATOR
    30693032# define GEN_FPU_LOAD(a_cBits, a_rdTypeIn, a_aSubTests, a_TestType) \
    3070 static void FpuLdR ## a_cBits ## Generate(PRTSTREAM pOut, uint32_t cTests) \
     3033static RTEXITCODE FpuLdR ## a_cBits ## Generate(uint32_t cTests, const char * const *papszNameFmts) \
    30713034{ \
    30723035    X86FXSTATE State; \
    … …  
    30743037    for (size_t iFn = 0; iFn < RT_ELEMENTS(a_aSubTests); iFn++) \
    30753038    { \
    3076         GenerateArrayStart(pOut, a_aSubTests[iFn].pszName, #a_TestType); \
     3039        IEMBINARYOUTPUT BinOut; \
     3040        AssertReturn(GENERATE_BINARY_OPEN(&BinOut, papszNameFmts, a_aSubTests[iFn]), RTEXITCODE_FAILURE); \
    30773041        for (uint32_t iTest = 0; iTest < cTests; iTest++) \
    30783042        { \
    … …  
    30863050                State.FCW = (State.FCW & ~X86_FCW_RC_MASK) | (iRounding << X86_FCW_RC_SHIFT); \
    30873051                a_aSubTests[iFn].pfn(&State, &Res, &InVal); \
    3088                 RTStrmPrintf(pOut, "    { %#06x, %#06x, %#06x, %s, %s }, /* #%u/%u */\n", \
    3089                              State.FCW, State.FSW, Res.FSW, GenFormatR80(&Res.r80Result), \
    3090                              GenFormatR ## a_cBits(&InVal), iTest, iRounding); \
     3052                a_TestType const Test = { State.FCW, State.FSW, Res.FSW, Res.r80Result, InVal }; \
     3053                GenerateBinaryWrite(&BinOut, &Test, sizeof(Test)); \
    30913054            } \
    30923055        } \
    3093         GenerateArrayEnd(pOut, a_aSubTests[iFn].pszName); \
     3056        AssertReturn(GenerateBinaryClose(&BinOut), RTEXITCODE_FAILURE); \
    30943057    } \
     3058    return RTEXITCODE_SUCCESS; \
     3059} \
     3060static RTEXITCODE FpuLdR ## a_cBits ## DumpAll(const char * const *papszNameFmts) \
     3061{ \
     3062    for (size_t iFn = 0; iFn < RT_ELEMENTS(a_aSubTests); iFn++) \
     3063        DUMP_TEST_ENTRY(a_aSubTests[iFn], papszNameFmts); \
     3064    return RTEXITCODE_SUCCESS; \
    30953065}
    30963066#else
    … …  
    31553125
    31563126#ifdef TSTIEMAIMPL_WITH_GENERATOR
    3157 static void FpuLdMemGenerate(PRTSTREAM pOut, uint32_t cTests)
    3158 {
    3159     FpuLdR80Generate(pOut, cTests);
    3160     FpuLdR64Generate(pOut, cTests);
    3161     FpuLdR32Generate(pOut, cTests);
     3127static RTEXITCODE FpuLdMemGenerate(uint32_t cTests, const char * const *papszNameFmts)
     3128{
     3129    RTEXITCODE rcExit = FpuLdR80Generate(cTests, papszNameFmts);
     3130    if (rcExit == RTEXITCODE_SUCCESS)
     3131        rcExit = FpuLdR64Generate(cTests, papszNameFmts);
     3132    if (rcExit == RTEXITCODE_SUCCESS)
     3133        rcExit = FpuLdR32Generate(cTests, papszNameFmts);
     3134    return rcExit;
     3135}
     3136
     3137static RTEXITCODE FpuLdMemDumpAll(const char * const *papszNameFmts)
     3138{
     3139    RTEXITCODE rcExit = FpuLdR80DumpAll(papszNameFmts);
     3140    if (rcExit == RTEXITCODE_SUCCESS)
     3141        rcExit = FpuLdR64DumpAll(papszNameFmts);
     3142    if (rcExit == RTEXITCODE_SUCCESS)
     3143        rcExit = FpuLdR32DumpAll(papszNameFmts);
     3144    return rcExit;
    31623145}
    31633146#endif
    … …  
    31763159#ifdef TSTIEMAIMPL_WITH_GENERATOR
    31773160# define GEN_FPU_LOAD_INT(a_cBits, a_iTypeIn, a_szFmtIn, a_aSubTests, a_TestType) \
    3178 static void FpuLdI ## a_cBits ## Generate(PRTSTREAM pOut, uint32_t cTests) \
     3161static RTEXITCODE FpuLdI ## a_cBits ## Generate(uint32_t cTests, const char * const *papszNameFmts) \
    31793162{ \
    31803163    X86FXSTATE State; \
    … …  
    31823165    for (size_t iFn = 0; iFn < RT_ELEMENTS(a_aSubTests); iFn++) \
    31833166    { \
    3184         GenerateArrayStart(pOut, a_aSubTests[iFn].pszName, #a_TestType); \
     3167        IEMBINARYOUTPUT BinOut; \
     3168        AssertReturn(GENERATE_BINARY_OPEN(&BinOut, papszNameFmts, a_aSubTests[iFn]), RTEXITCODE_FAILURE); \
    31853169        for (uint32_t iTest = 0; iTest < cTests; iTest++) \
    31863170        { \
    … …  
    31943178                State.FCW = (State.FCW & ~X86_FCW_RC_MASK) | (iRounding << X86_FCW_RC_SHIFT); \
    31953179                a_aSubTests[iFn].pfn(&State, &Res, &InVal); \
    3196                 RTStrmPrintf(pOut, "    { %#06x, %#06x, %#06x, %s, " a_szFmtIn " }, /* #%u/%u */\n", \
    3197                              State.FCW, State.FSW, Res.FSW, GenFormatR80(&Res.r80Result), InVal, iTest, iRounding); \
     3180                a_TestType const Test = { State.FCW, State.FSW, Res.FSW, Res.r80Result }; \
     3181                GenerateBinaryWrite(&BinOut, &Test, sizeof(Test)); \
    31983182            } \
    31993183        } \
    3200         GenerateArrayEnd(pOut, a_aSubTests[iFn].pszName); \
     3184        AssertReturn(GenerateBinaryClose(&BinOut), RTEXITCODE_FAILURE); \
    32013185    } \
     3186    return RTEXITCODE_SUCCESS; \
     3187} \
     3188static RTEXITCODE FpuLdI ## a_cBits ## DumpAll(const char * const *papszNameFmts) \
     3189{ \
     3190    for (size_t iFn = 0; iFn < RT_ELEMENTS(a_aSubTests); iFn++) \
     3191        DUMP_TEST_ENTRY(a_aSubTests[iFn], papszNameFmts); \
     3192    return RTEXITCODE_SUCCESS; \
    32023193}
    32033194#else
    … …  
    32613252
    32623253#ifdef TSTIEMAIMPL_WITH_GENERATOR
    3263 static void FpuLdIntGenerate(PRTSTREAM pOut, uint32_t cTests)
    3264 {
    3265     FpuLdI64Generate(pOut, cTests);
    3266     FpuLdI32Generate(pOut, cTests);
    3267     FpuLdI16Generate(pOut, cTests);
     3254static RTEXITCODE FpuLdIntGenerate(uint32_t cTests, const char * const *papszNameFmts)
     3255{
     3256    RTEXITCODE rcExit = FpuLdI64Generate(cTests, papszNameFmts);
     3257    if (rcExit == RTEXITCODE_SUCCESS)
     3258        rcExit = FpuLdI32Generate(cTests, papszNameFmts);
     3259    if (rcExit == RTEXITCODE_SUCCESS)
     3260        rcExit = FpuLdI16Generate(cTests, papszNameFmts);
     3261    return rcExit;
     3262}
     3263
     3264static RTEXITCODE FpuLdIntDumpAll(const char * const *papszNameFmts)
     3265{
     3266    RTEXITCODE rcExit = FpuLdI64DumpAll(papszNameFmts);
     3267    if (rcExit == RTEXITCODE_SUCCESS)
     3268        rcExit = FpuLdI32DumpAll(papszNameFmts);
     3269    if (rcExit == RTEXITCODE_SUCCESS)
     3270        rcExit = FpuLdI16DumpAll(papszNameFmts);
     3271    return rcExit;
    32683272}
    32693273#endif
    … …  
    32903294
    32913295#ifdef TSTIEMAIMPL_WITH_GENERATOR
    3292 static void FpuLdD80Generate(PRTSTREAM pOut, uint32_t cTests)
     3296static RTEXITCODE FpuLdD80Generate(uint32_t cTests, const char * const *papszNameFmts)
    32933297{
    32943298    X86FXSTATE State;
    … …  
    32963300    for (size_t iFn = 0; iFn < RT_ELEMENTS(g_aFpuLdD80); iFn++)
    32973301    {
    3298         GenerateArrayStart(pOut, g_aFpuLdD80[iFn].pszName, "FPU_D80_IN_TEST_T");
     3302        IEMBINARYOUTPUT BinOut;
     3303        AssertReturn(GENERATE_BINARY_OPEN(&BinOut, papszNameFmts, g_aFpuLdD80[iFn]), RTEXITCODE_FAILURE);
    32993304        for (uint32_t iTest = 0; iTest < cTests; iTest++)
    33003305        {
    … …  
    33083313                State.FCW = (State.FCW & ~X86_FCW_RC_MASK) | (iRounding << X86_FCW_RC_SHIFT);
    33093314                g_aFpuLdD80[iFn].pfn(&State, &Res, &InVal);
    3310                 RTStrmPrintf(pOut, "    { %#06x, %#06x, %#06x, %s, %s }, /* #%u/%u */\n",
    3311                              State.FCW, State.FSW, Res.FSW, GenFormatR80(&Res.r80Result), GenFormatD80(&InVal),
    3312                              iTest, iRounding);
     3315                FPU_D80_IN_TEST_T const Test = { State.FCW, State.FSW, Res.FSW, Res.r80Result, InVal };
     3316                GenerateBinaryWrite(&BinOut, &Test, sizeof(Test));
    33133317            }
    33143318        }
    3315         GenerateArrayEnd(pOut, g_aFpuLdD80[iFn].pszName);
    3316     }
     3319        AssertReturn(GenerateBinaryClose(&BinOut), RTEXITCODE_FAILURE);
     3320    }
     3321    return RTEXITCODE_SUCCESS;
     3322}
     3323static RTEXITCODE FpuLdD80DumpAll(const char * const *papszNameFmts)
     3324{
     3325    for (size_t iFn = 0; iFn < RT_ELEMENTS(g_aFpuLdD80); iFn++)
     3326        DUMP_TEST_ENTRY(g_aFpuLdD80[iFn], papszNameFmts);
     3327    return RTEXITCODE_SUCCESS;
    33173328}
    33183329#endif
    … …  
    33843395};
    33853396# define GEN_FPU_STORE(a_cBits, a_rdType, a_aSubTests, a_TestType) \
    3386 static void FpuStR ## a_cBits ## Generate(PRTSTREAM pOut, uint32_t cTests) \
     3397static RTEXITCODE FpuStR ## a_cBits ## Generate(uint32_t cTests, const char * const *papszNameFmts) \
    33873398{ \
    33883399    uint32_t const cTotalTests = cTests + RT_ELEMENTS(g_aFpuStR ## a_cBits ## Specials); \
    … …  
    33913402    for (size_t iFn = 0; iFn < RT_ELEMENTS(a_aSubTests); iFn++) \
    33923403    { \
    3393         GenerateArrayStart(pOut, a_aSubTests[iFn].pszName, #a_TestType); \
     3404        IEMBINARYOUTPUT BinOut; \
     3405        AssertReturn(GENERATE_BINARY_OPEN(&BinOut, papszNameFmts, a_aSubTests[iFn]), RTEXITCODE_FAILURE); \
    33943406        for (uint32_t iTest = 0; iTest < cTotalTests; iTest++) \
    33953407        { \
    … …  
    34143426                    State.FCW |= (iMask >> 1) << X86_FCW_OM_BIT; \
    34153427                    a_aSubTests[iFn].pfn(&State, &uFswOut, &OutVal, &InVal); \
    3416                     RTStrmPrintf(pOut, "    { %#06x, %#06x, %#06x, %s, %s }, /* #%u/%u/%u */\n", \
    3417                                  State.FCW, State.FSW, uFswOut, GenFormatR80(&InVal), \
    3418                                  GenFormatR ## a_cBits(&OutVal), iTest, iRounding, iMask); \
     3428                    a_TestType const Test = { State.FCW, State.FSW, uFswOut, InVal, OutVal }; \
     3429                    GenerateBinaryWrite(&BinOut, &Test, sizeof(Test)); \
    34193430                } \
    34203431            } \
    34213432        } \
    3422         GenerateArrayEnd(pOut, a_aSubTests[iFn].pszName); \
     3433        AssertReturn(GenerateBinaryClose(&BinOut), RTEXITCODE_FAILURE); \
    34233434    } \
     3435    return RTEXITCODE_SUCCESS; \
     3436} \
     3437static RTEXITCODE FpuStR ## a_cBits ## DumpAll(const char * const *papszNameFmts) \
     3438{ \
     3439    for (size_t iFn = 0; iFn < RT_ELEMENTS(a_aSubTests); iFn++) \
     3440        DUMP_TEST_ENTRY(a_aSubTests[iFn], papszNameFmts); \
     3441    return RTEXITCODE_SUCCESS; \
    34243442}
    34253443#else
    … …  
    34883506
    34893507#ifdef TSTIEMAIMPL_WITH_GENERATOR
    3490 static void FpuStMemGenerate(PRTSTREAM pOut, uint32_t cTests)
    3491 {
    3492     FpuStR80Generate(pOut, cTests);
    3493     FpuStR64Generate(pOut, cTests);
    3494     FpuStR32Generate(pOut, cTests);
     3508static RTEXITCODE FpuStMemGenerate(uint32_t cTests, const char * const *papszNameFmts)
     3509{
     3510    RTEXITCODE rcExit = FpuStR80Generate(cTests, papszNameFmts);
     3511    if (rcExit == RTEXITCODE_SUCCESS)
     3512        rcExit = FpuStR64Generate(cTests, papszNameFmts);
     3513    if (rcExit == RTEXITCODE_SUCCESS)
     3514        rcExit = FpuStR32Generate(cTests, papszNameFmts);
     3515    return rcExit;
     3516}
     3517
     3518static RTEXITCODE FpuStMemDumpAll(const char * const *papszNameFmts)
     3519{
     3520    RTEXITCODE rcExit = FpuStR80DumpAll(papszNameFmts);
     3521    if (rcExit == RTEXITCODE_SUCCESS)
     3522        rcExit = FpuStR64DumpAll(papszNameFmts);
     3523    if (rcExit == RTEXITCODE_SUCCESS)
     3524        rcExit = FpuStR32DumpAll(papszNameFmts);
     3525    return rcExit;
    34953526}
    34963527#endif
    … …  
    36203651
    36213652# define GEN_FPU_STORE_INT(a_cBits, a_iType, a_szFmt, a_aSubTests, a_TestType) \
    3622 static void FpuStI ## a_cBits ## Generate(PRTSTREAM pOut, PRTSTREAM pOutCpu, uint32_t cTests) \
     3653static RTEXITCODE FpuStI ## a_cBits ## Generate(uint32_t cTests, const char * const *papszNameFmts) \
    36233654{ \
    36243655    X86FXSTATE State; \
    … …  
    36283659        PFNIEMAIMPLFPUSTR80TOI ## a_cBits const pfn    = a_aSubTests[iFn].pfnNative \
    36293660                                                       ? a_aSubTests[iFn].pfnNative : a_aSubTests[iFn].pfn; \
    3630         PRTSTREAM                               pOutFn = pOut; \
    3631         if (a_aSubTests[iFn].idxCpuEflFlavour != IEMTARGETCPU_EFL_BEHAVIOR_NATIVE) \
    3632         { \
    3633             if (a_aSubTests[iFn].idxCpuEflFlavour != g_idxCpuEflFlavour) \
     3661        if (   a_aSubTests[iFn].idxCpuEflFlavour != IEMTARGETCPU_EFL_BEHAVIOR_NATIVE \
     3662            && a_aSubTests[iFn].idxCpuEflFlavour != g_idxCpuEflFlavour) \
    36343663                continue; \
    3635             pOutFn = pOutCpu; \
    3636         } \
    36373664        \
    3638         GenerateArrayStart(pOutFn, a_aSubTests[iFn].pszName, #a_TestType); \
     3665        IEMBINARYOUTPUT BinOut; \
     3666        AssertReturn(GENERATE_BINARY_OPEN(&BinOut, papszNameFmts, a_aSubTests[iFn]), RTEXITCODE_FAILURE); \
    36393667        uint32_t const cTotalTests = cTests + RT_ELEMENTS(g_aFpuStI ## a_cBits ## Specials); \
    36403668        for (uint32_t iTest = 0; iTest < cTotalTests; iTest++) \
    … …  
    36583686                    State.FCW |= (iMask >> 1) << X86_FCW_OM_BIT; \
    36593687                    pfn(&State, &uFswOut, &iOutVal, &InVal); \
    3660                     RTStrmPrintf(pOutFn, "    { %#06x, %#06x, %#06x, %s, %s }, /* #%u/%u/%u */\n", \
    3661                                  State.FCW, State.FSW, uFswOut, GenFormatR80(&InVal), \
    3662                                  GenFormatI ## a_cBits(iOutVal), iTest, iRounding, iMask); \
     3688                    a_TestType const Test = { State.FCW, State.FSW, uFswOut, InVal, iOutVal }; \
     3689                    GenerateBinaryWrite(&BinOut, &Test, sizeof(Test)); \
    36633690                } \
    36643691            } \
    36653692        } \
    3666         GenerateArrayEnd(pOutFn, a_aSubTests[iFn].pszName); \
     3693        AssertReturn(GenerateBinaryClose(&BinOut), RTEXITCODE_FAILURE); \
    36673694    } \
     3695    return RTEXITCODE_SUCCESS; \
     3696} \
     3697static RTEXITCODE FpuStI ## a_cBits ## DumpAll(const char * const *papszNameFmts) \
     3698{ \
     3699    for (size_t iFn = 0; iFn < RT_ELEMENTS(a_aSubTests); iFn++) \
     3700        DUMP_TEST_ENTRY(a_aSubTests[iFn], papszNameFmts); \
     3701    return RTEXITCODE_SUCCESS; \
    36683702}
    36693703#else
    … …  
    37223756
    37233757#ifdef TSTIEMAIMPL_WITH_GENERATOR
    3724 static void FpuStIntGenerate(PRTSTREAM pOut, PRTSTREAM pOutCpu, uint32_t cTests)
    3725 {
    3726     FpuStI64Generate(pOut, pOutCpu, cTests);
    3727     FpuStI32Generate(pOut, pOutCpu, cTests);
    3728     FpuStI16Generate(pOut, pOutCpu, cTests);
     3758static RTEXITCODE FpuStIntGenerate(uint32_t cTests, const char * const *papszNameFmts)
     3759{
     3760    RTEXITCODE rcExit = FpuStI64Generate(cTests, papszNameFmts);
     3761    if (rcExit == RTEXITCODE_SUCCESS)
     3762        rcExit = FpuStI32Generate(cTests, papszNameFmts);
     3763    if (rcExit == RTEXITCODE_SUCCESS)
     3764        rcExit = FpuStI16Generate(cTests, papszNameFmts);
     3765    return rcExit;
     3766}
     3767static RTEXITCODE FpuStIntDumpAll(const char * const *papszNameFmts)
     3768{
     3769    RTEXITCODE rcExit = FpuStI64DumpAll(papszNameFmts);
     3770    if (rcExit == RTEXITCODE_SUCCESS)
     3771        rcExit = FpuStI32DumpAll(papszNameFmts);
     3772    if (rcExit == RTEXITCODE_SUCCESS)
     3773        rcExit = FpuStI16DumpAll(papszNameFmts);
     3774    return rcExit;
    37293775}
    37303776#endif
    … …  
    37513797
    37523798#ifdef TSTIEMAIMPL_WITH_GENERATOR
    3753 static void FpuStD80Generate(PRTSTREAM pOut, uint32_t cTests)
     3799static RTEXITCODE FpuStD80Generate(uint32_t cTests, const char * const *papszNameFmts)
    37543800{
    37553801    static RTFLOAT80U const s_aSpecials[] =
    … …  
    37733819    for (size_t iFn = 0; iFn < RT_ELEMENTS(g_aFpuStD80); iFn++)
    37743820    {
    3775         GenerateArrayStart(pOut, g_aFpuStD80[iFn].pszName, "FPU_ST_D80_TEST_T");
     3821        IEMBINARYOUTPUT BinOut;
     3822        AssertReturn(GENERATE_BINARY_OPEN(&BinOut, papszNameFmts, g_aFpuStD80[iFn]), RTEXITCODE_FAILURE);
    37763823        for (uint32_t iTest = 0; iTest < cTests + RT_ELEMENTS(s_aSpecials); iTest += 1)
    37773824        {
    … …  
    37933840                    State.FCW |= (iMask >> 1) << X86_FCW_OM_BIT;
    37943841                    g_aFpuStD80[iFn].pfn(&State, &uFswOut, &OutVal, &InVal);
    3795                     RTStrmPrintf(pOut, "    { %#06x, %#06x, %#06x, %s, %s }, /* #%u/%u/%u */\n",
    3796                                  State.FCW, State.FSW, uFswOut, GenFormatR80(&InVal),
    3797                                  GenFormatD80(&OutVal), iTest, iRounding, iMask);
     3842                    FPU_ST_D80_TEST_T const Test = { State.FCW, State.FSW, uFswOut, InVal, OutVal };
     3843                    GenerateBinaryWrite(&BinOut, &Test, sizeof(Test));
    37983844                }
    37993845            }
    38003846        }
    3801         GenerateArrayEnd(pOut, g_aFpuStD80[iFn].pszName);
    3802     }
     3847        AssertReturn(GenerateBinaryClose(&BinOut), RTEXITCODE_FAILURE);
     3848    }
     3849    return RTEXITCODE_SUCCESS;
     3850}
     3851
     3852static RTEXITCODE FpuStD80DumpAll(const char * const *papszNameFmts)
     3853{
     3854    for (size_t iFn = 0; iFn < RT_ELEMENTS(g_aFpuStD80); iFn++)
     3855        DUMP_TEST_ENTRY(g_aFpuStD80[iFn], papszNameFmts);
     3856    return RTEXITCODE_SUCCESS;
    38033857}
    38043858#endif
    … …  
    38793933
    38803934#ifdef TSTIEMAIMPL_WITH_GENERATOR
    3881 static void FpuBinaryR80Generate(PRTSTREAM pOut, PRTSTREAM pOutCpu, uint32_t cTests)
     3935static RTEXITCODE FpuBinaryR80Generate(uint32_t cTests, const char * const *papszNameFmts)
    38823936{
    38833937    cTests = RT_MAX(192, cTests); /* there are 144 standard input variations */
    … …  
    39614015    {
    39624016        PFNIEMAIMPLFPUR80 const pfn = g_aFpuBinaryR80[iFn].pfnNative ? g_aFpuBinaryR80[iFn].pfnNative : g_aFpuBinaryR80[iFn].pfn;
    3963         PRTSTREAM            pOutFn = pOut;
    3964         if (g_aFpuBinaryR80[iFn].idxCpuEflFlavour != IEMTARGETCPU_EFL_BEHAVIOR_NATIVE)
    3965         {
    3966             if (g_aFpuBinaryR80[iFn].idxCpuEflFlavour != g_idxCpuEflFlavour)
    3967                 continue;
    3968             pOutFn = pOutCpu;
    3969         }
    3970 
    3971         GenerateArrayStart(pOutFn, g_aFpuBinaryR80[iFn].pszName, "FPU_BINARY_R80_TEST_T");
    3972         uint32_t iTestOutput        = 0;
     4017        if (   g_aFpuBinaryR80[iFn].idxCpuEflFlavour != IEMTARGETCPU_EFL_BEHAVIOR_NATIVE
     4018            && g_aFpuBinaryR80[iFn].idxCpuEflFlavour != g_idxCpuEflFlavour)
     4019            continue;
     4020
     4021        IEMBINARYOUTPUT BinOut;
     4022        AssertReturn(GENERATE_BINARY_OPEN(&BinOut, papszNameFmts, g_aFpuBinaryR80[iFn]), RTEXITCODE_FAILURE);
    39734023        uint32_t cNormalInputPairs  = 0;
    39744024        uint32_t cTargetRangeInputs = 0;
    … …  
    40114061                    IEMFPURESULT ResM = { RTFLOAT80U_INIT(0, 0, 0), 0 };
    40124062                    pfn(&State, &ResM, &InVal1, &InVal2);
    4013                     RTStrmPrintf(pOutFn, "    { %#06x, %#06x, %#06x, %s, %s, %s }, /* #%u/%u/%u/m = #%u */\n",
    4014                                  State.FCW | fFcwExtra, State.FSW, ResM.FSW, GenFormatR80(&InVal1), GenFormatR80(&InVal2),
    4015                                  GenFormatR80(&ResM.r80Result), iTest, iRounding, iPrecision, iTestOutput++);
     4063                    FPU_BINARY_R80_TEST_T const TestM
     4064                        = { (uint16_t)(State.FCW | fFcwExtra), State.FSW, ResM.FSW, InVal1, InVal2, ResM.r80Result };
     4065                    GenerateBinaryWrite(&BinOut, &TestM, sizeof(TestM));
    40164066
    40174067                    State.FCW = State.FCW & ~X86_FCW_MASK_ALL;
    40184068                    IEMFPURESULT ResU = { RTFLOAT80U_INIT(0, 0, 0), 0 };
    40194069                    pfn(&State, &ResU, &InVal1, &InVal2);
    4020                     RTStrmPrintf(pOutFn, "    { %#06x, %#06x, %#06x, %s, %s, %s }, /* #%u/%u/%u/u = #%u */\n",
    4021                                  State.FCW | fFcwExtra, State.FSW, ResU.FSW, GenFormatR80(&InVal1), GenFormatR80(&InVal2),
    4022                                  GenFormatR80(&ResU.r80Result), iTest, iRounding, iPrecision, iTestOutput++);
     4070                    FPU_BINARY_R80_TEST_T const TestU
     4071                        = { (uint16_t)(State.FCW | fFcwExtra), State.FSW, ResU.FSW, InVal1, InVal2, ResU.r80Result };
     4072                    GenerateBinaryWrite(&BinOut, &TestU, sizeof(TestU));
    40234073
    40244074                    uint16_t fXcpt = (ResM.FSW | ResU.FSW) & X86_FSW_XCPT_MASK & ~X86_FSW_SF;
    … …  
    40284078                        IEMFPURESULT Res1 = { RTFLOAT80U_INIT(0, 0, 0), 0 };
    40294079                        pfn(&State, &Res1, &InVal1, &InVal2);
    4030                         RTStrmPrintf(pOutFn, "    { %#06x, %#06x, %#06x, %s, %s, %s }, /* #%u/%u/%u/%#x = #%u */\n",
    4031                                      State.FCW | fFcwExtra, State.FSW, Res1.FSW, GenFormatR80(&InVal1), GenFormatR80(&InVal2),
    4032                                      GenFormatR80(&Res1.r80Result), iTest, iRounding, iPrecision, fXcpt, iTestOutput++);
     4080                        FPU_BINARY_R80_TEST_T const Test1
     4081                            = { (uint16_t)(State.FCW | fFcwExtra), State.FSW, Res1.FSW, InVal1, InVal2, Res1.r80Result };
     4082                        GenerateBinaryWrite(&BinOut, &Test1, sizeof(Test1));
     4083
    40334084                        if (((Res1.FSW & X86_FSW_XCPT_MASK) & fXcpt) != (Res1.FSW & X86_FSW_XCPT_MASK))
    40344085                        {
    … …  
    40374088                            IEMFPURESULT Res2 = { RTFLOAT80U_INIT(0, 0, 0), 0 };
    40384089                            pfn(&State, &Res2, &InVal1, &InVal2);
    4039                             RTStrmPrintf(pOutFn, "    { %#06x, %#06x, %#06x, %s, %s, %s }, /* #%u/%u/%u/%#x[!] = #%u */\n",
    4040                                          State.FCW | fFcwExtra, State.FSW, Res2.FSW, GenFormatR80(&InVal1), GenFormatR80(&InVal2),
    4041                                          GenFormatR80(&Res2.r80Result), iTest, iRounding, iPrecision, fXcpt, iTestOutput++);
     4090                            FPU_BINARY_R80_TEST_T const Test2
     4091                                = { (uint16_t)(State.FCW | fFcwExtra), State.FSW, Res2.FSW, InVal1, InVal2, Res2.r80Result };
     4092                            GenerateBinaryWrite(&BinOut, &Test2, sizeof(Test2));
    40424093                        }
    40434094                        if (!RT_IS_POWER_OF_TWO(fXcpt))
    … …  
    40484099                                    IEMFPURESULT Res3 = { RTFLOAT80U_INIT(0, 0, 0), 0 };
    40494100                                    pfn(&State, &Res3, &InVal1, &InVal2);
    4050                                     RTStrmPrintf(pOutFn, "    { %#06x, %#06x, %#06x, %s, %s, %s }, /* #%u/%u/%u/u%#x = #%u */\n",
    4051                                                  State.FCW | fFcwExtra, State.FSW, Res3.FSW, GenFormatR80(&InVal1), GenFormatR80(&InVal2),
    4052                                                  GenFormatR80(&Res3.r80Result), iTest, iRounding, iPrecision, fUnmasked, iTestOutput++);
     4101                                    FPU_BINARY_R80_TEST_T const Test3
     4102                                        = { (uint16_t)(State.FCW | fFcwExtra), State.FSW, Res3.FSW, InVal1, InVal2, Res3.r80Result };
     4103                                    GenerateBinaryWrite(&BinOut, &Test3, sizeof(Test3));
    40534104                                }
    40544105                    }
    … …  
    40654116                            IEMFPURESULT ResSeq = { RTFLOAT80U_INIT(0, 0, 0), 0 };
    40664117                            pfn(&State, &ResSeq, &ResPrev.r80Result, &InVal2);
    4067                             RTStrmPrintf(pOutFn, "    { %#06x, %#06x, %#06x, %s, %s, %s }, /* #%u/%u/%u/seq%u = #%u */\n",
    4068                                          State.FCW | fFcwExtra, State.FSW, ResSeq.FSW, GenFormatR80(&ResPrev.r80Result),
    4069                                          GenFormatR80(&InVal2), GenFormatR80(&ResSeq.r80Result),
    4070                                          iTest, iRounding, iPrecision, i + 1, iTestOutput++);
     4118                            FPU_BINARY_R80_TEST_T const TestSeq
     4119                                = { (uint16_t)(State.FCW | fFcwExtra), State.FSW, ResSeq.FSW, ResPrev.r80Result, InVal2, ResSeq.r80Result };
     4120                            GenerateBinaryWrite(&BinOut, &TestSeq, sizeof(TestSeq));
    40714121                            ResPrev = ResSeq;
    40724122                        }
    … …  
    40744124                }
    40754125        }
    4076         GenerateArrayEnd(pOutFn, g_aFpuBinaryR80[iFn].pszName);
    4077     }
     4126        AssertReturn(GenerateBinaryClose(&BinOut), RTEXITCODE_FAILURE);
     4127    }
     4128    return RTEXITCODE_SUCCESS;
     4129}
     4130
     4131static RTEXITCODE FpuBinaryR80DumpAll(const char * const *papszNameFmts)
     4132{
     4133    for (size_t iFn = 0; iFn < RT_ELEMENTS(g_aFpuBinaryR80); iFn++)
     4134        DUMP_TEST_ENTRY(g_aFpuBinaryR80[iFn], papszNameFmts);
     4135    return RTEXITCODE_SUCCESS;
    40784136}
    40794137#endif
    … …  
    41514209
    41524210# define GEN_FPU_BINARY_SMALL(a_fIntType, a_cBits, a_LoBits, a_UpBits, a_Type2, a_aSubTests, a_TestType) \
    4153 static void FpuBinary ## a_UpBits ## Generate(PRTSTREAM pOut, uint32_t cTests) \
     4211static RTEXITCODE FpuBinary ## a_UpBits ## Generate(uint32_t cTests, const char * const *papszNameFmts) \
    41544212{ \
    41554213    cTests = RT_MAX(160, cTests); /* there are 144 standard input variations for r80 by r80 */ \
    … …  
    41604218    for (size_t iFn = 0; iFn < RT_ELEMENTS(a_aSubTests); iFn++) \
    41614219    { \
    4162         GenerateArrayStart(pOut, a_aSubTests[iFn].pszName, #a_TestType); \
     4220        IEMBINARYOUTPUT BinOut; \
     4221        AssertReturn(GENERATE_BINARY_OPEN(&BinOut, papszNameFmts, a_aSubTests[iFn]), RTEXITCODE_FAILURE); \
    41634222        uint32_t cNormalInputPairs = 0; \
    41644223        for (uint32_t iTest = 0; iTest < cTests + RT_ELEMENTS(s_aFpuBinary ## a_UpBits ## Specials); iTest += 1) \
    … …  
    41914250                        IEMFPURESULT Res = { RTFLOAT80U_INIT(0, 0, 0), 0 }; \
    41924251                        a_aSubTests[iFn].pfn(&State, &Res, &InVal1, &InVal2); \
    4193                         RTStrmPrintf(pOut, "    { %#06x, %#06x, %#06x, %s, %s, %s }, /* #%u/%u/%u/%c */\n", \
    4194                                      State.FCW, State.FSW, Res.FSW, GenFormatR80(&InVal1), GenFormat ## a_UpBits(&InVal2), \
    4195                                      GenFormatR80(&Res.r80Result), iTest, iRounding, iPrecision, iMask ? 'c' : 'u'); \
     4252                        a_TestType const Test = { State.FCW, State.FSW, Res.FSW, InVal1, InVal2, Res.r80Result }; \
     4253                        GenerateBinaryWrite(&BinOut, &Test, sizeof(Test)); \
    41964254                    } \
    41974255                } \
    41984256            } \
    41994257        } \
    4200         GenerateArrayEnd(pOut, a_aSubTests[iFn].pszName); \
     4258        AssertReturn(GenerateBinaryClose(&BinOut), RTEXITCODE_FAILURE); \
    42014259    } \
     4260    return RTEXITCODE_SUCCESS; \
     4261} \
     4262static RTEXITCODE FpuBinary ## a_UpBits ## DumpAll(const char * const *papszNameFmts) \
     4263{ \
     4264    for (size_t iFn = 0; iFn < RT_ELEMENTS(a_aSubTests); iFn++) \
     4265        DUMP_TEST_ENTRY(a_aSubTests[iFn], papszNameFmts); \
     4266    return RTEXITCODE_SUCCESS; \
    42024267}
    42034268#else
    … …  
    42974362
    42984363# define GEN_FPU_BINARY_FSW(a_fIntType, a_cBits, a_UpBits, a_Type2, a_aSubTests, a_TestType) \
    4299 static void FpuBinaryFsw ## a_UpBits ## Generate(PRTSTREAM pOut, uint32_t cTests) \
     4364static RTEXITCODE FpuBinaryFsw ## a_UpBits ## Generate(uint32_t cTests, const char * const *papszNameFmts) \
    43004365{ \
    43014366    cTests = RT_MAX(160, cTests); /* there are 144 standard input variations for r80 by r80 */ \
    … …  
    43064371    for (size_t iFn = 0; iFn < RT_ELEMENTS(a_aSubTests); iFn++) \
    43074372    { \
    4308         GenerateArrayStart(pOut, a_aSubTests[iFn].pszName, #a_TestType); \
     4373        IEMBINARYOUTPUT BinOut; \
     4374        AssertReturn(GENERATE_BINARY_OPEN(&BinOut, papszNameFmts, a_aSubTests[iFn]), RTEXITCODE_FAILURE); \
    43094375        uint32_t cNormalInputPairs = 0; \
    43104376        for (uint32_t iTest = 0; iTest < cTests + RT_ELEMENTS(s_aFpuBinaryFsw ## a_UpBits ## Specials); iTest += 1) \
    … …  
    43314397                uint16_t fFswOut = 0; \
    43324398                a_aSubTests[iFn].pfn(&State, &fFswOut, &InVal1, &InVal2); \
    4333                 RTStrmPrintf(pOut, "    { %#06x, %#06x, %#06x, %s, %s }, /* #%u/%c */\n", \
    4334                              State.FCW, State.FSW, fFswOut, GenFormatR80(&InVal1), GenFormat ## a_UpBits(&InVal2), \
    4335                              iTest, iMask ? 'c' : 'u'); \
     4399                a_TestType const Test = { State.FCW, State.FSW, fFswOut, InVal1, InVal2 }; \
     4400                GenerateBinaryWrite(&BinOut, &Test, sizeof(Test)); \
    43364401            } \
    43374402        } \
    4338         GenerateArrayEnd(pOut, a_aSubTests[iFn].pszName); \
     4403        AssertReturn(GenerateBinaryClose(&BinOut), RTEXITCODE_FAILURE); \
    43394404    } \
     4405    return RTEXITCODE_SUCCESS; \
     4406} \
     4407static RTEXITCODE FpuBinaryFsw ## a_UpBits ## DumpAll(const char * const *papszNameFmts) \
     4408{ \
     4409    for (size_t iFn = 0; iFn < RT_ELEMENTS(a_aSubTests); iFn++) \
     4410        DUMP_TEST_ENTRY(a_aSubTests[iFn], papszNameFmts); \
     4411    return RTEXITCODE_SUCCESS; \
    43404412}
    43414413#else
    … …  
    44174489};
    44184490
    4419 static void FpuBinaryEflR80Generate(PRTSTREAM pOut, uint32_t cTests)
     4491static RTEXITCODE FpuBinaryEflR80Generate(uint32_t cTests, const char * const *papszNameFmts)
    44204492{
    44214493    cTests = RT_MAX(160, cTests); /* there are 144 standard input variations */
    … …  
    44264498    for (size_t iFn = 0; iFn < RT_ELEMENTS(g_aFpuBinaryEflR80); iFn++)
    44274499    {
    4428         GenerateArrayStart(pOut, g_aFpuBinaryEflR80[iFn].pszName, "FPU_BINARY_EFL_R80_TEST_T");
     4500        IEMBINARYOUTPUT BinOut;
     4501        AssertReturn(GENERATE_BINARY_OPEN(&BinOut, papszNameFmts, g_aFpuBinaryEflR80[iFn]), RTEXITCODE_FAILURE);
    44294502        uint32_t cNormalInputPairs = 0;
    44304503        for (uint32_t iTest = 0; iTest < cTests + RT_ELEMENTS(s_aFpuBinaryEflR80Specials); iTest += 1)
    … …  
    44494522                uint16_t uFswOut = 0;
    44504523                uint32_t fEflOut = g_aFpuBinaryEflR80[iFn].pfn(&State, &uFswOut, &InVal1, &InVal2);
    4451                 RTStrmPrintf(pOut, "    { %#06x, %#06x, %#06x, %s, %s, %#08x }, /* #%u/%c */\n",
    4452                              State.FCW, State.FSW, uFswOut, GenFormatR80(&InVal1), GenFormatR80(&InVal2), fEflOut,
    4453                              iTest, iMask ? 'c' : 'u');
     4524                FPU_BINARY_EFL_R80_TEST_T const Test = { State.FCW, State.FSW, uFswOut, InVal1, InVal2, fEflOut, };
     4525                GenerateBinaryWrite(&BinOut, &Test, sizeof(Test));
    44544526            }
    44554527        }
    4456         GenerateArrayEnd(pOut, g_aFpuBinaryEflR80[iFn].pszName);
    4457     }
     4528        AssertReturn(GenerateBinaryClose(&BinOut), RTEXITCODE_FAILURE);
     4529    }
     4530    return RTEXITCODE_SUCCESS;
     4531}
     4532
     4533static RTEXITCODE FpuBinaryEflR80DumpAll(const char * const *papszNameFmts)
     4534{
     4535    for (size_t iFn = 0; iFn < RT_ELEMENTS(g_aFpuBinaryEflR80); iFn++)
     4536        DUMP_TEST_ENTRY(g_aFpuBinaryEflR80[iFn], papszNameFmts);
     4537    return RTEXITCODE_SUCCESS;
    44584538}
    44594539#endif /*TSTIEMAIMPL_WITH_GENERATOR*/
    … …  
    45404620}
    45414621
    4542 static void FpuUnaryR80Generate(PRTSTREAM pOut, PRTSTREAM pOutCpu, uint32_t cTests)
     4622static RTEXITCODE FpuUnaryR80Generate(uint32_t cTests, const char * const *papszNameFmts)
    45434623{
    45444624    static RTFLOAT80U const s_aSpecials[] =
    … …  
    45614641    {
    45624642        PFNIEMAIMPLFPUR80UNARY const pfn = g_aFpuUnaryR80[iFn].pfnNative ? g_aFpuUnaryR80[iFn].pfnNative : g_aFpuUnaryR80[iFn].pfn;
    4563         PRTSTREAM                 pOutFn = pOut;
    4564         if (g_aFpuUnaryR80[iFn].idxCpuEflFlavour != IEMTARGETCPU_EFL_BEHAVIOR_NATIVE)
    4565         {
    4566             if (g_aFpuUnaryR80[iFn].idxCpuEflFlavour != g_idxCpuEflFlavour)
    4567                 continue;
    4568             pOutFn = pOutCpu;
    4569         }
    4570 
    4571         GenerateArrayStart(pOutFn, g_aFpuUnaryR80[iFn].pszName, "FPU_UNARY_R80_TEST_T");
    4572         uint32_t iTestOutput        = 0;
     4643        if (   g_aFpuUnaryR80[iFn].idxCpuEflFlavour != IEMTARGETCPU_EFL_BEHAVIOR_NATIVE
     4644            && g_aFpuUnaryR80[iFn].idxCpuEflFlavour != g_idxCpuEflFlavour)
     4645            continue;
     4646
     4647        IEMBINARYOUTPUT BinOut;
     4648        AssertReturn(GENERATE_BINARY_OPEN(&BinOut, papszNameFmts, g_aFpuUnaryR80[iFn]), RTEXITCODE_FAILURE);
    45734649        uint32_t cNormalInputs      = 0;
    45744650        uint32_t cTargetRangeInputs = 0;
    … …  
    46124688                    IEMFPURESULT ResM = { RTFLOAT80U_INIT(0, 0, 0), 0 };
    46134689                    pfn(&State, &ResM, &InVal);
    4614                     RTStrmPrintf(pOutFn, "    { %#06x, %#06x, %#06x, %s, %s }, /* #%u/%u/%u/m = #%u */\n",
    4615                                  State.FCW | fFcwExtra, State.FSW, ResM.FSW, GenFormatR80(&InVal),
    4616                                  GenFormatR80(&ResM.r80Result), iTest, iRounding, iPrecision, iTestOutput++);
     4690                    FPU_UNARY_R80_TEST_T const TestM
     4691                        = { (uint16_t)(State.FCW | fFcwExtra), State.FSW, ResM.FSW, InVal, ResM.r80Result };
     4692                    GenerateBinaryWrite(&BinOut, &TestM, sizeof(TestM));
    46174693
    46184694                    State.FCW = State.FCW & ~X86_FCW_MASK_ALL;
    46194695                    IEMFPURESULT ResU = { RTFLOAT80U_INIT(0, 0, 0), 0 };
    46204696                    pfn(&State, &ResU, &InVal);
    4621                     RTStrmPrintf(pOutFn, "    { %#06x, %#06x, %#06x, %s, %s }, /* #%u/%u/%u/u = #%u */\n",
    4622                                  State.FCW | fFcwExtra, State.FSW, ResU.FSW, GenFormatR80(&InVal),
    4623                                  GenFormatR80(&ResU.r80Result), iTest, iRounding, iPrecision, iTestOutput++);
     4697                    FPU_UNARY_R80_TEST_T const TestU
     4698                        = { (uint16_t)(State.FCW | fFcwExtra), State.FSW, ResU.FSW, InVal, ResU.r80Result };
     4699                    GenerateBinaryWrite(&BinOut, &TestU, sizeof(TestU));
    46244700
    46254701                    uint16_t fXcpt = (ResM.FSW | ResU.FSW) & X86_FSW_XCPT_MASK & ~X86_FSW_SF;
    … …  
    46294705                        IEMFPURESULT Res1 = { RTFLOAT80U_INIT(0, 0, 0), 0 };
    46304706                        pfn(&State, &Res1, &InVal);
    4631                         RTStrmPrintf(pOutFn, "    { %#06x, %#06x, %#06x, %s, %s }, /* #%u/%u/%u/%#x = #%u */\n",
    4632                                      State.FCW | fFcwExtra, State.FSW, Res1.FSW, GenFormatR80(&InVal),
    4633                                      GenFormatR80(&Res1.r80Result), iTest, iRounding, iPrecision, fXcpt, iTestOutput++);
     4707                        FPU_UNARY_R80_TEST_T const Test1
     4708                            = { (uint16_t)(State.FCW | fFcwExtra), State.FSW, Res1.FSW, InVal, Res1.r80Result };
     4709                        GenerateBinaryWrite(&BinOut, &Test1, sizeof(Test1));
    46344710                        if (((Res1.FSW & X86_FSW_XCPT_MASK) & fXcpt) != (Res1.FSW & X86_FSW_XCPT_MASK))
    46354711                        {
    … …  
    46384714                            IEMFPURESULT Res2 = { RTFLOAT80U_INIT(0, 0, 0), 0 };
    46394715                            pfn(&State, &Res2, &InVal);
    4640                             RTStrmPrintf(pOutFn, "    { %#06x, %#06x, %#06x, %s, %s }, /* #%u/%u/%u/%#x[!] = #%u */\n",
    4641                                          State.FCW | fFcwExtra, State.FSW, Res2.FSW, GenFormatR80(&InVal),
    4642                                          GenFormatR80(&Res2.r80Result), iTest, iRounding, iPrecision, fXcpt, iTestOutput++);
     4716                            FPU_UNARY_R80_TEST_T const Test2
     4717                                = { (uint16_t)(State.FCW | fFcwExtra), State.FSW, Res2.FSW, InVal, Res2.r80Result };
     4718                            GenerateBinaryWrite(&BinOut, &Test2, sizeof(Test2));
    46434719                        }
    46444720                        if (!RT_IS_POWER_OF_TWO(fXcpt))
    … …  
    46494725                                    IEMFPURESULT Res3 = { RTFLOAT80U_INIT(0, 0, 0), 0 };
    46504726                                    pfn(&State, &Res3, &InVal);
    4651                                     RTStrmPrintf(pOutFn, "    { %#06x, %#06x, %#06x, %s, %s }, /* #%u/%u/%u/u%#x = #%u */\n",
    4652                                                  State.FCW | fFcwExtra, State.FSW, Res3.FSW, GenFormatR80(&InVal),
    4653                                                  GenFormatR80(&Res3.r80Result), iTest, iRounding, iPrecision, fUnmasked, iTestOutput++);
     4727                                    FPU_UNARY_R80_TEST_T const Test3
     4728                                        = { (uint16_t)(State.FCW | fFcwExtra), State.FSW, Res3.FSW, InVal, Res3.r80Result };
     4729                                    GenerateBinaryWrite(&BinOut, &Test3, sizeof(Test3));
    46544730                                }
    46554731                    }
    46564732                }
    46574733        }
    4658         GenerateArrayEnd(pOutFn, g_aFpuUnaryR80[iFn].pszName);
    4659     }
     4734        AssertReturn(GenerateBinaryClose(&BinOut), RTEXITCODE_FAILURE);
     4735    }
     4736    return RTEXITCODE_SUCCESS;
     4737}
     4738
     4739static RTEXITCODE FpuUnaryR80DumpAll(const char * const *papszNameFmts)
     4740{
     4741    for (size_t iFn = 0; iFn < RT_ELEMENTS(g_aFpuUnaryR80); iFn++)
     4742        DUMP_TEST_ENTRY(g_aFpuUnaryR80[iFn], papszNameFmts);
     4743    return RTEXITCODE_SUCCESS;
    46604744}
    46614745#endif
    … …  
    47634847
    47644848#ifdef TSTIEMAIMPL_WITH_GENERATOR
    4765 static void FpuUnaryFswR80Generate(PRTSTREAM pOut, PRTSTREAM pOutCpu, uint32_t cTests)
     4849static RTEXITCODE FpuUnaryFswR80Generate(uint32_t cTests, const char * const *papszNameFmts)
    47664850{
    47674851    static RTFLOAT80U const s_aSpecials[] =
    … …  
    47774861        bool const                  fIsFxam = g_aFpuUnaryFswR80[iFn].uExtra == 1;
    47784862        PFNIEMAIMPLFPUR80UNARYFSW const pfn = g_aFpuUnaryFswR80[iFn].pfnNative ? g_aFpuUnaryFswR80[iFn].pfnNative : g_aFpuUnaryFswR80[iFn].pfn;
    4779         PRTSTREAM                    pOutFn = pOut;
    4780         if (g_aFpuUnaryFswR80[iFn].idxCpuEflFlavour != IEMTARGETCPU_EFL_BEHAVIOR_NATIVE)
    4781         {
    4782             if (g_aFpuUnaryFswR80[iFn].idxCpuEflFlavour != g_idxCpuEflFlavour)
    4783                 continue;
    4784             pOutFn = pOutCpu;
    4785         }
     4863        if (   g_aFpuUnaryFswR80[iFn].idxCpuEflFlavour != IEMTARGETCPU_EFL_BEHAVIOR_NATIVE
     4864            && g_aFpuUnaryFswR80[iFn].idxCpuEflFlavour != g_idxCpuEflFlavour)
     4865            continue;
    47864866        State.FTW = 0;
    47874867
    4788         GenerateArrayStart(pOutFn, g_aFpuUnaryFswR80[iFn].pszName, "FPU_UNARY_R80_TEST_T");
     4868        IEMBINARYOUTPUT BinOut;
     4869        AssertReturn(GENERATE_BINARY_OPEN(&BinOut, papszNameFmts, g_aFpuUnaryFswR80[iFn]), RTEXITCODE_FAILURE);
    47894870        uint32_t cNormalInputs = 0;
    47904871        for (uint32_t iTest = 0; iTest < cTests + RT_ELEMENTS(s_aSpecials); iTest += 1)
    … …  
    48154896                            uint16_t fFswOut = 0;
    48164897                            pfn(&State, &fFswOut, &InVal);
    4817                             RTStrmPrintf(pOutFn, "    { %#06x, %#06x, %#06x, %s }, /* #%u/%u/%u/%c */\n",
    4818                                          State.FCW, State.FSW, fFswOut, GenFormatR80(&InVal),
    4819                                          iTest, iRounding, iPrecision, iMask ? 'c' : 'u');
     4898                            FPU_UNARY_R80_TEST_T const Test = { State.FCW, State.FSW, fFswOut, InVal };
     4899                            GenerateBinaryWrite(&BinOut, &Test, sizeof(Test));
    48204900                        }
    48214901                    }
    … …  
    48294909                State.FCW = fFcw;
    48304910                pfn(&State, &fFswOut, &InVal);
    4831                 RTStrmPrintf(pOutFn, "    { %#06x, %#06x, %#06x, %s }, /* #%u%s */\n",
    4832                              fFcw | fEmpty, State.FSW, fFswOut, GenFormatR80(&InVal), iTest, fEmpty ? "/empty" : "");
     4911                FPU_UNARY_R80_TEST_T const Test = { (uint16_t)(fFcw | fEmpty), State.FSW, fFswOut, InVal };
     4912                GenerateBinaryWrite(&BinOut, &Test, sizeof(Test));
    48334913            }
    48344914        }
    4835         GenerateArrayEnd(pOutFn, g_aFpuUnaryFswR80[iFn].pszName);
    4836     }
     4915        AssertReturn(GenerateBinaryClose(&BinOut), RTEXITCODE_FAILURE);
     4916    }
     4917    return RTEXITCODE_SUCCESS;
     4918}
     4919
     4920static RTEXITCODE FpuUnaryFswR80DumpAll(const char * const *papszNameFmts)
     4921{
     4922    for (size_t iFn = 0; iFn < RT_ELEMENTS(g_aFpuUnaryFswR80); iFn++)
     4923        DUMP_TEST_ENTRY(g_aFpuUnaryFswR80[iFn], papszNameFmts);
     4924    return RTEXITCODE_SUCCESS;
    48374925}
    48384926#endif
    … …  
    48944982
    48954983#ifdef TSTIEMAIMPL_WITH_GENERATOR
    4896 static void FpuUnaryTwoR80Generate(PRTSTREAM pOut, PRTSTREAM pOutCpu, uint32_t cTests)
     4984static RTEXITCODE FpuUnaryTwoR80Generate(uint32_t cTests, const char * const *papszNameFmts)
    48974985{
    48984986    static RTFLOAT80U const s_aSpecials[] =
    … …  
    49074995    {
    49084996        PFNIEMAIMPLFPUR80UNARYTWO const pfn = g_aFpuUnaryTwoR80[iFn].pfnNative ? g_aFpuUnaryTwoR80[iFn].pfnNative : g_aFpuUnaryTwoR80[iFn].pfn;
    4909         PRTSTREAM                    pOutFn = pOut;
    4910         if (g_aFpuUnaryTwoR80[iFn].idxCpuEflFlavour != IEMTARGETCPU_EFL_BEHAVIOR_NATIVE)
    4911         {
    4912             if (g_aFpuUnaryTwoR80[iFn].idxCpuEflFlavour != g_idxCpuEflFlavour)
    4913                 continue;
    4914             pOutFn = pOutCpu;
    4915         }
    4916 
    4917         GenerateArrayStart(pOutFn, g_aFpuUnaryTwoR80[iFn].pszName, "FPU_UNARY_TWO_R80_TEST_T");
    4918         uint32_t iTestOutput        = 0;
     4997        if (   g_aFpuUnaryTwoR80[iFn].idxCpuEflFlavour != IEMTARGETCPU_EFL_BEHAVIOR_NATIVE
     4998            && g_aFpuUnaryTwoR80[iFn].idxCpuEflFlavour != g_idxCpuEflFlavour)
     4999            continue;
     5000
     5001        IEMBINARYOUTPUT BinOut;
     5002        AssertReturn(GENERATE_BINARY_OPEN(&BinOut, papszNameFmts, g_aFpuUnaryTwoR80[iFn]), RTEXITCODE_FAILURE);
    49195003        uint32_t cNormalInputs      = 0;
    49205004        uint32_t cTargetRangeInputs = 0;
    … …  
    49575041                    IEMFPURESULTTWO ResM = { RTFLOAT80U_INIT(0, 0, 0), 0, RTFLOAT80U_INIT(0, 0, 0) };
    49585042                    pfn(&State, &ResM, &InVal);
    4959                     RTStrmPrintf(pOutFn, "    { %#06x, %#06x, %#06x, %s, %s, %s }, /* #%u/%u/%u/m = #%u */\n",
    4960                                  State.FCW | fFcwExtra, State.FSW, ResM.FSW, GenFormatR80(&InVal), GenFormatR80(&ResM.r80Result1),
    4961                                  GenFormatR80(&ResM.r80Result2), iTest, iRounding, iPrecision, iTestOutput++);
     5043                    FPU_UNARY_TWO_R80_TEST_T const TestM
     5044                        = { (uint16_t)(State.FCW | fFcwExtra), State.FSW, ResM.FSW, InVal, ResM.r80Result1, ResM.r80Result2 };
     5045                    GenerateBinaryWrite(&BinOut, &TestM, sizeof(TestM));
    49625046
    49635047                    State.FCW = State.FCW & ~X86_FCW_MASK_ALL;
    49645048                    IEMFPURESULTTWO ResU = { RTFLOAT80U_INIT(0, 0, 0), 0, RTFLOAT80U_INIT(0, 0, 0) };
    49655049                    pfn(&State, &ResU, &InVal);
    4966                     RTStrmPrintf(pOutFn, "    { %#06x, %#06x, %#06x, %s, %s, %s }, /* #%u/%u/%u/u = #%u */\n",
    4967                                  State.FCW | fFcwExtra, State.FSW, ResU.FSW, GenFormatR80(&InVal), GenFormatR80(&ResU.r80Result1),
    4968                                  GenFormatR80(&ResU.r80Result2), iTest, iRounding, iPrecision, iTestOutput++);
     5050                    FPU_UNARY_TWO_R80_TEST_T const TestU
     5051                        = { (uint16_t)(State.FCW | fFcwExtra), State.FSW, ResU.FSW, InVal, ResU.r80Result1, ResU.r80Result2 };
     5052                    GenerateBinaryWrite(&BinOut, &TestU, sizeof(TestU));
    49695053
    49705054                    uint16_t fXcpt = (ResM.FSW | ResU.FSW) & X86_FSW_XCPT_MASK & ~X86_FSW_SF;
    … …  
    49745058                        IEMFPURESULTTWO Res1 = { RTFLOAT80U_INIT(0, 0, 0), 0, RTFLOAT80U_INIT(0, 0, 0) };
    49755059                        pfn(&State, &Res1, &InVal);
    4976                         RTStrmPrintf(pOutFn, "    { %#06x, %#06x, %#06x, %s, %s, %s }, /* #%u/%u/%u/%#x = #%u */\n",
    4977                                      State.FCW | fFcwExtra, State.FSW, Res1.FSW, GenFormatR80(&InVal), GenFormatR80(&Res1.r80Result1),
    4978                                      GenFormatR80(&Res1.r80Result2), iTest, iRounding, iPrecision, fXcpt, iTestOutput++);
     5060                        FPU_UNARY_TWO_R80_TEST_T const Test1
     5061                            = { (uint16_t)(State.FCW | fFcwExtra), State.FSW, Res1.FSW, InVal, Res1.r80Result1, Res1.r80Result2 };
     5062                        GenerateBinaryWrite(&BinOut, &Test1, sizeof(Test1));
     5063
    49795064                        if (((Res1.FSW & X86_FSW_XCPT_MASK) & fXcpt) != (Res1.FSW & X86_FSW_XCPT_MASK))
    49805065                        {
    … …  
    49835068                            IEMFPURESULTTWO Res2 = { RTFLOAT80U_INIT(0, 0, 0), 0, RTFLOAT80U_INIT(0, 0, 0) };
    49845069                            pfn(&State, &Res2, &InVal);
    4985                             RTStrmPrintf(pOutFn, "    { %#06x, %#06x, %#06x, %s, %s, %s }, /* #%u/%u/%u/%#x[!] = #%u */\n",
    4986                                          State.FCW | fFcwExtra, State.FSW, Res2.FSW, GenFormatR80(&InVal), GenFormatR80(&Res2.r80Result1),
    4987                                          GenFormatR80(&Res2.r80Result2), iTest, iRounding, iPrecision, fXcpt, iTestOutput++);
     5070                            FPU_UNARY_TWO_R80_TEST_T const Test2
     5071                                = { (uint16_t)(State.FCW | fFcwExtra), State.FSW, Res2.FSW, InVal, Res2.r80Result1, Res2.r80Result2 };
     5072                            GenerateBinaryWrite(&BinOut, &Test2, sizeof(Test2));
    49885073                        }
    49895074                        if (!RT_IS_POWER_OF_TWO(fXcpt))
    … …  
    49945079                                    IEMFPURESULTTWO Res3 = { RTFLOAT80U_INIT(0, 0, 0), 0, RTFLOAT80U_INIT(0, 0, 0) };
    49955080                                    pfn(&State, &Res3, &InVal);
    4996                                     RTStrmPrintf(pOutFn, "    { %#06x, %#06x, %#06x, %s, %s, %s }, /* #%u/%u/%u/u%#x = #%u */\n",
    4997                                                  State.FCW | fFcwExtra, State.FSW, Res3.FSW, GenFormatR80(&InVal), GenFormatR80(&Res3.r80Result1),
    4998                                                  GenFormatR80(&Res3.r80Result2), iTest, iRounding, iPrecision, fUnmasked, iTestOutput++);
     5081                                    FPU_UNARY_TWO_R80_TEST_T const Test3
     5082                                        = { (uint16_t)(State.FCW | fFcwExtra), State.FSW, Res3.FSW, InVal, Res3.r80Result1, Res3.r80Result2 };
     5083                                    GenerateBinaryWrite(&BinOut, &Test3, sizeof(Test3));
    49995084                                }
    50005085                    }
    50015086                }
    50025087        }
    5003         GenerateArrayEnd(pOutFn, g_aFpuUnaryTwoR80[iFn].pszName);
    5004     }
     5088        AssertReturn(GenerateBinaryClose(&BinOut), RTEXITCODE_FAILURE);
     5089    }
     5090    return RTEXITCODE_SUCCESS;
     5091}
     5092
     5093static RTEXITCODE FpuUnaryTwoR80DumpAll(const char * const *papszNameFmts)
     5094{
     5095    for (size_t iFn = 0; iFn < RT_ELEMENTS(g_aFpuUnaryTwoR80); iFn++)
     5096        DUMP_TEST_ENTRY(g_aFpuUnaryTwoR80[iFn], papszNameFmts);
     5097    return RTEXITCODE_SUCCESS;
    50055098}
    50065099#endif
    … …  
    97849877    {
    97859878#ifdef TSTIEMAIMPL_WITH_GENERATOR
    9786         char szCpuDesc[256] = {0};
    9787         RTMpGetDescription(NIL_RTCPUID, szCpuDesc, sizeof(szCpuDesc));
    9788         const char * const pszCpuType  = g_idxCpuEflFlavour == IEMTARGETCPU_EFL_BEHAVIOR_AMD ? "Amd"  : "Intel";
    9789 # if defined(RT_OS_WINDOWS) || defined(RT_OS_OS2)
    9790         const char * const pszBitBucket = "NUL";
    9791 # else
    9792         const char * const pszBitBucket = "/dev/null";
    9793 # endif
    9794 
    97959879        if (cTests == 0)
    97969880            cTests = cDefaultTests;
    … …  
    98279911        if (fFpuLdSt)
    98289912        {
    9829             const char *pszDataFile    = fCommonData ? "tstIEMAImplDataFpuLdSt.cpp" : pszBitBucket;
    9830             PRTSTREAM   pStrmData      = GenerateOpenWithHdr(pszDataFile, szCpuDesc, NULL);
    9831             const char *pszDataCpuFile = !fCpuData ? pszBitBucket : g_idxCpuEflFlavour == IEMTARGETCPU_EFL_BEHAVIOR_AMD
    9832                                        ? "tstIEMAImplDataFpuLdSt-Amd.cpp" : "tstIEMAImplDataFpuLdSt-Intel.cpp";
    9833             PRTSTREAM   pStrmDataCpu   = GenerateOpenWithHdr(pszDataCpuFile, szCpuDesc, pszCpuType);
    9834             if (!pStrmData || !pStrmDataCpu)
    9835                 return RTEXITCODE_FAILURE;
    9836 
    9837             FpuLdConstGenerate(pStrmData, cTests);
    9838             FpuLdIntGenerate(pStrmData, cTests);
    9839             FpuLdD80Generate(pStrmData, cTests);
    9840             FpuStIntGenerate(pStrmData, pStrmDataCpu, cTests);
    9841             FpuStD80Generate(pStrmData, cTests);
     9913            const char * const apszNameFmts[] =
     9914            {
     9915                /*[IEMTARGETCPU_EFL_BEHAVIOR_NATIVE] =*/ fCommonData ? "tstIEMAImplDataFpuLdSt-%s.bin.gz" : NULL,
     9916                /*[IEMTARGETCPU_EFL_BEHAVIOR_INTEL]  =*/ fCpuData    ? "tstIEMAImplDataFpuLdSt-%s.bin.gz" : NULL,
     9917                /*[IEMTARGETCPU_EFL_BEHAVIOR_AMD]    =*/ fCpuData    ? "tstIEMAImplDataFpuLdSt-%s.bin.gz" : NULL,
     9918            };
     9919            RTEXITCODE rcExit = FpuLdConstGenerate(cTests, apszNameFmts);
     9920            if (rcExit == RTEXITCODE_SUCCESS)
     9921                rcExit = FpuLdIntGenerate(cTests, apszNameFmts);
     9922            if (rcExit == RTEXITCODE_SUCCESS)
     9923                rcExit = FpuLdD80Generate(cTests, apszNameFmts);
     9924            if (rcExit == RTEXITCODE_SUCCESS)
     9925                rcExit = FpuStIntGenerate(cTests, apszNameFmts);
     9926            if (rcExit == RTEXITCODE_SUCCESS)
     9927                rcExit = FpuStD80Generate(cTests, apszNameFmts);
    98429928            uint32_t const cTests2 = RT_MAX(cTests, 384); /* need better coverage for the next ones. */
    9843             FpuLdMemGenerate(pStrmData, cTests2);
    9844             FpuStMemGenerate(pStrmData, cTests2);
    9845 
    9846             RTEXITCODE rcExit = GenerateFooterAndClose(pStrmDataCpu, pszDataCpuFile,
    9847                                                        GenerateFooterAndClose(pStrmData, pszDataFile, RTEXITCODE_SUCCESS));
     9929            if (rcExit == RTEXITCODE_SUCCESS)
     9930                rcExit = FpuLdMemGenerate(cTests2, apszNameFmts);
     9931            if (rcExit == RTEXITCODE_SUCCESS)
     9932                rcExit = FpuStMemGenerate(cTests2, apszNameFmts);
    98489933            if (rcExit != RTEXITCODE_SUCCESS)
    98499934                return rcExit;
    … …  
    98529937        if (fFpuBinary1)
    98539938        {
    9854             const char *pszDataFile    = fCommonData ? "tstIEMAImplDataFpuBinary1.cpp" : pszBitBucket;
    9855             PRTSTREAM   pStrmData      = GenerateOpenWithHdr(pszDataFile, szCpuDesc, NULL);
    9856             const char *pszDataCpuFile = !fCpuData ? pszBitBucket : g_idxCpuEflFlavour == IEMTARGETCPU_EFL_BEHAVIOR_AMD
    9857                                        ? "tstIEMAImplDataFpuBinary1-Amd.cpp" : "tstIEMAImplDataFpuBinary1-Intel.cpp";
    9858             PRTSTREAM   pStrmDataCpu   = GenerateOpenWithHdr(pszDataCpuFile, szCpuDesc, pszCpuType);
    9859             if (!pStrmData || !pStrmDataCpu)
    9860                 return RTEXITCODE_FAILURE;
    9861 
    9862             FpuBinaryR80Generate(pStrmData, pStrmDataCpu, cTests);
    9863             FpuBinaryFswR80Generate(pStrmData, cTests);
    9864             FpuBinaryEflR80Generate(pStrmData, cTests);
    9865 
    9866             RTEXITCODE rcExit = GenerateFooterAndClose(pStrmDataCpu, pszDataCpuFile,
    9867                                                        GenerateFooterAndClose(pStrmData, pszDataFile, RTEXITCODE_SUCCESS));
     9939            const char * const apszNameFmts[] =
     9940            {
     9941                /*[IEMTARGETCPU_EFL_BEHAVIOR_NATIVE] =*/ fCommonData ? "tstIEMAImplDataFpuBinary1-%s.bin.gz" : NULL,
     9942                /*[IEMTARGETCPU_EFL_BEHAVIOR_INTEL]  =*/ fCpuData    ? "tstIEMAImplDataFpuBinary1-%s.bin.gz" : NULL,
     9943                /*[IEMTARGETCPU_EFL_BEHAVIOR_AMD]    =*/ fCpuData    ? "tstIEMAImplDataFpuBinary1-%s.bin.gz" : NULL,
     9944            };
     9945            RTEXITCODE rcExit = FpuBinaryR80Generate(cTests, apszNameFmts);
     9946            if (rcExit == RTEXITCODE_SUCCESS)
     9947                rcExit = FpuBinaryFswR80Generate(cTests, apszNameFmts);
     9948            if (rcExit == RTEXITCODE_SUCCESS)
     9949                rcExit = FpuBinaryEflR80Generate(cTests, apszNameFmts);
    98689950            if (rcExit != RTEXITCODE_SUCCESS)
    98699951                return rcExit;
    … …  
    98729954        if (fFpuBinary2)
    98739955        {
    9874             const char *pszDataFile    = fCommonData ? "tstIEMAImplDataFpuBinary2.cpp" : pszBitBucket;
    9875             PRTSTREAM   pStrmData      = GenerateOpenWithHdr(pszDataFile, szCpuDesc, NULL);
    9876             const char *pszDataCpuFile = pszBitBucket; /*!fCpuData ? pszBitBucket : g_idxCpuEflFlavour == IEMTARGETCPU_EFL_BEHAVIOR_AMD
    9877                                        ? "tstIEMAImplDataFpuBinary2-Amd.cpp" : "tstIEMAImplDataFpuBinary2-Intel.cpp"; */
    9878             PRTSTREAM   pStrmDataCpu   = GenerateOpenWithHdr(pszDataCpuFile, szCpuDesc, pszCpuType);
    9879             if (!pStrmData || !pStrmDataCpu)
    9880                 return RTEXITCODE_FAILURE;
    9881 
    9882             FpuBinaryR64Generate(pStrmData, cTests);
    9883             FpuBinaryR32Generate(pStrmData, cTests);
    9884             FpuBinaryI32Generate(pStrmData, cTests);
    9885             FpuBinaryI16Generate(pStrmData, cTests);
    9886             FpuBinaryFswR64Generate(pStrmData, cTests);
    9887             FpuBinaryFswR32Generate(pStrmData, cTests);
    9888             FpuBinaryFswI32Generate(pStrmData, cTests);
    9889             FpuBinaryFswI16Generate(pStrmData, cTests);
    9890 
    9891             RTEXITCODE rcExit = GenerateFooterAndClose(pStrmDataCpu, pszDataCpuFile,
    9892                                                        GenerateFooterAndClose(pStrmData, pszDataFile, RTEXITCODE_SUCCESS));
     9956            const char * const apszNameFmts[] =
     9957            {
     9958                /*[IEMTARGETCPU_EFL_BEHAVIOR_NATIVE] =*/ fCommonData ? "tstIEMAImplDataFpuBinary2-%s.bin.gz" : NULL,
     9959                /*[IEMTARGETCPU_EFL_BEHAVIOR_INTEL]  =*/ fCpuData    ? "tstIEMAImplDataFpuBinary2-%s.bin.gz" : NULL,
     9960                /*[IEMTARGETCPU_EFL_BEHAVIOR_AMD]    =*/ fCpuData    ? "tstIEMAImplDataFpuBinary2-%s.bin.gz" : NULL,
     9961            };
     9962            RTEXITCODE rcExit = FpuBinaryR64Generate(cTests, apszNameFmts);
     9963            if (rcExit == RTEXITCODE_SUCCESS)
     9964                rcExit = FpuBinaryR32Generate(cTests, apszNameFmts);
     9965            if (rcExit == RTEXITCODE_SUCCESS)
     9966                rcExit = FpuBinaryI32Generate(cTests, apszNameFmts);
     9967            if (rcExit == RTEXITCODE_SUCCESS)
     9968                rcExit = FpuBinaryI16Generate(cTests, apszNameFmts);
     9969            if (rcExit == RTEXITCODE_SUCCESS)
     9970                rcExit = FpuBinaryFswR64Generate(cTests, apszNameFmts);
     9971            if (rcExit == RTEXITCODE_SUCCESS)
     9972                rcExit = FpuBinaryFswR32Generate(cTests, apszNameFmts);
     9973            if (rcExit == RTEXITCODE_SUCCESS)
     9974                rcExit = FpuBinaryFswI32Generate(cTests, apszNameFmts);
     9975            if (rcExit == RTEXITCODE_SUCCESS)
     9976                rcExit = FpuBinaryFswI16Generate(cTests, apszNameFmts);
    98939977            if (rcExit != RTEXITCODE_SUCCESS)
    98949978                return rcExit;
    … …  
    98979981        if (fFpuOther)
    98989982        {
    9899             const char *pszDataFile    = fCommonData ? "tstIEMAImplDataFpuOther.cpp" : pszBitBucket;
    9900             PRTSTREAM   pStrmData      = GenerateOpenWithHdr(pszDataFile, szCpuDesc, NULL);
    9901             const char *pszDataCpuFile = !fCpuData ? pszBitBucket : g_idxCpuEflFlavour == IEMTARGETCPU_EFL_BEHAVIOR_AMD
    9902                                        ? "tstIEMAImplDataFpuOther-Amd.cpp" : "tstIEMAImplDataFpuOther-Intel.cpp";
    9903             PRTSTREAM   pStrmDataCpu   = GenerateOpenWithHdr(pszDataCpuFile, szCpuDesc, pszCpuType);
    9904             if (!pStrmData || !pStrmDataCpu)
    9905                 return RTEXITCODE_FAILURE;
    9906 
    9907             FpuUnaryR80Generate(pStrmData, pStrmDataCpu, cTests);
    9908             FpuUnaryFswR80Generate(pStrmData, pStrmDataCpu, cTests);
    9909             FpuUnaryTwoR80Generate(pStrmData, pStrmDataCpu, cTests);
    9910 
    9911             RTEXITCODE rcExit = GenerateFooterAndClose(pStrmDataCpu, pszDataCpuFile,
    9912                                                        GenerateFooterAndClose(pStrmData, pszDataFile, RTEXITCODE_SUCCESS));
     9983            const char * const apszNameFmts[] =
     9984            {
     9985                /*[IEMTARGETCPU_EFL_BEHAVIOR_NATIVE] =*/ fCommonData ? "tstIEMAImplDataFpuOther-%s.bin.gz" : NULL,
     9986                /*[IEMTARGETCPU_EFL_BEHAVIOR_INTEL]  =*/ fCpuData    ? "tstIEMAImplDataFpuOther-%s.bin.gz" : NULL,
     9987                /*[IEMTARGETCPU_EFL_BEHAVIOR_AMD]    =*/ fCpuData    ? "tstIEMAImplDataFpuOther-%s.bin.gz" : NULL,
     9988            };
     9989            RTEXITCODE rcExit = FpuUnaryR80Generate(cTests, apszNameFmts);
     9990            if (rcExit == RTEXITCODE_SUCCESS)
     9991                rcExit = FpuUnaryFswR80Generate(cTests, apszNameFmts);
     9992            if (rcExit == RTEXITCODE_SUCCESS)
     9993                rcExit = FpuUnaryTwoR80Generate(cTests, apszNameFmts);
    99139994            if (rcExit != RTEXITCODE_SUCCESS)
    99149995                return rcExit;
    … …  
    1003010111            if (rcExit == RTEXITCODE_SUCCESS)
    1003110112                rcExit = MulDivDumpAll(apszNameFmts);
     10113            if (rcExit != RTEXITCODE_SUCCESS)
     10114                return rcExit;
     10115        }
     10116
     10117        if (fFpuLdSt)
     10118        {
     10119            const char * const apszNameFmts[] =
     10120            {
     10121                /*[IEMTARGETCPU_EFL_BEHAVIOR_NATIVE] =*/ fCommonData ? "tstIEMAImplDataFpuLdSt-%s.bin.gz" : NULL,
     10122                /*[IEMTARGETCPU_EFL_BEHAVIOR_INTEL]  =*/ fCpuData    ? "tstIEMAImplDataFpuLdSt-%s.bin.gz" : NULL,
     10123                /*[IEMTARGETCPU_EFL_BEHAVIOR_AMD]    =*/ fCpuData    ? "tstIEMAImplDataFpuLdSt-%s.bin.gz" : NULL,
     10124            };
     10125            RTEXITCODE rcExit = FpuLdConstDumpAll(apszNameFmts);
     10126            if (rcExit == RTEXITCODE_SUCCESS)
     10127                rcExit = FpuLdIntDumpAll(apszNameFmts);
     10128            if (rcExit == RTEXITCODE_SUCCESS)
     10129                rcExit = FpuLdD80DumpAll(apszNameFmts);
     10130            if (rcExit == RTEXITCODE_SUCCESS)
     10131                rcExit = FpuStIntDumpAll(apszNameFmts);
     10132            if (rcExit == RTEXITCODE_SUCCESS)
     10133                rcExit = FpuStD80DumpAll(apszNameFmts);
     10134            if (rcExit == RTEXITCODE_SUCCESS)
     10135                rcExit = FpuLdMemDumpAll(apszNameFmts);
     10136            if (rcExit == RTEXITCODE_SUCCESS)
     10137                rcExit = FpuStMemDumpAll(apszNameFmts);
     10138            if (rcExit != RTEXITCODE_SUCCESS)
     10139                return rcExit;
     10140        }
     10141
     10142        if (fFpuBinary1)
     10143        {
     10144            const char * const apszNameFmts[] =
     10145            {
     10146                /*[IEMTARGETCPU_EFL_BEHAVIOR_NATIVE] =*/ fCommonData ? "tstIEMAImplDataFpuBinary1-%s.bin.gz" : NULL,
     10147                /*[IEMTARGETCPU_EFL_BEHAVIOR_INTEL]  =*/ fCpuData    ? "tstIEMAImplDataFpuBinary1-%s.bin.gz" : NULL,
     10148                /*[IEMTARGETCPU_EFL_BEHAVIOR_AMD]    =*/ fCpuData    ? "tstIEMAImplDataFpuBinary1-%s.bin.gz" : NULL,
     10149            };
     10150            RTEXITCODE rcExit = FpuBinaryR80DumpAll(apszNameFmts);
     10151            if (rcExit == RTEXITCODE_SUCCESS)
     10152                rcExit = FpuBinaryFswR80DumpAll(apszNameFmts);
     10153            if (rcExit == RTEXITCODE_SUCCESS)
     10154                rcExit = FpuBinaryEflR80DumpAll(apszNameFmts);
     10155            if (rcExit != RTEXITCODE_SUCCESS)
     10156                return rcExit;
     10157        }
     10158
     10159        if (fFpuBinary2)
     10160        {
     10161            const char * const apszNameFmts[] =
     10162            {
     10163                /*[IEMTARGETCPU_EFL_BEHAVIOR_NATIVE] =*/ fCommonData ? "tstIEMAImplDataFpuBinary2-%s.bin.gz" : NULL,
     10164                /*[IEMTARGETCPU_EFL_BEHAVIOR_INTEL]  =*/ fCpuData    ? "tstIEMAImplDataFpuBinary2-%s.bin.gz" : NULL,
     10165                /*[IEMTARGETCPU_EFL_BEHAVIOR_AMD]    =*/ fCpuData    ? "tstIEMAImplDataFpuBinary2-%s.bin.gz" : NULL,
     10166            };
     10167            RTEXITCODE rcExit = FpuBinaryR64DumpAll(apszNameFmts);
     10168            if (rcExit == RTEXITCODE_SUCCESS)
     10169                rcExit = FpuBinaryR32DumpAll(apszNameFmts);
     10170            if (rcExit == RTEXITCODE_SUCCESS)
     10171                rcExit = FpuBinaryI32DumpAll(apszNameFmts);
     10172            if (rcExit == RTEXITCODE_SUCCESS)
     10173                rcExit = FpuBinaryI16DumpAll(apszNameFmts);
     10174            if (rcExit == RTEXITCODE_SUCCESS)
     10175                rcExit = FpuBinaryFswR64DumpAll(apszNameFmts);
     10176            if (rcExit == RTEXITCODE_SUCCESS)
     10177                rcExit = FpuBinaryFswR32DumpAll(apszNameFmts);
     10178            if (rcExit == RTEXITCODE_SUCCESS)
     10179                rcExit = FpuBinaryFswI32DumpAll(apszNameFmts);
     10180            if (rcExit == RTEXITCODE_SUCCESS)
     10181                rcExit = FpuBinaryFswI16DumpAll(apszNameFmts);
     10182            if (rcExit != RTEXITCODE_SUCCESS)
     10183                return rcExit;
     10184        }
     10185
     10186        if (fFpuOther)
     10187        {
     10188            const char * const apszNameFmts[] =
     10189            {
     10190                /*[IEMTARGETCPU_EFL_BEHAVIOR_NATIVE] =*/ fCommonData ? "tstIEMAImplDataFpuOther-%s.bin.gz" : NULL,
     10191                /*[IEMTARGETCPU_EFL_BEHAVIOR_INTEL]  =*/ fCpuData    ? "tstIEMAImplDataFpuOther-%s.bin.gz" : NULL,
     10192                /*[IEMTARGETCPU_EFL_BEHAVIOR_AMD]    =*/ fCpuData    ? "tstIEMAImplDataFpuOther-%s.bin.gz" : NULL,
     10193            };
     10194            RTEXITCODE rcExit = FpuUnaryR80DumpAll(apszNameFmts);
     10195            if (rcExit == RTEXITCODE_SUCCESS)
     10196                rcExit = FpuUnaryFswR80DumpAll(apszNameFmts);
     10197            if (rcExit == RTEXITCODE_SUCCESS)
     10198                rcExit = FpuUnaryTwoR80DumpAll(apszNameFmts);
    1003210199            if (rcExit != RTEXITCODE_SUCCESS)
    1003310200                return rcExit;
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