VirtualBox

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


Ignore:
Timestamp:
Apr 12, 2022 9:38:56 AM (3 years ago)
Author:
vboxsync
Message:

tstIEMAImpl: Exception variations for the fxtract++ set of tests too. bugref:9898

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r94540 r94569  
    35293529TYPEDEF_SUBTEST_TYPE(FPU_UNARY_R80_T, FPU_UNARY_R80_TEST_T, PFNIEMAIMPLFPUR80UNARY);
    35303530
    3531 enum { kUnary_Accurate = 0, kUnary_Rounding_F2xm1 };
     3531enum { kUnary_Accurate = 0, kUnary_Accurate_Trigonometry /*probably not accurate, but need impl to know*/, kUnary_Rounding_F2xm1 };
    35323532static const FPU_UNARY_R80_T g_aFpuUnaryR80[] =
    35333533{
    … …  
    35383538    ENTRY_EX(      fsqrt_r80,    kUnary_Accurate),
    35393539    ENTRY_EX(      frndint_r80,  kUnary_Accurate),
    3540     ENTRY_AMD_EX(  fsin_r80, 0,  kUnary_Accurate),  // value & C1 differences for pseudo denormals and others (e.g. -1m0x2b1e5683cbca5725^-3485)
    3541     ENTRY_INTEL_EX(fsin_r80, 0,  kUnary_Accurate),
    3542     ENTRY_AMD_EX(  fcos_r80, 0,  kUnary_Accurate),  // value & C1 differences
    3543     ENTRY_INTEL_EX(fcos_r80, 0,  kUnary_Accurate),
     3540    ENTRY_AMD_EX(  fsin_r80, 0,  kUnary_Accurate_Trigonometry),  // value & C1 differences for pseudo denormals and others (e.g. -1m0x2b1e5683cbca5725^-3485)
     3541    ENTRY_INTEL_EX(fsin_r80, 0,  kUnary_Accurate_Trigonometry),
     3542    ENTRY_AMD_EX(  fcos_r80, 0,  kUnary_Accurate_Trigonometry),  // value & C1 differences
     3543    ENTRY_INTEL_EX(fcos_r80, 0,  kUnary_Accurate_Trigonometry),
    35443544};
    35453545
    … …  
    35603560    static RTFLOAT80U const s_aSpecials[] =
    35613561    {
    3562 #if 1
    35633562        RTFLOAT80U_INIT_C(0, 0x8000000000000000, RTFLOAT80U_EXP_BIAS - 1), /*  0.5 (for f2xm1) */
    35643563        RTFLOAT80U_INIT_C(1, 0x8000000000000000, RTFLOAT80U_EXP_BIAS - 1), /* -0.5 (for f2xm1) */
    35653564        RTFLOAT80U_INIT_C(0, 0x8000000000000000, RTFLOAT80U_EXP_BIAS),     /*  1.0 (for f2xm1) */
    35663565        RTFLOAT80U_INIT_C(1, 0x8000000000000000, RTFLOAT80U_EXP_BIAS),     /* -1.0 (for f2xm1) */
    3567 #endif
    35683566        RTFLOAT80U_INIT_C(0, 0x8000000000000000, 0), /* +1.0^-16382 */
    35693567        RTFLOAT80U_INIT_C(1, 0x8000000000000000, 0), /* -1.0^-16382 */
    3570 #if 1
    35713568        RTFLOAT80U_INIT_C(0, 0xc000000000000000, 0), /* +1.1^-16382 */
    35723569        RTFLOAT80U_INIT_C(1, 0xc000000000000000, 0), /* -1.1^-16382 */
    35733570        RTFLOAT80U_INIT_C(0, 0xc000100000000000, 0), /* +1.1xxx1^-16382 */
    35743571        RTFLOAT80U_INIT_C(1, 0xc000100000000000, 0), /* -1.1xxx1^-16382 */
    3575 #endif
    35763572    };
    35773573    X86FXSTATE State;
    … …  
    35903586
    35913587        GenerateArrayStart(pOutFn, g_aFpuUnaryR80[iFn].pszName, "FPU_UNARY_R80_TEST_T");
    3592         uint32_t cNormalInputs = 0;
     3588        uint32_t iTestOutput        = 0;
     3589        uint32_t cNormalInputs      = 0;
    35933590        uint32_t cTargetRangeInputs = 0;
    35943591        for (uint32_t iTest = 0; iTest < cTests + RT_ELEMENTS(s_aSpecials); iTest += 1)
    … …  
    35993596                if (g_aFpuUnaryR80[iFn].uExtra == kUnary_Rounding_F2xm1)
    36003597                {
    3601                     unsigned uTargetExp = RTFLOAT80U_EXP_BIAS;
    3602                     unsigned cTargetExp = 69;
     3598                    unsigned uTargetExp = g_aFpuUnaryR80[iFn].uExtra == kUnary_Rounding_F2xm1
     3599                                        ? RTFLOAT80U_EXP_BIAS /* 2^0..2^-69 */ : RTFLOAT80U_EXP_BIAS + 63 + 1 /* 2^64..2^-64 */;
     3600                    unsigned cTargetExp = g_aFpuUnaryR80[iFn].uExtra == kUnary_Rounding_F2xm1 ? 69 : 63*2 + 2;
    36033601                    if (InVal.s.uExponent <= uTargetExp && InVal.s.uExponent >= uTargetExp - cTargetExp)
    36043602                        cTargetRangeInputs++;
    … …  
    36223620
    36233621            for (uint16_t iRounding = 0; iRounding < 4; iRounding++)
    3624             {
    36253622                for (uint16_t iPrecision = 0; iPrecision < 4; iPrecision++)
    36263623                {
    … …  
    36313628                    IEMFPURESULT ResM = { RTFLOAT80U_INIT(0, 0, 0), 0 };
    36323629                    pfn(&State, &ResM, &InVal);
    3633                     RTStrmPrintf(pOutFn, "    { %#06x, %#06x, %#06x, %s, %s }, /* #%u/%u/%u/m */\n",
     3630                    RTStrmPrintf(pOutFn, "    { %#06x, %#06x, %#06x, %s, %s }, /* #%u/%u/%u/m = #%u */\n",
    36343631                                 State.FCW | fFcwExtra, State.FSW, ResM.FSW, GenFormatR80(&InVal),
    3635                                  GenFormatR80(&ResM.r80Result), iTest, iRounding, iPrecision);
     3632                                 GenFormatR80(&ResM.r80Result), iTest, iRounding, iPrecision, iTestOutput++);
    36363633
    36373634                    State.FCW = State.FCW & ~X86_FCW_MASK_ALL;
    36383635                    IEMFPURESULT ResU = { RTFLOAT80U_INIT(0, 0, 0), 0 };
    36393636                    pfn(&State, &ResU, &InVal);
    3640                     RTStrmPrintf(pOutFn, "    { %#06x, %#06x, %#06x, %s, %s }, /* #%u/%u/%u/u */\n",
     3637                    RTStrmPrintf(pOutFn, "    { %#06x, %#06x, %#06x, %s, %s }, /* #%u/%u/%u/u = #%u */\n",
    36413638                                 State.FCW | fFcwExtra, State.FSW, ResU.FSW, GenFormatR80(&InVal),
    3642                                  GenFormatR80(&ResU.r80Result), iTest, iRounding, iPrecision);
     3639                                 GenFormatR80(&ResU.r80Result), iTest, iRounding, iPrecision, iTestOutput++);
    36433640
    36443641                    uint16_t fXcpt = (ResM.FSW | ResU.FSW) & X86_FSW_XCPT_MASK & ~X86_FSW_SF;
    … …  
    36483645                        IEMFPURESULT Res1 = { RTFLOAT80U_INIT(0, 0, 0), 0 };
    36493646                        pfn(&State, &Res1, &InVal);
    3650                         RTStrmPrintf(pOutFn, "    { %#06x, %#06x, %#06x, %s, %s }, /* #%u/%u/%u/%#x */\n",
     3647                        RTStrmPrintf(pOutFn, "    { %#06x, %#06x, %#06x, %s, %s }, /* #%u/%u/%u/%#x = #%u */\n",
    36513648                                     State.FCW | fFcwExtra, State.FSW, Res1.FSW, GenFormatR80(&InVal),
    3652                                      GenFormatR80(&Res1.r80Result), iTest, iRounding, iPrecision, fXcpt);
     3649                                     GenFormatR80(&Res1.r80Result), iTest, iRounding, iPrecision, fXcpt, iTestOutput++);
    36533650                        if (((Res1.FSW & X86_FSW_XCPT_MASK) & fXcpt) != (Res1.FSW & X86_FSW_XCPT_MASK))
    36543651                        {
    … …  
    36573654                            IEMFPURESULT Res2 = { RTFLOAT80U_INIT(0, 0, 0), 0 };
    36583655                            pfn(&State, &Res2, &InVal);
    3659                             RTStrmPrintf(pOutFn, "    { %#06x, %#06x, %#06x, %s, %s }, /* #%u/%u/%u/%#x[!] */\n",
     3656                            RTStrmPrintf(pOutFn, "    { %#06x, %#06x, %#06x, %s, %s }, /* #%u/%u/%u/%#x[!] = #%u */\n",
    36603657                                         State.FCW | fFcwExtra, State.FSW, Res2.FSW, GenFormatR80(&InVal),
    3661                                          GenFormatR80(&Res2.r80Result), iTest, iRounding, iPrecision, fXcpt);
     3658                                         GenFormatR80(&Res2.r80Result), iTest, iRounding, iPrecision, fXcpt, iTestOutput++);
    36623659                        }
    36633660                        if (!RT_IS_POWER_OF_TWO(fXcpt))
    … …  
    36683665                                    IEMFPURESULT Res3 = { RTFLOAT80U_INIT(0, 0, 0), 0 };
    36693666                                    pfn(&State, &Res3, &InVal);
    3670                                     RTStrmPrintf(pOutFn, "    { %#06x, %#06x, %#06x, %s, %s }, /* #%u/%u/%u/u%#x */\n",
     3667                                    RTStrmPrintf(pOutFn, "    { %#06x, %#06x, %#06x, %s, %s }, /* #%u/%u/%u/u%#x = #%u */\n",
    36713668                                                 State.FCW | fFcwExtra, State.FSW, Res3.FSW, GenFormatR80(&InVal),
    3672                                                  GenFormatR80(&Res3.r80Result), iTest, iRounding, iPrecision, fUnmasked);
     3669                                                 GenFormatR80(&Res3.r80Result), iTest, iRounding, iPrecision, fUnmasked, iTestOutput++);
    36733670                                }
    36743671                    }
    36753672                }
    3676             }
    36773673        }
    36783674        GenerateArrayEnd(pOutFn, g_aFpuUnaryR80[iFn].pszName);
    … …  
    39063902static const FPU_UNARY_TWO_R80_T g_aFpuUnaryTwoR80[] =
    39073903{
     3904    ENTRY(fxtract_r80_r80),
    39083905    ENTRY_AMD(  fptan_r80_r80, 0),   // rounding differences
    39093906    ENTRY_INTEL(fptan_r80_r80, 0),
    3910     ENTRY(fxtract_r80_r80),
    39113907    ENTRY_AMD(  fsincos_r80_r80, 0), // C1 differences & value differences (e.g. -1m0x235cf2f580244a27^-1696)
    39123908    ENTRY_INTEL(fsincos_r80_r80, 0),
    … …  
    39363932
    39373933        GenerateArrayStart(pOutFn, g_aFpuUnaryTwoR80[iFn].pszName, "FPU_UNARY_TWO_R80_TEST_T");
    3938         uint32_t cNormalInputs = 0;
     3934        uint32_t iTestOutput        = 0;
     3935        uint32_t cNormalInputs      = 0;
     3936        uint32_t cTargetRangeInputs = 0;
    39393937        for (uint32_t iTest = 0; iTest < cTests + RT_ELEMENTS(s_aSpecials); iTest += 1)
    39403938        {
    3941             RTFLOAT80U const InVal = iTest < cTests ? RandR80Ex() : s_aSpecials[iTest - cTests];
     3939            RTFLOAT80U InVal = iTest < cTests ? RandR80Ex() : s_aSpecials[iTest - cTests];
    39423940            if (RTFLOAT80U_IS_NORMAL(&InVal))
     3941            {
     3942                if (iFn != 0)
     3943                {
     3944                    unsigned uTargetExp = RTFLOAT80U_EXP_BIAS + 63 + 1 /* 2^64..2^-64 */;
     3945                    unsigned cTargetExp = g_aFpuUnaryR80[iFn].uExtra == kUnary_Rounding_F2xm1 ? 69 : 63*2 + 2;
     3946                    if (InVal.s.uExponent <= uTargetExp && InVal.s.uExponent >= uTargetExp - cTargetExp)
     3947                        cTargetRangeInputs++;
     3948                    else if (cTargetRangeInputs < cMinNormals / 2 && iTest + cMinNormals / 2 >= cTests && iTest < cTests)
     3949                    {
     3950                        InVal.s.uExponent = RTRandU32Ex(uTargetExp - cTargetExp, uTargetExp);
     3951                        cTargetRangeInputs++;
     3952                    }
     3953                }
    39433954                cNormalInputs++;
     3955            }
    39443956            else if (cNormalInputs < cMinNormals && iTest + cMinNormals >= cTests && iTest < cTests)
    39453957            {
    … …  
    39483960            }
    39493961
     3962            uint16_t const fFcwExtra = 0; /* for rounding error indication */
    39503963            uint16_t const fFcw = RandFcw();
    39513964            State.FSW = RandFsw();
    39523965
    39533966            for (uint16_t iRounding = 0; iRounding < 4; iRounding++)
    3954             {
    39553967                for (uint16_t iPrecision = 0; iPrecision < 4; iPrecision++)
    39563968                {
    3957                     for (uint16_t iMask = 0; iMask <= X86_FCW_MASK_ALL; iMask += X86_FCW_MASK_ALL)
     3969                    State.FCW = (fFcw & ~(X86_FCW_RC_MASK | X86_FCW_PC_MASK | X86_FCW_MASK_ALL))
     3970                              | (iRounding  << X86_FCW_RC_SHIFT)
     3971                              | (iPrecision << X86_FCW_PC_SHIFT)
     3972                              | X86_FCW_MASK_ALL;
     3973                    IEMFPURESULTTWO ResM = { RTFLOAT80U_INIT(0, 0, 0), 0, RTFLOAT80U_INIT(0, 0, 0) };
     3974                    pfn(&State, &ResM, &InVal);
     3975                    RTStrmPrintf(pOutFn, "    { %#06x, %#06x, %#06x, %s, %s, %s }, /* #%u/%u/%u/m = #%u */\n",
     3976                                 State.FCW | fFcwExtra, State.FSW, ResM.FSW, GenFormatR80(&InVal), GenFormatR80(&ResM.r80Result1),
     3977                                 GenFormatR80(&ResM.r80Result2), iTest, iRounding, iPrecision, iTestOutput++);
     3978
     3979                    State.FCW = State.FCW & ~X86_FCW_MASK_ALL;
     3980                    IEMFPURESULTTWO ResU = { RTFLOAT80U_INIT(0, 0, 0), 0, RTFLOAT80U_INIT(0, 0, 0) };
     3981                    pfn(&State, &ResU, &InVal);
     3982                    RTStrmPrintf(pOutFn, "    { %#06x, %#06x, %#06x, %s, %s, %s }, /* #%u/%u/%u/u = #%u */\n",
     3983                                 State.FCW | fFcwExtra, State.FSW, ResU.FSW, GenFormatR80(&InVal), GenFormatR80(&ResU.r80Result1),
     3984                                 GenFormatR80(&ResU.r80Result2), iTest, iRounding, iPrecision, iTestOutput++);
     3985
     3986                    uint16_t fXcpt = (ResM.FSW | ResU.FSW) & X86_FSW_XCPT_MASK & ~X86_FSW_SF;
     3987                    if (fXcpt)
    39583988                    {
    3959                         IEMFPURESULTTWO Res = { RTFLOAT80U_INIT(0, 0, 0), 0, RTFLOAT80U_INIT(0, 0, 0) };
    3960                         State.FCW = (fFcw & ~(X86_FCW_RC_MASK | X86_FCW_PC_MASK | X86_FCW_MASK_ALL))
    3961                                   | (iRounding  << X86_FCW_RC_SHIFT)
    3962                                   | (iPrecision << X86_FCW_PC_SHIFT)
    3963                                   | iMask;
    3964                         pfn(&State, &Res, &InVal);
    3965                         RTStrmPrintf(pOutFn, "    { %#06x, %#06x, %#06x, %s, %s, %s }, /* #%u/%u/%u/%c */\n",
    3966                                      State.FCW, State.FSW, Res.FSW, GenFormatR80(&InVal),
    3967                                      GenFormatR80(&Res.r80Result1), GenFormatR80(&Res.r80Result2),
    3968                                      iTest, iRounding, iPrecision, iMask ? 'c' : 'u');
     3989                        State.FCW = (State.FCW & ~X86_FCW_MASK_ALL) | fXcpt;
     3990                        IEMFPURESULTTWO Res1 = { RTFLOAT80U_INIT(0, 0, 0), 0, RTFLOAT80U_INIT(0, 0, 0) };
     3991                        pfn(&State, &Res1, &InVal);
     3992                        RTStrmPrintf(pOutFn, "    { %#06x, %#06x, %#06x, %s, %s, %s }, /* #%u/%u/%u/%#x = #%u */\n",
     3993                                     State.FCW | fFcwExtra, State.FSW, Res1.FSW, GenFormatR80(&InVal), GenFormatR80(&Res1.r80Result1),
     3994                                     GenFormatR80(&Res1.r80Result2), iTest, iRounding, iPrecision, fXcpt, iTestOutput++);
     3995                        if (((Res1.FSW & X86_FSW_XCPT_MASK) & fXcpt) != (Res1.FSW & X86_FSW_XCPT_MASK))
     3996                        {
     3997                            fXcpt |= Res1.FSW & X86_FSW_XCPT_MASK;
     3998                            State.FCW = (State.FCW & ~X86_FCW_MASK_ALL) | fXcpt;
     3999                            IEMFPURESULTTWO Res2 = { RTFLOAT80U_INIT(0, 0, 0), 0, RTFLOAT80U_INIT(0, 0, 0) };
     4000                            pfn(&State, &Res2, &InVal);
     4001                            RTStrmPrintf(pOutFn, "    { %#06x, %#06x, %#06x, %s, %s, %s }, /* #%u/%u/%u/%#x[!] = #%u */\n",
     4002                                         State.FCW | fFcwExtra, State.FSW, Res2.FSW, GenFormatR80(&InVal), GenFormatR80(&Res2.r80Result1),
     4003                                         GenFormatR80(&Res2.r80Result2), iTest, iRounding, iPrecision, fXcpt, iTestOutput++);
     4004                        }
     4005                        if (!RT_IS_POWER_OF_TWO(fXcpt))
     4006                            for (uint16_t fUnmasked = 1; fUnmasked <= X86_FCW_PM; fUnmasked <<= 1)
     4007                                if (fUnmasked & fXcpt)
     4008                                {
     4009                                    State.FCW = (State.FCW & ~X86_FCW_MASK_ALL) | (fXcpt & ~fUnmasked);
     4010                                    IEMFPURESULTTWO Res3 = { RTFLOAT80U_INIT(0, 0, 0), 0, RTFLOAT80U_INIT(0, 0, 0) };
     4011                                    pfn(&State, &Res3, &InVal);
     4012                                    RTStrmPrintf(pOutFn, "    { %#06x, %#06x, %#06x, %s, %s, %s }, /* #%u/%u/%u/u%#x = #%u */\n",
     4013                                                 State.FCW | fFcwExtra, State.FSW, Res3.FSW, GenFormatR80(&InVal), GenFormatR80(&Res3.r80Result1),
     4014                                                 GenFormatR80(&Res3.r80Result2), iTest, iRounding, iPrecision, fUnmasked, iTestOutput++);
     4015                                }
    39694016                    }
    39704017                }
    3971             }
    39724018        }
    39734019        GenerateArrayEnd(pOutFn, g_aFpuUnaryTwoR80[iFn].pszName);
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