VirtualBox

Changeset 96379 in vbox


Ignore:
Timestamp:
Aug 20, 2022 7:23:07 PM (2 years ago)
Author:
vboxsync
Message:

VMM/IEM: Implement cvtss2sd/cvtsd2ss instructions + some streamlinging of the instruction helpers and fixes, bugref:9898

Location:
trunk/src/VBox/VMM
Files:
5 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/VMM/VMMAll/IEMAllAImpl.asm

    r96351 r96379  
    46474647IEMIMPL_FP_F2_R32 divss
    46484648IEMIMPL_FP_F2_R32 maxss
     4649IEMIMPL_FP_F2_R32 cvtss2sd
    46494650
    46504651
    … …  
    46974698IEMIMPL_FP_F2_R64 divsd
    46984699IEMIMPL_FP_F2_R64 maxsd
     4700IEMIMPL_FP_F2_R64 cvtsd2ss

  • trunk/src/VBox/VMM/VMMAll/IEMAllAImplC.cpp

    r96351 r96379  
    1387613876 * @param   pr32Result      Where to store the result for IEM.
    1387713877 * @param   fMxcsr          The original MXCSR value.
    13878  * @param   pr32Src1        The first source operand (for setting \#DE under certain circumstances).
    13879  * @param   pr32Src2        The second source operand (for setting \#DE under certain circumstances).
    1388013878 */
    1388113879DECLINLINE(uint32_t) iemSseSoftStateAndR32ToMxcsrAndIprtResult(softfloat_state_t const *pSoftState, float32_t r32Result,
    13882                                                                PRTFLOAT32U pr32Result, uint32_t fMxcsr,
    13883                                                                PCRTFLOAT32U pr32Src1, PCRTFLOAT32U pr32Src2)
     13880                                                               PRTFLOAT32U pr32Result, uint32_t fMxcsr)
    1388413881{
    1388513882    iemFpSoftF32ToIprt(pr32Result, r32Result);
    … …  
    1390013897            && (RTFLOAT32U_IS_SUBNORMAL(pr32Result))))
    1390113898        fXcpt &= ~X86_MXCSR_DE;
    13902     else /* Need to set \#DE when one of the source operands is a De-normal. */
    13903         fXcpt |=   (   RTFLOAT32U_IS_SUBNORMAL(pr32Src1)
    13904                     || RTFLOAT32U_IS_SUBNORMAL(pr32Src2))
    13905                  ? X86_MXCSR_DE
    13906                  : 0;
    1390713899
    1390813900    return fMxcsr | (fXcpt & X86_MXCSR_XCPT_FLAGS);
    … …  
    1391913911 * @param   pr32Result      Where to store the result for IEM.
    1392013912 * @param   fMxcsr          The original MXCSR value.
    13921  * @param   pr32Src1        The first source operand (for setting \#DE under certain circumstances).
    13922  * @param   pr32Src2        The second source operand (for setting \#DE under certain circumstances).
    1392313913 */
    1392413914DECLINLINE(uint32_t) iemSseSoftStateAndR32ToMxcsrAndIprtResultNoFz(softfloat_state_t const *pSoftState, float32_t r32Result,
    13925                                                                    PRTFLOAT32U pr32Result, uint32_t fMxcsr,
    13926                                                                    PCRTFLOAT32U pr32Src1, PCRTFLOAT32U pr32Src2)
     13915                                                                   PRTFLOAT32U pr32Result, uint32_t fMxcsr)
    1392713916{
    1392813917    iemFpSoftF32ToIprt(pr32Result, r32Result);
    … …  
    1393413923            && (RTFLOAT32U_IS_SUBNORMAL(pr32Result))))
    1393513924        fXcpt &= ~X86_MXCSR_DE;
    13936     else /* Need to set \#DE when one of the source operands is a De-normal. */
    13937         fXcpt |=   (   RTFLOAT32U_IS_SUBNORMAL(pr32Src1)
    13938                     || RTFLOAT32U_IS_SUBNORMAL(pr32Src2))
    13939                  ? X86_MXCSR_DE
    13940                  : 0;
    1394113925
    1394213926    return fMxcsr | (fXcpt & X86_MXCSR_XCPT_FLAGS);
    … …  
    1395313937 * @param   pr64Result      Where to store the result for IEM.
    1395413938 * @param   fMxcsr          The original MXCSR value.
    13955  * @param   pr64Src1        The first source operand (for setting \#DE under certain circumstances).
    13956  * @param   pr64Src2        The second source operand (for setting \#DE under certain circumstances).
    1395713939 */
    1395813940DECLINLINE(uint32_t) iemSseSoftStateAndR64ToMxcsrAndIprtResult(softfloat_state_t const *pSoftState, float64_t r64Result,
    13959                                                                PRTFLOAT64U pr64Result, uint32_t fMxcsr,
    13960                                                                PCRTFLOAT64U pr64Src1, PCRTFLOAT64U pr64Src2)
     13941                                                               PRTFLOAT64U pr64Result, uint32_t fMxcsr)
    1396113942{
    1396213943    iemFpSoftF64ToIprt(pr64Result, r64Result);
    … …  
    1397813959            && (RTFLOAT64U_IS_SUBNORMAL(pr64Result))))
    1397913960        fXcpt &= ~X86_MXCSR_DE;
    13980     else /* Need to set \#DE when one of the source operands is a De-normal. */
    13981         fXcpt |=   (   RTFLOAT64U_IS_SUBNORMAL(pr64Src1)
    13982                     || RTFLOAT64U_IS_SUBNORMAL(pr64Src2))
    13983                  ? X86_MXCSR_DE
    13984                  : 0;
    1398513961
    1398613962    return fMxcsr | (fXcpt & X86_MXCSR_XCPT_FLAGS);
    … …  
    1399713973 * @param   pr64Result      Where to store the result for IEM.
    1399813974 * @param   fMxcsr          The original MXCSR value.
    13999  * @param   pr64Src1        The first source operand (for setting \#DE under certain circumstances).
    14000  * @param   pr64Src2        The second source operand (for setting \#DE under certain circumstances).
    1400113975 */
    1400213976DECLINLINE(uint32_t) iemSseSoftStateAndR64ToMxcsrAndIprtResultNoFz(softfloat_state_t const *pSoftState, float64_t r64Result,
    14003                                                                    PRTFLOAT64U pr64Result, uint32_t fMxcsr,
    14004                                                                    PCRTFLOAT64U pr64Src1, PCRTFLOAT64U pr64Src2)
     13977                                                                   PRTFLOAT64U pr64Result, uint32_t fMxcsr)
    1400513978{
    1400613979    iemFpSoftF64ToIprt(pr64Result, r64Result);
    … …  
    1401213985            && (RTFLOAT64U_IS_SUBNORMAL(pr64Result))))
    1401313986        fXcpt &= ~X86_MXCSR_DE;
    14014     else /* Need to set \#DE when one of the source operands is a De-normal. */
    14015         fXcpt |=   (   RTFLOAT64U_IS_SUBNORMAL(pr64Src1)
    14016                     || RTFLOAT64U_IS_SUBNORMAL(pr64Src2))
    14017                  ? X86_MXCSR_DE
    14018                  : 0;
    1401913987
    1402013988    return fMxcsr | (fXcpt & X86_MXCSR_XCPT_FLAGS);
    … …  
    1402613994 * in MXCSR into account.
    1402713995 *
    14028  * @returns nothing.
     13996 * @returns The output MXCSR De-normal flag if the input is a de-normal and the DAZ flag is not set.
    1402913997 * @param   pr32Val         Where to store the result.
    1403013998 * @param   fMxcsr          The input MXCSR value.
    1403113999 * @param   pr32Src         The value to use.
    1403214000 */
    14033 DECLINLINE(void) iemSsePrepareValueR32(PRTFLOAT32U pr32Val, uint32_t fMxcsr, PCRTFLOAT32U pr32Src)
    14034 {
    14035     /* De-normals are changed to 0. */
    14036     if (   fMxcsr & X86_MXCSR_DAZ
    14037         && RTFLOAT32U_IS_SUBNORMAL(pr32Src))
    14038     {
    14039         pr32Val->s.fSign     = pr32Src->s.fSign;
    14040         pr32Val->s.uFraction = 0;
    14041         pr32Val->s.uExponent = 0;
    14042     }
    14043     else
     14001DECLINLINE(uint32_t) iemSsePrepareValueR32(PRTFLOAT32U pr32Val, uint32_t fMxcsr, PCRTFLOAT32U pr32Src)
     14002{
     14003    if (RTFLOAT32U_IS_SUBNORMAL(pr32Src))
     14004    {
     14005        if (fMxcsr & X86_MXCSR_DAZ)
     14006        {
     14007            /* De-normals are changed to 0. */
     14008            pr32Val->s.fSign     = pr32Src->s.fSign;
     14009            pr32Val->s.uFraction = 0;
     14010            pr32Val->s.uExponent = 0;
     14011            return 0;
     14012        }
     14013
    1404414014        *pr32Val = *pr32Src;
     14015        return X86_MXCSR_DE;
     14016    }
     14017
     14018    *pr32Val = *pr32Src;
     14019    return 0;
    1404514020}
    1404614021
    … …  
    1405014025 * in MXCSR into account.
    1405114026 *
    14052  * @returns nothing.
     14027 * @returns The output MXCSR De-normal flag if the input is a de-normal and the DAZ flag is not set.
    1405314028 * @param   pr64Val         Where to store the result.
    1405414029 * @param   fMxcsr          The input MXCSR value.
    1405514030 * @param   pr64Src         The value to use.
    1405614031 */
    14057 DECLINLINE(void) iemSsePrepareValueR64(PRTFLOAT64U pr64Val, uint32_t fMxcsr, PCRTFLOAT64U pr64Src)
    14058 {
    14059     /* De-normals are changed to 0. */
    14060     if (   fMxcsr & X86_MXCSR_DAZ
    14061         && RTFLOAT64U_IS_SUBNORMAL(pr64Src))
    14062     {
    14063         pr64Val->s64.fSign     = pr64Src->s.fSign;
    14064         pr64Val->s64.uFraction = 0;
    14065         pr64Val->s64.uExponent = 0;
    14066     }
    14067     else
     14032DECLINLINE(uint32_t) iemSsePrepareValueR64(PRTFLOAT64U pr64Val, uint32_t fMxcsr, PCRTFLOAT64U pr64Src)
     14033{
     14034    if (RTFLOAT64U_IS_SUBNORMAL(pr64Src))
     14035    {
     14036        if (fMxcsr & X86_MXCSR_DAZ)
     14037        {
     14038            /* De-normals are changed to 0. */
     14039            pr64Val->s64.fSign     = pr64Src->s.fSign;
     14040            pr64Val->s64.uFraction = 0;
     14041            pr64Val->s64.uExponent = 0;
     14042            return 0;
     14043        }
     14044
    1406814045        *pr64Val = *pr64Src;
     14046        return X86_MXCSR_DE;
     14047    }
     14048
     14049    *pr64Val = *pr64Src;
     14050    return 0;
    1406914051}
    1407014052
    … …  
    1416514147
    1416614148    RTFLOAT32U r32Src1, r32Src2;
    14167     iemSsePrepareValueR32(&r32Src1, fMxcsr, pr32Val1);
    14168     iemSsePrepareValueR32(&r32Src2, fMxcsr, pr32Val2);
     14149    fMxcsr |= iemSsePrepareValueR32(&r32Src1, fMxcsr, pr32Val1);
     14150    fMxcsr |= iemSsePrepareValueR32(&r32Src2, fMxcsr, pr32Val2);
    1416914151    softfloat_state_t SoftState = IEM_SOFTFLOAT_STATE_INITIALIZER_FROM_MXCSR(fMxcsr);
    1417014152    float32_t r32Result = f32_add(iemFpSoftF32FromIprt(&r32Src1), iemFpSoftF32FromIprt(&r32Src2), &SoftState);
    14171     return iemSseSoftStateAndR32ToMxcsrAndIprtResult(&SoftState, r32Result, pr32Res, fMxcsr, &r32Src1, &r32Src2);
     14153    return iemSseSoftStateAndR32ToMxcsrAndIprtResult(&SoftState, r32Result, pr32Res, fMxcsr);
    1417214154}
    1417314155
    … …  
    1420714189
    1420814190    RTFLOAT64U r64Src1, r64Src2;
    14209     iemSsePrepareValueR64(&r64Src1, fMxcsr, pr64Val1);
    14210     iemSsePrepareValueR64(&r64Src2, fMxcsr, pr64Val2);
     14191    fMxcsr |= iemSsePrepareValueR64(&r64Src1, fMxcsr, pr64Val1);
     14192    fMxcsr |= iemSsePrepareValueR64(&r64Src2, fMxcsr, pr64Val2);
    1421114193    softfloat_state_t SoftState = IEM_SOFTFLOAT_STATE_INITIALIZER_FROM_MXCSR(fMxcsr);
    1421214194    float64_t r64Result = f64_add(iemFpSoftF64FromIprt(&r64Src1), iemFpSoftF64FromIprt(&r64Src2), &SoftState);
    14213     return iemSseSoftStateAndR64ToMxcsrAndIprtResult(&SoftState, r64Result, pr64Res, fMxcsr, &r64Src1, &r64Src2);
     14195    return iemSseSoftStateAndR64ToMxcsrAndIprtResult(&SoftState, r64Result, pr64Res, fMxcsr);
    1421414196}
    1421514197
    … …  
    1424514227
    1424614228    RTFLOAT32U r32Src1, r32Src2;
    14247     iemSsePrepareValueR32(&r32Src1, fMxcsr, pr32Val1);
    14248     iemSsePrepareValueR32(&r32Src2, fMxcsr, pr32Val2);
     14229    fMxcsr |= iemSsePrepareValueR32(&r32Src1, fMxcsr, pr32Val1);
     14230    fMxcsr |= iemSsePrepareValueR32(&r32Src2, fMxcsr, pr32Val2);
    1424914231    softfloat_state_t SoftState = IEM_SOFTFLOAT_STATE_INITIALIZER_FROM_MXCSR(fMxcsr);
    1425014232    float32_t r32Result = f32_mul(iemFpSoftF32FromIprt(&r32Src1), iemFpSoftF32FromIprt(&r32Src2), &SoftState);
    14251     return iemSseSoftStateAndR32ToMxcsrAndIprtResult(&SoftState, r32Result, pr32Res, fMxcsr, &r32Src1, &r32Src2);
     14233    return iemSseSoftStateAndR32ToMxcsrAndIprtResult(&SoftState, r32Result, pr32Res, fMxcsr);
    1425214234}
    1425314235
    … …  
    1428714269
    1428814270    RTFLOAT64U r64Src1, r64Src2;
    14289     iemSsePrepareValueR64(&r64Src1, fMxcsr, pr64Val1);
    14290     iemSsePrepareValueR64(&r64Src2, fMxcsr, pr64Val2);
     14271    fMxcsr |= iemSsePrepareValueR64(&r64Src1, fMxcsr, pr64Val1);
     14272    fMxcsr |= iemSsePrepareValueR64(&r64Src2, fMxcsr, pr64Val2);
    1429114273    softfloat_state_t SoftState = IEM_SOFTFLOAT_STATE_INITIALIZER_FROM_MXCSR(fMxcsr);
    1429214274    float64_t r64Result = f64_mul(iemFpSoftF64FromIprt(&r64Src1), iemFpSoftF64FromIprt(&r64Src2), &SoftState);
    14293     return iemSseSoftStateAndR64ToMxcsrAndIprtResult(&SoftState, r64Result, pr64Res, fMxcsr, &r64Src1, &r64Src2);
     14275    return iemSseSoftStateAndR64ToMxcsrAndIprtResult(&SoftState, r64Result, pr64Res, fMxcsr);
    1429414276}
    1429514277
    … …  
    1432514307
    1432614308    RTFLOAT32U r32Src1, r32Src2;
    14327     iemSsePrepareValueR32(&r32Src1, fMxcsr, pr32Val1);
    14328     iemSsePrepareValueR32(&r32Src2, fMxcsr, pr32Val2);
     14309    fMxcsr |= iemSsePrepareValueR32(&r32Src1, fMxcsr, pr32Val1);
     14310    fMxcsr |= iemSsePrepareValueR32(&r32Src2, fMxcsr, pr32Val2);
    1432914311    softfloat_state_t SoftState = IEM_SOFTFLOAT_STATE_INITIALIZER_FROM_MXCSR(fMxcsr);
    1433014312    float32_t r32Result = f32_sub(iemFpSoftF32FromIprt(&r32Src1), iemFpSoftF32FromIprt(&r32Src2), &SoftState);
    14331     return iemSseSoftStateAndR32ToMxcsrAndIprtResult(&SoftState, r32Result, pr32Res, fMxcsr, &r32Src1, &r32Src2);
     14313    return iemSseSoftStateAndR32ToMxcsrAndIprtResult(&SoftState, r32Result, pr32Res, fMxcsr);
    1433214314}
    1433314315
    … …  
    1436714349
    1436814350    RTFLOAT64U r64Src1, r64Src2;
    14369     iemSsePrepareValueR64(&r64Src1, fMxcsr, pr64Val1);
    14370     iemSsePrepareValueR64(&r64Src2, fMxcsr, pr64Val2);
     14351    fMxcsr |= iemSsePrepareValueR64(&r64Src1, fMxcsr, pr64Val1);
     14352    fMxcsr |= iemSsePrepareValueR64(&r64Src2, fMxcsr, pr64Val2);
    1437114353    softfloat_state_t SoftState = IEM_SOFTFLOAT_STATE_INITIALIZER_FROM_MXCSR(fMxcsr);
    1437214354    float64_t r64Result = f64_sub(iemFpSoftF64FromIprt(&r64Src1), iemFpSoftF64FromIprt(&r64Src2), &SoftState);
    14373     return iemSseSoftStateAndR64ToMxcsrAndIprtResult(&SoftState, r64Result, pr64Res, fMxcsr, &r64Src1, &r64Src2);
     14355    return iemSseSoftStateAndR64ToMxcsrAndIprtResult(&SoftState, r64Result, pr64Res, fMxcsr);
    1437414356}
    1437514357
    … …  
    1440114383static uint32_t iemAImpl_minps_u128_worker(PRTFLOAT32U pr32Res, uint32_t fMxcsr, PCRTFLOAT32U pr32Val1, PCRTFLOAT32U pr32Val2)
    1440214384{
     14385    if (RTFLOAT32U_IS_NAN(pr32Val1) || RTFLOAT32U_IS_NAN(pr32Val2))
     14386    {
     14387        /* The DAZ flag gets honored but the DE flag will not get set because \#IE has higher priority. */
     14388        iemSsePrepareValueR32(pr32Res, fMxcsr, pr32Val2);
     14389        return fMxcsr | X86_MXCSR_IE;
     14390    }
     14391
    1440314392    RTFLOAT32U r32Src1, r32Src2;
    14404     iemSsePrepareValueR32(&r32Src1, fMxcsr, pr32Val1);
    14405     iemSsePrepareValueR32(&r32Src2, fMxcsr, pr32Val2);
    14406 
     14393    fMxcsr |= iemSsePrepareValueR32(&r32Src1, fMxcsr, pr32Val1);
     14394    fMxcsr |= iemSsePrepareValueR32(&r32Src2, fMxcsr, pr32Val2);
    1440714395    if (RTFLOAT32U_IS_ZERO(&r32Src1) && RTFLOAT32U_IS_ZERO(&r32Src2))
    1440814396    {
    1440914397        *pr32Res = r32Src2;
    1441014398        return fMxcsr;
    14411     }
    14412     else if (RTFLOAT32U_IS_NAN(&r32Src1) || RTFLOAT32U_IS_NAN(&r32Src2))
    14413     {
    14414         *pr32Res = r32Src2;
    14415         return fMxcsr | X86_MXCSR_IE;
    1441614399    }
    1441714400
    … …  
    1442214405                                                         ? iemFpSoftF32FromIprt(&r32Src1)
    1442314406                                                         : iemFpSoftF32FromIprt(&r32Src2),
    14424                                                          pr32Res, fMxcsr, &r32Src1, &r32Src2);
     14407                                                         pr32Res, fMxcsr);
    1442514408}
    1442614409
    … …  
    1445614439static uint32_t iemAImpl_minpd_u128_worker(PRTFLOAT64U pr64Res, uint32_t fMxcsr, PCRTFLOAT64U pr64Val1, PCRTFLOAT64U pr64Val2)
    1445714440{
     14441    if (RTFLOAT64U_IS_NAN(pr64Val1) || RTFLOAT64U_IS_NAN(pr64Val2))
     14442    {
     14443        /* The DAZ flag gets honored but the DE flag will not get set because \#IE has higher priority. */
     14444        iemSsePrepareValueR64(pr64Res, fMxcsr, pr64Val2);
     14445        return fMxcsr | X86_MXCSR_IE;
     14446    }
     14447
    1445814448    RTFLOAT64U r64Src1, r64Src2;
    14459     iemSsePrepareValueR64(&r64Src1, fMxcsr, pr64Val1);
    14460     iemSsePrepareValueR64(&r64Src2, fMxcsr, pr64Val2);
    14461 
     14449    fMxcsr |= iemSsePrepareValueR64(&r64Src1, fMxcsr, pr64Val1);
     14450    fMxcsr |= iemSsePrepareValueR64(&r64Src2, fMxcsr, pr64Val2);
    1446214451    if (RTFLOAT64U_IS_ZERO(&r64Src1) && RTFLOAT64U_IS_ZERO(&r64Src2))
    1446314452    {
    1446414453        *pr64Res = r64Src2;
    1446514454        return fMxcsr;
    14466     }
    14467     else if (RTFLOAT64U_IS_NAN(&r64Src1) || RTFLOAT64U_IS_NAN(&r64Src2))
    14468     {
    14469         *pr64Res = r64Src2;
    14470         return fMxcsr | X86_MXCSR_IE;
    1447114455    }
    1447214456
    … …  
    1447714461                                                         ? iemFpSoftF64FromIprt(&r64Src1)
    1447814462                                                         : iemFpSoftF64FromIprt(&r64Src2),
    14479                                                          pr64Res, fMxcsr, &r64Src1, &r64Src2);
     14463                                                         pr64Res, fMxcsr);
    1448014464}
    1448114465
    … …  
    1451114495
    1451214496    RTFLOAT32U r32Src1, r32Src2;
    14513     iemSsePrepareValueR32(&r32Src1, fMxcsr, pr32Val1);
    14514     iemSsePrepareValueR32(&r32Src2, fMxcsr, pr32Val2);
    14515 
     14497    uint32_t fDe  = iemSsePrepareValueR32(&r32Src1, fMxcsr, pr32Val1);
     14498             fDe |= iemSsePrepareValueR32(&r32Src2, fMxcsr, pr32Val2);
    1451614499    if (RTFLOAT32U_IS_ZERO(&r32Src2))
    1451714500    {
    … …  
    1453614519    softfloat_state_t SoftState = IEM_SOFTFLOAT_STATE_INITIALIZER_FROM_MXCSR(fMxcsr);
    1453714520    float32_t r32Result = f32_div(iemFpSoftF32FromIprt(&r32Src1), iemFpSoftF32FromIprt(&r32Src2), &SoftState);
    14538     return iemSseSoftStateAndR32ToMxcsrAndIprtResult(&SoftState, r32Result, pr32Res, fMxcsr, &r32Src1, &r32Src2);
     14521    return iemSseSoftStateAndR32ToMxcsrAndIprtResult(&SoftState, r32Result, pr32Res, fMxcsr | fDe);
    1453914522}
    1454014523
    … …  
    1457414557
    1457514558    RTFLOAT64U r64Src1, r64Src2;
    14576     iemSsePrepareValueR64(&r64Src1, fMxcsr, pr64Val1);
    14577     iemSsePrepareValueR64(&r64Src2, fMxcsr, pr64Val2);
    14578 
     14559    uint32_t fDe  = iemSsePrepareValueR64(&r64Src1, fMxcsr, pr64Val1);
     14560             fDe |= iemSsePrepareValueR64(&r64Src2, fMxcsr, pr64Val2);
    1457914561    if (RTFLOAT64U_IS_ZERO(&r64Src2))
    1458014562    {
    … …  
    1459914581    softfloat_state_t SoftState = IEM_SOFTFLOAT_STATE_INITIALIZER_FROM_MXCSR(fMxcsr);
    1460014582    float64_t r64Result = f64_div(iemFpSoftF64FromIprt(&r64Src1), iemFpSoftF64FromIprt(&r64Src2), &SoftState);
    14601     return iemSseSoftStateAndR64ToMxcsrAndIprtResult(&SoftState, r64Result, pr64Res, fMxcsr, &r64Src1, &r64Src2);
     14583    return iemSseSoftStateAndR64ToMxcsrAndIprtResult(&SoftState, r64Result, pr64Res, fMxcsr | fDe);
    1460214584}
    1460314585
    … …  
    1462914611static uint32_t iemAImpl_maxps_u128_worker(PRTFLOAT32U pr32Res, uint32_t fMxcsr, PCRTFLOAT32U pr32Val1, PCRTFLOAT32U pr32Val2)
    1463014612{
     14613    if (RTFLOAT32U_IS_NAN(pr32Val1) || RTFLOAT32U_IS_NAN(pr32Val2))
     14614    {
     14615        /* The DAZ flag gets honored but the DE flag will not get set because \#IE has higher priority. */
     14616        iemSsePrepareValueR32(pr32Res, fMxcsr, pr32Val2);
     14617        return fMxcsr | X86_MXCSR_IE;
     14618    }
     14619
    1463114620    RTFLOAT32U r32Src1, r32Src2;
    14632     iemSsePrepareValueR32(&r32Src1, fMxcsr, pr32Val1);
    14633     iemSsePrepareValueR32(&r32Src2, fMxcsr, pr32Val2);
    14634 
     14621    fMxcsr |= iemSsePrepareValueR32(&r32Src1, fMxcsr, pr32Val1);
     14622    fMxcsr |= iemSsePrepareValueR32(&r32Src2, fMxcsr, pr32Val2);
    1463514623    if (RTFLOAT32U_IS_ZERO(&r32Src1) && RTFLOAT32U_IS_ZERO(&r32Src2))
    1463614624    {
    1463714625        *pr32Res = r32Src2;
    1463814626        return fMxcsr;
    14639     }
    14640     else if (RTFLOAT32U_IS_NAN(&r32Src1) || RTFLOAT32U_IS_NAN(&r32Src2))
    14641     {
    14642         *pr32Res = r32Src2;
    14643         return fMxcsr | X86_MXCSR_IE;
    1464414627    }
    1464514628
    … …  
    1465014633                                                         ? iemFpSoftF32FromIprt(&r32Src2)
    1465114634                                                         : iemFpSoftF32FromIprt(&r32Src1),
    14652                                                          pr32Res, fMxcsr, &r32Src1, &r32Src2);
     14635                                                         pr32Res, fMxcsr);
    1465314636}
    1465414637
    … …  
    1468414667static uint32_t iemAImpl_maxpd_u128_worker(PRTFLOAT64U pr64Res, uint32_t fMxcsr, PCRTFLOAT64U pr64Val1, PCRTFLOAT64U pr64Val2)
    1468514668{
     14669    if (RTFLOAT64U_IS_NAN(pr64Val1) || RTFLOAT64U_IS_NAN(pr64Val2))
     14670    {
     14671        /* The DAZ flag gets honored but the DE flag will not get set because \#IE has higher priority. */
     14672        iemSsePrepareValueR64(pr64Res, fMxcsr, pr64Val2);
     14673        return fMxcsr | X86_MXCSR_IE;
     14674    }
     14675
    1468614676    RTFLOAT64U r64Src1, r64Src2;
    14687     iemSsePrepareValueR64(&r64Src1, fMxcsr, pr64Val1);
    14688     iemSsePrepareValueR64(&r64Src2, fMxcsr, pr64Val2);
    14689 
     14677    fMxcsr |= iemSsePrepareValueR64(&r64Src1, fMxcsr, pr64Val1);
     14678    fMxcsr |= iemSsePrepareValueR64(&r64Src2, fMxcsr, pr64Val2);
    1469014679    if (RTFLOAT64U_IS_ZERO(&r64Src1) && RTFLOAT64U_IS_ZERO(&r64Src2))
    1469114680    {
    1469214681        *pr64Res = r64Src2;
    1469314682        return fMxcsr;
    14694     }
    14695     else if (RTFLOAT64U_IS_NAN(&r64Src1) || RTFLOAT64U_IS_NAN(&r64Src2))
    14696     {
    14697         *pr64Res = r64Src2;
    14698         return fMxcsr | X86_MXCSR_IE;
    1469914683    }
    1470014684
    … …  
    1470514689                                                         ? iemFpSoftF64FromIprt(&r64Src2)
    1470614690                                                         : iemFpSoftF64FromIprt(&r64Src1),
    14707                                                          pr64Res, fMxcsr, &r64Src1, &r64Src2);
     14691                                                         pr64Res, fMxcsr);
    1470814692}
    1470914693
    … …  
    1471614700#endif
    1471714701
     14702
    1471814703/**
    1471914704 * MAXSD
    … …  
    1472614711}
    1472714712#endif
     14713
     14714
     14715/**
     14716 * CVTSS2SD
     14717 */
     14718#ifdef IEM_WITHOUT_ASSEMBLY
     14719static uint32_t iemAImpl_cvtss2sd_u128_r32_worker(PRTFLOAT64U pr64Res, uint32_t fMxcsr, PCRTFLOAT32U pr32Val1)
     14720{
     14721    RTFLOAT32U r32Src1;
     14722    fMxcsr |= iemSsePrepareValueR32(&r32Src1, fMxcsr, pr32Val1);
     14723
     14724    softfloat_state_t SoftState = IEM_SOFTFLOAT_STATE_INITIALIZER_FROM_MXCSR(fMxcsr);
     14725    float64_t r64Result = f32_to_f64(iemFpSoftF32FromIprt(&r32Src1), &SoftState);
     14726    return iemSseSoftStateAndR64ToMxcsrAndIprtResult(&SoftState, r64Result, pr64Res, fMxcsr);
     14727}
     14728
     14729
     14730IEM_DECL_IMPL_DEF(void, iemAImpl_cvtss2sd_u128_r32,(PX86FXSTATE pFpuState, PIEMSSERESULT pResult, PCX86XMMREG puSrc1, PCRTFLOAT32U pr32Src2))
     14731{
     14732    pResult->MXCSR = iemAImpl_cvtss2sd_u128_r32_worker(&pResult->uResult.ar64[0], pFpuState->MXCSR, pr32Src2);
     14733    pResult->uResult.ar64[1] = puSrc1->ar64[1];
     14734}
     14735#endif
     14736
     14737
     14738/**
     14739 * CVTSD2SS
     14740 */
     14741#ifdef IEM_WITHOUT_ASSEMBLY
     14742static uint32_t iemAImpl_cvtsd2ss_u128_r64_worker(PRTFLOAT32U pr32Res, uint32_t fMxcsr, PCRTFLOAT64U pr64Val1)
     14743{
     14744    RTFLOAT64U r64Src1;
     14745    fMxcsr |= iemSsePrepareValueR64(&r64Src1, fMxcsr, pr64Val1);
     14746
     14747    softfloat_state_t SoftState = IEM_SOFTFLOAT_STATE_INITIALIZER_FROM_MXCSR(fMxcsr);
     14748    float32_t r32Result = f64_to_f32(iemFpSoftF64FromIprt(&r64Src1), &SoftState);
     14749    return iemSseSoftStateAndR32ToMxcsrAndIprtResult(&SoftState, r32Result, pr32Res, fMxcsr);
     14750}
     14751
     14752
     14753IEM_DECL_IMPL_DEF(void, iemAImpl_cvtsd2ss_u128_r64,(PX86FXSTATE pFpuState, PIEMSSERESULT pResult, PCX86XMMREG puSrc1, PCRTFLOAT64U pr64Src2))
     14754{
     14755    pResult->MXCSR = iemAImpl_cvtsd2ss_u128_r64_worker(&pResult->uResult.ar32[0], pFpuState->MXCSR, pr64Src2);
     14756    pResult->uResult.ar32[1] = puSrc1->ar32[1];
     14757    pResult->uResult.ar32[2] = puSrc1->ar32[2];
     14758    pResult->uResult.ar32[3] = puSrc1->ar32[3];
     14759}
     14760#endif

  • trunk/src/VBox/VMM/VMMAll/IEMAllInstructionsTwoByte0f.cpp.h

    r96351 r96379  
    41214121/** Opcode 0x66 0x0f 0x5a - cvtpd2ps Vps, Wpd */
    41224122FNIEMOP_STUB(iemOp_cvtpd2ps_Vps_Wpd);
     4123
     4124
    41234125/** Opcode 0xf3 0x0f 0x5a - cvtss2sd Vsd, Wss */
    4124 FNIEMOP_STUB(iemOp_cvtss2sd_Vsd_Wss);
     4126FNIEMOP_DEF(iemOp_cvtss2sd_Vsd_Wss)
     4127{
     4128    IEMOP_MNEMONIC2(RM, CVTSS2SD, cvtss2sd, Vsd, Wss, DISOPTYPE_HARMLESS, 0);
     4129    return FNIEMOP_CALL_1(iemOpCommonSseFp_FullR32_To_Full, iemAImpl_cvtss2sd_u128_r32);
     4130}
     4131
     4132
    41254133/** Opcode 0xf2 0x0f 0x5a - cvtsd2ss Vss, Wsd */
    4126 FNIEMOP_STUB(iemOp_cvtsd2ss_Vss_Wsd);
     4134FNIEMOP_DEF(iemOp_cvtsd2ss_Vss_Wsd)
     4135{
     4136    IEMOP_MNEMONIC2(RM, CVTSD2SS, cvtsd2ss, Vss, Wsd, DISOPTYPE_HARMLESS, 0);
     4137    return FNIEMOP_CALL_1(iemOpCommonSse2Fp_FullR64_To_Full, iemAImpl_cvtsd2ss_u128_r64);
     4138}
     4139
    41274140
    41284141/** Opcode      0x0f 0x5b - cvtdq2ps Vps, Wdq */

  • trunk/src/VBox/VMM/include/IEMInternal.h

    r96351 r96379  
    24512451FNIEMAIMPLFPSSEF2U128R32 iemAImpl_maxss_u128_r32;
    24522452FNIEMAIMPLFPSSEF2U128R64 iemAImpl_maxsd_u128_r64;
     2453FNIEMAIMPLFPSSEF2U128R32 iemAImpl_cvtss2sd_u128_r32;
     2454FNIEMAIMPLFPSSEF2U128R64 iemAImpl_cvtsd2ss_u128_r64;
    24532455
    24542456FNIEMAIMPLFPAVXF3U128 iemAImpl_vaddps_u128, iemAImpl_vaddps_u128_fallback;

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

    r96351 r96379  
    487487#define iemAImpl_maxss_u128_r32         NULL
    488488#define iemAImpl_maxsd_u128_r64         NULL
     489
     490#define iemAImpl_cvtss2sd_u128_r32      NULL
     491#define iemAImpl_cvtsd2ss_u128_r64      NULL
    489492
    490493/** @}  */
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