VirtualBox

Ignore:
Timestamp:
Apr 2, 2024 12:37:36 PM (8 months ago)
Author:
vboxsync
Message:

VMM/IEM: Rework MXCSR handling for SSE instructions, bugref:10641

The old approach by referencing the X86FXSTATE and accessing the MXCSR value there
prevents us from keeping the MXCSR shadowed in a host register for SIMD guest code
causing unecessary memory accesses. It also prevents avoiding skipping dirty guest registers
because the instruction helpers would have access the to CPUMCTX structure.

The new approach passes the guest MXCSR as the first argument of the helper callback and
the helper returns the MXCSR with the new exception flags being set as a return value.
With this the helpers only work on arguments supplied and don't access anything in CPUMCTX
directly which allows the recompiler to avoid flushing pending register writes unless they get
used.

As a bonus this also gets rid of the IEMSSERESULT struct which was required because the helpers
are restricted to 4 arguments due to restrictions on x86 for the assembly helpers in IEMAllAImpl.asm

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r104051 r104129  
    55
    66/*
    7  * Copyright (C) 2022-2023 Oracle and/or its affiliates.
     7 * Copyright (C) 2022-2024 Oracle and/or its affiliates.
    88 *
    99 * This file is part of VirtualBox base platform packages, as
    … …  
    55945594    };
    55955595
    5596     X86FXSTATE State;
    5597     RT_ZERO(State);
    55985596    uint32_t cMinNormalPairs       = (cTests - 144) / 4;
    55995597    for (size_t iFn = 0; iFn < RT_ELEMENTS(g_aSseBinaryR32); iFn++)
    … …  
    56355633                    for (uint8_t iFz = 0; iFz < 2; iFz++)
    56365634                    {
    5637                         State.MXCSR = (fMxcsr & ~X86_MXCSR_RC_MASK)
    5638                                     | (iRounding  << X86_MXCSR_RC_SHIFT)
    5639                                     | (iDaz ? X86_MXCSR_DAZ : 0)
    5640                                     | (iFz  ? X86_MXCSR_FZ  : 0)
    5641                                     | X86_MXCSR_XCPT_MASK;
    5642                         IEMSSERESULT ResM; RT_ZERO(ResM);
    5643                         pfn(&State, &ResM, &TestData.InVal1, &TestData.InVal2);
    5644                         TestData.fMxcsrIn  = State.MXCSR;
    5645                         TestData.fMxcsrOut = ResM.MXCSR;
    5646                         TestData.OutVal    = ResM.uResult;
     5635                        uint32_t uMxCsrIn = (fMxcsr & ~X86_MXCSR_RC_MASK)
     5636                                          | (iRounding  << X86_MXCSR_RC_SHIFT)
     5637                                          | (iDaz ? X86_MXCSR_DAZ : 0)
     5638                                          | (iFz  ? X86_MXCSR_FZ  : 0)
     5639                                          | X86_MXCSR_XCPT_MASK;
     5640                        X86XMMREG ResM; RT_ZERO(ResM);
     5641                        uint32_t uMxCsrOutM = pfn(uMxCsrIn, &ResM, &TestData.InVal1, &TestData.InVal2);
     5642                        TestData.fMxcsrIn  = uMxCsrIn;
     5643                        TestData.fMxcsrOut = uMxCsrOutM;
     5644                        TestData.OutVal    = ResM;
    56475645                        GenerateBinaryWrite(&BinOut, &TestData, sizeof(TestData));
    56485646
    5649                         State.MXCSR = State.MXCSR & ~X86_MXCSR_XCPT_MASK;
    5650                         IEMSSERESULT ResU; RT_ZERO(ResU);
    5651                         pfn(&State, &ResU, &TestData.InVal1, &TestData.InVal2);
    5652                         TestData.fMxcsrIn  = State.MXCSR;
    5653                         TestData.fMxcsrOut = ResU.MXCSR;
    5654                         TestData.OutVal    = ResU.uResult;
     5647                        uMxCsrIn = uMxCsrIn & ~X86_MXCSR_XCPT_MASK;
     5648                        X86XMMREG ResU; RT_ZERO(ResU);
     5649                        uint32_t uMxCsrOutU = pfn(uMxCsrIn, &ResU, &TestData.InVal1, &TestData.InVal2);
     5650                        TestData.fMxcsrIn  = uMxCsrIn;
     5651                        TestData.fMxcsrOut = uMxCsrOutU;
     5652                        TestData.OutVal    = ResU;
    56555653                        GenerateBinaryWrite(&BinOut, &TestData, sizeof(TestData));
    56565654
    5657                         uint16_t fXcpt = (ResM.MXCSR | ResU.MXCSR) & X86_MXCSR_XCPT_FLAGS;
     5655                        uint16_t fXcpt = (uMxCsrOutM | uMxCsrOutU) & X86_MXCSR_XCPT_FLAGS;
    56585656                        if (fXcpt)
    56595657                        {
    5660                             State.MXCSR = (State.MXCSR & ~X86_MXCSR_XCPT_MASK) | fXcpt;
    5661                             IEMSSERESULT Res1; RT_ZERO(Res1);
    5662                             pfn(&State, &Res1, &TestData.InVal1, &TestData.InVal2);
    5663                             TestData.fMxcsrIn  = State.MXCSR;
    5664                             TestData.fMxcsrOut = Res1.MXCSR;
    5665                             TestData.OutVal    = Res1.uResult;
     5658                            uMxCsrIn = (uMxCsrIn & ~X86_MXCSR_XCPT_MASK) | fXcpt;
     5659                            X86XMMREG Res1; RT_ZERO(Res1);
     5660                            uint32_t uMxCsrOut1 = pfn(uMxCsrIn, &Res1, &TestData.InVal1, &TestData.InVal2);
     5661                            TestData.fMxcsrIn  = uMxCsrIn;
     5662                            TestData.fMxcsrOut = uMxCsrOut1;
     5663                            TestData.OutVal    = Res1;
    56665664                            GenerateBinaryWrite(&BinOut, &TestData, sizeof(TestData));
    56675665
    5668                             if (((Res1.MXCSR & X86_MXCSR_XCPT_FLAGS) & fXcpt) != (Res1.MXCSR & X86_MXCSR_XCPT_FLAGS))
     5666                            if (((uMxCsrOut1 & X86_MXCSR_XCPT_FLAGS) & fXcpt) != (uMxCsrOut1 & X86_MXCSR_XCPT_FLAGS))
    56695667                            {
    5670                                 fXcpt |= Res1.MXCSR & X86_MXCSR_XCPT_FLAGS;
    5671                                 State.MXCSR = (State.MXCSR & ~X86_MXCSR_XCPT_MASK) | (fXcpt << X86_MXCSR_XCPT_MASK_SHIFT);
    5672                                 IEMSSERESULT Res2; RT_ZERO(Res2);
    5673                                 pfn(&State, &Res2, &TestData.InVal1, &TestData.InVal2);
    5674                                 TestData.fMxcsrIn  = State.MXCSR;
    5675                                 TestData.fMxcsrOut = Res2.MXCSR;
    5676                                 TestData.OutVal    = Res2.uResult;
     5668                                fXcpt |= uMxCsrOut1 & X86_MXCSR_XCPT_FLAGS;
     5669                                uMxCsrIn = (uMxCsrIn & ~X86_MXCSR_XCPT_MASK) | (fXcpt << X86_MXCSR_XCPT_MASK_SHIFT);
     5670                                X86XMMREG Res2; RT_ZERO(Res2);
     5671                                uint32_t uMxCsrOut2 = pfn(uMxCsrIn, &Res2, &TestData.InVal1, &TestData.InVal2);
     5672                                TestData.fMxcsrIn  = uMxCsrIn;
     5673                                TestData.fMxcsrOut = uMxCsrOut2;
     5674                                TestData.OutVal    = Res2;
    56775675                                GenerateBinaryWrite(&BinOut, &TestData, sizeof(TestData));
    56785676                            }
    … …  
    56815679                                    if (fUnmasked & fXcpt)
    56825680                                    {
    5683                                         State.MXCSR = (State.MXCSR & ~X86_MXCSR_XCPT_MASK) | ((fXcpt & ~fUnmasked) << X86_MXCSR_XCPT_MASK_SHIFT);
    5684                                         IEMSSERESULT Res3; RT_ZERO(Res3);
    5685                                         pfn(&State, &Res3, &TestData.InVal1, &TestData.InVal2);
    5686                                         TestData.fMxcsrIn  = State.MXCSR;
    5687                                         TestData.fMxcsrOut = Res3.MXCSR;
    5688                                         TestData.OutVal    = Res3.uResult;
     5681                                        uMxCsrIn = (uMxCsrIn & ~X86_MXCSR_XCPT_MASK) | ((fXcpt & ~fUnmasked) << X86_MXCSR_XCPT_MASK_SHIFT);
     5682                                        X86XMMREG Res3; RT_ZERO(Res3);
     5683                                        uint32_t uMxCsrOut3 = pfn(uMxCsrIn, &Res3, &TestData.InVal1, &TestData.InVal2);
     5684                                        TestData.fMxcsrIn  = uMxCsrIn;
     5685                                        TestData.fMxcsrOut = uMxCsrOut3;
     5686                                        TestData.OutVal    = Res3;
    56895687                                        GenerateBinaryWrite(&BinOut, &TestData, sizeof(TestData));
    56905688                                    }
    … …  
    57015699static void SseBinaryR32Test(void)
    57025700{
    5703     X86FXSTATE State;
    5704     RT_ZERO(State);
    57055701    for (size_t iFn = 0; iFn < RT_ELEMENTS(g_aSseBinaryR32); iFn++)
    57065702    {
    … …  
    57175713            for (uint32_t iTest = 0; iTest < cbTests / sizeof(paTests[0]); iTest++)
    57185714            {
    5719                 IEMSSERESULT Res; RT_ZERO(Res);
    5720 
    5721                 State.MXCSR = paTests[iTest].fMxcsrIn;
    5722                 pfn(&State, &Res, &paTests[iTest].InVal1, &paTests[iTest].InVal2);
    5723                 bool fValsIdentical =    RTFLOAT32U_ARE_IDENTICAL(&Res.uResult.ar32[0], &paTests[iTest].OutVal.ar32[0])
    5724                                       && RTFLOAT32U_ARE_IDENTICAL(&Res.uResult.ar32[1], &paTests[iTest].OutVal.ar32[1])
    5725                                       && RTFLOAT32U_ARE_IDENTICAL(&Res.uResult.ar32[2], &paTests[iTest].OutVal.ar32[2])
    5726                                       && RTFLOAT32U_ARE_IDENTICAL(&Res.uResult.ar32[3], &paTests[iTest].OutVal.ar32[3]);
    5727                 if (   Res.MXCSR != paTests[iTest].fMxcsrOut
     5715                X86XMMREG Res; RT_ZERO(Res);
     5716
     5717                uint32_t uMxCsrOut = pfn(paTests[iTest].fMxcsrIn, &Res, &paTests[iTest].InVal1, &paTests[iTest].InVal2);
     5718                bool fValsIdentical =    RTFLOAT32U_ARE_IDENTICAL(&Res.ar32[0], &paTests[iTest].OutVal.ar32[0])
     5719                                      && RTFLOAT32U_ARE_IDENTICAL(&Res.ar32[1], &paTests[iTest].OutVal.ar32[1])
     5720                                      && RTFLOAT32U_ARE_IDENTICAL(&Res.ar32[2], &paTests[iTest].OutVal.ar32[2])
     5721                                      && RTFLOAT32U_ARE_IDENTICAL(&Res.ar32[3], &paTests[iTest].OutVal.ar32[3]);
     5722                if (   uMxCsrOut != paTests[iTest].fMxcsrOut
    57285723                    || !fValsIdentical)
    57295724                    RTTestFailed(g_hTest, "#%04u%s: mxcsr=%#08x in1=%s'%s'%s'%s in2=%s'%s'%s'%s\n"
    … …  
    57355730                                 FormatR32(&paTests[iTest].InVal2.ar32[0]), FormatR32(&paTests[iTest].InVal2.ar32[1]),
    57365731                                 FormatR32(&paTests[iTest].InVal2.ar32[2]), FormatR32(&paTests[iTest].InVal2.ar32[3]),
    5737                                  iVar ? "  " : "", Res.MXCSR,
    5738                                  FormatR32(&Res.uResult.ar32[0]), FormatR32(&Res.uResult.ar32[1]),
    5739                                  FormatR32(&Res.uResult.ar32[2]), FormatR32(&Res.uResult.ar32[3]),
     5732                                 iVar ? "  " : "", uMxCsrOut,
     5733                                 FormatR32(&Res.ar32[0]), FormatR32(&Res.ar32[1]),
     5734                                 FormatR32(&Res.ar32[2]), FormatR32(&Res.ar32[3]),
    57405735                                 iVar ? "  " : "", paTests[iTest].fMxcsrOut,
    57415736                                 FormatR32(&paTests[iTest].OutVal.ar32[0]), FormatR32(&paTests[iTest].OutVal.ar32[1]),
    57425737                                 FormatR32(&paTests[iTest].OutVal.ar32[2]), FormatR32(&paTests[iTest].OutVal.ar32[3]),
    5743                                  MxcsrDiff(Res.MXCSR, paTests[iTest].fMxcsrOut),
     5738                                 MxcsrDiff(uMxCsrOut, paTests[iTest].fMxcsrOut),
    57445739                                 !fValsIdentical ? " - val" : "",
    57455740                                 FormatMxcsr(paTests[iTest].fMxcsrIn) );
    … …  
    57865781    };
    57875782
    5788     X86FXSTATE State;
    5789     RT_ZERO(State);
    57905783    uint32_t cMinNormalPairs       = (cTests - 144) / 4;
    57915784    for (size_t iFn = 0; iFn < RT_ELEMENTS(g_aSseBinaryR64); iFn++)
    … …  
    58205813                    for (uint8_t iFz = 0; iFz < 2; iFz++)
    58215814                    {
    5822                         State.MXCSR = (fMxcsr & ~X86_MXCSR_RC_MASK)
    5823                                     | (iRounding  << X86_MXCSR_RC_SHIFT)
    5824                                     | (iDaz ? X86_MXCSR_DAZ : 0)
    5825                                     | (iFz  ? X86_MXCSR_FZ  : 0)
    5826                                     | X86_MXCSR_XCPT_MASK;
    5827                         IEMSSERESULT ResM; RT_ZERO(ResM);
    5828                         pfn(&State, &ResM, &TestData.InVal1, &TestData.InVal2);
    5829                         TestData.fMxcsrIn  = State.MXCSR;
    5830                         TestData.fMxcsrOut = ResM.MXCSR;
    5831                         TestData.OutVal    = ResM.uResult;
     5815                        uint32_t uMxCsrIn = (fMxcsr & ~X86_MXCSR_RC_MASK)
     5816                                          | (iRounding  << X86_MXCSR_RC_SHIFT)
     5817                                          | (iDaz ? X86_MXCSR_DAZ : 0)
     5818                                          | (iFz  ? X86_MXCSR_FZ  : 0)
     5819                                          | X86_MXCSR_XCPT_MASK;
     5820                        X86XMMREG ResM; RT_ZERO(ResM);
     5821                        uint32_t uMxCsrOutM = pfn(uMxCsrIn, &ResM, &TestData.InVal1, &TestData.InVal2);
     5822                        TestData.fMxcsrIn  = uMxCsrIn;
     5823                        TestData.fMxcsrOut = uMxCsrOutM;
     5824                        TestData.OutVal    = ResM;
    58325825                        GenerateBinaryWrite(&BinOut, &TestData, sizeof(TestData));
    58335826
    5834                         State.MXCSR = State.MXCSR & ~X86_MXCSR_XCPT_MASK;
    5835                         IEMSSERESULT ResU; RT_ZERO(ResU);
    5836                         pfn(&State, &ResU, &TestData.InVal1, &TestData.InVal2);
    5837                         TestData.fMxcsrIn  = State.MXCSR;
    5838                         TestData.fMxcsrOut = ResU.MXCSR;
    5839                         TestData.OutVal    = ResU.uResult;
     5827                        uMxCsrIn = uMxCsrIn & ~X86_MXCSR_XCPT_MASK;
     5828                        X86XMMREG ResU; RT_ZERO(ResU);
     5829                        uint32_t uMxCsrOutU = pfn(uMxCsrIn, &ResU, &TestData.InVal1, &TestData.InVal2);
     5830                        TestData.fMxcsrIn  = uMxCsrIn;
     5831                        TestData.fMxcsrOut = uMxCsrOutU;
     5832                        TestData.OutVal    = ResU;
    58405833                        GenerateBinaryWrite(&BinOut, &TestData, sizeof(TestData));
    58415834
    5842                         uint16_t fXcpt = (ResM.MXCSR | ResU.MXCSR) & X86_MXCSR_XCPT_FLAGS;
     5835                        uint16_t fXcpt = (uMxCsrOutM | uMxCsrOutU) & X86_MXCSR_XCPT_FLAGS;
    58435836                        if (fXcpt)
    58445837                        {
    5845                             State.MXCSR = (State.MXCSR & ~X86_MXCSR_XCPT_MASK) | fXcpt;
    5846                             IEMSSERESULT Res1; RT_ZERO(Res1);
    5847                             pfn(&State, &Res1, &TestData.InVal1, &TestData.InVal2);
    5848                             TestData.fMxcsrIn  = State.MXCSR;
    5849                             TestData.fMxcsrOut = Res1.MXCSR;
    5850                             TestData.OutVal    = Res1.uResult;
     5838                            uMxCsrIn = (uMxCsrIn & ~X86_MXCSR_XCPT_MASK) | fXcpt;
     5839                            X86XMMREG Res1; RT_ZERO(Res1);
     5840                            uint32_t uMxCsrOut1 = pfn(uMxCsrIn, &Res1, &TestData.InVal1, &TestData.InVal2);
     5841                            TestData.fMxcsrIn  = uMxCsrIn;
     5842                            TestData.fMxcsrOut = uMxCsrOut1;
     5843                            TestData.OutVal    = Res1;
    58515844                            GenerateBinaryWrite(&BinOut, &TestData, sizeof(TestData));
    58525845
    5853                             if (((Res1.MXCSR & X86_MXCSR_XCPT_FLAGS) & fXcpt) != (Res1.MXCSR & X86_MXCSR_XCPT_FLAGS))
     5846                            if (((uMxCsrOut1 & X86_MXCSR_XCPT_FLAGS) & fXcpt) != (uMxCsrOut1 & X86_MXCSR_XCPT_FLAGS))
    58545847                            {
    5855                                 fXcpt |= Res1.MXCSR & X86_MXCSR_XCPT_FLAGS;
    5856                                 State.MXCSR = (State.MXCSR & ~X86_MXCSR_XCPT_MASK) | (fXcpt << X86_MXCSR_XCPT_MASK_SHIFT);
    5857                                 IEMSSERESULT Res2; RT_ZERO(Res2);
    5858                                 pfn(&State, &Res2, &TestData.InVal1, &TestData.InVal2);
    5859                                 TestData.fMxcsrIn  = State.MXCSR;
    5860                                 TestData.fMxcsrOut = Res2.MXCSR;
    5861                                 TestData.OutVal    = Res2.uResult;
     5848                                fXcpt |= uMxCsrOut1 & X86_MXCSR_XCPT_FLAGS;
     5849                                uMxCsrIn = (uMxCsrIn & ~X86_MXCSR_XCPT_MASK) | (fXcpt << X86_MXCSR_XCPT_MASK_SHIFT);
     5850                                X86XMMREG Res2; RT_ZERO(Res2);
     5851                                uint32_t uMxCsrOut2 = pfn(uMxCsrIn, &Res2, &TestData.InVal1, &TestData.InVal2);
     5852                                TestData.fMxcsrIn  = uMxCsrIn;
     5853                                TestData.fMxcsrOut = uMxCsrOut2;
     5854                                TestData.OutVal    = Res2;
    58625855                                GenerateBinaryWrite(&BinOut, &TestData, sizeof(TestData));
    58635856                            }
    … …  
    58665859                                    if (fUnmasked & fXcpt)
    58675860                                    {
    5868                                         State.MXCSR = (State.MXCSR & ~X86_MXCSR_XCPT_MASK) | ((fXcpt & ~fUnmasked) << X86_MXCSR_XCPT_MASK_SHIFT);
    5869                                         IEMSSERESULT Res3; RT_ZERO(Res3);
    5870                                         pfn(&State, &Res3, &TestData.InVal1, &TestData.InVal2);
    5871                                         TestData.fMxcsrIn  = State.MXCSR;
    5872                                         TestData.fMxcsrOut = Res3.MXCSR;
    5873                                         TestData.OutVal    = Res3.uResult;
     5861                                        uMxCsrIn = (uMxCsrIn & ~X86_MXCSR_XCPT_MASK) | ((fXcpt & ~fUnmasked) << X86_MXCSR_XCPT_MASK_SHIFT);
     5862                                        X86XMMREG Res3; RT_ZERO(Res3);
     5863                                        uint32_t uMxCsrOut3 = pfn(uMxCsrIn, &Res3, &TestData.InVal1, &TestData.InVal2);
     5864                                        TestData.fMxcsrIn  = uMxCsrIn;
     5865                                        TestData.fMxcsrOut = uMxCsrOut3;
     5866                                        TestData.OutVal    = Res3;
    58745867                                        GenerateBinaryWrite(&BinOut, &TestData, sizeof(TestData));
    58755868                                    }
    … …  
    58875880static void SseBinaryR64Test(void)
    58885881{
    5889     X86FXSTATE State;
    5890     RT_ZERO(State);
    58915882    for (size_t iFn = 0; iFn < RT_ELEMENTS(g_aSseBinaryR64); iFn++)
    58925883    {
    … …  
    59035894            for (uint32_t iTest = 0; iTest < cTests; iTest++)
    59045895            {
    5905                 IEMSSERESULT Res; RT_ZERO(Res);
    5906 
    5907                 State.MXCSR = paTests[iTest].fMxcsrIn;
    5908                 pfn(&State, &Res, &paTests[iTest].InVal1, &paTests[iTest].InVal2);
    5909                 if (   Res.MXCSR != paTests[iTest].fMxcsrOut
    5910                     || !RTFLOAT64U_ARE_IDENTICAL(&Res.uResult.ar64[0], &paTests[iTest].OutVal.ar64[0])
    5911                     || !RTFLOAT64U_ARE_IDENTICAL(&Res.uResult.ar64[1], &paTests[iTest].OutVal.ar64[1]))
     5896                X86XMMREG Res; RT_ZERO(Res);
     5897
     5898                uint32_t uMxCsrIn = paTests[iTest].fMxcsrIn;
     5899                uint32_t uMxCsrOut = pfn(uMxCsrIn, &Res, &paTests[iTest].InVal1, &paTests[iTest].InVal2);
     5900                if (   uMxCsrOut != paTests[iTest].fMxcsrOut
     5901                    || !RTFLOAT64U_ARE_IDENTICAL(&Res.ar64[0], &paTests[iTest].OutVal.ar64[0])
     5902                    || !RTFLOAT64U_ARE_IDENTICAL(&Res.ar64[1], &paTests[iTest].OutVal.ar64[1]))
    59125903                    RTTestFailed(g_hTest, "#%04u%s: mxcsr=%#08x in1=%s'%s in2=%s'%s\n"
    59135904                                          "%s               -> mxcsr=%#08x    %s'%s\n"
    … …  
    59165907                                 FormatR64(&paTests[iTest].InVal1.ar64[0]), FormatR64(&paTests[iTest].InVal1.ar64[1]),
    59175908                                 FormatR64(&paTests[iTest].InVal2.ar64[0]), FormatR64(&paTests[iTest].InVal2.ar64[1]),
    5918                                  iVar ? "  " : "", Res.MXCSR,
    5919                                  FormatR64(&Res.uResult.ar64[0]), FormatR64(&Res.uResult.ar64[1]),
     5909                                 iVar ? "  " : "", uMxCsrOut,
     5910                                 FormatR64(&Res.ar64[0]), FormatR64(&Res.ar64[1]),
    59205911                                 iVar ? "  " : "", paTests[iTest].fMxcsrOut,
    59215912                                 FormatR64(&paTests[iTest].OutVal.ar64[0]), FormatR64(&paTests[iTest].OutVal.ar64[1]),
    5922                                  MxcsrDiff(Res.MXCSR, paTests[iTest].fMxcsrOut),
    5923                                    (   !RTFLOAT64U_ARE_IDENTICAL(&Res.uResult.ar64[0], &paTests[iTest].OutVal.ar64[0])
    5924                                     || !RTFLOAT64U_ARE_IDENTICAL(&Res.uResult.ar64[1], &paTests[iTest].OutVal.ar64[1]))
     5913                                 MxcsrDiff(uMxCsrOut, paTests[iTest].fMxcsrOut),
     5914                                   (   !RTFLOAT64U_ARE_IDENTICAL(&Res.ar64[0], &paTests[iTest].OutVal.ar64[0])
     5915                                    || !RTFLOAT64U_ARE_IDENTICAL(&Res.ar64[1], &paTests[iTest].OutVal.ar64[1]))
    59255916                                 ? " - val" : "",
    59265917                                 FormatMxcsr(paTests[iTest].fMxcsrIn) );
    … …  
    59635954    };
    59645955
    5965     X86FXSTATE State;
    5966     RT_ZERO(State);
    59675956    uint32_t cMinNormalPairs       = (cTests - 144) / 4;
    59685957    for (size_t iFn = 0; iFn < RT_ELEMENTS(g_aSseBinaryU128R32); iFn++)
    … …  
    60025991                    for (uint8_t iFz = 0; iFz < 2; iFz++)
    60035992                    {
    6004                         State.MXCSR = (fMxcsr & ~X86_MXCSR_RC_MASK)
    6005                                     | (iRounding  << X86_MXCSR_RC_SHIFT)
    6006                                     | (iDaz ? X86_MXCSR_DAZ : 0)
    6007                                     | (iFz  ? X86_MXCSR_FZ  : 0)
    6008                                     | X86_MXCSR_XCPT_MASK;
    6009                         IEMSSERESULT ResM; RT_ZERO(ResM);
    6010                         pfn(&State, &ResM, &TestData.InVal1, &TestData.r32Val2);
    6011                         TestData.fMxcsrIn  = State.MXCSR;
    6012                         TestData.fMxcsrOut = ResM.MXCSR;
    6013                         TestData.OutVal    = ResM.uResult;
     5993                        uint32_t uMxCsrIn = (fMxcsr & ~X86_MXCSR_RC_MASK)
     5994                                          | (iRounding  << X86_MXCSR_RC_SHIFT)
     5995                                          | (iDaz ? X86_MXCSR_DAZ : 0)
     5996                                          | (iFz  ? X86_MXCSR_FZ  : 0)
     5997                                          | X86_MXCSR_XCPT_MASK;
     5998                        X86XMMREG ResM; RT_ZERO(ResM);
     5999                        uint32_t uMxCsrOutM = pfn(uMxCsrIn, &ResM, &TestData.InVal1, &TestData.r32Val2);
     6000                        TestData.fMxcsrIn  = uMxCsrIn;
     6001                        TestData.fMxcsrOut = uMxCsrOutM;
     6002                        TestData.OutVal    = ResM;
    60146003                        GenerateBinaryWrite(&BinOut, &TestData, sizeof(TestData));
    60156004
    6016                         State.MXCSR = State.MXCSR & ~X86_MXCSR_XCPT_MASK;
    6017                         IEMSSERESULT ResU; RT_ZERO(ResU);
    6018                         pfn(&State, &ResU, &TestData.InVal1, &TestData.r32Val2);
    6019                         TestData.fMxcsrIn  = State.MXCSR;
    6020                         TestData.fMxcsrOut = ResU.MXCSR;
    6021                         TestData.OutVal    = ResU.uResult;
     6005                        uMxCsrIn = uMxCsrIn & ~X86_MXCSR_XCPT_MASK;
     6006                        X86XMMREG ResU; RT_ZERO(ResU);
     6007                        uint32_t uMxCsrOutU = pfn(uMxCsrIn, &ResU, &TestData.InVal1, &TestData.r32Val2);
     6008                        TestData.fMxcsrIn  = uMxCsrIn;
     6009                        TestData.fMxcsrOut = uMxCsrOutU;
     6010                        TestData.OutVal    = ResU;
    60226011                        GenerateBinaryWrite(&BinOut, &TestData, sizeof(TestData));
    60236012
    6024                         uint16_t fXcpt = (ResM.MXCSR | ResU.MXCSR) & X86_MXCSR_XCPT_FLAGS;
     6013                        uint16_t fXcpt = (uMxCsrOutM | uMxCsrOutU) & X86_MXCSR_XCPT_FLAGS;
    60256014                        if (fXcpt)
    60266015                        {
    6027                             State.MXCSR = (State.MXCSR & ~X86_MXCSR_XCPT_MASK) | fXcpt;
    6028                             IEMSSERESULT Res1; RT_ZERO(Res1);
    6029                             pfn(&State, &Res1, &TestData.InVal1, &TestData.r32Val2);
    6030                             TestData.fMxcsrIn  = State.MXCSR;
    6031                             TestData.fMxcsrOut = Res1.MXCSR;
    6032                             TestData.OutVal    = Res1.uResult;
     6016                            uMxCsrIn = (uMxCsrIn & ~X86_MXCSR_XCPT_MASK) | fXcpt;
     6017                            X86XMMREG Res1; RT_ZERO(Res1);
     6018                            uint32_t uMxCsrOut1 = pfn(uMxCsrIn, &Res1, &TestData.InVal1, &TestData.r32Val2);
     6019                            TestData.fMxcsrIn  = uMxCsrIn;
     6020                            TestData.fMxcsrOut = uMxCsrOut1;
     6021                            TestData.OutVal    = Res1;
    60336022                            GenerateBinaryWrite(&BinOut, &TestData, sizeof(TestData));
    60346023
    6035                             if (((Res1.MXCSR & X86_MXCSR_XCPT_FLAGS) & fXcpt) != (Res1.MXCSR & X86_MXCSR_XCPT_FLAGS))
     6024                            if (((uMxCsrOut1 & X86_MXCSR_XCPT_FLAGS) & fXcpt) != (uMxCsrOut1 & X86_MXCSR_XCPT_FLAGS))
    60366025                            {
    6037                                 fXcpt |= Res1.MXCSR & X86_MXCSR_XCPT_FLAGS;
    6038                                 State.MXCSR = (State.MXCSR & ~X86_MXCSR_XCPT_MASK) | (fXcpt << X86_MXCSR_XCPT_MASK_SHIFT);
    6039                                 IEMSSERESULT Res2; RT_ZERO(Res2);
    6040                                 pfn(&State, &Res2, &TestData.InVal1, &TestData.r32Val2);
    6041                                 TestData.fMxcsrIn  = State.MXCSR;
    6042                                 TestData.fMxcsrOut = Res2.MXCSR;
    6043                                 TestData.OutVal    = Res2.uResult;
     6026                                fXcpt |= uMxCsrOut1 & X86_MXCSR_XCPT_FLAGS;
     6027                                uMxCsrIn = (uMxCsrIn & ~X86_MXCSR_XCPT_MASK) | (fXcpt << X86_MXCSR_XCPT_MASK_SHIFT);
     6028                                X86XMMREG Res2; RT_ZERO(Res2);
     6029                                uint32_t uMxCsrOut2 = pfn(uMxCsrIn, &Res2, &TestData.InVal1, &TestData.r32Val2);
     6030                                TestData.fMxcsrIn  = uMxCsrIn;
     6031                                TestData.fMxcsrOut = uMxCsrOut2;
     6032                                TestData.OutVal    = Res2;
    60446033                                GenerateBinaryWrite(&BinOut, &TestData, sizeof(TestData));
    60456034                            }
    … …  
    60486037                                    if (fUnmasked & fXcpt)
    60496038                                    {
    6050                                         State.MXCSR = (State.MXCSR & ~X86_MXCSR_XCPT_MASK) | ((fXcpt & ~fUnmasked) << X86_MXCSR_XCPT_MASK_SHIFT);
    6051                                         IEMSSERESULT Res3; RT_ZERO(Res3);
    6052                                         pfn(&State, &Res3, &TestData.InVal1, &TestData.r32Val2);
    6053                                         TestData.fMxcsrIn  = State.MXCSR;
    6054                                         TestData.fMxcsrOut = Res3.MXCSR;
    6055                                         TestData.OutVal    = Res3.uResult;
     6039                                        uMxCsrIn = (uMxCsrIn & ~X86_MXCSR_XCPT_MASK) | ((fXcpt & ~fUnmasked) << X86_MXCSR_XCPT_MASK_SHIFT);
     6040                                        X86XMMREG Res3; RT_ZERO(Res3);
     6041                                        uint32_t uMxCsrOut3 = pfn(uMxCsrIn, &Res3, &TestData.InVal1, &TestData.r32Val2);
     6042                                        TestData.fMxcsrIn  = uMxCsrIn;
     6043                                        TestData.fMxcsrOut = uMxCsrOut3;
     6044                                        TestData.OutVal    = Res3;
    60566045                                        GenerateBinaryWrite(&BinOut, &TestData, sizeof(TestData));
    60576046                                    }
    … …  
    60686057static void SseBinaryU128R32Test(void)
    60696058{
    6070     X86FXSTATE State;
    6071     RT_ZERO(State);
    60726059    for (size_t iFn = 0; iFn < RT_ELEMENTS(g_aSseBinaryU128R32); iFn++)
    60736060    {
    … …  
    60846071            for (uint32_t iTest = 0; iTest < cTests; iTest++)
    60856072            {
    6086                 IEMSSERESULT Res; RT_ZERO(Res);
    6087 
    6088                 State.MXCSR = paTests[iTest].fMxcsrIn;
    6089                 pfn(&State, &Res, &paTests[iTest].InVal1, &paTests[iTest].r32Val2);
    6090                 bool fValsIdentical =    RTFLOAT32U_ARE_IDENTICAL(&Res.uResult.ar32[0], &paTests[iTest].OutVal.ar32[0])
    6091                                       && RTFLOAT32U_ARE_IDENTICAL(&Res.uResult.ar32[1], &paTests[iTest].OutVal.ar32[1])
    6092                                       && RTFLOAT32U_ARE_IDENTICAL(&Res.uResult.ar32[2], &paTests[iTest].OutVal.ar32[2])
    6093                                       && RTFLOAT32U_ARE_IDENTICAL(&Res.uResult.ar32[3], &paTests[iTest].OutVal.ar32[3]);
    6094                 if (   Res.MXCSR != paTests[iTest].fMxcsrOut
     6073                X86XMMREG Res; RT_ZERO(Res);
     6074
     6075                uint32_t uMxCsrIn = paTests[iTest].fMxcsrIn;
     6076                uint32_t uMxCsrOut = pfn(uMxCsrIn, &Res, &paTests[iTest].InVal1, &paTests[iTest].r32Val2);
     6077                bool fValsIdentical =    RTFLOAT32U_ARE_IDENTICAL(&Res.ar32[0], &paTests[iTest].OutVal.ar32[0])
     6078                                      && RTFLOAT32U_ARE_IDENTICAL(&Res.ar32[1], &paTests[iTest].OutVal.ar32[1])
     6079                                      && RTFLOAT32U_ARE_IDENTICAL(&Res.ar32[2], &paTests[iTest].OutVal.ar32[2])
     6080                                      && RTFLOAT32U_ARE_IDENTICAL(&Res.ar32[3], &paTests[iTest].OutVal.ar32[3]);
     6081                if (   uMxCsrOut != paTests[iTest].fMxcsrOut
    60956082                    || !fValsIdentical)
    60966083                    RTTestFailed(g_hTest, "#%04u%s: mxcsr=%#08x in1=%s'%s'%s'%s in2=%s\n"
    … …  
    61016088                                 FormatR32(&paTests[iTest].InVal1.ar32[2]), FormatR32(&paTests[iTest].InVal1.ar32[3]),
    61026089                                 FormatR32(&paTests[iTest].r32Val2),
    6103                                  iVar ? "  " : "", Res.MXCSR,
    6104                                  FormatR32(&Res.uResult.ar32[0]), FormatR32(&Res.uResult.ar32[1]),
    6105                                  FormatR32(&Res.uResult.ar32[2]), FormatR32(&Res.uResult.ar32[3]),
     6090                                 iVar ? "  " : "", uMxCsrOut,
     6091                                 FormatR32(&Res.ar32[0]), FormatR32(&Res.ar32[1]),
     6092                                 FormatR32(&Res.ar32[2]), FormatR32(&Res.ar32[3]),
    61066093                                 iVar ? "  " : "", paTests[iTest].fMxcsrOut,
    61076094                                 FormatR32(&paTests[iTest].OutVal.ar32[0]), FormatR32(&paTests[iTest].OutVal.ar32[1]),
    61086095                                 FormatR32(&paTests[iTest].OutVal.ar32[2]), FormatR32(&paTests[iTest].OutVal.ar32[3]),
    6109                                  MxcsrDiff(Res.MXCSR, paTests[iTest].fMxcsrOut),
     6096                                 MxcsrDiff(uMxCsrOut, paTests[iTest].fMxcsrOut),
    61106097                                 !fValsIdentical ? " - val" : "",
    61116098                                 FormatMxcsr(paTests[iTest].fMxcsrIn) );
    … …  
    61476134    };
    61486135
    6149     X86FXSTATE State;
    6150     RT_ZERO(State);
    61516136    uint32_t cMinNormalPairs       = (cTests - 144) / 4;
    61526137    for (size_t iFn = 0; iFn < RT_ELEMENTS(g_aSseBinaryU128R64); iFn++)
    … …  
    61806165                    for (uint8_t iFz = 0; iFz < 2; iFz++)
    61816166                    {
    6182                         State.MXCSR = (fMxcsr & ~X86_MXCSR_RC_MASK)
    6183                                     | (iRounding  << X86_MXCSR_RC_SHIFT)
    6184                                     | (iDaz ? X86_MXCSR_DAZ : 0)
    6185                                     | (iFz  ? X86_MXCSR_FZ  : 0)
    6186                                     | X86_MXCSR_XCPT_MASK;
    6187                         IEMSSERESULT ResM; RT_ZERO(ResM);
    6188                         pfn(&State, &ResM, &TestData.InVal1, &TestData.r64Val2);
    6189                         TestData.fMxcsrIn  = State.MXCSR;
    6190                         TestData.fMxcsrOut = ResM.MXCSR;
    6191                         TestData.OutVal    = ResM.uResult;
     6167                        uint32_t uMxCsrIn = (fMxcsr & ~X86_MXCSR_RC_MASK)
     6168                                          | (iRounding  << X86_MXCSR_RC_SHIFT)
     6169                                          | (iDaz ? X86_MXCSR_DAZ : 0)
     6170                                          | (iFz  ? X86_MXCSR_FZ  : 0)
     6171                                          | X86_MXCSR_XCPT_MASK;
     6172                        uint32_t uMxCsrOutM = pfn(uMxCsrIn, &TestData.OutVal, &TestData.InVal1, &TestData.r64Val2);
     6173                        TestData.fMxcsrIn  = uMxCsrIn;
     6174                        TestData.fMxcsrOut = uMxCsrOutM;
    61926175                        GenerateBinaryWrite(&BinOut, &TestData, sizeof(TestData));
    61936176
    6194                         State.MXCSR = State.MXCSR & ~X86_MXCSR_XCPT_MASK;
    6195                         IEMSSERESULT ResU; RT_ZERO(ResU);
    6196                         pfn(&State, &ResU, &TestData.InVal1, &TestData.r64Val2);
    6197                         TestData.fMxcsrIn  = State.MXCSR;
    6198                         TestData.fMxcsrOut = ResU.MXCSR;
    6199                         TestData.OutVal    = ResU.uResult;
     6177                        uMxCsrIn = uMxCsrIn & ~X86_MXCSR_XCPT_MASK;
     6178                        uint32_t uMxCsrOutU = pfn(uMxCsrIn, &TestData.OutVal, &TestData.InVal1, &TestData.r64Val2);
     6179                        TestData.fMxcsrIn  = uMxCsrIn;
     6180                        TestData.fMxcsrOut = uMxCsrOutU;
    62006181                        GenerateBinaryWrite(&BinOut, &TestData, sizeof(TestData));
    62016182
    6202                         uint16_t fXcpt = (ResM.MXCSR | ResU.MXCSR) & X86_MXCSR_XCPT_FLAGS;
     6183                        uint16_t fXcpt = (uMxCsrOutM | uMxCsrOutU) & X86_MXCSR_XCPT_FLAGS;
    62036184                        if (fXcpt)
    62046185                        {
    6205                             State.MXCSR = (State.MXCSR & ~X86_MXCSR_XCPT_MASK) | fXcpt;
    6206                             IEMSSERESULT Res1; RT_ZERO(Res1);
    6207                             pfn(&State, &Res1, &TestData.InVal1, &TestData.r64Val2);
    6208                             TestData.fMxcsrIn  = State.MXCSR;
    6209                             TestData.fMxcsrOut = Res1.MXCSR;
    6210                             TestData.OutVal    = Res1.uResult;
     6186                            uMxCsrIn = (uMxCsrIn & ~X86_MXCSR_XCPT_MASK) | fXcpt;
     6187                            uint32_t uMxCsrOut1 = pfn(uMxCsrIn, &TestData.OutVal, &TestData.InVal1, &TestData.r64Val2);
     6188                            TestData.fMxcsrIn  = uMxCsrIn;
     6189                            TestData.fMxcsrOut = uMxCsrOut1;
    62116190                            GenerateBinaryWrite(&BinOut, &TestData, sizeof(TestData));
    62126191
    6213                             if (((Res1.MXCSR & X86_MXCSR_XCPT_FLAGS) & fXcpt) != (Res1.MXCSR & X86_MXCSR_XCPT_FLAGS))
     6192                            if (((uMxCsrOut1 & X86_MXCSR_XCPT_FLAGS) & fXcpt) != (uMxCsrOut1 & X86_MXCSR_XCPT_FLAGS))
    62146193                            {
    6215                                 fXcpt |= Res1.MXCSR & X86_MXCSR_XCPT_FLAGS;
    6216                                 State.MXCSR = (State.MXCSR & ~X86_MXCSR_XCPT_MASK) | (fXcpt << X86_MXCSR_XCPT_MASK_SHIFT);
    6217                                 IEMSSERESULT Res2; RT_ZERO(Res2);
    6218                                 pfn(&State, &Res2, &TestData.InVal1, &TestData.r64Val2);
    6219                                 TestData.fMxcsrIn  = State.MXCSR;
    6220                                 TestData.fMxcsrOut = Res2.MXCSR;
    6221                                 TestData.OutVal    = Res2.uResult;
     6194                                fXcpt |= uMxCsrOut1 & X86_MXCSR_XCPT_FLAGS;
     6195                                uMxCsrIn = (uMxCsrIn & ~X86_MXCSR_XCPT_MASK) | (fXcpt << X86_MXCSR_XCPT_MASK_SHIFT);
     6196                                uint32_t uMxCsrOut2 = pfn(uMxCsrIn, &TestData.OutVal, &TestData.InVal1, &TestData.r64Val2);
     6197                                TestData.fMxcsrIn  = uMxCsrIn;
     6198                                TestData.fMxcsrOut = uMxCsrOut2;
    62226199                                GenerateBinaryWrite(&BinOut, &TestData, sizeof(TestData));
    62236200                            }
    … …  
    62266203                                    if (fUnmasked & fXcpt)
    62276204                                    {
    6228                                         State.MXCSR = (State.MXCSR & ~X86_MXCSR_XCPT_MASK) | ((fXcpt & ~fUnmasked) << X86_MXCSR_XCPT_MASK_SHIFT);
    6229                                         IEMSSERESULT Res3; RT_ZERO(Res3);
    6230                                         pfn(&State, &Res3, &TestData.InVal1, &TestData.r64Val2);
    6231                                         TestData.fMxcsrIn  = State.MXCSR;
    6232                                         TestData.fMxcsrOut = Res3.MXCSR;
    6233                                         TestData.OutVal    = Res3.uResult;
     6205                                        uMxCsrIn = (uMxCsrIn & ~X86_MXCSR_XCPT_MASK) | ((fXcpt & ~fUnmasked) << X86_MXCSR_XCPT_MASK_SHIFT);
     6206                                        uint32_t uMxCsrOut3 = pfn(uMxCsrIn, &TestData.OutVal, &TestData.InVal1, &TestData.r64Val2);
     6207                                        TestData.fMxcsrIn  = uMxCsrIn;
     6208                                        TestData.fMxcsrOut = uMxCsrOut3;
    62346209                                        GenerateBinaryWrite(&BinOut, &TestData, sizeof(TestData));
    62356210                                    }
    … …  
    62476222static void SseBinaryU128R64Test(void)
    62486223{
    6249     X86FXSTATE State;
    6250     RT_ZERO(State);
    62516224    for (size_t iFn = 0; iFn < RT_ELEMENTS(g_aSseBinaryU128R64); iFn++)
    62526225    {
    … …  
    62636236            for (uint32_t iTest = 0; iTest < cTests; iTest++)
    62646237            {
    6265                 IEMSSERESULT Res; RT_ZERO(Res);
    6266 
    6267                 State.MXCSR = paTests[iTest].fMxcsrIn;
    6268                 pfn(&State, &Res, &paTests[iTest].InVal1, &paTests[iTest].r64Val2);
    6269                 if (   Res.MXCSR != paTests[iTest].fMxcsrOut
    6270                     || !RTFLOAT64U_ARE_IDENTICAL(&Res.uResult.ar64[0], &paTests[iTest].OutVal.ar64[0])
    6271                     || !RTFLOAT64U_ARE_IDENTICAL(&Res.uResult.ar64[1], &paTests[iTest].OutVal.ar64[1]))
     6238                X86XMMREG Res; RT_ZERO(Res);
     6239
     6240                uint32_t uMxCsrIn = paTests[iTest].fMxcsrIn;
     6241                uint32_t uMxCsrOut = pfn(uMxCsrIn, &Res, &paTests[iTest].InVal1, &paTests[iTest].r64Val2);
     6242                if (   uMxCsrOut != paTests[iTest].fMxcsrOut
     6243                    || !RTFLOAT64U_ARE_IDENTICAL(&Res.ar64[0], &paTests[iTest].OutVal.ar64[0])
     6244                    || !RTFLOAT64U_ARE_IDENTICAL(&Res.ar64[1], &paTests[iTest].OutVal.ar64[1]))
    62726245                    RTTestFailed(g_hTest, "#%04u%s: mxcsr=%#08x in1=%s'%s in2=%s\n"
    62736246                                          "%s               -> mxcsr=%#08x    %s'%s\n"
    … …  
    62766249                                 FormatR64(&paTests[iTest].InVal1.ar64[0]), FormatR64(&paTests[iTest].InVal1.ar64[1]),
    62776250                                 FormatR64(&paTests[iTest].r64Val2),
    6278                                  iVar ? "  " : "", Res.MXCSR,
    6279                                  FormatR64(&Res.uResult.ar64[0]), FormatR64(&Res.uResult.ar64[1]),
     6251                                 iVar ? "  " : "", uMxCsrOut,
     6252                                 FormatR64(&Res.ar64[0]), FormatR64(&Res.ar64[1]),
    62806253                                 iVar ? "  " : "", paTests[iTest].fMxcsrOut,
    62816254                                 FormatR64(&paTests[iTest].OutVal.ar64[0]), FormatR64(&paTests[iTest].OutVal.ar64[1]),
    6282                                  MxcsrDiff(Res.MXCSR, paTests[iTest].fMxcsrOut),
    6283                                    (   !RTFLOAT64U_ARE_IDENTICAL(&Res.uResult.ar64[0], &paTests[iTest].OutVal.ar64[0])
    6284                                     || !RTFLOAT64U_ARE_IDENTICAL(&Res.uResult.ar64[1], &paTests[iTest].OutVal.ar64[1]))
     6255                                 MxcsrDiff(uMxCsrOut, paTests[iTest].fMxcsrOut),
     6256                                   (   !RTFLOAT64U_ARE_IDENTICAL(&Res.ar64[0], &paTests[iTest].OutVal.ar64[0])
     6257                                    || !RTFLOAT64U_ARE_IDENTICAL(&Res.ar64[1], &paTests[iTest].OutVal.ar64[1]))
    62856258                                 ? " - val" : "",
    62866259                                 FormatMxcsr(paTests[iTest].fMxcsrIn) );
    … …  
    63166289    };
    63176290
    6318     X86FXSTATE State;
    6319     RT_ZERO(State);
    63206291    uint32_t cMinNormalPairs       = (cTests - 144) / 4;
    63216292    for (size_t iFn = 0; iFn < RT_ELEMENTS(g_aSseBinaryI32R64); iFn++)
    … …  
    63466317                    for (uint8_t iFz = 0; iFz < 2; iFz++)
    63476318                    {
    6348                         State.MXCSR = (fMxcsr & ~X86_MXCSR_RC_MASK)
    6349                                     | (iRounding  << X86_MXCSR_RC_SHIFT)
    6350                                     | (iDaz ? X86_MXCSR_DAZ : 0)
    6351                                     | (iFz  ? X86_MXCSR_FZ  : 0)
    6352                                     | X86_MXCSR_XCPT_MASK;
     6319                        uint32_t uMxCsrIn = (fMxcsr & ~X86_MXCSR_RC_MASK)
     6320                                          | (iRounding  << X86_MXCSR_RC_SHIFT)
     6321                                          | (iDaz ? X86_MXCSR_DAZ : 0)
     6322                                          | (iFz  ? X86_MXCSR_FZ  : 0)
     6323                                          | X86_MXCSR_XCPT_MASK;
    63536324                        uint32_t fMxcsrM; int32_t i32OutM;
    6354                         pfn(&State, &fMxcsrM, &i32OutM, &TestData.r64ValIn.u);
    6355                         TestData.fMxcsrIn  = State.MXCSR;
     6325                        fMxcsrM = pfn(uMxCsrIn, &i32OutM, &TestData.r64ValIn.u);
     6326                        TestData.fMxcsrIn  = uMxCsrIn;
    63566327                        TestData.fMxcsrOut = fMxcsrM;
    63576328                        TestData.i32ValOut = i32OutM;
    63586329                        GenerateBinaryWrite(&BinOut, &TestData, sizeof(TestData));
    63596330
    6360                         State.MXCSR = State.MXCSR & ~X86_MXCSR_XCPT_MASK;
     6331                        uMxCsrIn = uMxCsrIn & ~X86_MXCSR_XCPT_MASK;
    63616332                        uint32_t fMxcsrU; int32_t i32OutU;
    6362                         pfn(&State, &fMxcsrU, &i32OutU, &TestData.r64ValIn.u);
    6363                         TestData.fMxcsrIn  = State.MXCSR;
     6333                        fMxcsrU = pfn(uMxCsrIn, &i32OutU, &TestData.r64ValIn.u);
     6334                        TestData.fMxcsrIn  = uMxCsrIn;
    63646335                        TestData.fMxcsrOut = fMxcsrU;
    63656336                        TestData.i32ValOut = i32OutU;
    … …  
    63696340                        if (fXcpt)
    63706341                        {
    6371                             State.MXCSR = (State.MXCSR & ~X86_MXCSR_XCPT_MASK) | fXcpt;
     6342                            uMxCsrIn = (uMxCsrIn & ~X86_MXCSR_XCPT_MASK) | fXcpt;
    63726343                            uint32_t fMxcsr1; int32_t i32Out1;
    6373                             pfn(&State, &fMxcsr1, &i32Out1, &TestData.r64ValIn.u);
    6374                             TestData.fMxcsrIn  = State.MXCSR;
     6344                            fMxcsr1 = pfn(uMxCsrIn, &i32Out1, &TestData.r64ValIn.u);
     6345                            TestData.fMxcsrIn  = uMxCsrIn;
    63756346                            TestData.fMxcsrOut = fMxcsr1;
    63766347                            TestData.i32ValOut = i32Out1;
    … …  
    63806351                            {
    63816352                                fXcpt |= fMxcsr1 & X86_MXCSR_XCPT_FLAGS;
    6382                                 State.MXCSR = (State.MXCSR & ~X86_MXCSR_XCPT_MASK) | (fXcpt << X86_MXCSR_XCPT_MASK_SHIFT);
     6353                                uMxCsrIn = (uMxCsrIn & ~X86_MXCSR_XCPT_MASK) | (fXcpt << X86_MXCSR_XCPT_MASK_SHIFT);
    63836354                                uint32_t fMxcsr2; int32_t i32Out2;
    6384                                 pfn(&State, &fMxcsr2, &i32Out2, &TestData.r64ValIn.u);
    6385                                 TestData.fMxcsrIn  = State.MXCSR;
     6355                                fMxcsr2 = pfn(uMxCsrIn, &i32Out2, &TestData.r64ValIn.u);
     6356                                TestData.fMxcsrIn  = uMxCsrIn;
    63866357                                TestData.fMxcsrOut = fMxcsr2;
    63876358                                TestData.i32ValOut = i32Out2;
    … …  
    63926363                                    if (fUnmasked & fXcpt)
    63936364                                    {
    6394                                         State.MXCSR = (State.MXCSR & ~X86_MXCSR_XCPT_MASK) | ((fXcpt & ~fUnmasked) << X86_MXCSR_XCPT_MASK_SHIFT);
     6365                                        uMxCsrIn = (uMxCsrIn & ~X86_MXCSR_XCPT_MASK) | ((fXcpt & ~fUnmasked) << X86_MXCSR_XCPT_MASK_SHIFT);
    63956366                                        uint32_t fMxcsr3; int32_t i32Out3;
    6396                                         pfn(&State, &fMxcsr3, &i32Out3, &TestData.r64ValIn.u);
    6397                                         TestData.fMxcsrIn  = State.MXCSR;
     6367                                        fMxcsr3 = pfn(uMxCsrIn, &i32Out3, &TestData.r64ValIn.u);
     6368                                        TestData.fMxcsrIn  = uMxCsrIn;
    63986369                                        TestData.fMxcsrOut = fMxcsr3;
    63996370                                        TestData.i32ValOut = i32Out3;
    … …  
    64296400            for (uint32_t iTest = 0; iTest < cTests; iTest++)
    64306401            {
    6431                 uint32_t fMxcsr = 0;
    64326402                int32_t i32Dst = 0;
    64336403
    6434                 State.MXCSR = paTests[iTest].fMxcsrIn;
    6435                 pfn(&State, &fMxcsr, &i32Dst, &paTests[iTest].r64ValIn.u);
     6404                uint32_t fMxcsr = pfn(paTests[iTest].fMxcsrIn, &i32Dst, &paTests[iTest].r64ValIn.u);
    64366405                if (   fMxcsr != paTests[iTest].fMxcsrOut
    64376406                    || i32Dst != paTests[iTest].i32ValOut)
    … …  
    64786447    };
    64796448
    6480     X86FXSTATE State;
    6481     RT_ZERO(State);
    64826449    uint32_t cMinNormalPairs       = (cTests - 144) / 4;
    64836450    for (size_t iFn = 0; iFn < RT_ELEMENTS(g_aSseBinaryI64R64); iFn++)
    … …  
    65086475                    for (uint8_t iFz = 0; iFz < 2; iFz++)
    65096476                    {
    6510                         State.MXCSR = (fMxcsr & ~X86_MXCSR_RC_MASK)
    6511                                     | (iRounding  << X86_MXCSR_RC_SHIFT)
    6512                                     | (iDaz ? X86_MXCSR_DAZ : 0)
    6513                                     | (iFz  ? X86_MXCSR_FZ  : 0)
    6514                                     | X86_MXCSR_XCPT_MASK;
     6477                        uint32_t uMxCsrIn = (fMxcsr & ~X86_MXCSR_RC_MASK)
     6478                                          | (iRounding  << X86_MXCSR_RC_SHIFT)
     6479                                          | (iDaz ? X86_MXCSR_DAZ : 0)
     6480                                          | (iFz  ? X86_MXCSR_FZ  : 0)
     6481                                          | X86_MXCSR_XCPT_MASK;
    65156482                        uint32_t fMxcsrM; int64_t i64OutM;
    6516                         pfn(&State, &fMxcsrM, &i64OutM, &TestData.r64ValIn.u);
    6517                         TestData.fMxcsrIn  = State.MXCSR;
     6483                        fMxcsrM = pfn(uMxCsrIn, &i64OutM, &TestData.r64ValIn.u);
     6484                        TestData.fMxcsrIn  = uMxCsrIn;
    65186485                        TestData.fMxcsrOut = fMxcsrM;
    65196486                        TestData.i64ValOut = i64OutM;
    65206487                        GenerateBinaryWrite(&BinOut, &TestData, sizeof(TestData));
    65216488
    6522                         State.MXCSR = State.MXCSR & ~X86_MXCSR_XCPT_MASK;
     6489                        uMxCsrIn = uMxCsrIn & ~X86_MXCSR_XCPT_MASK;
    65236490                        uint32_t fMxcsrU; int64_t i64OutU;
    6524                         pfn(&State, &fMxcsrU, &i64OutU, &TestData.r64ValIn.u);
    6525                         TestData.fMxcsrIn  = State.MXCSR;
     6491                        fMxcsrU =pfn(uMxCsrIn, &i64OutU, &TestData.r64ValIn.u);
     6492                        TestData.fMxcsrIn  = uMxCsrIn;
    65266493                        TestData.fMxcsrOut = fMxcsrU;
    65276494                        TestData.i64ValOut = i64OutU;
    … …  
    65316498                        if (fXcpt)
    65326499                        {
    6533                             State.MXCSR = (State.MXCSR & ~X86_MXCSR_XCPT_MASK) | fXcpt;
     6500                            uMxCsrIn = (uMxCsrIn & ~X86_MXCSR_XCPT_MASK) | fXcpt;
    65346501                            uint32_t fMxcsr1; int64_t i64Out1;
    6535                             pfn(&State, &fMxcsr1, &i64Out1, &TestData.r64ValIn.u);
    6536                             TestData.fMxcsrIn  = State.MXCSR;
     6502                            fMxcsr1 = pfn(uMxCsrIn, &i64Out1, &TestData.r64ValIn.u);
     6503                            TestData.fMxcsrIn  = uMxCsrIn;
    65376504                            TestData.fMxcsrOut = fMxcsr1;
    65386505                            TestData.i64ValOut = i64Out1;
    … …  
    65426509                            {
    65436510                                fXcpt |= fMxcsr1 & X86_MXCSR_XCPT_FLAGS;
    6544                                 State.MXCSR = (State.MXCSR & ~X86_MXCSR_XCPT_MASK) | (fXcpt << X86_MXCSR_XCPT_MASK_SHIFT);
     6511                                uMxCsrIn = (uMxCsrIn & ~X86_MXCSR_XCPT_MASK) | (fXcpt << X86_MXCSR_XCPT_MASK_SHIFT);
    65456512                                uint32_t fMxcsr2; int64_t i64Out2;
    6546                                 pfn(&State, &fMxcsr2, &i64Out2, &TestData.r64ValIn.u);
    6547                                 TestData.fMxcsrIn  = State.MXCSR;
     6513                                fMxcsr2 = pfn(uMxCsrIn, &i64Out2, &TestData.r64ValIn.u);
     6514                                TestData.fMxcsrIn  = uMxCsrIn;
    65486515                                TestData.fMxcsrOut = fMxcsr2;
    65496516                                TestData.i64ValOut = i64Out2;
    … …  
    65546521                                    if (fUnmasked & fXcpt)
    65556522                                    {
    6556                                         State.MXCSR = (State.MXCSR & ~X86_MXCSR_XCPT_MASK) | ((fXcpt & ~fUnmasked) << X86_MXCSR_XCPT_MASK_SHIFT);
     6523                                        uMxCsrIn = (uMxCsrIn & ~X86_MXCSR_XCPT_MASK) | ((fXcpt & ~fUnmasked) << X86_MXCSR_XCPT_MASK_SHIFT);
    65576524                                        uint32_t fMxcsr3; int64_t i64Out3;
    6558                                         pfn(&State, &fMxcsr3, &i64Out3, &TestData.r64ValIn.u);
    6559                                         TestData.fMxcsrIn  = State.MXCSR;
     6525                                        fMxcsr3 = pfn(uMxCsrIn, &i64Out3, &TestData.r64ValIn.u);
     6526                                        TestData.fMxcsrIn  = uMxCsrIn;
    65606527                                        TestData.fMxcsrOut = fMxcsr3;
    65616528                                        TestData.i64ValOut = i64Out3;
    … …  
    65916558            for (uint32_t iTest = 0; iTest < cTests; iTest++)
    65926559            {
    6593                 uint32_t fMxcsr = 0;
    65946560                int64_t i64Dst = 0;
    6595 
    6596                 State.MXCSR = paTests[iTest].fMxcsrIn;
    6597                 pfn(&State, &fMxcsr, &i64Dst, &paTests[iTest].r64ValIn.u);
     6561                uint32_t fMxcsr = pfn(paTests[iTest].fMxcsrIn, &i64Dst, &paTests[iTest].r64ValIn.u);
    65986562                if (   fMxcsr != paTests[iTest].fMxcsrOut
    65996563                    || i64Dst != paTests[iTest].i64ValOut)
    … …  
    66406604    };
    66416605
    6642     X86FXSTATE State;
    6643     RT_ZERO(State);
    66446606    uint32_t cMinNormalPairs       = (cTests - 144) / 4;
    66456607    for (size_t iFn = 0; iFn < RT_ELEMENTS(g_aSseBinaryI32R32); iFn++)
    … …  
    66706632                    for (uint8_t iFz = 0; iFz < 2; iFz++)
    66716633                    {
    6672                         State.MXCSR = (fMxcsr & ~X86_MXCSR_RC_MASK)
    6673                                     | (iRounding  << X86_MXCSR_RC_SHIFT)
    6674                                     | (iDaz ? X86_MXCSR_DAZ : 0)
    6675                                     | (iFz  ? X86_MXCSR_FZ  : 0)
    6676                                     | X86_MXCSR_XCPT_MASK;
     6634                        uint32_t uMxCsrIn = (fMxcsr & ~X86_MXCSR_RC_MASK)
     6635                                          | (iRounding  << X86_MXCSR_RC_SHIFT)
     6636                                          | (iDaz ? X86_MXCSR_DAZ : 0)
     6637                                          | (iFz  ? X86_MXCSR_FZ  : 0)
     6638                                          | X86_MXCSR_XCPT_MASK;
    66776639                        uint32_t fMxcsrM; int32_t i32OutM;
    6678                         pfn(&State, &fMxcsrM, &i32OutM, &TestData.r32ValIn.u);
    6679                         TestData.fMxcsrIn  = State.MXCSR;
     6640                        fMxcsrM = pfn(uMxCsrIn, &i32OutM, &TestData.r32ValIn.u);
     6641                        TestData.fMxcsrIn  = uMxCsrIn;
    66806642                        TestData.fMxcsrOut = fMxcsrM;
    66816643                        TestData.i32ValOut = i32OutM;
    66826644                        GenerateBinaryWrite(&BinOut, &TestData, sizeof(TestData));
    66836645
    6684                         State.MXCSR = State.MXCSR & ~X86_MXCSR_XCPT_MASK;
     6646                        uMxCsrIn = uMxCsrIn & ~X86_MXCSR_XCPT_MASK;
    66856647                        uint32_t fMxcsrU; int32_t i32OutU;
    6686                         pfn(&State, &fMxcsrU, &i32OutU, &TestData.r32ValIn.u);
    6687                         TestData.fMxcsrIn  = State.MXCSR;
     6648                        fMxcsrU = pfn(uMxCsrIn, &i32OutU, &TestData.r32ValIn.u);
     6649                        TestData.fMxcsrIn  = uMxCsrIn;
    66886650                        TestData.fMxcsrOut = fMxcsrU;
    66896651                        TestData.i32ValOut = i32OutU;
    … …  
    66936655                        if (fXcpt)
    66946656                        {
    6695                             State.MXCSR = (State.MXCSR & ~X86_MXCSR_XCPT_MASK) | fXcpt;
     6657                            uMxCsrIn = (uMxCsrIn & ~X86_MXCSR_XCPT_MASK) | fXcpt;
    66966658                            uint32_t fMxcsr1; int32_t i32Out1;
    6697                             pfn(&State, &fMxcsr1, &i32Out1, &TestData.r32ValIn.u);
    6698                             TestData.fMxcsrIn  = State.MXCSR;
     6659                            fMxcsr1 = pfn(uMxCsrIn, &i32Out1, &TestData.r32ValIn.u);
     6660                            TestData.fMxcsrIn  = uMxCsrIn;
    66996661                            TestData.fMxcsrOut = fMxcsr1;
    67006662                            TestData.i32ValOut = i32Out1;
    … …  
    67046666                            {
    67056667                                fXcpt |= fMxcsr1 & X86_MXCSR_XCPT_FLAGS;
    6706                                 State.MXCSR = (State.MXCSR & ~X86_MXCSR_XCPT_MASK) | (fXcpt << X86_MXCSR_XCPT_MASK_SHIFT);
     6668                                uMxCsrIn = (uMxCsrIn & ~X86_MXCSR_XCPT_MASK) | (fXcpt << X86_MXCSR_XCPT_MASK_SHIFT);
    67076669                                uint32_t fMxcsr2; int32_t i32Out2;
    6708                                 pfn(&State, &fMxcsr2, &i32Out2, &TestData.r32ValIn.u);
    6709                                 TestData.fMxcsrIn  = State.MXCSR;
     6670                                fMxcsr2 = pfn(uMxCsrIn, &i32Out2, &TestData.r32ValIn.u);
     6671                                TestData.fMxcsrIn  = uMxCsrIn;
    67106672                                TestData.fMxcsrOut = fMxcsr2;
    67116673                                TestData.i32ValOut = i32Out2;
    … …  
    67166678                                    if (fUnmasked & fXcpt)
    67176679                                    {
    6718                                         State.MXCSR = (State.MXCSR & ~X86_MXCSR_XCPT_MASK) | ((fXcpt & ~fUnmasked) << X86_MXCSR_XCPT_MASK_SHIFT);
     6680                                        uMxCsrIn = (uMxCsrIn & ~X86_MXCSR_XCPT_MASK) | ((fXcpt & ~fUnmasked) << X86_MXCSR_XCPT_MASK_SHIFT);
    67196681                                        uint32_t fMxcsr3; int32_t i32Out3;
    6720                                         pfn(&State, &fMxcsr3, &i32Out3, &TestData.r32ValIn.u);
    6721                                         TestData.fMxcsrIn  = State.MXCSR;
     6682                                        fMxcsr3 = pfn(uMxCsrIn, &i32Out3, &TestData.r32ValIn.u);
     6683                                        TestData.fMxcsrIn  = uMxCsrIn;
    67226684                                        TestData.fMxcsrOut = fMxcsr3;
    67236685                                        TestData.i32ValOut = i32Out3;
    … …  
    67536715            for (uint32_t iTest = 0; iTest < cTests; iTest++)
    67546716            {
    6755                 uint32_t fMxcsr = 0;
    67566717                int32_t i32Dst = 0;
    67576718
    6758                 State.MXCSR = paTests[iTest].fMxcsrIn;
    6759                 pfn(&State, &fMxcsr, &i32Dst, &paTests[iTest].r32ValIn.u);
     6719                uint32_t fMxcsr = pfn(paTests[iTest].fMxcsrIn, &i32Dst, &paTests[iTest].r32ValIn.u);
    67606720                if (   fMxcsr != paTests[iTest].fMxcsrOut
    67616721                    || i32Dst != paTests[iTest].i32ValOut)
    … …  
    68326792                    for (uint8_t iFz = 0; iFz < 2; iFz++)
    68336793                    {
    6834                         State.MXCSR = (fMxcsr & ~X86_MXCSR_RC_MASK)
    6835                                     | (iRounding  << X86_MXCSR_RC_SHIFT)
    6836                                     | (iDaz ? X86_MXCSR_DAZ : 0)
    6837                                     | (iFz  ? X86_MXCSR_FZ  : 0)
    6838                                     | X86_MXCSR_XCPT_MASK;
     6794                        uint32_t uMxCsrIn = (fMxcsr & ~X86_MXCSR_RC_MASK)
     6795                                          | (iRounding  << X86_MXCSR_RC_SHIFT)
     6796                                          | (iDaz ? X86_MXCSR_DAZ : 0)
     6797                                          | (iFz  ? X86_MXCSR_FZ  : 0)
     6798                                          | X86_MXCSR_XCPT_MASK;
    68396799                        uint32_t fMxcsrM; int64_t i64OutM;
    6840                         pfn(&State, &fMxcsrM, &i64OutM, &TestData.r32ValIn.u);
     6800                        fMxcsrM = pfn(uMxCsrIn, &i64OutM, &TestData.r32ValIn.u);
    68416801                        TestData.fMxcsrIn  = State.MXCSR;
    68426802                        TestData.fMxcsrOut = fMxcsrM;
    … …  
    68446804                        GenerateBinaryWrite(&BinOut, &TestData, sizeof(TestData));
    68456805
    6846                         State.MXCSR = State.MXCSR & ~X86_MXCSR_XCPT_MASK;
     6806                        uMxCsrIn = uMxCsrIn & ~X86_MXCSR_XCPT_MASK;
    68476807                        uint32_t fMxcsrU; int64_t i64OutU;
    6848                         pfn(&State, &fMxcsrU, &i64OutU, &TestData.r32ValIn.u);
     6808                        fMxcsrU = pfn(uMxCsrIn, &i64OutU, &TestData.r32ValIn.u);
    68496809                        TestData.fMxcsrIn  = State.MXCSR;
    68506810                        TestData.fMxcsrOut = fMxcsrU;
    … …  
    68556815                        if (fXcpt)
    68566816                        {
    6857                             State.MXCSR = (State.MXCSR & ~X86_MXCSR_XCPT_MASK) | fXcpt;
     6817                            uMxCsrIn = (uMxCsrIn & ~X86_MXCSR_XCPT_MASK) | fXcpt;
    68586818                            uint32_t fMxcsr1; int64_t i64Out1;
    6859                             pfn(&State, &fMxcsr1, &i64Out1, &TestData.r32ValIn.u);
     6819                            fMxcsr1 = pfn(uMxCsrIn, &i64Out1, &TestData.r32ValIn.u);
    68606820                            TestData.fMxcsrIn  = State.MXCSR;
    68616821                            TestData.fMxcsrOut = fMxcsr1;
    … …  
    68666826                            {
    68676827                                fXcpt |= fMxcsr1 & X86_MXCSR_XCPT_FLAGS;
    6868                                 State.MXCSR = (State.MXCSR & ~X86_MXCSR_XCPT_MASK) | (fXcpt << X86_MXCSR_XCPT_MASK_SHIFT);
     6828                                uMxCsrIn = (uMxCsrIn & ~X86_MXCSR_XCPT_MASK) | (fXcpt << X86_MXCSR_XCPT_MASK_SHIFT);
    68696829                                uint32_t fMxcsr2; int64_t i64Out2;
    6870                                 pfn(&State, &fMxcsr2, &i64Out2, &TestData.r32ValIn.u);
     6830                                fMxcsr2 = pfn(uMxCsrIn, &i64Out2, &TestData.r32ValIn.u);
    68716831                                TestData.fMxcsrIn  = State.MXCSR;
    68726832                                TestData.fMxcsrOut = fMxcsr2;
    … …  
    68786838                                    if (fUnmasked & fXcpt)
    68796839                                    {
    6880                                         State.MXCSR = (State.MXCSR & ~X86_MXCSR_XCPT_MASK) | ((fXcpt & ~fUnmasked) << X86_MXCSR_XCPT_MASK_SHIFT);
     6840                                        uMxCsrIn = (uMxCsrIn & ~X86_MXCSR_XCPT_MASK) | ((fXcpt & ~fUnmasked) << X86_MXCSR_XCPT_MASK_SHIFT);
    68816841                                        uint32_t fMxcsr3; int64_t i64Out3;
    6882                                         pfn(&State, &fMxcsr3, &i64Out3, &TestData.r32ValIn.u);
     6842                                        fMxcsr3 = pfn(uMxCsrIn, &i64Out3, &TestData.r32ValIn.u);
    68836843                                        TestData.fMxcsrIn  = State.MXCSR;
    68846844                                        TestData.fMxcsrOut = fMxcsr3;
    … …  
    69156875            for (uint32_t iTest = 0; iTest < cTests; iTest++)
    69166876            {
    6917                 uint32_t fMxcsr = 0;
    69186877                int64_t i64Dst = 0;
    69196878
    6920                 State.MXCSR = paTests[iTest].fMxcsrIn;
    6921                 pfn(&State, &fMxcsr, &i64Dst, &paTests[iTest].r32ValIn.u);
     6879                uint32_t fMxcsr = pfn(paTests[iTest].fMxcsrIn, &i64Dst, &paTests[iTest].r32ValIn.u);
    69226880                if (   fMxcsr != paTests[iTest].fMxcsrOut
    69236881                    || i64Dst != paTests[iTest].i64ValOut)
    … …  
    69646922    };
    69656923
    6966     X86FXSTATE State;
    6967     RT_ZERO(State);
    69686924    for (size_t iFn = 0; iFn < RT_ELEMENTS(g_aSseBinaryR64I32); iFn++)
    69696925    {
    … …  
    69846940                    for (uint8_t iFz = 0; iFz < 2; iFz++)
    69856941                    {
    6986                         State.MXCSR = (fMxcsr & ~X86_MXCSR_RC_MASK)
    6987                                     | (iRounding  << X86_MXCSR_RC_SHIFT)
    6988                                     | (iDaz ? X86_MXCSR_DAZ : 0)
    6989                                     | (iFz  ? X86_MXCSR_FZ  : 0)
    6990                                     | X86_MXCSR_XCPT_MASK;
     6942                        uint32_t uMxCsrIn = (fMxcsr & ~X86_MXCSR_RC_MASK)
     6943                                          | (iRounding  << X86_MXCSR_RC_SHIFT)
     6944                                          | (iDaz ? X86_MXCSR_DAZ : 0)
     6945                                          | (iFz  ? X86_MXCSR_FZ  : 0)
     6946                                          | X86_MXCSR_XCPT_MASK;
    69916947                        uint32_t fMxcsrM; RTFLOAT64U r64OutM;
    6992                         pfn(&State, &fMxcsrM, &r64OutM, &TestData.i32ValIn);
    6993                         TestData.fMxcsrIn  = State.MXCSR;
     6948                        fMxcsrM = pfn(uMxCsrIn, &r64OutM, &TestData.i32ValIn);
     6949                        TestData.fMxcsrIn  = uMxCsrIn;
    69946950                        TestData.fMxcsrOut = fMxcsrM;
    69956951                        TestData.r64ValOut = r64OutM;
    69966952                        GenerateBinaryWrite(&BinOut, &TestData, sizeof(TestData));
    69976953
    6998                         State.MXCSR = State.MXCSR & ~X86_MXCSR_XCPT_MASK;
     6954                        uMxCsrIn = uMxCsrIn & ~X86_MXCSR_XCPT_MASK;
    69996955                        uint32_t fMxcsrU; RTFLOAT64U r64OutU;
    7000                         pfn(&State, &fMxcsrU, &r64OutU, &TestData.i32ValIn);
    7001                         TestData.fMxcsrIn  = State.MXCSR;
     6956                        fMxcsrU = pfn(uMxCsrIn, &r64OutU, &TestData.i32ValIn);
     6957                        TestData.fMxcsrIn  = uMxCsrIn;
    70026958                        TestData.fMxcsrOut = fMxcsrU;
    70036959                        TestData.r64ValOut = r64OutU;
    … …  
    70076963                        if (fXcpt)
    70086964                        {
    7009                             State.MXCSR = (State.MXCSR & ~X86_MXCSR_XCPT_MASK) | fXcpt;
     6965                            uMxCsrIn = (uMxCsrIn & ~X86_MXCSR_XCPT_MASK) | fXcpt;
    70106966                            uint32_t fMxcsr1; RTFLOAT64U r64Out1;
    7011                             pfn(&State, &fMxcsr1, &r64Out1, &TestData.i32ValIn);
    7012                             TestData.fMxcsrIn  = State.MXCSR;
     6967                            fMxcsr1 = pfn(uMxCsrIn, &r64Out1, &TestData.i32ValIn);
     6968                            TestData.fMxcsrIn  = uMxCsrIn;
    70136969                            TestData.fMxcsrOut = fMxcsr1;
    70146970                            TestData.r64ValOut = r64Out1;
    … …  
    70186974                            {
    70196975                                fXcpt |= fMxcsr1 & X86_MXCSR_XCPT_FLAGS;
    7020                                 State.MXCSR = (State.MXCSR & ~X86_MXCSR_XCPT_MASK) | (fXcpt << X86_MXCSR_XCPT_MASK_SHIFT);
     6976                                uMxCsrIn = (uMxCsrIn & ~X86_MXCSR_XCPT_MASK) | (fXcpt << X86_MXCSR_XCPT_MASK_SHIFT);
    70216977                                uint32_t fMxcsr2; RTFLOAT64U r64Out2;
    7022                                 pfn(&State, &fMxcsr2, &r64Out2, &TestData.i32ValIn);
    7023                                 TestData.fMxcsrIn  = State.MXCSR;
     6978                                fMxcsr2 = pfn(uMxCsrIn, &r64Out2, &TestData.i32ValIn);
     6979                                TestData.fMxcsrIn  = uMxCsrIn;
    70246980                                TestData.fMxcsrOut = fMxcsr2;
    70256981                                TestData.r64ValOut = r64Out2;
    … …  
    70306986                                    if (fUnmasked & fXcpt)
    70316987                                    {
    7032                                         State.MXCSR = (State.MXCSR & ~X86_MXCSR_XCPT_MASK) | ((fXcpt & ~fUnmasked) << X86_MXCSR_XCPT_MASK_SHIFT);
     6988                                        uMxCsrIn = (uMxCsrIn & ~X86_MXCSR_XCPT_MASK) | ((fXcpt & ~fUnmasked) << X86_MXCSR_XCPT_MASK_SHIFT);
    70336989                                        uint32_t fMxcsr3; RTFLOAT64U r64Out3;
    7034                                         pfn(&State, &fMxcsr3, &r64Out3, &TestData.i32ValIn);
    7035                                         TestData.fMxcsrIn  = State.MXCSR;
     6990                                        fMxcsr3 = pfn(uMxCsrIn, &r64Out3, &TestData.i32ValIn);
     6991                                        TestData.fMxcsrIn  = uMxCsrIn;
    70366992                                        TestData.fMxcsrOut = fMxcsr3;
    70376993                                        TestData.r64ValOut = r64Out3;
    … …  
    70517007static void SseBinaryR64I32Test(void)
    70527008{
    7053     X86FXSTATE State;
    7054     RT_ZERO(State);
    70557009    for (size_t iFn = 0; iFn < RT_ELEMENTS(g_aSseBinaryR64I32); iFn++)
    70567010    {
    … …  
    70677021            for (uint32_t iTest = 0; iTest < cTests; iTest++)
    70687022            {
    7069                 uint32_t fMxcsr = 0;
    70707023                RTFLOAT64U r64Dst; RT_ZERO(r64Dst);
    70717024
    7072                 State.MXCSR = paTests[iTest].fMxcsrIn;
    7073                 pfn(&State, &fMxcsr, &r64Dst, &paTests[iTest].i32ValIn);
     7025                uint32_t fMxcsr = pfn(paTests[iTest].fMxcsrIn, &r64Dst, &paTests[iTest].i32ValIn);
    70747026                if (   fMxcsr != paTests[iTest].fMxcsrOut
    70757027                    || !RTFLOAT64U_ARE_IDENTICAL(&r64Dst, &paTests[iTest].r64ValOut))
    … …  
    71167068    };
    71177069
    7118     X86FXSTATE State;
    7119     RT_ZERO(State);
    71207070    for (size_t iFn = 0; iFn < RT_ELEMENTS(g_aSseBinaryR64I64); iFn++)
    71217071    {
    … …  
    71367086                    for (uint8_t iFz = 0; iFz < 2; iFz++)
    71377087                    {
    7138                         State.MXCSR = (fMxcsr & ~X86_MXCSR_RC_MASK)
    7139                                     | (iRounding  << X86_MXCSR_RC_SHIFT)
    7140                                     | (iDaz ? X86_MXCSR_DAZ : 0)
    7141                                     | (iFz  ? X86_MXCSR_FZ  : 0)
    7142                                     | X86_MXCSR_XCPT_MASK;
     7088                        uint32_t uMxCsrIn = (fMxcsr & ~X86_MXCSR_RC_MASK)
     7089                                          | (iRounding  << X86_MXCSR_RC_SHIFT)
     7090                                          | (iDaz ? X86_MXCSR_DAZ : 0)
     7091                                          | (iFz  ? X86_MXCSR_FZ  : 0)
     7092                                          | X86_MXCSR_XCPT_MASK;
    71437093                        uint32_t fMxcsrM; RTFLOAT64U r64OutM;
    7144                         pfn(&State, &fMxcsrM, &r64OutM, &TestData.i64ValIn);
    7145                         TestData.fMxcsrIn  = State.MXCSR;
     7094                        fMxcsrM = pfn(uMxCsrIn, &r64OutM, &TestData.i64ValIn);
     7095                        TestData.fMxcsrIn  = uMxCsrIn;
    71467096                        TestData.fMxcsrOut = fMxcsrM;
    71477097                        TestData.r64ValOut = r64OutM;
    71487098                        GenerateBinaryWrite(&BinOut, &TestData, sizeof(TestData));
    71497099
    7150                         State.MXCSR = State.MXCSR & ~X86_MXCSR_XCPT_MASK;
     7100                        uMxCsrIn = uMxCsrIn & ~X86_MXCSR_XCPT_MASK;
    71517101                        uint32_t fMxcsrU; RTFLOAT64U r64OutU;
    7152                         pfn(&State, &fMxcsrU, &r64OutU, &TestData.i64ValIn);
    7153                         TestData.fMxcsrIn  = State.MXCSR;
     7102                        fMxcsrU = pfn(uMxCsrIn, &r64OutU, &TestData.i64ValIn);
     7103                        TestData.fMxcsrIn  = uMxCsrIn;
    71547104                        TestData.fMxcsrOut = fMxcsrU;
    71557105                        TestData.r64ValOut = r64OutU;
    … …  
    71597109                        if (fXcpt)
    71607110                        {
    7161                             State.MXCSR = (State.MXCSR & ~X86_MXCSR_XCPT_MASK) | fXcpt;
     7111                            uMxCsrIn = (uMxCsrIn & ~X86_MXCSR_XCPT_MASK) | fXcpt;
    71627112                            uint32_t fMxcsr1; RTFLOAT64U r64Out1;
    7163                             pfn(&State, &fMxcsr1, &r64Out1, &TestData.i64ValIn);
    7164                             TestData.fMxcsrIn  = State.MXCSR;
     7113                            fMxcsr1 = pfn(uMxCsrIn, &r64Out1, &TestData.i64ValIn);
     7114                            TestData.fMxcsrIn  = uMxCsrIn;
    71657115                            TestData.fMxcsrOut = fMxcsr1;
    71667116                            TestData.r64ValOut = r64Out1;
    … …  
    71707120                            {
    71717121                                fXcpt |= fMxcsr1 & X86_MXCSR_XCPT_FLAGS;
    7172                                 State.MXCSR = (State.MXCSR & ~X86_MXCSR_XCPT_MASK) | (fXcpt << X86_MXCSR_XCPT_MASK_SHIFT);
     7122                                uMxCsrIn = (uMxCsrIn & ~X86_MXCSR_XCPT_MASK) | (fXcpt << X86_MXCSR_XCPT_MASK_SHIFT);
    71737123                                uint32_t fMxcsr2; RTFLOAT64U r64Out2;
    7174                                 pfn(&State, &fMxcsr2, &r64Out2, &TestData.i64ValIn);
    7175                                 TestData.fMxcsrIn  = State.MXCSR;
     7124                                fMxcsr2 = pfn(uMxCsrIn, &r64Out2, &TestData.i64ValIn);
     7125                                TestData.fMxcsrIn  = uMxCsrIn;
    71767126                                TestData.fMxcsrOut = fMxcsr2;
    71777127                                TestData.r64ValOut = r64Out2;
    … …  
    71827132                                    if (fUnmasked & fXcpt)
    71837133                                    {
    7184                                         State.MXCSR = (State.MXCSR & ~X86_MXCSR_XCPT_MASK) | ((fXcpt & ~fUnmasked) << X86_MXCSR_XCPT_MASK_SHIFT);
     7134                                        uMxCsrIn = (uMxCsrIn & ~X86_MXCSR_XCPT_MASK) | ((fXcpt & ~fUnmasked) << X86_MXCSR_XCPT_MASK_SHIFT);
    71857135                                        uint32_t fMxcsr3; RTFLOAT64U r64Out3;
    7186                                         pfn(&State, &fMxcsr3, &r64Out3, &TestData.i64ValIn);
    7187                                         TestData.fMxcsrIn  = State.MXCSR;
     7136                                        fMxcsr3 = pfn(uMxCsrIn, &r64Out3, &TestData.i64ValIn);
     7137                                        TestData.fMxcsrIn  = uMxCsrIn;
    71887138                                        TestData.fMxcsrOut = fMxcsr3;
    71897139                                        TestData.r64ValOut = r64Out3;
    … …  
    72037153static void SseBinaryR64I64Test(void)
    72047154{
    7205     X86FXSTATE State;
    7206     RT_ZERO(State);
    72077155    for (size_t iFn = 0; iFn < RT_ELEMENTS(g_aSseBinaryR64I64); iFn++)
    72087156    {
    … …  
    72197167            for (uint32_t iTest = 0; iTest < cTests; iTest++)
    72207168            {
    7221                 uint32_t fMxcsr = 0;
    72227169                RTFLOAT64U r64Dst; RT_ZERO(r64Dst);
    72237170
    7224                 State.MXCSR = paTests[iTest].fMxcsrIn;
    7225                 pfn(&State, &fMxcsr, &r64Dst, &paTests[iTest].i64ValIn);
     7171                uint32_t fMxcsr = pfn(paTests[iTest].fMxcsrIn, &r64Dst, &paTests[iTest].i64ValIn);
    72267172                if (   fMxcsr != paTests[iTest].fMxcsrOut
    72277173                    || !RTFLOAT64U_ARE_IDENTICAL(&r64Dst, &paTests[iTest].r64ValOut))
    … …  
    72687214    };
    72697215
    7270     X86FXSTATE State;
    7271     RT_ZERO(State);
    72727216    for (size_t iFn = 0; iFn < RT_ELEMENTS(g_aSseBinaryR32I32); iFn++)
    72737217    {
    … …  
    72887232                    for (uint8_t iFz = 0; iFz < 2; iFz++)
    72897233                    {
    7290                         State.MXCSR = (fMxcsr & ~X86_MXCSR_RC_MASK)
    7291                                     | (iRounding  << X86_MXCSR_RC_SHIFT)
    7292                                     | (iDaz ? X86_MXCSR_DAZ : 0)
    7293                                     | (iFz  ? X86_MXCSR_FZ  : 0)
    7294                                     | X86_MXCSR_XCPT_MASK;
     7234                        uint32_t uMxCsrIn = (fMxcsr & ~X86_MXCSR_RC_MASK)
     7235                                          | (iRounding  << X86_MXCSR_RC_SHIFT)
     7236                                          | (iDaz ? X86_MXCSR_DAZ : 0)
     7237                                          | (iFz  ? X86_MXCSR_FZ  : 0)
     7238                                          | X86_MXCSR_XCPT_MASK;
    72957239                        uint32_t fMxcsrM; RTFLOAT32U r32OutM;
    7296                         pfn(&State, &fMxcsrM, &r32OutM, &TestData.i32ValIn);
    7297                         TestData.fMxcsrIn  = State.MXCSR;
     7240                        fMxcsrM = pfn(uMxCsrIn, &r32OutM, &TestData.i32ValIn);
     7241                        TestData.fMxcsrIn  = uMxCsrIn;
    72987242                        TestData.fMxcsrOut = fMxcsrM;
    72997243                        TestData.r32ValOut = r32OutM;
    73007244                        GenerateBinaryWrite(&BinOut, &TestData, sizeof(TestData));
    73017245
    7302                         State.MXCSR = State.MXCSR & ~X86_MXCSR_XCPT_MASK;
     7246                        uMxCsrIn = uMxCsrIn & ~X86_MXCSR_XCPT_MASK;
    73037247                        uint32_t fMxcsrU; RTFLOAT32U r32OutU;
    7304                         pfn(&State, &fMxcsrU, &r32OutU, &TestData.i32ValIn);
    7305                         TestData.fMxcsrIn  = State.MXCSR;
     7248                        fMxcsrU = pfn(uMxCsrIn, &r32OutU, &TestData.i32ValIn);
     7249                        TestData.fMxcsrIn  = uMxCsrIn;
    73067250                        TestData.fMxcsrOut = fMxcsrU;
    73077251                        TestData.r32ValOut = r32OutU;
    … …  
    73117255                        if (fXcpt)
    73127256                        {
    7313                             State.MXCSR = (State.MXCSR & ~X86_MXCSR_XCPT_MASK) | fXcpt;
     7257                            uMxCsrIn = (uMxCsrIn & ~X86_MXCSR_XCPT_MASK) | fXcpt;
    73147258                            uint32_t fMxcsr1; RTFLOAT32U r32Out1;
    7315                             pfn(&State, &fMxcsr1, &r32Out1, &TestData.i32ValIn);
    7316                             TestData.fMxcsrIn  = State.MXCSR;
     7259                            fMxcsr1 = pfn(uMxCsrIn, &r32Out1, &TestData.i32ValIn);
     7260                            TestData.fMxcsrIn  = uMxCsrIn;
    73177261                            TestData.fMxcsrOut = fMxcsr1;
    73187262                            TestData.r32ValOut = r32Out1;
    … …  
    73227266                            {
    73237267                                fXcpt |= fMxcsr1 & X86_MXCSR_XCPT_FLAGS;
    7324                                 State.MXCSR = (State.MXCSR & ~X86_MXCSR_XCPT_MASK) | (fXcpt << X86_MXCSR_XCPT_MASK_SHIFT);
     7268                                uMxCsrIn = (uMxCsrIn & ~X86_MXCSR_XCPT_MASK) | (fXcpt << X86_MXCSR_XCPT_MASK_SHIFT);
    73257269                                uint32_t fMxcsr2; RTFLOAT32U r32Out2;
    7326                                 pfn(&State, &fMxcsr2, &r32Out2, &TestData.i32ValIn);
    7327                                 TestData.fMxcsrIn  = State.MXCSR;
     7270                                fMxcsr2 = pfn(uMxCsrIn, &r32Out2, &TestData.i32ValIn);
     7271                                TestData.fMxcsrIn  = uMxCsrIn;
    73287272                                TestData.fMxcsrOut = fMxcsr2;
    73297273                                TestData.r32ValOut = r32Out2;
    … …  
    73347278                                    if (fUnmasked & fXcpt)
    73357279                                    {
    7336                                         State.MXCSR = (State.MXCSR & ~X86_MXCSR_XCPT_MASK) | ((fXcpt & ~fUnmasked) << X86_MXCSR_XCPT_MASK_SHIFT);
     7280                                        uMxCsrIn = (uMxCsrIn & ~X86_MXCSR_XCPT_MASK) | ((fXcpt & ~fUnmasked) << X86_MXCSR_XCPT_MASK_SHIFT);
    73377281                                        uint32_t fMxcsr3; RTFLOAT32U r32Out3;
    7338                                         pfn(&State, &fMxcsr3, &r32Out3, &TestData.i32ValIn);
    7339                                         TestData.fMxcsrIn  = State.MXCSR;
     7282                                        fMxcsr3 = pfn(uMxCsrIn, &r32Out3, &TestData.i32ValIn);
     7283                                        TestData.fMxcsrIn  = uMxCsrIn;
    73407284                                        TestData.fMxcsrOut = fMxcsr3;
    73417285                                        TestData.r32ValOut = r32Out3;
    … …  
    73557299static void SseBinaryR32I32Test(void)
    73567300{
    7357     X86FXSTATE State;
    7358     RT_ZERO(State);
    73597301    for (size_t iFn = 0; iFn < RT_ELEMENTS(g_aSseBinaryR32I32); iFn++)
    73607302    {
    … …  
    73717313            for (uint32_t iTest = 0; iTest < cTests; iTest++)
    73727314            {
    7373                 uint32_t fMxcsr = 0;
    73747315                RTFLOAT32U r32Dst; RT_ZERO(r32Dst);
    73757316
    7376                 State.MXCSR = paTests[iTest].fMxcsrIn;
    7377                 pfn(&State, &fMxcsr, &r32Dst, &paTests[iTest].i32ValIn);
     7317                uint32_t fMxcsr = pfn(paTests[iTest].fMxcsrIn, &r32Dst, &paTests[iTest].i32ValIn);
    73787318                if (   fMxcsr != paTests[iTest].fMxcsrOut
    73797319                    || !RTFLOAT32U_ARE_IDENTICAL(&r32Dst, &paTests[iTest].r32ValOut))
    … …  
    74207360    };
    74217361
    7422     X86FXSTATE State;
    7423     RT_ZERO(State);
    74247362    for (size_t iFn = 0; iFn < RT_ELEMENTS(g_aSseBinaryR32I64); iFn++)
    74257363    {
    … …  
    74407378                    for (uint8_t iFz = 0; iFz < 2; iFz++)
    74417379                    {
    7442                         State.MXCSR = (fMxcsr & ~X86_MXCSR_RC_MASK)
    7443                                     | (iRounding  << X86_MXCSR_RC_SHIFT)
    7444                                     | (iDaz ? X86_MXCSR_DAZ : 0)
    7445                                     | (iFz  ? X86_MXCSR_FZ  : 0)
    7446                                     | X86_MXCSR_XCPT_MASK;
     7380                        uint32_t uMxCsrIn = (fMxcsr & ~X86_MXCSR_RC_MASK)
     7381                                          | (iRounding  << X86_MXCSR_RC_SHIFT)
     7382                                          | (iDaz ? X86_MXCSR_DAZ : 0)
     7383                                          | (iFz  ? X86_MXCSR_FZ  : 0)
     7384                                          | X86_MXCSR_XCPT_MASK;
    74477385                        uint32_t fMxcsrM; RTFLOAT32U r32OutM;
    7448                         pfn(&State, &fMxcsrM, &r32OutM, &TestData.i64ValIn);
    7449                         TestData.fMxcsrIn  = State.MXCSR;
     7386                        fMxcsrM = pfn(uMxCsrIn, &r32OutM, &TestData.i64ValIn);
     7387                        TestData.fMxcsrIn  = uMxCsrIn;
    74507388                        TestData.fMxcsrOut = fMxcsrM;
    74517389                        TestData.r32ValOut = r32OutM;
    74527390                        GenerateBinaryWrite(&BinOut, &TestData, sizeof(TestData));
    74537391
    7454                         State.MXCSR = State.MXCSR & ~X86_MXCSR_XCPT_MASK;
     7392                        uMxCsrIn = uMxCsrIn & ~X86_MXCSR_XCPT_MASK;
    74557393                        uint32_t fMxcsrU; RTFLOAT32U r32OutU;
    7456                         pfn(&State, &fMxcsrU, &r32OutU, &TestData.i64ValIn);
    7457                         TestData.fMxcsrIn  = State.MXCSR;
     7394                        fMxcsrU = pfn(uMxCsrIn, &r32OutU, &TestData.i64ValIn);
     7395                        TestData.fMxcsrIn  = uMxCsrIn;
    74587396                        TestData.fMxcsrOut = fMxcsrU;
    74597397                        TestData.r32ValOut = r32OutU;
    … …  
    74637401                        if (fXcpt)
    74647402                        {
    7465                             State.MXCSR = (State.MXCSR & ~X86_MXCSR_XCPT_MASK) | fXcpt;
     7403                            uMxCsrIn = (uMxCsrIn & ~X86_MXCSR_XCPT_MASK) | fXcpt;
    74667404                            uint32_t fMxcsr1; RTFLOAT32U r32Out1;
    7467                             pfn(&State, &fMxcsr1, &r32Out1, &TestData.i64ValIn);
    7468                             TestData.fMxcsrIn  = State.MXCSR;
     7405                            fMxcsr1 = pfn(uMxCsrIn, &r32Out1, &TestData.i64ValIn);
     7406                            TestData.fMxcsrIn  = uMxCsrIn;
    74697407                            TestData.fMxcsrOut = fMxcsr1;
    74707408                            TestData.r32ValOut = r32Out1;
    … …  
    74747412                            {
    74757413                                fXcpt |= fMxcsr1 & X86_MXCSR_XCPT_FLAGS;
    7476                                 State.MXCSR = (State.MXCSR & ~X86_MXCSR_XCPT_MASK) | (fXcpt << X86_MXCSR_XCPT_MASK_SHIFT);
     7414                                uMxCsrIn = (uMxCsrIn & ~X86_MXCSR_XCPT_MASK) | (fXcpt << X86_MXCSR_XCPT_MASK_SHIFT);
    74777415                                uint32_t fMxcsr2; RTFLOAT32U r32Out2;
    7478                                 pfn(&State, &fMxcsr2, &r32Out2, &TestData.i64ValIn);
    7479                                 TestData.fMxcsrIn  = State.MXCSR;
     7416                                fMxcsr2 = pfn(uMxCsrIn, &r32Out2, &TestData.i64ValIn);
     7417                                TestData.fMxcsrIn  = uMxCsrIn;
    74807418                                TestData.fMxcsrOut = fMxcsr2;
    74817419                                TestData.r32ValOut = r32Out2;
    … …  
    74867424                                    if (fUnmasked & fXcpt)
    74877425                                    {
    7488                                         State.MXCSR = (State.MXCSR & ~X86_MXCSR_XCPT_MASK) | ((fXcpt & ~fUnmasked) << X86_MXCSR_XCPT_MASK_SHIFT);
     7426                                        uMxCsrIn = (uMxCsrIn & ~X86_MXCSR_XCPT_MASK) | ((fXcpt & ~fUnmasked) << X86_MXCSR_XCPT_MASK_SHIFT);
    74897427                                        uint32_t fMxcsr3; RTFLOAT32U r32Out3;
    7490                                         pfn(&State, &fMxcsr3, &r32Out3, &TestData.i64ValIn);
    7491                                         TestData.fMxcsrIn  = State.MXCSR;
     7428                                        fMxcsr3 = pfn(uMxCsrIn, &r32Out3, &TestData.i64ValIn);
     7429                                        TestData.fMxcsrIn  = uMxCsrIn;
    74927430                                        TestData.fMxcsrOut = fMxcsr3;
    74937431                                        TestData.r32ValOut = r32Out3;
    … …  
    75077445static void SseBinaryR32I64Test(void)
    75087446{
    7509     X86FXSTATE State;
    7510     RT_ZERO(State);
    75117447    for (size_t iFn = 0; iFn < RT_ELEMENTS(g_aSseBinaryR32I64); iFn++)
    75127448    {
    … …  
    75237459            for (uint32_t iTest = 0; iTest < cTests; iTest++)
    75247460            {
    7525                 uint32_t fMxcsr = 0;
    75267461                RTFLOAT32U r32Dst; RT_ZERO(r32Dst);
    75277462
    7528                 State.MXCSR = paTests[iTest].fMxcsrIn;
    7529                 pfn(&State, &fMxcsr, &r32Dst, &paTests[iTest].i64ValIn);
     7463                uint32_t fMxcsr = pfn(paTests[iTest].fMxcsrIn, &r32Dst, &paTests[iTest].i64ValIn);
    75307464                if (   fMxcsr != paTests[iTest].fMxcsrOut
    75317465                    || !RTFLOAT32U_ARE_IDENTICAL(&r32Dst, &paTests[iTest].r32ValOut))
    … …  
    76247558                        uint32_t fMxcsrM  = fMxcsrIn;
    76257559                        uint32_t fEFlagsM = fEFlags;
    7626                         pfn(&fMxcsrM, &fEFlagsM, &ValIn1, &ValIn2);
     7560                        fMxcsrM = pfn(fMxcsrIn, &fEFlagsM, &ValIn1, &ValIn2);
    76277561                        TestData.fMxcsrIn   = fMxcsrIn;
    76287562                        TestData.fMxcsrOut  = fMxcsrM;
    … …  
    76347568                        uint32_t fMxcsrU  = fMxcsrIn;
    76357569                        uint32_t fEFlagsU = fEFlags;
    7636                         pfn(&fMxcsrU, &fEFlagsU, &ValIn1, &ValIn2);
     7570                        fMxcsrU = pfn(fMxcsrIn, &fEFlagsU, &ValIn1, &ValIn2);
    76377571                        TestData.fMxcsrIn   = fMxcsrIn;
    76387572                        TestData.fMxcsrOut  = fMxcsrU;
    … …  
    76477581                            uint32_t fMxcsr1  = fMxcsrIn;
    76487582                            uint32_t fEFlags1 = fEFlags;
    7649                             pfn(&fMxcsr1, &fEFlags1, &ValIn1, &ValIn2);
     7583                            fMxcsr1 = pfn(fMxcsrIn, &fEFlags1, &ValIn1, &ValIn2);
    76507584                            TestData.fMxcsrIn   = fMxcsrIn;
    76517585                            TestData.fMxcsrOut  = fMxcsr1;
    … …  
    76607594                                uint32_t fMxcsr2  = fMxcsrIn;
    76617595                                uint32_t fEFlags2 = fEFlags;
    7662                                 pfn(&fMxcsr2, &fEFlags2, &ValIn1, &ValIn2);
     7596                                fMxcsr2 = pfn(fMxcsrIn, &fEFlags2, &ValIn1, &ValIn2);
    76637597                                TestData.fMxcsrIn   = fMxcsrIn;
    76647598                                TestData.fMxcsrOut  = fMxcsr2;
    … …  
    76747608                                        uint32_t fMxcsr3  = fMxcsrIn;
    76757609                                        uint32_t fEFlags3 = fEFlags;
    7676                                         pfn(&fMxcsr3, &fEFlags3, &ValIn1, &ValIn2);
     7610                                        fMxcsr3 = pfn(fMxcsrIn, &fEFlags3, &ValIn1, &ValIn2);
    76777611                                        TestData.fMxcsrIn   = fMxcsrIn;
    76787612                                        TestData.fMxcsrOut  = fMxcsr3;
    … …  
    77127646                ValIn1.ar32[0] = paTests[iTest].r32ValIn1;
    77137647                ValIn2.ar32[0] = paTests[iTest].r32ValIn2;
    7714                 uint32_t fMxcsr = paTests[iTest].fMxcsrIn;
    77157648                uint32_t fEFlags = paTests[iTest].fEflIn;
    7716                 pfn(&fMxcsr, &fEFlags, &ValIn1, &ValIn2);
     7649                uint32_t fMxcsr = pfn(paTests[iTest].fMxcsrIn, &fEFlags, &ValIn1, &ValIn2);
    77177650                if (   fMxcsr != paTests[iTest].fMxcsrOut
    77187651                    || fEFlags != paTests[iTest].fEflOut)
    … …  
    78107743                        uint32_t fMxcsrM  = fMxcsrIn;
    78117744                        uint32_t fEFlagsM = fEFlags;
    7812                         pfn(&fMxcsrM, &fEFlagsM, &ValIn1, &ValIn2);
     7745                        fMxcsrM = pfn(fMxcsrIn, &fEFlagsM, &ValIn1, &ValIn2);
    78137746                        TestData.fMxcsrIn   = fMxcsrIn;
    78147747                        TestData.fMxcsrOut  = fMxcsrM;
    … …  
    78207753                        uint32_t fMxcsrU  = fMxcsrIn;
    78217754                        uint32_t fEFlagsU = fEFlags;
    7822                         pfn(&fMxcsrU, &fEFlagsU, &ValIn1, &ValIn2);
     7755                        fMxcsrU = pfn(fMxcsrIn, &fEFlagsU, &ValIn1, &ValIn2);
    78237756                        TestData.fMxcsrIn   = fMxcsrIn;
    78247757                        TestData.fMxcsrOut  = fMxcsrU;
    … …  
    78337766                            uint32_t fMxcsr1  = fMxcsrIn;
    78347767                            uint32_t fEFlags1 = fEFlags;
    7835                             pfn(&fMxcsr1, &fEFlags1, &ValIn1, &ValIn2);
     7768                            fMxcsr1 = pfn(fMxcsrIn, &fEFlags1, &ValIn1, &ValIn2);
    78367769                            TestData.fMxcsrIn   = fMxcsrIn;
    78377770                            TestData.fMxcsrOut  = fMxcsr1;
    … …  
    78467779                                uint32_t fMxcsr2  = fMxcsrIn;
    78477780                                uint32_t fEFlags2 = fEFlags;
    7848                                 pfn(&fMxcsr2, &fEFlags2, &ValIn1, &ValIn2);
     7781                                fMxcsr2 = pfn(fMxcsrIn, &fEFlags2, &ValIn1, &ValIn2);
    78497782                                TestData.fMxcsrIn   = fMxcsrIn;
    78507783                                TestData.fMxcsrOut  = fMxcsr2;
    … …  
    78607793                                        uint32_t fMxcsr3  = fMxcsrIn;
    78617794                                        uint32_t fEFlags3 = fEFlags;
    7862                                         pfn(&fMxcsr3, &fEFlags3, &ValIn1, &ValIn2);
     7795                                        fMxcsr3 = pfn(fMxcsrIn, &fEFlags3, &ValIn1, &ValIn2);
    78637796                                        TestData.fMxcsrIn   = fMxcsrIn;
    78647797                                        TestData.fMxcsrOut  = fMxcsr3;
    … …  
    78987831                ValIn1.ar64[0] = paTests[iTest].r64ValIn1;
    78997832                ValIn2.ar64[0] = paTests[iTest].r64ValIn2;
    7900                 uint32_t fMxcsr = paTests[iTest].fMxcsrIn;
    79017833                uint32_t fEFlags = paTests[iTest].fEflIn;
    7902                 pfn(&fMxcsr, &fEFlags, &ValIn1, &ValIn2);
     7834                uint32_t fMxcsr = pfn(paTests[iTest].fMxcsrIn, &fEFlags, &ValIn1, &ValIn2);
    79037835                if (   fMxcsr != paTests[iTest].fMxcsrOut
    79047836                    || fEFlags != paTests[iTest].fEflOut)
    … …  
    83558287        AssertReturn(GENERATE_BINARY_OPEN(&BinOut, papszNameFmts, g_aSseConvertXmmI32R32[iFn]), RTEXITCODE_FAILURE);
    83568288
    8357         X86FXSTATE State;
    8358         RT_ZERO(State);
    83598289        for (uint32_t iTest = 0; iTest < cTests + RT_ELEMENTS(s_aSpecials); iTest += 1)
    83608290        {
    … …  
    83718301                    for (uint8_t iFz = 0; iFz < 2; iFz++)
    83728302                    {
    8373                         State.MXCSR = (fMxcsr & ~X86_MXCSR_RC_MASK)
    8374                                     | (iRounding  << X86_MXCSR_RC_SHIFT)
    8375                                     | (iDaz ? X86_MXCSR_DAZ : 0)
    8376                                     | (iFz  ? X86_MXCSR_FZ  : 0)
    8377                                     | X86_MXCSR_XCPT_MASK;
    8378                         IEMSSERESULT ResM; RT_ZERO(ResM);
    8379                         pfn(&State, &ResM, &ResM.uResult, &TestData.InVal);
    8380                         TestData.fMxcsrIn  = State.MXCSR;
    8381                         TestData.fMxcsrOut = ResM.MXCSR;
    8382                         TestData.OutVal    = ResM.uResult;
     8303                        uint32_t uMxCsrIn = (fMxcsr & ~X86_MXCSR_RC_MASK)
     8304                                          | (iRounding  << X86_MXCSR_RC_SHIFT)
     8305                                          | (iDaz ? X86_MXCSR_DAZ : 0)
     8306                                          | (iFz  ? X86_MXCSR_FZ  : 0)
     8307                                          | X86_MXCSR_XCPT_MASK;
     8308                        uint32_t uMxCsrOutM = pfn(uMxCsrIn, &TestData.OutVal, &TestData.OutVal, &TestData.InVal);
     8309                        TestData.fMxcsrIn  = uMxCsrIn;
     8310                        TestData.fMxcsrOut = uMxCsrOutM;
    83838311                        GenerateBinaryWrite(&BinOut, &TestData, sizeof(TestData));
    83848312
    8385                         State.MXCSR = State.MXCSR & ~X86_MXCSR_XCPT_MASK;
    8386                         IEMSSERESULT ResU; RT_ZERO(ResU);
    8387                         pfn(&State, &ResU, &ResU.uResult, &TestData.InVal);
    8388                         TestData.fMxcsrIn  = State.MXCSR;
    8389                         TestData.fMxcsrOut = ResU.MXCSR;
    8390                         TestData.OutVal    = ResU.uResult;
     8313                        uMxCsrIn = uMxCsrIn & ~X86_MXCSR_XCPT_MASK;
     8314                        uint32_t uMxCsrOutU = pfn(uMxCsrIn, &TestData.OutVal, &TestData.OutVal, &TestData.InVal);
     8315                        TestData.fMxcsrIn  = uMxCsrIn;
     8316                        TestData.fMxcsrOut = uMxCsrOutU;
    83918317                        GenerateBinaryWrite(&BinOut, &TestData, sizeof(TestData));
    83928318
    8393                         uint16_t fXcpt = (ResM.MXCSR | ResU.MXCSR) & X86_MXCSR_XCPT_FLAGS;
     8319                        uint16_t fXcpt = (uMxCsrOutM | uMxCsrOutU) & X86_MXCSR_XCPT_FLAGS;
    83948320                        if (fXcpt)
    83958321                        {
    8396                             State.MXCSR = (State.MXCSR & ~X86_MXCSR_XCPT_MASK) | fXcpt;
    8397                             IEMSSERESULT Res1; RT_ZERO(Res1);
    8398                             pfn(&State, &Res1, &Res1.uResult, &TestData.InVal);
    8399                             TestData.fMxcsrIn  = State.MXCSR;
    8400                             TestData.fMxcsrOut = Res1.MXCSR;
    8401                             TestData.OutVal    = Res1.uResult;
     8322                            uMxCsrIn = (uMxCsrIn & ~X86_MXCSR_XCPT_MASK) | fXcpt;
     8323                            uint32_t uMxCsrOut1 = pfn(uMxCsrIn, &TestData.OutVal, &TestData.OutVal, &TestData.InVal);
     8324                            TestData.fMxcsrIn  = uMxCsrIn;
     8325                            TestData.fMxcsrOut = uMxCsrOut1;
    84028326                            GenerateBinaryWrite(&BinOut, &TestData, sizeof(TestData));
    84038327
    8404                             if (((Res1.MXCSR & X86_MXCSR_XCPT_FLAGS) & fXcpt) != (Res1.MXCSR & X86_MXCSR_XCPT_FLAGS))
     8328                            if (((uMxCsrOut1 & X86_MXCSR_XCPT_FLAGS) & fXcpt) != (uMxCsrOut1 & X86_MXCSR_XCPT_FLAGS))
    84058329                            {
    8406                                 fXcpt |= Res1.MXCSR & X86_MXCSR_XCPT_FLAGS;
    8407                                 State.MXCSR = (State.MXCSR & ~X86_MXCSR_XCPT_MASK) | (fXcpt << X86_MXCSR_XCPT_MASK_SHIFT);
    8408                                 IEMSSERESULT Res2; RT_ZERO(Res2);
    8409                                 pfn(&State, &Res2, &Res2.uResult, &TestData.InVal);
    8410                                 TestData.fMxcsrIn  = State.MXCSR;
    8411                                 TestData.fMxcsrOut = Res2.MXCSR;
    8412                                 TestData.OutVal    = Res2.uResult;
     8330                                fXcpt |= uMxCsrOut1 & X86_MXCSR_XCPT_FLAGS;
     8331                                uMxCsrIn = (uMxCsrIn & ~X86_MXCSR_XCPT_MASK) | (fXcpt << X86_MXCSR_XCPT_MASK_SHIFT);
     8332                                uint32_t uMxCsrOut2 = pfn(uMxCsrIn, &TestData.OutVal, &TestData.OutVal, &TestData.InVal);
     8333                                TestData.fMxcsrIn  = uMxCsrIn;
     8334                                TestData.fMxcsrOut = uMxCsrOut2;
    84138335                                GenerateBinaryWrite(&BinOut, &TestData, sizeof(TestData));
    84148336                            }
    … …  
    84178339                                    if (fUnmasked & fXcpt)
    84188340                                    {
    8419                                         State.MXCSR = (State.MXCSR & ~X86_MXCSR_XCPT_MASK) | ((fXcpt & ~fUnmasked) << X86_MXCSR_XCPT_MASK_SHIFT);
    8420                                         IEMSSERESULT Res3; RT_ZERO(Res3);
    8421                                         pfn(&State, &Res3, &Res3.uResult, &TestData.InVal);
    8422                                         TestData.fMxcsrIn  = State.MXCSR;
    8423                                         TestData.fMxcsrOut = Res3.MXCSR;
    8424                                         TestData.OutVal    = Res3.uResult;
     8341                                        uMxCsrIn = (uMxCsrIn & ~X86_MXCSR_XCPT_MASK) | ((fXcpt & ~fUnmasked) << X86_MXCSR_XCPT_MASK_SHIFT);
     8342                                        uint32_t uMxCsrOut3 = pfn(uMxCsrIn, &TestData.OutVal, &TestData.OutVal, &TestData.InVal);
     8343                                        TestData.fMxcsrIn  = uMxCsrIn;
     8344                                        TestData.fMxcsrOut = uMxCsrOut3;
    84258345                                        GenerateBinaryWrite(&BinOut, &TestData, sizeof(TestData));
    84268346                                    }
    … …  
    84378357static void SseConvertXmmI32R32Test(void)
    84388358{
    8439     X86FXSTATE State;
    8440     RT_ZERO(State);
    8441 
    84428359    for (size_t iFn = 0; iFn < RT_ELEMENTS(g_aSseConvertXmmI32R32); iFn++)
    84438360    {
    … …  
    84548371            for (uint32_t iTest = 0; iTest < cTests; iTest++)
    84558372            {
    8456                 IEMSSERESULT Res; RT_ZERO(Res);
    8457 
    8458                 State.MXCSR = paTests[iTest].fMxcsrIn;
    8459                 pfn(&State, &Res, &Res.uResult, &paTests[iTest].InVal);
    8460                 if (   Res.MXCSR != paTests[iTest].fMxcsrOut
    8461                     || !RTFLOAT32U_ARE_IDENTICAL(&Res.uResult.ar32[0], &paTests[iTest].OutVal.ar32[0])
    8462                     || !RTFLOAT32U_ARE_IDENTICAL(&Res.uResult.ar32[1], &paTests[iTest].OutVal.ar32[1])
    8463                     || !RTFLOAT32U_ARE_IDENTICAL(&Res.uResult.ar32[2], &paTests[iTest].OutVal.ar32[2])
    8464                     || !RTFLOAT32U_ARE_IDENTICAL(&Res.uResult.ar32[3], &paTests[iTest].OutVal.ar32[3]))
     8373                X86XMMREG Res; RT_ZERO(Res);
     8374
     8375                uint32_t fMxCsr = pfn(paTests[iTest].fMxcsrIn, &Res, &Res, &paTests[iTest].InVal);
     8376                if (   fMxCsr != paTests[iTest].fMxcsrOut
     8377                    || !RTFLOAT32U_ARE_IDENTICAL(&Res.ar32[0], &paTests[iTest].OutVal.ar32[0])
     8378                    || !RTFLOAT32U_ARE_IDENTICAL(&Res.ar32[1], &paTests[iTest].OutVal.ar32[1])
     8379                    || !RTFLOAT32U_ARE_IDENTICAL(&Res.ar32[2], &paTests[iTest].OutVal.ar32[2])
     8380                    || !RTFLOAT32U_ARE_IDENTICAL(&Res.ar32[3], &paTests[iTest].OutVal.ar32[3]))
    84658381                    RTTestFailed(g_hTest, "#%04u%s: mxcsr=%#08x in1=%RI32'%RI32'%RI32'%RI32 \n"
    84668382                                          "%s               -> mxcsr=%#08x    %s'%s'%s'%s\n"
    … …  
    84698385                                 paTests[iTest].InVal.ai32[0], paTests[iTest].InVal.ai32[1],
    84708386                                 paTests[iTest].InVal.ai32[2], paTests[iTest].InVal.ai32[3],
    8471                                  iVar ? "  " : "", Res.MXCSR,
    8472                                  FormatR32(&Res.uResult.ar32[0]), FormatR32(&Res.uResult.ar32[1]),
    8473                                  FormatR32(&Res.uResult.ar32[2]), FormatR32(&Res.uResult.ar32[3]),
     8387                                 iVar ? "  " : "", fMxCsr,
     8388                                 FormatR32(&Res.ar32[0]), FormatR32(&Res.ar32[1]),
     8389                                 FormatR32(&Res.ar32[2]), FormatR32(&Res.ar32[3]),
    84748390                                 iVar ? "  " : "", paTests[iTest].fMxcsrOut,
    84758391                                 FormatR32(&paTests[iTest].OutVal.ar32[0]), FormatR32(&paTests[iTest].OutVal.ar32[1]),
    84768392                                 FormatR32(&paTests[iTest].OutVal.ar32[2]), FormatR32(&paTests[iTest].OutVal.ar32[3]),
    8477                                  MxcsrDiff(Res.MXCSR, paTests[iTest].fMxcsrOut),
    8478                                    (   !RTFLOAT32U_ARE_IDENTICAL(&Res.uResult.ar32[0], &paTests[iTest].OutVal.ar32[0])
    8479                                     || !RTFLOAT32U_ARE_IDENTICAL(&Res.uResult.ar32[1], &paTests[iTest].OutVal.ar32[1])
    8480                                     || !RTFLOAT32U_ARE_IDENTICAL(&Res.uResult.ar32[2], &paTests[iTest].OutVal.ar32[2])
    8481                                     || !RTFLOAT32U_ARE_IDENTICAL(&Res.uResult.ar32[3], &paTests[iTest].OutVal.ar32[3]))
     8393                                 MxcsrDiff(fMxCsr, paTests[iTest].fMxcsrOut),
     8394                                   (   !RTFLOAT32U_ARE_IDENTICAL(&Res.ar32[0], &paTests[iTest].OutVal.ar32[0])
     8395                                    || !RTFLOAT32U_ARE_IDENTICAL(&Res.ar32[1], &paTests[iTest].OutVal.ar32[1])
     8396                                    || !RTFLOAT32U_ARE_IDENTICAL(&Res.ar32[2], &paTests[iTest].OutVal.ar32[2])
     8397                                    || !RTFLOAT32U_ARE_IDENTICAL(&Res.ar32[3], &paTests[iTest].OutVal.ar32[3]))
    84828398                                 ? " - val" : "",
    84838399                                 FormatMxcsr(paTests[iTest].fMxcsrIn));
    … …  
    85148430    };
    85158431
    8516     X86FXSTATE State;
    8517     RT_ZERO(State);
    85188432    uint32_t cMinNormalPairs       = (cTests - 144) / 4;
    85198433    for (size_t iFn = 0; iFn < RT_ELEMENTS(g_aSseConvertXmmR32I32); iFn++)
    … …  
    85508464                    for (uint8_t iFz = 0; iFz < 2; iFz++)
    85518465                    {
    8552                         State.MXCSR = (fMxcsr & ~X86_MXCSR_RC_MASK)
    8553                                     | (iRounding  << X86_MXCSR_RC_SHIFT)
    8554                                     | (iDaz ? X86_MXCSR_DAZ : 0)
    8555                                     | (iFz  ? X86_MXCSR_FZ  : 0)
    8556                                     | X86_MXCSR_XCPT_MASK;
    8557                         IEMSSERESULT ResM; RT_ZERO(ResM);
    8558                         pfn(&State, &ResM, &ResM.uResult, &TestData.InVal);
    8559                         TestData.fMxcsrIn  = State.MXCSR;
    8560                         TestData.fMxcsrOut = ResM.MXCSR;
    8561                         TestData.OutVal    = ResM.uResult;
     8466                        uint32_t uMxCsrIn = (fMxcsr & ~X86_MXCSR_RC_MASK)
     8467                                          | (iRounding  << X86_MXCSR_RC_SHIFT)
     8468                                          | (iDaz ? X86_MXCSR_DAZ : 0)
     8469                                          | (iFz  ? X86_MXCSR_FZ  : 0)
     8470                                          | X86_MXCSR_XCPT_MASK;
     8471                        uint32_t uMxCsrOutM = pfn(uMxCsrIn, &TestData.OutVal, &TestData.OutVal, &TestData.InVal);
     8472                        TestData.fMxcsrIn  = uMxCsrIn;
     8473                        TestData.fMxcsrOut = uMxCsrOutM;
    85628474                        GenerateBinaryWrite(&BinOut, &TestData, sizeof(TestData));
    85638475
    8564                         State.MXCSR = State.MXCSR & ~X86_MXCSR_XCPT_MASK;
    8565                         IEMSSERESULT ResU; RT_ZERO(ResU);
    8566                         pfn(&State, &ResU, &ResU.uResult, &TestData.InVal);
    8567                         TestData.fMxcsrIn  = State.MXCSR;
    8568                         TestData.fMxcsrOut = ResU.MXCSR;
    8569                         TestData.OutVal    = ResU.uResult;
     8476                        uMxCsrIn = uMxCsrIn & ~X86_MXCSR_XCPT_MASK;
     8477                        uint32_t uMxCsrOutU = pfn(uMxCsrIn, &TestData.OutVal, &TestData.OutVal, &TestData.InVal);
     8478                        TestData.fMxcsrIn  = uMxCsrIn;
     8479                        TestData.fMxcsrOut = uMxCsrOutU;
    85708480                        GenerateBinaryWrite(&BinOut, &TestData, sizeof(TestData));
    85718481
    8572                         uint16_t fXcpt = (ResM.MXCSR | ResU.MXCSR) & X86_MXCSR_XCPT_FLAGS;
     8482                        uint16_t fXcpt = (uMxCsrOutM | uMxCsrOutU) & X86_MXCSR_XCPT_FLAGS;
    85738483                        if (fXcpt)
    85748484                        {
    8575                             State.MXCSR = (State.MXCSR & ~X86_MXCSR_XCPT_MASK) | fXcpt;
    8576                             IEMSSERESULT Res1; RT_ZERO(Res1);
    8577                             pfn(&State, &Res1, &Res1.uResult, &TestData.InVal);
    8578                             TestData.fMxcsrIn  = State.MXCSR;
    8579                             TestData.fMxcsrOut = Res1.MXCSR;
    8580                             TestData.OutVal    = Res1.uResult;
     8485                            uMxCsrIn = (uMxCsrIn & ~X86_MXCSR_XCPT_MASK) | fXcpt;
     8486                            uint32_t uMxCsrOut1 = pfn(uMxCsrIn, &TestData.OutVal, &TestData.OutVal, &TestData.InVal);
     8487                            TestData.fMxcsrIn  = uMxCsrIn;
     8488                            TestData.fMxcsrOut = uMxCsrOut1;
    85818489                            GenerateBinaryWrite(&BinOut, &TestData, sizeof(TestData));
    85828490
    8583                             if (((Res1.MXCSR & X86_MXCSR_XCPT_FLAGS) & fXcpt) != (Res1.MXCSR & X86_MXCSR_XCPT_FLAGS))
     8491                            if (((uMxCsrOut1 & X86_MXCSR_XCPT_FLAGS) & fXcpt) != (uMxCsrOut1 & X86_MXCSR_XCPT_FLAGS))
    85848492                            {
    8585                                 fXcpt |= Res1.MXCSR & X86_MXCSR_XCPT_FLAGS;
    8586                                 State.MXCSR = (State.MXCSR & ~X86_MXCSR_XCPT_MASK) | (fXcpt << X86_MXCSR_XCPT_MASK_SHIFT);
    8587                                 IEMSSERESULT Res2; RT_ZERO(Res2);
    8588                                 pfn(&State, &Res2, &Res2.uResult, &TestData.InVal);
    8589                                 TestData.fMxcsrIn  = State.MXCSR;
    8590                                 TestData.fMxcsrOut = Res2.MXCSR;
    8591                                 TestData.OutVal    = Res2.uResult;
     8493                                fXcpt |= uMxCsrOut1 & X86_MXCSR_XCPT_FLAGS;
     8494                                uMxCsrIn = (uMxCsrIn & ~X86_MXCSR_XCPT_MASK) | (fXcpt << X86_MXCSR_XCPT_MASK_SHIFT);
     8495                                uint32_t uMxCsrOut2 = pfn(uMxCsrIn, &TestData.OutVal, &TestData.OutVal, &TestData.InVal);
     8496                                TestData.fMxcsrIn  = uMxCsrIn;
     8497                                TestData.fMxcsrOut = uMxCsrOut2;
    85928498                                GenerateBinaryWrite(&BinOut, &TestData, sizeof(TestData));
    85938499                            }
    … …  
    85968502                                    if (fUnmasked & fXcpt)
    85978503                                    {
    8598                                         State.MXCSR = (State.MXCSR & ~X86_MXCSR_XCPT_MASK) | ((fXcpt & ~fUnmasked) << X86_MXCSR_XCPT_MASK_SHIFT);
    8599                                         IEMSSERESULT Res3; RT_ZERO(Res3);
    8600                                         pfn(&State, &Res3, &Res3.uResult, &TestData.InVal);
    8601                                         TestData.fMxcsrIn  = State.MXCSR;
    8602                                         TestData.fMxcsrOut = Res3.MXCSR;
    8603                                         TestData.OutVal    = Res3.uResult;
     8504                                        uMxCsrIn = (uMxCsrIn & ~X86_MXCSR_XCPT_MASK) | ((fXcpt & ~fUnmasked) << X86_MXCSR_XCPT_MASK_SHIFT);
     8505                                        uint32_t uMxCsrOut3 = pfn(uMxCsrIn, &TestData.OutVal, &TestData.OutVal, &TestData.InVal);
     8506                                        TestData.fMxcsrIn  = uMxCsrIn;
     8507                                        TestData.fMxcsrOut = uMxCsrOut3;
    86048508                                        GenerateBinaryWrite(&BinOut, &TestData, sizeof(TestData));
    86058509                                    }
    … …  
    86168520static void SseConvertXmmR32I32Test(void)
    86178521{
    8618     X86FXSTATE State;
    8619     RT_ZERO(State);
    8620 
    86218522    for (size_t iFn = 0; iFn < RT_ELEMENTS(g_aSseConvertXmmR32I32); iFn++)
    86228523    {
    … …  
    86338534            for (uint32_t iTest = 0; iTest < cTests; iTest++)
    86348535            {
    8635                 IEMSSERESULT Res; RT_ZERO(Res);
    8636 
    8637                 State.MXCSR = paTests[iTest].fMxcsrIn;
    8638                 pfn(&State, &Res, &Res.uResult, &paTests[iTest].InVal);
    8639                 if (   Res.MXCSR != paTests[iTest].fMxcsrOut
    8640                     || Res.uResult.ai32[0] != paTests[iTest].OutVal.ai32[0]
    8641                     || Res.uResult.ai32[1] != paTests[iTest].OutVal.ai32[1]
    8642                     || Res.uResult.ai32[2] != paTests[iTest].OutVal.ai32[2]
    8643                     || Res.uResult.ai32[3] != paTests[iTest].OutVal.ai32[3])
     8536                X86XMMREG Res; RT_ZERO(Res);
     8537
     8538                uint32_t fMxCsr = pfn(paTests[iTest].fMxcsrIn, &Res, &Res, &paTests[iTest].InVal);
     8539                if (   fMxCsr != paTests[iTest].fMxcsrOut
     8540                    || Res.ai32[0] != paTests[iTest].OutVal.ai32[0]
     8541                    || Res.ai32[1] != paTests[iTest].OutVal.ai32[1]
     8542                    || Res.ai32[2] != paTests[iTest].OutVal.ai32[2]
     8543                    || Res.ai32[3] != paTests[iTest].OutVal.ai32[3])
    86448544                    RTTestFailed(g_hTest, "#%04u%s: mxcsr=%#08x in1=%s'%s'%s'%s \n"
    86458545                                          "%s               -> mxcsr=%#08x    %RI32'%RI32'%RI32'%RI32\n"
    … …  
    86488548                                 FormatR32(&paTests[iTest].InVal.ar32[0]), FormatR32(&paTests[iTest].InVal.ar32[1]),
    86498549                                 FormatR32(&paTests[iTest].InVal.ar32[2]), FormatR32(&paTests[iTest].InVal.ar32[3]),
    8650                                  iVar ? "  " : "", Res.MXCSR,
    8651                                  Res.uResult.ai32[0], Res.uResult.ai32[1],
    8652                                  Res.uResult.ai32[2], Res.uResult.ai32[3],
     8550                                 iVar ? "  " : "", fMxCsr,
     8551                                 Res.ai32[0], Res.ai32[1],
     8552                                 Res.ai32[2], Res.ai32[3],
    86538553                                 iVar ? "  " : "", paTests[iTest].fMxcsrOut,
    86548554                                 paTests[iTest].OutVal.ai32[0], paTests[iTest].OutVal.ai32[1],
    86558555                                 paTests[iTest].OutVal.ai32[2], paTests[iTest].OutVal.ai32[3],
    8656                                  MxcsrDiff(Res.MXCSR, paTests[iTest].fMxcsrOut),
    8657                                    (   Res.uResult.ai32[0] != paTests[iTest].OutVal.ai32[0]
    8658                                     || Res.uResult.ai32[1] != paTests[iTest].OutVal.ai32[1]
    8659                                     || Res.uResult.ai32[2] != paTests[iTest].OutVal.ai32[2]
    8660                                     || Res.uResult.ai32[3] != paTests[iTest].OutVal.ai32[3])
     8556                                 MxcsrDiff(fMxCsr, paTests[iTest].fMxcsrOut),
     8557                                   (   Res.ai32[0] != paTests[iTest].OutVal.ai32[0]
     8558                                    || Res.ai32[1] != paTests[iTest].OutVal.ai32[1]
     8559                                    || Res.ai32[2] != paTests[iTest].OutVal.ai32[2]
     8560                                    || Res.ai32[3] != paTests[iTest].OutVal.ai32[3])
    86618561                                 ? " - val" : "",
    86628562                                 FormatMxcsr(paTests[iTest].fMxcsrIn));
    … …  
    87018601        AssertReturn(GENERATE_BINARY_OPEN(&BinOut, papszNameFmts, g_aSseConvertXmmI32R64[iFn]), RTEXITCODE_FAILURE);
    87028602
    8703         X86FXSTATE State;
    8704         RT_ZERO(State);
    87058603        for (uint32_t iTest = 0; iTest < cTests + RT_ELEMENTS(s_aSpecials); iTest += 1)
    87068604        {
    … …  
    87178615                    for (uint8_t iFz = 0; iFz < 2; iFz++)
    87188616                    {
    8719                         State.MXCSR = (fMxcsr & ~X86_MXCSR_RC_MASK)
    8720                                     | (iRounding  << X86_MXCSR_RC_SHIFT)
    8721                                     | (iDaz ? X86_MXCSR_DAZ : 0)
    8722                                     | (iFz  ? X86_MXCSR_FZ  : 0)
    8723                                     | X86_MXCSR_XCPT_MASK;
    8724                         IEMSSERESULT ResM; RT_ZERO(ResM);
    8725                         pfn(&State, &ResM, &ResM.uResult, &TestData.InVal);
    8726                         TestData.fMxcsrIn  = State.MXCSR;
    8727                         TestData.fMxcsrOut = ResM.MXCSR;
    8728                         TestData.OutVal    = ResM.uResult;
     8617                        uint32_t uMxCsrIn = (fMxcsr & ~X86_MXCSR_RC_MASK)
     8618                                          | (iRounding  << X86_MXCSR_RC_SHIFT)
     8619                                          | (iDaz ? X86_MXCSR_DAZ : 0)
     8620                                          | (iFz  ? X86_MXCSR_FZ  : 0)
     8621                                          | X86_MXCSR_XCPT_MASK;
     8622                        uint32_t uMxCsrOutM = pfn(uMxCsrIn, &TestData.OutVal, &TestData.OutVal, &TestData.InVal);
     8623                        TestData.fMxcsrIn  = uMxCsrIn;
     8624                        TestData.fMxcsrOut = uMxCsrOutM;
    87298625                        GenerateBinaryWrite(&BinOut, &TestData, sizeof(TestData));
    87308626
    8731                         State.MXCSR = State.MXCSR & ~X86_MXCSR_XCPT_MASK;
    8732                         IEMSSERESULT ResU; RT_ZERO(ResU);
    8733                         pfn(&State, &ResU, &ResU.uResult, &TestData.InVal);
    8734                         TestData.fMxcsrIn  = State.MXCSR;
    8735                         TestData.fMxcsrOut = ResU.MXCSR;
    8736                         TestData.OutVal    = ResU.uResult;
     8627                        uMxCsrIn = uMxCsrIn & ~X86_MXCSR_XCPT_MASK;
     8628                        uint32_t uMxCsrOutU = pfn(uMxCsrIn, &TestData.OutVal, &TestData.OutVal, &TestData.InVal);
     8629                        TestData.fMxcsrIn  = uMxCsrIn;
     8630                        TestData.fMxcsrOut = uMxCsrOutU;
    87378631                        GenerateBinaryWrite(&BinOut, &TestData, sizeof(TestData));
    87388632
    8739                         uint16_t fXcpt = (ResM.MXCSR | ResU.MXCSR) & X86_MXCSR_XCPT_FLAGS;
     8633                        uint16_t fXcpt = (uMxCsrOutM | uMxCsrOutU) & X86_MXCSR_XCPT_FLAGS;
    87408634                        if (fXcpt)
    87418635                        {
    8742                             State.MXCSR = (State.MXCSR & ~X86_MXCSR_XCPT_MASK) | fXcpt;
    8743                             IEMSSERESULT Res1; RT_ZERO(Res1);
    8744                             pfn(&State, &Res1, &Res1.uResult, &TestData.InVal);
    8745                             TestData.fMxcsrIn  = State.MXCSR;
    8746                             TestData.fMxcsrOut = Res1.MXCSR;
    8747                             TestData.OutVal    = Res1.uResult;
     8636                            uMxCsrIn = (uMxCsrIn & ~X86_MXCSR_XCPT_MASK) | fXcpt;
     8637                            uint32_t uMxCsrOut1 = pfn(uMxCsrIn, &TestData.OutVal, &TestData.OutVal, &TestData.InVal);
     8638                            TestData.fMxcsrIn  = uMxCsrIn;
     8639                            TestData.fMxcsrOut = uMxCsrOut1;
    87488640                            GenerateBinaryWrite(&BinOut, &TestData, sizeof(TestData));
    87498641
    8750                             if (((Res1.MXCSR & X86_MXCSR_XCPT_FLAGS) & fXcpt) != (Res1.MXCSR & X86_MXCSR_XCPT_FLAGS))
     8642                            if (((uMxCsrOut1 & X86_MXCSR_XCPT_FLAGS) & fXcpt) != (uMxCsrOut1 & X86_MXCSR_XCPT_FLAGS))
    87518643                            {
    8752                                 fXcpt |= Res1.MXCSR & X86_MXCSR_XCPT_FLAGS;
    8753                                 State.MXCSR = (State.MXCSR & ~X86_MXCSR_XCPT_MASK) | (fXcpt << X86_MXCSR_XCPT_MASK_SHIFT);
    8754                                 IEMSSERESULT Res2; RT_ZERO(Res2);
    8755                                 pfn(&State, &Res2, &Res2.uResult, &TestData.InVal);
    8756                                 TestData.fMxcsrIn  = State.MXCSR;
    8757                                 TestData.fMxcsrOut = Res2.MXCSR;
    8758                                 TestData.OutVal    = Res2.uResult;
     8644                                fXcpt |= uMxCsrOut1 & X86_MXCSR_XCPT_FLAGS;
     8645                                uMxCsrIn = (uMxCsrIn & ~X86_MXCSR_XCPT_MASK) | (fXcpt << X86_MXCSR_XCPT_MASK_SHIFT);
     8646                                uint32_t uMxCsrOut2 = pfn(uMxCsrIn, &TestData.OutVal, &TestData.OutVal, &TestData.InVal);
     8647                                TestData.fMxcsrIn  = uMxCsrIn;
     8648                                TestData.fMxcsrOut = uMxCsrOut2;
    87598649                                GenerateBinaryWrite(&BinOut, &TestData, sizeof(TestData));
    87608650                            }
    … …  
    87638653                                    if (fUnmasked & fXcpt)
    87648654                                    {
    8765                                         State.MXCSR = (State.MXCSR & ~X86_MXCSR_XCPT_MASK) | ((fXcpt & ~fUnmasked) << X86_MXCSR_XCPT_MASK_SHIFT);
    8766                                         IEMSSERESULT Res3; RT_ZERO(Res3);
    8767                                         pfn(&State, &Res3, &Res3.uResult, &TestData.InVal);
    8768                                         TestData.fMxcsrIn  = State.MXCSR;
    8769                                         TestData.fMxcsrOut = Res3.MXCSR;
    8770                                         TestData.OutVal    = Res3.uResult;
     8655                                        uMxCsrIn = (uMxCsrIn & ~X86_MXCSR_XCPT_MASK) | ((fXcpt & ~fUnmasked) << X86_MXCSR_XCPT_MASK_SHIFT);
     8656                                        uint32_t uMxCsrOut3 = pfn(uMxCsrIn, &TestData.OutVal, &TestData.OutVal, &TestData.InVal);
     8657                                        TestData.fMxcsrIn  = uMxCsrIn;
     8658                                        TestData.fMxcsrOut = uMxCsrOut3;
    87718659                                        GenerateBinaryWrite(&BinOut, &TestData, sizeof(TestData));
    87728660                                    }
    … …  
    87838671static void SseConvertXmmI32R64Test(void)
    87848672{
    8785     X86FXSTATE State;
    8786     RT_ZERO(State);
    8787 
    87888673    for (size_t iFn = 0; iFn < RT_ELEMENTS(g_aSseConvertXmmI32R64); iFn++)
    87898674    {
    … …  
    88008685            for (uint32_t iTest = 0; iTest < cTests; iTest++)
    88018686            {
    8802                 IEMSSERESULT Res; RT_ZERO(Res);
    8803 
    8804                 State.MXCSR = paTests[iTest].fMxcsrIn;
    8805                 pfn(&State, &Res, &Res.uResult, &paTests[iTest].InVal);
    8806                 if (   Res.MXCSR != paTests[iTest].fMxcsrOut
    8807                     || !RTFLOAT64U_ARE_IDENTICAL(&Res.uResult.ar64[0], &paTests[iTest].OutVal.ar64[0])
    8808                     || !RTFLOAT64U_ARE_IDENTICAL(&Res.uResult.ar64[1], &paTests[iTest].OutVal.ar64[1]))
     8687                X86XMMREG Res; RT_ZERO(Res);
     8688
     8689                uint32_t fMxCsr = pfn(paTests[iTest].fMxcsrIn, &Res, &Res, &paTests[iTest].InVal);
     8690                if (   fMxCsr != paTests[iTest].fMxcsrOut
     8691                    || !RTFLOAT64U_ARE_IDENTICAL(&Res.ar64[0], &paTests[iTest].OutVal.ar64[0])
     8692                    || !RTFLOAT64U_ARE_IDENTICAL(&Res.ar64[1], &paTests[iTest].OutVal.ar64[1]))
    88098693                    RTTestFailed(g_hTest, "#%04u%s: mxcsr=%#08x in1=%RI32'%RI32'%RI32'%RI32 \n"
    88108694                                          "%s               -> mxcsr=%#08x    %s'%s\n"
    … …  
    88138697                                 paTests[iTest].InVal.ai32[0], paTests[iTest].InVal.ai32[1],
    88148698                                 paTests[iTest].InVal.ai32[2], paTests[iTest].InVal.ai32[3],
    8815                                  iVar ? "  " : "", Res.MXCSR,
    8816                                  FormatR64(&Res.uResult.ar64[0]), FormatR64(&Res.uResult.ar64[1]),
     8699                                 iVar ? "  " : "", fMxCsr,
     8700                                 FormatR64(&Res.ar64[0]), FormatR64(&Res.ar64[1]),
    88178701                                 iVar ? "  " : "", paTests[iTest].fMxcsrOut,
    88188702                                 FormatR64(&paTests[iTest].OutVal.ar64[0]), FormatR64(&paTests[iTest].OutVal.ar64[1]),
    8819                                  MxcsrDiff(Res.MXCSR, paTests[iTest].fMxcsrOut),
    8820                                    (   !RTFLOAT64U_ARE_IDENTICAL(&Res.uResult.ar64[0], &paTests[iTest].OutVal.ar64[0])
    8821                                     || !RTFLOAT64U_ARE_IDENTICAL(&Res.uResult.ar64[1], &paTests[iTest].OutVal.ar64[1]))
     8703                                 MxcsrDiff(fMxCsr, paTests[iTest].fMxcsrOut),
     8704                                   (   !RTFLOAT64U_ARE_IDENTICAL(&Res.ar64[0], &paTests[iTest].OutVal.ar64[0])
     8705                                    || !RTFLOAT64U_ARE_IDENTICAL(&Res.ar64[1], &paTests[iTest].OutVal.ar64[1]))
    88228706                                 ? " - val" : "",
    88238707                                 FormatMxcsr(paTests[iTest].fMxcsrIn));
    … …  
    88548738    };
    88558739
    8856     X86FXSTATE State;
    8857     RT_ZERO(State);
    88588740    uint32_t cMinNormalPairs       = (cTests - 144) / 4;
    88598741    for (size_t iFn = 0; iFn < RT_ELEMENTS(g_aSseConvertXmmR64I32); iFn++)
    … …  
    88868768                    for (uint8_t iFz = 0; iFz < 2; iFz++)
    88878769                    {
    8888                         State.MXCSR = (fMxcsr & ~X86_MXCSR_RC_MASK)
    8889                                     | (iRounding  << X86_MXCSR_RC_SHIFT)
    8890                                     | (iDaz ? X86_MXCSR_DAZ : 0)
    8891                                     | (iFz  ? X86_MXCSR_FZ  : 0)
    8892                                     | X86_MXCSR_XCPT_MASK;
    8893                         IEMSSERESULT ResM; RT_ZERO(ResM);
    8894                         pfn(&State, &ResM, &ResM.uResult, &TestData.InVal);
    8895                         TestData.fMxcsrIn  = State.MXCSR;
    8896                         TestData.fMxcsrOut = ResM.MXCSR;
    8897                         TestData.OutVal    = ResM.uResult;
     8770                        uint32_t uMxCsrIn = (fMxcsr & ~X86_MXCSR_RC_MASK)
     8771                                          | (iRounding  << X86_MXCSR_RC_SHIFT)
     8772                                          | (iDaz ? X86_MXCSR_DAZ : 0)
     8773                                          | (iFz  ? X86_MXCSR_FZ  : 0)
     8774                                          | X86_MXCSR_XCPT_MASK;
     8775                        uint32_t uMxCsrOutM = pfn(uMxCsrIn, &TestData.OutVal, &TestData.OutVal, &TestData.InVal);
     8776                        TestData.fMxcsrIn  = uMxCsrIn;
     8777                        TestData.fMxcsrOut = uMxCsrOutM;
    88988778                        GenerateBinaryWrite(&BinOut, &TestData, sizeof(TestData));
    88998779
    8900                         State.MXCSR = State.MXCSR & ~X86_MXCSR_XCPT_MASK;
    8901                         IEMSSERESULT ResU; RT_ZERO(ResU);
    8902                         pfn(&State, &ResU, &ResU.uResult, &TestData.InVal);
    8903                         TestData.fMxcsrIn  = State.MXCSR;
    8904                         TestData.fMxcsrOut = ResU.MXCSR;
    8905                         TestData.OutVal    = ResU.uResult;
     8780                        uMxCsrIn = uMxCsrIn & ~X86_MXCSR_XCPT_MASK;
     8781                        uint32_t uMxCsrOutU = pfn(uMxCsrIn, &TestData.OutVal, &TestData.OutVal, &TestData.InVal);
     8782                        TestData.fMxcsrIn  = uMxCsrIn;
     8783                        TestData.fMxcsrOut = uMxCsrOutU;
    89068784                        GenerateBinaryWrite(&BinOut, &TestData, sizeof(TestData));
    89078785
    8908                         uint16_t fXcpt = (ResM.MXCSR | ResU.MXCSR) & X86_MXCSR_XCPT_FLAGS;
     8786                        uint16_t fXcpt = (uMxCsrOutM | uMxCsrOutU) & X86_MXCSR_XCPT_FLAGS;
    89098787                        if (fXcpt)
    89108788                        {
    8911                             State.MXCSR = (State.MXCSR & ~X86_MXCSR_XCPT_MASK) | fXcpt;
    8912                             IEMSSERESULT Res1; RT_ZERO(Res1);
    8913                             pfn(&State, &Res1, &Res1.uResult, &TestData.InVal);
    8914                             TestData.fMxcsrIn  = State.MXCSR;
    8915                             TestData.fMxcsrOut = Res1.MXCSR;
    8916                             TestData.OutVal    = Res1.uResult;
     8789                            uMxCsrIn = (uMxCsrIn & ~X86_MXCSR_XCPT_MASK) | fXcpt;
     8790                            uint32_t uMxCsrOut1 = pfn(uMxCsrIn, &TestData.OutVal, &TestData.OutVal, &TestData.InVal);
     8791                            TestData.fMxcsrIn  = uMxCsrIn;
     8792                            TestData.fMxcsrOut = uMxCsrOut1;
    89178793                            GenerateBinaryWrite(&BinOut, &TestData, sizeof(TestData));
    89188794
    8919                             if (((Res1.MXCSR & X86_MXCSR_XCPT_FLAGS) & fXcpt) != (Res1.MXCSR & X86_MXCSR_XCPT_FLAGS))
     8795                            if (((uMxCsrOut1 & X86_MXCSR_XCPT_FLAGS) & fXcpt) != (uMxCsrOut1 & X86_MXCSR_XCPT_FLAGS))
    89208796                            {
    8921                                 fXcpt |= Res1.MXCSR & X86_MXCSR_XCPT_FLAGS;
    8922                                 State.MXCSR = (State.MXCSR & ~X86_MXCSR_XCPT_MASK) | (fXcpt << X86_MXCSR_XCPT_MASK_SHIFT);
    8923                                 IEMSSERESULT Res2; RT_ZERO(Res2);
    8924                                 pfn(&State, &Res2, &Res2.uResult, &TestData.InVal);
    8925                                 TestData.fMxcsrIn  = State.MXCSR;
    8926                                 TestData.fMxcsrOut = Res2.MXCSR;
    8927                                 TestData.OutVal    = Res2.uResult;
     8797                                fXcpt |= uMxCsrOut1 & X86_MXCSR_XCPT_FLAGS;
     8798                                uMxCsrIn = (uMxCsrIn & ~X86_MXCSR_XCPT_MASK) | (fXcpt << X86_MXCSR_XCPT_MASK_SHIFT);
     8799                                uint32_t uMxCsrOut2 = pfn(uMxCsrIn, &TestData.OutVal, &TestData.OutVal, &TestData.InVal);
     8800                                TestData.fMxcsrIn  = uMxCsrIn;
     8801                                TestData.fMxcsrOut = uMxCsrOut2;
    89288802                                GenerateBinaryWrite(&BinOut, &TestData, sizeof(TestData));
    89298803                            }
    … …  
    89328806                                    if (fUnmasked & fXcpt)
    89338807                                    {
    8934                                         State.MXCSR = (State.MXCSR & ~X86_MXCSR_XCPT_MASK) | ((fXcpt & ~fUnmasked) << X86_MXCSR_XCPT_MASK_SHIFT);
    8935                                         IEMSSERESULT Res3; RT_ZERO(Res3);
    8936                                         pfn(&State, &Res3, &Res3.uResult, &TestData.InVal);
    8937                                         TestData.fMxcsrIn  = State.MXCSR;
    8938                                         TestData.fMxcsrOut = Res3.MXCSR;
    8939                                         TestData.OutVal    = Res3.uResult;
     8808                                        uMxCsrIn = (uMxCsrIn & ~X86_MXCSR_XCPT_MASK) | ((fXcpt & ~fUnmasked) << X86_MXCSR_XCPT_MASK_SHIFT);
     8809                                        uint32_t uMxCsrOut3 = pfn(uMxCsrIn, &TestData.OutVal, &TestData.OutVal, &TestData.InVal);
     8810                                        TestData.fMxcsrIn  = uMxCsrIn;
     8811                                        TestData.fMxcsrOut = uMxCsrOut3;
    89408812                                        GenerateBinaryWrite(&BinOut, &TestData, sizeof(TestData));
    89418813                                    }
    … …  
    89528824static void SseConvertXmmR64I32Test(void)
    89538825{
    8954     X86FXSTATE State;
    8955     RT_ZERO(State);
    8956 
    89578826    for (size_t iFn = 0; iFn < RT_ELEMENTS(g_aSseConvertXmmR64I32); iFn++)
    89588827    {
    … …  
    89698838            for (uint32_t iTest = 0; iTest < cTests; iTest++)
    89708839            {
    8971                 IEMSSERESULT Res; RT_ZERO(Res);
    8972 
    8973                 State.MXCSR = paTests[iTest].fMxcsrIn;
    8974                 pfn(&State, &Res, &Res.uResult, &paTests[iTest].InVal);
    8975                 if (   Res.MXCSR != paTests[iTest].fMxcsrOut
    8976                     || Res.uResult.ai32[0] != paTests[iTest].OutVal.ai32[0]
    8977                     || Res.uResult.ai32[1] != paTests[iTest].OutVal.ai32[1]
    8978                     || Res.uResult.ai32[2] != paTests[iTest].OutVal.ai32[2]
    8979                     || Res.uResult.ai32[3] != paTests[iTest].OutVal.ai32[3])
     8840                X86XMMREG Res; RT_ZERO(Res);
     8841
     8842                uint32_t fMxCsr = pfn(paTests[iTest].fMxcsrIn, &Res, &Res, &paTests[iTest].InVal);
     8843                if (   fMxCsr != paTests[iTest].fMxcsrOut
     8844                    || Res.ai32[0] != paTests[iTest].OutVal.ai32[0]
     8845                    || Res.ai32[1] != paTests[iTest].OutVal.ai32[1]
     8846                    || Res.ai32[2] != paTests[iTest].OutVal.ai32[2]
     8847                    || Res.ai32[3] != paTests[iTest].OutVal.ai32[3])
    89808848                    RTTestFailed(g_hTest, "#%04u%s: mxcsr=%#08x in1=%s'%s \n"
    89818849                                          "%s               -> mxcsr=%#08x    %RI32'%RI32'%RI32'%RI32\n"
    … …  
    89838851                                 iTest, iVar ? "/n" : "", paTests[iTest].fMxcsrIn,
    89848852                                 FormatR64(&paTests[iTest].InVal.ar64[0]), FormatR64(&paTests[iTest].InVal.ar64[1]),
    8985                                  iVar ? "  " : "", Res.MXCSR,
    8986                                  Res.uResult.ai32[0], Res.uResult.ai32[1],
    8987                                  Res.uResult.ai32[2], Res.uResult.ai32[3],
     8853                                 iVar ? "  " : "", fMxCsr,
     8854                                 Res.ai32[0], Res.ai32[1],
     8855                                 Res.ai32[2], Res.ai32[3],
    89888856                                 iVar ? "  " : "", paTests[iTest].fMxcsrOut,
    89898857                                 paTests[iTest].OutVal.ai32[0], paTests[iTest].OutVal.ai32[1],
    89908858                                 paTests[iTest].OutVal.ai32[2], paTests[iTest].OutVal.ai32[3],
    8991                                  MxcsrDiff(Res.MXCSR, paTests[iTest].fMxcsrOut),
    8992                                    (   Res.uResult.ai32[0] != paTests[iTest].OutVal.ai32[0]
    8993                                     || Res.uResult.ai32[1] != paTests[iTest].OutVal.ai32[1]
    8994                                     || Res.uResult.ai32[2] != paTests[iTest].OutVal.ai32[2]
    8995                                     || Res.uResult.ai32[3] != paTests[iTest].OutVal.ai32[3])
     8859                                 MxcsrDiff(fMxCsr, paTests[iTest].fMxcsrOut),
     8860                                   (   Res.ai32[0] != paTests[iTest].OutVal.ai32[0]
     8861                                    || Res.ai32[1] != paTests[iTest].OutVal.ai32[1]
     8862                                    || Res.ai32[2] != paTests[iTest].OutVal.ai32[2]
     8863                                    || Res.ai32[3] != paTests[iTest].OutVal.ai32[3])
    89968864                                 ? " - val" : "",
    89978865                                 FormatMxcsr(paTests[iTest].fMxcsrIn));
    … …  
    91318999static void SseConvertMmXmmTest(void)
    91329000{
    9133     X86FXSTATE State;
    9134     RT_ZERO(State);
    9135 
    91369001    for (size_t iFn = 0; iFn < RT_ELEMENTS(g_aSseConvertMmXmm); iFn++)
    91379002    {
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