VirtualBox

Changeset 103099 in vbox for trunk/src/VBox/VMM/testcase


Ignore:
Timestamp:
Jan 26, 2024 11:34:32 PM (16 months ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
161345
Message:

tstIEMAImpl,VMM/IEM: Regenerated integer tests on intel, increasing the number to 1024 entries per tests. Fixed some issues. bugref:9898 bugref:10591

Location:
trunk/src/VBox/VMM/testcase
Files:
182 edited

Legend:

Unmodified
Added
Removed

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

    r103084 r103099  
    183183
    184184
     185typedef struct IEMBINARYFOOTER
     186{
     187    char        szMagic[24];
     188    uint32_t    cbEntry;
     189    uint32_t    cEntries;
     190} IEMBINARYFOOTER;
     191AssertCompileSize(IEMBINARYFOOTER, 32);
     192                             // 012345678901234567890123
     193#define IEMBINARYFOOTER_MAGIC "\nIEMAImpl Bin Footer v1"
     194AssertCompile(sizeof(IEMBINARYFOOTER_MAGIC) == 24);
     195
     196
    185197/** Fixed part of TYPEDEF_SUBTEST_TYPE and friends. */
    186198typedef struct IEMTESTENTRYINFO
    … …  
    200212    /** The stream we write uncompressed binary test data to. */
    201213    RTVFSIOSTREAM   hVfsUncompressed;
     214    /** The number of bytes written (ignoring write failures). */
     215    size_t          cbWritten;
     216    /** The entry size. */
     217    uint32_t        cbEntry;
    202218    /** Write status. */
    203219    int             rcWrite;
    204220    /** Set if NULL. */
    205221    bool            fNull;
     222    /** Set if we wrote a header and should write a footer as well. */
     223    bool            fWroteHeader;
    206224    /** Filename.   */
    207     char            szFilename[79];
     225    char            szFilename[94];
    208226} IEMBINARYOUTPUT;
    209227typedef IEMBINARYOUTPUT *PIEMBINARYOUTPUT;
    … …  
    10581076static void GenerateBinaryWrite(PIEMBINARYOUTPUT pBinOut, const void *pvData, size_t cbData)
    10591077{
     1078    pBinOut->cbWritten += cbData; /* ignore errors - makes entry calculation simpler */
    10601079    if (RT_SUCCESS_NP(pBinOut->rcWrite))
    10611080    {
    … …  
    10701089                               IEMTESTENTRYINFO const *pInfoToPreserve, uint32_t cbEntry)
    10711090{
     1091    pBinOut->cbEntry          = cbEntry;
     1092    pBinOut->cbWritten        = 0;
    10721093    pBinOut->hVfsFile         = NIL_RTVFSFILE;
    10731094    pBinOut->hVfsUncompressed = NIL_RTVFSIOSTREAM;
    … …  
    10901111                    if (RT_SUCCESS(pBinOut->rcWrite))
    10911112                    {
    1092                         pBinOut->rcWrite = VINF_SUCCESS;
     1113                        pBinOut->rcWrite      = VINF_SUCCESS;
     1114                        pBinOut->fWroteHeader = false;
    10931115
    10941116                        /* Write the header if applicable. */
    … …  
    11041126                                      pInfoToPreserve ? pInfoToPreserve->pszCpuDesc : g_szCpuDesc);
    11051127                            GenerateBinaryWrite(pBinOut, &Hdr, sizeof(Hdr));
     1128                            pBinOut->fWroteHeader = true;
    11061129                        }
    11071130
    … …  
    11321155    pBinOut->rcWrite       = VERR_IGNORED;
    11331156    pBinOut->fNull         = true;
     1157    pBinOut->fWroteHeader  = false;
    11341158    pBinOut->szFilename[0] = '\0';
    11351159    return true;
    … …  
    11441168    if (!pBinOut->fNull)
    11451169    {
     1170        /* Write footer if we've written a header. */
     1171        if (pBinOut->fWroteHeader)
     1172        {
     1173            IEMBINARYFOOTER Ftr;
     1174            RT_ZERO(Ftr);
     1175            memcpy(Ftr.szMagic, IEMBINARYFOOTER_MAGIC, sizeof(IEMBINARYFOOTER_MAGIC));
     1176            Ftr.cbEntry  = pBinOut->cbEntry;
     1177            Ftr.cEntries = (uint32_t)((pBinOut->cbWritten - sizeof(IEMBINARYHEADER)) / pBinOut->cbEntry);
     1178            Assert(Ftr.cEntries * pBinOut->cbEntry + sizeof(IEMBINARYHEADER) == pBinOut->cbWritten);
     1179            GenerateBinaryWrite(pBinOut, &Ftr, sizeof(Ftr));
     1180        }
     1181
    11461182        /* This is rather jovial about rcWrite. */
    11471183        int const rc1 = RTVfsIoStrmFlush(pBinOut->hVfsUncompressed);
    … …  
    12641300            if (RT_SUCCESS(rc))
    12651301            {
    1266                 /* Validate the header if present and subtract if from 'off'. */
     1302                size_t          const  cbUncompressed = off;
     1303
     1304                /* Validate the header and footer if present and subtract them from 'off'. */
    12671305                IEMBINARYHEADER const *pHdr = NULL;
    12681306                if (   off >= sizeof(IEMTESTENTRYINFO)
    … …  
    12701308                {
    12711309                    pHdr = (IEMBINARYHEADER const *)pbDecompressed;
     1310                    IEMBINARYFOOTER const *pFtr = (IEMBINARYFOOTER const *)&pbDecompressed[off - sizeof(IEMBINARYFOOTER)];
     1311
     1312                    off -= sizeof(*pHdr) + sizeof(*pFtr);
     1313                    rc = VERR_IO_BAD_UNIT;
    12721314                    if (pHdr->cbEntry != cbEntry)
    1273                     {
    12741315                        RTTestIFailed("Test entry size differs for '%s': %#x (header r%u), expected %#zx (uncompressed size %#zx)",
    1275                                       pszWhat, pHdr->cbEntry, pHdr->uSvnRev, cbEntry, off);
    1276                         rc = VERR_IO_BAD_UNIT;
    1277                     }
    1278                     off -= sizeof(*pHdr);
     1316                                      pszWhat, pHdr->cbEntry, pHdr->uSvnRev, cbEntry, off + sizeof(*pHdr) + sizeof(*pFtr));
     1317                    else if (memcmp(pFtr->szMagic, IEMBINARYFOOTER_MAGIC, sizeof(IEMBINARYFOOTER_MAGIC)) != 0)
     1318                        RTTestIFailed("Wrong footer magic for '%s': %.*Rhxs\n", pszWhat, sizeof(pFtr->szMagic), pFtr->szMagic);
     1319                    else if (pFtr->cbEntry != cbEntry)
     1320                        RTTestIFailed("Wrong footer entry size for '%s': %#x, expected %#x\n", pszWhat, pFtr->cbEntry, cbEntry);
     1321                    else if (pFtr->cEntries != off / cbEntry)
     1322                        RTTestIFailed("Wrong footer entry count for '%s': %#x, expected %#x\n",
     1323                                      pszWhat, pFtr->cEntries, off / cbEntry);
     1324                    else
     1325                        rc = VINF_SUCCESS;
    12791326                }
    12801327
    … …  
    12931340                     */
    12941341                    /* Reallocate the block if it's way to big. */
    1295                     if (cbDecompressedAlloc - off > _512K)
     1342                    if (cbDecompressedAlloc - cbUncompressed > _512K)
    12961343                    {
    1297                         void * const pvNew = RTMemRealloc(pbDecompressed, off);
     1344                        void * const pvNew = RTMemRealloc(pbDecompressed, cbUncompressed);
    12981345                        if (pvNew)
    12991346                        {
    … …  
    13061353
    13071354                    /* Fill in the info and other return values.  */
    1308                     pInfo->cbUncompressed = (uint32_t)off;
     1355                    pInfo->cbUncompressed = (uint32_t)cbUncompressed;
    13091356                    pInfo->pvUncompressed = pbDecompressed;
    13101357                    pInfo->pszCpuDesc     = pHdr ? pHdr->szCpuDesc : NULL;
    … …  
    27392786static const MULDIVU8_TEST_T g_aFixedTests_idiv_u8[] =
    27402787{
    2741     /* efl in, efl out, uDstIn, uDstOut, uSrcIn,  rc */
    2742     { UINT32_MAX,    0, 0x8000,        0 , 0xc7,  -1 }, /* -32768 / -57 = #DE (574.8771929824...)  */
    2743     { UINT32_MAX,    0, 0x8000,        0 , 0xdd,  -1 }, /* -32768 / -35 = #DE (936.2285714285...) */
     2788    /* efl in, efl out, uDstIn, uDstOut, uSrcIn,  rc (0 or -1 for actual; -128 for auto) */
     2789    { UINT32_MAX,    0, 0x8000,        0,  0xc7,  -1   }, /* -32768 / -57 = #DE (574.8771929824...)  */
     2790    { UINT32_MAX,    0, 0x8000,        0,  0xdd,  -128 }, /* -32768 / -35 = #DE (936.2285714285...) */
     2791    { UINT32_MAX,    0, 0x7f00,        0,  0x7f,  -1   }, /* 0x7f00 / 0x7f = #DE (0x100)  */
     2792    { UINT32_MAX,    0, 0x3f80,        0,  0x7f,  -1   }, /* 0x3F80 / 0x7f = #DE (0x80)  */
     2793    { UINT32_MAX,    0, 0x3f7f,        0,  0x7f,   0   }, /* 0x3F7F / 0x7f = 127.992125984... */
     2794    { UINT32_MAX,    0, 0xc000,        0,  0x80,  -1   }, /* -16384 / -128 = #DE (0x80) */
     2795    { UINT32_MAX,    0, 0xc001,        0,  0x80,   0   }, /* -16383 / -128 =  127.9921875 */
    27442796};
    27452797#endif
    … …  
    27912843            Test.uSrcIn    = g_aMulDivU8[iFn].paFixedTests[iTest].uSrcIn;
    27922844            Test.rc        = g_aMulDivU8[iFn].pfnNative(&Test.uDstOut, Test.uSrcIn, &Test.fEflOut);
     2845            if (g_aMulDivU8[iFn].paFixedTests[iTest].rc == 0 || g_aMulDivU8[iFn].paFixedTests[iTest].rc == -1)
     2846                Test.rc = g_aMulDivU8[iFn].paFixedTests[iTest].rc;
    27932847            GenerateBinaryWrite(&BinOut, &Test, sizeof(Test));
    27942848        }
    … …  
    28452899
    28462900#ifdef TSTIEMAIMPL_WITH_GENERATOR
     2901static const MULDIVU16_TEST_T g_aFixedTests_idiv_u16[] =
     2902{
     2903    /*                     low         high  */
     2904    /* --- eflags ---, -- uDst1 --, -- uDst2 --, */
     2905    /*        in, out,    in , out,    in , out, uSrcIn,  rc (0 or -1 for actual; -128 for auto) */
     2906    { UINT32_MAX,   0, 0x0000,   0, 0x8000,   0, 0xc004,  -1   }, /* -2147483648 /-16380 = #DE (131104.00781...) */
     2907    { UINT32_MAX,   0, 0xffff,   0, 0x7fff,   0, 0x7fff,  -1   }, /*  2147483647 / 32767 = #DE (65538.000030...) */
     2908    { UINT32_MAX,   0, 0x8000,   0, 0x3fff,   0, 0x7fff,  -1   }, /* 0x3fff8000 / 0x7fff = #DE (0x8000) */
     2909    { UINT32_MAX,   0, 0x7fff,   0, 0x3fff,   0, 0x7fff,   0   }, /* 0x3fff7fff / 0x7fff = 32767.99996948... */
     2910    { UINT32_MAX,   0, 0x0000,   0, 0xc000,   0, 0x8000,  -1   }, /* -1073741824 / -32768 = #DE (0x8000) */
     2911    { UINT32_MAX,   0, 0x0001,   0, 0xc000,   0, 0x8000,   0   }, /* -1073741823 / -32768 =  32767.999969482421875 */
     2912};
     2913
     2914static const MULDIVU32_TEST_T g_aFixedTests_idiv_u32[] =
     2915{
     2916    /*                       low              high  */
     2917    /* --- eflags ---, ---- uDst1 ----, ---- uDst2 ----, */
     2918    /*        in, out,        in , out,        in , out,     uSrcIn,  rc (0 or -1 for actual; -128 for auto) */
     2919    { UINT32_MAX,   0, 0x00000000,   0, 0x80000000,   0, 0xc0000004,  -1   },
     2920    { UINT32_MAX,   0, 0xffffffff,   0, 0x7fffffff,   0, 0x7fffffff,  -1   },
     2921    { UINT32_MAX,   0, 0x80000000,   0, 0x3fffffff,   0, 0x7fffffff,  -1   },
     2922    { UINT32_MAX,   0, 0x7fffffff,   0, 0x3fffffff,   0, 0x7fffffff,   0   },
     2923    { UINT32_MAX,   0, 0x00000000,   0, 0xc0000000,   0, 0x80000000,  -1   },
     2924    { UINT32_MAX,   0, 0x00000001,   0, 0xc0000000,   0, 0x80000000,   0   },
     2925};
     2926
     2927static const MULDIVU64_TEST_T g_aFixedTests_idiv_u64[] =
     2928{
     2929    /*                       low              high  */
     2930    /* --- eflags ---, -------- uDst1 --------, -------- uDst2 --------, */
     2931    /*        in, out,                in , out,                in , out,             uSrcIn,  rc (0 or -1 for actual; -128 for auto) */
     2932    { UINT32_MAX,   0, 0x0000000000000000,   0, 0x8000000000000000,   0, 0xc000000000000004,  -1   },
     2933    { UINT32_MAX,   0, 0xffffffffffffffff,   0, 0x7fffffffffffffff,   0, 0x7fffffffffffffff,  -1   },
     2934    { UINT32_MAX,   0, 0x8000000000000000,   0, 0x3fffffffffffffff,   0, 0x7fffffffffffffff,  -1   },
     2935    { UINT32_MAX,   0, 0x7fffffffffffffff,   0, 0x3fffffffffffffff,   0, 0x7fffffffffffffff,   0   },
     2936    { UINT32_MAX,   0, 0x0000000000000000,   0, 0xc000000000000000,   0, 0x8000000000000000,  -1   },
     2937    { UINT32_MAX,   0, 0x0000000000000001,   0, 0xc000000000000000,   0, 0x8000000000000000,   0   },
     2938};
     2939
    28472940# define GEN_MULDIV(a_cBits, a_Fmt, a_TestType, a_aSubTests) \
    28482941DUMP_ALL_FN(MulDivU ## a_cBits, a_aSubTests) \
    … …  
    28552948            continue; \
    28562949        IEMBINARYOUTPUT BinOut; \
     2950        a_TestType      Test; \
     2951        RT_ZERO(Test); /* 64-bit variant contains alignment padding */ \
    28572952        AssertReturn(GENERATE_BINARY_OPEN(&BinOut, papszNameFmts, a_aSubTests[iFn]), RTEXITCODE_FAILURE); \
    28582953        for (uint32_t iTest = 0; iTest < cTests; iTest++ ) \
    28592954        { \
    2860             a_TestType Test; \
    28612955            Test.fEflIn    = RandEFlags(); \
    28622956            Test.fEflOut   = Test.fEflIn; \
    … …  
    28692963            GenerateBinaryWrite(&BinOut, &Test, sizeof(Test)); \
    28702964        } \
     2965        for (uint32_t iTest = 0; iTest < a_aSubTests[iFn].cFixedTests; iTest++ ) \
     2966        { \
     2967            Test.fEflIn    = a_aSubTests[iFn].paFixedTests[iTest].fEflIn == UINT32_MAX ? RandEFlags() \
     2968                           : a_aSubTests[iFn].paFixedTests[iTest].fEflIn; \
     2969            Test.fEflOut   = Test.fEflIn; \
     2970            Test.uDst1In   = a_aSubTests[iFn].paFixedTests[iTest].uDst1In; \
     2971            Test.uDst1Out  = Test.uDst1In; \
     2972            Test.uDst2In   = a_aSubTests[iFn].paFixedTests[iTest].uDst2In; \
     2973            Test.uDst2Out  = Test.uDst2In; \
     2974            Test.uSrcIn    = a_aSubTests[iFn].paFixedTests[iTest].uSrcIn; \
     2975            Test.rc        = a_aSubTests[iFn].pfnNative(&Test.uDst1Out, &Test.uDst2Out, Test.uSrcIn, &Test.fEflOut); \
     2976            if (a_aSubTests[iFn].paFixedTests[iTest].rc == 0 || a_aSubTests[iFn].paFixedTests[iTest].rc == -1) \
     2977                Test.rc = a_aSubTests[iFn].paFixedTests[iTest].rc; \
     2978            GenerateBinaryWrite(&BinOut, &Test, sizeof(Test)); \
     2979        } \
    28712980        AssertReturn(GenerateBinaryClose(&BinOut), RTEXITCODE_FAILURE); \
    28722981    } \
    … …  
    28782987
    28792988#define TEST_MULDIV(a_cBits, a_Type, a_Fmt, a_TestType, a_SubTestType, a_aSubTests) \
    2880 /** @todo fixed tests like u8 with INT16_MIN, INT32_MIN & INT64_MIN and \
    2881  *        divisors. */ \
    28822989TYPEDEF_SUBTEST_TYPE(a_SubTestType, a_TestType, PFNIEMAIMPLMULDIVU ## a_cBits); \
    28832990static a_SubTestType a_aSubTests [] = \
    28842991{ \
    2885     ENTRY_BIN_AMD_EX(mul_u ## a_cBits,    X86_EFL_SF | X86_EFL_ZF | X86_EFL_AF | X86_EFL_PF, 0), \
    2886     ENTRY_BIN_INTEL_EX(mul_u ## a_cBits,  X86_EFL_SF | X86_EFL_ZF | X86_EFL_AF | X86_EFL_PF, 0), \
    2887     ENTRY_BIN_AMD_EX(imul_u ## a_cBits,   X86_EFL_SF | X86_EFL_ZF | X86_EFL_AF | X86_EFL_PF, 0), \
    2888     ENTRY_BIN_INTEL_EX(imul_u ## a_cBits, X86_EFL_SF | X86_EFL_ZF | X86_EFL_AF | X86_EFL_PF, 0), \
    2889     ENTRY_BIN_AMD_EX(div_u ## a_cBits,    X86_EFL_SF | X86_EFL_ZF | X86_EFL_AF | X86_EFL_PF | X86_EFL_CF | X86_EFL_OF, 0), \
    2890     ENTRY_BIN_INTEL_EX(div_u ## a_cBits,  X86_EFL_SF | X86_EFL_ZF | X86_EFL_AF | X86_EFL_PF | X86_EFL_CF | X86_EFL_OF, 0), \
    2891     ENTRY_BIN_AMD_EX(idiv_u ## a_cBits,   X86_EFL_SF | X86_EFL_ZF | X86_EFL_AF | X86_EFL_PF | X86_EFL_CF | X86_EFL_OF, 0), \
    2892     ENTRY_BIN_INTEL_EX(idiv_u ## a_cBits, X86_EFL_SF | X86_EFL_ZF | X86_EFL_AF | X86_EFL_PF | X86_EFL_CF | X86_EFL_OF, 0), \
     2992    ENTRY_BIN_AMD_EX(mul_u ## a_cBits,        X86_EFL_SF | X86_EFL_ZF | X86_EFL_AF | X86_EFL_PF, 0), \
     2993    ENTRY_BIN_INTEL_EX(mul_u ## a_cBits,      X86_EFL_SF | X86_EFL_ZF | X86_EFL_AF | X86_EFL_PF, 0), \
     2994    ENTRY_BIN_AMD_EX(imul_u ## a_cBits,       X86_EFL_SF | X86_EFL_ZF | X86_EFL_AF | X86_EFL_PF, 0), \
     2995    ENTRY_BIN_INTEL_EX(imul_u ## a_cBits,     X86_EFL_SF | X86_EFL_ZF | X86_EFL_AF | X86_EFL_PF, 0), \
     2996    ENTRY_BIN_AMD_EX(div_u ## a_cBits,        X86_EFL_SF | X86_EFL_ZF | X86_EFL_AF | X86_EFL_PF | X86_EFL_CF | X86_EFL_OF, 0), \
     2997    ENTRY_BIN_INTEL_EX(div_u ## a_cBits,      X86_EFL_SF | X86_EFL_ZF | X86_EFL_AF | X86_EFL_PF | X86_EFL_CF | X86_EFL_OF, 0), \
     2998    ENTRY_BIN_FIX_AMD_EX(idiv_u ## a_cBits,   X86_EFL_SF | X86_EFL_ZF | X86_EFL_AF | X86_EFL_PF | X86_EFL_CF | X86_EFL_OF, 0), \
     2999    ENTRY_BIN_FIX_INTEL_EX(idiv_u ## a_cBits, X86_EFL_SF | X86_EFL_ZF | X86_EFL_AF | X86_EFL_PF | X86_EFL_CF | X86_EFL_OF, 0), \
    28933000}; \
    28943001\
    … …  
    29193026                    || (fEfl | fEflIgn) != (paTests[iTest].fEflOut | fEflIgn)\
    29203027                    || rc    != paTests[iTest].rc) \
    2921                     RTTestFailed(g_hTest, "#%02u%s: efl=%#08x dst1=" a_Fmt " dst2=" a_Fmt " src=" a_Fmt "\n" \
    2922                                            "  -> efl=%#08x dst1=" a_Fmt  " dst2=" a_Fmt " rc=%d\n" \
    2923                                            "expected %#08x      " a_Fmt  "      " a_Fmt "    %d%s -%s%s%s\n", \
    2924                                  iTest, iVar == 0 ? "" : "/n", \
     3028                { __debugbreak(); \
     3029                    RTTestFailed(g_hTest, "#%04u%s: efl=%#010x dst1=" a_Fmt " dst2=" a_Fmt " src=" a_Fmt "\n" \
     3030                                           "      -> efl=%#010x dst1=" a_Fmt  " dst2=" a_Fmt " rc=%d\n" \
     3031                                           "    expected %#010x      " a_Fmt  "      " a_Fmt "    %d%s -%s%s%s\n", \
     3032                                 iTest, iVar == 0 ? "  " : "/n", \
    29253033                                 paTests[iTest].fEflIn, paTests[iTest].uDst1In, paTests[iTest].uDst2In, paTests[iTest].uSrcIn, \
    29263034                                 fEfl, uDst1, uDst2, rc, \
    … …  
    29293037                                 uDst1 != paTests[iTest].uDst1Out ? " dst1" : "", uDst2 != paTests[iTest].uDst2Out ? " dst2" : "", \
    29303038                                 (fEfl | fEflIgn) != (paTests[iTest].fEflOut | fEflIgn) ? " eflags" : ""); \
     3039                } \
    29313040                else \
    29323041                { \
    … …  
    29453054        FREE_DECOMPRESSED_TESTS(a_aSubTests[iFn]); \
    29463055    } \
    2947 }
     3056}                   //1068553096 = 0x3FB0D388 (1068553096)
    29483057TEST_MULDIV(16, uint16_t, "%#06RX16",  MULDIVU16_TEST_T, INT_MULDIV_U16_T, g_aMulDivU16)
    29493058TEST_MULDIV(32, uint32_t, "%#010RX32", MULDIVU32_TEST_T, INT_MULDIV_U32_T, g_aMulDivU32)
Note: See TracChangeset for help on using the changeset viewer.

© 2025 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette