VirtualBox

Changeset 94409 in vbox for trunk/src/VBox/VMM


Ignore:
Timestamp:
Mar 31, 2022 10:42:18 AM (3 years ago)
Author:
vboxsync
Message:

tstIEMAImpl: Split the data out and put it in separate files to avoid turning it into a compiler memory usage test. bugref:9898

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

Legend:

Unmodified
Added
Removed

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

    r94155 r94409  
    219219
    220220#
    221 # Glboal config tool.
     221# Global config tool.
    222222#
    223223if defined(VBOX_WITH_HARDENING) && "$(KBUILD_TARGET)" == "win"
    … …  
    237237tstGlobalConfig_LIBS     = $(LIB_RUNTIME)
    238238
     239
    239240#
    240241# Testcase for checking the C (IEMAllAImplC.cpp) and assembly (IEMAllAImpl.asm)
    … …  
    245246tstIEMAImpl_TEMPLATE  = VBOXR3TSTEXE
    246247tstIEMAImpl_DEFS      = $(VMM_COMMON_DEFS) IEM_WITHOUT_ASSEMBLY IN_TSTVMSTRUCT
    247 tstIEMAImpl_INCS      = ../include
     248tstIEMAImpl_INCS      = ../include .
     249tstIEMAImpl_CLEAN     = \
     250        $(tstIEMAImpl_0_OUTDIR)/tstIEMAImplDataInt.cpp \
     251        $(tstIEMAImpl_0_OUTDIR)/tstIEMAImplDataInt-Amd.cpp \
     252        $(tstIEMAImpl_0_OUTDIR)/tstIEMAImplDataInt-Intel.cpp \
     253        $(tstIEMAImpl_0_OUTDIR)/tstIEMAImplDataFpuLdSt.cpp \
     254        $(tstIEMAImpl_0_OUTDIR)/tstIEMAImplDataFpuBinary1.cpp \
     255        $(tstIEMAImpl_0_OUTDIR)/tstIEMAImplDataFpuBinary2.cpp
    248256tstIEMAImpl_SOURCES   = \
    249257        tstIEMAImpl.cpp \
    250        ../VMMAll/IEMAllAImplC.cpp
     258       ../VMMAll/IEMAllAImplC.cpp \
     259       $(tstIEMAImpl_CLEAN)
     260$(call KB_FN_DO_PASS0_ON_TARGET,tstIEMAImpl)
    251261
    252262# This variant mainly for generating data.
    253263tstIEMAImplAsm_TEMPLATE  = VBOXR3TSTEXE
    254264tstIEMAImplAsm_DEFS      = $(VMM_COMMON_DEFS) IEM_WITH_ASSEMBLY IN_TSTVMSTRUCT TSTIEMAIMPL_WITH_GENERATOR
    255 tstIEMAImplAsm_INCS      = ../include
     265tstIEMAImplAsm_INCS      = ../include .
    256266tstIEMAImplAsm_SOURCES   = \
    257267        tstIEMAImpl.cpp \
    258268       ../VMMAll/IEMAllAImpl.asm \
    259        ../VMMAll/IEMAllAImplC.cpp
     269       ../VMMAll/IEMAllAImplC.cpp \
     270       $(tstIEMAImpl_CLEAN)
     271
     272## @param 1   The sub-name of the file in question.
     273define def_tstIEMAImplData_adjust
     274$$(tstIEMAImpl_0_OUTDIR)/tstIEMAImplData$(1).cpp: \
     275                $$(tstIEMAImpl_DEFPATH)/tstIEMAImplData$(1).cpp \
     276                $$(tstIEMAImpl_DEFPATH)/tstIEMAImplData.sh \
     277                $$(tstIEMAImpl_DEFPATH)/tstIEMAImpl.h \
     278                | $$(tstIEMAImpl_0_OUTDIR)/
     279        $$(ASH) "$$(tstIEMAImpl_DEFPATH)/tstIEMAImplData.sh" \
     280                "$$(CP_EXT)" \
     281                "$$(MV_EXT)" \
     282                "$$(SED_EXT)" \
     283                "$$(tstIEMAImpl_0_OUTDIR)" \
     284                "$$(tstIEMAImpl_DEFPATH)" \
     285                "$(1)"
     286endef
     287$(evalcall2 def_tstIEMAImplData_adjust,Int)
     288$(evalcall2 def_tstIEMAImplData_adjust,Int-Amd)
     289$(evalcall2 def_tstIEMAImplData_adjust,Int-Intel)
     290$(evalcall2 def_tstIEMAImplData_adjust,FpuLdSt)
     291$(evalcall2 def_tstIEMAImplData_adjust,FpuBinary1)
     292$(evalcall2 def_tstIEMAImplData_adjust,FpuBinary2)
     293
    260294
    261295#

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

    r94402 r94409  
    3535#include <iprt/test.h>
    3636
    37 
    38 /*********************************************************************************************************************************
    39 *   Structures and Typedefs                                                                                                      *
    40 *********************************************************************************************************************************/
    41 /** @name 8-bit binary (PFNIEMAIMPLBINU8)
    42  * @{ */
    43 typedef struct BINU8_TEST_T
    44 {
    45     uint32_t                fEflIn;
    46     uint32_t                fEflOut;
    47     uint8_t                 uDstIn;
    48     uint8_t                 uDstOut;
    49     uint8_t                 uSrcIn;
    50     uint8_t                 uMisc;
    51 } BINU8_TEST_T;
    52 
    53 typedef struct BINU8_T
    54 {
    55     const char             *pszName;
    56     PFNIEMAIMPLBINU8        pfn;
    57     PFNIEMAIMPLBINU8        pfnNative;
    58     BINU8_TEST_T const     *paTests;
    59     uint32_t                cTests;
    60     uint32_t                uExtra;
    61     uint8_t                 idxCpuEflFlavour;
    62 } BINU8_T;
    63 /** @} */
    64 
    65 
    66 /** @name 16-bit binary (PFNIEMAIMPLBINU16)
    67  * @{ */
    68 typedef struct BINU16_TEST_T
    69 {
    70     uint32_t                fEflIn;
    71     uint32_t                fEflOut;
    72     uint16_t                uDstIn;
    73     uint16_t                uDstOut;
    74     uint16_t                uSrcIn;
    75     uint16_t                uMisc;
    76 } BINU16_TEST_T;
    77 
    78 typedef struct BINU16_T
    79 {
    80     const char             *pszName;
    81     PFNIEMAIMPLBINU16       pfn;
    82     PFNIEMAIMPLBINU16       pfnNative;
    83     BINU16_TEST_T const    *paTests;
    84     uint32_t                cTests;
    85     uint32_t                uExtra;
    86     uint8_t                 idxCpuEflFlavour;
    87 } BINU16_T;
    88 /** @} */
    89 
    90 
    91 /** @name 32-bit binary (PFNIEMAIMPLBINU32)
    92  * @{ */
    93 typedef struct BINU32_TEST_T
    94 {
    95     uint32_t                fEflIn;
    96     uint32_t                fEflOut;
    97     uint32_t                uDstIn;
    98     uint32_t                uDstOut;
    99     uint32_t                uSrcIn;
    100     uint32_t                uMisc;
    101 } BINU32_TEST_T;
    102 
    103 typedef struct BINU32_T
    104 {
    105     const char             *pszName;
    106     PFNIEMAIMPLBINU32       pfn;
    107     PFNIEMAIMPLBINU32       pfnNative;
    108     BINU32_TEST_T const    *paTests;
    109     uint32_t                cTests;
    110     uint32_t                uExtra;
    111     uint8_t                 idxCpuEflFlavour;
    112 } BINU32_T;
    113 /** @} */
    114 
    115 
    116 /** @name 64-bit binary (PFNIEMAIMPLBINU64)
    117  * @{ */
    118 typedef struct BINU64_TEST_T
    119 {
    120     uint32_t                fEflIn;
    121     uint32_t                fEflOut;
    122     uint64_t                uDstIn;
    123     uint64_t                uDstOut;
    124     uint64_t                uSrcIn;
    125     uint64_t                uMisc;
    126 } BINU64_TEST_T;
    127 
    128 typedef struct BINU64_T
    129 {
    130     const char             *pszName;
    131     PFNIEMAIMPLBINU64       pfn;
    132     PFNIEMAIMPLBINU64       pfnNative;
    133     BINU64_TEST_T const    *paTests;
    134     uint32_t                cTests;
    135     uint32_t                uExtra;
    136     uint8_t                 idxCpuEflFlavour;
    137 } BINU64_T;
    138 /** @} */
    139 
    140 
    141 /** @name mult/div (PFNIEMAIMPLBINU8, PFNIEMAIMPLBINU16, PFNIEMAIMPLBINU32, PFNIEMAIMPLBINU64)
    142  * @{ */
    143 typedef struct MULDIVU8_TEST_T
    144 {
    145     uint32_t                fEflIn;
    146     uint32_t                fEflOut;
    147     uint16_t                uDstIn;
    148     uint16_t                uDstOut;
    149     uint8_t                 uSrcIn;
    150     int32_t                 rc;
    151 } MULDIVU8_TEST_T;
    152 
    153 typedef struct MULDIVU16_TEST_T
    154 {
    155     uint32_t                fEflIn;
    156     uint32_t                fEflOut;
    157     uint16_t                uDst1In;
    158     uint16_t                uDst1Out;
    159     uint16_t                uDst2In;
    160     uint16_t                uDst2Out;
    161     uint16_t                uSrcIn;
    162     int32_t                 rc;
    163 } MULDIVU16_TEST_T;
    164 
    165 typedef struct MULDIVU32_TEST_T
    166 {
    167     uint32_t                fEflIn;
    168     uint32_t                fEflOut;
    169     uint32_t                uDst1In;
    170     uint32_t                uDst1Out;
    171     uint32_t                uDst2In;
    172     uint32_t                uDst2Out;
    173     uint32_t                uSrcIn;
    174     int32_t                 rc;
    175 } MULDIVU32_TEST_T;
    176 
    177 typedef struct MULDIVU64_TEST_T
    178 {
    179     uint32_t                fEflIn;
    180     uint32_t                fEflOut;
    181     uint64_t                uDst1In;
    182     uint64_t                uDst1Out;
    183     uint64_t                uDst2In;
    184     uint64_t                uDst2Out;
    185     uint64_t                uSrcIn;
    186     int32_t                 rc;
    187 } MULDIVU64_TEST_T;
    188 /** @} */
     37#include "tstIEMAImpl.h"
    18938
    19039
    … …  
    19544#define ENTRY_EX(a_Name, a_uExtra) \
    19645    { RT_XSTR(a_Name), iemAImpl_ ## a_Name, NULL, \
    197       g_aTests_ ## a_Name, RT_ELEMENTS(g_aTests_ ## a_Name), \
     46      g_aTests_ ## a_Name, &g_cTests_ ## a_Name, \
    19847      a_uExtra, IEMTARGETCPU_EFL_BEHAVIOR_NATIVE /* means same for all here */ }
    19948
    … …  
    20150#define ENTRY_INTEL_EX(a_Name, a_fEflUndef, a_uExtra) \
    20251    { RT_XSTR(a_Name) "_intel", iemAImpl_ ## a_Name ## _intel, iemAImpl_ ## a_Name, \
    203       g_aTests_ ## a_Name ## _intel, RT_ELEMENTS(g_aTests_ ## a_Name ## _intel), \
     52      g_aTests_ ## a_Name ## _intel, &g_cTests_ ## a_Name ## _intel, \
    20453      a_uExtra, IEMTARGETCPU_EFL_BEHAVIOR_INTEL }
    20554
    … …  
    20756#define ENTRY_AMD_EX(a_Name, a_fEflUndef, a_uExtra) \
    20857    { RT_XSTR(a_Name) "_amd", iemAImpl_ ## a_Name ## _amd,   iemAImpl_ ## a_Name, \
    209       g_aTests_ ## a_Name ## _amd, RT_ELEMENTS(g_aTests_ ## a_Name ## _amd), \
     58      g_aTests_ ## a_Name ## _amd, &g_cTests_ ## a_Name ## _amd, \
    21059      a_uExtra, IEMTARGETCPU_EFL_BEHAVIOR_AMD }
     60
     61#define TYPEDEF_SUBTEST_TYPE(a_TypeName, a_TestType, a_FunctionPtrType) \
     62    typedef struct a_TypeName \
     63    { \
     64        const char             *pszName; \
     65        a_FunctionPtrType       pfn; \
     66        a_FunctionPtrType       pfnNative; \
     67        a_TestType const       *paTests; \
     68        uint32_t const         *pcTests; \
     69        uint32_t                uExtra; \
     70        uint8_t                 idxCpuEflFlavour; \
     71    } a_TypeName
    21172
    21273
    … …  
    23091
    23192
    232 #include "tstIEMAImplData.h"
    233 #include "tstIEMAImplData-Intel.h"
    234 #include "tstIEMAImplData-Amd.h"
    235 
    236 
    23793/*********************************************************************************************************************************
    23894*   Internal Functions                                                                                                           *
    … …  
    253109}
    254110
     111#ifdef TSTIEMAIMPL_WITH_GENERATOR
    255112
    256113static uint8_t  RandU8(void)
    … …  
    271128}
    272129
     130#endif
    273131
    274132static uint64_t  RandU64(void)
    … …  
    759617
    760618
    761 static void GenerateHeader(PRTSTREAM pOut, const char *pszFileInfix,
    762                            const char *pszCpuDesc, const char *pszCpuType, const char *pszCpuSuffU)
     619static void GenerateHeader(PRTSTREAM pOut, const char *pszCpuDesc, const char *pszCpuType)
    763620{
    764621    /* We want to tag the generated source code with the revision that produced it. */
    … …  
    787644                 " */\n"
    788645                 "\n"
    789                  "#ifndef VMM_INCLUDED_SRC_testcase_tstIEMAImplData%s%s_h\n"
    790                  "#define VMM_INCLUDED_SRC_testcase_tstIEMAImplData%s%s_h\n"
    791                  "#ifndef RT_WITHOUT_PRAGMA_ONCE\n"
    792                  "# pragma once\n"
    793                  "#endif\n"
     646                 "#include \"tstIEMAImpl.h\"\n"
     647                 "\n"
    794648                 ,
    795                  pszCpuType ? " " : "", pszCpuType ? pszCpuType : "", cchRev, pszRev, pszCpuDesc,
    796                  pszFileInfix, pszCpuSuffU,
    797                  pszFileInfix, pszCpuSuffU);
    798 }
    799 
    800 
    801 static RTEXITCODE GenerateFooterAndClose(PRTSTREAM pOut, const char *pszFilename, const char *pszFileInfix,
    802                                          const char *pszCpuSuff, RTEXITCODE rcExit)
     649                 pszCpuType ? " " : "", pszCpuType ? pszCpuType : "", cchRev, pszRev, pszCpuDesc);
     650}
     651
     652
     653static PRTSTREAM GenerateOpenWithHdr(const char *pszFilename, const char *pszCpuDesc, const char *pszCpuType)
     654{
     655    PRTSTREAM pOut = NULL;
     656    int rc = RTStrmOpen(pszFilename, "w", &pOut);
     657    if (RT_SUCCESS(rc))
     658    {
     659        GenerateHeader(pOut, pszCpuDesc, pszCpuType);
     660        return pOut;
     661    }
     662    RTMsgError("Failed to open %s for writing: %Rrc", pszFilename, rc);
     663    return NULL;
     664}
     665
     666
     667static RTEXITCODE GenerateFooterAndClose(PRTSTREAM pOut, const char *pszFilename, RTEXITCODE rcExit)
    803668{
    804669    RTStrmPrintf(pOut,
    805670                 "\n"
    806                  "#endif /* !VMM_INCLUDED_SRC_testcase_tstIEMAImplData%s%s_h */\n", pszFileInfix, pszCpuSuff);
     671                 "/* end of file */\n");
    807672    int rc = RTStrmClose(pOut);
    808673    if (RT_SUCCESS(rc))
    … …  
    811676}
    812677
    813 #endif
     678
     679static void GenerateArrayStart(PRTSTREAM pOut, const char *pszName, const char *pszType)
     680{
     681    RTStrmPrintf(pOut, "%s const g_aTests_%s[] =\n{\n", pszType, pszName);
     682}
     683
     684
     685static void GenerateArrayEnd(PRTSTREAM pOut, const char *pszName)
     686{
     687    RTStrmPrintf(pOut,
     688                 "};\n"
     689                 "uint32_t const g_cTests_%s = RT_ELEMENTS(g_aTests_%s);\n"
     690                 "\n",
     691                 pszName, pszName);
     692}
     693
     694#endif /* TSTIEMAIMPL_WITH_GENERATOR */
    814695
    815696
    … …  
    1004885 * Binary operations.
    1005886 */
     887TYPEDEF_SUBTEST_TYPE(BINU8_T,  BINU8_TEST_T,  PFNIEMAIMPLBINU8);
     888TYPEDEF_SUBTEST_TYPE(BINU16_T, BINU16_TEST_T, PFNIEMAIMPLBINU16);
     889TYPEDEF_SUBTEST_TYPE(BINU32_T, BINU32_TEST_T, PFNIEMAIMPLBINU32);
     890TYPEDEF_SUBTEST_TYPE(BINU64_T, BINU64_TEST_T, PFNIEMAIMPLBINU64);
     891
    1006892#ifdef TSTIEMAIMPL_WITH_GENERATOR
    1007 # define GEN_BINARY_TESTS(a_cBits, a_Fmt) \
    1008 static void BinU ## a_cBits ## Generate(PRTSTREAM pOut, PRTSTREAM pOutCpu, const char *pszCpuSuffU, uint32_t cTests) \
     893# define GEN_BINARY_TESTS(a_cBits, a_Fmt, a_TestType) \
     894static void BinU ## a_cBits ## Generate(PRTSTREAM pOut, PRTSTREAM pOutCpu, uint32_t cTests) \
    1009895{ \
    1010     RTStrmPrintf(pOut, "\n\n#define HAVE_BINU%u_TESTS\n", a_cBits); \
    1011     RTStrmPrintf(pOutCpu, "\n\n#define HAVE_BINU%u_TESTS%s\n", a_cBits, pszCpuSuffU); \
    1012896    for (size_t iFn = 0; iFn < RT_ELEMENTS(g_aBinU ## a_cBits); iFn++) \
    1013897    { \
    … …  
    1022906        } \
    1023907        \
    1024         RTStrmPrintf(pOutFn, "static const BINU%u_TEST_T g_aTests_%s[] =\n{\n", a_cBits, g_aBinU ## a_cBits[iFn].pszName); \
     908        GenerateArrayStart(pOutFn, g_aBinU ## a_cBits[iFn].pszName, #a_TestType); \
    1025909        for (uint32_t iTest = 0; iTest < cTests; iTest++ ) \
    1026910        { \
    1027             BINU ## a_cBits ## _TEST_T Test; \
     911            a_TestType Test; \
    1028912            Test.fEflIn    = RandEFlags(); \
    1029913            Test.fEflOut   = Test.fEflIn; \
    … …  
    1038922                         Test.fEflIn, Test.fEflOut, Test.uDstIn, Test.uDstOut, Test.uSrcIn, Test.uMisc, iTest); \
    1039923        } \
    1040         RTStrmPrintf(pOutFn, "};\n"); \
     924        GenerateArrayEnd(pOutFn, g_aBinU ## a_cBits[iFn].pszName); \
    1041925    } \
    1042926}
    1043927#else
    1044 # define GEN_BINARY_TESTS(a_cBits, a_Fmt)
     928# define GEN_BINARY_TESTS(a_cBits, a_Fmt, a_TestType)
    1045929#endif
    1046930
    1047 #define TEST_BINARY_OPS(a_cBits, a_uType, a_Fmt, a_aSubTests) \
    1048 GEN_BINARY_TESTS(a_cBits, a_Fmt) \
     931#define TEST_BINARY_OPS(a_cBits, a_uType, a_Fmt, a_TestType, a_aSubTests) \
     932GEN_BINARY_TESTS(a_cBits, a_Fmt, a_TestType) \
    1049933\
    1050934static void BinU ## a_cBits ## Test(void) \
    … …  
    1053937    { \
    1054938        RTTestSub(g_hTest, a_aSubTests[iFn].pszName); \
    1055         BINU ## a_cBits ## _TEST_T const * const paTests = a_aSubTests[iFn].paTests; \
    1056         uint32_t const                           cTests  = a_aSubTests[iFn].cTests; \
    1057         PFNIEMAIMPLBINU ## a_cBits               pfn     = a_aSubTests[iFn].pfn; \
     939        a_TestType const * const  paTests = a_aSubTests[iFn].paTests; \
     940        uint32_t const             cTests  = *a_aSubTests[iFn].pcTests; \
     941        PFNIEMAIMPLBINU ## a_cBits pfn     = a_aSubTests[iFn].pfn; \
    1058942        uint32_t const cVars = 1 + (a_aSubTests[iFn].idxCpuEflFlavour == g_idxCpuEflFlavour && a_aSubTests[iFn].pfnNative); \
     943        if (!cTests) RTTestSkipped(g_hTest, "no tests"); \
    1059944        for (uint32_t iVar = 0; iVar < cVars; iVar++) \
    1060945        { \
    … …  
    1089974 * 8-bit binary operations.
    1090975 */
    1091 
    1092 #ifndef HAVE_BINU8_TESTS
    1093 static const BINU8_TEST_T g_aTests_add_u8[]         = { {0} };
    1094 static const BINU8_TEST_T g_aTests_add_u8_locked[]  = { {0} };
    1095 static const BINU8_TEST_T g_aTests_adc_u8[]         = { {0} };
    1096 static const BINU8_TEST_T g_aTests_adc_u8_locked[]  = { {0} };
    1097 static const BINU8_TEST_T g_aTests_sub_u8[]         = { {0} };
    1098 static const BINU8_TEST_T g_aTests_sub_u8_locked[]  = { {0} };
    1099 static const BINU8_TEST_T g_aTests_sbb_u8[]         = { {0} };
    1100 static const BINU8_TEST_T g_aTests_sbb_u8_locked[]  = { {0} };
    1101 static const BINU8_TEST_T g_aTests_or_u8[]          = { {0} };
    1102 static const BINU8_TEST_T g_aTests_or_u8_locked[]   = { {0} };
    1103 static const BINU8_TEST_T g_aTests_xor_u8[]         = { {0} };
    1104 static const BINU8_TEST_T g_aTests_xor_u8_locked[]  = { {0} };
    1105 static const BINU8_TEST_T g_aTests_and_u8[]         = { {0} };
    1106 static const BINU8_TEST_T g_aTests_and_u8_locked[]  = { {0} };
    1107 static const BINU8_TEST_T g_aTests_cmp_u8[]         = { {0} };
    1108 static const BINU8_TEST_T g_aTests_test_u8[]        = { {0} };
    1109 #endif
    1110 
    1111976static const BINU8_T g_aBinU8[] =
    1112977{
    … …  
    1128993    ENTRY(test_u8),
    1129994};
    1130 
    1131 TEST_BINARY_OPS(8, uint8_t, "%#04x", g_aBinU8)
     995TEST_BINARY_OPS(8, uint8_t, "%#04x", BINU8_TEST_T, g_aBinU8)
    1132996
    1133997
    … …  
    1135999 * 16-bit binary operations.
    11361000 */
    1137 
    1138 #ifndef HAVE_BINU16_TESTS
    1139 static const BINU16_TEST_T g_aTests_add_u16[]        = { {0} };
    1140 static const BINU16_TEST_T g_aTests_add_u16_locked[] = { {0} };
    1141 static const BINU16_TEST_T g_aTests_adc_u16[]        = { {0} };
    1142 static const BINU16_TEST_T g_aTests_adc_u16_locked[] = { {0} };
    1143 static const BINU16_TEST_T g_aTests_sub_u16[]        = { {0} };
    1144 static const BINU16_TEST_T g_aTests_sub_u16_locked[] = { {0} };
    1145 static const BINU16_TEST_T g_aTests_sbb_u16[]        = { {0} };
    1146 static const BINU16_TEST_T g_aTests_sbb_u16_locked[] = { {0} };
    1147 static const BINU16_TEST_T g_aTests_or_u16[]         = { {0} };
    1148 static const BINU16_TEST_T g_aTests_or_u16_locked[]  = { {0} };
    1149 static const BINU16_TEST_T g_aTests_xor_u16[]        = { {0} };
    1150 static const BINU16_TEST_T g_aTests_xor_u16_locked[] = { {0} };
    1151 static const BINU16_TEST_T g_aTests_and_u16[]        = { {0} };
    1152 static const BINU16_TEST_T g_aTests_and_u16_locked[] = { {0} };
    1153 static const BINU16_TEST_T g_aTests_cmp_u16[]        = { {0} };
    1154 static const BINU16_TEST_T g_aTests_test_u16[]       = { {0} };
    1155 static const BINU16_TEST_T g_aTests_bt_u16[]         = { {0} };
    1156 static const BINU16_TEST_T g_aTests_btc_u16[]        = { {0} };
    1157 static const BINU16_TEST_T g_aTests_btc_u16_locked[] = { {0} };
    1158 static const BINU16_TEST_T g_aTests_btr_u16[]        = { {0} };
    1159 static const BINU16_TEST_T g_aTests_btr_u16_locked[] = { {0} };
    1160 static const BINU16_TEST_T g_aTests_bts_u16[]        = { {0} };
    1161 static const BINU16_TEST_T g_aTests_bts_u16_locked[] = { {0} };
    1162 static const BINU16_TEST_T g_aTests_arpl[]           = { {0} };
    1163 #endif
    1164 #ifndef HAVE_BINU16_TESTS_AMD
    1165 static const BINU16_TEST_T g_aTests_bsf_u16_amd[]           = { {0} };
    1166 static const BINU16_TEST_T g_aTests_bsr_u16_amd[]           = { {0} };
    1167 static const BINU16_TEST_T g_aTests_imul_two_u16_amd[]      = { {0} };
    1168 #endif
    1169 #ifndef HAVE_BINU16_TESTS_INTEL
    1170 static const BINU16_TEST_T g_aTests_bsf_u16_intel[]         = { {0} };
    1171 static const BINU16_TEST_T g_aTests_bsr_u16_intel[]         = { {0} };
    1172 static const BINU16_TEST_T g_aTests_imul_two_u16_intel[]    = { {0} };
    1173 #endif
    1174 
    11751001static const BINU16_T g_aBinU16[] =
    11761002{
    … …  
    12061032    ENTRY(arpl),
    12071033};
    1208 
    1209 TEST_BINARY_OPS(16, uint16_t, "%#06x", g_aBinU16)
     1034TEST_BINARY_OPS(16, uint16_t, "%#06x", BINU16_TEST_T, g_aBinU16)
    12101035
    12111036
    … …  
    12131038 * 32-bit binary operations.
    12141039 */
    1215 
    1216 #ifndef HAVE_BINU32_TESTS
    1217 static const BINU32_TEST_T g_aTests_add_u32[]        = { {0} };
    1218 static const BINU32_TEST_T g_aTests_add_u32_locked[] = { {0} };
    1219 static const BINU32_TEST_T g_aTests_adc_u32[]        = { {0} };
    1220 static const BINU32_TEST_T g_aTests_adc_u32_locked[] = { {0} };
    1221 static const BINU32_TEST_T g_aTests_sub_u32[]        = { {0} };
    1222 static const BINU32_TEST_T g_aTests_sub_u32_locked[] = { {0} };
    1223 static const BINU32_TEST_T g_aTests_sbb_u32[]        = { {0} };
    1224 static const BINU32_TEST_T g_aTests_sbb_u32_locked[] = { {0} };
    1225 static const BINU32_TEST_T g_aTests_or_u32[]         = { {0} };
    1226 static const BINU32_TEST_T g_aTests_or_u32_locked[]  = { {0} };
    1227 static const BINU32_TEST_T g_aTests_xor_u32[]        = { {0} };
    1228 static const BINU32_TEST_T g_aTests_xor_u32_locked[] = { {0} };
    1229 static const BINU32_TEST_T g_aTests_and_u32[]        = { {0} };
    1230 static const BINU32_TEST_T g_aTests_and_u32_locked[] = { {0} };
    1231 static const BINU32_TEST_T g_aTests_cmp_u32[]        = { {0} };
    1232 static const BINU32_TEST_T g_aTests_test_u32[]       = { {0} };
    1233 static const BINU32_TEST_T g_aTests_bt_u32[]         = { {0} };
    1234 static const BINU32_TEST_T g_aTests_btc_u32[]        = { {0} };
    1235 static const BINU32_TEST_T g_aTests_btc_u32_locked[] = { {0} };
    1236 static const BINU32_TEST_T g_aTests_btr_u32[]        = { {0} };
    1237 static const BINU32_TEST_T g_aTests_btr_u32_locked[] = { {0} };
    1238 static const BINU32_TEST_T g_aTests_bts_u32[]        = { {0} };
    1239 static const BINU32_TEST_T g_aTests_bts_u32_locked[] = { {0} };
    1240 #endif
    1241 #ifndef HAVE_BINU32_TESTS_AMD
    1242 static const BINU32_TEST_T g_aTests_bsf_u32_amd[]           = { {0} };
    1243 static const BINU32_TEST_T g_aTests_bsr_u32_amd[]           = { {0} };
    1244 static const BINU32_TEST_T g_aTests_imul_two_u32_amd[]      = { {0} };
    1245 #endif
    1246 #ifndef HAVE_BINU32_TESTS_INTEL
    1247 static const BINU32_TEST_T g_aTests_bsf_u32_intel[]         = { {0} };
    1248 static const BINU32_TEST_T g_aTests_bsr_u32_intel[]         = { {0} };
    1249 static const BINU32_TEST_T g_aTests_imul_two_u32_intel[]    = { {0} };
    1250 #endif
    1251 
    12521040static const BINU32_T g_aBinU32[] =
    12531041{
    … …  
    12821070    ENTRY_INTEL(imul_two_u32, X86_EFL_PF | X86_EFL_AF | X86_EFL_ZF | X86_EFL_SF),
    12831071};
    1284 
    1285 TEST_BINARY_OPS(32, uint32_t, "%#010RX32", g_aBinU32)
     1072TEST_BINARY_OPS(32, uint32_t, "%#010RX32", BINU32_TEST_T, g_aBinU32)
    12861073
    12871074
    … …  
    12891076 * 64-bit binary operations.
    12901077 */
    1291 
    1292 #ifndef HAVE_BINU64_TESTS
    1293 static const BINU64_TEST_T g_aTests_add_u64[]        = { {0} };
    1294 static const BINU64_TEST_T g_aTests_add_u64_locked[] = { {0} };
    1295 static const BINU64_TEST_T g_aTests_adc_u64[]        = { {0} };
    1296 static const BINU64_TEST_T g_aTests_adc_u64_locked[] = { {0} };
    1297 static const BINU64_TEST_T g_aTests_sub_u64[]        = { {0} };
    1298 static const BINU64_TEST_T g_aTests_sub_u64_locked[] = { {0} };
    1299 static const BINU64_TEST_T g_aTests_sbb_u64[]        = { {0} };
    1300 static const BINU64_TEST_T g_aTests_sbb_u64_locked[] = { {0} };
    1301 static const BINU64_TEST_T g_aTests_or_u64[]         = { {0} };
    1302 static const BINU64_TEST_T g_aTests_or_u64_locked[]  = { {0} };
    1303 static const BINU64_TEST_T g_aTests_xor_u64[]        = { {0} };
    1304 static const BINU64_TEST_T g_aTests_xor_u64_locked[] = { {0} };
    1305 static const BINU64_TEST_T g_aTests_and_u64[]        = { {0} };
    1306 static const BINU64_TEST_T g_aTests_and_u64_locked[] = { {0} };
    1307 static const BINU64_TEST_T g_aTests_cmp_u64[]        = { {0} };
    1308 static const BINU64_TEST_T g_aTests_test_u64[]       = { {0} };
    1309 static const BINU64_TEST_T g_aTests_bt_u64[]         = { {0} };
    1310 static const BINU64_TEST_T g_aTests_btc_u64[]        = { {0} };
    1311 static const BINU64_TEST_T g_aTests_btc_u64_locked[] = { {0} };
    1312 static const BINU64_TEST_T g_aTests_btr_u64[]        = { {0} };
    1313 static const BINU64_TEST_T g_aTests_btr_u64_locked[] = { {0} };
    1314 static const BINU64_TEST_T g_aTests_bts_u64[]        = { {0} };
    1315 static const BINU64_TEST_T g_aTests_bts_u64_locked[] = { {0} };
    1316 #endif
    1317 #ifndef HAVE_BINU64_TESTS_AMD
    1318 static const BINU64_TEST_T g_aTests_bsf_u64_amd[]           = { {0} };
    1319 static const BINU64_TEST_T g_aTests_bsr_u64_amd[]           = { {0} };
    1320 static const BINU64_TEST_T g_aTests_imul_two_u64_amd[]      = { {0} };
    1321 #endif
    1322 #ifndef HAVE_BINU64_TESTS_INTEL
    1323 static const BINU64_TEST_T g_aTests_bsf_u64_intel[]         = { {0} };
    1324 static const BINU64_TEST_T g_aTests_bsr_u64_intel[]         = { {0} };
    1325 static const BINU64_TEST_T g_aTests_imul_two_u64_intel[]    = { {0} };
    1326 #endif
    1327 
    13281078static const BINU64_T g_aBinU64[] =
    13291079{
    … …  
    13581108    ENTRY_INTEL(imul_two_u64, X86_EFL_PF | X86_EFL_AF | X86_EFL_ZF | X86_EFL_SF),
    13591109};
    1360 
    1361 TEST_BINARY_OPS(64, uint64_t, "%#018RX64", g_aBinU64)
     1110TEST_BINARY_OPS(64, uint64_t, "%#018RX64", BINU64_TEST_T, g_aBinU64)
    13621111
    13631112
    … …  
    14431192            FNIEMAIMPLXADDU ## a_cBits         *pfn; \
    14441193            BINU ## a_cBits ## _TEST_T const   *paTests; \
    1445             uint32_t                            cTests; \
     1194            uint32_t const                     *pcTests; \
    14461195        } const s_aFuncs[] = \
    14471196        { \
    14481197            { "xadd_u" # a_cBits,            iemAImpl_xadd_u ## a_cBits, \
    1449               g_aTests_add_u ## a_cBits, RT_ELEMENTS(g_aTests_add_u ## a_cBits) }, \
     1198              g_aTests_add_u ## a_cBits, &g_cTests_add_u ## a_cBits }, \
    14501199            { "xadd_u" # a_cBits "8_locked", iemAImpl_xadd_u ## a_cBits ## _locked, \
    1451               g_aTests_add_u ## a_cBits, RT_ELEMENTS(g_aTests_add_u ## a_cBits) }, \
     1200              g_aTests_add_u ## a_cBits, &g_cTests_add_u ## a_cBits }, \
    14521201        }; \
    14531202        for (size_t iFn = 0; iFn < RT_ELEMENTS(s_aFuncs); iFn++) \
    14541203        { \
    14551204            RTTestSub(g_hTest, s_aFuncs[iFn].pszName); \
     1205            uint32_t const                           cTests  = *s_aFuncs[iFn].pcTests; \
    14561206            BINU ## a_cBits ## _TEST_T const * const paTests = s_aFuncs[iFn].paTests; \
    1457             uint32_t const                           cTests  = s_aFuncs[iFn].cTests; \
     1207            if (!cTests) RTTestSkipped(g_hTest, "no tests"); \
    14581208            for (uint32_t iTest = 0; iTest < cTests; iTest++) \
    14591209            { \
    … …  
    14931243            PFNIEMAIMPLBINU ## a_cBits          pfnSub; \
    14941244            BINU ## a_cBits ## _TEST_T const   *paTests; \
    1495             uint32_t                            cTests; \
     1245            uint32_t const                     *pcTests; \
    14961246        } const s_aFuncs[] = \
    14971247        { \
    14981248            { "cmpxchg_u" # a_cBits,           iemAImpl_cmpxchg_u ## a_cBits, iemAImpl_sub_u ## a_cBits, \
    1499               g_aTests_cmp_u ## a_cBits, RT_ELEMENTS(g_aTests_cmp_u ## a_cBits) }, \
     1249              g_aTests_cmp_u ## a_cBits, &g_cTests_cmp_u ## a_cBits }, \
    15001250            { "cmpxchg_u" # a_cBits "_locked", iemAImpl_cmpxchg_u ## a_cBits ## _locked, iemAImpl_sub_u ## a_cBits, \
    1501               g_aTests_cmp_u ## a_cBits, RT_ELEMENTS(g_aTests_cmp_u ## a_cBits) }, \
     1251              g_aTests_cmp_u ## a_cBits, &g_cTests_cmp_u ## a_cBits }, \
    15021252        }; \
    15031253        for (size_t iFn = 0; iFn < RT_ELEMENTS(s_aFuncs); iFn++) \
    … …  
    15051255            RTTestSub(g_hTest, s_aFuncs[iFn].pszName); \
    15061256            BINU ## a_cBits ## _TEST_T const * const paTests = s_aFuncs[iFn].paTests; \
    1507             uint32_t const                           cTests  = s_aFuncs[iFn].cTests; \
     1257            uint32_t const                           cTests  = *s_aFuncs[iFn].pcTests; \
     1258            if (!cTests) RTTestSkipped(g_hTest, "no tests"); \
    15081259            for (uint32_t iTest = 0; iTest < cTests; iTest++) \
    15091260            { \
    … …  
    16831434 * Note! We use BINUxx_TEST_T with the shift value in the uMisc field.
    16841435 */
    1685 
    1686 #ifndef HAVE_SHIFT_DBL_TESTS_AMD
    1687 static const BINU16_TEST_T g_aTests_shrd_u16_amd[] = { {0} };
    1688 static const BINU16_TEST_T g_aTests_shld_u16_amd[] = { {0} };
    1689 static const BINU32_TEST_T g_aTests_shrd_u32_amd[] = { {0} };
    1690 static const BINU32_TEST_T g_aTests_shld_u32_amd[] = { {0} };
    1691 static const BINU64_TEST_T g_aTests_shrd_u64_amd[] = { {0} };
    1692 static const BINU64_TEST_T g_aTests_shld_u64_amd[] = { {0} };
    1693 #endif
    1694 #ifndef HAVE_SHIFT_DBL_TESTS_INTEL
    1695 static const BINU16_TEST_T g_aTests_shrd_u16_intel[] = { {0} };
    1696 static const BINU16_TEST_T g_aTests_shld_u16_intel[] = { {0} };
    1697 static const BINU32_TEST_T g_aTests_shrd_u32_intel[] = { {0} };
    1698 static const BINU32_TEST_T g_aTests_shld_u32_intel[] = { {0} };
    1699 static const BINU64_TEST_T g_aTests_shrd_u64_intel[] = { {0} };
    1700 static const BINU64_TEST_T g_aTests_shld_u64_intel[] = { {0} };
    1701 #endif
    1702 
    17031436#ifdef TSTIEMAIMPL_WITH_GENERATOR
    1704 # define GEN_SHIFT_DBL(a_cBits, a_Fmt, a_aSubTests) \
     1437# define GEN_SHIFT_DBL(a_cBits, a_Fmt, a_TestType, a_aSubTests) \
    17051438void ShiftDblU ## a_cBits ## Generate(PRTSTREAM pOut, uint32_t cTests) \
    17061439{ \
    … …  
    17101443            && a_aSubTests[iFn].idxCpuEflFlavour != g_idxCpuEflFlavour) \
    17111444            continue; \
    1712         RTStrmPrintf(pOut, "static const BINU" #a_cBits "_TEST_T g_aTests_%s[] =\n{\n", a_aSubTests[iFn].pszName); \
     1445        GenerateArrayStart(pOut, a_aSubTests[iFn].pszName, #a_TestType); \
    17131446        for (uint32_t iTest = 0; iTest < cTests; iTest++ ) \
    17141447        { \
    1715             BINU ## a_cBits ## _TEST_T Test; \
     1448            a_TestType Test; \
    17161449            Test.fEflIn    = RandEFlags(); \
    17171450            Test.fEflOut   = Test.fEflIn; \
    … …  
    17241457                        Test.fEflIn, Test.fEflOut, Test.uDstIn, Test.uDstOut, Test.uSrcIn, Test.uMisc, iTest); \
    17251458        } \
    1726         RTStrmPrintf(pOut, "};\n"); \
     1459        GenerateArrayEnd(pOut, a_aSubTests[iFn].pszName); \
    17271460    } \
    17281461}
    17291462#else
    1730 # define GEN_SHIFT_DBL(a_cBits, a_Fmt, a_aSubTests)
     1463# define GEN_SHIFT_DBL(a_cBits, a_Fmt, a_TestType, a_aSubTests)
    17311464#endif
    17321465
    1733 #define TEST_SHIFT_DBL(a_cBits, a_Type, a_Fmt, a_aSubTests) \
    1734 static const struct \
    1735 { \
    1736     const char                       *pszName; \
    1737     PFNIEMAIMPLSHIFTDBLU ## a_cBits   pfn; \
    1738     PFNIEMAIMPLSHIFTDBLU ## a_cBits   pfnNative; \
    1739     BINU ## a_cBits ## _TEST_T const *paTests; \
    1740     uint32_t                          cTests, uExtra; \
    1741     uint8_t                           idxCpuEflFlavour; \
    1742 } a_aSubTests[] = \
     1466#define TEST_SHIFT_DBL(a_cBits, a_Type, a_Fmt, a_TestType, a_SubTestType, a_aSubTests) \
     1467TYPEDEF_SUBTEST_TYPE(a_SubTestType, a_TestType, PFNIEMAIMPLSHIFTDBLU ## a_cBits); \
     1468\
     1469static a_SubTestType const a_aSubTests[] = \
    17431470{ \
    17441471    ENTRY_AMD(shld_u ## a_cBits,   X86_EFL_OF | X86_EFL_CF), \
    … …  
    17481475}; \
    17491476\
    1750 GEN_SHIFT_DBL(a_cBits, a_Fmt, a_aSubTests) \
     1477GEN_SHIFT_DBL(a_cBits, a_Fmt, a_TestType, a_aSubTests) \
    17511478\
    17521479static void ShiftDblU ## a_cBits ## Test(void) \
    … …  
    17551482    { \
    17561483        RTTestSub(g_hTest, a_aSubTests[iFn].pszName); \
    1757         BINU ## a_cBits ## _TEST_T const * const paTests = a_aSubTests[iFn].paTests; \
    1758         uint32_t const                           cTests  = a_aSubTests[iFn].cTests; \
    1759         PFNIEMAIMPLSHIFTDBLU ## a_cBits          pfn     = a_aSubTests[iFn].pfn; \
     1484        a_TestType const * const        paTests = a_aSubTests[iFn].paTests; \
     1485        PFNIEMAIMPLSHIFTDBLU ## a_cBits pfn     = a_aSubTests[iFn].pfn; \
     1486        uint32_t const                  cTests  = *a_aSubTests[iFn].pcTests; \
    17601487        uint32_t const cVars = 1 + (a_aSubTests[iFn].idxCpuEflFlavour == g_idxCpuEflFlavour && a_aSubTests[iFn].pfnNative); \
     1488        if (!cTests) RTTestSkipped(g_hTest, "no tests"); \
    17611489        for (uint32_t iVar = 0; iVar < cVars; iVar++) \
    17621490        { \
    … …  
    17861514    } \
    17871515}
    1788 TEST_SHIFT_DBL(16, uint16_t, "%#06RX16",  g_aShiftDblU16)
    1789 TEST_SHIFT_DBL(32, uint32_t, "%#010RX32", g_aShiftDblU32)
    1790 TEST_SHIFT_DBL(64, uint64_t, "%#018RX64", g_aShiftDblU64)
     1516TEST_SHIFT_DBL(16, uint16_t, "%#06RX16",  BINU16_TEST_T, SHIFT_DBL_U16_T, g_aShiftDblU16)
     1517TEST_SHIFT_DBL(32, uint32_t, "%#010RX32", BINU32_TEST_T, SHIFT_DBL_U32_T, g_aShiftDblU32)
     1518TEST_SHIFT_DBL(64, uint64_t, "%#018RX64", BINU64_TEST_T, SHIFT_DBL_U64_T, g_aShiftDblU64)
    17911519
    17921520#ifdef TSTIEMAIMPL_WITH_GENERATOR
    1793 static void ShiftDblGenerate(PRTSTREAM pOut, const char *pszCpuSuffU, uint32_t cTests)
    1794 {
    1795     RTStrmPrintf(pOut, "\n\n#define HAVE_SHIFT_DBL_TESTS%s\n", pszCpuSuffU);
     1521static void ShiftDblGenerate(PRTSTREAM pOut, uint32_t cTests)
     1522{
    17961523    ShiftDblU16Generate(pOut, cTests);
    17971524    ShiftDblU32Generate(pOut, cTests);
    … …  
    18131540 * Note! We use BINUxx_TEST_T ignoreing uSrcIn and uMisc.
    18141541 */
    1815 
    1816 #ifndef HAVE_UNARY_TESTS
    1817 # define DUMMY_UNARY_TESTS(a_cBits, a_Type) \
    1818     static const a_Type g_aTests_inc_u ## a_cBits[] = { {0} }; \
    1819     static const a_Type g_aTests_inc_u ## a_cBits ## _locked[] = { {0} }; \
    1820     static const a_Type g_aTests_dec_u ## a_cBits[] = { {0} }; \
    1821     static const a_Type g_aTests_dec_u ## a_cBits ## _locked[] = { {0} }; \
    1822     static const a_Type g_aTests_not_u ## a_cBits[] = { {0} }; \
    1823     static const a_Type g_aTests_not_u ## a_cBits ## _locked[] = { {0} }; \
    1824     static const a_Type g_aTests_neg_u ## a_cBits[] = { {0} }; \
    1825     static const a_Type g_aTests_neg_u ## a_cBits ## _locked[] = { {0} }
    1826 DUMMY_UNARY_TESTS(8,  BINU8_TEST_T);
    1827 DUMMY_UNARY_TESTS(16, BINU16_TEST_T);
    1828 DUMMY_UNARY_TESTS(32, BINU32_TEST_T);
    1829 DUMMY_UNARY_TESTS(64, BINU64_TEST_T);
    1830 #endif
    1831 
    1832 #define TEST_UNARY(a_cBits, a_Type, a_Fmt, a_TestType) \
    1833 static const struct \
    1834 { \
    1835     const char                  *pszName; \
    1836     PFNIEMAIMPLUNARYU ## a_cBits pfn; \
    1837     PFNIEMAIMPLUNARYU ## a_cBits pfnNative; \
    1838     a_TestType const            *paTests; \
    1839     uint32_t                     cTests, uExtra; \
    1840     uint8_t                      idxCpuEflFlavour; \
    1841 } g_aUnaryU ## a_cBits [] = \
    1842 { \
    1843     ENTRY(inc_u ## a_cBits), \
    1844     ENTRY(inc_u ## a_cBits ## _locked), \
    1845     ENTRY(dec_u ## a_cBits), \
    1846     ENTRY(dec_u ## a_cBits ## _locked), \
    1847     ENTRY(not_u ## a_cBits), \
    1848     ENTRY(not_u ## a_cBits ## _locked), \
    1849     ENTRY(neg_u ## a_cBits), \
    1850     ENTRY(neg_u ## a_cBits ## _locked), \
    1851 }; \
    1852 \
     1542#ifdef TSTIEMAIMPL_WITH_GENERATOR
     1543# define GEN_UNARY(a_cBits, a_Type, a_Fmt, a_TestType, a_SubTestType) \
    18531544void UnaryU ## a_cBits ## Generate(PRTSTREAM pOut, uint32_t cTests) \
    18541545{ \
    18551546    for (size_t iFn = 0; iFn < RT_ELEMENTS(g_aUnaryU ## a_cBits); iFn++) \
    18561547    { \
    1857         RTStrmPrintf(pOut, "static const BINU" #a_cBits "_TEST_T g_aTests_%s[] =\n{\n", g_aUnaryU ## a_cBits[iFn].pszName); \
     1548        GenerateArrayStart(pOut, g_aUnaryU ## a_cBits[iFn].pszName, #a_TestType); \
    18581549        for (uint32_t iTest = 0; iTest < cTests; iTest++ ) \
    18591550        { \
    … …  
    18691560                        Test.fEflIn, Test.fEflOut, Test.uDstIn, Test.uDstOut, iTest); \
    18701561        } \
    1871         RTStrmPrintf(pOut, "};\n"); \
     1562        GenerateArrayEnd(pOut, g_aUnaryU ## a_cBits[iFn].pszName); \
    18721563    } \
    1873 } \
     1564}
     1565#else
     1566# define GEN_UNARY(a_cBits, a_Type, a_Fmt, a_TestType, a_SubTestType)
     1567#endif
     1568
     1569#define TEST_UNARY(a_cBits, a_Type, a_Fmt, a_TestType, a_SubTestType) \
     1570TYPEDEF_SUBTEST_TYPE(a_SubTestType, a_TestType, PFNIEMAIMPLUNARYU ## a_cBits); \
     1571static a_SubTestType const g_aUnaryU ## a_cBits [] = \
     1572{ \
     1573    ENTRY(inc_u ## a_cBits), \
     1574    ENTRY(inc_u ## a_cBits ## _locked), \
     1575    ENTRY(dec_u ## a_cBits), \
     1576    ENTRY(dec_u ## a_cBits ## _locked), \
     1577    ENTRY(not_u ## a_cBits), \
     1578    ENTRY(not_u ## a_cBits ## _locked), \
     1579    ENTRY(neg_u ## a_cBits), \
     1580    ENTRY(neg_u ## a_cBits ## _locked), \
     1581}; \
     1582\
     1583GEN_UNARY(a_cBits, a_Type, a_Fmt, a_TestType, a_SubTestType) \
    18741584\
    18751585static void UnaryU ## a_cBits ## Test(void) \
    … …  
    18791589        RTTestSub(g_hTest, g_aUnaryU ## a_cBits[iFn].pszName); \
    18801590        a_TestType const * const paTests = g_aUnaryU ## a_cBits[iFn].paTests; \
    1881         uint32_t const           cTests  = g_aUnaryU ## a_cBits[iFn].cTests; \
     1591        uint32_t const           cTests  = *g_aUnaryU ## a_cBits[iFn].pcTests; \
     1592        if (!cTests) RTTestSkipped(g_hTest, "no tests"); \
    18821593        for (uint32_t iTest = 0; iTest < cTests; iTest++ ) \
    18831594        { \
    … …  
    19021613    } \
    19031614}
    1904 TEST_UNARY(8,  uint8_t,  "%#04RX8",   BINU8_TEST_T)
    1905 TEST_UNARY(16, uint16_t, "%#06RX16",  BINU16_TEST_T)
    1906 TEST_UNARY(32, uint32_t, "%#010RX32", BINU32_TEST_T)
    1907 TEST_UNARY(64, uint64_t, "%#018RX64", BINU64_TEST_T)
     1615TEST_UNARY(8,  uint8_t,  "%#04RX8",   BINU8_TEST_T,  INT_UNARY_U8_T)
     1616TEST_UNARY(16, uint16_t, "%#06RX16",  BINU16_TEST_T, INT_UNARY_U16_T)
     1617TEST_UNARY(32, uint32_t, "%#010RX32", BINU32_TEST_T, INT_UNARY_U32_T)
     1618TEST_UNARY(64, uint64_t, "%#018RX64", BINU64_TEST_T, INT_UNARY_U64_T)
    19081619
    19091620#ifdef TSTIEMAIMPL_WITH_GENERATOR
    19101621static void UnaryGenerate(PRTSTREAM pOut, uint32_t cTests)
    19111622{
    1912     RTStrmPrintf(pOut, "\n\n#define HAVE_UNARY_TESTS\n");
    19131623    UnaryU8Generate(pOut, cTests);
    19141624    UnaryU16Generate(pOut, cTests);
    … …  
    19321642 * Note! We use BINUxx_TEST_T with the shift count in uMisc and uSrcIn unused.
    19331643 */
    1934 #define DUMMY_SHIFT_TESTS(a_cBits, a_Type, a_Vendor) \
    1935     static const a_Type  g_aTests_rol_u ## a_cBits ## a_Vendor[] = { {0} }; \
    1936     static const a_Type  g_aTests_ror_u ## a_cBits ## a_Vendor[] = { {0} }; \
    1937     static const a_Type  g_aTests_rcl_u ## a_cBits ## a_Vendor[] = { {0} }; \
    1938     static const a_Type  g_aTests_rcr_u ## a_cBits ## a_Vendor[] = { {0} }; \
    1939     static const a_Type  g_aTests_shl_u ## a_cBits ## a_Vendor[] = { {0} }; \
    1940     static const a_Type  g_aTests_shr_u ## a_cBits ## a_Vendor[] = { {0} }; \
    1941     static const a_Type  g_aTests_sar_u ## a_cBits ## a_Vendor[] = { {0} }
    1942 #ifndef HAVE_SHIFT_TESTS_AMD
    1943 DUMMY_SHIFT_TESTS(8,  BINU8_TEST_T,  _amd);
    1944 DUMMY_SHIFT_TESTS(16, BINU16_TEST_T, _amd);
    1945 DUMMY_SHIFT_TESTS(32, BINU32_TEST_T, _amd);
    1946 DUMMY_SHIFT_TESTS(64, BINU64_TEST_T, _amd);
    1947 #endif
    1948 #ifndef HAVE_SHIFT_TESTS_INTEL
    1949 DUMMY_SHIFT_TESTS(8,  BINU8_TEST_T,  _intel);
    1950 DUMMY_SHIFT_TESTS(16, BINU16_TEST_T, _intel);
    1951 DUMMY_SHIFT_TESTS(32, BINU32_TEST_T, _intel);
    1952 DUMMY_SHIFT_TESTS(64, BINU64_TEST_T, _intel);
    1953 #endif
    1954 
    19551644#ifdef TSTIEMAIMPL_WITH_GENERATOR
    19561645# define GEN_SHIFT(a_cBits, a_Fmt, a_TestType, a_aSubTests) \
    … …  
    19621651            && a_aSubTests[iFn].idxCpuEflFlavour != g_idxCpuEflFlavour) \
    19631652            continue; \
    1964         RTStrmPrintf(pOut, "static const BINU" #a_cBits "_TEST_T g_aTests_%s[] =\n{\n", a_aSubTests[iFn].pszName); \
     1653        GenerateArrayStart(pOut, a_aSubTests[iFn].pszName, #a_TestType); \
    19651654        for (uint32_t iTest = 0; iTest < cTests; iTest++ ) \
    19661655        { \
    … …  
    19831672                         Test.fEflIn, Test.fEflOut, Test.uDstIn, Test.uDstOut, Test.uMisc, iTest); \
    19841673        } \
    1985         RTStrmPrintf(pOut, "};\n"); \
     1674        GenerateArrayEnd(pOut, a_aSubTests[iFn].pszName); \
    19861675    } \
    19871676}
    … …  
    19901679#endif
    19911680
    1992 #define TEST_SHIFT(a_cBits, a_Type, a_Fmt, a_TestType, a_aSubTests) \
    1993 static const struct \
    1994 { \
    1995     const char                  *pszName; \
    1996     PFNIEMAIMPLSHIFTU ## a_cBits pfn; \
    1997     PFNIEMAIMPLSHIFTU ## a_cBits pfnNative; \
    1998     a_TestType const            *paTests; \
    1999     uint32_t                     cTests, uExtra; \
    2000     uint8_t                      idxCpuEflFlavour; \
    2001 } a_aSubTests[] = \
     1681#define TEST_SHIFT(a_cBits, a_Type, a_Fmt, a_TestType, a_SubTestType, a_aSubTests) \
     1682TYPEDEF_SUBTEST_TYPE(a_SubTestType, a_TestType, PFNIEMAIMPLSHIFTU ## a_cBits); \
     1683static a_SubTestType const a_aSubTests[] = \
    20021684{ \
    20031685    ENTRY_AMD(  rol_u ## a_cBits, X86_EFL_OF), \
    … …  
    20241706    { \
    20251707        RTTestSub(g_hTest, a_aSubTests[iFn].pszName); \
     1708        PFNIEMAIMPLSHIFTU ## a_cBits pfn     = a_aSubTests[iFn].pfn; \
    20261709        a_TestType const * const     paTests = a_aSubTests[iFn].paTests; \
    2027         uint32_t const               cTests  = a_aSubTests[iFn].cTests; \
    2028         PFNIEMAIMPLSHIFTU ## a_cBits pfn     = a_aSubTests[iFn].pfn; \
     1710        uint32_t const               cTests  = *a_aSubTests[iFn].pcTests; \
    20291711        uint32_t const cVars = 1 + (a_aSubTests[iFn].idxCpuEflFlavour == g_idxCpuEflFlavour && a_aSubTests[iFn].pfnNative); \
     1712        if (!cTests) RTTestSkipped(g_hTest, "no tests"); \
    20301713        for (uint32_t iVar = 0; iVar < cVars; iVar++) \
    20311714        { \
    … …  
    20551738    } \
    20561739}
    2057 TEST_SHIFT(8,  uint8_t,  "%#04RX8",   BINU8_TEST_T,  g_aShiftU8)
    2058 TEST_SHIFT(16, uint16_t, "%#06RX16",  BINU16_TEST_T, g_aShiftU16)
    2059 TEST_SHIFT(32, uint32_t, "%#010RX32", BINU32_TEST_T, g_aShiftU32)
    2060 TEST_SHIFT(64, uint64_t, "%#018RX64", BINU64_TEST_T, g_aShiftU64)
     1740TEST_SHIFT(8,  uint8_t,  "%#04RX8",   BINU8_TEST_T,  INT_BINARY_U8_T,  g_aShiftU8)
     1741TEST_SHIFT(16, uint16_t, "%#06RX16",  BINU16_TEST_T, INT_BINARY_U16_T, g_aShiftU16)
     1742TEST_SHIFT(32, uint32_t, "%#010RX32", BINU32_TEST_T, INT_BINARY_U32_T, g_aShiftU32)
     1743TEST_SHIFT(64, uint64_t, "%#018RX64", BINU64_TEST_T, INT_BINARY_U64_T, g_aShiftU64)
    20611744
    20621745#ifdef TSTIEMAIMPL_WITH_GENERATOR
    2063 static void ShiftGenerate(PRTSTREAM pOut, const char *pszCpuSuffU, uint32_t cTests)
    2064 {
    2065     RTStrmPrintf(pOut, "\n\n#define HAVE_SHIFT_TESTS%s\n", pszCpuSuffU);
     1746static void ShiftGenerate(PRTSTREAM pOut, uint32_t cTests)
     1747{
    20661748    ShiftU8Generate(pOut, cTests);
    20671749    ShiftU16Generate(pOut, cTests);
    … …  
    20871769 */
    20881770
    2089 # define DUMMY_MULDIV_TESTS(a_cBits, a_Type, a_Vendor) \
    2090     static const a_Type g_aTests_mul_u ## a_cBits ## a_Vendor[]  = { {0} }; \
    2091     static const a_Type g_aTests_imul_u ## a_cBits ## a_Vendor[] = { {0} }; \
    2092     static const a_Type g_aTests_div_u ## a_cBits ## a_Vendor[]  = { {0} }; \
    2093     static const a_Type g_aTests_idiv_u ## a_cBits ## a_Vendor[] = { {0} }
    2094 
    2095 #ifndef HAVE_MULDIV_TESTS_AMD
    2096 DUMMY_MULDIV_TESTS(8,  MULDIVU8_TEST_T,  _amd);
    2097 DUMMY_MULDIV_TESTS(16, MULDIVU16_TEST_T, _amd);
    2098 DUMMY_MULDIV_TESTS(32, MULDIVU32_TEST_T, _amd);
    2099 DUMMY_MULDIV_TESTS(64, MULDIVU64_TEST_T, _amd);
    2100 #endif
    2101 
    2102 #ifndef HAVE_MULDIV_TESTS_INTEL
    2103 DUMMY_MULDIV_TESTS(8,  MULDIVU8_TEST_T,  _intel);
    2104 DUMMY_MULDIV_TESTS(16, MULDIVU16_TEST_T, _intel);
    2105 DUMMY_MULDIV_TESTS(32, MULDIVU32_TEST_T, _intel);
    2106 DUMMY_MULDIV_TESTS(64, MULDIVU64_TEST_T, _intel);
    2107 #endif
    2108 
    21091771/* U8 */
    2110 static const struct
    2111 {
    2112     const char                     *pszName;
    2113     PFNIEMAIMPLMULDIVU8             pfn;
    2114     PFNIEMAIMPLMULDIVU8             pfnNative;
    2115     MULDIVU8_TEST_T const          *paTests;
    2116     uint32_t                        cTests, uExtra;
    2117     uint8_t                         idxCpuEflFlavour;
    2118 } g_aMulDivU8[] =
     1772TYPEDEF_SUBTEST_TYPE(INT_MULDIV_U8_T, MULDIVU8_TEST_T, PFNIEMAIMPLMULDIVU8);
     1773static INT_MULDIV_U8_T const g_aMulDivU8[] =
    21191774{
    21201775    ENTRY_AMD_EX(mul_u8,    X86_EFL_SF | X86_EFL_ZF | X86_EFL_AF | X86_EFL_PF,
    … …  
    21381793            && g_aMulDivU8[iFn].idxCpuEflFlavour != g_idxCpuEflFlavour)
    21391794            continue;
    2140         RTStrmPrintf(pOut, "static const MULDIVU8_TEST_T g_aTests_%s[] =\n{\n", g_aMulDivU8[iFn].pszName);
     1795        GenerateArrayStart(pOut, g_aMulDivU8[iFn].pszName, "MULDIVU8_TEST_T"); \
    21411796        for (uint32_t iTest = 0; iTest < cTests; iTest++ )
    21421797        {
    … …  
    21511806                         Test.fEflIn, Test.fEflOut, Test.uDstIn, Test.uDstOut, Test.uSrcIn, Test.rc, iTest);
    21521807        }
    2153         RTStrmPrintf(pOut, "};\n");
     1808        GenerateArrayEnd(pOut, g_aMulDivU8[iFn].pszName);
    21541809    }
    21551810}
    … …  
    21621817        RTTestSub(g_hTest, g_aMulDivU8[iFn].pszName);
    21631818        MULDIVU8_TEST_T const * const paTests = g_aMulDivU8[iFn].paTests;
    2164         uint32_t const                cTests  = g_aMulDivU8[iFn].cTests;
     1819        uint32_t const                cTests  = *g_aMulDivU8[iFn].pcTests;
    21651820        uint32_t const                fEflIgn = g_aMulDivU8[iFn].uExtra;
    21661821        PFNIEMAIMPLMULDIVU8           pfn     = g_aMulDivU8[iFn].pfn;
    21671822        uint32_t const cVars = 1 + (g_aMulDivU8[iFn].idxCpuEflFlavour == g_idxCpuEflFlavour && g_aMulDivU8[iFn].pfnNative);
     1823        if (!cTests) RTTestSkipped(g_hTest, "no tests");
    21681824        for (uint32_t iVar = 0; iVar < cVars; iVar++)
    21691825        {
    … …  
    22071863            && a_aSubTests[iFn].idxCpuEflFlavour != g_idxCpuEflFlavour) \
    22081864            continue; \
    2209         RTStrmPrintf(pOut, "static const MULDIVU" #a_cBits "_TEST_T g_aTests_%s[] =\n{\n", a_aSubTests[iFn].pszName); \
     1865        GenerateArrayStart(pOut, a_aSubTests[iFn].pszName, #a_TestType); \
    22101866        for (uint32_t iTest = 0; iTest < cTests; iTest++ ) \
    22111867        { \
    … …  
    22231879                        Test.rc, iTest); \
    22241880        } \
    2225         RTStrmPrintf(pOut, "};\n"); \
     1881        GenerateArrayEnd(pOut, a_aSubTests[iFn].pszName); \
    22261882    } \
    22271883}
    … …  
    22301886#endif
    22311887
    2232 #define TEST_MULDIV(a_cBits, a_Type, a_Fmt, a_TestType, a_aSubTests) \
    2233 static const struct \
    2234 { \
    2235     const char                     *pszName; \
    2236     PFNIEMAIMPLMULDIVU ## a_cBits   pfn; \
    2237     PFNIEMAIMPLMULDIVU ## a_cBits   pfnNative; \
    2238     a_TestType const               *paTests; \
    2239     uint32_t                        cTests, uExtra; \
    2240     uint8_t                         idxCpuEflFlavour; \
    2241 } a_aSubTests [] = \
     1888#define TEST_MULDIV(a_cBits, a_Type, a_Fmt, a_TestType, a_SubTestType, a_aSubTests) \
     1889TYPEDEF_SUBTEST_TYPE(a_SubTestType, a_TestType, PFNIEMAIMPLMULDIVU ## a_cBits); \
     1890static a_SubTestType const a_aSubTests [] = \
    22421891{ \
    22431892    ENTRY_AMD_EX(mul_u ## a_cBits,    X86_EFL_SF | X86_EFL_ZF | X86_EFL_AF | X86_EFL_PF, 0), \
    … …  
    22591908        RTTestSub(g_hTest, a_aSubTests[iFn].pszName); \
    22601909        a_TestType const * const      paTests = a_aSubTests[iFn].paTests; \
    2261         uint32_t const                cTests  = a_aSubTests[iFn].cTests; \
     1910        uint32_t const                cTests  = *a_aSubTests[iFn].pcTests; \
    22621911        uint32_t const                fEflIgn = a_aSubTests[iFn].uExtra; \
    22631912        PFNIEMAIMPLMULDIVU ## a_cBits pfn     = a_aSubTests[iFn].pfn; \
    22641913        uint32_t const cVars = 1 + (a_aSubTests[iFn].idxCpuEflFlavour == g_idxCpuEflFlavour && a_aSubTests[iFn].pfnNative); \
     1914        if (!cTests) RTTestSkipped(g_hTest, "no tests"); \
    22651915        for (uint32_t iVar = 0; iVar < cVars; iVar++) \
    22661916        { \
    … …  
    23011951    } \
    23021952}
    2303 TEST_MULDIV(16, uint16_t, "%#06RX16",  MULDIVU16_TEST_T, g_aMulDivU16)
    2304 TEST_MULDIV(32, uint32_t, "%#010RX32", MULDIVU32_TEST_T, g_aMulDivU32)
    2305 TEST_MULDIV(64, uint64_t, "%#018RX64", MULDIVU64_TEST_T, g_aMulDivU64)
     1953TEST_MULDIV(16, uint16_t, "%#06RX16",  MULDIVU16_TEST_T, INT_MULDIV_U16_T, g_aMulDivU16)
     1954TEST_MULDIV(32, uint32_t, "%#010RX32", MULDIVU32_TEST_T, INT_MULDIV_U32_T, g_aMulDivU32)
     1955TEST_MULDIV(64, uint64_t, "%#018RX64", MULDIVU64_TEST_T, INT_MULDIV_U64_T, g_aMulDivU64)
    23061956
    23071957#ifdef TSTIEMAIMPL_WITH_GENERATOR
    2308 static void MulDivGenerate(PRTSTREAM pOut, const char *pszCpuSuffU, uint32_t cTests)
    2309 {
    2310     RTStrmPrintf(pOut, "\n\n#define HAVE_MULDIV_TESTS%s\n", pszCpuSuffU);
     1958static void MulDivGenerate(PRTSTREAM pOut, uint32_t cTests)
     1959{
    23111960    MulDivU8Generate(pOut, cTests);
    23121961    MulDivU16Generate(pOut, cTests);
    … …  
    23632012*********************************************************************************************************************************/
    23642013
    2365 typedef struct FPU_LD_CONST_TEST_T
    2366 {
    2367     uint16_t                fFcw;
    2368     uint16_t                fFswIn;
    2369     uint16_t                fFswOut;
    2370     RTFLOAT80U              rdResult;
    2371 } FPU_LD_CONST_TEST_T;
    2372 
    2373 typedef struct FPU_R32_IN_TEST_T
    2374 {
    2375     uint16_t                fFcw;
    2376     uint16_t                fFswIn;
    2377     uint16_t                fFswOut;
    2378     RTFLOAT80U              rdResult;
    2379     RTFLOAT32U              InVal;
    2380 } FPU_R32_IN_TEST_T;
    2381 
    2382 typedef struct FPU_R64_IN_TEST_T
    2383 {
    2384     uint16_t                fFcw;
    2385     uint16_t                fFswIn;
    2386     uint16_t                fFswOut;
    2387     RTFLOAT80U              rdResult;
    2388     RTFLOAT64U              InVal;
    2389 } FPU_R64_IN_TEST_T;
    2390 
    2391 typedef struct FPU_R80_IN_TEST_T
    2392 {
    2393     uint16_t                fFcw;
    2394     uint16_t                fFswIn;
    2395     uint16_t                fFswOut;
    2396     RTFLOAT80U              rdResult;
    2397     RTFLOAT80U              InVal;
    2398 } FPU_R80_IN_TEST_T;
    2399 
    2400 typedef struct FPU_I16_IN_TEST_T
    2401 {
    2402     uint16_t                fFcw;
    2403     uint16_t                fFswIn;
    2404     uint16_t                fFswOut;
    2405     RTFLOAT80U              rdResult;
    2406     int16_t                 iInVal;
    2407 } FPU_I16_IN_TEST_T;
    2408 
    2409 typedef struct FPU_I32_IN_TEST_T
    2410 {
    2411     uint16_t                fFcw;
    2412     uint16_t                fFswIn;
    2413     uint16_t                fFswOut;
    2414     RTFLOAT80U              rdResult;
    2415     int32_t                 iInVal;
    2416 } FPU_I32_IN_TEST_T;
    2417 
    2418 typedef struct FPU_I64_IN_TEST_T
    2419 {
    2420     uint16_t                fFcw;
    2421     uint16_t                fFswIn;
    2422     uint16_t                fFswOut;
    2423     RTFLOAT80U              rdResult;
    2424     int64_t                 iInVal;
    2425 } FPU_I64_IN_TEST_T;
    2426 
    2427 typedef struct FPU_D80_IN_TEST_T
    2428 {
    2429     uint16_t                fFcw;
    2430     uint16_t                fFswIn;
    2431     uint16_t                fFswOut;
    2432     RTFLOAT80U              rdResult;
    2433     RTPBCD80U               InVal;
    2434 } FPU_D80_IN_TEST_T;
    2435 
    2436 typedef struct FPU_ST_R32_TEST_T
    2437 {
    2438     uint16_t                fFcw;
    2439     uint16_t                fFswIn;
    2440     uint16_t                fFswOut;
    2441     RTFLOAT80U              InVal;
    2442     RTFLOAT32U              OutVal;
    2443 } FPU_ST_R32_TEST_T;
    2444 
    2445 typedef struct FPU_ST_R64_TEST_T
    2446 {
    2447     uint16_t                fFcw;
    2448     uint16_t                fFswIn;
    2449     uint16_t                fFswOut;
    2450     RTFLOAT80U              InVal;
    2451     RTFLOAT64U              OutVal;
    2452 } FPU_ST_R64_TEST_T;
    2453 
    2454 typedef struct FPU_ST_R80_TEST_T
    2455 {
    2456     uint16_t                fFcw;
    2457     uint16_t                fFswIn;
    2458     uint16_t                fFswOut;
    2459     RTFLOAT80U              InVal;
    2460     RTFLOAT80U              OutVal;
    2461 } FPU_ST_R80_TEST_T;
    2462 
    2463 typedef struct FPU_ST_I16_TEST_T
    2464 {
    2465     uint16_t                fFcw;
    2466     uint16_t                fFswIn;
    2467     uint16_t                fFswOut;
    2468     RTFLOAT80U              InVal;
    2469     int16_t                 iOutVal;
    2470 } FPU_ST_I16_TEST_T;
    2471 
    2472 typedef struct FPU_ST_I32_TEST_T
    2473 {
    2474     uint16_t                fFcw;
    2475     uint16_t                fFswIn;
    2476     uint16_t                fFswOut;
    2477     RTFLOAT80U              InVal;
    2478     int32_t                 iOutVal;
    2479 } FPU_ST_I32_TEST_T;
    2480 
    2481 typedef struct FPU_ST_I64_TEST_T
    2482 {
    2483     uint16_t                fFcw;
    2484     uint16_t                fFswIn;
    2485     uint16_t                fFswOut;
    2486     RTFLOAT80U              InVal;
    2487     int64_t                 iOutVal;
    2488 } FPU_ST_I64_TEST_T;
    2489 
    2490 typedef struct FPU_ST_D80_TEST_T
    2491 {
    2492     uint16_t                fFcw;
    2493     uint16_t                fFswIn;
    2494     uint16_t                fFswOut;
    2495     RTFLOAT80U              InVal;
    2496     RTPBCD80U               OutVal;
    2497 } FPU_ST_D80_TEST_T;
    2498 
    2499 #include "tstIEMAImplDataFpuLdSt.h"
    2500 
    2501 
    25022014/*
    25032015 * FPU constant loading.
    25042016 */
    2505 
    2506 #ifndef HAVE_FPU_LOAD_CONST_TESTS
    2507 static const FPU_LD_CONST_TEST_T g_aTests_fld1[]   = { {0} };
    2508 static const FPU_LD_CONST_TEST_T g_aTests_fldl2t[] = { {0} };
    2509 static const FPU_LD_CONST_TEST_T g_aTests_fldl2e[] = { {0} };
    2510 static const FPU_LD_CONST_TEST_T g_aTests_fldpi[]  = { {0} };
    2511 static const FPU_LD_CONST_TEST_T g_aTests_fldlg2[] = { {0} };
    2512 static const FPU_LD_CONST_TEST_T g_aTests_fldln2[] = { {0} };
    2513 static const FPU_LD_CONST_TEST_T g_aTests_fldz[]   = { {0} };
    2514 #endif
    2515 
    2516 typedef struct FPU_LD_CONST_T
    2517 {
    2518     const char                 *pszName;
    2519     PFNIEMAIMPLFPUR80LDCONST    pfn;
    2520     PFNIEMAIMPLFPUR80LDCONST    pfnNative;
    2521     FPU_LD_CONST_TEST_T const  *paTests;
    2522     uint32_t                    cTests;
    2523     uint32_t                    uExtra;
    2524     uint8_t                     idxCpuEflFlavour;
    2525 } FPU_LD_CONST_T;
     2017TYPEDEF_SUBTEST_TYPE(FPU_LD_CONST_T, FPU_LD_CONST_TEST_T, PFNIEMAIMPLFPUR80LDCONST);
    25262018
    25272019static const FPU_LD_CONST_T g_aFpuLdConst[] =
    … …  
    25392031static void FpuLdConstGenerate(PRTSTREAM pOut, uint32_t cTests)
    25402032{
    2541     RTStrmPrintf(pOut, "\n\n#define HAVE_FPU_LOAD_CONST_TESTS\n");
    25422033    X86FXSTATE State;
    25432034    RT_ZERO(State);
    25442035    for (size_t iFn = 0; iFn < RT_ELEMENTS(g_aFpuLdConst); iFn++)
    25452036    {
    2546         RTStrmPrintf(pOut, "static const FPU_LD_CONST_TEST_T g_aTests_%s[] =\n{\n", g_aFpuLdConst[iFn].pszName);
     2037        GenerateArrayStart(pOut, g_aFpuLdConst[iFn].pszName, "FPU_LD_CONST_TEST_T");
    25472038        for (uint32_t iTest = 0; iTest < cTests; iTest += 4)
    25482039        {
    … …  
    25592050            }
    25602051        }
    2561         RTStrmPrintf(pOut, "};\n");
     2052        GenerateArrayEnd(pOut, g_aFpuLdConst[iFn].pszName);
    25622053    }
    25632054}
    … …  
    25792070        RTTestSub(g_hTest, g_aFpuLdConst[iFn].pszName);
    25802071
    2581         uint32_t const              cTests  = g_aFpuLdConst[iFn].cTests;
     2072        uint32_t const              cTests  = *g_aFpuLdConst[iFn].pcTests;
    25822073        FPU_LD_CONST_TEST_T const  *paTests = g_aFpuLdConst[iFn].paTests;
    25832074        PFNIEMAIMPLFPUR80LDCONST    pfn     = g_aFpuLdConst[iFn].pfn;
    25842075        uint32_t const cVars = 1 + (g_aFpuLdConst[iFn].idxCpuEflFlavour == g_idxCpuEflFlavour && g_aFpuLdConst[iFn].pfnNative);
     2076        if (!cTests) RTTestSkipped(g_hTest, "no tests");
    25852077        for (uint32_t iVar = 0; iVar < cVars; iVar++)
    25862078        {
    … …  
    26102102 * Load floating point values from memory.
    26112103 */
    2612 
    2613 #ifndef HAVE_FPU_LD_MEM
    2614 static FPU_R80_IN_TEST_T const g_aTests_fld_r80_from_r80[] = { {0} };
    2615 static FPU_R64_IN_TEST_T const g_aTests_fld_r80_from_r64[] = { {0} };
    2616 static FPU_R32_IN_TEST_T const g_aTests_fld_r80_from_r32[] = { {0} };
    2617 #endif
    2618 
    26192104#ifdef TSTIEMAIMPL_WITH_GENERATOR
    26202105# define GEN_FPU_LOAD(a_cBits, a_rdTypeIn, a_aSubTests, a_TestType) \
    … …  
    26252110    for (size_t iFn = 0; iFn < RT_ELEMENTS(a_aSubTests); iFn++) \
    26262111    { \
    2627         RTStrmPrintf(pOut, "static const " #a_TestType " g_aTests_%s[] =\n{\n", a_aSubTests[iFn].pszName); \
     2112        GenerateArrayStart(pOut, a_aSubTests[iFn].pszName, #a_TestType); \
    26282113        for (uint32_t iTest = 0; iTest < cTests; iTest++) \
    26292114        { \
    … …  
    26422127            } \
    26432128        } \
    2644         RTStrmPrintf(pOut, "};\n"); \
     2129        GenerateArrayEnd(pOut, a_aSubTests[iFn].pszName); \
    26452130    } \
    26462131}
    … …  
    26522137typedef IEM_DECL_IMPL_TYPE(void, FNIEMAIMPLFPULDR80FROM ## a_cBits,(PCX86FXSTATE, PIEMFPURESULT, PC ## a_rdTypeIn)); \
    26532138typedef FNIEMAIMPLFPULDR80FROM ## a_cBits *PFNIEMAIMPLFPULDR80FROM ## a_cBits; \
    2654 typedef struct a_SubTestType \
    2655 { \
    2656     const char                             *pszName; \
    2657     PFNIEMAIMPLFPULDR80FROM ## a_cBits      pfn, pfnNative; \
    2658     a_TestType const                       *paTests; \
    2659     uint32_t                                cTests; \
    2660     uint32_t                                uExtra; \
    2661     uint8_t                                 idxCpuEflFlavour; \
    2662 } a_SubTestType; \
     2139TYPEDEF_SUBTEST_TYPE(a_SubTestType, a_TestType, PFNIEMAIMPLFPULDR80FROM ## a_cBits); \
    26632140\
    26642141static const a_SubTestType a_aSubTests[] = \
    … …  
    26762153        RTTestSub(g_hTest, a_aSubTests[iFn].pszName); \
    26772154        \
    2678         uint32_t const                     cTests  = a_aSubTests[iFn].cTests; \
     2155        uint32_t const                     cTests  = *a_aSubTests[iFn].pcTests; \
    26792156        a_TestType const           * const paTests = a_aSubTests[iFn].paTests; \
    26802157        PFNIEMAIMPLFPULDR80FROM ## a_cBits pfn     = a_aSubTests[iFn].pfn; \
    26812158        uint32_t const cVars = 1 + (a_aSubTests[iFn].idxCpuEflFlavour == g_idxCpuEflFlavour && a_aSubTests[iFn].pfnNative); \
     2159        if (!cTests) RTTestSkipped(g_hTest, "no tests"); \
    26822160        for (uint32_t iVar = 0; iVar < cVars; iVar++) \
    26832161        { \
    … …  
    27142192static void FpuLdMemGenerate(PRTSTREAM pOut, uint32_t cTests)
    27152193{
    2716     RTStrmPrintf(pOut, "\n\n#define HAVE_FPU_LD_MEM\n");
    27172194    FpuLdR80Generate(pOut, cTests);
    27182195    FpuLdR64Generate(pOut, cTests);
    … …  
    27322209 * Load integer values from memory.
    27332210 */
    2734 
    2735 #ifndef HAVE_FPU_LD_INT
    2736 static FPU_I64_IN_TEST_T const g_aTests_fild_r80_from_i64[] = { {0} };
    2737 static FPU_I32_IN_TEST_T const g_aTests_fild_r80_from_i32[] = { {0} };
    2738 static FPU_I16_IN_TEST_T const g_aTests_fild_r80_from_i16[] = { {0} };
    2739 #endif
    2740 
    27412211#ifdef TSTIEMAIMPL_WITH_GENERATOR
    27422212# define GEN_FPU_LOAD_INT(a_cBits, a_iTypeIn, a_szFmtIn, a_aSubTests, a_TestType) \
    … …  
    27472217    for (size_t iFn = 0; iFn < RT_ELEMENTS(a_aSubTests); iFn++) \
    27482218    { \
    2749         RTStrmPrintf(pOut, "static const " #a_TestType " g_aTests_%s[] =\n{\n", a_aSubTests[iFn].pszName); \
     2219        GenerateArrayStart(pOut, a_aSubTests[iFn].pszName, #a_TestType); \
    27502220        for (uint32_t iTest = 0; iTest < cTests; iTest++) \
    27512221        { \
    … …  
    27632233            } \
    27642234        } \
    2765         RTStrmPrintf(pOut, "};\n"); \
     2235        GenerateArrayEnd(pOut, a_aSubTests[iFn].pszName); \
    27662236    } \
    27672237}
    … …  
    27732243typedef IEM_DECL_IMPL_TYPE(void, FNIEMAIMPLFPULDR80FROMI ## a_cBits,(PCX86FXSTATE, PIEMFPURESULT, a_iTypeIn const *)); \
    27742244typedef FNIEMAIMPLFPULDR80FROMI ## a_cBits *PFNIEMAIMPLFPULDR80FROMI ## a_cBits; \
    2775 typedef struct a_SubTestType \
    2776 { \
    2777     const char                             *pszName; \
    2778     PFNIEMAIMPLFPULDR80FROMI ## a_cBits      pfn, pfnNative; \
    2779     a_TestType const                       *paTests; \
    2780     uint32_t                                cTests; \
    2781     uint32_t                                uExtra; \
    2782     uint8_t                                 idxCpuEflFlavour; \
    2783 } a_SubTestType; \
     2245TYPEDEF_SUBTEST_TYPE(a_SubTestType, a_TestType, PFNIEMAIMPLFPULDR80FROMI ## a_cBits); \
    27842246\
    27852247static const a_SubTestType a_aSubTests[] = \
    … …  
    27972259        RTTestSub(g_hTest, a_aSubTests[iFn].pszName); \
    27982260        \
    2799         uint32_t const                      cTests  = a_aSubTests[iFn].cTests; \
     2261        uint32_t const                      cTests  = *a_aSubTests[iFn].pcTests; \
    28002262        a_TestType const            * const paTests = a_aSubTests[iFn].paTests; \
    28012263        PFNIEMAIMPLFPULDR80FROMI ## a_cBits pfn     = a_aSubTests[iFn].pfn; \
    28022264        uint32_t const cVars = 1 + (a_aSubTests[iFn].idxCpuEflFlavour == g_idxCpuEflFlavour && a_aSubTests[iFn].pfnNative); \
     2265        if (!cTests) RTTestSkipped(g_hTest, "no tests"); \
    28032266        for (uint32_t iVar = 0; iVar < cVars; iVar++) \
    28042267        { \
    … …  
    28342297static void FpuLdIntGenerate(PRTSTREAM pOut, uint32_t cTests)
    28352298{
    2836     RTStrmPrintf(pOut, "\n\n#define HAVE_FPU_LD_INT\n");
    28372299    FpuLdI64Generate(pOut, cTests);
    28382300    FpuLdI32Generate(pOut, cTests);
    … …  
    28522314 * Load binary coded decimal values from memory.
    28532315 */
    2854 
    2855 #ifndef HAVE_FPU_LD_BCD
    2856 static FPU_D80_IN_TEST_T const g_aTests_fld_r80_from_d80[] = { {0} };
    2857 #endif
    2858 
    28592316typedef IEM_DECL_IMPL_TYPE(void, FNIEMAIMPLFPULDR80FROMD80,(PCX86FXSTATE, PIEMFPURESULT, PCRTPBCD80U));
    28602317typedef FNIEMAIMPLFPULDR80FROMD80 *PFNIEMAIMPLFPULDR80FROMD80;
    2861 typedef struct FPU_LD_D80_T
    2862 {
    2863     const char                 *pszName;
    2864     PFNIEMAIMPLFPULDR80FROMD80  pfn, pfnNative;
    2865     FPU_D80_IN_TEST_T const    *paTests;
    2866     uint32_t                    cTests;
    2867     uint32_t                    uExtra;
    2868     uint8_t                     idxCpuEflFlavour;
    2869 } FPU_LD_D80_T;
     2318TYPEDEF_SUBTEST_TYPE(FPU_LD_D80_T, FPU_D80_IN_TEST_T, PFNIEMAIMPLFPULDR80FROMD80);
    28702319
    28712320static const FPU_LD_D80_T g_aFpuLdD80[] =
    … …  
    28742323};
    28752324
    2876 
    28772325#ifdef TSTIEMAIMPL_WITH_GENERATOR
    28782326static void FpuLdD80Generate(PRTSTREAM pOut, uint32_t cTests)
    28792327{
    2880     RTStrmPrintf(pOut, "\n\n#define HAVE_FPU_LD_BCD\n");
    28812328    X86FXSTATE State;
    28822329    RT_ZERO(State);
    28832330    for (size_t iFn = 0; iFn < RT_ELEMENTS(g_aFpuLdD80); iFn++)
    28842331    {
    2885         RTStrmPrintf(pOut, "static const FPU_D80_IN_TEST_T g_aTests_%s[] =\n{\n", g_aFpuLdD80[iFn].pszName); \
     2332        GenerateArrayStart(pOut, g_aFpuLdD80[iFn].pszName, "FPU_D80_IN_TEST_T");
    28862333        for (uint32_t iTest = 0; iTest < cTests; iTest++)
    28872334        {
    … …  
    29002347            }
    29012348        }
    2902         RTStrmPrintf(pOut, "};\n");
     2349        GenerateArrayEnd(pOut, g_aFpuLdD80[iFn].pszName);
    29032350    }
    29042351}
    … …  
    29132360        RTTestSub(g_hTest, g_aFpuLdD80[iFn].pszName);
    29142361
    2915         uint32_t const                  cTests  = g_aFpuLdD80[iFn].cTests;
     2362        uint32_t const                  cTests  = *g_aFpuLdD80[iFn].pcTests;
    29162363        FPU_D80_IN_TEST_T const * const paTests = g_aFpuLdD80[iFn].paTests;
    29172364        PFNIEMAIMPLFPULDR80FROMD80      pfn     = g_aFpuLdD80[iFn].pfn;
    29182365        uint32_t const cVars = 1 + (g_aFpuLdD80[iFn].idxCpuEflFlavour == g_idxCpuEflFlavour && g_aFpuLdD80[iFn].pfnNative);
     2366        if (!cTests) RTTestSkipped(g_hTest, "no tests");
    29192367        for (uint32_t iVar = 0; iVar < cVars; iVar++)
    29202368        {
    … …  
    29482396 * Store values floating point values to memory.
    29492397 */
    2950 
    2951 #ifndef HAVE_FPU_ST_MEM
    2952 static FPU_ST_R80_TEST_T const g_aTests_fst_r80_to_r80[] = { {0} };
    2953 static FPU_ST_R64_TEST_T const g_aTests_fst_r80_to_r64[] = { {0} };
    2954 static FPU_ST_R32_TEST_T const g_aTests_fst_r80_to_r32[] = { {0} };
    2955 #endif
    2956 
    29572398#ifdef TSTIEMAIMPL_WITH_GENERATOR
    29582399static const RTFLOAT80U g_aFpuStR32Specials[] =
    … …  
    29832424    for (size_t iFn = 0; iFn < RT_ELEMENTS(a_aSubTests); iFn++) \
    29842425    { \
    2985         RTStrmPrintf(pOut, "static const " #a_TestType " g_aTests_%s[] =\n{\n", a_aSubTests[iFn].pszName); \
     2426        GenerateArrayStart(pOut, a_aSubTests[iFn].pszName, #a_TestType); \
    29862427        for (uint32_t iTest = 0; iTest < cTotalTests; iTest++) \
    29872428        { \
    … …  
    30112452            } \
    30122453        } \
    3013         RTStrmPrintf(pOut, "};\n"); \
     2454        GenerateArrayEnd(pOut, a_aSubTests[iFn].pszName); \
    30142455    } \
    30152456}
    … …  
    30222463                                                                   PRTFLOAT ## a_cBits ## U, PCRTFLOAT80U)); \
    30232464typedef FNIEMAIMPLFPUSTR80TOR ## a_cBits *PFNIEMAIMPLFPUSTR80TOR ## a_cBits; \
    3024 typedef struct a_SubTestType \
    3025 { \
    3026     const char                             *pszName; \
    3027     PFNIEMAIMPLFPUSTR80TOR ## a_cBits       pfn, pfnNative; \
    3028     a_TestType const                       *paTests; \
    3029     uint32_t                                cTests; \
    3030     uint32_t                                uExtra; \
    3031     uint8_t                                 idxCpuEflFlavour; \
    3032 } a_SubTestType; \
     2465TYPEDEF_SUBTEST_TYPE(a_SubTestType, a_TestType, PFNIEMAIMPLFPUSTR80TOR ## a_cBits); \
    30332466\
    30342467static const a_SubTestType a_aSubTests[] = \
    … …  
    30462479        RTTestSub(g_hTest, a_aSubTests[iFn].pszName); \
    30472480        \
    3048         uint32_t const                    cTests  = a_aSubTests[iFn].cTests; \
     2481        uint32_t const                    cTests  = *a_aSubTests[iFn].pcTests; \
    30492482        a_TestType const          * const paTests = a_aSubTests[iFn].paTests; \
    30502483        PFNIEMAIMPLFPUSTR80TOR ## a_cBits pfn     = a_aSubTests[iFn].pfn; \
    30512484        uint32_t const cVars = 1 + (a_aSubTests[iFn].idxCpuEflFlavour == g_idxCpuEflFlavour && a_aSubTests[iFn].pfnNative); \
     2485        if (!cTests) RTTestSkipped(g_hTest, "no tests"); \
    30522486        for (uint32_t iVar = 0; iVar < cVars; iVar++) \
    30532487        { \
    … …  
    30872521static void FpuStMemGenerate(PRTSTREAM pOut, uint32_t cTests)
    30882522{
    3089     RTStrmPrintf(pOut, "\n\n#define HAVE_FPU_ST_MEM\n");
    30902523    FpuStR80Generate(pOut, cTests);
    30912524    FpuStR64Generate(pOut, cTests);
    … …  
    31052538 * Store integer values to memory or register.
    31062539 */
    3107 
    3108 #ifndef HAVE_FPU_ST_INT
    3109 static FPU_ST_I64_TEST_T const g_aTests_fist_r80_to_i64[] = { {0} };
    3110 static FPU_ST_I32_TEST_T const g_aTests_fist_r80_to_i32[] = { {0} };
    3111 static FPU_ST_I16_TEST_T const g_aTests_fist_r80_to_i16[] = { {0} };
    3112 static FPU_ST_I64_TEST_T const g_aTests_fistt_r80_to_i64[] = { {0} };
    3113 static FPU_ST_I32_TEST_T const g_aTests_fistt_r80_to_i32[] = { {0} };
    3114 static FPU_ST_I16_TEST_T const g_aTests_fistt_r80_to_i16[] = { {0} };
    3115 #endif
    3116 
    31172540#ifdef TSTIEMAIMPL_WITH_GENERATOR
    31182541static const RTFLOAT80U g_aFpuStI16Specials[] = /* 16-bit variant borrows properties from the 32-bit one, thus all this stuff. */
    … …  
    32132636    for (size_t iFn = 0; iFn < RT_ELEMENTS(a_aSubTests); iFn++) \
    32142637    { \
    3215         RTStrmPrintf(pOut, "static const " #a_TestType " g_aTests_%s[] =\n{\n", a_aSubTests[iFn].pszName); \
     2638        GenerateArrayStart(pOut, a_aSubTests[iFn].pszName, #a_TestType); \
    32162639        uint32_t const cTotalTests = cTests + RT_ELEMENTS(g_aFpuStI ## a_cBits ## Specials); \
    32172640        for (uint32_t iTest = 0; iTest < cTotalTests; iTest++) \
    … …  
    32412664            } \
    32422665        } \
    3243         RTStrmPrintf(pOut, "};\n"); \
     2666        GenerateArrayEnd(pOut, a_aSubTests[iFn].pszName); \
    32442667    } \
    32452668}
    … …  
    32512674typedef IEM_DECL_IMPL_TYPE(void, FNIEMAIMPLFPUSTR80TOI ## a_cBits,(PCX86FXSTATE, uint16_t *, a_iType *, PCRTFLOAT80U)); \
    32522675typedef FNIEMAIMPLFPUSTR80TOI ## a_cBits *PFNIEMAIMPLFPUSTR80TOI ## a_cBits; \
    3253 typedef struct a_SubTestType \
    3254 { \
    3255     const char                             *pszName; \
    3256     PFNIEMAIMPLFPUSTR80TOI ## a_cBits       pfn, pfnNative; \
    3257     a_TestType const                       *paTests; \
    3258     uint32_t                                cTests; \
    3259     uint32_t                                uExtra; \
    3260     uint8_t                                 idxCpuEflFlavour; \
    3261 } a_SubTestType; \
     2676TYPEDEF_SUBTEST_TYPE(a_SubTestType, a_TestType, PFNIEMAIMPLFPUSTR80TOI ## a_cBits); \
    32622677\
    32632678static const a_SubTestType a_aSubTests[] = \
    … …  
    32762691        RTTestSub(g_hTest, a_aSubTests[iFn].pszName); \
    32772692        \
    3278         uint32_t const                    cTests  = a_aSubTests[iFn].cTests; \
     2693        uint32_t const                    cTests  = *a_aSubTests[iFn].pcTests; \
    32792694        a_TestType const          * const paTests = a_aSubTests[iFn].paTests; \
    32802695        PFNIEMAIMPLFPUSTR80TOI ## a_cBits pfn     = a_aSubTests[iFn].pfn; \
    32812696        uint32_t const cVars = 1 + (a_aSubTests[iFn].idxCpuEflFlavour == g_idxCpuEflFlavour && a_aSubTests[iFn].pfnNative); \
     2697        if (!cTests) RTTestSkipped(g_hTest, "no tests"); \
    32822698        for (uint32_t iVar = 0; iVar < cVars; iVar++) \
    32832699        { \
    … …  
    33142730static void FpuStIntGenerate(PRTSTREAM pOut, uint32_t cTests)
    33152731{
    3316     RTStrmPrintf(pOut, "\n\n#define HAVE_FPU_ST_INT\n");
    33172732    FpuStI64Generate(pOut, cTests);
    33182733    FpuStI32Generate(pOut, cTests);
    … …  
    33322747 * Store as packed BCD value (memory).
    33332748 */
    3334 
    3335 #ifndef HAVE_FPU_ST_BCD
    3336 static FPU_ST_D80_TEST_T const g_aTests_fst_r80_to_d80[] = { {0} };
    3337 #endif
    3338 
    33392749typedef IEM_DECL_IMPL_TYPE(void, FNIEMAIMPLFPUSTR80TOD80,(PCX86FXSTATE, uint16_t *, PRTPBCD80U, PCRTFLOAT80U));
    33402750typedef FNIEMAIMPLFPUSTR80TOD80 *PFNIEMAIMPLFPUSTR80TOD80;
    3341 typedef struct FPU_ST_D80_T
    3342 {
    3343     const char                 *pszName;
    3344     PFNIEMAIMPLFPUSTR80TOD80    pfn, pfnNative;
    3345     FPU_ST_D80_TEST_T const    *paTests;
    3346     uint32_t                    cTests;
    3347     uint32_t                    uExtra;
    3348     uint8_t                     idxCpuEflFlavour;
    3349 } FPU_ST_D80_T;
     2751TYPEDEF_SUBTEST_TYPE(FPU_ST_D80_T, FPU_ST_D80_TEST_T, PFNIEMAIMPLFPUSTR80TOD80);
    33502752
    33512753static const FPU_ST_D80_T g_aFpuStD80[] =
    … …  
    33732775    };
    33742776
    3375     RTStrmPrintf(pOut, "\n\n#define HAVE_FPU_ST_BCD\n");
    33762777    X86FXSTATE State;
    33772778    RT_ZERO(State);
    33782779    for (size_t iFn = 0; iFn < RT_ELEMENTS(g_aFpuStD80); iFn++)
    33792780    {
    3380         RTStrmPrintf(pOut, "static const FPU_ST_D80_TEST_T g_aTests_%s[] =\n{\n", g_aFpuStD80[iFn].pszName);
     2781        GenerateArrayStart(pOut, g_aFpuStD80[iFn].pszName, "FPU_ST_D80_TEST_T");
    33812782        for (uint32_t iTest = 0; iTest < cTests + RT_ELEMENTS(s_aSpecials); iTest += 1)
    33822783        {
    … …  
    34042805            }
    34052806        }
    3406         RTStrmPrintf(pOut, "};\n");
     2807        GenerateArrayEnd(pOut, g_aFpuStD80[iFn].pszName);
    34072808    }
    34082809}
    … …  
    34182819        RTTestSub(g_hTest, g_aFpuStD80[iFn].pszName);
    34192820
    3420         uint32_t const                  cTests  = g_aFpuStD80[iFn].cTests;
     2821        uint32_t const                  cTests  = *g_aFpuStD80[iFn].pcTests;
    34212822        FPU_ST_D80_TEST_T const * const paTests = g_aFpuStD80[iFn].paTests;
    34222823        PFNIEMAIMPLFPUSTR80TOD80        pfn     = g_aFpuStD80[iFn].pfn;
    34232824        uint32_t const cVars = 1 + (g_aFpuStD80[iFn].idxCpuEflFlavour == g_idxCpuEflFlavour && g_aFpuStD80[iFn].pfnNative);
     2825        if (!cTests) RTTestSkipped(g_hTest, "no tests");
    34242826        for (uint32_t iVar = 0; iVar < cVars; iVar++)
    34252827        {
    … …  
    34522854
    34532855
    3454 /*
    3455  * Other FPU stuff.
    3456  */
    3457 
    3458 typedef struct FPU_BINARY_R80_TEST_T
    3459 {
    3460     uint16_t                fFcw;
    3461     uint16_t                fFswIn;
    3462     uint16_t                fFswOut;
    3463     RTFLOAT80U              InVal1;
    3464     RTFLOAT80U              InVal2;
    3465     RTFLOAT80U              OutVal;
    3466 } FPU_BINARY_R80_TEST_T;
    3467 
    3468 typedef struct FPU_BINARY_R64_TEST_T
    3469 {
    3470     uint16_t                fFcw;
    3471     uint16_t                fFswIn;
    3472     uint16_t                fFswOut;
    3473     RTFLOAT80U              InVal1;
    3474     RTFLOAT64U              InVal2;
    3475     RTFLOAT80U              OutVal;
    3476 } FPU_BINARY_R64_TEST_T;
    3477 
    3478 typedef struct FPU_BINARY_R32_TEST_T
    3479 {
    3480     uint16_t                fFcw;
    3481     uint16_t                fFswIn;
    3482     uint16_t                fFswOut;
    3483     RTFLOAT80U              InVal1;
    3484     RTFLOAT32U              InVal2;
    3485     RTFLOAT80U              OutVal;
    3486 } FPU_BINARY_R32_TEST_T;
    3487 
    3488 typedef struct FPU_BINARY_EFL_R80_TEST_T
    3489 {
    3490     uint16_t                fFcw;
    3491     uint16_t                fFswIn;
    3492     uint16_t                fFswOut;
    3493     RTFLOAT80U              InVal1;
    3494     RTFLOAT80U              InVal2;
    3495     uint32_t                fEflOut;
    3496 } FPU_BINARY_EFL_R80_TEST_T;
    3497 
    3498 #include "tstIEMAImplDataFpuBinary.h"
    3499 
     2856/*********************************************************************************************************************************
     2857*   x87 FPU Binary Operations                                                                                                    *
     2858*********************************************************************************************************************************/
    35002859
    35012860/*
    35022861 * Binary FPU operations on two 80-bit floating point values.
    35032862 */
    3504 
    3505 #ifndef HAVE_FPU_BINARY_R80
    3506 static FPU_BINARY_R80_TEST_T const g_aTests_fadd_r80_by_r80[]    = { {0} };
    3507 static FPU_BINARY_R80_TEST_T const g_aTests_fsub_r80_by_r80[]    = { {0} };
    3508 static FPU_BINARY_R80_TEST_T const g_aTests_fsubr_r80_by_r80[]   = { {0} };
    3509 static FPU_BINARY_R80_TEST_T const g_aTests_fmul_r80_by_r80[]    = { {0} };
    3510 static FPU_BINARY_R80_TEST_T const g_aTests_fdiv_r80_by_r80[]    = { {0} };
    3511 static FPU_BINARY_R80_TEST_T const g_aTests_fdivr_r80_by_r80[]   = { {0} };
    3512 static FPU_BINARY_R80_TEST_T const g_aTests_fprem_r80_by_r80[]   = { {0} };
    3513 static FPU_BINARY_R80_TEST_T const g_aTests_fprem1_r80_by_r80[]  = { {0} };
    3514 static FPU_BINARY_R80_TEST_T const g_aTests_fscale_r80_by_r80[]  = { {0} };
    3515 static FPU_BINARY_R80_TEST_T const g_aTests_fpatan_r80_by_r80[]  = { {0} };
    3516 static FPU_BINARY_R80_TEST_T const g_aTests_fyl2x_r80_by_r80[]   = { {0} };
    3517 static FPU_BINARY_R80_TEST_T const g_aTests_fyl2xp1_r80_by_r80[] = { {0} };
    3518 #endif
    3519 
    3520 typedef struct FPU_BINARY_R80_T
    3521 {
    3522     const char                     *pszName;
    3523     PFNIEMAIMPLFPUR80               pfn, pfnNative;
    3524     FPU_BINARY_R80_TEST_T const    *paTests;
    3525     uint32_t                        cTests;
    3526     uint32_t                        uExtra;
    3527     uint8_t                         idxCpuEflFlavour;
    3528 } FPU_BINARY_R80_T;
     2863TYPEDEF_SUBTEST_TYPE(FPU_BINARY_R80_T, FPU_BINARY_R80_TEST_T, PFNIEMAIMPLFPUR80);
    35292864
    35302865static const FPU_BINARY_R80_T g_aFpuBinaryR80[] =
    … …  
    35532888    };
    35542889
    3555     RTStrmPrintf(pOut, "\n\n#define HAVE_FPU_BINARY_R80\n");
    35562890    X86FXSTATE State;
    35572891    RT_ZERO(State);
    … …  
    35592893    for (size_t iFn = 0; iFn < RT_ELEMENTS(g_aFpuBinaryR80); iFn++)
    35602894    {
    3561         RTStrmPrintf(pOut, "static const FPU_BINARY_R80_TEST_T g_aTests_%s[] =\n{\n", g_aFpuBinaryR80[iFn].pszName);
     2895        GenerateArrayStart(pOut, g_aFpuBinaryR80[iFn].pszName, "FPU_BINARY_R80_TEST_T");
    35622896        uint32_t cNormalInputPairs = 0;
    35632897        for (uint32_t iTest = 0; iTest < cTests + RT_ELEMENTS(s_aSpecials); iTest += 1)
    … …  
    35952929            }
    35962930        }
    3597         RTStrmPrintf(pOut, "};\n");
     2931        GenerateArrayEnd(pOut, g_aFpuBinaryR80[iFn].pszName);
    35982932    }
    35992933}
    … …  
    36092943        RTTestSub(g_hTest, g_aFpuBinaryR80[iFn].pszName);
    36102944
    3611         uint32_t const                      cTests  = g_aFpuBinaryR80[iFn].cTests;
     2945        uint32_t const                      cTests  = *g_aFpuBinaryR80[iFn].pcTests;
    36122946        FPU_BINARY_R80_TEST_T const * const paTests = g_aFpuBinaryR80[iFn].paTests;
    36132947        PFNIEMAIMPLFPUR80                   pfn     = g_aFpuBinaryR80[iFn].pfn;
    36142948        uint32_t const cVars = 1 + (g_aFpuBinaryR80[iFn].idxCpuEflFlavour == g_idxCpuEflFlavour && g_aFpuBinaryR80[iFn].pfnNative);
     2949        if (!cTests) RTTestSkipped(g_hTest, "no tests");
    36152950        for (uint32_t iVar = 0; iVar < cVars; iVar++)
    36162951        {
    … …  
    36452980 * Binary FPU operations on one 80-bit floating point value and one 64-bit or 32-bit one.
    36462981 */
    3647 
    3648 #ifndef HAVE_FPU_BINARY_R64
    3649 static FPU_BINARY_R64_TEST_T const g_aTests_fadd_r80_by_r64[]   = { {0} };
    3650 static FPU_BINARY_R64_TEST_T const g_aTests_fmul_r80_by_r64[]   = { {0} };
    3651 static FPU_BINARY_R64_TEST_T const g_aTests_fsub_r80_by_r64[]   = { {0} };
    3652 static FPU_BINARY_R64_TEST_T const g_aTests_fsubr_r80_by_r64[]  = { {0} };
    3653 static FPU_BINARY_R64_TEST_T const g_aTests_fdiv_r80_by_r64[]   = { {0} };
    3654 static FPU_BINARY_R64_TEST_T const g_aTests_fdivr_r80_by_r64[]  = { {0} };
    3655 #endif
    3656 #ifndef HAVE_FPU_BINARY_R32
    3657 static FPU_BINARY_R32_TEST_T const g_aTests_fadd_r80_by_r32[]   = { {0} };
    3658 static FPU_BINARY_R32_TEST_T const g_aTests_fmul_r80_by_r32[]   = { {0} };
    3659 static FPU_BINARY_R32_TEST_T const g_aTests_fsub_r80_by_r32[]   = { {0} };
    3660 static FPU_BINARY_R32_TEST_T const g_aTests_fsubr_r80_by_r32[]  = { {0} };
    3661 static FPU_BINARY_R32_TEST_T const g_aTests_fdiv_r80_by_r32[]   = { {0} };
    3662 static FPU_BINARY_R32_TEST_T const g_aTests_fdivr_r80_by_r32[]  = { {0} };
    3663 #endif
    3664 
    36652982#ifdef TSTIEMAIMPL_WITH_GENERATOR
    36662983static struct { RTFLOAT80U Val1; RTFLOAT64U Val2; } const s_aFpuBinaryR64Specials[] =
    … …  
    36782995static void FpuBinaryR ## a_cBits ## Generate(PRTSTREAM pOut, uint32_t cTests) \
    36792996{ \
    3680     RTStrmPrintf(pOut, "\n\n#define HAVE_FPU_BINARY_R" #a_cBits "\n"); \
    36812997    X86FXSTATE State; \
    36822998    RT_ZERO(State); \
    … …  
    36843000    for (size_t iFn = 0; iFn < RT_ELEMENTS(a_aSubTests); iFn++) \
    36853001    { \
    3686         RTStrmPrintf(pOut, "static const " #a_TestType " g_aTests_%s[] =\n{\n", a_aSubTests[iFn].pszName); \
     3002        GenerateArrayStart(pOut, a_aSubTests[iFn].pszName, #a_TestType); \
    36873003        uint32_t cNormalInputPairs = 0; \
    36883004        for (uint32_t iTest = 0; iTest < cTests + RT_ELEMENTS(s_aFpuBinaryR ## a_cBits ## Specials); iTest += 1) \
    … …  
    37223038            } \
    37233039        } \
    3724         RTStrmPrintf(pOut, "};\n"); \
     3040        GenerateArrayEnd(pOut, a_aSubTests[iFn].pszName); \
    37253041    } \
    37263042}
    … …  
    37303046
    37313047#define TEST_FPU_BINARY_SMALL(a_cBits, a_rdType, a_SubTestType, a_aSubTests, a_TestType) \
    3732 typedef struct a_SubTestType \
    3733 { \
    3734     const char                     *pszName; \
    3735     PFNIEMAIMPLFPUR ## a_cBits      pfn, pfnNative; \
    3736     a_TestType const               *paTests; \
    3737     uint32_t                        cTests; \
    3738     uint32_t                        uExtra; \
    3739     uint8_t                         idxCpuEflFlavour; \
    3740 } a_SubTestType; \
     3048TYPEDEF_SUBTEST_TYPE(a_SubTestType, a_TestType, PFNIEMAIMPLFPUR ## a_cBits); \
    37413049\
    37423050static const a_SubTestType a_aSubTests[] = \
    … …  
    37603068        RTTestSub(g_hTest, a_aSubTests[iFn].pszName); \
    37613069        \
    3762         uint32_t const             cTests  = a_aSubTests[iFn].cTests; \
     3070        uint32_t const             cTests  = *a_aSubTests[iFn].pcTests; \
    37633071        a_TestType const * const   paTests = a_aSubTests[iFn].paTests; \
    37643072        PFNIEMAIMPLFPUR ## a_cBits pfn     = a_aSubTests[iFn].pfn; \
    37653073        uint32_t const cVars = 1 + (a_aSubTests[iFn].idxCpuEflFlavour == g_idxCpuEflFlavour && a_aSubTests[iFn].pfnNative); \
     3074        if (!cTests) RTTestSkipped(g_hTest, "no tests"); \
    37663075        for (uint32_t iVar = 0; iVar < cVars; iVar++) \
    37673076        { \
    … …  
    37993108 * Binary operations on 80-, 64- and 32-bit floating point only affecting FSW.
    38003109 */
    3801 #ifndef HAVE_FPU_BINARY_FSW_R80
    3802 static FPU_BINARY_R80_TEST_T const g_aTests_fcom_r80_by_r80[]   = { {0} };
    3803 static FPU_BINARY_R80_TEST_T const g_aTests_fucom_r80_by_r80[]  = { {0} };
    3804 #endif
    3805 #ifndef HAVE_FPU_BINARY_FSW_R64
    3806 static FPU_BINARY_R64_TEST_T const g_aTests_fcom_r80_by_r64[]   = { {0} };
    3807 #endif
    3808 #ifndef HAVE_FPU_BINARY_FSW_R32
    3809 static FPU_BINARY_R32_TEST_T const g_aTests_fcom_r80_by_r32[]   = { {0} };
    3810 #endif
    3811 
    38123110#ifdef TSTIEMAIMPL_WITH_GENERATOR
    38133111static struct { RTFLOAT80U Val1, Val2; } const s_aFpuBinaryFswR80Specials[] =
    … …  
    38303128static void FpuBinaryFswR ## a_cBits ## Generate(PRTSTREAM pOut, uint32_t cTests) \
    38313129{ \
    3832     RTStrmPrintf(pOut, "\n\n#define HAVE_FPU_BINARY_FSW_R" #a_cBits "\n"); \
    38333130    X86FXSTATE State; \
    38343131    RT_ZERO(State); \
    … …  
    38363133    for (size_t iFn = 0; iFn < RT_ELEMENTS(a_aSubTests); iFn++) \
    38373134    { \
    3838         RTStrmPrintf(pOut, "static const " #a_TestType " g_aTests_%s[] =\n{\n", a_aSubTests[iFn].pszName); \
     3135        GenerateArrayStart(pOut, a_aSubTests[iFn].pszName, #a_TestType); \
    38393136        uint32_t cNormalInputPairs = 0; \
    38403137        for (uint32_t iTest = 0; iTest < cTests + RT_ELEMENTS(s_aFpuBinaryFswR ## a_cBits ## Specials); iTest += 1) \
    … …  
    38663163            } \
    38673164        } \
    3868         RTStrmPrintf(pOut, "};\n"); \
     3165        GenerateArrayEnd(pOut, a_aSubTests[iFn].pszName); \
    38693166    } \
    38703167}
    … …  
    38743171
    38753172#define TEST_FPU_BINARY_FSW(a_cBits, a_rdType, a_SubTestType, a_aSubTests, a_TestType, ...) \
    3876 typedef struct a_SubTestType \
    3877 { \
    3878     const char                         *pszName; \
    3879     PFNIEMAIMPLFPUR ## a_cBits ## FSW   pfn, pfnNative; \
    3880     a_TestType const                   *paTests; \
    3881     uint32_t                            cTests; \
    3882     uint32_t                            uExtra; \
    3883     uint8_t                             idxCpuEflFlavour; \
    3884 } a_SubTestType; \
     3173TYPEDEF_SUBTEST_TYPE(a_SubTestType, a_TestType, PFNIEMAIMPLFPUR ## a_cBits ## FSW); \
    38853174\
    38863175static const a_SubTestType a_aSubTests[] = \
    … …  
    39003189        RTTestSub(g_hTest, a_aSubTests[iFn].pszName); \
    39013190        \
    3902         uint32_t const                      cTests  = a_aSubTests[iFn].cTests; \
     3191        uint32_t const                      cTests  = *a_aSubTests[iFn].pcTests; \
    39033192        a_TestType const * const            paTests = a_aSubTests[iFn].paTests; \
    39043193        PFNIEMAIMPLFPUR ## a_cBits ## FSW   pfn     = a_aSubTests[iFn].pfn; \
    39053194        uint32_t const cVars = 1 + (a_aSubTests[iFn].idxCpuEflFlavour == g_idxCpuEflFlavour && a_aSubTests[iFn].pfnNative); \
     3195        if (!cTests) RTTestSkipped(g_hTest, "no tests"); \
    39063196        for (uint32_t iVar = 0; iVar < cVars; iVar++) \
    39073197        { \
    … …  
    39373227 * Binary operations on 80-bit floating point that effects only EFLAGS and possibly FSW.
    39383228 */
    3939 #ifndef HAVE_FPU_BINARY_EFL_R80
    3940 static FPU_BINARY_EFL_R80_TEST_T const g_aTests_fcomi_r80_by_r80[]  = { {0} };
    3941 static FPU_BINARY_EFL_R80_TEST_T const g_aTests_fucomi_r80_by_r80[] = { {0} };
    3942 #endif
    3943 
    3944 typedef struct FPU_BINARY_EFL_R80_T
    3945 {
    3946     const char                         *pszName;
    3947     PFNIEMAIMPLFPUR80EFL                pfn, pfnNative;
    3948     FPU_BINARY_EFL_R80_TEST_T const    *paTests;
    3949     uint32_t                            cTests;
    3950     uint32_t                            uExtra;
    3951     uint8_t                             idxCpuEflFlavour;
    3952 } FPU_BINARY_EFL_R80_T;
     3229TYPEDEF_SUBTEST_TYPE(FPU_BINARY_EFL_R80_T, FPU_BINARY_EFL_R80_TEST_T, PFNIEMAIMPLFPUR80EFL);
    39533230
    39543231static const FPU_BINARY_EFL_R80_T g_aFpuBinaryEflR80[] =
    … …  
    39673244static void FpuBinaryEflR80Generate(PRTSTREAM pOut, uint32_t cTests)
    39683245{
    3969     RTStrmPrintf(pOut, "\n\n#define HAVE_FPU_BINARY_EFL_R80\n");
    39703246    X86FXSTATE State;
    39713247    RT_ZERO(State);
    … …  
    39733249    for (size_t iFn = 0; iFn < RT_ELEMENTS(g_aFpuBinaryEflR80); iFn++)
    39743250    {
    3975         RTStrmPrintf(pOut, "static const FPU_BINARY_EFL_R80_TEST_T g_aTests_%s[] =\n{\n", g_aFpuBinaryEflR80[iFn].pszName);
     3251        GenerateArrayStart(pOut, g_aFpuBinaryEflR80[iFn].pszName, "FPU_BINARY_EFL_R80_TEST_T");
    39763252        uint32_t cNormalInputPairs = 0;
    39773253        for (uint32_t iTest = 0; iTest < cTests + RT_ELEMENTS(s_aFpuBinaryEflR80Specials); iTest += 1)
    … …  
    40013277            }
    40023278        }
    4003         RTStrmPrintf(pOut, "};\n");
     3279        GenerateArrayEnd(pOut, g_aFpuBinaryEflR80[iFn].pszName);
    40043280    }
    40053281}
    … …  
    40143290        RTTestSub(g_hTest, g_aFpuBinaryEflR80[iFn].pszName);
    40153291
    4016         uint32_t const                          cTests  = g_aFpuBinaryEflR80[iFn].cTests;
     3292        uint32_t const                          cTests  = *g_aFpuBinaryEflR80[iFn].pcTests;
    40173293        FPU_BINARY_EFL_R80_TEST_T const * const paTests = g_aFpuBinaryEflR80[iFn].paTests;
    40183294        PFNIEMAIMPLFPUR80EFL                    pfn     = g_aFpuBinaryEflR80[iFn].pfn;
    40193295        uint32_t const cVars = 1 + (g_aFpuBinaryEflR80[iFn].idxCpuEflFlavour == g_idxCpuEflFlavour && g_aFpuBinaryEflR80[iFn].pfnNative);
     3296        if (!cTests) RTTestSkipped(g_hTest, "no tests");
    40203297        for (uint32_t iVar = 0; iVar < cVars; iVar++)
    40213298        {
    … …  
    40713348    bool                fInt          = true;
    40723349    bool                fFpuLdSt      = true;
    4073     bool                fFpuBinary    = true;
     3350    bool                fFpuBinary1   = true;
     3351    bool                fFpuBinary2   = true;
    40743352    bool                fFpuOther     = true;
    40753353    bool                fCpuData      = true;
    … …  
    40883366        { "--fpu-ld-st",            'F', RTGETOPT_REQ_NOTHING },  /* FPU stuff is upper case */
    40893367        { "--fpu-load-store",       'F', RTGETOPT_REQ_NOTHING },
    4090         { "--fpu-binary",           'B', RTGETOPT_REQ_NOTHING },
     3368        { "--fpu-binary-1",         'B', RTGETOPT_REQ_NOTHING },
     3369        { "--fpu-binary-2",         'P', RTGETOPT_REQ_NOTHING },
    40913370        { "--fpu-other",            'O', RTGETOPT_REQ_NOTHING },
    40923371        { "--int",                  'i', RTGETOPT_REQ_NOTHING },
    … …  
    41173396                fInt        = true;
    41183397                fFpuLdSt    = true;
    4119                 fFpuBinary  = true;
     3398                fFpuBinary1 = true;
     3399                fFpuBinary2 = true;
    41203400                fFpuOther   = true;
    41213401                break;
    … …  
    41253405                fInt        = false;
    41263406                fFpuLdSt    = false;
    4127                 fFpuBinary  = false;
     3407                fFpuBinary1  = false;
     3408                fFpuBinary2  = false;
    41283409                fFpuOther   = false;
    41293410                break;
    … …  
    41353416                break;
    41363417            case 'B':
    4137                 fFpuBinary  = true;
     3418                fFpuBinary1 = true;
     3419                break;
     3420            case 'P':
     3421                fFpuBinary2 = true;
    41383422                break;
    41393423            case 'i':
    … …  
    41673451                         "  -F, --fpu-ld-st\n"
    41683452                         "    Enable FPU load and store tests.\n"
    4169                          "  -B, --fpu-binary\n"
    4170                          "    Enable FPU binary 80, 64 and 32-bit FP tests.\n"
     3453                         "  -B, --fpu-binary-1\n"
     3454                         "    Enable FPU binary 80-bit FP tests.\n"
     3455                         "  -P, --fpu-binary-2\n"
     3456                         "    Enable FPU binary 64- and 32-bit FP tests.\n"
    41713457                         "  -O, --fpu-other\n"
    41723458                         "    Enable other FPU tests.\n"
    … …  
    41953481        RTMpGetDescription(NIL_RTCPUID, szCpuDesc, sizeof(szCpuDesc));
    41963482        const char * const pszCpuType  = g_idxCpuEflFlavour == IEMTARGETCPU_EFL_BEHAVIOR_AMD ? "Amd"  : "Intel";
    4197         const char * const pszCpuSuff  = g_idxCpuEflFlavour == IEMTARGETCPU_EFL_BEHAVIOR_AMD ? "_Amd" : "_Intel";
    4198         const char * const pszCpuSuffU = g_idxCpuEflFlavour == IEMTARGETCPU_EFL_BEHAVIOR_AMD ? "_AMD" : "_INTEL";
    41993483# if defined(RT_OS_WINDOWS) || defined(RT_OS_OS2)
    42003484        const char * const pszBitBucket = "NUL";
    … …  
    42103494        if (fInt)
    42113495        {
    4212             const char *pszFileInfix = "";
    4213             const char *pszDataFile  = fCommonData ? "tstIEMAImplData.h" : pszBitBucket;
    4214             PRTSTREAM   pStrmData    = NULL;
    4215             rc = RTStrmOpen(pszDataFile, "w", &pStrmData);
    4216             if (!pStrmData)
    4217                 return RTMsgErrorExitFailure("Failed to open %s for writing: %Rrc", pszDataFile, rc);
    4218 
     3496            const char *pszDataFile    = fCommonData ? "tstIEMAImplDataInt.cpp" : pszBitBucket;
     3497            PRTSTREAM   pStrmData      = GenerateOpenWithHdr(pszDataFile, szCpuDesc, NULL);
    42193498            const char *pszDataCpuFile = !fCpuData ? pszBitBucket : g_idxCpuEflFlavour == IEMTARGETCPU_EFL_BEHAVIOR_AMD
    4220                                        ? "tstIEMAImplData-Amd.h" : "tstIEMAImplData-Intel.h";
    4221             PRTSTREAM   pStrmDataCpu   = NULL;
    4222             rc = RTStrmOpen(pszDataCpuFile, "w", &pStrmDataCpu);
    4223             if (!pStrmData)
    4224                 return RTMsgErrorExitFailure("Failed to open %s for writing: %Rrc", pszDataCpuFile, rc);
    4225 
    4226             GenerateHeader(pStrmData, pszFileInfix, szCpuDesc, NULL, "");
    4227             GenerateHeader(pStrmDataCpu, pszFileInfix, szCpuDesc, pszCpuType, pszCpuSuff);
    4228 
    4229             BinU8Generate( pStrmData, pStrmDataCpu, pszCpuSuffU, cTests);
    4230             BinU16Generate(pStrmData, pStrmDataCpu, pszCpuSuffU, cTests);
    4231             BinU32Generate(pStrmData, pStrmDataCpu, pszCpuSuffU, cTests);
    4232             BinU64Generate(pStrmData, pStrmDataCpu, pszCpuSuffU, cTests);
    4233             ShiftDblGenerate(pStrmDataCpu, pszCpuSuffU, RT_MAX(cTests, 128));
     3499                                       ? "tstIEMAImplDataInt-Amd.cpp" : "tstIEMAImplDataInt-Intel.cpp";
     3500            PRTSTREAM   pStrmDataCpu   = GenerateOpenWithHdr(pszDataCpuFile, szCpuDesc, pszCpuType);
     3501            if (!pStrmData || !pStrmDataCpu)
     3502                return RTEXITCODE_FAILURE;
     3503
     3504            BinU8Generate( pStrmData, pStrmDataCpu, cTests);
     3505            BinU16Generate(pStrmData, pStrmDataCpu, cTests);
     3506            BinU32Generate(pStrmData, pStrmDataCpu, cTests);
     3507            BinU64Generate(pStrmData, pStrmDataCpu, cTests);
     3508            ShiftDblGenerate(pStrmDataCpu, RT_MAX(cTests, 128));
    42343509            UnaryGenerate(pStrmData, cTests);
    4235             ShiftGenerate(pStrmDataCpu, pszCpuSuffU, cTests);
    4236             MulDivGenerate(pStrmDataCpu, pszCpuSuffU, cTests);
    4237 
    4238             RTEXITCODE rcExit = GenerateFooterAndClose(pStrmDataCpu, pszDataCpuFile, pszFileInfix, pszCpuSuff,
    4239                                                        GenerateFooterAndClose(pStrmData, pszDataFile, pszFileInfix, "",
    4240                                                                               RTEXITCODE_SUCCESS));
     3510            ShiftGenerate(pStrmDataCpu, cTests);
     3511            MulDivGenerate(pStrmDataCpu, cTests);
     3512
     3513            RTEXITCODE rcExit = GenerateFooterAndClose(pStrmDataCpu, pszDataCpuFile,
     3514                                                       GenerateFooterAndClose(pStrmData, pszDataFile, RTEXITCODE_SUCCESS));
    42413515            if (rcExit != RTEXITCODE_SUCCESS)
    42423516                return rcExit;
    … …  
    42453519        if (fFpuLdSt)
    42463520        {
    4247             const char *pszFileInfix = "FpuLdSt";
    4248             const char *pszDataFile  = fCommonData ? "tstIEMAImplDataFpuLdSt.h" : pszBitBucket;
    4249             PRTSTREAM   pStrmData    = NULL;
    4250             rc = RTStrmOpen(pszDataFile, "w", &pStrmData);
    4251             if (!pStrmData)
    4252                 return RTMsgErrorExitFailure("Failed to open %s for writing: %Rrc", pszDataFile, rc);
    4253 
     3521            const char *pszDataFile    = fCommonData ? "tstIEMAImplDataFpuLdSt.cpp" : pszBitBucket;
     3522            PRTSTREAM   pStrmData      = GenerateOpenWithHdr(pszDataFile, szCpuDesc, NULL);
    42543523            const char *pszDataCpuFile = !fCpuData ? pszBitBucket : g_idxCpuEflFlavour == IEMTARGETCPU_EFL_BEHAVIOR_AMD
    4255                                        ? "tstIEMAImplDataFpuLdSt-Amd.h" : "tstIEMAImplDataFpuLdSt-Intel.h";
    4256             PRTSTREAM   pStrmDataCpu   = NULL;
    4257             rc = RTStrmOpen(pszDataCpuFile, "w", &pStrmDataCpu);
    4258             if (!pStrmData)
    4259                 return RTMsgErrorExitFailure("Failed to open %s for writing: %Rrc", pszDataCpuFile, rc);
    4260 
    4261             GenerateHeader(pStrmData, pszFileInfix, szCpuDesc, NULL, "");
    4262             GenerateHeader(pStrmDataCpu, pszFileInfix, szCpuDesc, pszCpuType, pszCpuSuff);
     3524                                       ? "tstIEMAImplDataFpuLdSt-Amd.cpp" : "tstIEMAImplDataFpuLdSt-Intel.cpp";
     3525            PRTSTREAM   pStrmDataCpu   = GenerateOpenWithHdr(pszDataCpuFile, szCpuDesc, pszCpuType);
     3526            if (!pStrmData || !pStrmDataCpu)
     3527                return RTEXITCODE_FAILURE;
    42633528
    42643529            FpuLdConstGenerate(pStrmData, cTests);
    … …  
    42713536            FpuStMemGenerate(pStrmData, cTests);
    42723537
    4273             RTEXITCODE rcExit = GenerateFooterAndClose(pStrmDataCpu, pszDataCpuFile, pszFileInfix, pszCpuSuff,
    4274                                                        GenerateFooterAndClose(pStrmData, pszDataFile, pszFileInfix, "",
    4275                                                                               RTEXITCODE_SUCCESS));
     3538            RTEXITCODE rcExit = GenerateFooterAndClose(pStrmDataCpu, pszDataCpuFile,
     3539                                                       GenerateFooterAndClose(pStrmData, pszDataFile, RTEXITCODE_SUCCESS));
    42763540            if (rcExit != RTEXITCODE_SUCCESS)
    42773541                return rcExit;
    42783542        }
    42793543
    4280         if (fFpuBinary)
     3544        if (fFpuBinary1)
    42813545        {
    4282             const char *pszFileInfix = "FpuBinary";
    4283             const char *pszDataFile  = fCommonData ? "tstIEMAImplDataFpuBinary.h" : pszBitBucket;
    4284             PRTSTREAM   pStrmData    = NULL;
    4285             rc = RTStrmOpen(pszDataFile, "w", &pStrmData);
    4286             if (!pStrmData)
    4287                 return RTMsgErrorExitFailure("Failed to open %s for writing: %Rrc", pszDataFile, rc);
    4288 
    4289             const char *pszDataCpuFile = !fCpuData ? pszBitBucket : g_idxCpuEflFlavour == IEMTARGETCPU_EFL_BEHAVIOR_AMD
    4290                                        ? "tstIEMAImplDataFpuBinary-Amd.h" : "tstIEMAImplDataFpuBinary-Intel.h";
    4291             PRTSTREAM   pStrmDataCpu   = NULL;
    4292             rc = RTStrmOpen(pszDataCpuFile, "w", &pStrmDataCpu);
    4293             if (!pStrmData)
    4294                 return RTMsgErrorExitFailure("Failed to open %s for writing: %Rrc", pszDataCpuFile, rc);
    4295 
    4296             GenerateHeader(pStrmData, pszFileInfix, szCpuDesc, NULL, "");
    4297             GenerateHeader(pStrmDataCpu, pszFileInfix, szCpuDesc, pszCpuType, pszCpuSuff);
     3546            const char *pszDataFile    = fCommonData ? "tstIEMAImplDataFpuBinary1.cpp" : pszBitBucket;
     3547            PRTSTREAM   pStrmData      = GenerateOpenWithHdr(pszDataFile, szCpuDesc, NULL);
     3548            const char *pszDataCpuFile = pszBitBucket; /*!fCpuData ? pszBitBucket : g_idxCpuEflFlavour == IEMTARGETCPU_EFL_BEHAVIOR_AMD
     3549                                       ? "tstIEMAImplDataFpuBinary1-Amd.cpp" : "tstIEMAImplDataFpuBinary1-Intel.cpp";*/
     3550            PRTSTREAM   pStrmDataCpu   = GenerateOpenWithHdr(pszDataCpuFile, szCpuDesc, pszCpuType);
     3551            if (!pStrmData || !pStrmDataCpu)
     3552                return RTEXITCODE_FAILURE;
    42983553
    42993554            FpuBinaryR80Generate(pStrmData, cTests);
    4300             FpuBinaryR64Generate(pStrmData, cTests);
    4301             FpuBinaryR32Generate(pStrmData, cTests);
    43023555            FpuBinaryFswR80Generate(pStrmData, cTests);
    4303             FpuBinaryFswR64Generate(pStrmData, cTests);
    4304             FpuBinaryFswR32Generate(pStrmData, cTests);
    43053556            FpuBinaryEflR80Generate(pStrmData, cTests);
    43063557
    4307             RTEXITCODE rcExit = GenerateFooterAndClose(pStrmDataCpu, pszDataCpuFile, pszFileInfix, pszCpuSuff,
    4308                                                        GenerateFooterAndClose(pStrmData, pszDataFile, pszFileInfix, "",
    4309                                                                               RTEXITCODE_SUCCESS));
     3558            RTEXITCODE rcExit = GenerateFooterAndClose(pStrmDataCpu, pszDataCpuFile,
     3559                                                       GenerateFooterAndClose(pStrmData, pszDataFile, RTEXITCODE_SUCCESS));
    43103560            if (rcExit != RTEXITCODE_SUCCESS)
    43113561                return rcExit;
    43123562        }
    43133563
     3564        if (fFpuBinary2)
     3565        {
     3566            const char *pszDataFile    = fCommonData ? "tstIEMAImplDataFpuBinary2.cpp" : pszBitBucket;
     3567            PRTSTREAM   pStrmData      = GenerateOpenWithHdr(pszDataFile, szCpuDesc, NULL);
     3568            const char *pszDataCpuFile = pszBitBucket; /*!fCpuData ? pszBitBucket : g_idxCpuEflFlavour == IEMTARGETCPU_EFL_BEHAVIOR_AMD
     3569                                       ? "tstIEMAImplDataFpuBinary2-Amd.cpp" : "tstIEMAImplDataFpuBinary2-Intel.cpp"; */
     3570            PRTSTREAM   pStrmDataCpu   = GenerateOpenWithHdr(pszDataCpuFile, szCpuDesc, pszCpuType);
     3571            if (!pStrmData || !pStrmDataCpu)
     3572                return RTEXITCODE_FAILURE;
     3573
     3574            FpuBinaryR64Generate(pStrmData, cTests);
     3575            FpuBinaryR32Generate(pStrmData, cTests);
     3576            FpuBinaryFswR64Generate(pStrmData, cTests);
     3577            FpuBinaryFswR32Generate(pStrmData, cTests);
     3578
     3579            RTEXITCODE rcExit = GenerateFooterAndClose(pStrmDataCpu, pszDataCpuFile,
     3580                                                       GenerateFooterAndClose(pStrmData, pszDataFile, RTEXITCODE_SUCCESS));
     3581            if (rcExit != RTEXITCODE_SUCCESS)
     3582                return rcExit;
     3583        }
     3584
    43143585# if 0
    43153586        if (fFpuOther)
    43163587        {
    4317             const char *pszFileInfix = "FpuOther";
    4318             const char *pszDataFile  = fCommonData ? "tstIEMAImplDataFpuOther.h" : pszBitBucket;
    4319             PRTSTREAM   pStrmData    = NULL;
    4320             rc = RTStrmOpen(pszDataFile, "w", &pStrmData);
    4321             if (!pStrmData)
    4322                 return RTMsgErrorExitFailure("Failed to open %s for writing: %Rrc", pszDataFile, rc);
    4323 
     3588            const char *pszDataFile    = fCommonData ? "tstIEMAImplDataFpuOther.cpp" : pszBitBucket;
     3589            PRTSTREAM   pStrmData      = GenerateOpenWithHdr(pszDataFile, szCpuDesc, NULL);
    43243590            const char *pszDataCpuFile = !fCpuData ? pszBitBucket : g_idxCpuEflFlavour == IEMTARGETCPU_EFL_BEHAVIOR_AMD
    4325                                        ? "tstIEMAImplDataFpuOther-Amd.h" : "tstIEMAImplDataFpuOther-Intel.h";
    4326             PRTSTREAM   pStrmDataCpu   = NULL;
    4327             rc = RTStrmOpen(pszDataCpuFile, "w", &pStrmDataCpu);
    4328             if (!pStrmData)
    4329                 return RTMsgErrorExitFailure("Failed to open %s for writing: %Rrc", pszDataCpuFile, rc);
    4330 
    4331             GenerateHeader(pStrmData, pszFileInfix, szCpuDesc, NULL, "");
    4332             GenerateHeader(pStrmDataCpu, pszFileInfix, szCpuDesc, pszCpuType, pszCpuSuff);
     3591                                       ? "tstIEMAImplDataFpuOther-Amd.cpp" : "tstIEMAImplDataFpuOther-Intel.cpp";
     3592            PRTSTREAM   pStrmDataCpu   = GenerateOpenWithHdr(pszDataCpuFile, szCpuDesc, pszCpuType);
     3593            if (!pStrmData || !pStrmDataCpu)
     3594                return RTEXITCODE_FAILURE;
    43333595
    43343596            /* later */
    43353597
    4336             RTEXITCODE rcExit = GenerateFooterAndClose(pStrmDataCpu, pszDataCpuFile, pszFileInfix, pszCpuSuff,
    4337                                                        GenerateFooterAndClose(pStrmData, pszDataFile, pszFileInfix, "",
    4338                                                                               RTEXITCODE_SUCCESS));
     3598            RTEXITCODE rcExit = GenerateFooterAndClose(pStrmDataCpu, pszDataCpuFile,
     3599                                                       GenerateFooterAndClose(pStrmData, pszDataFile, RTEXITCODE_SUCCESS));
    43393600            if (rcExit != RTEXITCODE_SUCCESS)
    43403601                return rcExit;
    … …  
    44053666            }
    44063667
    4407             if (fFpuBinary)
     3668            if (fFpuBinary1)
    44083669            {
    44093670                FpuBinaryR80Test();
     3671                FpuBinaryFswR80Test();
     3672                FpuBinaryEflR80Test();
     3673            }
     3674
     3675            if (fFpuBinary2)
     3676            {
    44103677                FpuBinaryR64Test();
    44113678                FpuBinaryR32Test();
    4412                 FpuBinaryFswR80Test();
    44133679                FpuBinaryFswR64Test();
    44143680                FpuBinaryFswR32Test();
    4415                 FpuBinaryEflR80Test();
    44163681            }
    44173682        }
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