VirtualBox

Ignore:
Timestamp:
Apr 11, 2022 1:55:56 PM (3 years ago)
Author:
vboxsync
Message:

VMM/IEM,libs/softfloat: Don't use global variables in SoftFloat, pass in a state pointer to (almost) all functions instead. Started on fsqrt instruction implementation. bugref:9898

Location:
trunk/src/libs/softfloat-3e/source
Files:
316 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/libs/softfloat-3e/source/8086-SSE/s_extF80MToCommonNaN.c

    r94480 r94558  
    4949void
    5050 softfloat_extF80MToCommonNaN(
    51      const struct extFloat80M *aSPtr, struct commonNaN *zPtr )
     51     const struct extFloat80M *aSPtr, struct commonNaN *zPtr SOFTFLOAT_STATE_DECL_COMMA )
    5252{
    5353
    5454    if ( extF80M_isSignalingNaN( (const extFloat80_t *) aSPtr ) ) {
    55         softfloat_raiseFlags( softfloat_flag_invalid );
     55        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    5656    }
    5757    zPtr->sign = signExtF80UI64( aSPtr->signExp );

  • trunk/src/libs/softfloat-3e/source/8086-SSE/s_extF80UIToCommonNaN.c

    r94480 r94558  
    4949void
    5050 softfloat_extF80UIToCommonNaN(
    51      uint_fast16_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr )
     51     uint_fast16_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr SOFTFLOAT_STATE_DECL_COMMA )
    5252{
    5353
    5454    if ( softfloat_isSigNaNExtF80UI( uiA64, uiA0 ) ) {
    55         softfloat_raiseFlags( softfloat_flag_invalid );
     55        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    5656    }
    5757    zPtr->sign = uiA64>>15;

  • trunk/src/libs/softfloat-3e/source/8086-SSE/s_f128MToCommonNaN.c

    r94480 r94558  
    5050*----------------------------------------------------------------------------*/
    5151void
    52  softfloat_f128MToCommonNaN( const uint32_t *aWPtr, struct commonNaN *zPtr )
     52 softfloat_f128MToCommonNaN( const uint32_t *aWPtr, struct commonNaN *zPtr SOFTFLOAT_STATE_DECL_COMMA )
    5353{
    5454
    5555    if ( f128M_isSignalingNaN( (const float128_t *) aWPtr ) ) {
    56         softfloat_raiseFlags( softfloat_flag_invalid );
     56        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    5757    }
    5858    zPtr->sign = aWPtr[indexWordHi( 4 )]>>31;

  • trunk/src/libs/softfloat-3e/source/8086-SSE/s_f128UIToCommonNaN.c

    r94480 r94558  
    5050void
    5151 softfloat_f128UIToCommonNaN(
    52      uint_fast64_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr )
     52     uint_fast64_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr SOFTFLOAT_STATE_DECL_COMMA )
    5353{
    5454    struct uint128 NaNSig;
    5555
    5656    if ( softfloat_isSigNaNF128UI( uiA64, uiA0 ) ) {
    57         softfloat_raiseFlags( softfloat_flag_invalid );
     57        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    5858    }
    5959    NaNSig = softfloat_shortShiftLeft128( uiA64, uiA0, 16 );

  • trunk/src/libs/softfloat-3e/source/8086-SSE/s_f16UIToCommonNaN.c

    r94480 r94558  
    4646| exception is raised.
    4747*----------------------------------------------------------------------------*/
    48 void softfloat_f16UIToCommonNaN( uint_fast16_t uiA, struct commonNaN *zPtr )
     48void softfloat_f16UIToCommonNaN( uint_fast16_t uiA, struct commonNaN *zPtr SOFTFLOAT_STATE_DECL_COMMA )
    4949{
    5050
    5151    if ( softfloat_isSigNaNF16UI( uiA ) ) {
    52         softfloat_raiseFlags( softfloat_flag_invalid );
     52        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    5353    }
    5454    zPtr->sign = uiA>>15;

  • trunk/src/libs/softfloat-3e/source/8086-SSE/s_f32UIToCommonNaN.c

    r94480 r94558  
    4646| exception is raised.
    4747*----------------------------------------------------------------------------*/
    48 void softfloat_f32UIToCommonNaN( uint_fast32_t uiA, struct commonNaN *zPtr )
     48void softfloat_f32UIToCommonNaN( uint_fast32_t uiA, struct commonNaN *zPtr SOFTFLOAT_STATE_DECL_COMMA )
    4949{
    5050
    5151    if ( softfloat_isSigNaNF32UI( uiA ) ) {
    52         softfloat_raiseFlags( softfloat_flag_invalid );
     52        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    5353    }
    5454    zPtr->sign = uiA>>31;

  • trunk/src/libs/softfloat-3e/source/8086-SSE/s_f64UIToCommonNaN.c

    r94480 r94558  
    4646| exception is raised.
    4747*----------------------------------------------------------------------------*/
    48 void softfloat_f64UIToCommonNaN( uint_fast64_t uiA, struct commonNaN *zPtr )
     48void softfloat_f64UIToCommonNaN( uint_fast64_t uiA, struct commonNaN *zPtr SOFTFLOAT_STATE_DECL_COMMA )
    4949{
    5050
    5151    if ( softfloat_isSigNaNF64UI( uiA ) ) {
    52         softfloat_raiseFlags( softfloat_flag_invalid );
     52        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    5353    }
    5454    zPtr->sign = uiA>>63;

  • trunk/src/libs/softfloat-3e/source/8086-SSE/s_propagateNaNExtF80M.c

    r94480 r94558  
    5353     const struct extFloat80M *bSPtr,
    5454     struct extFloat80M *zSPtr
     55     SOFTFLOAT_STATE_DECL_COMMA
    5556 )
    5657{
    … …  
    6768    sPtr = aSPtr;
    6869    if ( ! bSPtr ) {
    69         if ( isSigNaNA ) softfloat_raiseFlags( softfloat_flag_invalid );
     70        if ( isSigNaNA ) softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    7071        goto copy;
    7172    }
    7273    isSigNaNB = extF80M_isSignalingNaN( (const extFloat80_t *) bSPtr );
    7374    if ( isSigNaNA | isSigNaNB ) {
    74         softfloat_raiseFlags( softfloat_flag_invalid );
     75        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    7576        if ( isSigNaNA ) {
    7677            uiB64 = bSPtr->signExp;

  • trunk/src/libs/softfloat-3e/source/8086-SSE/s_propagateNaNExtF80UI.c

    r94480 r94558  
    5757     uint_fast16_t uiB64,
    5858     uint_fast64_t uiB0
     59     SOFTFLOAT_STATE_DECL_COMMA
    5960 )
    6061{
    … …  
    7677    *------------------------------------------------------------------------*/
    7778    if ( isSigNaNA | isSigNaNB ) {
    78         softfloat_raiseFlags( softfloat_flag_invalid );
     79        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    7980        if ( isSigNaNA ) {
    8081            if ( isSigNaNB ) goto returnLargerMag;

  • trunk/src/libs/softfloat-3e/source/8086-SSE/s_propagateNaNF128M.c

    r94480 r94558  
    5252void
    5353 softfloat_propagateNaNF128M(
    54      const uint32_t *aWPtr, const uint32_t *bWPtr, uint32_t *zWPtr )
     54     const uint32_t *aWPtr, const uint32_t *bWPtr, uint32_t *zWPtr SOFTFLOAT_STATE_DECL_COMMA )
    5555{
    5656    bool isSigNaNA;
    … …  
    6363            || (bWPtr && f128M_isSignalingNaN( (const float128_t *) bWPtr ))
    6464    ) {
    65         softfloat_raiseFlags( softfloat_flag_invalid );
     65        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    6666        if ( isSigNaNA ) goto copy;
    6767    }

  • trunk/src/libs/softfloat-3e/source/8086-SSE/s_propagateNaNF128UI.c

    r94480 r94558  
    5757     uint_fast64_t uiB64,
    5858     uint_fast64_t uiB0
     59     SOFTFLOAT_STATE_DECL_COMMA
    5960 )
    6061{
    … …  
    6465    isSigNaNA = softfloat_isSigNaNF128UI( uiA64, uiA0 );
    6566    if ( isSigNaNA || softfloat_isSigNaNF128UI( uiB64, uiB0 ) ) {
    66         softfloat_raiseFlags( softfloat_flag_invalid );
     67        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    6768        if ( isSigNaNA ) goto returnNonsigA;
    6869    }

  • trunk/src/libs/softfloat-3e/source/8086-SSE/s_propagateNaNF16UI.c

    r94480 r94558  
    4949*----------------------------------------------------------------------------*/
    5050uint_fast16_t
    51  softfloat_propagateNaNF16UI( uint_fast16_t uiA, uint_fast16_t uiB )
     51 softfloat_propagateNaNF16UI( uint_fast16_t uiA, uint_fast16_t uiB SOFTFLOAT_STATE_DECL_COMMA )
    5252{
    5353    bool isSigNaNA;
    … …  
    5555    isSigNaNA = softfloat_isSigNaNF16UI( uiA );
    5656    if ( isSigNaNA || softfloat_isSigNaNF16UI( uiB ) ) {
    57         softfloat_raiseFlags( softfloat_flag_invalid );
     57        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    5858        if ( isSigNaNA ) return uiA | 0x0200;
    5959    }

  • trunk/src/libs/softfloat-3e/source/8086-SSE/s_propagateNaNF32UI.c

    r94480 r94558  
    4949*----------------------------------------------------------------------------*/
    5050uint_fast32_t
    51  softfloat_propagateNaNF32UI( uint_fast32_t uiA, uint_fast32_t uiB )
     51 softfloat_propagateNaNF32UI( uint_fast32_t uiA, uint_fast32_t uiB SOFTFLOAT_STATE_DECL_COMMA )
    5252{
    5353    bool isSigNaNA;
    … …  
    5555    isSigNaNA = softfloat_isSigNaNF32UI( uiA );
    5656    if ( isSigNaNA || softfloat_isSigNaNF32UI( uiB ) ) {
    57         softfloat_raiseFlags( softfloat_flag_invalid );
     57        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    5858        if ( isSigNaNA ) return uiA | 0x00400000;
    5959    }

  • trunk/src/libs/softfloat-3e/source/8086-SSE/s_propagateNaNF64UI.c

    r94480 r94558  
    4949*----------------------------------------------------------------------------*/
    5050uint_fast64_t
    51  softfloat_propagateNaNF64UI( uint_fast64_t uiA, uint_fast64_t uiB )
     51 softfloat_propagateNaNF64UI( uint_fast64_t uiA, uint_fast64_t uiB SOFTFLOAT_STATE_DECL_COMMA )
    5252{
    5353    bool isSigNaNA;
    … …  
    5555    isSigNaNA = softfloat_isSigNaNF64UI( uiA );
    5656    if ( isSigNaNA || softfloat_isSigNaNF64UI( uiB ) ) {
    57         softfloat_raiseFlags( softfloat_flag_invalid );
     57        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    5858        if ( isSigNaNA ) return uiA | UINT64_C( 0x0008000000000000 );
    5959    }

  • trunk/src/libs/softfloat-3e/source/8086-SSE/softfloat_raiseFlags.c

    r94480 r94558  
    4444| should be simply `softfloat_exceptionFlags |= flags;'.
    4545*----------------------------------------------------------------------------*/
    46 void softfloat_raiseFlags( uint_fast8_t flags )
     46void softfloat_raiseFlags( uint_fast8_t flags SOFTFLOAT_STATE_ARG_COMMA )
    4747{
    4848
     49#ifdef VBOX_WITHOUT_SOFTFLOAT_GLOBALS
    4950    softfloat_exceptionFlags |= flags;
     51#else
     52    pState->exceptionFlags   |= flags;
     53#endif
    5054
    5155}

  • trunk/src/libs/softfloat-3e/source/8086-SSE/specialize.h

    r94480 r94558  
    101101| exception is raised.
    102102*----------------------------------------------------------------------------*/
    103 void softfloat_f16UIToCommonNaN( uint_fast16_t uiA, struct commonNaN *zPtr );
     103void softfloat_f16UIToCommonNaN( uint_fast16_t uiA, struct commonNaN *zPtr SOFTFLOAT_STATE_DECL_COMMA );
    104104
    105105/*----------------------------------------------------------------------------
    … …  
    116116*----------------------------------------------------------------------------*/
    117117uint_fast16_t
    118  softfloat_propagateNaNF16UI( uint_fast16_t uiA, uint_fast16_t uiB );
     118 softfloat_propagateNaNF16UI( uint_fast16_t uiA, uint_fast16_t uiB SOFTFLOAT_STATE_DECL_COMMA );
    119119
    120120/*----------------------------------------------------------------------------
    … …  
    136136| exception is raised.
    137137*----------------------------------------------------------------------------*/
    138 void softfloat_f32UIToCommonNaN( uint_fast32_t uiA, struct commonNaN *zPtr );
     138void softfloat_f32UIToCommonNaN( uint_fast32_t uiA, struct commonNaN *zPtr SOFTFLOAT_STATE_DECL_COMMA );
    139139
    140140/*----------------------------------------------------------------------------
    … …  
    151151*----------------------------------------------------------------------------*/
    152152uint_fast32_t
    153  softfloat_propagateNaNF32UI( uint_fast32_t uiA, uint_fast32_t uiB );
     153 softfloat_propagateNaNF32UI( uint_fast32_t uiA, uint_fast32_t uiB SOFTFLOAT_STATE_DECL_COMMA );
    154154
    155155/*----------------------------------------------------------------------------
    … …  
    171171| exception is raised.
    172172*----------------------------------------------------------------------------*/
    173 void softfloat_f64UIToCommonNaN( uint_fast64_t uiA, struct commonNaN *zPtr );
     173void softfloat_f64UIToCommonNaN( uint_fast64_t uiA, struct commonNaN *zPtr SOFTFLOAT_STATE_DECL_COMMA );
    174174
    175175/*----------------------------------------------------------------------------
    … …  
    186186*----------------------------------------------------------------------------*/
    187187uint_fast64_t
    188  softfloat_propagateNaNF64UI( uint_fast64_t uiA, uint_fast64_t uiB );
     188 softfloat_propagateNaNF64UI( uint_fast64_t uiA, uint_fast64_t uiB SOFTFLOAT_STATE_DECL_COMMA );
    189189
    190190/*----------------------------------------------------------------------------
    … …  
    218218void
    219219 softfloat_extF80UIToCommonNaN(
    220      uint_fast16_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr );
     220     uint_fast16_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr SOFTFLOAT_STATE_DECL_COMMA );
    221221
    222222/*----------------------------------------------------------------------------
    … …  
    242242     uint_fast16_t uiB64,
    243243     uint_fast64_t uiB0
     244     SOFTFLOAT_STATE_DECL_COMMA
    244245 );
    245246
    … …  
    267268void
    268269 softfloat_f128UIToCommonNaN(
    269      uint_fast64_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr );
     270     uint_fast64_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr SOFTFLOAT_STATE_DECL_COMMA );
    270271
    271272/*----------------------------------------------------------------------------
    … …  
    290291     uint_fast64_t uiB64,
    291292     uint_fast64_t uiB0
     293     SOFTFLOAT_STATE_DECL_COMMA
    292294 );
    293295
    … …  
    307309void
    308310 softfloat_extF80MToCommonNaN(
    309      const struct extFloat80M *aSPtr, struct commonNaN *zPtr );
     311     const struct extFloat80M *aSPtr, struct commonNaN *zPtr SOFTFLOAT_STATE_DECL_COMMA );
    310312
    311313/*----------------------------------------------------------------------------
    … …  
    329331     const struct extFloat80M *bSPtr,
    330332     struct extFloat80M *zSPtr
     333     SOFTFLOAT_STATE_DECL_COMMA
    331334 );
    332335
    … …  
    348351*----------------------------------------------------------------------------*/
    349352void
    350  softfloat_f128MToCommonNaN( const uint32_t *aWPtr, struct commonNaN *zPtr );
     353 softfloat_f128MToCommonNaN( const uint32_t *aWPtr, struct commonNaN *zPtr SOFTFLOAT_STATE_DECL_COMMA );
    351354
    352355/*----------------------------------------------------------------------------
    … …  
    369372void
    370373 softfloat_propagateNaNF128M(
    371      const uint32_t *aWPtr, const uint32_t *bWPtr, uint32_t *zWPtr );
     374     const uint32_t *aWPtr, const uint32_t *bWPtr, uint32_t *zWPtr SOFTFLOAT_STATE_DECL_COMMA );
    372375
    373376#endif

  • trunk/src/libs/softfloat-3e/source/8086/s_extF80MToCommonNaN.c

    r94480 r94558  
    4949void
    5050 softfloat_extF80MToCommonNaN(
    51      const struct extFloat80M *aSPtr, struct commonNaN *zPtr )
     51     const struct extFloat80M *aSPtr, struct commonNaN *zPtr SOFTFLOAT_STATE_DECL_COMMA )
    5252{
    5353
    5454    if ( extF80M_isSignalingNaN( (const extFloat80_t *) aSPtr ) ) {
    55         softfloat_raiseFlags( softfloat_flag_invalid );
     55        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    5656    }
    5757    zPtr->sign = signExtF80UI64( aSPtr->signExp );

  • trunk/src/libs/softfloat-3e/source/8086/s_extF80UIToCommonNaN.c

    r94480 r94558  
    4949void
    5050 softfloat_extF80UIToCommonNaN(
    51      uint_fast16_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr )
     51     uint_fast16_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr SOFTFLOAT_STATE_DECL_COMMA )
    5252{
    5353
    5454    if ( softfloat_isSigNaNExtF80UI( uiA64, uiA0 ) ) {
    55         softfloat_raiseFlags( softfloat_flag_invalid );
     55        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    5656    }
    5757    zPtr->sign = uiA64>>15;

  • trunk/src/libs/softfloat-3e/source/8086/s_f128MToCommonNaN.c

    r94480 r94558  
    5050*----------------------------------------------------------------------------*/
    5151void
    52  softfloat_f128MToCommonNaN( const uint32_t *aWPtr, struct commonNaN *zPtr )
     52 softfloat_f128MToCommonNaN( const uint32_t *aWPtr, struct commonNaN *zPtr SOFTFLOAT_STATE_DECL_COMMA )
    5353{
    5454
    5555    if ( f128M_isSignalingNaN( (const float128_t *) aWPtr ) ) {
    56         softfloat_raiseFlags( softfloat_flag_invalid );
     56        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    5757    }
    5858    zPtr->sign = aWPtr[indexWordHi( 4 )]>>31;

  • trunk/src/libs/softfloat-3e/source/8086/s_f128UIToCommonNaN.c

    r94480 r94558  
    5050void
    5151 softfloat_f128UIToCommonNaN(
    52      uint_fast64_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr )
     52     uint_fast64_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr SOFTFLOAT_STATE_DECL_COMMA )
    5353{
    5454    struct uint128 NaNSig;
    5555
    5656    if ( softfloat_isSigNaNF128UI( uiA64, uiA0 ) ) {
    57         softfloat_raiseFlags( softfloat_flag_invalid );
     57        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    5858    }
    5959    NaNSig = softfloat_shortShiftLeft128( uiA64, uiA0, 16 );

  • trunk/src/libs/softfloat-3e/source/8086/s_f16UIToCommonNaN.c

    r94480 r94558  
    4646| exception is raised.
    4747*----------------------------------------------------------------------------*/
    48 void softfloat_f16UIToCommonNaN( uint_fast16_t uiA, struct commonNaN *zPtr )
     48void softfloat_f16UIToCommonNaN( uint_fast16_t uiA, struct commonNaN *zPtr SOFTFLOAT_STATE_DECL_COMMA )
    4949{
    5050
    5151    if ( softfloat_isSigNaNF16UI( uiA ) ) {
    52         softfloat_raiseFlags( softfloat_flag_invalid );
     52        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    5353    }
    5454    zPtr->sign = uiA>>15;

  • trunk/src/libs/softfloat-3e/source/8086/s_f32UIToCommonNaN.c

    r94480 r94558  
    4646| exception is raised.
    4747*----------------------------------------------------------------------------*/
    48 void softfloat_f32UIToCommonNaN( uint_fast32_t uiA, struct commonNaN *zPtr )
     48void softfloat_f32UIToCommonNaN( uint_fast32_t uiA, struct commonNaN *zPtr SOFTFLOAT_STATE_DECL_COMMA )
    4949{
    5050
    5151    if ( softfloat_isSigNaNF32UI( uiA ) ) {
    52         softfloat_raiseFlags( softfloat_flag_invalid );
     52        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    5353    }
    5454    zPtr->sign = uiA>>31;

  • trunk/src/libs/softfloat-3e/source/8086/s_f64UIToCommonNaN.c

    r94480 r94558  
    4646| exception is raised.
    4747*----------------------------------------------------------------------------*/
    48 void softfloat_f64UIToCommonNaN( uint_fast64_t uiA, struct commonNaN *zPtr )
     48void softfloat_f64UIToCommonNaN( uint_fast64_t uiA, struct commonNaN *zPtr SOFTFLOAT_STATE_DECL_COMMA )
    4949{
    5050
    5151    if ( softfloat_isSigNaNF64UI( uiA ) ) {
    52         softfloat_raiseFlags( softfloat_flag_invalid );
     52        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    5353    }
    5454    zPtr->sign = uiA>>63;

  • trunk/src/libs/softfloat-3e/source/8086/s_propagateNaNExtF80M.c

    r94480 r94558  
    5353     const struct extFloat80M *bSPtr,
    5454     struct extFloat80M *zSPtr
     55     SOFTFLOAT_STATE_DECL_COMMA
    5556 )
    5657{
    … …  
    6768    sPtr = aSPtr;
    6869    if ( ! bSPtr ) {
    69         if ( isSigNaNA ) softfloat_raiseFlags( softfloat_flag_invalid );
     70        if ( isSigNaNA ) softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    7071        goto copy;
    7172    }
    7273    isSigNaNB = extF80M_isSignalingNaN( (const extFloat80_t *) bSPtr );
    7374    if ( isSigNaNA | isSigNaNB ) {
    74         softfloat_raiseFlags( softfloat_flag_invalid );
     75        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    7576        if ( isSigNaNA ) {
    7677            uiB64 = bSPtr->signExp;

  • trunk/src/libs/softfloat-3e/source/8086/s_propagateNaNExtF80UI.c

    r94480 r94558  
    5757     uint_fast16_t uiB64,
    5858     uint_fast64_t uiB0
     59     SOFTFLOAT_STATE_DECL_COMMA
    5960 )
    6061{
    … …  
    7677    *------------------------------------------------------------------------*/
    7778    if ( isSigNaNA | isSigNaNB ) {
    78         softfloat_raiseFlags( softfloat_flag_invalid );
     79        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    7980        if ( isSigNaNA ) {
    8081            if ( isSigNaNB ) goto returnLargerMag;

  • trunk/src/libs/softfloat-3e/source/8086/s_propagateNaNF128M.c

    r94480 r94558  
    5252void
    5353 softfloat_propagateNaNF128M(
    54      const uint32_t *aWPtr, const uint32_t *bWPtr, uint32_t *zWPtr )
     54     const uint32_t *aWPtr, const uint32_t *bWPtr, uint32_t *zWPtr SOFTFLOAT_STATE_DECL_COMMA )
    5555{
    5656    bool isSigNaNA;
    … …  
    6262    ptr = aWPtr;
    6363    if ( ! bWPtr ) {
    64         if ( isSigNaNA ) softfloat_raiseFlags( softfloat_flag_invalid );
     64        if ( isSigNaNA ) softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    6565        goto copy;
    6666    }
    6767    isSigNaNB = f128M_isSignalingNaN( (const float128_t *) bWPtr );
    6868    if ( isSigNaNA | isSigNaNB ) {
    69         softfloat_raiseFlags( softfloat_flag_invalid );
     69        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    7070        if ( isSigNaNA ) {
    7171            if ( isSigNaNB ) goto returnLargerUIMag;

  • trunk/src/libs/softfloat-3e/source/8086/s_propagateNaNF128UI.c

    r94480 r94558  
    5757     uint_fast64_t uiB64,
    5858     uint_fast64_t uiB0
     59     SOFTFLOAT_STATE_DECL_COMMA
    5960 )
    6061{
    … …  
    7576    *------------------------------------------------------------------------*/
    7677    if ( isSigNaNA | isSigNaNB ) {
    77         softfloat_raiseFlags( softfloat_flag_invalid );
     78        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    7879        if ( isSigNaNA ) {
    7980            if ( isSigNaNB ) goto returnLargerMag;

  • trunk/src/libs/softfloat-3e/source/8086/s_propagateNaNF16UI.c

    r94480 r94558  
    4949*----------------------------------------------------------------------------*/
    5050uint_fast16_t
    51  softfloat_propagateNaNF16UI( uint_fast16_t uiA, uint_fast16_t uiB )
     51 softfloat_propagateNaNF16UI( uint_fast16_t uiA, uint_fast16_t uiB SOFTFLOAT_STATE_DECL_COMMA )
    5252{
    5353    bool isSigNaNA, isSigNaNB;
    … …  
    6666    *------------------------------------------------------------------------*/
    6767    if ( isSigNaNA | isSigNaNB ) {
    68         softfloat_raiseFlags( softfloat_flag_invalid );
     68        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    6969        if ( isSigNaNA ) {
    7070            if ( isSigNaNB ) goto returnLargerMag;

  • trunk/src/libs/softfloat-3e/source/8086/s_propagateNaNF32UI.c

    r94480 r94558  
    4949*----------------------------------------------------------------------------*/
    5050uint_fast32_t
    51  softfloat_propagateNaNF32UI( uint_fast32_t uiA, uint_fast32_t uiB )
     51 softfloat_propagateNaNF32UI( uint_fast32_t uiA, uint_fast32_t uiB SOFTFLOAT_STATE_DECL_COMMA )
    5252{
    5353    bool isSigNaNA, isSigNaNB;
    … …  
    6666    *------------------------------------------------------------------------*/
    6767    if ( isSigNaNA | isSigNaNB ) {
    68         softfloat_raiseFlags( softfloat_flag_invalid );
     68        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    6969        if ( isSigNaNA ) {
    7070            if ( isSigNaNB ) goto returnLargerMag;

  • trunk/src/libs/softfloat-3e/source/8086/s_propagateNaNF64UI.c

    r94480 r94558  
    4949*----------------------------------------------------------------------------*/
    5050uint_fast64_t
    51  softfloat_propagateNaNF64UI( uint_fast64_t uiA, uint_fast64_t uiB )
     51 softfloat_propagateNaNF64UI( uint_fast64_t uiA, uint_fast64_t uiB SOFTFLOAT_STATE_DECL_COMMA )
    5252{
    5353    bool isSigNaNA, isSigNaNB;
    … …  
    6666    *------------------------------------------------------------------------*/
    6767    if ( isSigNaNA | isSigNaNB ) {
    68         softfloat_raiseFlags( softfloat_flag_invalid );
     68        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    6969        if ( isSigNaNA ) {
    7070            if ( isSigNaNB ) goto returnLargerMag;

  • trunk/src/libs/softfloat-3e/source/8086/softfloat_raiseFlags.c

    r94480 r94558  
    4444| should be simply `softfloat_exceptionFlags |= flags;'.
    4545*----------------------------------------------------------------------------*/
    46 void softfloat_raiseFlags( uint_fast8_t flags )
     46void softfloat_raiseFlags( uint_fast8_t flags SOFTFLOAT_STATE_DECL_COMMA )
    4747{
    4848
     49#ifdef VBOX_WITHOUT_SOFTFLOAT_GLOBALS
    4950    softfloat_exceptionFlags |= flags;
     51#else
     52    pState->exceptionFlags   |= flags;
     53#endif
    5054
    5155}

  • trunk/src/libs/softfloat-3e/source/8086/specialize.h

    r94480 r94558  
    101101| exception is raised.
    102102*----------------------------------------------------------------------------*/
    103 void softfloat_f16UIToCommonNaN( uint_fast16_t uiA, struct commonNaN *zPtr );
     103void softfloat_f16UIToCommonNaN( uint_fast16_t uiA, struct commonNaN *zPtr SOFTFLOAT_STATE_DECL_COMMA );
    104104
    105105/*----------------------------------------------------------------------------
    … …  
    116116*----------------------------------------------------------------------------*/
    117117uint_fast16_t
    118  softfloat_propagateNaNF16UI( uint_fast16_t uiA, uint_fast16_t uiB );
     118 softfloat_propagateNaNF16UI( uint_fast16_t uiA, uint_fast16_t uiB SOFTFLOAT_STATE_DECL_COMMA );
    119119
    120120/*----------------------------------------------------------------------------
    … …  
    136136| exception is raised.
    137137*----------------------------------------------------------------------------*/
    138 void softfloat_f32UIToCommonNaN( uint_fast32_t uiA, struct commonNaN *zPtr );
     138void softfloat_f32UIToCommonNaN( uint_fast32_t uiA, struct commonNaN *zPtr SOFTFLOAT_STATE_DECL_COMMA );
    139139
    140140/*----------------------------------------------------------------------------
    … …  
    151151*----------------------------------------------------------------------------*/
    152152uint_fast32_t
    153  softfloat_propagateNaNF32UI( uint_fast32_t uiA, uint_fast32_t uiB );
     153 softfloat_propagateNaNF32UI( uint_fast32_t uiA, uint_fast32_t uiB SOFTFLOAT_STATE_DECL_COMMA );
    154154
    155155/*----------------------------------------------------------------------------
    … …  
    171171| exception is raised.
    172172*----------------------------------------------------------------------------*/
    173 void softfloat_f64UIToCommonNaN( uint_fast64_t uiA, struct commonNaN *zPtr );
     173void softfloat_f64UIToCommonNaN( uint_fast64_t uiA, struct commonNaN *zPtr SOFTFLOAT_STATE_DECL_COMMA );
    174174
    175175/*----------------------------------------------------------------------------
    … …  
    186186*----------------------------------------------------------------------------*/
    187187uint_fast64_t
    188  softfloat_propagateNaNF64UI( uint_fast64_t uiA, uint_fast64_t uiB );
     188 softfloat_propagateNaNF64UI( uint_fast64_t uiA, uint_fast64_t uiB SOFTFLOAT_STATE_DECL_COMMA );
    189189
    190190/*----------------------------------------------------------------------------
    … …  
    218218void
    219219 softfloat_extF80UIToCommonNaN(
    220      uint_fast16_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr );
     220     uint_fast16_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr SOFTFLOAT_STATE_DECL_COMMA );
    221221
    222222/*----------------------------------------------------------------------------
    … …  
    242242     uint_fast16_t uiB64,
    243243     uint_fast64_t uiB0
     244     SOFTFLOAT_STATE_DECL_COMMA
    244245 );
    245246
    … …  
    267268void
    268269 softfloat_f128UIToCommonNaN(
    269      uint_fast64_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr );
     270     uint_fast64_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr SOFTFLOAT_STATE_DECL_COMMA );
    270271
    271272/*----------------------------------------------------------------------------
    … …  
    290291     uint_fast64_t uiB64,
    291292     uint_fast64_t uiB0
     293     SOFTFLOAT_STATE_DECL_COMMA
    292294 );
    293295
    … …  
    307309void
    308310 softfloat_extF80MToCommonNaN(
    309      const struct extFloat80M *aSPtr, struct commonNaN *zPtr );
     311     const struct extFloat80M *aSPtr, struct commonNaN *zPtr SOFTFLOAT_STATE_DECL_COMMA );
    310312
    311313/*----------------------------------------------------------------------------
    … …  
    329331     const struct extFloat80M *bSPtr,
    330332     struct extFloat80M *zSPtr
     333     SOFTFLOAT_STATE_DECL_COMMA
    331334 );
    332335
    … …  
    348351*----------------------------------------------------------------------------*/
    349352void
    350  softfloat_f128MToCommonNaN( const uint32_t *aWPtr, struct commonNaN *zPtr );
     353 softfloat_f128MToCommonNaN( const uint32_t *aWPtr, struct commonNaN *zPtr SOFTFLOAT_STATE_DECL_COMMA );
    351354
    352355/*----------------------------------------------------------------------------
    … …  
    369372void
    370373 softfloat_propagateNaNF128M(
    371      const uint32_t *aWPtr, const uint32_t *bWPtr, uint32_t *zWPtr );
     374     const uint32_t *aWPtr, const uint32_t *bWPtr, uint32_t *zWPtr SOFTFLOAT_STATE_DECL_COMMA );
    372375
    373376#endif

  • trunk/src/libs/softfloat-3e/source/ARM-VFPv2-defaultNaN/s_propagateNaNExtF80M.c

    r94480 r94558  
    5252     const struct extFloat80M *bSPtr,
    5353     struct extFloat80M *zSPtr
     54     SOFTFLOAT_STATE_DECL_COMMA
    5455 )
    5556{
    … …  
    6667                        softfloat_isSigNaNExtF80UI( ui64, ui0 )))
    6768    ) {
    68         softfloat_raiseFlags( softfloat_flag_invalid );
     69        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    6970    }
    7071    zSPtr->signExp = defaultNaNExtF80UI64;

  • trunk/src/libs/softfloat-3e/source/ARM-VFPv2-defaultNaN/s_propagateNaNExtF80UI.c

    r94480 r94558  
    5656     uint_fast16_t uiB64,
    5757     uint_fast64_t uiB0
     58     SOFTFLOAT_STATE_DECL_COMMA
    5859 )
    5960{
    … …  
    6465        || softfloat_isSigNaNExtF80UI( uiB64, uiB0 )
    6566    ) {
    66         softfloat_raiseFlags( softfloat_flag_invalid );
     67        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    6768    }
    6869    uiZ.v64 = defaultNaNExtF80UI64;

  • trunk/src/libs/softfloat-3e/source/ARM-VFPv2-defaultNaN/s_propagateNaNF128M.c

    r94480 r94558  
    5151void
    5252 softfloat_propagateNaNF128M(
    53      const uint32_t *aWPtr, const uint32_t *bWPtr, uint32_t *zWPtr )
     53     const uint32_t *aWPtr, const uint32_t *bWPtr, uint32_t *zWPtr SOFTFLOAT_STATE_DECL_COMMA )
    5454{
    5555
    … …  
    5858            || (bWPtr && f128M_isSignalingNaN( (const float128_t *) bWPtr ))
    5959    ) {
    60         softfloat_raiseFlags( softfloat_flag_invalid );
     60        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    6161    }
    6262    zWPtr[indexWord( 4, 3 )] = defaultNaNF128UI96;

  • trunk/src/libs/softfloat-3e/source/ARM-VFPv2-defaultNaN/s_propagateNaNF128UI.c

    r94480 r94558  
    5656     uint_fast64_t uiB64,
    5757     uint_fast64_t uiB0
     58     SOFTFLOAT_STATE_DECL_COMMA
    5859 )
    5960{
    … …  
    6465        || softfloat_isSigNaNF128UI( uiB64, uiB0 )
    6566    ) {
    66         softfloat_raiseFlags( softfloat_flag_invalid );
     67        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    6768    }
    6869    uiZ.v64 = defaultNaNF128UI64;

  • trunk/src/libs/softfloat-3e/source/ARM-VFPv2-defaultNaN/s_propagateNaNF16UI.c

    r94480 r94558  
    4747*----------------------------------------------------------------------------*/
    4848uint_fast16_t
    49  softfloat_propagateNaNF16UI( uint_fast16_t uiA, uint_fast16_t uiB )
     49 softfloat_propagateNaNF16UI( uint_fast16_t uiA, uint_fast16_t uiB SOFTFLOAT_STATE_DECL_COMMA )
    5050{
    5151
    5252    if ( softfloat_isSigNaNF16UI( uiA ) || softfloat_isSigNaNF16UI( uiB ) ) {
    53         softfloat_raiseFlags( softfloat_flag_invalid );
     53        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    5454    }
    5555    return defaultNaNF16UI;

  • trunk/src/libs/softfloat-3e/source/ARM-VFPv2-defaultNaN/s_propagateNaNF32UI.c

    r94480 r94558  
    4747*----------------------------------------------------------------------------*/
    4848uint_fast32_t
    49  softfloat_propagateNaNF32UI( uint_fast32_t uiA, uint_fast32_t uiB )
     49 softfloat_propagateNaNF32UI( uint_fast32_t uiA, uint_fast32_t uiB SOFTFLOAT_STATE_DECL_COMMA )
    5050{
    5151
    5252    if ( softfloat_isSigNaNF32UI( uiA ) || softfloat_isSigNaNF32UI( uiB ) ) {
    53         softfloat_raiseFlags( softfloat_flag_invalid );
     53        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    5454    }
    5555    return defaultNaNF32UI;

  • trunk/src/libs/softfloat-3e/source/ARM-VFPv2-defaultNaN/s_propagateNaNF64UI.c

    r94480 r94558  
    4747*----------------------------------------------------------------------------*/
    4848uint_fast64_t
    49  softfloat_propagateNaNF64UI( uint_fast64_t uiA, uint_fast64_t uiB )
     49 softfloat_propagateNaNF64UI( uint_fast64_t uiA, uint_fast64_t uiB SOFTFLOAT_STATE_DECL_COMMA )
    5050{
    5151
    5252    if ( softfloat_isSigNaNF64UI( uiA ) || softfloat_isSigNaNF64UI( uiB ) ) {
    53         softfloat_raiseFlags( softfloat_flag_invalid );
     53        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    5454    }
    5555    return defaultNaNF64UI;

  • trunk/src/libs/softfloat-3e/source/ARM-VFPv2-defaultNaN/softfloat_raiseFlags.c

    r94480 r94558  
    4444| should be simply 'softfloat_exceptionFlags |= flags;'.
    4545*----------------------------------------------------------------------------*/
    46 void softfloat_raiseFlags( uint_fast8_t flags )
     46void softfloat_raiseFlags( uint_fast8_t flags SOFTFLOAT_STATE_ARG_COMMA )
    4747{
    4848
     49#ifdef VBOX_WITHOUT_SOFTFLOAT_GLOBALS
    4950    softfloat_exceptionFlags |= flags;
     51#else
     52    pState->exceptionFlags   |= flags;
     53#endif
    5054
    5155}

  • trunk/src/libs/softfloat-3e/source/ARM-VFPv2-defaultNaN/specialize.h

    r94480 r94558  
    9494| exception is raised.
    9595*----------------------------------------------------------------------------*/
     96#ifdef VBOX_WITHOUT_SOFTFLOAT_GLOBALS
    9697#define softfloat_f16UIToCommonNaN( uiA, zPtr ) if ( ! ((uiA) & 0x0200) ) softfloat_raiseFlags( softfloat_flag_invalid )
     98#else
     99# define softfloat_f16UIToCommonNaN( uiA, zPtr, pState ) if ( ! ((uiA) & 0x0200) ) softfloat_raiseFlags( softfloat_flag_invalid, pState )
     100#endif
    97101
    98102/*----------------------------------------------------------------------------
    … …  
    109113*----------------------------------------------------------------------------*/
    110114uint_fast16_t
    111  softfloat_propagateNaNF16UI( uint_fast16_t uiA, uint_fast16_t uiB );
     115 softfloat_propagateNaNF16UI( uint_fast16_t uiA, uint_fast16_t uiB SOFTFLOAT_STATE_DECL_COMMA );
    112116
    113117/*----------------------------------------------------------------------------
    … …  
    129133| exception is raised.
    130134*----------------------------------------------------------------------------*/
     135#ifdef VBOX_WITHOUT_SOFTFLOAT_GLOBALS
    131136#define softfloat_f32UIToCommonNaN( uiA, zPtr ) if ( ! ((uiA) & 0x00400000) ) softfloat_raiseFlags( softfloat_flag_invalid )
     137#else
     138# define softfloat_f32UIToCommonNaN( uiA, zPtr, pState ) if ( ! ((uiA) & 0x00400000) ) softfloat_raiseFlags( softfloat_flag_invalid, pState )
     139#endif
    132140
    133141/*----------------------------------------------------------------------------
    … …  
    144152*----------------------------------------------------------------------------*/
    145153uint_fast32_t
    146  softfloat_propagateNaNF32UI( uint_fast32_t uiA, uint_fast32_t uiB );
     154 softfloat_propagateNaNF32UI( uint_fast32_t uiA, uint_fast32_t uiB SOFTFLOAT_STATE_DECL_COMMA );
    147155
    148156/*----------------------------------------------------------------------------
    … …  
    164172| exception is raised.
    165173*----------------------------------------------------------------------------*/
     174#ifdef VBOX_WITHOUT_SOFTFLOAT_GLOBALS
    166175#define softfloat_f64UIToCommonNaN( uiA, zPtr ) if ( ! ((uiA) & UINT64_C( 0x0008000000000000 )) ) softfloat_raiseFlags( softfloat_flag_invalid )
     176#else
     177# define softfloat_f64UIToCommonNaN( uiA, zPtr, pState ) if ( ! ((uiA) & UINT64_C( 0x0008000000000000 )) ) softfloat_raiseFlags( softfloat_flag_invalid, pState )
     178#endif
    167179
    168180/*----------------------------------------------------------------------------
    … …  
    179191*----------------------------------------------------------------------------*/
    180192uint_fast64_t
    181  softfloat_propagateNaNF64UI( uint_fast64_t uiA, uint_fast64_t uiB );
     193 softfloat_propagateNaNF64UI( uint_fast64_t uiA, uint_fast64_t uiB SOFTFLOAT_STATE_DECL_COMMA );
    182194
    183195/*----------------------------------------------------------------------------
    … …  
    209221| exception is raised.
    210222*----------------------------------------------------------------------------*/
     223#ifdef VBOX_WITHOUT_SOFTFLOAT_GLOBALS
    211224#define softfloat_extF80UIToCommonNaN( uiA64, uiA0, zPtr ) if ( ! ((uiA0) & UINT64_C( 0x4000000000000000 )) ) softfloat_raiseFlags( softfloat_flag_invalid )
     225#else
     226# define softfloat_extF80UIToCommonNaN( uiA64, uiA0, zPtr, pState ) if ( ! ((uiA0) & UINT64_C( 0x4000000000000000 )) ) softfloat_raiseFlags( softfloat_flag_invalid, pState )
     227#endif
    212228
    213229/*----------------------------------------------------------------------------
    … …  
    244260     uint_fast16_t uiB64,
    245261     uint_fast64_t uiB0
     262     SOFTFLOAT_STATE_DECL_COMMA
    246263 );
    247264
    … …  
    267284| is raised.
    268285*----------------------------------------------------------------------------*/
     286#ifdef VBOX_WITHOUT_SOFTFLOAT_GLOBALS
    269287#define softfloat_f128UIToCommonNaN( uiA64, uiA0, zPtr ) if ( ! ((uiA64) & UINT64_C( 0x0000800000000000 )) ) softfloat_raiseFlags( softfloat_flag_invalid )
     288#else
     289# define softfloat_f128UIToCommonNaN( uiA64, uiA0, zPtr, pState ) if ( ! ((uiA64) & UINT64_C( 0x0000800000000000 )) ) softfloat_raiseFlags( softfloat_flag_invalid, pState)
     290#endif
    270291
    271292/*----------------------------------------------------------------------------
    … …  
    301322     uint_fast64_t uiB64,
    302323     uint_fast64_t uiB0
     324     SOFTFLOAT_STATE_DECL_COMMA
    303325 );
    304326
    … …  
    316338| NaN, the invalid exception is raised.
    317339*----------------------------------------------------------------------------*/
     340#ifdef VBOX_WITHOUT_SOFTFLOAT_GLOBALS
    318341#define softfloat_extF80MToCommonNaN( aSPtr, zPtr ) if ( ! ((aSPtr)->signif & UINT64_C( 0x4000000000000000 )) ) softfloat_raiseFlags( softfloat_flag_invalid )
     342#else
     343# define softfloat_extF80MToCommonNaN( aSPtr, zPtr, pState ) if ( ! ((aSPtr)->signif & UINT64_C( 0x4000000000000000 )) ) softfloat_raiseFlags( softfloat_flag_invalid, pState )
     344#endif
    319345
    320346/*----------------------------------------------------------------------------
    … …  
    349375     const struct extFloat80M *bSPtr,
    350376     struct extFloat80M *zSPtr
     377     SOFTFLOAT_STATE_DECL_COMMA
    351378 );
    352379
    … …  
    367394| to form a 128-bit floating-point value.
    368395*----------------------------------------------------------------------------*/
     396#ifdef VBOX_WITHOUT_SOFTFLOAT_GLOBALS
    369397#define softfloat_f128MToCommonNaN( aWPtr, zPtr ) if ( ! ((aWPtr)[indexWordHi( 4 )] & UINT64_C( 0x0000800000000000 )) ) softfloat_raiseFlags( softfloat_flag_invalid )
     398#else
     399# define softfloat_f128MToCommonNaN( aWPtr, zPtr ) if ( ! ((aWPtr)[indexWordHi( 4 )] & UINT64_C( 0x0000800000000000 )) ) softfloat_raiseFlags( softfloat_flag_invalid, pState )
     400#endif
    370401
    371402/*----------------------------------------------------------------------------
    … …  
    400431void
    401432 softfloat_propagateNaNF128M(
    402      const uint32_t *aWPtr, const uint32_t *bWPtr, uint32_t *zWPtr );
    403 
    404 #endif
    405 
    406 #endif
    407 
     433     const uint32_t *aWPtr, const uint32_t *bWPtr, uint32_t *zWPtr SOFTFLOAT_STATE_DECL_COMMA );
     434
     435#endif
     436
     437#endif
     438

  • trunk/src/libs/softfloat-3e/source/ARM-VFPv2/s_extF80MToCommonNaN.c

    r94480 r94558  
    4949void
    5050 softfloat_extF80MToCommonNaN(
    51      const struct extFloat80M *aSPtr, struct commonNaN *zPtr )
     51     const struct extFloat80M *aSPtr, struct commonNaN *zPtr SOFTFLOAT_STATE_DECL_COMMA )
    5252{
    5353
    5454    if ( extF80M_isSignalingNaN( (const extFloat80_t *) aSPtr ) ) {
    55         softfloat_raiseFlags( softfloat_flag_invalid );
     55        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    5656    }
    5757    zPtr->sign = signExtF80UI64( aSPtr->signExp );

  • trunk/src/libs/softfloat-3e/source/ARM-VFPv2/s_extF80UIToCommonNaN.c

    r94480 r94558  
    4949void
    5050 softfloat_extF80UIToCommonNaN(
    51      uint_fast16_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr )
     51     uint_fast16_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr SOFTFLOAT_STATE_DECL_COMMA )
    5252{
    5353
    5454    if ( softfloat_isSigNaNExtF80UI( uiA64, uiA0 ) ) {
    55         softfloat_raiseFlags( softfloat_flag_invalid );
     55        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    5656    }
    5757    zPtr->sign = uiA64>>15;

  • trunk/src/libs/softfloat-3e/source/ARM-VFPv2/s_f128MToCommonNaN.c

    r94480 r94558  
    5050*----------------------------------------------------------------------------*/
    5151void
    52  softfloat_f128MToCommonNaN( const uint32_t *aWPtr, struct commonNaN *zPtr )
     52 softfloat_f128MToCommonNaN( const uint32_t *aWPtr, struct commonNaN *zPtr SOFTFLOAT_STATE_DECL_COMMA )
    5353{
    5454
    5555    if ( f128M_isSignalingNaN( (const float128_t *) aWPtr ) ) {
    56         softfloat_raiseFlags( softfloat_flag_invalid );
     56        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    5757    }
    5858    zPtr->sign = aWPtr[indexWordHi( 4 )]>>31;

  • trunk/src/libs/softfloat-3e/source/ARM-VFPv2/s_f128UIToCommonNaN.c

    r94480 r94558  
    5050void
    5151 softfloat_f128UIToCommonNaN(
    52      uint_fast64_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr )
     52     uint_fast64_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr SOFTFLOAT_STATE_DECL_COMMA )
    5353{
    5454    struct uint128 NaNSig;
    5555
    5656    if ( softfloat_isSigNaNF128UI( uiA64, uiA0 ) ) {
    57         softfloat_raiseFlags( softfloat_flag_invalid );
     57        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    5858    }
    5959    NaNSig = softfloat_shortShiftLeft128( uiA64, uiA0, 16 );

  • trunk/src/libs/softfloat-3e/source/ARM-VFPv2/s_f16UIToCommonNaN.c

    r94480 r94558  
    4646| exception is raised.
    4747*----------------------------------------------------------------------------*/
    48 void softfloat_f16UIToCommonNaN( uint_fast16_t uiA, struct commonNaN *zPtr )
     48void softfloat_f16UIToCommonNaN( uint_fast16_t uiA, struct commonNaN *zPtr SOFTFLOAT_STATE_DECL_COMMA )
    4949{
    5050
    5151    if ( softfloat_isSigNaNF16UI( uiA ) ) {
    52         softfloat_raiseFlags( softfloat_flag_invalid );
     52        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    5353    }
    5454    zPtr->sign = uiA>>15;

  • trunk/src/libs/softfloat-3e/source/ARM-VFPv2/s_f32UIToCommonNaN.c

    r94480 r94558  
    4646| exception is raised.
    4747*----------------------------------------------------------------------------*/
    48 void softfloat_f32UIToCommonNaN( uint_fast32_t uiA, struct commonNaN *zPtr )
     48void softfloat_f32UIToCommonNaN( uint_fast32_t uiA, struct commonNaN *zPtr SOFTFLOAT_STATE_DECL_COMMA )
    4949{
    5050
    5151    if ( softfloat_isSigNaNF32UI( uiA ) ) {
    52         softfloat_raiseFlags( softfloat_flag_invalid );
     52        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    5353    }
    5454    zPtr->sign = uiA>>31;

  • trunk/src/libs/softfloat-3e/source/ARM-VFPv2/s_f64UIToCommonNaN.c

    r94480 r94558  
    4646| exception is raised.
    4747*----------------------------------------------------------------------------*/
    48 void softfloat_f64UIToCommonNaN( uint_fast64_t uiA, struct commonNaN *zPtr )
     48void softfloat_f64UIToCommonNaN( uint_fast64_t uiA, struct commonNaN *zPtr SOFTFLOAT_STATE_DECL_COMMA )
    4949{
    5050
    5151    if ( softfloat_isSigNaNF64UI( uiA ) ) {
    52         softfloat_raiseFlags( softfloat_flag_invalid );
     52        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    5353    }
    5454    zPtr->sign = uiA>>63;

  • trunk/src/libs/softfloat-3e/source/ARM-VFPv2/s_propagateNaNExtF80M.c

    r94480 r94558  
    5353     const struct extFloat80M *bSPtr,
    5454     struct extFloat80M *zSPtr
     55     SOFTFLOAT_STATE_DECL_COMMA
    5556 )
    5657{
    … …  
    6768                    && extF80M_isSignalingNaN( (const extFloat80_t *) bSPtr ))
    6869    ) {
    69         softfloat_raiseFlags( softfloat_flag_invalid );
     70        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    7071        if ( isSigNaNA ) goto copyNonsig;
    7172        goto copyNonsigB;

  • trunk/src/libs/softfloat-3e/source/ARM-VFPv2/s_propagateNaNExtF80UI.c

    r94480 r94558  
    5757     uint_fast16_t uiB64,
    5858     uint_fast64_t uiB0
     59     SOFTFLOAT_STATE_DECL_COMMA
    5960 )
    6061{
    … …  
    6465    isSigNaNA = softfloat_isSigNaNExtF80UI( uiA64, uiA0 );
    6566    if ( isSigNaNA || softfloat_isSigNaNExtF80UI( uiB64, uiB0 ) ) {
    66         softfloat_raiseFlags( softfloat_flag_invalid );
     67        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    6768        if ( isSigNaNA ) goto returnNonsigA;
    6869        goto returnNonsigB;

  • trunk/src/libs/softfloat-3e/source/ARM-VFPv2/s_propagateNaNF128M.c

    r94480 r94558  
    5252void
    5353 softfloat_propagateNaNF128M(
    54      const uint32_t *aWPtr, const uint32_t *bWPtr, uint32_t *zWPtr )
     54     const uint32_t *aWPtr, const uint32_t *bWPtr, uint32_t *zWPtr SOFTFLOAT_STATE_DECL_COMMA )
    5555{
    5656    const uint32_t *ptr;
    … …  
    6363            || (bWPtr && f128M_isSignalingNaN( (const float128_t *) bWPtr ))
    6464    ) {
    65         softfloat_raiseFlags( softfloat_flag_invalid );
     65        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    6666        if ( ! isSigNaNA ) ptr = bWPtr;
    6767        goto copyNonsig;

  • trunk/src/libs/softfloat-3e/source/ARM-VFPv2/s_propagateNaNF128UI.c

    r94480 r94558  
    5757     uint_fast64_t uiB64,
    5858     uint_fast64_t uiB0
     59     SOFTFLOAT_STATE_DECL_COMMA
    5960 )
    6061{
    … …  
    6465    isSigNaNA = softfloat_isSigNaNF128UI( uiA64, uiA0 );
    6566    if ( isSigNaNA || softfloat_isSigNaNF128UI( uiB64, uiB0 ) ) {
    66         softfloat_raiseFlags( softfloat_flag_invalid );
     67        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    6768        if ( isSigNaNA ) goto returnNonsigA;
    6869        goto returnNonsigB;

  • trunk/src/libs/softfloat-3e/source/ARM-VFPv2/s_propagateNaNF16UI.c

    r94480 r94558  
    4949*----------------------------------------------------------------------------*/
    5050uint_fast16_t
    51  softfloat_propagateNaNF16UI( uint_fast16_t uiA, uint_fast16_t uiB )
     51 softfloat_propagateNaNF16UI( uint_fast16_t uiA, uint_fast16_t uiB SOFTFLOAT_STATE_DECL_COMMA )
    5252{
    5353    bool isSigNaNA;
    … …  
    5555    isSigNaNA = softfloat_isSigNaNF16UI( uiA );
    5656    if ( isSigNaNA || softfloat_isSigNaNF16UI( uiB ) ) {
    57         softfloat_raiseFlags( softfloat_flag_invalid );
     57        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    5858        return (isSigNaNA ? uiA : uiB) | 0x0200;
    5959    }

  • trunk/src/libs/softfloat-3e/source/ARM-VFPv2/s_propagateNaNF32UI.c

    r94480 r94558  
    4949*----------------------------------------------------------------------------*/
    5050uint_fast32_t
    51  softfloat_propagateNaNF32UI( uint_fast32_t uiA, uint_fast32_t uiB )
     51 softfloat_propagateNaNF32UI( uint_fast32_t uiA, uint_fast32_t uiB SOFTFLOAT_STATE_DECL_COMMA )
    5252{
    5353    bool isSigNaNA;
    … …  
    5555    isSigNaNA = softfloat_isSigNaNF32UI( uiA );
    5656    if ( isSigNaNA || softfloat_isSigNaNF32UI( uiB ) ) {
    57         softfloat_raiseFlags( softfloat_flag_invalid );
     57        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    5858        return (isSigNaNA ? uiA : uiB) | 0x00400000;
    5959    }

  • trunk/src/libs/softfloat-3e/source/ARM-VFPv2/s_propagateNaNF64UI.c

    r94480 r94558  
    4949*----------------------------------------------------------------------------*/
    5050uint_fast64_t
    51  softfloat_propagateNaNF64UI( uint_fast64_t uiA, uint_fast64_t uiB )
     51 softfloat_propagateNaNF64UI( uint_fast64_t uiA, uint_fast64_t uiB SOFTFLOAT_STATE_DECL_COMMA )
    5252{
    5353    bool isSigNaNA;
    … …  
    5555    isSigNaNA = softfloat_isSigNaNF64UI( uiA );
    5656    if ( isSigNaNA || softfloat_isSigNaNF64UI( uiB ) ) {
    57         softfloat_raiseFlags( softfloat_flag_invalid );
     57        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    5858        return (isSigNaNA ? uiA : uiB) | UINT64_C( 0x0008000000000000 );
    5959    }

  • trunk/src/libs/softfloat-3e/source/ARM-VFPv2/softfloat_raiseFlags.c

    r94480 r94558  
    4444| should be simply 'softfloat_exceptionFlags |= flags;'.
    4545*----------------------------------------------------------------------------*/
    46 void softfloat_raiseFlags( uint_fast8_t flags )
     46void softfloat_raiseFlags( uint_fast8_t flags SOFTFLOAT_STATE_ARG_COMMA )
    4747{
    4848
     49#ifdef VBOX_WITHOUT_SOFTFLOAT_GLOBALS
    4950    softfloat_exceptionFlags |= flags;
     51#else
     52    pState->exceptionFlags   |= flags;
     53#endif
    5054
    5155}

  • trunk/src/libs/softfloat-3e/source/ARM-VFPv2/specialize.h

    r94480 r94558  
    101101| exception is raised.
    102102*----------------------------------------------------------------------------*/
    103 void softfloat_f16UIToCommonNaN( uint_fast16_t uiA, struct commonNaN *zPtr );
     103void softfloat_f16UIToCommonNaN( uint_fast16_t uiA, struct commonNaN *zPtr SOFTFLOAT_STATE_DECL_COMMA );
    104104
    105105/*----------------------------------------------------------------------------
    … …  
    116116*----------------------------------------------------------------------------*/
    117117uint_fast16_t
    118  softfloat_propagateNaNF16UI( uint_fast16_t uiA, uint_fast16_t uiB );
     118 softfloat_propagateNaNF16UI( uint_fast16_t uiA, uint_fast16_t uiB SOFTFLOAT_STATE_DECL_COMMA );
    119119
    120120/*----------------------------------------------------------------------------
    … …  
    136136| exception is raised.
    137137*----------------------------------------------------------------------------*/
    138 void softfloat_f32UIToCommonNaN( uint_fast32_t uiA, struct commonNaN *zPtr );
     138void softfloat_f32UIToCommonNaN( uint_fast32_t uiA, struct commonNaN *zPtr SOFTFLOAT_STATE_DECL_COMMA );
    139139
    140140/*----------------------------------------------------------------------------
    … …  
    151151*----------------------------------------------------------------------------*/
    152152uint_fast32_t
    153  softfloat_propagateNaNF32UI( uint_fast32_t uiA, uint_fast32_t uiB );
     153 softfloat_propagateNaNF32UI( uint_fast32_t uiA, uint_fast32_t uiB SOFTFLOAT_STATE_DECL_COMMA );
    154154
    155155/*----------------------------------------------------------------------------
    … …  
    171171| exception is raised.
    172172*----------------------------------------------------------------------------*/
    173 void softfloat_f64UIToCommonNaN( uint_fast64_t uiA, struct commonNaN *zPtr );
     173void softfloat_f64UIToCommonNaN( uint_fast64_t uiA, struct commonNaN *zPtr SOFTFLOAT_STATE_DECL_COMMA );
    174174
    175175/*----------------------------------------------------------------------------
    … …  
    186186*----------------------------------------------------------------------------*/
    187187uint_fast64_t
    188  softfloat_propagateNaNF64UI( uint_fast64_t uiA, uint_fast64_t uiB );
     188 softfloat_propagateNaNF64UI( uint_fast64_t uiA, uint_fast64_t uiB SOFTFLOAT_STATE_DECL_COMMA );
    189189
    190190/*----------------------------------------------------------------------------
    … …  
    218218void
    219219 softfloat_extF80UIToCommonNaN(
    220      uint_fast16_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr );
     220     uint_fast16_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr SOFTFLOAT_STATE_DECL_COMMA );
    221221
    222222/*----------------------------------------------------------------------------
    … …  
    242242     uint_fast16_t uiB64,
    243243     uint_fast64_t uiB0
     244     SOFTFLOAT_STATE_DECL_COMMA
    244245 );
    245246
    … …  
    267268void
    268269 softfloat_f128UIToCommonNaN(
    269      uint_fast64_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr );
     270     uint_fast64_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr SOFTFLOAT_STATE_DECL_COMMA );
    270271
    271272/*----------------------------------------------------------------------------
    … …  
    290291     uint_fast64_t uiB64,
    291292     uint_fast64_t uiB0
     293     SOFTFLOAT_STATE_DECL_COMMA
    292294 );
    293295
    … …  
    307309void
    308310 softfloat_extF80MToCommonNaN(
    309      const struct extFloat80M *aSPtr, struct commonNaN *zPtr );
     311     const struct extFloat80M *aSPtr, struct commonNaN *zPtr SOFTFLOAT_STATE_DECL_COMMA );
    310312
    311313/*----------------------------------------------------------------------------
    … …  
    329331     const struct extFloat80M *bSPtr,
    330332     struct extFloat80M *zSPtr
     333     SOFTFLOAT_STATE_DECL_COMMA
    331334 );
    332335
    … …  
    348351*----------------------------------------------------------------------------*/
    349352void
    350  softfloat_f128MToCommonNaN( const uint32_t *aWPtr, struct commonNaN *zPtr );
     353 softfloat_f128MToCommonNaN( const uint32_t *aWPtr, struct commonNaN *zPtr SOFTFLOAT_STATE_DECL_COMMA );
    351354
    352355/*----------------------------------------------------------------------------
    … …  
    369372void
    370373 softfloat_propagateNaNF128M(
    371      const uint32_t *aWPtr, const uint32_t *bWPtr, uint32_t *zWPtr );
     374     const uint32_t *aWPtr, const uint32_t *bWPtr, uint32_t *zWPtr SOFTFLOAT_STATE_DECL_COMMA );
    372375
    373376#endif

  • trunk/src/libs/softfloat-3e/source/extF80M_add.c

    r94480 r94558  
    4444void
    4545 extF80M_add(
    46      const extFloat80_t *aPtr, const extFloat80_t *bPtr, extFloat80_t *zPtr )
     46     const extFloat80_t *aPtr, const extFloat80_t *bPtr, extFloat80_t *zPtr SOFTFLOAT_STATE_DECL_COMMA )
    4747{
    4848    const struct extFloat80M *aSPtr, *bSPtr;
    … …  
    5656    extFloat80_t
    5757        (*magsFuncPtr)(
    58             uint_fast16_t, uint_fast64_t, uint_fast16_t, uint_fast64_t, bool );
     58            uint_fast16_t, uint_fast64_t, uint_fast16_t, uint_fast64_t, bool SOFTFLOAT_STATE_DECL_COMMA );
    5959#endif
    6060
    … …  
    6969#if defined INLINE_LEVEL && (2 <= INLINE_LEVEL)
    7070    if ( signA == signB ) {
    71         *zPtr = softfloat_addMagsExtF80( uiA64, uiA0, uiB64, uiB0, signA );
     71        *zPtr = softfloat_addMagsExtF80( uiA64, uiA0, uiB64, uiB0, signA SOFTFLOAT_STATE_ARG_COMMA );
    7272    } else {
    73         *zPtr = softfloat_subMagsExtF80( uiA64, uiA0, uiB64, uiB0, signA );
     73        *zPtr = softfloat_subMagsExtF80( uiA64, uiA0, uiB64, uiB0, signA SOFTFLOAT_STATE_ARG_COMMA );
    7474    }
    7575#else
    7676    magsFuncPtr =
    7777        (signA == signB) ? softfloat_addMagsExtF80 : softfloat_subMagsExtF80;
    78     *zPtr = (*magsFuncPtr)( uiA64, uiA0, uiB64, uiB0, signA );
     78    *zPtr = (*magsFuncPtr)( uiA64, uiA0, uiB64, uiB0, signA SOFTFLOAT_STATE_ARG_COMMA );
    7979#endif
    8080
    … …  
    8585void
    8686 extF80M_add(
    87      const extFloat80_t *aPtr, const extFloat80_t *bPtr, extFloat80_t *zPtr )
     87     const extFloat80_t *aPtr, const extFloat80_t *bPtr, extFloat80_t *zPtr SOFTFLOAT_STATE_DECL_COMMA )
    8888{
    8989
    … …  
    9393        (struct extFloat80M *) zPtr,
    9494        false
     95        SOFTFLOAT_STATE_ARG_COMMA
    9596    );
    9697

  • trunk/src/libs/softfloat-3e/source/extF80M_div.c

    r94480 r94558  
    4646void
    4747 extF80M_div(
    48      const extFloat80_t *aPtr, const extFloat80_t *bPtr, extFloat80_t *zPtr )
     48     const extFloat80_t *aPtr, const extFloat80_t *bPtr, extFloat80_t *zPtr SOFTFLOAT_STATE_DECL_COMMA )
    4949{
    5050
    51     *zPtr = extF80_div( *aPtr, *bPtr );
     51    *zPtr = extF80_div( *aPtr, *bPtr SOFTFLOAT_STATE_ARG_COMMA );
    5252
    5353}
    … …  
    5757void
    5858 extF80M_div(
    59      const extFloat80_t *aPtr, const extFloat80_t *bPtr, extFloat80_t *zPtr )
     59     const extFloat80_t *aPtr, const extFloat80_t *bPtr, extFloat80_t *zPtr SOFTFLOAT_STATE_DECL_COMMA )
    6060{
    6161    const struct extFloat80M *aSPtr, *bSPtr;
    … …  
    9090    *------------------------------------------------------------------------*/
    9191    if ( (expA == 0x7FFF) || (expB == 0x7FFF) ) {
    92         if ( softfloat_tryPropagateNaNExtF80M( aSPtr, bSPtr, zSPtr ) ) return;
     92        if ( softfloat_tryPropagateNaNExtF80M( aSPtr, bSPtr, zSPtr SOFTFLOAT_STATE_ARG_COMMA ) ) return;
    9393        if ( expA == 0x7FFF ) {
    9494            if ( expB == 0x7FFF ) goto invalid;
    … …  
    105105        if ( ! x64 ) {
    106106            if ( ! sigA ) goto invalid;
    107             softfloat_raiseFlags( softfloat_flag_infinite );
     107            softfloat_raiseFlags( softfloat_flag_infinite SOFTFLOAT_STATE_ARG_COMMA );
    108108            goto infinity;
    109109        }
    … …  
    167167    y[indexWord( 3, 2 )] = (qs[1]<<3) + (x64>>32);
    168168    softfloat_roundPackMToExtF80M(
    169         signZ, expZ, y, extF80_roundingPrecision, zSPtr );
     169        signZ, expZ, y, extF80_roundingPrecision, zSPtr SOFTFLOAT_STATE_ARG_COMMA );
    170170    return;
    171171    /*------------------------------------------------------------------------
    172172    *------------------------------------------------------------------------*/
    173173 invalid:
    174     softfloat_invalidExtF80M( zSPtr );
     174    softfloat_invalidExtF80M( zSPtr SOFTFLOAT_STATE_ARG_COMMA );
    175175    return;
    176176    /*------------------------------------------------------------------------

  • trunk/src/libs/softfloat-3e/source/extF80M_eq.c

    r94480 r94558  
    4444#ifdef SOFTFLOAT_FAST_INT64
    4545
    46 bool extF80M_eq( const extFloat80_t *aPtr, const extFloat80_t *bPtr )
     46bool extF80M_eq( const extFloat80_t *aPtr, const extFloat80_t *bPtr SOFTFLOAT_STATE_DECL_COMMA )
    4747{
    4848
    49     return extF80_eq( *aPtr, *bPtr );
     49    return extF80_eq( *aPtr, *bPtr SOFTFLOAT_STATE_ARG_COMMA );
    5050
    5151}
    … …  
    5353#else
    5454
    55 bool extF80M_eq( const extFloat80_t *aPtr, const extFloat80_t *bPtr )
     55bool extF80M_eq( const extFloat80_t *aPtr, const extFloat80_t *bPtr SOFTFLOAT_STATE_DECL_COMMA )
    5656{
    5757    const struct extFloat80M *aSPtr, *bSPtr;
    … …  
    7878            || softfloat_isSigNaNExtF80UI( uiB64, uiB0 )
    7979        ) {
    80             softfloat_raiseFlags( softfloat_flag_invalid );
     80            softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    8181        }
    8282        return false;

  • trunk/src/libs/softfloat-3e/source/extF80M_eq_signaling.c

    r94480 r94558  
    4343#ifdef SOFTFLOAT_FAST_INT64
    4444
    45 bool extF80M_eq_signaling( const extFloat80_t *aPtr, const extFloat80_t *bPtr )
     45bool extF80M_eq_signaling( const extFloat80_t *aPtr, const extFloat80_t *bPtr SOFTFLOAT_STATE_DECL_COMMA )
    4646{
    4747
    48     return extF80_eq_signaling( *aPtr, *bPtr );
     48    return extF80_eq_signaling( *aPtr, *bPtr SOFTFLOAT_STATE_ARG_COMMA );
    4949
    5050}
    … …  
    5252#else
    5353
    54 bool extF80M_eq_signaling( const extFloat80_t *aPtr, const extFloat80_t *bPtr )
     54bool extF80M_eq_signaling( const extFloat80_t *aPtr, const extFloat80_t *bPtr SOFTFLOAT_STATE_DECL_COMMA )
    5555{
    5656    const struct extFloat80M *aSPtr, *bSPtr;
    … …  
    7373    *------------------------------------------------------------------------*/
    7474    if ( isNaNExtF80UI( uiA64, uiA0 ) || isNaNExtF80UI( uiB64, uiB0 ) ) {
    75         softfloat_raiseFlags( softfloat_flag_invalid );
     75        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    7676        return false;
    7777    }

  • trunk/src/libs/softfloat-3e/source/extF80M_le.c

    r94480 r94558  
    4343#ifdef SOFTFLOAT_FAST_INT64
    4444
    45 bool extF80M_le( const extFloat80_t *aPtr, const extFloat80_t *bPtr )
     45bool extF80M_le( const extFloat80_t *aPtr, const extFloat80_t *bPtr SOFTFLOAT_STATE_DECL_COMMA )
    4646{
    4747
    48     return extF80_le( *aPtr, *bPtr );
     48    return extF80_le( *aPtr, *bPtr SOFTFLOAT_STATE_ARG_COMMA );
    4949
    5050}
    … …  
    5252#else
    5353
    54 bool extF80M_le( const extFloat80_t *aPtr, const extFloat80_t *bPtr )
     54bool extF80M_le( const extFloat80_t *aPtr, const extFloat80_t *bPtr SOFTFLOAT_STATE_DECL_COMMA )
    5555{
    5656    const struct extFloat80M *aSPtr, *bSPtr;
    … …  
    7474    *------------------------------------------------------------------------*/
    7575    if ( isNaNExtF80UI( uiA64, uiA0 ) || isNaNExtF80UI( uiB64, uiB0 ) ) {
    76         softfloat_raiseFlags( softfloat_flag_invalid );
     76        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    7777        return false;
    7878    }

  • trunk/src/libs/softfloat-3e/source/extF80M_le_quiet.c

    r94480 r94558  
    4444#ifdef SOFTFLOAT_FAST_INT64
    4545
    46 bool extF80M_le_quiet( const extFloat80_t *aPtr, const extFloat80_t *bPtr )
     46bool extF80M_le_quiet( const extFloat80_t *aPtr, const extFloat80_t *bPtr SOFTFLOAT_STATE_DECL_COMMA )
    4747{
    4848
    49     return extF80_le_quiet( *aPtr, *bPtr );
     49    return extF80_le_quiet( *aPtr, *bPtr SOFTFLOAT_STATE_ARG_COMMA );
    5050
    5151}
    … …  
    5353#else
    5454
    55 bool extF80M_le_quiet( const extFloat80_t *aPtr, const extFloat80_t *bPtr )
     55bool extF80M_le_quiet( const extFloat80_t *aPtr, const extFloat80_t *bPtr SOFTFLOAT_STATE_DECL_COMMA )
    5656{
    5757    const struct extFloat80M *aSPtr, *bSPtr;
    … …  
    7979            || softfloat_isSigNaNExtF80UI( uiB64, uiB0 )
    8080        ) {
    81             softfloat_raiseFlags( softfloat_flag_invalid );
     81            softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    8282        }
    8383        return false;

  • trunk/src/libs/softfloat-3e/source/extF80M_lt.c

    r94480 r94558  
    4343#ifdef SOFTFLOAT_FAST_INT64
    4444
    45 bool extF80M_lt( const extFloat80_t *aPtr, const extFloat80_t *bPtr )
     45bool extF80M_lt( const extFloat80_t *aPtr, const extFloat80_t *bPtr SOFTFLOAT_STATE_DECL_COMMA )
    4646{
    4747
    48     return extF80_lt( *aPtr, *bPtr );
     48    return extF80_lt( *aPtr, *bPtr SOFTFLOAT_STATE_ARG_COMMA );
    4949
    5050}
    … …  
    5252#else
    5353
    54 bool extF80M_lt( const extFloat80_t *aPtr, const extFloat80_t *bPtr )
     54bool extF80M_lt( const extFloat80_t *aPtr, const extFloat80_t *bPtr SOFTFLOAT_STATE_DECL_COMMA )
    5555{
    5656    const struct extFloat80M *aSPtr, *bSPtr;
    … …  
    7474    *------------------------------------------------------------------------*/
    7575    if ( isNaNExtF80UI( uiA64, uiA0 ) || isNaNExtF80UI( uiB64, uiB0 ) ) {
    76         softfloat_raiseFlags( softfloat_flag_invalid );
     76        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    7777        return false;
    7878    }

  • trunk/src/libs/softfloat-3e/source/extF80M_lt_quiet.c

    r94480 r94558  
    4444#ifdef SOFTFLOAT_FAST_INT64
    4545
    46 bool extF80M_lt_quiet( const extFloat80_t *aPtr, const extFloat80_t *bPtr )
     46bool extF80M_lt_quiet( const extFloat80_t *aPtr, const extFloat80_t *bPtr SOFTFLOAT_STATE_DECL_COMMA )
    4747{
    4848
    49     return extF80_lt_quiet( *aPtr, *bPtr );
     49    return extF80_lt_quiet( *aPtr, *bPtr SOFTFLOAT_STATE_ARG_COMMA );
    5050
    5151}
    … …  
    5353#else
    5454
    55 bool extF80M_lt_quiet( const extFloat80_t *aPtr, const extFloat80_t *bPtr )
     55bool extF80M_lt_quiet( const extFloat80_t *aPtr, const extFloat80_t *bPtr SOFTFLOAT_STATE_DECL_COMMA )
    5656{
    5757    const struct extFloat80M *aSPtr, *bSPtr;
    … …  
    7979            || softfloat_isSigNaNExtF80UI( uiB64, uiB0 )
    8080        ) {
    81             softfloat_raiseFlags( softfloat_flag_invalid );
     81            softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    8282        }
    8383        return false;

  • trunk/src/libs/softfloat-3e/source/extF80M_mul.c

    r94480 r94558  
    4646void
    4747 extF80M_mul(
    48      const extFloat80_t *aPtr, const extFloat80_t *bPtr, extFloat80_t *zPtr )
     48     const extFloat80_t *aPtr, const extFloat80_t *bPtr, extFloat80_t *zPtr SOFTFLOAT_STATE_DECL_COMMA )
    4949{
    5050
    51     *zPtr = extF80_mul( *aPtr, *bPtr );
     51    *zPtr = extF80_mul( *aPtr, *bPtr SOFTFLOAT_STATE_ARG_COMMA );
    5252
    5353}
    … …  
    5757void
    5858 extF80M_mul(
    59      const extFloat80_t *aPtr, const extFloat80_t *bPtr, extFloat80_t *zPtr )
     59     const extFloat80_t *aPtr, const extFloat80_t *bPtr, extFloat80_t *zPtr SOFTFLOAT_STATE_DECL_COMMA )
    6060{
    6161    const struct extFloat80M *aSPtr, *bSPtr;
    … …  
    8686    *------------------------------------------------------------------------*/
    8787    if ( (expA == 0x7FFF) || (expB == 0x7FFF) ) {
    88         if ( softfloat_tryPropagateNaNExtF80M( aSPtr, bSPtr, zSPtr ) ) return;
     88        if ( softfloat_tryPropagateNaNExtF80M( aSPtr, bSPtr, zSPtr SOFTFLOAT_STATE_ARG_COMMA ) ) return;
    8989        if (
    9090               (! aSPtr->signif && (expA != 0x7FFF))
    9191            || (! bSPtr->signif && (expB != 0x7FFF))
    9292        ) {
    93             softfloat_invalidExtF80M( zSPtr );
     93            softfloat_invalidExtF80M( zSPtr SOFTFLOAT_STATE_ARG_COMMA );
    9494            return;
    9595        }
    … …  
    123123    }
    124124    softfloat_roundPackMToExtF80M(
    125         signZ, expZ, extSigZPtr, extF80_roundingPrecision, zSPtr );
     125        signZ, expZ, extSigZPtr, extF80_roundingPrecision, zSPtr SOFTFLOAT_STATE_ARG_COMMA );
    126126    return;
    127127    /*------------------------------------------------------------------------

  • trunk/src/libs/softfloat-3e/source/extF80M_rem.c

    r94480 r94558  
    4646void
    4747 extF80M_rem(
    48      const extFloat80_t *aPtr, const extFloat80_t *bPtr, extFloat80_t *zPtr )
     48     const extFloat80_t *aPtr, const extFloat80_t *bPtr, extFloat80_t *zPtr SOFTFLOAT_STATE_DECL_COMMA )
    4949{
    5050
    51     *zPtr = extF80_rem( *aPtr, *bPtr );
     51    *zPtr = extF80_rem( *aPtr, *bPtr SOFTFLOAT_STATE_ARG_COMMA );
    5252
    5353}
    … …  
    5757void
    5858 extF80M_rem(
    59      const extFloat80_t *aPtr, const extFloat80_t *bPtr, extFloat80_t *zPtr )
     59     const extFloat80_t *aPtr, const extFloat80_t *bPtr, extFloat80_t *zPtr SOFTFLOAT_STATE_DECL_COMMA )
    6060{
    6161    const struct extFloat80M *aSPtr, *bSPtr;
    … …  
    8383    *------------------------------------------------------------------------*/
    8484    if ( (expA == 0x7FFF) || (expB == 0x7FFF) ) {
    85         if ( softfloat_tryPropagateNaNExtF80M( aSPtr, bSPtr, zSPtr ) ) return;
     85        if ( softfloat_tryPropagateNaNExtF80M( aSPtr, bSPtr, zSPtr SOFTFLOAT_STATE_ARG_COMMA ) ) return;
    8686        if ( expA == 0x7FFF ) goto invalid;
    8787        /*--------------------------------------------------------------------
    … …  
    182182        softfloat_negX96M( remPtr );
    183183    }
    184     softfloat_normRoundPackMToExtF80M( signRem, expB + 2, remPtr, 80, zSPtr );
     184    softfloat_normRoundPackMToExtF80M( signRem, expB + 2, remPtr, 80, zSPtr SOFTFLOAT_STATE_ARG_COMMA );
    185185    return;
    186186    /*------------------------------------------------------------------------
    187187    *------------------------------------------------------------------------*/
    188188 invalid:
    189     softfloat_invalidExtF80M( zSPtr );
     189    softfloat_invalidExtF80M( zSPtr SOFTFLOAT_STATE_ARG_COMMA );
    190190    return;
    191191    /*------------------------------------------------------------------------

  • trunk/src/libs/softfloat-3e/source/extF80M_roundToInt.c

    r94480 r94558  
    5050     bool exact,
    5151     extFloat80_t *zPtr
     52     SOFTFLOAT_STATE_DECL_COMMA
    5253 )
    5354{
    5455
    55     *zPtr = extF80_roundToInt( *aPtr, roundingMode, exact );
     56    *zPtr = extF80_roundToInt( *aPtr, roundingMode, exact SOFTFLOAT_STATE_ARG_COMMA );
    5657
    5758}
    … …  
    6566     bool exact,
    6667     extFloat80_t *zPtr
     68     SOFTFLOAT_STATE_DECL_COMMA
    6769 )
    6870{
    … …  
    129131        if ( exp == 0x7FFF ) {
    130132            if ( sigA & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) {
    131                 softfloat_propagateNaNExtF80M( aSPtr, 0, zSPtr );
     133                softfloat_propagateNaNExtF80M( aSPtr, 0, zSPtr SOFTFLOAT_STATE_ARG_COMMA );
    132134                return;
    133135            }

  • trunk/src/libs/softfloat-3e/source/extF80M_sqrt.c

    r94480 r94558  
    4444#ifdef SOFTFLOAT_FAST_INT64
    4545
    46 void extF80M_sqrt( const extFloat80_t *aPtr, extFloat80_t *zPtr )
     46void extF80M_sqrt( const extFloat80_t *aPtr, extFloat80_t *zPtr SOFTFLOAT_STATE_DECL_COMMA )
    4747{
    4848
    49     *zPtr = extF80_sqrt( *aPtr );
     49    *zPtr = extF80_sqrt( *aPtr SOFTFLOAT_STATE_ARG_COMMA );
    5050
    5151}
    … …  
    5353#else
    5454
    55 void extF80M_sqrt( const extFloat80_t *aPtr, extFloat80_t *zPtr )
     55void extF80M_sqrt( const extFloat80_t *aPtr, extFloat80_t *zPtr SOFTFLOAT_STATE_DECL_COMMA )
    5656{
    5757    const struct extFloat80M *aSPtr;
    … …  
    7979    if ( expA == 0x7FFF ) {
    8080        if ( rem64 & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) {
    81             softfloat_propagateNaNExtF80M( aSPtr, 0, zSPtr );
     81            softfloat_propagateNaNExtF80M( aSPtr, 0, zSPtr SOFTFLOAT_STATE_ARG_COMMA );
    8282            return;
    8383        }
    … …  
    162162    }
    163163    softfloat_roundPackMToExtF80M(
    164         0, expZ, extSigZ, extF80_roundingPrecision, zSPtr );
     164        0, expZ, extSigZ, extF80_roundingPrecision, zSPtr SOFTFLOAT_STATE_ARG_COMMA );
    165165    return;
    166166    /*------------------------------------------------------------------------
    167167    *------------------------------------------------------------------------*/
    168168 invalid:
    169     softfloat_invalidExtF80M( zSPtr );
     169    softfloat_invalidExtF80M( zSPtr SOFTFLOAT_STATE_ARG_COMMA );
    170170    return;
    171171    /*------------------------------------------------------------------------

  • trunk/src/libs/softfloat-3e/source/extF80M_sub.c

    r94480 r94558  
    4444void
    4545 extF80M_sub(
    46      const extFloat80_t *aPtr, const extFloat80_t *bPtr, extFloat80_t *zPtr )
     46     const extFloat80_t *aPtr, const extFloat80_t *bPtr, extFloat80_t *zPtr SOFTFLOAT_STATE_DECL_COMMA )
    4747{
    4848    const struct extFloat80M *aSPtr, *bSPtr;
    … …  
    5656    extFloat80_t
    5757        (*magsFuncPtr)(
    58             uint_fast16_t, uint_fast64_t, uint_fast16_t, uint_fast64_t, bool );
     58            uint_fast16_t, uint_fast64_t, uint_fast16_t, uint_fast64_t, bool SOFTFLOAT_STATE_DECL_COMMA );
    5959#endif
    6060
    … …  
    6969#if defined INLINE_LEVEL && (2 <= INLINE_LEVEL)
    7070    if ( signA == signB ) {
    71         *zPtr = softfloat_subMagsExtF80( uiA64, uiA0, uiB64, uiB0, signA );
     71        *zPtr = softfloat_subMagsExtF80( uiA64, uiA0, uiB64, uiB0, signA SOFTFLOAT_STATE_ARG_COMMA );
    7272    } else {
    73         *zPtr = softfloat_addMagsExtF80( uiA64, uiA0, uiB64, uiB0, signA );
     73        *zPtr = softfloat_addMagsExtF80( uiA64, uiA0, uiB64, uiB0, signA SOFTFLOAT_STATE_ARG_COMMA );
    7474    }
    7575#else
    7676    magsFuncPtr =
    7777        (signA == signB) ? softfloat_subMagsExtF80 : softfloat_addMagsExtF80;
    78     *zPtr = (*magsFuncPtr)( uiA64, uiA0, uiB64, uiB0, signA );
     78    *zPtr = (*magsFuncPtr)( uiA64, uiA0, uiB64, uiB0, signA SOFTFLOAT_STATE_ARG_COMMA );
    7979#endif
    8080
    … …  
    8585void
    8686 extF80M_sub(
    87      const extFloat80_t *aPtr, const extFloat80_t *bPtr, extFloat80_t *zPtr )
     87     const extFloat80_t *aPtr, const extFloat80_t *bPtr, extFloat80_t *zPtr SOFTFLOAT_STATE_DECL_COMMA )
    8888{
    8989
    … …  
    9393        (struct extFloat80M *) zPtr,
    9494        true
     95        SOFTFLOAT_STATE_ARG_COMMA
    9596    );
    9697

  • trunk/src/libs/softfloat-3e/source/extF80M_to_f128M.c

    r94480 r94558  
    4444#ifdef SOFTFLOAT_FAST_INT64
    4545
    46 void extF80M_to_f128M( const extFloat80_t *aPtr, float128_t *zPtr )
     46void extF80M_to_f128M( const extFloat80_t *aPtr, float128_t *zPtr SOFTFLOAT_STATE_DECL_COMMA )
    4747{
    4848
    49     *zPtr = extF80_to_f128( *aPtr );
     49    *zPtr = extF80_to_f128( *aPtr SOFTFLOAT_STATE_ARG_COMMA );
    5050
    5151}
    … …  
    5353#else
    5454
    55 void extF80M_to_f128M( const extFloat80_t *aPtr, float128_t *zPtr )
     55void extF80M_to_f128M( const extFloat80_t *aPtr, float128_t *zPtr SOFTFLOAT_STATE_DECL_COMMA )
    5656{
    5757    const struct extFloat80M *aSPtr;
    … …  
    7979    if ( exp == 0x7FFF ) {
    8080        if ( sig & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) {
    81             softfloat_extF80MToCommonNaN( aSPtr, &commonNaN );
     81            softfloat_extF80MToCommonNaN( aSPtr, &commonNaN SOFTFLOAT_STATE_ARG_COMMA );
    8282            softfloat_commonNaNToF128M( &commonNaN, zWPtr );
    8383            return;

  • trunk/src/libs/softfloat-3e/source/extF80M_to_f16.c

    r94480 r94558  
    4444#ifdef SOFTFLOAT_FAST_INT64
    4545
    46 float16_t extF80M_to_f16( const extFloat80_t *aPtr )
     46float16_t extF80M_to_f16( const extFloat80_t *aPtr SOFTFLOAT_STATE_DECL_COMMA )
    4747{
    4848
    49     return extF80_to_f16( *aPtr );
     49    return extF80_to_f16( *aPtr SOFTFLOAT_STATE_ARG_COMMA );
    5050
    5151}
    … …  
    5353#else
    5454
    55 float16_t extF80M_to_f16( const extFloat80_t *aPtr )
     55float16_t extF80M_to_f16( const extFloat80_t *aPtr SOFTFLOAT_STATE_DECL_COMMA )
    5656{
    5757    const struct extFloat80M *aSPtr;
    … …  
    7777    if ( exp == 0x7FFF ) {
    7878        if ( sig & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) {
    79             softfloat_extF80MToCommonNaN( aSPtr, &commonNaN );
     79            softfloat_extF80MToCommonNaN( aSPtr, &commonNaN SOFTFLOAT_STATE_ARG_COMMA );
    8080            uiZ = softfloat_commonNaNToF16UI( &commonNaN );
    8181        } else {
    … …  
    100100        if ( exp < -0x40 ) exp = -0x40;
    101101    }
    102     return softfloat_roundPackToF16( sign, exp, sig16 );
     102    return softfloat_roundPackToF16( sign, exp, sig16 SOFTFLOAT_STATE_ARG_COMMA );
    103103    /*------------------------------------------------------------------------
    104104    *------------------------------------------------------------------------*/

  • trunk/src/libs/softfloat-3e/source/extF80M_to_f32.c

    r94480 r94558  
    4444#ifdef SOFTFLOAT_FAST_INT64
    4545
    46 float32_t extF80M_to_f32( const extFloat80_t *aPtr )
     46float32_t extF80M_to_f32( const extFloat80_t *aPtr SOFTFLOAT_STATE_DECL_COMMA )
    4747{
    4848
    49     return extF80_to_f32( *aPtr );
     49    return extF80_to_f32( *aPtr SOFTFLOAT_STATE_ARG_COMMA );
    5050
    5151}
    … …  
    5353#else
    5454
    55 float32_t extF80M_to_f32( const extFloat80_t *aPtr )
     55float32_t extF80M_to_f32( const extFloat80_t *aPtr SOFTFLOAT_STATE_DECL_COMMA )
    5656{
    5757    const struct extFloat80M *aSPtr;
    … …  
    7777    if ( exp == 0x7FFF ) {
    7878        if ( sig & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) {
    79             softfloat_extF80MToCommonNaN( aSPtr, &commonNaN );
     79            softfloat_extF80MToCommonNaN( aSPtr, &commonNaN SOFTFLOAT_STATE_ARG_COMMA );
    8080            uiZ = softfloat_commonNaNToF32UI( &commonNaN );
    8181        } else {
    … …  
    100100        if ( exp < -0x1000 ) exp = -0x1000;
    101101    }
    102     return softfloat_roundPackToF32( sign, exp, sig32 );
     102    return softfloat_roundPackToF32( sign, exp, sig32 SOFTFLOAT_STATE_ARG_COMMA );
    103103    /*------------------------------------------------------------------------
    104104    *------------------------------------------------------------------------*/

  • trunk/src/libs/softfloat-3e/source/extF80M_to_f64.c

    r94480 r94558  
    4444#ifdef SOFTFLOAT_FAST_INT64
    4545
    46 float64_t extF80M_to_f64( const extFloat80_t *aPtr )
     46float64_t extF80M_to_f64( const extFloat80_t *aPtr SOFTFLOAT_STATE_DECL_COMMA )
    4747{
    4848
    49     return extF80_to_f64( *aPtr );
     49    return extF80_to_f64( *aPtr SOFTFLOAT_STATE_ARG_COMMA );
    5050
    5151}
    … …  
    5353#else
    5454
    55 float64_t extF80M_to_f64( const extFloat80_t *aPtr )
     55float64_t extF80M_to_f64( const extFloat80_t *aPtr SOFTFLOAT_STATE_DECL_COMMA )
    5656{
    5757    const struct extFloat80M *aSPtr;
    … …  
    7777    if ( exp == 0x7FFF ) {
    7878        if ( sig & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) {
    79             softfloat_extF80MToCommonNaN( aSPtr, &commonNaN );
     79            softfloat_extF80MToCommonNaN( aSPtr, &commonNaN SOFTFLOAT_STATE_ARG_COMMA );
    8080            uiZ = softfloat_commonNaNToF64UI( &commonNaN );
    8181        } else {
    … …  
    100100        if ( exp < -0x1000 ) exp = -0x1000;
    101101    }
    102     return softfloat_roundPackToF64( sign, exp, sig );
     102    return softfloat_roundPackToF64( sign, exp, sig SOFTFLOAT_STATE_ARG_COMMA );
    103103    /*------------------------------------------------------------------------
    104104    *------------------------------------------------------------------------*/

  • trunk/src/libs/softfloat-3e/source/extF80M_to_i32.c

    r94480 r94558  
    4646int_fast32_t
    4747 extF80M_to_i32(
    48      const extFloat80_t *aPtr, uint_fast8_t roundingMode, bool exact )
     48     const extFloat80_t *aPtr, uint_fast8_t roundingMode, bool exact SOFTFLOAT_STATE_DECL_COMMA )
    4949{
    5050
    51     return extF80_to_i32( *aPtr, roundingMode, exact );
     51    return extF80_to_i32( *aPtr, roundingMode, exact SOFTFLOAT_STATE_ARG_COMMA );
    5252
    5353}
    … …  
    5757int_fast32_t
    5858 extF80M_to_i32(
    59      const extFloat80_t *aPtr, uint_fast8_t roundingMode, bool exact )
     59     const extFloat80_t *aPtr, uint_fast8_t roundingMode, bool exact SOFTFLOAT_STATE_DECL_COMMA )
    6060{
    6161    const struct extFloat80M *aSPtr;
    … …  
    8686        sig = softfloat_shiftRightJam64( sig, shiftDist );
    8787    }
    88     return softfloat_roundToI32( sign, sig, roundingMode, exact );
     88    return softfloat_roundToI32( sign, sig, roundingMode, exact SOFTFLOAT_STATE_ARG_COMMA );
    8989    /*------------------------------------------------------------------------
    9090    *------------------------------------------------------------------------*/
    9191 invalid:
    92     softfloat_raiseFlags( softfloat_flag_invalid );
     92    softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    9393    return
    9494        (exp == 0x7FFF) && (sig & UINT64_C( 0x7FFFFFFFFFFFFFFF )) ? i32_fromNaN

  • trunk/src/libs/softfloat-3e/source/extF80M_to_i32_r_minMag.c

    r94480 r94558  
    4444#ifdef SOFTFLOAT_FAST_INT64
    4545
    46 int_fast32_t extF80M_to_i32_r_minMag( const extFloat80_t *aPtr, bool exact )
     46int_fast32_t extF80M_to_i32_r_minMag( const extFloat80_t *aPtr, bool exact SOFTFLOAT_STATE_DECL_COMMA )
    4747{
    4848
    49     return extF80_to_i32_r_minMag( *aPtr, exact );
     49    return extF80_to_i32_r_minMag( *aPtr, exact SOFTFLOAT_STATE_ARG_COMMA );
    5050
    5151}
    … …  
    5353#else
    5454
    55 int_fast32_t extF80M_to_i32_r_minMag( const extFloat80_t *aPtr, bool exact )
     55int_fast32_t extF80M_to_i32_r_minMag( const extFloat80_t *aPtr, bool exact SOFTFLOAT_STATE_DECL_COMMA )
    5656{
    5757    const struct extFloat80M *aSPtr;
    … …  
    110110    *------------------------------------------------------------------------*/
    111111 invalid:
    112     softfloat_raiseFlags( softfloat_flag_invalid );
     112    softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    113113    return
    114114        (exp == 0x7FFF) && (sig & UINT64_C( 0x7FFFFFFFFFFFFFFF )) ? i32_fromNaN

  • trunk/src/libs/softfloat-3e/source/extF80M_to_i64.c

    r94480 r94558  
    4646int_fast64_t
    4747 extF80M_to_i64(
    48      const extFloat80_t *aPtr, uint_fast8_t roundingMode, bool exact )
     48     const extFloat80_t *aPtr, uint_fast8_t roundingMode, bool exact SOFTFLOAT_STATE_DECL_COMMA )
    4949{
    5050
    51     return extF80_to_i64( *aPtr, roundingMode, exact );
     51    return extF80_to_i64( *aPtr, roundingMode, exact SOFTFLOAT_STATE_ARG_COMMA );
    5252
    5353}
    … …  
    5757int_fast64_t
    5858 extF80M_to_i64(
    59      const extFloat80_t *aPtr, uint_fast8_t roundingMode, bool exact )
     59     const extFloat80_t *aPtr, uint_fast8_t roundingMode, bool exact SOFTFLOAT_STATE_DECL_COMMA )
    6060{
    6161    const struct extFloat80M *aSPtr;
    … …  
    7878    shiftDist = 0x403E - exp;
    7979    if ( shiftDist < 0 ) {
    80         softfloat_raiseFlags( softfloat_flag_invalid );
     80        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    8181        return
    8282            (exp == 0x7FFF) && (sig & UINT64_C( 0x7FFFFFFFFFFFFFFF ))
    … …  
    9090    extSig[indexWord( 3, 0 )] = 0;
    9191    if ( shiftDist ) softfloat_shiftRightJam96M( extSig, shiftDist, extSig );
    92     return softfloat_roundMToI64( sign, extSig, roundingMode, exact );
     92    return softfloat_roundMToI64( sign, extSig, roundingMode, exact SOFTFLOAT_STATE_ARG_COMMA );
    9393
    9494}

  • trunk/src/libs/softfloat-3e/source/extF80M_to_i64_r_minMag.c

    r94480 r94558  
    4444#ifdef SOFTFLOAT_FAST_INT64
    4545
    46 int_fast64_t extF80M_to_i64_r_minMag( const extFloat80_t *aPtr, bool exact )
     46int_fast64_t extF80M_to_i64_r_minMag( const extFloat80_t *aPtr, bool exact SOFTFLOAT_STATE_DECL_COMMA )
    4747{
    4848
    49     return extF80_to_i64_r_minMag( *aPtr, exact );
     49    return extF80_to_i64_r_minMag( *aPtr, exact SOFTFLOAT_STATE_ARG_COMMA );
    5050
    5151}
    … …  
    5353#else
    5454
    55 int_fast64_t extF80M_to_i64_r_minMag( const extFloat80_t *aPtr, bool exact )
     55int_fast64_t extF80M_to_i64_r_minMag( const extFloat80_t *aPtr, bool exact SOFTFLOAT_STATE_DECL_COMMA )
    5656{
    5757    const struct extFloat80M *aSPtr;
    … …  
    105105    *------------------------------------------------------------------------*/
    106106 invalid:
    107     softfloat_raiseFlags( softfloat_flag_invalid );
     107    softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    108108    return
    109109        (exp == 0x7FFF) && (sig & UINT64_C( 0x7FFFFFFFFFFFFFFF )) ? i64_fromNaN

  • trunk/src/libs/softfloat-3e/source/extF80M_to_ui32.c

    r94480 r94558  
    4646uint_fast32_t
    4747 extF80M_to_ui32(
    48      const extFloat80_t *aPtr, uint_fast8_t roundingMode, bool exact )
     48     const extFloat80_t *aPtr, uint_fast8_t roundingMode, bool exact SOFTFLOAT_STATE_DECL_COMMA )
    4949{
    5050
    51     return extF80_to_ui32( *aPtr, roundingMode, exact );
     51    return extF80_to_ui32( *aPtr, roundingMode, exact SOFTFLOAT_STATE_ARG_COMMA );
    5252
    5353}
    … …  
    5757uint_fast32_t
    5858 extF80M_to_ui32(
    59      const extFloat80_t *aPtr, uint_fast8_t roundingMode, bool exact )
     59     const extFloat80_t *aPtr, uint_fast8_t roundingMode, bool exact SOFTFLOAT_STATE_DECL_COMMA )
    6060{
    6161    const struct extFloat80M *aSPtr;
    … …  
    8686        sig = softfloat_shiftRightJam64( sig, shiftDist );
    8787    }
    88     return softfloat_roundToUI32( sign, sig, roundingMode, exact );
     88    return softfloat_roundToUI32( sign, sig, roundingMode, exact SOFTFLOAT_STATE_ARG_COMMA );
    8989    /*------------------------------------------------------------------------
    9090    *------------------------------------------------------------------------*/
    9191 invalid:
    92     softfloat_raiseFlags( softfloat_flag_invalid );
     92    softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    9393    return
    9494        (exp == 0x7FFF) && (sig & UINT64_C( 0x7FFFFFFFFFFFFFFF ))

  • trunk/src/libs/softfloat-3e/source/extF80M_to_ui32_r_minMag.c

    r94480 r94558  
    4444#ifdef SOFTFLOAT_FAST_INT64
    4545
    46 uint_fast32_t extF80M_to_ui32_r_minMag( const extFloat80_t *aPtr, bool exact )
     46uint_fast32_t extF80M_to_ui32_r_minMag( const extFloat80_t *aPtr, bool exact SOFTFLOAT_STATE_DECL_COMMA )
    4747{
    4848
    49     return extF80_to_ui32_r_minMag( *aPtr, exact );
     49    return extF80_to_ui32_r_minMag( *aPtr, exact SOFTFLOAT_STATE_ARG_COMMA );
    5050
    5151}
    … …  
    5353#else
    5454
    55 uint_fast32_t extF80M_to_ui32_r_minMag( const extFloat80_t *aPtr, bool exact )
     55uint_fast32_t extF80M_to_ui32_r_minMag( const extFloat80_t *aPtr, bool exact SOFTFLOAT_STATE_DECL_COMMA )
    5656{
    5757    const struct extFloat80M *aSPtr;
    … …  
    100100    *------------------------------------------------------------------------*/
    101101 invalid:
    102     softfloat_raiseFlags( softfloat_flag_invalid );
     102    softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    103103    return
    104104        (exp == 0x7FFF) && (sig & UINT64_C( 0x7FFFFFFFFFFFFFFF ))

  • trunk/src/libs/softfloat-3e/source/extF80M_to_ui64.c

    r94480 r94558  
    4646uint_fast64_t
    4747 extF80M_to_ui64(
    48      const extFloat80_t *aPtr, uint_fast8_t roundingMode, bool exact )
     48     const extFloat80_t *aPtr, uint_fast8_t roundingMode, bool exact SOFTFLOAT_STATE_DECL_COMMA )
    4949{
    5050
    51     return extF80_to_ui64( *aPtr, roundingMode, exact );
     51    return extF80_to_ui64( *aPtr, roundingMode, exact SOFTFLOAT_STATE_ARG_COMMA );
    5252
    5353}
    … …  
    5757uint_fast64_t
    5858 extF80M_to_ui64(
    59      const extFloat80_t *aPtr, uint_fast8_t roundingMode, bool exact )
     59     const extFloat80_t *aPtr, uint_fast8_t roundingMode, bool exact SOFTFLOAT_STATE_DECL_COMMA )
    6060{
    6161    const struct extFloat80M *aSPtr;
    … …  
    7878    shiftDist = 0x403E - exp;
    7979    if ( shiftDist < 0 ) {
    80         softfloat_raiseFlags( softfloat_flag_invalid );
     80        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    8181        return
    8282            (exp == 0x7FFF) && (sig & UINT64_C( 0x7FFFFFFFFFFFFFFF ))
    … …  
    9090    extSig[indexWord( 3, 0 )] = 0;
    9191    if ( shiftDist ) softfloat_shiftRightJam96M( extSig, shiftDist, extSig );
    92     return softfloat_roundMToUI64( sign, extSig, roundingMode, exact );
     92    return softfloat_roundMToUI64( sign, extSig, roundingMode, exact SOFTFLOAT_STATE_ARG_COMMA);
    9393
    9494}

  • trunk/src/libs/softfloat-3e/source/extF80M_to_ui64_r_minMag.c

    r94480 r94558  
    4444#ifdef SOFTFLOAT_FAST_INT64
    4545
    46 uint_fast64_t extF80M_to_ui64_r_minMag( const extFloat80_t *aPtr, bool exact )
     46uint_fast64_t extF80M_to_ui64_r_minMag( const extFloat80_t *aPtr, bool exact SOFTFLOAT_STATE_DECL_COMMA )
    4747{
    4848
    49     return extF80_to_ui64_r_minMag( *aPtr, exact );
     49    return extF80_to_ui64_r_minMag( *aPtr, exact SOFTFLOAT_STATE_ARG_COMMA );
    5050
    5151}
    … …  
    5353#else
    5454
    55 uint_fast64_t extF80M_to_ui64_r_minMag( const extFloat80_t *aPtr, bool exact )
     55uint_fast64_t extF80M_to_ui64_r_minMag( const extFloat80_t *aPtr, bool exact SOFTFLOAT_STATE_DECL_COMMA )
    5656{
    5757    const struct extFloat80M *aSPtr;
    … …  
    9797    *------------------------------------------------------------------------*/
    9898 invalid:
    99     softfloat_raiseFlags( softfloat_flag_invalid );
     99    softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    100100    return
    101101        (exp == 0x7FFF) && (sig & UINT64_C( 0x7FFFFFFFFFFFFFFF ))

  • trunk/src/libs/softfloat-3e/source/extF80_add.c

    r94480 r94558  
    4141#include "softfloat.h"
    4242
    43 extFloat80_t extF80_add( extFloat80_t a, extFloat80_t b )
     43extFloat80_t extF80_add( extFloat80_t a, extFloat80_t b SOFTFLOAT_STATE_DECL_COMMA )
    4444{
    4545    union { struct extFloat80M s; extFloat80_t f; } uA;
    … …  
    5454    extFloat80_t
    5555        (*magsFuncPtr)(
    56             uint_fast16_t, uint_fast64_t, uint_fast16_t, uint_fast64_t, bool );
     56            uint_fast16_t, uint_fast64_t, uint_fast16_t, uint_fast64_t, bool SOFTFLOAT_STATE_DECL_COMMA );
    5757#endif
    5858
    … …  
    6767#if defined INLINE_LEVEL && (2 <= INLINE_LEVEL)
    6868    if ( signA == signB ) {
    69         return softfloat_addMagsExtF80( uiA64, uiA0, uiB64, uiB0, signA );
     69        return softfloat_addMagsExtF80( uiA64, uiA0, uiB64, uiB0, signA SOFTFLOAT_STATE_ARG_COMMA );
    7070    } else {
    71         return softfloat_subMagsExtF80( uiA64, uiA0, uiB64, uiB0, signA );
     71        return softfloat_subMagsExtF80( uiA64, uiA0, uiB64, uiB0, signA SOFTFLOAT_STATE_ARG_COMMA );
    7272    }
    7373#else
    7474    magsFuncPtr =
    7575        (signA == signB) ? softfloat_addMagsExtF80 : softfloat_subMagsExtF80;
    76     return (*magsFuncPtr)( uiA64, uiA0, uiB64, uiB0, signA );
     76    return (*magsFuncPtr)( uiA64, uiA0, uiB64, uiB0, signA SOFTFLOAT_STATE_ARG_COMMA );
    7777#endif
    7878

  • trunk/src/libs/softfloat-3e/source/extF80_div.c

    r94480 r94558  
    4242#include "softfloat.h"
    4343
    44 extFloat80_t extF80_div( extFloat80_t a, extFloat80_t b )
     44extFloat80_t extF80_div( extFloat80_t a, extFloat80_t b SOFTFLOAT_STATE_DECL_COMMA )
    4545{
    4646    union { struct extFloat80M s; extFloat80_t f; } uA;
    … …  
    107107        if ( ! sigB ) {
    108108            if ( ! sigA ) goto invalid;
    109             softfloat_raiseFlags( softfloat_flag_infinite );
     109            softfloat_raiseFlags( softfloat_flag_infinite SOFTFLOAT_STATE_ARG_COMMA );
    110110            goto infinity;
    111111        }
    … …  
    169169    return
    170170        softfloat_roundPackToExtF80(
    171             signZ, expZ, sigZ, sigZExtra, extF80_roundingPrecision );
     171            signZ, expZ, sigZ, sigZExtra, extF80_roundingPrecision SOFTFLOAT_STATE_ARG_COMMA );
    172172    /*------------------------------------------------------------------------
    173173    *------------------------------------------------------------------------*/
    174174 propagateNaN:
    175     uiZ = softfloat_propagateNaNExtF80UI( uiA64, uiA0, uiB64, uiB0 );
     175    uiZ = softfloat_propagateNaNExtF80UI( uiA64, uiA0, uiB64, uiB0 SOFTFLOAT_STATE_ARG_COMMA );
    176176    uiZ64 = uiZ.v64;
    177177    uiZ0  = uiZ.v0;
    … …  
    180180    *------------------------------------------------------------------------*/
    181181 invalid:
    182     softfloat_raiseFlags( softfloat_flag_invalid );
     182    softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    183183    uiZ64 = defaultNaNExtF80UI64;
    184184    uiZ0  = defaultNaNExtF80UI0;

  • trunk/src/libs/softfloat-3e/source/extF80_eq.c

    r94480 r94558  
    4242#include "softfloat.h"
    4343
    44 bool extF80_eq( extFloat80_t a, extFloat80_t b )
     44bool extF80_eq( extFloat80_t a, extFloat80_t b SOFTFLOAT_STATE_DECL_COMMA )
    4545{
    4646    union { struct extFloat80M s; extFloat80_t f; } uA;
    … …  
    6262            || softfloat_isSigNaNExtF80UI( uiB64, uiB0 )
    6363        ) {
    64             softfloat_raiseFlags( softfloat_flag_invalid );
     64            softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    6565        }
    6666        return false;

  • trunk/src/libs/softfloat-3e/source/extF80_eq_signaling.c

    r94480 r94558  
    4141#include "softfloat.h"
    4242
    43 bool extF80_eq_signaling( extFloat80_t a, extFloat80_t b )
     43bool extF80_eq_signaling( extFloat80_t a, extFloat80_t b SOFTFLOAT_STATE_DECL_COMMA )
    4444{
    4545    union { struct extFloat80M s; extFloat80_t f; } uA;
    … …  
    5757    uiB0  = uB.s.signif;
    5858    if ( isNaNExtF80UI( uiA64, uiA0 ) || isNaNExtF80UI( uiB64, uiB0 ) ) {
    59         softfloat_raiseFlags( softfloat_flag_invalid );
     59        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    6060        return false;
    6161    }

  • trunk/src/libs/softfloat-3e/source/extF80_le.c

    r94480 r94558  
    4242#include "softfloat.h"
    4343
    44 bool extF80_le( extFloat80_t a, extFloat80_t b )
     44bool extF80_le( extFloat80_t a, extFloat80_t b SOFTFLOAT_STATE_DECL_COMMA )
    4545{
    4646    union { struct extFloat80M s; extFloat80_t f; } uA;
    … …  
    5959    uiB0  = uB.s.signif;
    6060    if ( isNaNExtF80UI( uiA64, uiA0 ) || isNaNExtF80UI( uiB64, uiB0 ) ) {
    61         softfloat_raiseFlags( softfloat_flag_invalid );
     61        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    6262        return false;
    6363    }

  • trunk/src/libs/softfloat-3e/source/extF80_le_quiet.c

    r94480 r94558  
    4242#include "softfloat.h"
    4343
    44 bool extF80_le_quiet( extFloat80_t a, extFloat80_t b )
     44bool extF80_le_quiet( extFloat80_t a, extFloat80_t b SOFTFLOAT_STATE_DECL_COMMA )
    4545{
    4646    union { struct extFloat80M s; extFloat80_t f; } uA;
    … …  
    6363            || softfloat_isSigNaNExtF80UI( uiB64, uiB0 )
    6464        ) {
    65             softfloat_raiseFlags( softfloat_flag_invalid );
     65            softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    6666        }
    6767        return false;

  • trunk/src/libs/softfloat-3e/source/extF80_lt.c

    r94480 r94558  
    4242#include "softfloat.h"
    4343
    44 bool extF80_lt( extFloat80_t a, extFloat80_t b )
     44bool extF80_lt( extFloat80_t a, extFloat80_t b SOFTFLOAT_STATE_DECL_COMMA )
    4545{
    4646    union { struct extFloat80M s; extFloat80_t f; } uA;
    … …  
    5959    uiB0  = uB.s.signif;
    6060    if ( isNaNExtF80UI( uiA64, uiA0 ) || isNaNExtF80UI( uiB64, uiB0 ) ) {
    61         softfloat_raiseFlags( softfloat_flag_invalid );
     61        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    6262        return false;
    6363    }

  • trunk/src/libs/softfloat-3e/source/extF80_lt_quiet.c

    r94480 r94558  
    4242#include "softfloat.h"
    4343
    44 bool extF80_lt_quiet( extFloat80_t a, extFloat80_t b )
     44bool extF80_lt_quiet( extFloat80_t a, extFloat80_t b SOFTFLOAT_STATE_DECL_COMMA )
    4545{
    4646    union { struct extFloat80M s; extFloat80_t f; } uA;
    … …  
    6363            || softfloat_isSigNaNExtF80UI( uiB64, uiB0 )
    6464        ) {
    65             softfloat_raiseFlags( softfloat_flag_invalid );
     65            softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    6666        }
    6767        return false;

  • trunk/src/libs/softfloat-3e/source/extF80_mul.c

    r94480 r94558  
    4242#include "softfloat.h"
    4343
    44 extFloat80_t extF80_mul( extFloat80_t a, extFloat80_t b )
     44extFloat80_t extF80_mul( extFloat80_t a, extFloat80_t b SOFTFLOAT_STATE_DECL_COMMA )
    4545{
    4646    union { struct extFloat80M s; extFloat80_t f; } uA;
    … …  
    125125    return
    126126        softfloat_roundPackToExtF80(
    127             signZ, expZ, sig128Z.v64, sig128Z.v0, extF80_roundingPrecision );
     127            signZ, expZ, sig128Z.v64, sig128Z.v0, extF80_roundingPrecision SOFTFLOAT_STATE_ARG_COMMA );
    128128    /*------------------------------------------------------------------------
    129129    *------------------------------------------------------------------------*/
    130130 propagateNaN:
    131     uiZ = softfloat_propagateNaNExtF80UI( uiA64, uiA0, uiB64, uiB0 );
     131    uiZ = softfloat_propagateNaNExtF80UI( uiA64, uiA0, uiB64, uiB0 SOFTFLOAT_STATE_ARG_COMMA );
    132132    uiZ64 = uiZ.v64;
    133133    uiZ0  = uiZ.v0;
    … …  
    137137 infArg:
    138138    if ( ! magBits ) {
    139         softfloat_raiseFlags( softfloat_flag_invalid );
     139        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    140140        uiZ64 = defaultNaNExtF80UI64;
    141141        uiZ0  = defaultNaNExtF80UI0;

  • trunk/src/libs/softfloat-3e/source/extF80_rem.c

    r94480 r94558  
    4242#include "softfloat.h"
    4343
    44 extFloat80_t extF80_rem( extFloat80_t a, extFloat80_t b )
     44extFloat80_t extF80_rem( extFloat80_t a, extFloat80_t b SOFTFLOAT_STATE_DECL_COMMA )
    4545{
    4646    union { struct extFloat80M s; extFloat80_t f; } uA;
    … …  
    193193    return
    194194        softfloat_normRoundPackToExtF80(
    195             signRem, rem.v64 | rem.v0 ? expB + 32 : 0, rem.v64, rem.v0, 80 );
     195            signRem, rem.v64 | rem.v0 ? expB + 32 : 0, rem.v64, rem.v0, 80 SOFTFLOAT_STATE_ARG_COMMA );
    196196    /*------------------------------------------------------------------------
    197197    *------------------------------------------------------------------------*/
    198198 propagateNaN:
    199     uiZ = softfloat_propagateNaNExtF80UI( uiA64, uiA0, uiB64, uiB0 );
     199    uiZ = softfloat_propagateNaNExtF80UI( uiA64, uiA0, uiB64, uiB0 SOFTFLOAT_STATE_ARG_COMMA );
    200200    uiZ64 = uiZ.v64;
    201201    uiZ0  = uiZ.v0;
    … …  
    204204    *------------------------------------------------------------------------*/
    205205 invalid:
    206     softfloat_raiseFlags( softfloat_flag_invalid );
     206    softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    207207    uiZ64 = defaultNaNExtF80UI64;
    208208    uiZ0  = defaultNaNExtF80UI0;

  • trunk/src/libs/softfloat-3e/source/extF80_roundToInt.c

    r94548 r94558  
    4444
    4545extFloat80_t
    46  extF80_roundToInt( extFloat80_t a, uint_fast8_t roundingMode, bool exact )
     46 extF80_roundToInt( extFloat80_t a, uint_fast8_t roundingMode, bool exact SOFTFLOAT_STATE_DECL_COMMA )
    4747{
    4848    union { struct extFloat80M s; extFloat80_t f; } uA;
    … …  
    8181        if ( exp == 0x7FFF ) {
    8282            if ( sigA & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) {
    83                 uiZ = softfloat_propagateNaNExtF80UI( uiA64, sigA, 0, 0 );
     83                uiZ = softfloat_propagateNaNExtF80UI( uiA64, sigA, 0, 0 SOFTFLOAT_STATE_ARG_COMMA );
    8484                uiZ64 = uiZ.v64;
    8585                sigZ  = uiZ.v0;

  • trunk/src/libs/softfloat-3e/source/extF80_sqrt.c

    r94480 r94558  
    4242#include "softfloat.h"
    4343
    44 extFloat80_t extF80_sqrt( extFloat80_t a )
     44extFloat80_t extF80_sqrt( extFloat80_t a SOFTFLOAT_STATE_DECL_COMMA )
    4545{
    4646    union { struct extFloat80M s; extFloat80_t f; } uA;
    … …  
    7474    if ( expA == 0x7FFF ) {
    7575        if ( sigA & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) {
    76             uiZ = softfloat_propagateNaNExtF80UI( uiA64, uiA0, 0, 0 );
     76            uiZ = softfloat_propagateNaNExtF80UI( uiA64, uiA0, 0, 0 SOFTFLOAT_STATE_ARG_COMMA );
    7777            uiZ64 = uiZ.v64;
    7878            uiZ0  = uiZ.v0;
    … …  
    155155    return
    156156        softfloat_roundPackToExtF80(
    157             0, expZ, sigZ, sigZExtra, extF80_roundingPrecision );
     157            0, expZ, sigZ, sigZExtra, extF80_roundingPrecision SOFTFLOAT_STATE_ARG_COMMA );
    158158    /*------------------------------------------------------------------------
    159159    *------------------------------------------------------------------------*/
    160160 invalid:
    161     softfloat_raiseFlags( softfloat_flag_invalid );
     161    softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    162162    uiZ64 = defaultNaNExtF80UI64;
    163163    uiZ0  = defaultNaNExtF80UI0;

  • trunk/src/libs/softfloat-3e/source/extF80_sub.c

    r94480 r94558  
    4141#include "softfloat.h"
    4242
    43 extFloat80_t extF80_sub( extFloat80_t a, extFloat80_t b )
     43extFloat80_t extF80_sub( extFloat80_t a, extFloat80_t b SOFTFLOAT_STATE_DECL_COMMA )
    4444{
    4545    union { struct extFloat80M s; extFloat80_t f; } uA;
    … …  
    5454    extFloat80_t
    5555        (*magsFuncPtr)(
    56             uint_fast16_t, uint_fast64_t, uint_fast16_t, uint_fast64_t, bool );
     56            uint_fast16_t, uint_fast64_t, uint_fast16_t, uint_fast64_t, bool SOFTFLOAT_STATE_DECL_COMMA );
    5757#endif
    5858
    … …  
    6767#if defined INLINE_LEVEL && (2 <= INLINE_LEVEL)
    6868    if ( signA == signB ) {
    69         return softfloat_subMagsExtF80( uiA64, uiA0, uiB64, uiB0, signA );
     69        return softfloat_subMagsExtF80( uiA64, uiA0, uiB64, uiB0, signA SOFTFLOAT_STATE_ARG_COMMA );
    7070    } else {
    71         return softfloat_addMagsExtF80( uiA64, uiA0, uiB64, uiB0, signA );
     71        return softfloat_addMagsExtF80( uiA64, uiA0, uiB64, uiB0, signA SOFTFLOAT_STATE_ARG_COMMA );
    7272    }
    7373#else
    7474    magsFuncPtr =
    7575        (signA == signB) ? softfloat_subMagsExtF80 : softfloat_addMagsExtF80;
    76     return (*magsFuncPtr)( uiA64, uiA0, uiB64, uiB0, signA );
     76    return (*magsFuncPtr)( uiA64, uiA0, uiB64, uiB0, signA SOFTFLOAT_STATE_ARG_COMMA );
    7777#endif
    7878

  • trunk/src/libs/softfloat-3e/source/extF80_to_f128.c

    r94480 r94558  
    4242#include "softfloat.h"
    4343
    44 float128_t extF80_to_f128( extFloat80_t a )
     44float128_t extF80_to_f128( extFloat80_t a SOFTFLOAT_STATE_DECL_COMMA )
    4545{
    4646    union { struct extFloat80M s; extFloat80_t f; } uA;
    … …  
    6161    frac = uiA0 & UINT64_C( 0x7FFFFFFFFFFFFFFF );
    6262    if ( (exp == 0x7FFF) && frac ) {
    63         softfloat_extF80UIToCommonNaN( uiA64, uiA0, &commonNaN );
     63        softfloat_extF80UIToCommonNaN( uiA64, uiA0, &commonNaN SOFTFLOAT_STATE_ARG_COMMA );
    6464        uiZ = softfloat_commonNaNToF128UI( &commonNaN );
    6565    } else {

  • trunk/src/libs/softfloat-3e/source/extF80_to_f16.c

    r94480 r94558  
    4242#include "softfloat.h"
    4343
    44 float16_t extF80_to_f16( extFloat80_t a )
     44float16_t extF80_to_f16( extFloat80_t a SOFTFLOAT_STATE_DECL_COMMA )
    4545{
    4646    union { struct extFloat80M s; extFloat80_t f; } uA;
    … …  
    6666    if ( exp == 0x7FFF ) {
    6767        if ( sig & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) {
    68             softfloat_extF80UIToCommonNaN( uiA64, uiA0, &commonNaN );
     68            softfloat_extF80UIToCommonNaN( uiA64, uiA0, &commonNaN SOFTFLOAT_STATE_ARG_COMMA );
    6969            uiZ = softfloat_commonNaNToF16UI( &commonNaN );
    7070        } else {
    … …  
    8686        if ( exp < -0x40 ) exp = -0x40;
    8787    }
    88     return softfloat_roundPackToF16( sign, exp, sig16 );
     88    return softfloat_roundPackToF16( sign, exp, sig16 SOFTFLOAT_STATE_ARG_COMMA );
    8989    /*------------------------------------------------------------------------
    9090    *------------------------------------------------------------------------*/

  • trunk/src/libs/softfloat-3e/source/extF80_to_f32.c

    r94480 r94558  
    4242#include "softfloat.h"
    4343
    44 float32_t extF80_to_f32( extFloat80_t a )
     44float32_t extF80_to_f32( extFloat80_t a SOFTFLOAT_STATE_DECL_COMMA )
    4545{
    4646    union { struct extFloat80M s; extFloat80_t f; } uA;
    … …  
    6666    if ( exp == 0x7FFF ) {
    6767        if ( sig & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) {
    68             softfloat_extF80UIToCommonNaN( uiA64, uiA0, &commonNaN );
     68            softfloat_extF80UIToCommonNaN( uiA64, uiA0, &commonNaN SOFTFLOAT_STATE_ARG_COMMA );
    6969            uiZ = softfloat_commonNaNToF32UI( &commonNaN );
    7070        } else {
    … …  
    8686        if ( exp < -0x1000 ) exp = -0x1000;
    8787    }
    88     return softfloat_roundPackToF32( sign, exp, sig32 );
     88    return softfloat_roundPackToF32( sign, exp, sig32 SOFTFLOAT_STATE_ARG_COMMA );
    8989    /*------------------------------------------------------------------------
    9090    *------------------------------------------------------------------------*/

  • trunk/src/libs/softfloat-3e/source/extF80_to_f64.c

    r94480 r94558  
    4242#include "softfloat.h"
    4343
    44 float64_t extF80_to_f64( extFloat80_t a )
     44float64_t extF80_to_f64( extFloat80_t a SOFTFLOAT_STATE_DECL_COMMA )
    4545{
    4646    union { struct extFloat80M s; extFloat80_t f; } uA;
    … …  
    7272    if ( exp == 0x7FFF ) {
    7373        if ( sig & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) {
    74             softfloat_extF80UIToCommonNaN( uiA64, uiA0, &commonNaN );
     74            softfloat_extF80UIToCommonNaN( uiA64, uiA0, &commonNaN SOFTFLOAT_STATE_ARG_COMMA );
    7575            uiZ = softfloat_commonNaNToF64UI( &commonNaN );
    7676        } else {
    … …  
    8686        if ( exp < -0x1000 ) exp = -0x1000;
    8787    }
    88     return softfloat_roundPackToF64( sign, exp, sig );
     88    return softfloat_roundPackToF64( sign, exp, sig SOFTFLOAT_STATE_ARG_COMMA );
    8989    /*------------------------------------------------------------------------
    9090    *------------------------------------------------------------------------*/

  • trunk/src/libs/softfloat-3e/source/extF80_to_i32.c

    r94480 r94558  
    4343
    4444int_fast32_t
    45  extF80_to_i32( extFloat80_t a, uint_fast8_t roundingMode, bool exact )
     45 extF80_to_i32( extFloat80_t a, uint_fast8_t roundingMode, bool exact SOFTFLOAT_STATE_DECL_COMMA )
    4646{
    4747    union { struct extFloat80M s; extFloat80_t f; } uA;
    … …  
    6868        sign = 1;
    6969#else
    70         softfloat_raiseFlags( softfloat_flag_invalid );
     70        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    7171        return i32_fromNaN;
    7272#endif
    … …  
    7878    if ( shiftDist <= 0 ) shiftDist = 1;
    7979    sig = softfloat_shiftRightJam64( sig, shiftDist );
    80     return softfloat_roundToI32( sign, sig, roundingMode, exact );
     80    return softfloat_roundToI32( sign, sig, roundingMode, exact SOFTFLOAT_STATE_ARG_COMMA );
    8181
    8282}

  • trunk/src/libs/softfloat-3e/source/extF80_to_i32_r_minMag.c

    r94480 r94558  
    4242#include "softfloat.h"
    4343
    44 int_fast32_t extF80_to_i32_r_minMag( extFloat80_t a, bool exact )
     44int_fast32_t extF80_to_i32_r_minMag( extFloat80_t a, bool exact SOFTFLOAT_STATE_DECL_COMMA )
    4545{
    4646    union { struct extFloat80M s; extFloat80_t f; } uA;
    … …  
    8080            return -0x7FFFFFFF - 1;
    8181        }
    82         softfloat_raiseFlags( softfloat_flag_invalid );
     82        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    8383        return
    8484            (exp == 0x7FFF) && (sig & UINT64_C( 0x7FFFFFFFFFFFFFFF ))

  • trunk/src/libs/softfloat-3e/source/extF80_to_i64.c

    r94480 r94558  
    4343
    4444int_fast64_t
    45  extF80_to_i64( extFloat80_t a, uint_fast8_t roundingMode, bool exact )
     45 extF80_to_i64( extFloat80_t a, uint_fast8_t roundingMode, bool exact SOFTFLOAT_STATE_DECL_COMMA )
    4646{
    4747    union { struct extFloat80M s; extFloat80_t f; } uA;
    … …  
    6868        *--------------------------------------------------------------------*/
    6969        if ( shiftDist ) {
    70             softfloat_raiseFlags( softfloat_flag_invalid );
     70            softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    7171            return
    7272                (exp == 0x7FFF) && (sig & UINT64_C( 0x7FFFFFFFFFFFFFFF ))
    … …  
    8484        sigExtra = sig64Extra.extra;
    8585    }
    86     return softfloat_roundToI64( sign, sig, sigExtra, roundingMode, exact );
     86    return softfloat_roundToI64( sign, sig, sigExtra, roundingMode, exact SOFTFLOAT_STATE_ARG_COMMA );
    8787
    8888}

  • trunk/src/libs/softfloat-3e/source/extF80_to_i64_r_minMag.c

    r94480 r94558  
    4242#include "softfloat.h"
    4343
    44 int_fast64_t extF80_to_i64_r_minMag( extFloat80_t a, bool exact )
     44int_fast64_t extF80_to_i64_r_minMag( extFloat80_t a, bool exact SOFTFLOAT_STATE_DECL_COMMA )
    4545{
    4646    union { struct extFloat80M s; extFloat80_t f; } uA;
    … …  
    7777            return -INT64_C( 0x7FFFFFFFFFFFFFFF ) - 1;
    7878        }
    79         softfloat_raiseFlags( softfloat_flag_invalid );
     79        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    8080        return
    8181            (exp == 0x7FFF) && (sig & UINT64_C( 0x7FFFFFFFFFFFFFFF ))

  • trunk/src/libs/softfloat-3e/source/extF80_to_ui32.c

    r94480 r94558  
    4343
    4444uint_fast32_t
    45  extF80_to_ui32( extFloat80_t a, uint_fast8_t roundingMode, bool exact )
     45 extF80_to_ui32( extFloat80_t a, uint_fast8_t roundingMode, bool exact SOFTFLOAT_STATE_DECL_COMMA )
    4646{
    4747    union { struct extFloat80M s; extFloat80_t f; } uA;
    … …  
    6868        sign = 1;
    6969#else
    70         softfloat_raiseFlags( softfloat_flag_invalid );
     70        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    7171        return ui32_fromNaN;
    7272#endif
    … …  
    7878    if ( shiftDist <= 0 ) shiftDist = 1;
    7979    sig = softfloat_shiftRightJam64( sig, shiftDist );
    80     return softfloat_roundToUI32( sign, sig, roundingMode, exact );
     80    return softfloat_roundToUI32( sign, sig, roundingMode, exact SOFTFLOAT_STATE_ARG_COMMA );
    8181
    8282}

  • trunk/src/libs/softfloat-3e/source/extF80_to_ui32_r_minMag.c

    r94480 r94558  
    4242#include "softfloat.h"
    4343
    44 uint_fast32_t extF80_to_ui32_r_minMag( extFloat80_t a, bool exact )
     44uint_fast32_t extF80_to_ui32_r_minMag( extFloat80_t a, bool exact SOFTFLOAT_STATE_DECL_COMMA )
    4545{
    4646    union { struct extFloat80M s; extFloat80_t f; } uA;
    … …  
    7171    sign = signExtF80UI64( uiA64 );
    7272    if ( sign || (shiftDist < 32) ) {
    73         softfloat_raiseFlags( softfloat_flag_invalid );
     73        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    7474        return
    7575            (exp == 0x7FFF) && (sig & UINT64_C( 0x7FFFFFFFFFFFFFFF ))

  • trunk/src/libs/softfloat-3e/source/extF80_to_ui64.c

    r94480 r94558  
    4343
    4444uint_fast64_t
    45  extF80_to_ui64( extFloat80_t a, uint_fast8_t roundingMode, bool exact )
     45 extF80_to_ui64( extFloat80_t a, uint_fast8_t roundingMode, bool exact SOFTFLOAT_STATE_DECL_COMMA )
    4646{
    4747    union { struct extFloat80M s; extFloat80_t f; } uA;
    … …  
    6565    shiftDist = 0x403E - exp;
    6666    if ( shiftDist < 0 ) {
    67         softfloat_raiseFlags( softfloat_flag_invalid );
     67        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    6868        return
    6969            (exp == 0x7FFF) && (sig & UINT64_C( 0x7FFFFFFFFFFFFFFF ))
    … …  
    7979        sigExtra = sig64Extra.extra;
    8080    }
    81     return softfloat_roundToUI64( sign, sig, sigExtra, roundingMode, exact );
     81    return softfloat_roundToUI64( sign, sig, sigExtra, roundingMode, exact SOFTFLOAT_STATE_ARG_COMMA );
    8282
    8383}

  • trunk/src/libs/softfloat-3e/source/extF80_to_ui64_r_minMag.c

    r94480 r94558  
    4242#include "softfloat.h"
    4343
    44 uint_fast64_t extF80_to_ui64_r_minMag( extFloat80_t a, bool exact )
     44uint_fast64_t extF80_to_ui64_r_minMag( extFloat80_t a, bool exact SOFTFLOAT_STATE_DECL_COMMA )
    4545{
    4646    union { struct extFloat80M s; extFloat80_t f; } uA;
    … …  
    7171    sign = signExtF80UI64( uiA64 );
    7272    if ( sign || (shiftDist < 0) ) {
    73         softfloat_raiseFlags( softfloat_flag_invalid );
     73        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    7474        return
    7575            (exp == 0x7FFF) && (sig & UINT64_C( 0x7FFFFFFFFFFFFFFF ))

  • trunk/src/libs/softfloat-3e/source/f128M_add.c

    r94480 r94558  
    4444
    4545void
    46  f128M_add( const float128_t *aPtr, const float128_t *bPtr, float128_t *zPtr )
     46 f128M_add( const float128_t *aPtr, const float128_t *bPtr, float128_t *zPtr SOFTFLOAT_STATE_DECL_COMMA )
    4747{
    4848    const uint64_t *aWPtr, *bWPtr;
    … …  
    5454    float128_t
    5555        (*magsFuncPtr)(
    56             uint_fast64_t, uint_fast64_t, uint_fast64_t, uint_fast64_t, bool );
     56            uint_fast64_t, uint_fast64_t, uint_fast64_t, uint_fast64_t, bool SOFTFLOAT_STATE_DECL_COMMA );
    5757#endif
    5858
    … …  
    6767#if defined INLINE_LEVEL && (2 <= INLINE_LEVEL)
    6868    if ( signA == signB ) {
    69         *zPtr = softfloat_addMagsF128( uiA64, uiA0, uiB64, uiB0, signA );
     69        *zPtr = softfloat_addMagsF128( uiA64, uiA0, uiB64, uiB0, signA SOFTFLOAT_STATE_ARG_COMMA );
    7070    } else {
    71         *zPtr = softfloat_subMagsF128( uiA64, uiA0, uiB64, uiB0, signA );
     71        *zPtr = softfloat_subMagsF128( uiA64, uiA0, uiB64, uiB0, signA SOFTFLOAT_STATE_ARG_COMMA );
    7272    }
    7373#else
    7474    magsFuncPtr =
    7575        (signA == signB) ? softfloat_addMagsF128 : softfloat_subMagsF128;
    76     *zPtr = (*magsFuncPtr)( uiA64, uiA0, uiB64, uiB0, signA );
     76    *zPtr = (*magsFuncPtr)( uiA64, uiA0, uiB64, uiB0, signA SOFTFLOAT_STATE_ARG_COMMA );
    7777#endif
    7878
    … …  
    8282
    8383void
    84  f128M_add( const float128_t *aPtr, const float128_t *bPtr, float128_t *zPtr )
     84 f128M_add( const float128_t *aPtr, const float128_t *bPtr, float128_t *zPtr SOFTFLOAT_STATE_DECL_COMMA )
    8585{
    8686
    … …  
    9090        (uint32_t *) zPtr,
    9191        false
     92        SOFTFLOAT_STATE_ARG_COMMA
    9293    );
    9394

  • trunk/src/libs/softfloat-3e/source/f128M_div.c

    r94480 r94558  
    4545
    4646void
    47  f128M_div( const float128_t *aPtr, const float128_t *bPtr, float128_t *zPtr )
     47 f128M_div( const float128_t *aPtr, const float128_t *bPtr, float128_t *zPtr SOFTFLOAT_STATE_DECL_COMMA )
    4848{
    4949
    50     *zPtr = f128_div( *aPtr, *bPtr );
     50    *zPtr = f128_div( *aPtr, *bPtr SOFTFLOAT_STATE_ARG_COMMA );
    5151
    5252}
    … …  
    5555
    5656void
    57  f128M_div( const float128_t *aPtr, const float128_t *bPtr, float128_t *zPtr )
     57 f128M_div( const float128_t *aPtr, const float128_t *bPtr, float128_t *zPtr SOFTFLOAT_STATE_DECL_COMMA )
    5858{
    5959    const uint32_t *aWPtr, *bWPtr;
    … …  
    8989    *------------------------------------------------------------------------*/
    9090    if ( (expA == 0x7FFF) || (expB == 0x7FFF) ) {
    91         if ( softfloat_tryPropagateNaNF128M( aWPtr, bWPtr, zWPtr ) ) return;
     91        if ( softfloat_tryPropagateNaNF128M( aWPtr, bWPtr, zWPtr SOFTFLOAT_STATE_ARG_COMMA ) ) return;
    9292        if ( expA == 0x7FFF ) {
    9393            if ( expB == 0x7FFF ) goto invalid;
    … …  
    105105    }
    106106    if ( expB == -128 ) {
    107         softfloat_raiseFlags( softfloat_flag_infinite );
     107        softfloat_raiseFlags( softfloat_flag_infinite SOFTFLOAT_STATE_ARG_COMMA );
    108108        goto infinity;
    109109    }
    … …  
    162162    y[indexWord( 5, 3 )] = q64;
    163163    y[indexWord( 5, 4 )] = q64>>32;
    164     softfloat_roundPackMToF128M( signZ, expZ, y, zWPtr );
     164    softfloat_roundPackMToF128M( signZ, expZ, y, zWPtr SOFTFLOAT_STATE_ARG_COMMA );
    165165    return;
    166166    /*------------------------------------------------------------------------
    167167    *------------------------------------------------------------------------*/
    168168 invalid:
    169     softfloat_invalidF128M( zWPtr );
     169    softfloat_invalidF128M( zWPtr SOFTFLOAT_STATE_ARG_COMMA );
    170170    return;
    171171    /*------------------------------------------------------------------------

  • trunk/src/libs/softfloat-3e/source/f128M_eq.c

    r94480 r94558  
    4444#ifdef SOFTFLOAT_FAST_INT64
    4545
    46 bool f128M_eq( const float128_t *aPtr, const float128_t *bPtr )
     46bool f128M_eq( const float128_t *aPtr, const float128_t *bPtr SOFTFLOAT_STATE_DECL_COMMA )
    4747{
    4848
    49     return f128_eq( *aPtr, *bPtr );
     49    return f128_eq( *aPtr, *bPtr SOFTFLOAT_STATE_ARG_COMMA );
    5050
    5151}
    … …  
    5353#else
    5454
    55 bool f128M_eq( const float128_t *aPtr, const float128_t *bPtr )
     55bool f128M_eq( const float128_t *aPtr, const float128_t *bPtr SOFTFLOAT_STATE_DECL_COMMA )
    5656{
    5757    const uint32_t *aWPtr, *bWPtr;
    … …  
    9191        || f128M_isSignalingNaN( (const float128_t *) bWPtr )
    9292    ) {
    93         softfloat_raiseFlags( softfloat_flag_invalid );
     93        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    9494    }
    9595    return false;

  • trunk/src/libs/softfloat-3e/source/f128M_eq_signaling.c

    r94480 r94558  
    4444#ifdef SOFTFLOAT_FAST_INT64
    4545
    46 bool f128M_eq_signaling( const float128_t *aPtr, const float128_t *bPtr )
     46bool f128M_eq_signaling( const float128_t *aPtr, const float128_t *bPtr SOFTFLOAT_STATE_DECL_COMMA )
    4747{
    4848
    49     return f128_eq_signaling( *aPtr, *bPtr );
     49    return f128_eq_signaling( *aPtr, *bPtr SOFTFLOAT_STATE_ARG_COMMA );
    5050
    5151}
    … …  
    5353#else
    5454
    55 bool f128M_eq_signaling( const float128_t *aPtr, const float128_t *bPtr )
     55bool f128M_eq_signaling( const float128_t *aPtr, const float128_t *bPtr SOFTFLOAT_STATE_DECL_COMMA )
    5656{
    5757    const uint32_t *aWPtr, *bWPtr;
    … …  
    6363    bWPtr = (const uint32_t *) bPtr;
    6464    if ( softfloat_isNaNF128M( aWPtr ) || softfloat_isNaNF128M( bWPtr ) ) {
    65         softfloat_raiseFlags( softfloat_flag_invalid );
     65        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    6666        return false;
    6767    }

  • trunk/src/libs/softfloat-3e/source/f128M_le.c

    r94480 r94558  
    4343#ifdef SOFTFLOAT_FAST_INT64
    4444
    45 bool f128M_le( const float128_t *aPtr, const float128_t *bPtr )
     45bool f128M_le( const float128_t *aPtr, const float128_t *bPtr SOFTFLOAT_STATE_DECL_COMMA )
    4646{
    4747
    48     return f128_le( *aPtr, *bPtr );
     48    return f128_le( *aPtr, *bPtr SOFTFLOAT_STATE_ARG_COMMA );
    4949
    5050}
    … …  
    5252#else
    5353
    54 bool f128M_le( const float128_t *aPtr, const float128_t *bPtr )
     54bool f128M_le( const float128_t *aPtr, const float128_t *bPtr SOFTFLOAT_STATE_DECL_COMMA )
    5555{
    5656    const uint32_t *aWPtr, *bWPtr;
    … …  
    6262    bWPtr = (const uint32_t *) bPtr;
    6363    if ( softfloat_isNaNF128M( aWPtr ) || softfloat_isNaNF128M( bWPtr ) ) {
    64         softfloat_raiseFlags( softfloat_flag_invalid );
     64        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    6565        return false;
    6666    }

  • trunk/src/libs/softfloat-3e/source/f128M_le_quiet.c

    r94480 r94558  
    4444#ifdef SOFTFLOAT_FAST_INT64
    4545
    46 bool f128M_le_quiet( const float128_t *aPtr, const float128_t *bPtr )
     46bool f128M_le_quiet( const float128_t *aPtr, const float128_t *bPtr SOFTFLOAT_STATE_DECL_COMMA )
    4747{
    4848
    49     return f128_le_quiet( *aPtr, *bPtr );
     49    return f128_le_quiet( *aPtr, *bPtr SOFTFLOAT_STATE_ARG_COMMA );
    5050
    5151}
    … …  
    5353#else
    5454
    55 bool f128M_le_quiet( const float128_t *aPtr, const float128_t *bPtr )
     55bool f128M_le_quiet( const float128_t *aPtr, const float128_t *bPtr SOFTFLOAT_STATE_DECL_COMMA )
    5656{
    5757    const uint32_t *aWPtr, *bWPtr;
    … …  
    6464    if ( softfloat_isNaNF128M( aWPtr ) || softfloat_isNaNF128M( bWPtr ) ) {
    6565        if ( f128M_isSignalingNaN( aPtr ) || f128M_isSignalingNaN( bPtr ) ) {
    66             softfloat_raiseFlags( softfloat_flag_invalid );
     66            softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    6767        }
    6868        return false;

  • trunk/src/libs/softfloat-3e/source/f128M_lt.c

    r94480 r94558  
    4343#ifdef SOFTFLOAT_FAST_INT64
    4444
    45 bool f128M_lt( const float128_t *aPtr, const float128_t *bPtr )
     45bool f128M_lt( const float128_t *aPtr, const float128_t *bPtr SOFTFLOAT_STATE_DECL_COMMA )
    4646{
    4747
    48     return f128_lt( *aPtr, *bPtr );
     48    return f128_lt( *aPtr, *bPtr SOFTFLOAT_STATE_ARG_COMMA );
    4949
    5050}
    … …  
    5252#else
    5353
    54 bool f128M_lt( const float128_t *aPtr, const float128_t *bPtr )
     54bool f128M_lt( const float128_t *aPtr, const float128_t *bPtr SOFTFLOAT_STATE_DECL_COMMA )
    5555{
    5656    const uint32_t *aWPtr, *bWPtr;
    … …  
    6262    bWPtr = (const uint32_t *) bPtr;
    6363    if ( softfloat_isNaNF128M( aWPtr ) || softfloat_isNaNF128M( bWPtr ) ) {
    64         softfloat_raiseFlags( softfloat_flag_invalid );
     64        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    6565        return false;
    6666    }

  • trunk/src/libs/softfloat-3e/source/f128M_lt_quiet.c

    r94480 r94558  
    4444#ifdef SOFTFLOAT_FAST_INT64
    4545
    46 bool f128M_lt_quiet( const float128_t *aPtr, const float128_t *bPtr )
     46bool f128M_lt_quiet( const float128_t *aPtr, const float128_t *bPtr SOFTFLOAT_STATE_DECL_COMMA )
    4747{
    4848
    49     return f128_lt_quiet( *aPtr, *bPtr );
     49    return f128_lt_quiet( *aPtr, *bPtr SOFTFLOAT_STATE_ARG_COMMA );
    5050
    5151}
    … …  
    5353#else
    5454
    55 bool f128M_lt_quiet( const float128_t *aPtr, const float128_t *bPtr )
     55bool f128M_lt_quiet( const float128_t *aPtr, const float128_t *bPtr SOFTFLOAT_STATE_DECL_COMMA )
    5656{
    5757    const uint32_t *aWPtr, *bWPtr;
    … …  
    6464    if ( softfloat_isNaNF128M( aWPtr ) || softfloat_isNaNF128M( bWPtr ) ) {
    6565        if ( f128M_isSignalingNaN( aPtr ) || f128M_isSignalingNaN( bPtr ) ) {
    66             softfloat_raiseFlags( softfloat_flag_invalid );
     66            softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    6767        }
    6868        return false;

  • trunk/src/libs/softfloat-3e/source/f128M_mul.c

    r94480 r94558  
    4545
    4646void
    47  f128M_mul( const float128_t *aPtr, const float128_t *bPtr, float128_t *zPtr )
     47 f128M_mul( const float128_t *aPtr, const float128_t *bPtr, float128_t *zPtr SOFTFLOAT_STATE_DECL_COMMA )
    4848{
    4949
    50     *zPtr = f128_mul( *aPtr, *bPtr );
     50    *zPtr = f128_mul( *aPtr, *bPtr SOFTFLOAT_STATE_ARG_COMMA );
    5151
    5252}
    … …  
    5555
    5656void
    57  f128M_mul( const float128_t *aPtr, const float128_t *bPtr, float128_t *zPtr )
     57 f128M_mul( const float128_t *aPtr, const float128_t *bPtr, float128_t *zPtr SOFTFLOAT_STATE_DECL_COMMA )
    5858{
    5959    const uint32_t *aWPtr, *bWPtr;
    … …  
    8686    *------------------------------------------------------------------------*/
    8787    if ( (expA == 0x7FFF) || (expB == 0x7FFF) ) {
    88         if ( softfloat_tryPropagateNaNF128M( aWPtr, bWPtr, zWPtr ) ) return;
     88        if ( softfloat_tryPropagateNaNF128M( aWPtr, bWPtr, zWPtr SOFTFLOAT_STATE_ARG_COMMA ) ) return;
    8989        ptr = aWPtr;
    9090        if ( ! expA ) goto possiblyInvalid;
    … …  
    9797                              | ptr[indexWord( 4, 0 )])
    9898            ) {
    99                 softfloat_invalidF128M( zWPtr );
     99                softfloat_invalidF128M( zWPtr SOFTFLOAT_STATE_ARG_COMMA );
    100100                return;
    101101            }
    … …  
    141141    }
    142142    softfloat_shortShiftLeft160M( extSigZPtr, shiftDist, extSigZPtr );
    143     softfloat_roundPackMToF128M( signZ, expZ, extSigZPtr, zWPtr );
     143    softfloat_roundPackMToF128M( signZ, expZ, extSigZPtr, zWPtr SOFTFLOAT_STATE_ARG_COMMA );
    144144    return;
    145145    /*------------------------------------------------------------------------

  • trunk/src/libs/softfloat-3e/source/f128M_mulAdd.c

    r94480 r94558  
    4848     const float128_t *cPtr,
    4949     float128_t *zPtr
     50     SOFTFLOAT_STATE_DECL_COMMA
    5051 )
    5152{
    … …  
    6465    uiC64 = cWPtr[indexWord( 2, 1 )];
    6566    uiC0  = cWPtr[indexWord( 2, 0 )];
    66     *zPtr = softfloat_mulAddF128( uiA64, uiA0, uiB64, uiB0, uiC64, uiC0, 0 );
     67    *zPtr = softfloat_mulAddF128( uiA64, uiA0, uiB64, uiB0, uiC64, uiC0, 0 SOFTFLOAT_STATE_ARG_COMMA );
    6768
    6869}
    … …  
    7677     const float128_t *cPtr,
    7778     float128_t *zPtr
     79     SOFTFLOAT_STATE_DECL_COMMA
    7880 )
    7981{
    … …  
    8587        (uint32_t *) zPtr,
    8688        0
     89        SOFTFLOAT_STATE_ARG_COMMA
    8790    );
    8891

  • trunk/src/libs/softfloat-3e/source/f128M_rem.c

    r94480 r94558  
    4545
    4646void
    47  f128M_rem( const float128_t *aPtr, const float128_t *bPtr, float128_t *zPtr )
     47 f128M_rem( const float128_t *aPtr, const float128_t *bPtr, float128_t *zPtr SOFTFLOAT_STATE_DECL_COMMA )
    4848{
    4949
    50     *zPtr = f128_rem( *aPtr, *bPtr );
     50    *zPtr = f128_rem( *aPtr, *bPtr SOFTFLOAT_STATE_ARG_COMMA );
    5151
    5252}
    … …  
    5555
    5656void
    57  f128M_rem( const float128_t *aPtr, const float128_t *bPtr, float128_t *zPtr )
     57 f128M_rem( const float128_t *aPtr, const float128_t *bPtr, float128_t *zPtr SOFTFLOAT_STATE_DECL_COMMA )
    5858{
    5959    const uint32_t *aWPtr, *bWPtr;
    … …  
    8080    *------------------------------------------------------------------------*/
    8181    if ( (expA == 0x7FFF) || (expB == 0x7FFF) ) {
    82         if ( softfloat_tryPropagateNaNF128M( aWPtr, bWPtr, zWPtr ) ) return;
     82        if ( softfloat_tryPropagateNaNF128M( aWPtr, bWPtr, zWPtr SOFTFLOAT_STATE_ARG_COMMA ) ) return;
    8383        if ( expA == 0x7FFF ) goto invalid;
    8484        goto copyA;
    … …  
    162162    remPtr -= indexMultiwordLo( 5, 4 );
    163163    remPtr[indexWordHi( 5 )] = 0;
    164     softfloat_normRoundPackMToF128M( signRem, expB + 18, remPtr, zWPtr );
     164    softfloat_normRoundPackMToF128M( signRem, expB + 18, remPtr, zWPtr SOFTFLOAT_STATE_ARG_COMMA );
    165165    return;
    166166    /*------------------------------------------------------------------------
    167167    *------------------------------------------------------------------------*/
    168168 invalid:
    169     softfloat_invalidF128M( zWPtr );
     169    softfloat_invalidF128M( zWPtr SOFTFLOAT_STATE_ARG_COMMA );
    170170    return;
    171171    /*------------------------------------------------------------------------

  • trunk/src/libs/softfloat-3e/source/f128M_roundToInt.c

    r94480 r94558  
    5050     bool exact,
    5151     float128_t *zPtr
     52     SOFTFLOAT_STATE_DECL_COMMA
    5253 )
    5354{
    5455
    55     *zPtr = f128_roundToInt( *aPtr, roundingMode, exact );
     56    *zPtr = f128_roundToInt( *aPtr, roundingMode, exact SOFTFLOAT_STATE_ARG_COMMA );
    5657
    5758}
    … …  
    6566     bool exact,
    6667     float128_t *zPtr
     68     SOFTFLOAT_STATE_DECL_COMMA
    6769 )
    6870{
    … …  
    134136                                | aWPtr[indexWord( 4, 0 )]))
    135137        ) {
    136             softfloat_propagateNaNF128M( aWPtr, 0, zWPtr );
     138            softfloat_propagateNaNF128M( aWPtr, 0, zWPtr SOFTFLOAT_STATE_ARG_COMMA );
    137139            return;
    138140        }

  • trunk/src/libs/softfloat-3e/source/f128M_sqrt.c

    r94480 r94558  
    4444#ifdef SOFTFLOAT_FAST_INT64
    4545
    46 void f128M_sqrt( const float128_t *aPtr, float128_t *zPtr )
     46void f128M_sqrt( const float128_t *aPtr, float128_t *zPtr SOFTFLOAT_STATE_DECL_COMMA )
    4747{
    4848
    49     *zPtr = f128_sqrt( *aPtr );
     49    *zPtr = f128_sqrt( *aPtr SOFTFLOAT_STATE_ARG_COMMA );
    5050
    5151}
    … …  
    5353#else
    5454
    55 void f128M_sqrt( const float128_t *aPtr, float128_t *zPtr )
     55void f128M_sqrt( const float128_t *aPtr, float128_t *zPtr SOFTFLOAT_STATE_DECL_COMMA )
    5656{
    5757    const uint32_t *aWPtr;
    … …  
    8686                        | aWPtr[indexWord( 4, 0 )])
    8787        ) {
    88             softfloat_propagateNaNF128M( aWPtr, 0, zWPtr );
     88            softfloat_propagateNaNF128M( aWPtr, 0, zWPtr SOFTFLOAT_STATE_ARG_COMMA );
    8989            return;
    9090        }
    … …  
    208208        }
    209209    }
    210     softfloat_roundPackMToF128M( 0, expZ, y, zWPtr );
     210    softfloat_roundPackMToF128M( 0, expZ, y, zWPtr SOFTFLOAT_STATE_ARG_COMMA );
    211211    return;
    212212    /*------------------------------------------------------------------------
    213213    *------------------------------------------------------------------------*/
    214214 invalid:
    215     softfloat_invalidF128M( zWPtr );
     215    softfloat_invalidF128M( zWPtr SOFTFLOAT_STATE_ARG_COMMA );
    216216    return;
    217217    /*------------------------------------------------------------------------

  • trunk/src/libs/softfloat-3e/source/f128M_sub.c

    r94480 r94558  
    4444
    4545void
    46  f128M_sub( const float128_t *aPtr, const float128_t *bPtr, float128_t *zPtr )
     46 f128M_sub( const float128_t *aPtr, const float128_t *bPtr, float128_t *zPtr SOFTFLOAT_STATE_DECL_COMMA )
    4747{
    4848    const uint64_t *aWPtr, *bWPtr;
    … …  
    5454    float128_t
    5555        (*magsFuncPtr)(
    56             uint_fast64_t, uint_fast64_t, uint_fast64_t, uint_fast64_t, bool );
     56            uint_fast64_t, uint_fast64_t, uint_fast64_t, uint_fast64_t, bool SOFTFLOAT_STATE_DECL_COMMA );
    5757#endif
    5858
    … …  
    6767#if defined INLINE_LEVEL && (2 <= INLINE_LEVEL)
    6868    if ( signA == signB ) {
    69         *zPtr = softfloat_subMagsF128( uiA64, uiA0, uiB64, uiB0, signA );
     69        *zPtr = softfloat_subMagsF128( uiA64, uiA0, uiB64, uiB0, signA SOFTFLOAT_STATE_ARG_COMMA );
    7070    } else {
    71         *zPtr = softfloat_addMagsF128( uiA64, uiA0, uiB64, uiB0, signA );
     71        *zPtr = softfloat_addMagsF128( uiA64, uiA0, uiB64, uiB0, signA SOFTFLOAT_STATE_ARG_COMMA );
    7272    }
    7373#else
    7474    magsFuncPtr =
    7575        (signA == signB) ? softfloat_subMagsF128 : softfloat_addMagsF128;
    76     *zPtr = (*magsFuncPtr)( uiA64, uiA0, uiB64, uiB0, signA );
     76    *zPtr = (*magsFuncPtr)( uiA64, uiA0, uiB64, uiB0, signA SOFTFLOAT_STATE_ARG_COMMA );
    7777#endif
    7878
    … …  
    8282
    8383void
    84  f128M_sub( const float128_t *aPtr, const float128_t *bPtr, float128_t *zPtr )
     84 f128M_sub( const float128_t *aPtr, const float128_t *bPtr, float128_t *zPtr SOFTFLOAT_STATE_DECL_COMMA )
    8585{
    8686
    … …  
    9090        (uint32_t *) zPtr,
    9191        true
     92        SOFTFLOAT_STATE_ARG_COMMA
    9293    );
    9394

  • trunk/src/libs/softfloat-3e/source/f128M_to_extF80M.c

    r94480 r94558  
    4444#ifdef SOFTFLOAT_FAST_INT64
    4545
    46 void f128M_to_extF80M( const float128_t *aPtr, extFloat80_t *zPtr )
     46void f128M_to_extF80M( const float128_t *aPtr, extFloat80_t *zPtr SOFTFLOAT_STATE_DECL_COMMA )
    4747{
    4848
    49     *zPtr = f128_to_extF80( *aPtr );
     49    *zPtr = f128_to_extF80( *aPtr SOFTFLOAT_STATE_ARG_COMMA );
    5050
    5151}
    … …  
    5353#else
    5454
    55 void f128M_to_extF80M( const float128_t *aPtr, extFloat80_t *zPtr )
     55void f128M_to_extF80M( const float128_t *aPtr, extFloat80_t *zPtr SOFTFLOAT_STATE_DECL_COMMA )
    5656{
    5757    const uint32_t *aWPtr;
    … …  
    7676    if ( exp == 0x7FFF ) {
    7777        if ( softfloat_isNaNF128M( aWPtr ) ) {
    78             softfloat_f128MToCommonNaN( aWPtr, &commonNaN );
     78            softfloat_f128MToCommonNaN( aWPtr, &commonNaN SOFTFLOAT_STATE_ARG_COMMA );
    7979            softfloat_commonNaNToExtF80M( &commonNaN, zSPtr );
    8080            return;
    … …  
    9494    if ( sig[indexWord( 4, 0 )] ) sig[indexWord( 4, 1 )] |= 1;
    9595    softfloat_roundPackMToExtF80M(
    96         sign, exp, &sig[indexMultiwordHi( 4, 3 )], 80, zSPtr );
     96        sign, exp, &sig[indexMultiwordHi( 4, 3 )], 80, zSPtr SOFTFLOAT_STATE_ARG_COMMA );
    9797
    9898}

  • trunk/src/libs/softfloat-3e/source/f128M_to_f16.c

    r94480 r94558  
    4444#ifdef SOFTFLOAT_FAST_INT64
    4545
    46 float16_t f128M_to_f16( const float128_t *aPtr )
     46float16_t f128M_to_f16( const float128_t *aPtr SOFTFLOAT_STATE_DECL_COMMA )
    4747{
    4848
    49     return f128_to_f16( *aPtr );
     49    return f128_to_f16( *aPtr SOFTFLOAT_STATE_ARG_COMMA );
    5050
    5151}
    … …  
    5353#else
    5454
    55 float16_t f128M_to_f16( const float128_t *aPtr )
     55float16_t f128M_to_f16( const float128_t *aPtr SOFTFLOAT_STATE_DECL_COMMA )
    5656{
    5757    const uint32_t *aWPtr;
    … …  
    8181    if ( exp == 0x7FFF ) {
    8282        if ( frac32 ) {
    83             softfloat_f128MToCommonNaN( aWPtr, &commonNaN );
     83            softfloat_f128MToCommonNaN( aWPtr, &commonNaN SOFTFLOAT_STATE_ARG_COMMA );
    8484            uiZ = softfloat_commonNaNToF16UI( &commonNaN );
    8585        } else {
    … …  
    101101        if ( exp < -0x40 ) exp = -0x40;
    102102    }
    103     return softfloat_roundPackToF16( sign, exp, frac16 | 0x4000 );
     103    return softfloat_roundPackToF16( sign, exp, frac16 | 0x4000 SOFTFLOAT_STATE_ARG_COMMA );
    104104    /*------------------------------------------------------------------------
    105105    *------------------------------------------------------------------------*/

  • trunk/src/libs/softfloat-3e/source/f128M_to_f32.c

    r94480 r94558  
    4444#ifdef SOFTFLOAT_FAST_INT64
    4545
    46 float32_t f128M_to_f32( const float128_t *aPtr )
     46float32_t f128M_to_f32( const float128_t *aPtr SOFTFLOAT_STATE_DECL_COMMA )
    4747{
    4848
    49     return f128_to_f32( *aPtr );
     49    return f128_to_f32( *aPtr SOFTFLOAT_STATE_ARG_COMMA );
    5050
    5151}
    … …  
    5353#else
    5454
    55 float32_t f128M_to_f32( const float128_t *aPtr )
     55float32_t f128M_to_f32( const float128_t *aPtr SOFTFLOAT_STATE_DECL_COMMA )
    5656{
    5757    const uint32_t *aWPtr;
    … …  
    7777    if ( exp == 0x7FFF ) {
    7878        if ( frac64 ) {
    79             softfloat_f128MToCommonNaN( aWPtr, &commonNaN );
     79            softfloat_f128MToCommonNaN( aWPtr, &commonNaN SOFTFLOAT_STATE_ARG_COMMA );
    8080            uiZ = softfloat_commonNaNToF32UI( &commonNaN );
    8181        } else {
    … …  
    9797        if ( exp < -0x1000 ) exp = -0x1000;
    9898    }
    99     return softfloat_roundPackToF32( sign, exp, frac32 | 0x40000000 );
     99    return softfloat_roundPackToF32( sign, exp, frac32 | 0x40000000 SOFTFLOAT_STATE_ARG_COMMA );
    100100    /*------------------------------------------------------------------------
    101101    *------------------------------------------------------------------------*/

  • trunk/src/libs/softfloat-3e/source/f128M_to_f64.c

    r94480 r94558  
    4444#ifdef SOFTFLOAT_FAST_INT64
    4545
    46 float64_t f128M_to_f64( const float128_t *aPtr )
     46float64_t f128M_to_f64( const float128_t *aPtr SOFTFLOAT_STATE_DECL_COMMA )
    4747{
    4848
    49     return f128_to_f64( *aPtr );
     49    return f128_to_f64( *aPtr SOFTFLOAT_STATE_ARG_COMMA );
    5050
    5151}
    … …  
    5353#else
    5454
    55 float64_t f128M_to_f64( const float128_t *aPtr )
     55float64_t f128M_to_f64( const float128_t *aPtr SOFTFLOAT_STATE_DECL_COMMA )
    5656{
    5757    const uint32_t *aWPtr;
    … …  
    7676    if ( exp == 0x7FFF ) {
    7777        if ( frac64 || aWPtr[indexWord( 4, 1 )] | aWPtr[indexWord( 4, 0 )] ) {
    78             softfloat_f128MToCommonNaN( aWPtr, &commonNaN );
     78            softfloat_f128MToCommonNaN( aWPtr, &commonNaN SOFTFLOAT_STATE_ARG_COMMA );
    7979            uiZ = softfloat_commonNaNToF64UI( &commonNaN );
    8080        } else {
    … …  
    100100    return
    101101        softfloat_roundPackToF64(
    102             sign, exp, frac64 | UINT64_C( 0x4000000000000000 ) );
     102            sign, exp, frac64 | UINT64_C( 0x4000000000000000 ) SOFTFLOAT_STATE_ARG_COMMA );
    103103    /*------------------------------------------------------------------------
    104104    *------------------------------------------------------------------------*/

  • trunk/src/libs/softfloat-3e/source/f128M_to_i32.c

    r94480 r94558  
    4545
    4646int_fast32_t
    47  f128M_to_i32( const float128_t *aPtr, uint_fast8_t roundingMode, bool exact )
     47 f128M_to_i32( const float128_t *aPtr, uint_fast8_t roundingMode, bool exact SOFTFLOAT_STATE_DECL_COMMA )
    4848{
    4949
    50     return f128_to_i32( *aPtr, roundingMode, exact );
     50    return f128_to_i32( *aPtr, roundingMode, exact SOFTFLOAT_STATE_ARG_COMMA );
    5151
    5252}
    … …  
    5555
    5656int_fast32_t
    57  f128M_to_i32( const float128_t *aPtr, uint_fast8_t roundingMode, bool exact )
     57 f128M_to_i32( const float128_t *aPtr, uint_fast8_t roundingMode, bool exact SOFTFLOAT_STATE_DECL_COMMA )
    5858{
    5959    const uint32_t *aWPtr;
    … …  
    8181        sign = 1;
    8282#else
    83         softfloat_raiseFlags( softfloat_flag_invalid );
     83        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    8484        return i32_fromNaN;
    8585#endif
    … …  
    9191    shiftDist = 0x4023 - exp;
    9292    if ( 0 < shiftDist ) sig64 = softfloat_shiftRightJam64( sig64, shiftDist );
    93     return softfloat_roundToI32( sign, sig64, roundingMode, exact );
     93    return softfloat_roundToI32( sign, sig64, roundingMode, exact SOFTFLOAT_STATE_ARG_COMMA );
    9494
    9595}

  • trunk/src/libs/softfloat-3e/source/f128M_to_i32_r_minMag.c

    r94480 r94558  
    4444#ifdef SOFTFLOAT_FAST_INT64
    4545
    46 int_fast32_t f128M_to_i32_r_minMag( const float128_t *aPtr, bool exact )
     46int_fast32_t f128M_to_i32_r_minMag( const float128_t *aPtr, bool exact SOFTFLOAT_STATE_DECL_COMMA )
    4747{
    4848
    49     return f128_to_i32_r_minMag( *aPtr, exact );
     49    return f128_to_i32_r_minMag( *aPtr, exact SOFTFLOAT_STATE_ARG_COMMA );
    5050
    5151}
    … …  
    5353#else
    5454
    55 int_fast32_t f128M_to_i32_r_minMag( const float128_t *aPtr, bool exact )
     55int_fast32_t f128M_to_i32_r_minMag( const float128_t *aPtr, bool exact SOFTFLOAT_STATE_DECL_COMMA )
    5656{
    5757    const uint32_t *aWPtr;
    … …  
    9696    *------------------------------------------------------------------------*/
    9797 invalid:
    98     softfloat_raiseFlags( softfloat_flag_invalid );
     98    softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    9999    return
    100100        (exp == 0x7FFF) && sig64 ? i32_fromNaN

  • trunk/src/libs/softfloat-3e/source/f128M_to_i64.c

    r94480 r94558  
    4545
    4646int_fast64_t
    47  f128M_to_i64( const float128_t *aPtr, uint_fast8_t roundingMode, bool exact )
     47 f128M_to_i64( const float128_t *aPtr, uint_fast8_t roundingMode, bool exact SOFTFLOAT_STATE_DECL_COMMA )
    4848{
    4949
    50     return f128_to_i64( *aPtr, roundingMode, exact );
     50    return f128_to_i64( *aPtr, roundingMode, exact SOFTFLOAT_STATE_ARG_COMMA );
    5151
    5252}
    … …  
    5555
    5656int_fast64_t
    57  f128M_to_i64( const float128_t *aPtr, uint_fast8_t roundingMode, bool exact )
     57 f128M_to_i64( const float128_t *aPtr, uint_fast8_t roundingMode, bool exact SOFTFLOAT_STATE_DECL_COMMA )
    5858{
    5959    const uint32_t *aWPtr;
    … …  
    7676    shiftDist = 0x404F - exp;
    7777    if ( shiftDist < 17 ) {
    78         softfloat_raiseFlags( softfloat_flag_invalid );
     78        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    7979        return
    8080            (exp == 0x7FFF)
    … …  
    9595    return
    9696        softfloat_roundMToI64(
    97             sign, sig + indexMultiwordLo( 4, 3 ), roundingMode, exact );
     97            sign, sig + indexMultiwordLo( 4, 3 ), roundingMode, exact SOFTFLOAT_STATE_ARG_COMMA );
    9898
    9999}

  • trunk/src/libs/softfloat-3e/source/f128M_to_i64_r_minMag.c

    r94480 r94558  
    4444#ifdef SOFTFLOAT_FAST_INT64
    4545
    46 int_fast64_t f128M_to_i64_r_minMag( const float128_t *aPtr, bool exact )
     46int_fast64_t f128M_to_i64_r_minMag( const float128_t *aPtr, bool exact SOFTFLOAT_STATE_DECL_COMMA )
    4747{
    4848
    49     return f128_to_i64_r_minMag( *aPtr, exact );
     49    return f128_to_i64_r_minMag( *aPtr, exact SOFTFLOAT_STATE_ARG_COMMA );
    5050
    5151}
    … …  
    5353#else
    5454
    55 int_fast64_t f128M_to_i64_r_minMag( const float128_t *aPtr, bool exact )
     55int_fast64_t f128M_to_i64_r_minMag( const float128_t *aPtr, bool exact SOFTFLOAT_STATE_DECL_COMMA )
    5656{
    5757    const uint32_t *aWPtr;
    … …  
    110110    *------------------------------------------------------------------------*/
    111111 invalid:
    112     softfloat_raiseFlags( softfloat_flag_invalid );
     112    softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    113113    return
    114114        (exp == 0x7FFF)

  • trunk/src/libs/softfloat-3e/source/f128M_to_ui32.c

    r94480 r94558  
    4545
    4646uint_fast32_t
    47  f128M_to_ui32( const float128_t *aPtr, uint_fast8_t roundingMode, bool exact )
     47 f128M_to_ui32( const float128_t *aPtr, uint_fast8_t roundingMode, bool exact SOFTFLOAT_STATE_DECL_COMMA )
    4848{
    4949
    50     return f128_to_ui32( *aPtr, roundingMode, exact );
     50    return f128_to_ui32( *aPtr, roundingMode, exact SOFTFLOAT_STATE_ARG_COMMA );
    5151
    5252}
    … …  
    5555
    5656uint_fast32_t
    57  f128M_to_ui32( const float128_t *aPtr, uint_fast8_t roundingMode, bool exact )
     57 f128M_to_ui32( const float128_t *aPtr, uint_fast8_t roundingMode, bool exact SOFTFLOAT_STATE_DECL_COMMA )
    5858{
    5959    const uint32_t *aWPtr;
    … …  
    8181        sign = 1;
    8282#else
    83         softfloat_raiseFlags( softfloat_flag_invalid );
     83        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    8484        return ui32_fromNaN;
    8585#endif
    … …  
    9191    shiftDist = 0x4023 - exp;
    9292    if ( 0 < shiftDist ) sig64 = softfloat_shiftRightJam64( sig64, shiftDist );
    93     return softfloat_roundToUI32( sign, sig64, roundingMode, exact );
     93    return softfloat_roundToUI32( sign, sig64, roundingMode, exact SOFTFLOAT_STATE_ARG_COMMA );
    9494
    9595}

  • trunk/src/libs/softfloat-3e/source/f128M_to_ui32_r_minMag.c

    r94480 r94558  
    4444#ifdef SOFTFLOAT_FAST_INT64
    4545
    46 uint_fast32_t f128M_to_ui32_r_minMag( const float128_t *aPtr, bool exact )
     46uint_fast32_t f128M_to_ui32_r_minMag( const float128_t *aPtr, bool exact SOFTFLOAT_STATE_DECL_COMMA )
    4747{
    4848
    49     return f128_to_ui32_r_minMag( *aPtr, exact );
     49    return f128_to_ui32_r_minMag( *aPtr, exact SOFTFLOAT_STATE_ARG_COMMA );
    5050
    5151}
    … …  
    5353#else
    5454
    55 uint_fast32_t f128M_to_ui32_r_minMag( const float128_t *aPtr, bool exact )
     55uint_fast32_t f128M_to_ui32_r_minMag( const float128_t *aPtr, bool exact SOFTFLOAT_STATE_DECL_COMMA )
    5656{
    5757    const uint32_t *aWPtr;
    … …  
    8383    sign = signF128UI96( uiA96 );
    8484    if ( sign || (shiftDist < 17) ) {
    85         softfloat_raiseFlags( softfloat_flag_invalid );
     85        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    8686        return
    8787            (exp == 0x7FFF) && sig64 ? ui32_fromNaN

  • trunk/src/libs/softfloat-3e/source/f128M_to_ui64.c

    r94480 r94558  
    4545
    4646uint_fast64_t
    47  f128M_to_ui64( const float128_t *aPtr, uint_fast8_t roundingMode, bool exact )
     47 f128M_to_ui64( const float128_t *aPtr, uint_fast8_t roundingMode, bool exact SOFTFLOAT_STATE_DECL_COMMA )
    4848{
    4949
    50     return f128_to_ui64( *aPtr, roundingMode, exact );
     50    return f128_to_ui64( *aPtr, roundingMode, exact SOFTFLOAT_STATE_ARG_COMMA );
    5151
    5252}
    … …  
    5555
    5656uint_fast64_t
    57  f128M_to_ui64( const float128_t *aPtr, uint_fast8_t roundingMode, bool exact )
     57 f128M_to_ui64( const float128_t *aPtr, uint_fast8_t roundingMode, bool exact SOFTFLOAT_STATE_DECL_COMMA )
    5858{
    5959    const uint32_t *aWPtr;
    … …  
    7676    shiftDist = 0x404F - exp;
    7777    if ( shiftDist < 17 ) {
    78         softfloat_raiseFlags( softfloat_flag_invalid );
     78        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    7979        return
    8080            (exp == 0x7FFF)
    … …  
    9595    return
    9696        softfloat_roundMToUI64(
    97             sign, sig + indexMultiwordLo( 4, 3 ), roundingMode, exact );
     97            sign, sig + indexMultiwordLo( 4, 3 ), roundingMode, exact SOFTFLOAT_STATE_ARG_COMMA);
    9898
    9999}

  • trunk/src/libs/softfloat-3e/source/f128M_to_ui64_r_minMag.c

    r94480 r94558  
    4444#ifdef SOFTFLOAT_FAST_INT64
    4545
    46 uint_fast64_t f128M_to_ui64_r_minMag( const float128_t *aPtr, bool exact )
     46uint_fast64_t f128M_to_ui64_r_minMag( const float128_t *aPtr, bool exact SOFTFLOAT_STATE_DECL_COMMA )
    4747{
    4848
    49     return f128_to_ui64_r_minMag( *aPtr, exact );
     49    return f128_to_ui64_r_minMag( *aPtr, exact SOFTFLOAT_STATE_ARG_COMMA );
    5050
    5151}
    … …  
    5353#else
    5454
    55 uint_fast64_t f128M_to_ui64_r_minMag( const float128_t *aPtr, bool exact )
     55uint_fast64_t f128M_to_ui64_r_minMag( const float128_t *aPtr, bool exact SOFTFLOAT_STATE_DECL_COMMA )
    5656{
    5757    const uint32_t *aWPtr;
    … …  
    100100    *------------------------------------------------------------------------*/
    101101 invalid:
    102     softfloat_raiseFlags( softfloat_flag_invalid );
     102    softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    103103    return
    104104        (exp == 0x7FFF)

  • trunk/src/libs/softfloat-3e/source/f128_add.c

    r94480 r94558  
    4141#include "softfloat.h"
    4242
    43 float128_t f128_add( float128_t a, float128_t b )
     43float128_t f128_add( float128_t a, float128_t b SOFTFLOAT_STATE_DECL_COMMA )
    4444{
    4545    union ui128_f128 uA;
    … …  
    5252    float128_t
    5353        (*magsFuncPtr)(
    54             uint_fast64_t, uint_fast64_t, uint_fast64_t, uint_fast64_t, bool );
     54            uint_fast64_t, uint_fast64_t, uint_fast64_t, uint_fast64_t, bool SOFTFLOAT_STATE_DECL_COMMA );
    5555#endif
    5656
    … …  
    6565#if defined INLINE_LEVEL && (2 <= INLINE_LEVEL)
    6666    if ( signA == signB ) {
    67         return softfloat_addMagsF128( uiA64, uiA0, uiB64, uiB0, signA );
     67        return softfloat_addMagsF128( uiA64, uiA0, uiB64, uiB0, signA SOFTFLOAT_STATE_ARG_COMMA );
    6868    } else {
    69         return softfloat_subMagsF128( uiA64, uiA0, uiB64, uiB0, signA );
     69        return softfloat_subMagsF128( uiA64, uiA0, uiB64, uiB0, signA SOFTFLOAT_STATE_ARG_COMMA );
    7070    }
    7171#else
    7272    magsFuncPtr =
    7373        (signA == signB) ? softfloat_addMagsF128 : softfloat_subMagsF128;
    74     return (*magsFuncPtr)( uiA64, uiA0, uiB64, uiB0, signA );
     74    return (*magsFuncPtr)( uiA64, uiA0, uiB64, uiB0, signA SOFTFLOAT_STATE_ARG_COMMA );
    7575#endif
    7676

  • trunk/src/libs/softfloat-3e/source/f128_div.c

    r94480 r94558  
    4242#include "softfloat.h"
    4343
    44 float128_t f128_div( float128_t a, float128_t b )
     44float128_t f128_div( float128_t a, float128_t b SOFTFLOAT_STATE_DECL_COMMA )
    4545{
    4646    union ui128_f128 uA;
    … …  
    104104        if ( ! (sigB.v64 | sigB.v0) ) {
    105105            if ( ! (expA | sigA.v64 | sigA.v0) ) goto invalid;
    106             softfloat_raiseFlags( softfloat_flag_infinite );
     106            softfloat_raiseFlags( softfloat_flag_infinite SOFTFLOAT_STATE_ARG_COMMA );
    107107            goto infinity;
    108108        }
    … …  
    168168        );
    169169    return
    170         softfloat_roundPackToF128( signZ, expZ, sigZ.v64, sigZ.v0, sigZExtra );
     170        softfloat_roundPackToF128( signZ, expZ, sigZ.v64, sigZ.v0, sigZExtra SOFTFLOAT_STATE_ARG_COMMA );
    171171    /*------------------------------------------------------------------------
    172172    *------------------------------------------------------------------------*/
    173173 propagateNaN:
    174     uiZ = softfloat_propagateNaNF128UI( uiA64, uiA0, uiB64, uiB0 );
     174    uiZ = softfloat_propagateNaNF128UI( uiA64, uiA0, uiB64, uiB0 SOFTFLOAT_STATE_ARG_COMMA );
    175175    goto uiZ;
    176176    /*------------------------------------------------------------------------
    177177    *------------------------------------------------------------------------*/
    178178 invalid:
    179     softfloat_raiseFlags( softfloat_flag_invalid );
     179    softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    180180    uiZ.v64 = defaultNaNF128UI64;
    181181    uiZ.v0  = defaultNaNF128UI0;

  • trunk/src/libs/softfloat-3e/source/f128_eq.c

    r94480 r94558  
    4242#include "softfloat.h"
    4343
    44 bool f128_eq( float128_t a, float128_t b )
     44bool f128_eq( float128_t a, float128_t b SOFTFLOAT_STATE_DECL_COMMA )
    4545{
    4646    union ui128_f128 uA;
    … …  
    6060            || softfloat_isSigNaNF128UI( uiB64, uiB0 )
    6161        ) {
    62             softfloat_raiseFlags( softfloat_flag_invalid );
     62            softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    6363        }
    6464        return false;

  • trunk/src/libs/softfloat-3e/source/f128_eq_signaling.c

    r94480 r94558  
    4141#include "softfloat.h"
    4242
    43 bool f128_eq_signaling( float128_t a, float128_t b )
     43bool f128_eq_signaling( float128_t a, float128_t b SOFTFLOAT_STATE_DECL_COMMA )
    4444{
    4545    union ui128_f128 uA;
    … …  
    5555    uiB0  = uB.ui.v0;
    5656    if ( isNaNF128UI( uiA64, uiA0 ) || isNaNF128UI( uiB64, uiB0 ) ) {
    57         softfloat_raiseFlags( softfloat_flag_invalid );
     57        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    5858        return false;
    5959    }

  • trunk/src/libs/softfloat-3e/source/f128_le.c

    r94480 r94558  
    4141#include "softfloat.h"
    4242
    43 bool f128_le( float128_t a, float128_t b )
     43bool f128_le( float128_t a, float128_t b SOFTFLOAT_STATE_DECL_COMMA )
    4444{
    4545    union ui128_f128 uA;
    … …  
    5656    uiB0  = uB.ui.v0;
    5757    if ( isNaNF128UI( uiA64, uiA0 ) || isNaNF128UI( uiB64, uiB0 ) ) {
    58         softfloat_raiseFlags( softfloat_flag_invalid );
     58        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    5959        return false;
    6060    }

  • trunk/src/libs/softfloat-3e/source/f128_le_quiet.c

    r94480 r94558  
    4242#include "softfloat.h"
    4343
    44 bool f128_le_quiet( float128_t a, float128_t b )
     44bool f128_le_quiet( float128_t a, float128_t b SOFTFLOAT_STATE_DECL_COMMA )
    4545{
    4646    union ui128_f128 uA;
    … …  
    6161            || softfloat_isSigNaNF128UI( uiB64, uiB0 )
    6262        ) {
    63             softfloat_raiseFlags( softfloat_flag_invalid );
     63            softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    6464        }
    6565        return false;

  • trunk/src/libs/softfloat-3e/source/f128_lt.c

    r94480 r94558  
    4141#include "softfloat.h"
    4242
    43 bool f128_lt( float128_t a, float128_t b )
     43bool f128_lt( float128_t a, float128_t b SOFTFLOAT_STATE_DECL_COMMA )
    4444{
    4545    union ui128_f128 uA;
    … …  
    5656    uiB0  = uB.ui.v0;
    5757    if ( isNaNF128UI( uiA64, uiA0 ) || isNaNF128UI( uiB64, uiB0 ) ) {
    58         softfloat_raiseFlags( softfloat_flag_invalid );
     58        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    5959        return false;
    6060    }

  • trunk/src/libs/softfloat-3e/source/f128_lt_quiet.c

    r94480 r94558  
    4242#include "softfloat.h"
    4343
    44 bool f128_lt_quiet( float128_t a, float128_t b )
     44bool f128_lt_quiet( float128_t a, float128_t b SOFTFLOAT_STATE_DECL_COMMA )
    4545{
    4646    union ui128_f128 uA;
    … …  
    6161            || softfloat_isSigNaNF128UI( uiB64, uiB0 )
    6262        ) {
    63             softfloat_raiseFlags( softfloat_flag_invalid );
     63            softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    6464        }
    6565        return false;

  • trunk/src/libs/softfloat-3e/source/f128_mul.c

    r94480 r94558  
    4242#include "softfloat.h"
    4343
    44 float128_t f128_mul( float128_t a, float128_t b )
     44float128_t f128_mul( float128_t a, float128_t b SOFTFLOAT_STATE_DECL_COMMA )
    4545{
    4646    union ui128_f128 uA;
    … …  
    133133    }
    134134    return
    135         softfloat_roundPackToF128( signZ, expZ, sigZ.v64, sigZ.v0, sigZExtra );
     135        softfloat_roundPackToF128( signZ, expZ, sigZ.v64, sigZ.v0, sigZExtra SOFTFLOAT_STATE_ARG_COMMA );
    136136    /*------------------------------------------------------------------------
    137137    *------------------------------------------------------------------------*/
    138138 propagateNaN:
    139     uiZ = softfloat_propagateNaNF128UI( uiA64, uiA0, uiB64, uiB0 );
     139    uiZ = softfloat_propagateNaNF128UI( uiA64, uiA0, uiB64, uiB0 SOFTFLOAT_STATE_ARG_COMMA );
    140140    goto uiZ;
    141141    /*------------------------------------------------------------------------
    … …  
    143143 infArg:
    144144    if ( ! magBits ) {
    145         softfloat_raiseFlags( softfloat_flag_invalid );
     145        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    146146        uiZ.v64 = defaultNaNF128UI64;
    147147        uiZ.v0  = defaultNaNF128UI0;

  • trunk/src/libs/softfloat-3e/source/f128_mulAdd.c

    r94480 r94558  
    4040#include "softfloat.h"
    4141
    42 float128_t f128_mulAdd( float128_t a, float128_t b, float128_t c )
     42float128_t f128_mulAdd( float128_t a, float128_t b, float128_t c SOFTFLOAT_STATE_DECL_COMMA )
    4343{
    4444    union ui128_f128 uA;
    … …  
    5858    uiC64 = uC.ui.v64;
    5959    uiC0  = uC.ui.v0;
    60     return softfloat_mulAddF128( uiA64, uiA0, uiB64, uiB0, uiC64, uiC0, 0 );
     60    return softfloat_mulAddF128( uiA64, uiA0, uiB64, uiB0, uiC64, uiC0, 0 SOFTFLOAT_STATE_ARG_COMMA );
    6161
    6262}

  • trunk/src/libs/softfloat-3e/source/f128_rem.c

    r94480 r94558  
    4242#include "softfloat.h"
    4343
    44 float128_t f128_rem( float128_t a, float128_t b )
     44float128_t f128_rem( float128_t a, float128_t b SOFTFLOAT_STATE_DECL_COMMA )
    4545{
    4646    union ui128_f128 uA;
    … …  
    171171        rem = softfloat_sub128( 0, 0, rem.v64, rem.v0 );
    172172    }
    173     return softfloat_normRoundPackToF128( signRem, expB - 1, rem.v64, rem.v0 );
     173    return softfloat_normRoundPackToF128( signRem, expB - 1, rem.v64, rem.v0 SOFTFLOAT_STATE_ARG_COMMA );
    174174    /*------------------------------------------------------------------------
    175175    *------------------------------------------------------------------------*/
    176176 propagateNaN:
    177     uiZ = softfloat_propagateNaNF128UI( uiA64, uiA0, uiB64, uiB0 );
     177    uiZ = softfloat_propagateNaNF128UI( uiA64, uiA0, uiB64, uiB0 SOFTFLOAT_STATE_ARG_COMMA );
    178178    goto uiZ;
    179179    /*------------------------------------------------------------------------
    180180    *------------------------------------------------------------------------*/
    181181 invalid:
    182     softfloat_raiseFlags( softfloat_flag_invalid );
     182    softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    183183    uiZ.v64 = defaultNaNF128UI64;
    184184    uiZ.v0  = defaultNaNF128UI0;

  • trunk/src/libs/softfloat-3e/source/f128_roundToInt.c

    r94548 r94558  
    4444
    4545float128_t
    46  f128_roundToInt( float128_t a, uint_fast8_t roundingMode, bool exact )
     46 f128_roundToInt( float128_t a, uint_fast8_t roundingMode, bool exact SOFTFLOAT_STATE_DECL_COMMA )
    4747{
    4848    union ui128_f128 uA;
    … …  
    6868        if ( 0x406F <= exp ) {
    6969            if ( (exp == 0x7FFF) && (fracF128UI64( uiA64 ) | uiA0) ) {
    70                 uiZ = softfloat_propagateNaNF128UI( uiA64, uiA0, 0, 0 );
     70                uiZ = softfloat_propagateNaNF128UI( uiA64, uiA0, 0, 0 SOFTFLOAT_STATE_ARG_COMMA );
    7171                goto uiZ;
    7272            }

  • trunk/src/libs/softfloat-3e/source/f128_sqrt.c

    r94480 r94558  
    4242#include "softfloat.h"
    4343
    44 float128_t f128_sqrt( float128_t a )
     44float128_t f128_sqrt( float128_t a SOFTFLOAT_STATE_DECL_COMMA )
    4545{
    4646    union ui128_f128 uA;
    … …  
    7474    if ( expA == 0x7FFF ) {
    7575        if ( sigA.v64 | sigA.v0 ) {
    76             uiZ = softfloat_propagateNaNF128UI( uiA64, uiA0, 0, 0 );
     76            uiZ = softfloat_propagateNaNF128UI( uiA64, uiA0, 0, 0 SOFTFLOAT_STATE_ARG_COMMA );
    7777            goto uiZ;
    7878        }
    … …  
    187187        }
    188188    }
    189     return softfloat_roundPackToF128( 0, expZ, sigZ.v64, sigZ.v0, sigZExtra );
     189    return softfloat_roundPackToF128( 0, expZ, sigZ.v64, sigZ.v0, sigZExtra SOFTFLOAT_STATE_ARG_COMMA );
    190190    /*------------------------------------------------------------------------
    191191    *------------------------------------------------------------------------*/
    192192 invalid:
    193     softfloat_raiseFlags( softfloat_flag_invalid );
     193    softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    194194    uiZ.v64 = defaultNaNF128UI64;
    195195    uiZ.v0  = defaultNaNF128UI0;

  • trunk/src/libs/softfloat-3e/source/f128_sub.c

    r94480 r94558  
    4141#include "softfloat.h"
    4242
    43 float128_t f128_sub( float128_t a, float128_t b )
     43float128_t f128_sub( float128_t a, float128_t b SOFTFLOAT_STATE_DECL_COMMA )
    4444{
    4545    union ui128_f128 uA;
    … …  
    5252    float128_t
    5353        (*magsFuncPtr)(
    54             uint_fast64_t, uint_fast64_t, uint_fast64_t, uint_fast64_t, bool );
     54            uint_fast64_t, uint_fast64_t, uint_fast64_t, uint_fast64_t, bool SOFTFLOAT_STATE_DECL_COMMA );
    5555#endif
    5656
    … …  
    6565#if defined INLINE_LEVEL && (2 <= INLINE_LEVEL)
    6666    if ( signA == signB ) {
    67         return softfloat_subMagsF128( uiA64, uiA0, uiB64, uiB0, signA );
     67        return softfloat_subMagsF128( uiA64, uiA0, uiB64, uiB0, signA SOFTFLOAT_STATE_ARG_COMMA );
    6868    } else {
    69         return softfloat_addMagsF128( uiA64, uiA0, uiB64, uiB0, signA );
     69        return softfloat_addMagsF128( uiA64, uiA0, uiB64, uiB0, signA SOFTFLOAT_STATE_ARG_COMMA );
    7070    }
    7171#else
    7272    magsFuncPtr =
    7373        (signA == signB) ? softfloat_subMagsF128 : softfloat_addMagsF128;
    74     return (*magsFuncPtr)( uiA64, uiA0, uiB64, uiB0, signA );
     74    return (*magsFuncPtr)( uiA64, uiA0, uiB64, uiB0, signA SOFTFLOAT_STATE_ARG_COMMA );
    7575#endif
    7676

  • trunk/src/libs/softfloat-3e/source/f128_to_extF80.c

    r94480 r94558  
    4242#include "softfloat.h"
    4343
    44 extFloat80_t f128_to_extF80( float128_t a )
     44extFloat80_t f128_to_extF80( float128_t a SOFTFLOAT_STATE_DECL_COMMA )
    4545{
    4646    union ui128_f128 uA;
    … …  
    7070    if ( exp == 0x7FFF ) {
    7171        if ( frac64 | frac0 ) {
    72             softfloat_f128UIToCommonNaN( uiA64, uiA0, &commonNaN );
     72            softfloat_f128UIToCommonNaN( uiA64, uiA0, &commonNaN SOFTFLOAT_STATE_ARG_COMMA );
    7373            uiZ = softfloat_commonNaNToExtF80UI( &commonNaN );
    7474            uiZ64 = uiZ.v64;
    … …  
    9898        softfloat_shortShiftLeft128(
    9999            frac64 | UINT64_C( 0x0001000000000000 ), frac0, 15 );
    100     return softfloat_roundPackToExtF80( sign, exp, sig128.v64, sig128.v0, 80 );
     100    return softfloat_roundPackToExtF80( sign, exp, sig128.v64, sig128.v0, 80 SOFTFLOAT_STATE_ARG_COMMA );
    101101    /*------------------------------------------------------------------------
    102102    *------------------------------------------------------------------------*/

  • trunk/src/libs/softfloat-3e/source/f128_to_f16.c

    r94480 r94558  
    4242#include "softfloat.h"
    4343
    44 float16_t f128_to_f16( float128_t a )
     44float16_t f128_to_f16( float128_t a SOFTFLOAT_STATE_DECL_COMMA )
    4545{
    4646    union ui128_f128 uA;
    … …  
    6565    if ( exp == 0x7FFF ) {
    6666        if ( frac64 ) {
    67             softfloat_f128UIToCommonNaN( uiA64, uiA0, &commonNaN );
     67            softfloat_f128UIToCommonNaN( uiA64, uiA0, &commonNaN SOFTFLOAT_STATE_ARG_COMMA );
    6868            uiZ = softfloat_commonNaNToF16UI( &commonNaN );
    6969        } else {
    … …  
    8585        if ( exp < -0x40 ) exp = -0x40;
    8686    }
    87     return softfloat_roundPackToF16( sign, exp, frac16 | 0x4000 );
     87    return softfloat_roundPackToF16( sign, exp, frac16 | 0x4000 SOFTFLOAT_STATE_ARG_COMMA );
    8888    /*------------------------------------------------------------------------
    8989    *------------------------------------------------------------------------*/

  • trunk/src/libs/softfloat-3e/source/f128_to_f32.c

    r94480 r94558  
    4242#include "softfloat.h"
    4343
    44 float32_t f128_to_f32( float128_t a )
     44float32_t f128_to_f32( float128_t a SOFTFLOAT_STATE_DECL_COMMA )
    4545{
    4646    union ui128_f128 uA;
    … …  
    6565    if ( exp == 0x7FFF ) {
    6666        if ( frac64 ) {
    67             softfloat_f128UIToCommonNaN( uiA64, uiA0, &commonNaN );
     67            softfloat_f128UIToCommonNaN( uiA64, uiA0, &commonNaN SOFTFLOAT_STATE_ARG_COMMA );
    6868            uiZ = softfloat_commonNaNToF32UI( &commonNaN );
    6969        } else {
    … …  
    8585        if ( exp < -0x1000 ) exp = -0x1000;
    8686    }
    87     return softfloat_roundPackToF32( sign, exp, frac32 | 0x40000000 );
     87    return softfloat_roundPackToF32( sign, exp, frac32 | 0x40000000 SOFTFLOAT_STATE_ARG_COMMA );
    8888    /*------------------------------------------------------------------------
    8989    *------------------------------------------------------------------------*/

  • trunk/src/libs/softfloat-3e/source/f128_to_f64.c

    r94480 r94558  
    4242#include "softfloat.h"
    4343
    44 float64_t f128_to_f64( float128_t a )
     44float64_t f128_to_f64( float128_t a SOFTFLOAT_STATE_DECL_COMMA )
    4545{
    4646    union ui128_f128 uA;
    … …  
    6767    if ( exp == 0x7FFF ) {
    6868        if ( frac64 | frac0 ) {
    69             softfloat_f128UIToCommonNaN( uiA64, uiA0, &commonNaN );
     69            softfloat_f128UIToCommonNaN( uiA64, uiA0, &commonNaN SOFTFLOAT_STATE_ARG_COMMA );
    7070            uiZ = softfloat_commonNaNToF64UI( &commonNaN );
    7171        } else {
    … …  
    9090    return
    9191        softfloat_roundPackToF64(
    92             sign, exp, frac64 | UINT64_C( 0x4000000000000000 ) );
     92            sign, exp, frac64 | UINT64_C( 0x4000000000000000 ) SOFTFLOAT_STATE_ARG_COMMA );
    9393    /*------------------------------------------------------------------------
    9494    *------------------------------------------------------------------------*/

  • trunk/src/libs/softfloat-3e/source/f128_to_i32.c

    r94480 r94558  
    4242#include "softfloat.h"
    4343
    44 int_fast32_t f128_to_i32( float128_t a, uint_fast8_t roundingMode, bool exact )
     44int_fast32_t f128_to_i32( float128_t a, uint_fast8_t roundingMode, bool exact SOFTFLOAT_STATE_DECL_COMMA )
    4545{
    4646    union ui128_f128 uA;
    … …  
    6969        sign = 1;
    7070#else
    71         softfloat_raiseFlags( softfloat_flag_invalid );
     71        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    7272        return i32_fromNaN;
    7373#endif
    … …  
    8080    shiftDist = 0x4023 - exp;
    8181    if ( 0 < shiftDist ) sig64 = softfloat_shiftRightJam64( sig64, shiftDist );
    82     return softfloat_roundToI32( sign, sig64, roundingMode, exact );
     82    return softfloat_roundToI32( sign, sig64, roundingMode, exact SOFTFLOAT_STATE_ARG_COMMA );
    8383
    8484}

  • trunk/src/libs/softfloat-3e/source/f128_to_i32_r_minMag.c

    r94480 r94558  
    4242#include "softfloat.h"
    4343
    44 int_fast32_t f128_to_i32_r_minMag( float128_t a, bool exact )
     44int_fast32_t f128_to_i32_r_minMag( float128_t a, bool exact SOFTFLOAT_STATE_DECL_COMMA )
    4545{
    4646    union ui128_f128 uA;
    … …  
    8181            return -0x7FFFFFFF - 1;
    8282        }
    83         softfloat_raiseFlags( softfloat_flag_invalid );
     83        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    8484        return
    8585            (exp == 0x7FFF) && sig64 ? i32_fromNaN

  • trunk/src/libs/softfloat-3e/source/f128_to_i64.c

    r94480 r94558  
    4242#include "softfloat.h"
    4343
    44 int_fast64_t f128_to_i64( float128_t a, uint_fast8_t roundingMode, bool exact )
     44int_fast64_t f128_to_i64( float128_t a, uint_fast8_t roundingMode, bool exact SOFTFLOAT_STATE_DECL_COMMA )
    4545{
    4646    union ui128_f128 uA;
    … …  
    6969        *--------------------------------------------------------------------*/
    7070        if ( shiftDist < -15 ) {
    71             softfloat_raiseFlags( softfloat_flag_invalid );
     71            softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    7272            return
    7373                (exp == 0x7FFF) && (sig64 | sig0) ? i64_fromNaN
    … …  
    9090        sig0  = sigExtra.extra;
    9191    }
    92     return softfloat_roundToI64( sign, sig64, sig0, roundingMode, exact );
     92    return softfloat_roundToI64( sign, sig64, sig0, roundingMode, exact SOFTFLOAT_STATE_ARG_COMMA );
    9393
    9494}

  • trunk/src/libs/softfloat-3e/source/f128_to_i64_r_minMag.c

    r94480 r94558  
    4242#include "softfloat.h"
    4343
    44 int_fast64_t f128_to_i64_r_minMag( float128_t a, bool exact )
     44int_fast64_t f128_to_i64_r_minMag( float128_t a, bool exact SOFTFLOAT_STATE_DECL_COMMA )
    4545{
    4646    union ui128_f128 uA;
    … …  
    7878                return -INT64_C( 0x7FFFFFFFFFFFFFFF ) - 1;
    7979            }
    80             softfloat_raiseFlags( softfloat_flag_invalid );
     80            softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    8181            return
    8282                (exp == 0x7FFF) && (sig64 | sig0) ? i64_fromNaN

  • trunk/src/libs/softfloat-3e/source/f128_to_ui32.c

    r94480 r94558  
    4343
    4444uint_fast32_t
    45  f128_to_ui32( float128_t a, uint_fast8_t roundingMode, bool exact )
     45 f128_to_ui32( float128_t a, uint_fast8_t roundingMode, bool exact SOFTFLOAT_STATE_DECL_COMMA )
    4646{
    4747    union ui128_f128 uA;
    … …  
    6969        sign = 1;
    7070#else
    71         softfloat_raiseFlags( softfloat_flag_invalid );
     71        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    7272        return ui32_fromNaN;
    7373#endif
    … …  
    8181        sig64 = softfloat_shiftRightJam64( sig64, shiftDist );
    8282    }
    83     return softfloat_roundToUI32( sign, sig64, roundingMode, exact );
     83    return softfloat_roundToUI32( sign, sig64, roundingMode, exact SOFTFLOAT_STATE_ARG_COMMA );
    8484
    8585}

  • trunk/src/libs/softfloat-3e/source/f128_to_ui32_r_minMag.c

    r94480 r94558  
    4242#include "softfloat.h"
    4343
    44 uint_fast32_t f128_to_ui32_r_minMag( float128_t a, bool exact )
     44uint_fast32_t f128_to_ui32_r_minMag( float128_t a, bool exact SOFTFLOAT_STATE_DECL_COMMA )
    4545{
    4646    union ui128_f128 uA;
    … …  
    7272    sign = signF128UI64( uiA64 );
    7373    if ( sign || (shiftDist < 17) ) {
    74         softfloat_raiseFlags( softfloat_flag_invalid );
     74        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    7575        return
    7676            (exp == 0x7FFF) && sig64 ? ui32_fromNaN

  • trunk/src/libs/softfloat-3e/source/f128_to_ui64.c

    r94480 r94558  
    4343
    4444uint_fast64_t
    45  f128_to_ui64( float128_t a, uint_fast8_t roundingMode, bool exact )
     45 f128_to_ui64( float128_t a, uint_fast8_t roundingMode, bool exact SOFTFLOAT_STATE_DECL_COMMA )
    4646{
    4747    union ui128_f128 uA;
    … …  
    7070        *--------------------------------------------------------------------*/
    7171        if ( shiftDist < -15 ) {
    72             softfloat_raiseFlags( softfloat_flag_invalid );
     72            softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    7373            return
    7474                (exp == 0x7FFF) && (sig64 | sig0) ? ui64_fromNaN
    … …  
    9191        sig0  = sigExtra.extra;
    9292    }
    93     return softfloat_roundToUI64( sign, sig64, sig0, roundingMode, exact );
     93    return softfloat_roundToUI64( sign, sig64, sig0, roundingMode, exact SOFTFLOAT_STATE_ARG_COMMA );
    9494
    9595}

  • trunk/src/libs/softfloat-3e/source/f128_to_ui64_r_minMag.c

    r94480 r94558  
    4242#include "softfloat.h"
    4343
    44 uint_fast64_t f128_to_ui64_r_minMag( float128_t a, bool exact )
     44uint_fast64_t f128_to_ui64_r_minMag( float128_t a, bool exact SOFTFLOAT_STATE_DECL_COMMA )
    4545{
    4646    union ui128_f128 uA;
    … …  
    9797    *------------------------------------------------------------------------*/
    9898 invalid:
    99     softfloat_raiseFlags( softfloat_flag_invalid );
     99    softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    100100    return
    101101        (exp == 0x7FFF) && (sig64 | sig0) ? ui64_fromNaN

  • trunk/src/libs/softfloat-3e/source/f16_add.c

    r94480 r94558  
    4141#include "softfloat.h"
    4242
    43 float16_t f16_add( float16_t a, float16_t b )
     43float16_t f16_add( float16_t a, float16_t b SOFTFLOAT_STATE_DECL_COMMA )
    4444{
    4545    union ui16_f16 uA;
    … …  
    4848    uint_fast16_t uiB;
    4949#if ! defined INLINE_LEVEL || (INLINE_LEVEL < 1)
    50     float16_t (*magsFuncPtr)( uint_fast16_t, uint_fast16_t );
     50    float16_t (*magsFuncPtr)( uint_fast16_t, uint_fast16_t SOFTFLOAT_STATE_DECL_COMMA );
    5151#endif
    5252
    … …  
    5757#if defined INLINE_LEVEL && (1 <= INLINE_LEVEL)
    5858    if ( signF16UI( uiA ^ uiB ) ) {
    59         return softfloat_subMagsF16( uiA, uiB );
     59        return softfloat_subMagsF16( uiA, uiB SOFTFLOAT_STATE_ARG_COMMA );
    6060    } else {
    61         return softfloat_addMagsF16( uiA, uiB );
     61        return softfloat_addMagsF16( uiA, uiB SOFTFLOAT_STATE_ARG_COMMA );
    6262    }
    6363#else
    6464    magsFuncPtr =
    6565        signF16UI( uiA ^ uiB ) ? softfloat_subMagsF16 : softfloat_addMagsF16;
    66     return (*magsFuncPtr)( uiA, uiB );
     66    return (*magsFuncPtr)( uiA, uiB SOFTFLOAT_STATE_ARG_COMMA );
    6767#endif
    6868

  • trunk/src/libs/softfloat-3e/source/f16_div.c

    r94480 r94558  
    4545extern const uint16_t softfloat_approxRecip_1k1s[];
    4646
    47 float16_t f16_div( float16_t a, float16_t b )
     47float16_t f16_div( float16_t a, float16_t b SOFTFLOAT_STATE_DECL_COMMA  )
    4848{
    4949    union ui16_f16 uA;
    … …  
    103103        if ( ! sigB ) {
    104104            if ( ! (expA | sigA) ) goto invalid;
    105             softfloat_raiseFlags( softfloat_flag_infinite );
     105            softfloat_raiseFlags( softfloat_flag_infinite SOFTFLOAT_STATE_ARG_COMMA );
    106106            goto infinity;
    107107        }
    … …  
    158158    }
    159159#endif
    160     return softfloat_roundPackToF16( signZ, expZ, sigZ );
     160    return softfloat_roundPackToF16( signZ, expZ, sigZ SOFTFLOAT_STATE_ARG_COMMA );
    161161    /*------------------------------------------------------------------------
    162162    *------------------------------------------------------------------------*/
    163163 propagateNaN:
    164     uiZ = softfloat_propagateNaNF16UI( uiA, uiB );
     164    uiZ = softfloat_propagateNaNF16UI( uiA, uiB SOFTFLOAT_STATE_ARG_COMMA );
    165165    goto uiZ;
    166166    /*------------------------------------------------------------------------
    167167    *------------------------------------------------------------------------*/
    168168 invalid:
    169     softfloat_raiseFlags( softfloat_flag_invalid );
     169    softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    170170    uiZ = defaultNaNF16UI;
    171171    goto uiZ;

  • trunk/src/libs/softfloat-3e/source/f16_eq.c

    r94480 r94558  
    4242#include "softfloat.h"
    4343
    44 bool f16_eq( float16_t a, float16_t b )
     44bool f16_eq( float16_t a, float16_t b SOFTFLOAT_STATE_DECL_COMMA  )
    4545{
    4646    union ui16_f16 uA;
    … …  
    5757            softfloat_isSigNaNF16UI( uiA ) || softfloat_isSigNaNF16UI( uiB )
    5858        ) {
    59             softfloat_raiseFlags( softfloat_flag_invalid );
     59            softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    6060        }
    6161        return false;

  • trunk/src/libs/softfloat-3e/source/f16_eq_signaling.c

    r94480 r94558  
    4141#include "softfloat.h"
    4242
    43 bool f16_eq_signaling( float16_t a, float16_t b )
     43bool f16_eq_signaling( float16_t a, float16_t b SOFTFLOAT_STATE_DECL_COMMA  )
    4444{
    4545    union ui16_f16 uA;
    … …  
    5353    uiB = uB.ui;
    5454    if ( isNaNF16UI( uiA ) || isNaNF16UI( uiB ) ) {
    55         softfloat_raiseFlags( softfloat_flag_invalid );
     55        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    5656        return false;
    5757    }

  • trunk/src/libs/softfloat-3e/source/f16_le.c

    r94480 r94558  
    4141#include "softfloat.h"
    4242
    43 bool f16_le( float16_t a, float16_t b )
     43bool f16_le( float16_t a, float16_t b SOFTFLOAT_STATE_DECL_COMMA  )
    4444{
    4545    union ui16_f16 uA;
    … …  
    5454    uiB = uB.ui;
    5555    if ( isNaNF16UI( uiA ) || isNaNF16UI( uiB ) ) {
    56         softfloat_raiseFlags( softfloat_flag_invalid );
     56        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    5757        return false;
    5858    }

  • trunk/src/libs/softfloat-3e/source/f16_le_quiet.c

    r94480 r94558  
    4242#include "softfloat.h"
    4343
    44 bool f16_le_quiet( float16_t a, float16_t b )
     44bool f16_le_quiet( float16_t a, float16_t b SOFTFLOAT_STATE_DECL_COMMA  )
    4545{
    4646    union ui16_f16 uA;
    … …  
    5858            softfloat_isSigNaNF16UI( uiA ) || softfloat_isSigNaNF16UI( uiB )
    5959        ) {
    60             softfloat_raiseFlags( softfloat_flag_invalid );
     60            softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    6161        }
    6262        return false;

  • trunk/src/libs/softfloat-3e/source/f16_lt.c

    r94480 r94558  
    4141#include "softfloat.h"
    4242
    43 bool f16_lt( float16_t a, float16_t b )
     43bool f16_lt( float16_t a, float16_t b SOFTFLOAT_STATE_DECL_COMMA  )
    4444{
    4545    union ui16_f16 uA;
    … …  
    5454    uiB = uB.ui;
    5555    if ( isNaNF16UI( uiA ) || isNaNF16UI( uiB ) ) {
    56         softfloat_raiseFlags( softfloat_flag_invalid );
     56        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    5757        return false;
    5858    }

  • trunk/src/libs/softfloat-3e/source/f16_lt_quiet.c

    r94480 r94558  
    4242#include "softfloat.h"
    4343
    44 bool f16_lt_quiet( float16_t a, float16_t b )
     44bool f16_lt_quiet( float16_t a, float16_t b SOFTFLOAT_STATE_DECL_COMMA )
    4545{
    4646    union ui16_f16 uA;
    … …  
    5858            softfloat_isSigNaNF16UI( uiA ) || softfloat_isSigNaNF16UI( uiB )
    5959        ) {
    60             softfloat_raiseFlags( softfloat_flag_invalid );
     60            softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    6161        }
    6262        return false;

  • trunk/src/libs/softfloat-3e/source/f16_mul.c

    r94480 r94558  
    4242#include "softfloat.h"
    4343
    44 float16_t f16_mul( float16_t a, float16_t b )
     44float16_t f16_mul( float16_t a, float16_t b SOFTFLOAT_STATE_DECL_COMMA  )
    4545{
    4646    union ui16_f16 uA;
    … …  
    113113        sigZ <<= 1;
    114114    }
    115     return softfloat_roundPackToF16( signZ, expZ, sigZ );
     115    return softfloat_roundPackToF16( signZ, expZ, sigZ SOFTFLOAT_STATE_ARG_COMMA );
    116116    /*------------------------------------------------------------------------
    117117    *------------------------------------------------------------------------*/
    118118 propagateNaN:
    119     uiZ = softfloat_propagateNaNF16UI( uiA, uiB );
     119    uiZ = softfloat_propagateNaNF16UI( uiA, uiB SOFTFLOAT_STATE_ARG_COMMA );
    120120    goto uiZ;
    121121    /*------------------------------------------------------------------------
    … …  
    123123 infArg:
    124124    if ( ! magBits ) {
    125         softfloat_raiseFlags( softfloat_flag_invalid );
     125        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    126126        uiZ = defaultNaNF16UI;
    127127    } else {

  • trunk/src/libs/softfloat-3e/source/f16_mulAdd.c

    r94480 r94558  
    4040#include "softfloat.h"
    4141
    42 float16_t f16_mulAdd( float16_t a, float16_t b, float16_t c )
     42float16_t f16_mulAdd( float16_t a, float16_t b, float16_t c SOFTFLOAT_STATE_DECL_COMMA  )
    4343{
    4444    union ui16_f16 uA;
    … …  
    5555    uC.f = c;
    5656    uiC = uC.ui;
    57     return softfloat_mulAddF16( uiA, uiB, uiC, 0 );
     57    return softfloat_mulAddF16( uiA, uiB, uiC, 0 SOFTFLOAT_STATE_ARG_COMMA );
    5858
    5959}

  • trunk/src/libs/softfloat-3e/source/f16_rem.c

    r94480 r94558  
    4242#include "softfloat.h"
    4343
    44 float16_t f16_rem( float16_t a, float16_t b )
     44float16_t f16_rem( float16_t a, float16_t b SOFTFLOAT_STATE_DECL_COMMA  )
    4545{
    4646    union ui16_f16 uA;
    … …  
    155155        rem = -rem;
    156156    }
    157     return softfloat_normRoundPackToF16( signRem, expB, rem );
     157    return softfloat_normRoundPackToF16( signRem, expB, rem SOFTFLOAT_STATE_ARG_COMMA );
    158158    /*------------------------------------------------------------------------
    159159    *------------------------------------------------------------------------*/
    160160 propagateNaN:
    161     uiZ = softfloat_propagateNaNF16UI( uiA, uiB );
     161    uiZ = softfloat_propagateNaNF16UI( uiA, uiB SOFTFLOAT_STATE_ARG_COMMA );
    162162    goto uiZ;
    163163 invalid:
    164     softfloat_raiseFlags( softfloat_flag_invalid );
     164    softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    165165    uiZ = defaultNaNF16UI;
    166166 uiZ:

  • trunk/src/libs/softfloat-3e/source/f16_roundToInt.c

    r94548 r94558  
    4343#include <iprt/cdefs.h> /* VBox: for RT_FALL_THROUGH */
    4444
    45 float16_t f16_roundToInt( float16_t a, uint_fast8_t roundingMode, bool exact )
     45float16_t f16_roundToInt( float16_t a, uint_fast8_t roundingMode, bool exact SOFTFLOAT_STATE_DECL_COMMA  )
    4646{
    4747    union ui16_f16 uA;
    … …  
    8787    if ( 0x19 <= exp ) {
    8888        if ( (exp == 0x1F) && fracF16UI( uiA ) ) {
    89             uiZ = softfloat_propagateNaNF16UI( uiA, 0 );
     89            uiZ = softfloat_propagateNaNF16UI( uiA, 0 SOFTFLOAT_STATE_ARG_COMMA );
    9090            goto uiZ;
    9191        }

  • trunk/src/libs/softfloat-3e/source/f16_sqrt.c

    r94480 r94558  
    4545extern const uint16_t softfloat_approxRecipSqrt_1k1s[];
    4646
    47 float16_t f16_sqrt( float16_t a )
     47float16_t f16_sqrt( float16_t a SOFTFLOAT_STATE_DECL_COMMA  )
    4848{
    4949    union ui16_f16 uA;
    … …  
    7373    if ( expA == 0x1F ) {
    7474        if ( sigA ) {
    75             uiZ = softfloat_propagateNaNF16UI( uiA, 0 );
     75            uiZ = softfloat_propagateNaNF16UI( uiA, 0 SOFTFLOAT_STATE_ARG_COMMA );
    7676            goto uiZ;
    7777        }
    … …  
    123123        }
    124124    }
    125     return softfloat_roundPackToF16( 0, expZ, sigZ );
     125    return softfloat_roundPackToF16( 0, expZ, sigZ SOFTFLOAT_STATE_ARG_COMMA );
    126126    /*------------------------------------------------------------------------
    127127    *------------------------------------------------------------------------*/
    128128 invalid:
    129     softfloat_raiseFlags( softfloat_flag_invalid );
     129    softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    130130    uiZ = defaultNaNF16UI;
    131131 uiZ:

  • trunk/src/libs/softfloat-3e/source/f16_sub.c

    r94480 r94558  
    4141#include "softfloat.h"
    4242
    43 float16_t f16_sub( float16_t a, float16_t b )
     43float16_t f16_sub( float16_t a, float16_t b SOFTFLOAT_STATE_DECL_COMMA  )
    4444{
    4545    union ui16_f16 uA;
    … …  
    4848    uint_fast16_t uiB;
    4949#if ! defined INLINE_LEVEL || (INLINE_LEVEL < 1)
    50     float16_t (*magsFuncPtr)( uint_fast16_t, uint_fast16_t );
     50    float16_t (*magsFuncPtr)( uint_fast16_t, uint_fast16_t SOFTFLOAT_STATE_DECL_COMMA );
    5151#endif
    5252
    … …  
    5757#if defined INLINE_LEVEL && (1 <= INLINE_LEVEL)
    5858    if ( signF16UI( uiA ^ uiB ) ) {
    59         return softfloat_addMagsF16( uiA, uiB );
     59        return softfloat_addMagsF16( uiA, uiB SOFTFLOAT_STATE_ARG_COMMA );
    6060    } else {
    61         return softfloat_subMagsF16( uiA, uiB );
     61        return softfloat_subMagsF16( uiA, uiB SOFTFLOAT_STATE_ARG_COMMA );
    6262    }
    6363#else
    6464    magsFuncPtr =
    6565        signF16UI( uiA ^ uiB ) ? softfloat_addMagsF16 : softfloat_subMagsF16;
    66     return (*magsFuncPtr)( uiA, uiB );
     66    return (*magsFuncPtr)( uiA, uiB SOFTFLOAT_STATE_ARG_COMMA );
    6767#endif
    6868

  • trunk/src/libs/softfloat-3e/source/f16_to_extF80.c

    r94480 r94558  
    4242#include "softfloat.h"
    4343
    44 extFloat80_t f16_to_extF80( float16_t a )
     44extFloat80_t f16_to_extF80( float16_t a SOFTFLOAT_STATE_DECL_COMMA )
    4545{
    4646    union ui16_f16 uA;
    … …  
    6767    if ( exp == 0x1F ) {
    6868        if ( frac ) {
    69             softfloat_f16UIToCommonNaN( uiA, &commonNaN );
     69            softfloat_f16UIToCommonNaN( uiA, &commonNaN SOFTFLOAT_STATE_ARG_COMMA );
    7070            uiZ = softfloat_commonNaNToExtF80UI( &commonNaN );
    7171            uiZ64 = uiZ.v64;

  • trunk/src/libs/softfloat-3e/source/f16_to_extF80M.c

    r94480 r94558  
    4444#ifdef SOFTFLOAT_FAST_INT64
    4545
    46 void f16_to_extF80M( float16_t a, extFloat80_t *zPtr )
     46void f16_to_extF80M( float16_t a, extFloat80_t *zPtr SOFTFLOAT_STATE_DECL_COMMA )
    4747{
    4848
    49     *zPtr = f16_to_extF80( a );
     49    *zPtr = f16_to_extF80( a SOFTFLOAT_STATE_ARG_COMMA );
    5050
    5151}
    … …  
    5353#else
    5454
    55 void f16_to_extF80M( float16_t a, extFloat80_t *zPtr )
     55void f16_to_extF80M( float16_t a, extFloat80_t *zPtr SOFTFLOAT_STATE_DECL_COMMA )
    5656{
    5757    struct extFloat80M *zSPtr;
    … …  
    7878    if ( exp == 0x1F ) {
    7979        if ( frac ) {
    80             softfloat_f16UIToCommonNaN( uiA, &commonNaN );
     80            softfloat_f16UIToCommonNaN( uiA, &commonNaN SOFTFLOAT_STATE_ARG_COMMA );
    8181            softfloat_commonNaNToExtF80M( &commonNaN, zSPtr );
    8282            return;

  • trunk/src/libs/softfloat-3e/source/f16_to_f128.c

    r94480 r94558  
    4242#include "softfloat.h"
    4343
    44 float128_t f16_to_f128( float16_t a )
     44float128_t f16_to_f128( float16_t a SOFTFLOAT_STATE_DECL_COMMA )
    4545{
    4646    union ui16_f16 uA;
    … …  
    6565    if ( exp == 0x1F ) {
    6666        if ( frac ) {
    67             softfloat_f16UIToCommonNaN( uiA, &commonNaN );
     67            softfloat_f16UIToCommonNaN( uiA, &commonNaN SOFTFLOAT_STATE_ARG_COMMA );
    6868            uiZ = softfloat_commonNaNToF128UI( &commonNaN );
    6969        } else {

  • trunk/src/libs/softfloat-3e/source/f16_to_f128M.c

    r94480 r94558  
    4444#ifdef SOFTFLOAT_FAST_INT64
    4545
    46 void f16_to_f128M( float16_t a, float128_t *zPtr )
     46void f16_to_f128M( float16_t a, float128_t *zPtr SOFTFLOAT_STATE_DECL_COMMA )
    4747{
    4848
    49     *zPtr = f16_to_f128( a );
     49    *zPtr = f16_to_f128( a SOFTFLOAT_STATE_ARG_COMMA );
    5050
    5151}
    … …  
    5353#else
    5454
    55 void f16_to_f128M( float16_t a, float128_t *zPtr )
     55void f16_to_f128M( float16_t a, float128_t *zPtr SOFTFLOAT_STATE_DECL_COMMA )
    5656{
    5757    uint32_t *zWPtr;
    … …  
    7979    if ( exp == 0x1F ) {
    8080        if ( frac ) {
    81             softfloat_f16UIToCommonNaN( uiA, &commonNaN );
     81            softfloat_f16UIToCommonNaN( uiA, &commonNaN SOFTFLOAT_STATE_ARG_COMMA );
    8282            softfloat_commonNaNToF128M( &commonNaN, zWPtr );
    8383            return;

  • trunk/src/libs/softfloat-3e/source/f16_to_f32.c

    r94480 r94558  
    4242#include "softfloat.h"
    4343
    44 float32_t f16_to_f32( float16_t a )
     44float32_t f16_to_f32( float16_t a SOFTFLOAT_STATE_DECL_COMMA )
    4545{
    4646    union ui16_f16 uA;
    … …  
    6565    if ( exp == 0x1F ) {
    6666        if ( frac ) {
    67             softfloat_f16UIToCommonNaN( uiA, &commonNaN );
     67            softfloat_f16UIToCommonNaN( uiA, &commonNaN SOFTFLOAT_STATE_ARG_COMMA );
    6868            uiZ = softfloat_commonNaNToF32UI( &commonNaN );
    6969        } else {

  • trunk/src/libs/softfloat-3e/source/f16_to_f64.c

    r94480 r94558  
    4242#include "softfloat.h"
    4343
    44 float64_t f16_to_f64( float16_t a )
     44float64_t f16_to_f64( float16_t a SOFTFLOAT_STATE_DECL_COMMA )
    4545{
    4646    union ui16_f16 uA;
    … …  
    6565    if ( exp == 0x1F ) {
    6666        if ( frac ) {
    67             softfloat_f16UIToCommonNaN( uiA, &commonNaN );
     67            softfloat_f16UIToCommonNaN( uiA, &commonNaN SOFTFLOAT_STATE_ARG_COMMA );
    6868            uiZ = softfloat_commonNaNToF64UI( &commonNaN );
    6969        } else {

  • trunk/src/libs/softfloat-3e/source/f16_to_i32.c

    r94480 r94558  
    4242#include "softfloat.h"
    4343
    44 int_fast32_t f16_to_i32( float16_t a, uint_fast8_t roundingMode, bool exact )
     44int_fast32_t f16_to_i32( float16_t a, uint_fast8_t roundingMode, bool exact SOFTFLOAT_STATE_DECL_COMMA )
    4545{
    4646    union ui16_f16 uA;
    … …  
    6262    *------------------------------------------------------------------------*/
    6363    if ( exp == 0x1F ) {
    64         softfloat_raiseFlags( softfloat_flag_invalid );
     64        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    6565        return
    6666            frac ? i32_fromNaN
    … …  
    8282    return
    8383        softfloat_roundToI32(
    84             sign, (uint_fast32_t) sig32, roundingMode, exact );
     84            sign, (uint_fast32_t) sig32, roundingMode, exact SOFTFLOAT_STATE_ARG_COMMA );
    8585
    8686}

  • trunk/src/libs/softfloat-3e/source/f16_to_i32_r_minMag.c

    r94480 r94558  
    4242#include "softfloat.h"
    4343
    44 int_fast32_t f16_to_i32_r_minMag( float16_t a, bool exact )
     44int_fast32_t f16_to_i32_r_minMag( float16_t a, bool exact SOFTFLOAT_STATE_DECL_COMMA )
    4545{
    4646    union ui16_f16 uA;
    … …  
    7171    sign = signF16UI( uiA );
    7272    if ( exp == 0x1F ) {
    73         softfloat_raiseFlags( softfloat_flag_invalid );
     73        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    7474        return
    7575            (exp == 0x1F) && frac ? i32_fromNaN

  • trunk/src/libs/softfloat-3e/source/f16_to_i64.c

    r94480 r94558  
    4242#include "softfloat.h"
    4343
    44 int_fast64_t f16_to_i64( float16_t a, uint_fast8_t roundingMode, bool exact )
     44int_fast64_t f16_to_i64( float16_t a, uint_fast8_t roundingMode, bool exact SOFTFLOAT_STATE_DECL_COMMA )
    4545{
    4646    union ui16_f16 uA;
    … …  
    6262    *------------------------------------------------------------------------*/
    6363    if ( exp == 0x1F ) {
    64         softfloat_raiseFlags( softfloat_flag_invalid );
     64        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    6565        return
    6666            frac ? i64_fromNaN
    … …  
    8282    return
    8383        softfloat_roundToI32(
    84             sign, (uint_fast32_t) sig32, roundingMode, exact );
     84            sign, (uint_fast32_t) sig32, roundingMode, exact SOFTFLOAT_STATE_ARG_COMMA );
    8585
    8686}

  • trunk/src/libs/softfloat-3e/source/f16_to_i64_r_minMag.c

    r94480 r94558  
    4242#include "softfloat.h"
    4343
    44 int_fast64_t f16_to_i64_r_minMag( float16_t a, bool exact )
     44int_fast64_t f16_to_i64_r_minMag( float16_t a, bool exact SOFTFLOAT_STATE_DECL_COMMA )
    4545{
    4646    union ui16_f16 uA;
    … …  
    7171    sign = signF16UI( uiA );
    7272    if ( exp == 0x1F ) {
    73         softfloat_raiseFlags( softfloat_flag_invalid );
     73        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    7474        return
    7575            (exp == 0x1F) && frac ? i64_fromNaN

  • trunk/src/libs/softfloat-3e/source/f16_to_ui32.c

    r94480 r94558  
    4242#include "softfloat.h"
    4343
    44 uint_fast32_t f16_to_ui32( float16_t a, uint_fast8_t roundingMode, bool exact )
     44uint_fast32_t f16_to_ui32( float16_t a, uint_fast8_t roundingMode, bool exact SOFTFLOAT_STATE_DECL_COMMA )
    4545{
    4646    union ui16_f16 uA;
    … …  
    6262    *------------------------------------------------------------------------*/
    6363    if ( exp == 0x1F ) {
    64         softfloat_raiseFlags( softfloat_flag_invalid );
     64        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    6565        return
    6666            frac ? ui32_fromNaN
    … …  
    7979        if ( 0 < shiftDist ) sig32 <<= shiftDist;
    8080    }
    81     return softfloat_roundToUI32( sign, sig32, roundingMode, exact );
     81    return softfloat_roundToUI32( sign, sig32, roundingMode, exact SOFTFLOAT_STATE_ARG_COMMA );
    8282
    8383}

  • trunk/src/libs/softfloat-3e/source/f16_to_ui32_r_minMag.c

    r94480 r94558  
    4242#include "softfloat.h"
    4343
    44 uint_fast32_t f16_to_ui32_r_minMag( float16_t a, bool exact )
     44uint_fast32_t f16_to_ui32_r_minMag( float16_t a, bool exact SOFTFLOAT_STATE_DECL_COMMA )
    4545{
    4646    union ui16_f16 uA;
    … …  
    7171    sign = signF16UI( uiA );
    7272    if ( sign || (exp == 0x1F) ) {
    73         softfloat_raiseFlags( softfloat_flag_invalid );
     73        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    7474        return
    7575            (exp == 0x1F) && frac ? ui32_fromNaN

  • trunk/src/libs/softfloat-3e/source/f16_to_ui64.c

    r94480 r94558  
    4242#include "softfloat.h"
    4343
    44 uint_fast64_t f16_to_ui64( float16_t a, uint_fast8_t roundingMode, bool exact )
     44uint_fast64_t f16_to_ui64( float16_t a, uint_fast8_t roundingMode, bool exact SOFTFLOAT_STATE_DECL_COMMA )
    4545{
    4646    union ui16_f16 uA;
    … …  
    6565    *------------------------------------------------------------------------*/
    6666    if ( exp == 0x1F ) {
    67         softfloat_raiseFlags( softfloat_flag_invalid );
     67        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    6868        return
    6969            frac ? ui64_fromNaN
    … …  
    8585    return
    8686        softfloat_roundToUI64(
    87             sign, sig32>>12, (uint_fast64_t) sig32<<52, roundingMode, exact );
     87            sign, sig32>>12, (uint_fast64_t) sig32<<52, roundingMode, exact SOFTFLOAT_STATE_ARG_COMMA );
    8888#else
    8989    extSig[indexWord( 3, 2 )] = 0;
    9090    extSig[indexWord( 3, 1 )] = sig32>>12;
    9191    extSig[indexWord( 3, 0 )] = sig32<<20;
    92     return softfloat_roundMToUI64( sign, extSig, roundingMode, exact );
     92    return softfloat_roundMToUI64( sign, extSig, roundingMode, exact SOFTFLOAT_STATE_ARG_COMMA);
    9393#endif
    9494

  • trunk/src/libs/softfloat-3e/source/f16_to_ui64_r_minMag.c

    r94480 r94558  
    4242#include "softfloat.h"
    4343
    44 uint_fast64_t f16_to_ui64_r_minMag( float16_t a, bool exact )
     44uint_fast64_t f16_to_ui64_r_minMag( float16_t a, bool exact SOFTFLOAT_STATE_DECL_COMMA )
    4545{
    4646    union ui16_f16 uA;
    … …  
    7171    sign = signF16UI( uiA );
    7272    if ( sign || (exp == 0x1F) ) {
    73         softfloat_raiseFlags( softfloat_flag_invalid );
     73        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    7474        return
    7575            (exp == 0x1F) && frac ? ui64_fromNaN

  • trunk/src/libs/softfloat-3e/source/f32_add.c

    r94480 r94558  
    4141#include "softfloat.h"
    4242
    43 float32_t f32_add( float32_t a, float32_t b )
     43float32_t f32_add( float32_t a, float32_t b SOFTFLOAT_STATE_DECL_COMMA )
    4444{
    4545    union ui32_f32 uA;
    … …  
    4848    uint_fast32_t uiB;
    4949#if ! defined INLINE_LEVEL || (INLINE_LEVEL < 1)
    50     float32_t (*magsFuncPtr)( uint_fast32_t, uint_fast32_t );
     50    float32_t (*magsFuncPtr)( uint_fast32_t, uint_fast32_t SOFTFLOAT_STATE_DECL_COMMA );
    5151#endif
    5252
    … …  
    5757#if defined INLINE_LEVEL && (1 <= INLINE_LEVEL)
    5858    if ( signF32UI( uiA ^ uiB ) ) {
    59         return softfloat_subMagsF32( uiA, uiB );
     59        return softfloat_subMagsF32( uiA, uiB SOFTFLOAT_STATE_ARG_COMMA );
    6060    } else {
    61         return softfloat_addMagsF32( uiA, uiB );
     61        return softfloat_addMagsF32( uiA, uiB SOFTFLOAT_STATE_ARG_COMMA );
    6262    }
    6363#else
    6464    magsFuncPtr =
    6565        signF32UI( uiA ^ uiB ) ? softfloat_subMagsF32 : softfloat_addMagsF32;
    66     return (*magsFuncPtr)( uiA, uiB );
     66    return (*magsFuncPtr)( uiA, uiB SOFTFLOAT_STATE_ARG_COMMA );
    6767#endif
    6868

  • trunk/src/libs/softfloat-3e/source/f32_div.c

    r94480 r94558  
    4242#include "softfloat.h"
    4343
    44 float32_t f32_div( float32_t a, float32_t b )
     44float32_t f32_div( float32_t a, float32_t b SOFTFLOAT_STATE_DECL_COMMA )
    4545{
    4646    union ui32_f32 uA;
    … …  
    9999        if ( ! sigB ) {
    100100            if ( ! (expA | sigA) ) goto invalid;
    101             softfloat_raiseFlags( softfloat_flag_infinite );
     101            softfloat_raiseFlags( softfloat_flag_infinite SOFTFLOAT_STATE_ARG_COMMA );
    102102            goto infinity;
    103103        }
    … …  
    152152    }
    153153#endif
    154     return softfloat_roundPackToF32( signZ, expZ, sigZ );
     154    return softfloat_roundPackToF32( signZ, expZ, sigZ SOFTFLOAT_STATE_ARG_COMMA );
    155155    /*------------------------------------------------------------------------
    156156    *------------------------------------------------------------------------*/
    157157 propagateNaN:
    158     uiZ = softfloat_propagateNaNF32UI( uiA, uiB );
     158    uiZ = softfloat_propagateNaNF32UI( uiA, uiB SOFTFLOAT_STATE_ARG_COMMA );
    159159    goto uiZ;
    160160    /*------------------------------------------------------------------------
    161161    *------------------------------------------------------------------------*/
    162162 invalid:
    163     softfloat_raiseFlags( softfloat_flag_invalid );
     163    softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    164164    uiZ = defaultNaNF32UI;
    165165    goto uiZ;

  • trunk/src/libs/softfloat-3e/source/f32_eq.c

    r94480 r94558  
    4242#include "softfloat.h"
    4343
    44 bool f32_eq( float32_t a, float32_t b )
     44bool f32_eq( float32_t a, float32_t b SOFTFLOAT_STATE_DECL_COMMA )
    4545{
    4646    union ui32_f32 uA;
    … …  
    5757            softfloat_isSigNaNF32UI( uiA ) || softfloat_isSigNaNF32UI( uiB )
    5858        ) {
    59             softfloat_raiseFlags( softfloat_flag_invalid );
     59            softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    6060        }
    6161        return false;

  • trunk/src/libs/softfloat-3e/source/f32_eq_signaling.c

    r94480 r94558  
    4141#include "softfloat.h"
    4242
    43 bool f32_eq_signaling( float32_t a, float32_t b )
     43bool f32_eq_signaling( float32_t a, float32_t b SOFTFLOAT_STATE_DECL_COMMA )
    4444{
    4545    union ui32_f32 uA;
    … …  
    5353    uiB = uB.ui;
    5454    if ( isNaNF32UI( uiA ) || isNaNF32UI( uiB ) ) {
    55         softfloat_raiseFlags( softfloat_flag_invalid );
     55        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    5656        return false;
    5757    }

  • trunk/src/libs/softfloat-3e/source/f32_le.c

    r94480 r94558  
    4141#include "softfloat.h"
    4242
    43 bool f32_le( float32_t a, float32_t b )
     43bool f32_le( float32_t a, float32_t b SOFTFLOAT_STATE_DECL_COMMA )
    4444{
    4545    union ui32_f32 uA;
    … …  
    5454    uiB = uB.ui;
    5555    if ( isNaNF32UI( uiA ) || isNaNF32UI( uiB ) ) {
    56         softfloat_raiseFlags( softfloat_flag_invalid );
     56        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    5757        return false;
    5858    }

  • trunk/src/libs/softfloat-3e/source/f32_le_quiet.c

    r94480 r94558  
    4242#include "softfloat.h"
    4343
    44 bool f32_le_quiet( float32_t a, float32_t b )
     44bool f32_le_quiet( float32_t a, float32_t b SOFTFLOAT_STATE_DECL_COMMA )
    4545{
    4646    union ui32_f32 uA;
    … …  
    5858            softfloat_isSigNaNF32UI( uiA ) || softfloat_isSigNaNF32UI( uiB )
    5959        ) {
    60             softfloat_raiseFlags( softfloat_flag_invalid );
     60            softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    6161        }
    6262        return false;

  • trunk/src/libs/softfloat-3e/source/f32_lt.c

    r94480 r94558  
    4141#include "softfloat.h"
    4242
    43 bool f32_lt( float32_t a, float32_t b )
     43bool f32_lt( float32_t a, float32_t b SOFTFLOAT_STATE_DECL_COMMA )
    4444{
    4545    union ui32_f32 uA;
    … …  
    5454    uiB = uB.ui;
    5555    if ( isNaNF32UI( uiA ) || isNaNF32UI( uiB ) ) {
    56         softfloat_raiseFlags( softfloat_flag_invalid );
     56        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    5757        return false;
    5858    }

  • trunk/src/libs/softfloat-3e/source/f32_lt_quiet.c

    r94480 r94558  
    4242#include "softfloat.h"
    4343
    44 bool f32_lt_quiet( float32_t a, float32_t b )
     44bool f32_lt_quiet( float32_t a, float32_t b SOFTFLOAT_STATE_DECL_COMMA )
    4545{
    4646    union ui32_f32 uA;
    … …  
    5858            softfloat_isSigNaNF32UI( uiA ) || softfloat_isSigNaNF32UI( uiB )
    5959        ) {
    60             softfloat_raiseFlags( softfloat_flag_invalid );
     60            softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    6161        }
    6262        return false;

  • trunk/src/libs/softfloat-3e/source/f32_mul.c

    r94480 r94558  
    4242#include "softfloat.h"
    4343
    44 float32_t f32_mul( float32_t a, float32_t b )
     44float32_t f32_mul( float32_t a, float32_t b SOFTFLOAT_STATE_DECL_COMMA )
    4545{
    4646    union ui32_f32 uA;
    … …  
    110110        sigZ <<= 1;
    111111    }
    112     return softfloat_roundPackToF32( signZ, expZ, sigZ );
     112    return softfloat_roundPackToF32( signZ, expZ, sigZ SOFTFLOAT_STATE_ARG_COMMA );
    113113    /*------------------------------------------------------------------------
    114114    *------------------------------------------------------------------------*/
    115115 propagateNaN:
    116     uiZ = softfloat_propagateNaNF32UI( uiA, uiB );
     116    uiZ = softfloat_propagateNaNF32UI( uiA, uiB SOFTFLOAT_STATE_ARG_COMMA );
    117117    goto uiZ;
    118118    /*------------------------------------------------------------------------
    … …  
    120120 infArg:
    121121    if ( ! magBits ) {
    122         softfloat_raiseFlags( softfloat_flag_invalid );
     122        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    123123        uiZ = defaultNaNF32UI;
    124124    } else {

  • trunk/src/libs/softfloat-3e/source/f32_mulAdd.c

    r94480 r94558  
    4040#include "softfloat.h"
    4141
    42 float32_t f32_mulAdd( float32_t a, float32_t b, float32_t c )
     42float32_t f32_mulAdd( float32_t a, float32_t b, float32_t c SOFTFLOAT_STATE_DECL_COMMA )
    4343{
    4444    union ui32_f32 uA;
    … …  
    5555    uC.f = c;
    5656    uiC = uC.ui;
    57     return softfloat_mulAddF32( uiA, uiB, uiC, 0 );
     57    return softfloat_mulAddF32( uiA, uiB, uiC, 0 SOFTFLOAT_STATE_ARG_COMMA );
    5858
    5959}

  • trunk/src/libs/softfloat-3e/source/f32_rem.c

    r94480 r94558  
    4242#include "softfloat.h"
    4343
    44 float32_t f32_rem( float32_t a, float32_t b )
     44float32_t f32_rem( float32_t a, float32_t b SOFTFLOAT_STATE_DECL_COMMA )
    4545{
    4646    union ui32_f32 uA;
    … …  
    152152        rem = -rem;
    153153    }
    154     return softfloat_normRoundPackToF32( signRem, expB, rem );
     154    return softfloat_normRoundPackToF32( signRem, expB, rem SOFTFLOAT_STATE_ARG_COMMA );
    155155    /*------------------------------------------------------------------------
    156156    *------------------------------------------------------------------------*/
    157157 propagateNaN:
    158     uiZ = softfloat_propagateNaNF32UI( uiA, uiB );
     158    uiZ = softfloat_propagateNaNF32UI( uiA, uiB SOFTFLOAT_STATE_ARG_COMMA );
    159159    goto uiZ;
    160160 invalid:
    161     softfloat_raiseFlags( softfloat_flag_invalid );
     161    softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    162162    uiZ = defaultNaNF32UI;
    163163 uiZ:

  • trunk/src/libs/softfloat-3e/source/f32_roundToInt.c

    r94548 r94558  
    4343#include <iprt/cdefs.h> /* VBox: for RT_FALL_THROUGH */
    4444
    45 float32_t f32_roundToInt( float32_t a, uint_fast8_t roundingMode, bool exact )
     45float32_t f32_roundToInt( float32_t a, uint_fast8_t roundingMode, bool exact SOFTFLOAT_STATE_DECL_COMMA )
    4646{
    4747    union ui32_f32 uA;
    … …  
    8787    if ( 0x96 <= exp ) {
    8888        if ( (exp == 0xFF) && fracF32UI( uiA ) ) {
    89             uiZ = softfloat_propagateNaNF32UI( uiA, 0 );
     89            uiZ = softfloat_propagateNaNF32UI( uiA, 0 SOFTFLOAT_STATE_ARG_COMMA );
    9090            goto uiZ;
    9191        }

  • trunk/src/libs/softfloat-3e/source/f32_sqrt.c

    r94480 r94558  
    4242#include "softfloat.h"
    4343
    44 float32_t f32_sqrt( float32_t a )
     44float32_t f32_sqrt( float32_t a SOFTFLOAT_STATE_DECL_COMMA )
    4545{
    4646    union ui32_f32 uA;
    … …  
    6666    if ( expA == 0xFF ) {
    6767        if ( sigA ) {
    68             uiZ = softfloat_propagateNaNF32UI( uiA, 0 );
     68            uiZ = softfloat_propagateNaNF32UI( uiA, 0 SOFTFLOAT_STATE_ARG_COMMA );
    6969            goto uiZ;
    7070        }
    … …  
    108108        }
    109109    }
    110     return softfloat_roundPackToF32( 0, expZ, sigZ );
     110    return softfloat_roundPackToF32( 0, expZ, sigZ SOFTFLOAT_STATE_ARG_COMMA );
    111111    /*------------------------------------------------------------------------
    112112    *------------------------------------------------------------------------*/
    113113 invalid:
    114     softfloat_raiseFlags( softfloat_flag_invalid );
     114    softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    115115    uiZ = defaultNaNF32UI;
    116116 uiZ:

  • trunk/src/libs/softfloat-3e/source/f32_sub.c

    r94480 r94558  
    4141#include "softfloat.h"
    4242
    43 float32_t f32_sub( float32_t a, float32_t b )
     43float32_t f32_sub( float32_t a, float32_t b SOFTFLOAT_STATE_DECL_COMMA )
    4444{
    4545    union ui32_f32 uA;
    … …  
    4848    uint_fast32_t uiB;
    4949#if ! defined INLINE_LEVEL || (INLINE_LEVEL < 1)
    50     float32_t (*magsFuncPtr)( uint_fast32_t, uint_fast32_t );
     50    float32_t (*magsFuncPtr)( uint_fast32_t, uint_fast32_t SOFTFLOAT_STATE_DECL_COMMA );
    5151#endif
    5252
    … …  
    5757#if defined INLINE_LEVEL && (1 <= INLINE_LEVEL)
    5858    if ( signF32UI( uiA ^ uiB ) ) {
    59         return softfloat_addMagsF32( uiA, uiB );
     59        return softfloat_addMagsF32( uiA, uiB SOFTFLOAT_STATE_ARG_COMMA );
    6060    } else {
    61         return softfloat_subMagsF32( uiA, uiB );
     61        return softfloat_subMagsF32( uiA, uiB SOFTFLOAT_STATE_ARG_COMMA );
    6262    }
    6363#else
    6464    magsFuncPtr =
    6565        signF32UI( uiA ^ uiB ) ? softfloat_addMagsF32 : softfloat_subMagsF32;
    66     return (*magsFuncPtr)( uiA, uiB );
     66    return (*magsFuncPtr)( uiA, uiB SOFTFLOAT_STATE_ARG_COMMA );
    6767#endif
    6868

  • trunk/src/libs/softfloat-3e/source/f32_to_extF80.c

    r94480 r94558  
    4242#include "softfloat.h"
    4343
    44 extFloat80_t f32_to_extF80( float32_t a )
     44extFloat80_t f32_to_extF80( float32_t a SOFTFLOAT_STATE_DECL_COMMA )
    4545{
    4646    union ui32_f32 uA;
    … …  
    6767    if ( exp == 0xFF ) {
    6868        if ( frac ) {
    69             softfloat_f32UIToCommonNaN( uiA, &commonNaN );
     69            softfloat_f32UIToCommonNaN( uiA, &commonNaN SOFTFLOAT_STATE_ARG_COMMA );
    7070            uiZ = softfloat_commonNaNToExtF80UI( &commonNaN );
    7171            uiZ64 = uiZ.v64;

  • trunk/src/libs/softfloat-3e/source/f32_to_extF80M.c

    r94480 r94558  
    4444#ifdef SOFTFLOAT_FAST_INT64
    4545
    46 void f32_to_extF80M( float32_t a, extFloat80_t *zPtr )
     46void f32_to_extF80M( float32_t a, extFloat80_t *zPtr SOFTFLOAT_STATE_DECL_COMMA )
    4747{
    4848
    49     *zPtr = f32_to_extF80( a );
     49    *zPtr = f32_to_extF80( a SOFTFLOAT_STATE_ARG_COMMA );
    5050
    5151}
    … …  
    5353#else
    5454
    55 void f32_to_extF80M( float32_t a, extFloat80_t *zPtr )
     55void f32_to_extF80M( float32_t a, extFloat80_t *zPtr SOFTFLOAT_STATE_DECL_COMMA )
    5656{
    5757    struct extFloat80M *zSPtr;
    … …  
    7878    if ( exp == 0xFF ) {
    7979        if ( frac ) {
    80             softfloat_f32UIToCommonNaN( uiA, &commonNaN );
     80            softfloat_f32UIToCommonNaN( uiA, &commonNaN SOFTFLOAT_STATE_ARG_COMMA );
    8181            softfloat_commonNaNToExtF80M( &commonNaN, zSPtr );
    8282            return;

  • trunk/src/libs/softfloat-3e/source/f32_to_f128.c

    r94480 r94558  
    4242#include "softfloat.h"
    4343
    44 float128_t f32_to_f128( float32_t a )
     44float128_t f32_to_f128( float32_t a SOFTFLOAT_STATE_DECL_COMMA )
    4545{
    4646    union ui32_f32 uA;
    … …  
    6565    if ( exp == 0xFF ) {
    6666        if ( frac ) {
    67             softfloat_f32UIToCommonNaN( uiA, &commonNaN );
     67            softfloat_f32UIToCommonNaN( uiA, &commonNaN SOFTFLOAT_STATE_ARG_COMMA );
    6868            uiZ = softfloat_commonNaNToF128UI( &commonNaN );
    6969        } else {

  • trunk/src/libs/softfloat-3e/source/f32_to_f128M.c

    r94480 r94558  
    4444#ifdef SOFTFLOAT_FAST_INT64
    4545
    46 void f32_to_f128M( float32_t a, float128_t *zPtr )
     46void f32_to_f128M( float32_t a, float128_t *zPtr SOFTFLOAT_STATE_DECL_COMMA )
    4747{
    4848
    49     *zPtr = f32_to_f128( a );
     49    *zPtr = f32_to_f128( a SOFTFLOAT_STATE_ARG_COMMA );
    5050
    5151}
    … …  
    5353#else
    5454
    55 void f32_to_f128M( float32_t a, float128_t *zPtr )
     55void f32_to_f128M( float32_t a, float128_t *zPtr SOFTFLOAT_STATE_DECL_COMMA )
    5656{
    5757    uint32_t *zWPtr;
    … …  
    8181    if ( exp == 0xFF ) {
    8282        if ( frac ) {
    83             softfloat_f32UIToCommonNaN( uiA, &commonNaN );
     83            softfloat_f32UIToCommonNaN( uiA, &commonNaN SOFTFLOAT_STATE_ARG_COMMA );
    8484            softfloat_commonNaNToF128M( &commonNaN, zWPtr );
    8585            return;

  • trunk/src/libs/softfloat-3e/source/f32_to_f16.c

    r94480 r94558  
    4242#include "softfloat.h"
    4343
    44 float16_t f32_to_f16( float32_t a )
     44float16_t f32_to_f16( float32_t a SOFTFLOAT_STATE_DECL_COMMA )
    4545{
    4646    union ui32_f32 uA;
    … …  
    6464    if ( exp == 0xFF ) {
    6565        if ( frac ) {
    66             softfloat_f32UIToCommonNaN( uiA, &commonNaN );
     66            softfloat_f32UIToCommonNaN( uiA, &commonNaN SOFTFLOAT_STATE_ARG_COMMA );
    6767            uiZ = softfloat_commonNaNToF16UI( &commonNaN );
    6868        } else {
    … …  
    8080    /*------------------------------------------------------------------------
    8181    *------------------------------------------------------------------------*/
    82     return softfloat_roundPackToF16( sign, exp - 0x71, frac16 | 0x4000 );
     82    return softfloat_roundPackToF16( sign, exp - 0x71, frac16 | 0x4000 SOFTFLOAT_STATE_ARG_COMMA );
    8383 uiZ:
    8484    uZ.ui = uiZ;

  • trunk/src/libs/softfloat-3e/source/f32_to_f64.c

    r94480 r94558  
    4242#include "softfloat.h"
    4343
    44 float64_t f32_to_f64( float32_t a )
     44float64_t f32_to_f64( float32_t a SOFTFLOAT_STATE_DECL_COMMA )
    4545{
    4646    union ui32_f32 uA;
    … …  
    6565    if ( exp == 0xFF ) {
    6666        if ( frac ) {
    67             softfloat_f32UIToCommonNaN( uiA, &commonNaN );
     67            softfloat_f32UIToCommonNaN( uiA, &commonNaN SOFTFLOAT_STATE_ARG_COMMA );
    6868            uiZ = softfloat_commonNaNToF64UI( &commonNaN );
    6969        } else {

  • trunk/src/libs/softfloat-3e/source/f32_to_i32.c

    r94480 r94558  
    4242#include "softfloat.h"
    4343
    44 int_fast32_t f32_to_i32( float32_t a, uint_fast8_t roundingMode, bool exact )
     44int_fast32_t f32_to_i32( float32_t a, uint_fast8_t roundingMode, bool exact SOFTFLOAT_STATE_DECL_COMMA )
    4545{
    4646    union ui32_f32 uA;
    … …  
    6868        sign = 1;
    6969#else
    70         softfloat_raiseFlags( softfloat_flag_invalid );
     70        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    7171        return i32_fromNaN;
    7272#endif
    … …  
    7979    shiftDist = 0xAA - exp;
    8080    if ( 0 < shiftDist ) sig64 = softfloat_shiftRightJam64( sig64, shiftDist );
    81     return softfloat_roundToI32( sign, sig64, roundingMode, exact );
     81    return softfloat_roundToI32( sign, sig64, roundingMode, exact SOFTFLOAT_STATE_ARG_COMMA );
    8282
    8383}

  • trunk/src/libs/softfloat-3e/source/f32_to_i32_r_minMag.c

    r94480 r94558  
    4242#include "softfloat.h"
    4343
    44 int_fast32_t f32_to_i32_r_minMag( float32_t a, bool exact )
     44int_fast32_t f32_to_i32_r_minMag( float32_t a, bool exact SOFTFLOAT_STATE_DECL_COMMA )
    4545{
    4646    union ui32_f32 uA;
    … …  
    7272    if ( shiftDist <= 0 ) {
    7373        if ( uiA == packToF32UI( 1, 0x9E, 0 ) ) return -0x7FFFFFFF - 1;
    74         softfloat_raiseFlags( softfloat_flag_invalid );
     74        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    7575        return
    7676            (exp == 0xFF) && sig ? i32_fromNaN

  • trunk/src/libs/softfloat-3e/source/f32_to_i64.c

    r94480 r94558  
    4242#include "softfloat.h"
    4343
    44 int_fast64_t f32_to_i64( float32_t a, uint_fast8_t roundingMode, bool exact )
     44int_fast64_t f32_to_i64( float32_t a, uint_fast8_t roundingMode, bool exact SOFTFLOAT_STATE_DECL_COMMA )
    4545{
    4646    union ui32_f32 uA;
    … …  
    6868    shiftDist = 0xBE - exp;
    6969    if ( shiftDist < 0 ) {
    70         softfloat_raiseFlags( softfloat_flag_invalid );
     70        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    7171        return
    7272            (exp == 0xFF) && sig ? i64_fromNaN
    … …  
    8484        extra = sig64Extra.extra;
    8585    }
    86     return softfloat_roundToI64( sign, sig64, extra, roundingMode, exact );
     86    return softfloat_roundToI64( sign, sig64, extra, roundingMode, exact SOFTFLOAT_STATE_ARG_COMMA );
    8787#else
    8888    extSig[indexWord( 3, 2 )] = sig<<8;
    … …  
    9090    extSig[indexWord( 3, 0 )] = 0;
    9191    if ( shiftDist ) softfloat_shiftRightJam96M( extSig, shiftDist, extSig );
    92     return softfloat_roundMToI64( sign, extSig, roundingMode, exact );
     92    return softfloat_roundMToI64( sign, extSig, roundingMode, exact SOFTFLOAT_STATE_ARG_COMMA );
    9393#endif
    9494

  • trunk/src/libs/softfloat-3e/source/f32_to_i64_r_minMag.c

    r94480 r94558  
    4242#include "softfloat.h"
    4343
    44 int_fast64_t f32_to_i64_r_minMag( float32_t a, bool exact )
     44int_fast64_t f32_to_i64_r_minMag( float32_t a, bool exact SOFTFLOAT_STATE_DECL_COMMA )
    4545{
    4646    union ui32_f32 uA;
    … …  
    7575            return -INT64_C( 0x7FFFFFFFFFFFFFFF ) - 1;
    7676        }
    77         softfloat_raiseFlags( softfloat_flag_invalid );
     77        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    7878        return
    7979            (exp == 0xFF) && sig ? i64_fromNaN

  • trunk/src/libs/softfloat-3e/source/f32_to_ui32.c

    r94480 r94558  
    4242#include "softfloat.h"
    4343
    44 uint_fast32_t f32_to_ui32( float32_t a, uint_fast8_t roundingMode, bool exact )
     44uint_fast32_t f32_to_ui32( float32_t a, uint_fast8_t roundingMode, bool exact SOFTFLOAT_STATE_DECL_COMMA )
    4545{
    4646    union ui32_f32 uA;
    … …  
    6868        sign = 1;
    6969#else
    70         softfloat_raiseFlags( softfloat_flag_invalid );
     70        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    7171        return ui32_fromNaN;
    7272#endif
    … …  
    7979    shiftDist = 0xAA - exp;
    8080    if ( 0 < shiftDist ) sig64 = softfloat_shiftRightJam64( sig64, shiftDist );
    81     return softfloat_roundToUI32( sign, sig64, roundingMode, exact );
     81    return softfloat_roundToUI32( sign, sig64, roundingMode, exact SOFTFLOAT_STATE_ARG_COMMA );
    8282
    8383}

  • trunk/src/libs/softfloat-3e/source/f32_to_ui32_r_minMag.c

    r94480 r94558  
    4242#include "softfloat.h"
    4343
    44 uint_fast32_t f32_to_ui32_r_minMag( float32_t a, bool exact )
     44uint_fast32_t f32_to_ui32_r_minMag( float32_t a, bool exact SOFTFLOAT_STATE_DECL_COMMA )
    4545{
    4646    union ui32_f32 uA;
    … …  
    7171    sign = signF32UI( uiA );
    7272    if ( sign || (shiftDist < 0) ) {
    73         softfloat_raiseFlags( softfloat_flag_invalid );
     73        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    7474        return
    7575            (exp == 0xFF) && sig ? ui32_fromNaN

  • trunk/src/libs/softfloat-3e/source/f32_to_ui64.c

    r94480 r94558  
    4242#include "softfloat.h"
    4343
    44 uint_fast64_t f32_to_ui64( float32_t a, uint_fast8_t roundingMode, bool exact )
     44uint_fast64_t f32_to_ui64( float32_t a, uint_fast8_t roundingMode, bool exact SOFTFLOAT_STATE_DECL_COMMA )
    4545{
    4646    union ui32_f32 uA;
    … …  
    6868    shiftDist = 0xBE - exp;
    6969    if ( shiftDist < 0 ) {
    70         softfloat_raiseFlags( softfloat_flag_invalid );
     70        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    7171        return
    7272            (exp == 0xFF) && sig ? ui64_fromNaN
    … …  
    8484        extra = sig64Extra.extra;
    8585    }
    86     return softfloat_roundToUI64( sign, sig64, extra, roundingMode, exact );
     86    return softfloat_roundToUI64( sign, sig64, extra, roundingMode, exact SOFTFLOAT_STATE_ARG_COMMA );
    8787#else
    8888    extSig[indexWord( 3, 2 )] = sig<<8;
    … …  
    9090    extSig[indexWord( 3, 0 )] = 0;
    9191    if ( shiftDist ) softfloat_shiftRightJam96M( extSig, shiftDist, extSig );
    92     return softfloat_roundMToUI64( sign, extSig, roundingMode, exact );
     92    return softfloat_roundMToUI64( sign, extSig, roundingMode, exact SOFTFLOAT_STATE_ARG_COMMA);
    9393#endif
    9494

  • trunk/src/libs/softfloat-3e/source/f32_to_ui64_r_minMag.c

    r94480 r94558  
    4242#include "softfloat.h"
    4343
    44 uint_fast64_t f32_to_ui64_r_minMag( float32_t a, bool exact )
     44uint_fast64_t f32_to_ui64_r_minMag( float32_t a, bool exact SOFTFLOAT_STATE_DECL_COMMA )
    4545{
    4646    union ui32_f32 uA;
    … …  
    7171    sign = signF32UI( uiA );
    7272    if ( sign || (shiftDist < 0) ) {
    73         softfloat_raiseFlags( softfloat_flag_invalid );
     73        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    7474        return
    7575            (exp == 0xFF) && sig ? ui64_fromNaN

  • trunk/src/libs/softfloat-3e/source/f64_add.c

    r94480 r94558  
    4141#include "softfloat.h"
    4242
    43 float64_t f64_add( float64_t a, float64_t b )
     43float64_t f64_add( float64_t a, float64_t b SOFTFLOAT_STATE_DECL_COMMA )
    4444{
    4545    union ui64_f64 uA;
    … …  
    5050    bool signB;
    5151#if ! defined INLINE_LEVEL || (INLINE_LEVEL < 2)
    52     float64_t (*magsFuncPtr)( uint_fast64_t, uint_fast64_t, bool );
     52    float64_t (*magsFuncPtr)( uint_fast64_t, uint_fast64_t, bool SOFTFLOAT_STATE_DECL_COMMA );
    5353#endif
    5454
    … …  
    6161#if defined INLINE_LEVEL && (2 <= INLINE_LEVEL)
    6262    if ( signA == signB ) {
    63         return softfloat_addMagsF64( uiA, uiB, signA );
     63        return softfloat_addMagsF64( uiA, uiB, signA SOFTFLOAT_STATE_ARG_COMMA );
    6464    } else {
    65         return softfloat_subMagsF64( uiA, uiB, signA );
     65        return softfloat_subMagsF64( uiA, uiB, signA SOFTFLOAT_STATE_ARG_COMMA );
    6666    }
    6767#else
    6868    magsFuncPtr =
    6969        (signA == signB) ? softfloat_addMagsF64 : softfloat_subMagsF64;
    70     return (*magsFuncPtr)( uiA, uiB, signA );
     70    return (*magsFuncPtr)( uiA, uiB, signA SOFTFLOAT_STATE_ARG_COMMA );
    7171#endif
    7272

  • trunk/src/libs/softfloat-3e/source/f64_div.c

    r94480 r94558  
    4242#include "softfloat.h"
    4343
    44 float64_t f64_div( float64_t a, float64_t b )
     44float64_t f64_div( float64_t a, float64_t b SOFTFLOAT_STATE_DECL_COMMA )
    4545{
    4646    union ui64_f64 uA;
    … …  
    9696        if ( ! sigB ) {
    9797            if ( ! (expA | sigA) ) goto invalid;
    98             softfloat_raiseFlags( softfloat_flag_infinite );
     98            softfloat_raiseFlags( softfloat_flag_infinite SOFTFLOAT_STATE_ARG_COMMA );
    9999            goto infinity;
    100100        }
    … …  
    144144        }
    145145    }
    146     return softfloat_roundPackToF64( signZ, expZ, sigZ );
     146    return softfloat_roundPackToF64( signZ, expZ, sigZ SOFTFLOAT_STATE_ARG_COMMA );
    147147    /*------------------------------------------------------------------------
    148148    *------------------------------------------------------------------------*/
    149149 propagateNaN:
    150     uiZ = softfloat_propagateNaNF64UI( uiA, uiB );
     150    uiZ = softfloat_propagateNaNF64UI( uiA, uiB SOFTFLOAT_STATE_ARG_COMMA );
    151151    goto uiZ;
    152152    /*------------------------------------------------------------------------
    153153    *------------------------------------------------------------------------*/
    154154 invalid:
    155     softfloat_raiseFlags( softfloat_flag_invalid );
     155    softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    156156    uiZ = defaultNaNF64UI;
    157157    goto uiZ;

  • trunk/src/libs/softfloat-3e/source/f64_eq.c

    r94480 r94558  
    4242#include "softfloat.h"
    4343
    44 bool f64_eq( float64_t a, float64_t b )
     44bool f64_eq( float64_t a, float64_t b SOFTFLOAT_STATE_DECL_COMMA )
    4545{
    4646    union ui64_f64 uA;
    … …  
    5757            softfloat_isSigNaNF64UI( uiA ) || softfloat_isSigNaNF64UI( uiB )
    5858        ) {
    59             softfloat_raiseFlags( softfloat_flag_invalid );
     59            softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    6060        }
    6161        return false;

  • trunk/src/libs/softfloat-3e/source/f64_eq_signaling.c

    r94480 r94558  
    4141#include "softfloat.h"
    4242
    43 bool f64_eq_signaling( float64_t a, float64_t b )
     43bool f64_eq_signaling( float64_t a, float64_t b SOFTFLOAT_STATE_DECL_COMMA )
    4444{
    4545    union ui64_f64 uA;
    … …  
    5353    uiB = uB.ui;
    5454    if ( isNaNF64UI( uiA ) || isNaNF64UI( uiB ) ) {
    55         softfloat_raiseFlags( softfloat_flag_invalid );
     55        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    5656        return false;
    5757    }

  • trunk/src/libs/softfloat-3e/source/f64_le.c

    r94480 r94558  
    4141#include "softfloat.h"
    4242
    43 bool f64_le( float64_t a, float64_t b )
     43bool f64_le( float64_t a, float64_t b SOFTFLOAT_STATE_DECL_COMMA )
    4444{
    4545    union ui64_f64 uA;
    … …  
    5454    uiB = uB.ui;
    5555    if ( isNaNF64UI( uiA ) || isNaNF64UI( uiB ) ) {
    56         softfloat_raiseFlags( softfloat_flag_invalid );
     56        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    5757        return false;
    5858    }

  • trunk/src/libs/softfloat-3e/source/f64_le_quiet.c

    r94480 r94558  
    4242#include "softfloat.h"
    4343
    44 bool f64_le_quiet( float64_t a, float64_t b )
     44bool f64_le_quiet( float64_t a, float64_t b SOFTFLOAT_STATE_DECL_COMMA )
    4545{
    4646    union ui64_f64 uA;
    … …  
    5858            softfloat_isSigNaNF64UI( uiA ) || softfloat_isSigNaNF64UI( uiB )
    5959        ) {
    60             softfloat_raiseFlags( softfloat_flag_invalid );
     60            softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    6161        }
    6262        return false;

  • trunk/src/libs/softfloat-3e/source/f64_lt.c

    r94480 r94558  
    4141#include "softfloat.h"
    4242
    43 bool f64_lt( float64_t a, float64_t b )
     43bool f64_lt( float64_t a, float64_t b SOFTFLOAT_STATE_DECL_COMMA )
    4444{
    4545    union ui64_f64 uA;
    … …  
    5454    uiB = uB.ui;
    5555    if ( isNaNF64UI( uiA ) || isNaNF64UI( uiB ) ) {
    56         softfloat_raiseFlags( softfloat_flag_invalid );
     56        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    5757        return false;
    5858    }

  • trunk/src/libs/softfloat-3e/source/f64_lt_quiet.c

    r94480 r94558  
    4242#include "softfloat.h"
    4343
    44 bool f64_lt_quiet( float64_t a, float64_t b )
     44bool f64_lt_quiet( float64_t a, float64_t b SOFTFLOAT_STATE_DECL_COMMA )
    4545{
    4646    union ui64_f64 uA;
    … …  
    5858            softfloat_isSigNaNF64UI( uiA ) || softfloat_isSigNaNF64UI( uiB )
    5959        ) {
    60             softfloat_raiseFlags( softfloat_flag_invalid );
     60            softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    6161        }
    6262        return false;

  • trunk/src/libs/softfloat-3e/source/f64_mul.c

    r94480 r94558  
    4242#include "softfloat.h"
    4343
    44 float64_t f64_mul( float64_t a, float64_t b )
     44float64_t f64_mul( float64_t a, float64_t b SOFTFLOAT_STATE_DECL_COMMA )
    4545{
    4646    union ui64_f64 uA;
    … …  
    123123        sigZ <<= 1;
    124124    }
    125     return softfloat_roundPackToF64( signZ, expZ, sigZ );
     125    return softfloat_roundPackToF64( signZ, expZ, sigZ SOFTFLOAT_STATE_ARG_COMMA );
    126126    /*------------------------------------------------------------------------
    127127    *------------------------------------------------------------------------*/
    128128 propagateNaN:
    129     uiZ = softfloat_propagateNaNF64UI( uiA, uiB );
     129    uiZ = softfloat_propagateNaNF64UI( uiA, uiB SOFTFLOAT_STATE_ARG_COMMA );
    130130    goto uiZ;
    131131    /*------------------------------------------------------------------------
    … …  
    133133 infArg:
    134134    if ( ! magBits ) {
    135         softfloat_raiseFlags( softfloat_flag_invalid );
     135        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    136136        uiZ = defaultNaNF64UI;
    137137    } else {

  • trunk/src/libs/softfloat-3e/source/f64_mulAdd.c

    r94480 r94558  
    4040#include "softfloat.h"
    4141
    42 float64_t f64_mulAdd( float64_t a, float64_t b, float64_t c )
     42float64_t f64_mulAdd( float64_t a, float64_t b, float64_t c SOFTFLOAT_STATE_DECL_COMMA )
    4343{
    4444    union ui64_f64 uA;
    … …  
    5555    uC.f = c;
    5656    uiC = uC.ui;
    57     return softfloat_mulAddF64( uiA, uiB, uiC, 0 );
     57    return softfloat_mulAddF64( uiA, uiB, uiC, 0 SOFTFLOAT_STATE_ARG_COMMA );
    5858
    5959}

  • trunk/src/libs/softfloat-3e/source/f64_rem.c

    r94480 r94558  
    4242#include "softfloat.h"
    4343
    44 float64_t f64_rem( float64_t a, float64_t b )
     44float64_t f64_rem( float64_t a, float64_t b SOFTFLOAT_STATE_DECL_COMMA )
    4545{
    4646    union ui64_f64 uA;
    … …  
    173173        rem = -rem;
    174174    }
    175     return softfloat_normRoundPackToF64( signRem, expB, rem );
     175    return softfloat_normRoundPackToF64( signRem, expB, rem SOFTFLOAT_STATE_ARG_COMMA );
    176176    /*------------------------------------------------------------------------
    177177    *------------------------------------------------------------------------*/
    178178 propagateNaN:
    179     uiZ = softfloat_propagateNaNF64UI( uiA, uiB );
     179    uiZ = softfloat_propagateNaNF64UI( uiA, uiB SOFTFLOAT_STATE_ARG_COMMA );
    180180    goto uiZ;
    181181 invalid:
    182     softfloat_raiseFlags( softfloat_flag_invalid );
     182    softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    183183    uiZ = defaultNaNF64UI;
    184184 uiZ:

  • trunk/src/libs/softfloat-3e/source/f64_roundToInt.c

    r94548 r94558  
    4343#include <iprt/cdefs.h> /* VBox: for RT_FALL_THROUGH */
    4444
    45 float64_t f64_roundToInt( float64_t a, uint_fast8_t roundingMode, bool exact )
     45float64_t f64_roundToInt( float64_t a, uint_fast8_t roundingMode, bool exact SOFTFLOAT_STATE_DECL_COMMA )
    4646{
    4747    union ui64_f64 uA;
    … …  
    8787    if ( 0x433 <= exp ) {
    8888        if ( (exp == 0x7FF) && fracF64UI( uiA ) ) {
    89             uiZ = softfloat_propagateNaNF64UI( uiA, 0 );
     89            uiZ = softfloat_propagateNaNF64UI( uiA, 0 SOFTFLOAT_STATE_ARG_COMMA );
    9090            goto uiZ;
    9191        }

  • trunk/src/libs/softfloat-3e/source/f64_sqrt.c

    r94480 r94558  
    4242#include "softfloat.h"
    4343
    44 float64_t f64_sqrt( float64_t a )
     44float64_t f64_sqrt( float64_t a SOFTFLOAT_STATE_DECL_COMMA )
    4545{
    4646    union ui64_f64 uA;
    … …  
    6868    if ( expA == 0x7FF ) {
    6969        if ( sigA ) {
    70             uiZ = softfloat_propagateNaNF64UI( uiA, 0 );
     70            uiZ = softfloat_propagateNaNF64UI( uiA, 0 SOFTFLOAT_STATE_ARG_COMMA );
    7171            goto uiZ;
    7272        }
    … …  
    120120        }
    121121    }
    122     return softfloat_roundPackToF64( 0, expZ, sigZ );
     122    return softfloat_roundPackToF64( 0, expZ, sigZ SOFTFLOAT_STATE_ARG_COMMA );
    123123    /*------------------------------------------------------------------------
    124124    *------------------------------------------------------------------------*/
    125125 invalid:
    126     softfloat_raiseFlags( softfloat_flag_invalid );
     126    softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    127127    uiZ = defaultNaNF64UI;
    128128 uiZ:

  • trunk/src/libs/softfloat-3e/source/f64_sub.c

    r94480 r94558  
    4141#include "softfloat.h"
    4242
    43 float64_t f64_sub( float64_t a, float64_t b )
     43float64_t f64_sub( float64_t a, float64_t b SOFTFLOAT_STATE_DECL_COMMA )
    4444{
    4545    union ui64_f64 uA;
    … …  
    5050    bool signB;
    5151#if ! defined INLINE_LEVEL || (INLINE_LEVEL < 2)
    52     float64_t (*magsFuncPtr)( uint_fast64_t, uint_fast64_t, bool );
     52    float64_t (*magsFuncPtr)( uint_fast64_t, uint_fast64_t, bool SOFTFLOAT_STATE_DECL_COMMA );
    5353#endif
    5454
    … …  
    6161#if defined INLINE_LEVEL && (2 <= INLINE_LEVEL)
    6262    if ( signA == signB ) {
    63         return softfloat_subMagsF64( uiA, uiB, signA );
     63        return softfloat_subMagsF64( uiA, uiB, signA SOFTFLOAT_STATE_ARG_COMMA );
    6464    } else {
    65         return softfloat_addMagsF64( uiA, uiB, signA );
     65        return softfloat_addMagsF64( uiA, uiB, signA SOFTFLOAT_STATE_ARG_COMMA );
    6666    }
    6767#else
    6868    magsFuncPtr =
    6969        (signA == signB) ? softfloat_subMagsF64 : softfloat_addMagsF64;
    70     return (*magsFuncPtr)( uiA, uiB, signA );
     70    return (*magsFuncPtr)( uiA, uiB, signA SOFTFLOAT_STATE_ARG_COMMA );
    7171#endif
    7272

  • trunk/src/libs/softfloat-3e/source/f64_to_extF80.c

    r94480 r94558  
    4242#include "softfloat.h"
    4343
    44 extFloat80_t f64_to_extF80( float64_t a )
     44extFloat80_t f64_to_extF80( float64_t a SOFTFLOAT_STATE_DECL_COMMA )
    4545{
    4646    union ui64_f64 uA;
    … …  
    6767    if ( exp == 0x7FF ) {
    6868        if ( frac ) {
    69             softfloat_f64UIToCommonNaN( uiA, &commonNaN );
     69            softfloat_f64UIToCommonNaN( uiA, &commonNaN SOFTFLOAT_STATE_ARG_COMMA );
    7070            uiZ = softfloat_commonNaNToExtF80UI( &commonNaN );
    7171            uiZ64 = uiZ.v64;

  • trunk/src/libs/softfloat-3e/source/f64_to_extF80M.c

    r94480 r94558  
    4444#ifdef SOFTFLOAT_FAST_INT64
    4545
    46 void f64_to_extF80M( float64_t a, extFloat80_t *zPtr )
     46void f64_to_extF80M( float64_t a, extFloat80_t *zPtr SOFTFLOAT_STATE_DECL_COMMA )
    4747{
    4848
    49     *zPtr = f64_to_extF80( a );
     49    *zPtr = f64_to_extF80( a SOFTFLOAT_STATE_ARG_COMMA );
    5050
    5151}
    … …  
    5353#else
    5454
    55 void f64_to_extF80M( float64_t a, extFloat80_t *zPtr )
     55void f64_to_extF80M( float64_t a, extFloat80_t *zPtr SOFTFLOAT_STATE_DECL_COMMA )
    5656{
    5757    struct extFloat80M *zSPtr;
    … …  
    7878    if ( exp == 0x7FF ) {
    7979        if ( frac ) {
    80             softfloat_f64UIToCommonNaN( uiA, &commonNaN );
     80            softfloat_f64UIToCommonNaN( uiA, &commonNaN SOFTFLOAT_STATE_ARG_COMMA );
    8181            softfloat_commonNaNToExtF80M( &commonNaN, zSPtr );
    8282            return;

  • trunk/src/libs/softfloat-3e/source/f64_to_f128.c

    r94480 r94558  
    4242#include "softfloat.h"
    4343
    44 float128_t f64_to_f128( float64_t a )
     44float128_t f64_to_f128( float64_t a SOFTFLOAT_STATE_DECL_COMMA )
    4545{
    4646    union ui64_f64 uA;
    … …  
    6666    if ( exp == 0x7FF ) {
    6767        if ( frac ) {
    68             softfloat_f64UIToCommonNaN( uiA, &commonNaN );
     68            softfloat_f64UIToCommonNaN( uiA, &commonNaN SOFTFLOAT_STATE_ARG_COMMA );
    6969            uiZ = softfloat_commonNaNToF128UI( &commonNaN );
    7070        } else {

  • trunk/src/libs/softfloat-3e/source/f64_to_f128M.c

    r94480 r94558  
    4444#ifdef SOFTFLOAT_FAST_INT64
    4545
    46 void f64_to_f128M( float64_t a, float128_t *zPtr )
     46void f64_to_f128M( float64_t a, float128_t *zPtr SOFTFLOAT_STATE_DECL_COMMA )
    4747{
    4848
    49     *zPtr = f64_to_f128( a );
     49    *zPtr = f64_to_f128( a SOFTFLOAT_STATE_ARG_COMMA );
    5050
    5151}
    … …  
    5353#else
    5454
    55 void f64_to_f128M( float64_t a, float128_t *zPtr )
     55void f64_to_f128M( float64_t a, float128_t *zPtr SOFTFLOAT_STATE_DECL_COMMA )
    5656{
    5757    uint32_t *zWPtr;
    … …  
    8080    if ( exp == 0x7FF ) {
    8181        if ( frac ) {
    82             softfloat_f64UIToCommonNaN( uiA, &commonNaN );
     82            softfloat_f64UIToCommonNaN( uiA, &commonNaN SOFTFLOAT_STATE_ARG_COMMA );
    8383            softfloat_commonNaNToF128M( &commonNaN, zWPtr );
    8484            return;

  • trunk/src/libs/softfloat-3e/source/f64_to_f16.c

    r94480 r94558  
    4242#include "softfloat.h"
    4343
    44 float16_t f64_to_f16( float64_t a )
     44float16_t f64_to_f16( float64_t a SOFTFLOAT_STATE_DECL_COMMA )
    4545{
    4646    union ui64_f64 uA;
    … …  
    6464    if ( exp == 0x7FF ) {
    6565        if ( frac ) {
    66             softfloat_f64UIToCommonNaN( uiA, &commonNaN );
     66            softfloat_f64UIToCommonNaN( uiA, &commonNaN SOFTFLOAT_STATE_ARG_COMMA );
    6767            uiZ = softfloat_commonNaNToF16UI( &commonNaN );
    6868        } else {
    … …  
    8080    /*------------------------------------------------------------------------
    8181    *------------------------------------------------------------------------*/
    82     return softfloat_roundPackToF16( sign, exp - 0x3F1, frac16 | 0x4000 );
     82    return softfloat_roundPackToF16( sign, exp - 0x3F1, frac16 | 0x4000 SOFTFLOAT_STATE_ARG_COMMA );
    8383 uiZ:
    8484    uZ.ui = uiZ;

  • trunk/src/libs/softfloat-3e/source/f64_to_f32.c

    r94480 r94558  
    4242#include "softfloat.h"
    4343
    44 float32_t f64_to_f32( float64_t a )
     44float32_t f64_to_f32( float64_t a SOFTFLOAT_STATE_DECL_COMMA )
    4545{
    4646    union ui64_f64 uA;
    … …  
    6464    if ( exp == 0x7FF ) {
    6565        if ( frac ) {
    66             softfloat_f64UIToCommonNaN( uiA, &commonNaN );
     66            softfloat_f64UIToCommonNaN( uiA, &commonNaN SOFTFLOAT_STATE_ARG_COMMA );
    6767            uiZ = softfloat_commonNaNToF32UI( &commonNaN );
    6868        } else {
    … …  
    8080    /*------------------------------------------------------------------------
    8181    *------------------------------------------------------------------------*/
    82     return softfloat_roundPackToF32( sign, exp - 0x381, frac32 | 0x40000000 );
     82    return softfloat_roundPackToF32( sign, exp - 0x381, frac32 | 0x40000000 SOFTFLOAT_STATE_ARG_COMMA );
    8383 uiZ:
    8484    uZ.ui = uiZ;

  • trunk/src/libs/softfloat-3e/source/f64_to_i32.c

    r94480 r94558  
    4242#include "softfloat.h"
    4343
    44 int_fast32_t f64_to_i32( float64_t a, uint_fast8_t roundingMode, bool exact )
     44int_fast32_t f64_to_i32( float64_t a, uint_fast8_t roundingMode, bool exact SOFTFLOAT_STATE_DECL_COMMA )
    4545{
    4646    union ui64_f64 uA;
    … …  
    6767        sign = 1;
    6868#else
    69         softfloat_raiseFlags( softfloat_flag_invalid );
     69        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    7070        return i32_fromNaN;
    7171#endif
    … …  
    7777    shiftDist = 0x427 - exp;
    7878    if ( 0 < shiftDist ) sig = softfloat_shiftRightJam64( sig, shiftDist );
    79     return softfloat_roundToI32( sign, sig, roundingMode, exact );
     79    return softfloat_roundToI32( sign, sig, roundingMode, exact SOFTFLOAT_STATE_ARG_COMMA );
    8080
    8181}

  • trunk/src/libs/softfloat-3e/source/f64_to_i32_r_minMag.c

    r94480 r94558  
    4242#include "softfloat.h"
    4343
    44 int_fast32_t f64_to_i32_r_minMag( float64_t a, bool exact )
     44int_fast32_t f64_to_i32_r_minMag( float64_t a, bool exact SOFTFLOAT_STATE_DECL_COMMA )
    4545{
    4646    union ui64_f64 uA;
    … …  
    7979            return -0x7FFFFFFF - 1;
    8080        }
    81         softfloat_raiseFlags( softfloat_flag_invalid );
     81        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    8282        return
    8383            (exp == 0x7FF) && sig ? i32_fromNaN

  • trunk/src/libs/softfloat-3e/source/f64_to_i64.c

    r94480 r94558  
    4242#include "softfloat.h"
    4343
    44 int_fast64_t f64_to_i64( float64_t a, uint_fast8_t roundingMode, bool exact )
     44int_fast64_t f64_to_i64( float64_t a, uint_fast8_t roundingMode, bool exact SOFTFLOAT_STATE_DECL_COMMA )
    4545{
    4646    union ui64_f64 uA;
    … …  
    7777    return
    7878        softfloat_roundToI64(
    79             sign, sigExtra.v, sigExtra.extra, roundingMode, exact );
     79            sign, sigExtra.v, sigExtra.extra, roundingMode, exact SOFTFLOAT_STATE_ARG_COMMA );
    8080#else
    8181    extSig[indexWord( 3, 0 )] = 0;
    … …  
    9090        softfloat_shiftRightJam96M( extSig, shiftDist, extSig );
    9191    }
    92     return softfloat_roundMToI64( sign, extSig, roundingMode, exact );
     92    return softfloat_roundMToI64( sign, extSig, roundingMode, exact SOFTFLOAT_STATE_ARG_COMMA );
    9393#endif
    9494    /*------------------------------------------------------------------------
    9595    *------------------------------------------------------------------------*/
    9696 invalid:
    97     softfloat_raiseFlags( softfloat_flag_invalid );
     97    softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    9898    return
    9999        (exp == 0x7FF) && fracF64UI( uiA ) ? i64_fromNaN

  • trunk/src/libs/softfloat-3e/source/f64_to_i64_r_minMag.c

    r94480 r94558  
    4242#include "softfloat.h"
    4343
    44 int_fast64_t f64_to_i64_r_minMag( float64_t a, bool exact )
     44int_fast64_t f64_to_i64_r_minMag( float64_t a, bool exact SOFTFLOAT_STATE_DECL_COMMA )
    4545{
    4646    union ui64_f64 uA;
    … …  
    6969                return -INT64_C( 0x7FFFFFFFFFFFFFFF ) - 1;
    7070            }
    71             softfloat_raiseFlags( softfloat_flag_invalid );
     71            softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    7272            return
    7373                (exp == 0x7FF) && sig ? i64_fromNaN

  • trunk/src/libs/softfloat-3e/source/f64_to_ui32.c

    r94480 r94558  
    4242#include "softfloat.h"
    4343
    44 uint_fast32_t f64_to_ui32( float64_t a, uint_fast8_t roundingMode, bool exact )
     44uint_fast32_t f64_to_ui32( float64_t a, uint_fast8_t roundingMode, bool exact SOFTFLOAT_STATE_DECL_COMMA )
    4545{
    4646    union ui64_f64 uA;
    … …  
    6767        sign = 1;
    6868#else
    69         softfloat_raiseFlags( softfloat_flag_invalid );
     69        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    7070        return ui32_fromNaN;
    7171#endif
    … …  
    7777    shiftDist = 0x427 - exp;
    7878    if ( 0 < shiftDist ) sig = softfloat_shiftRightJam64( sig, shiftDist );
    79     return softfloat_roundToUI32( sign, sig, roundingMode, exact );
     79    return softfloat_roundToUI32( sign, sig, roundingMode, exact SOFTFLOAT_STATE_ARG_COMMA );
    8080
    8181}

  • trunk/src/libs/softfloat-3e/source/f64_to_ui32_r_minMag.c

    r94480 r94558  
    4242#include "softfloat.h"
    4343
    44 uint_fast32_t f64_to_ui32_r_minMag( float64_t a, bool exact )
     44uint_fast32_t f64_to_ui32_r_minMag( float64_t a, bool exact SOFTFLOAT_STATE_DECL_COMMA )
    4545{
    4646    union ui64_f64 uA;
    … …  
    7171    sign = signF64UI( uiA );
    7272    if ( sign || (shiftDist < 21) ) {
    73         softfloat_raiseFlags( softfloat_flag_invalid );
     73        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    7474        return
    7575            (exp == 0x7FF) && sig ? ui32_fromNaN

  • trunk/src/libs/softfloat-3e/source/f64_to_ui64.c

    r94480 r94558  
    4242#include "softfloat.h"
    4343
    44 uint_fast64_t f64_to_ui64( float64_t a, uint_fast8_t roundingMode, bool exact )
     44uint_fast64_t f64_to_ui64( float64_t a, uint_fast8_t roundingMode, bool exact SOFTFLOAT_STATE_DECL_COMMA )
    4545{
    4646    union ui64_f64 uA;
    … …  
    7777    return
    7878        softfloat_roundToUI64(
    79             sign, sigExtra.v, sigExtra.extra, roundingMode, exact );
     79            sign, sigExtra.v, sigExtra.extra, roundingMode, exact SOFTFLOAT_STATE_ARG_COMMA );
    8080#else
    8181    extSig[indexWord( 3, 0 )] = 0;
    … …  
    9090        softfloat_shiftRightJam96M( extSig, shiftDist, extSig );
    9191    }
    92     return softfloat_roundMToUI64( sign, extSig, roundingMode, exact );
     92    return softfloat_roundMToUI64( sign, extSig, roundingMode, exact SOFTFLOAT_STATE_ARG_COMMA);
    9393#endif
    9494    /*------------------------------------------------------------------------
    9595    *------------------------------------------------------------------------*/
    9696 invalid:
    97     softfloat_raiseFlags( softfloat_flag_invalid );
     97    softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    9898    return
    9999        (exp == 0x7FF) && fracF64UI( uiA ) ? ui64_fromNaN

  • trunk/src/libs/softfloat-3e/source/f64_to_ui64_r_minMag.c

    r94480 r94558  
    4242#include "softfloat.h"
    4343
    44 uint_fast64_t f64_to_ui64_r_minMag( float64_t a, bool exact )
     44uint_fast64_t f64_to_ui64_r_minMag( float64_t a, bool exact SOFTFLOAT_STATE_DECL_COMMA )
    4545{
    4646    union ui64_f64 uA;
    … …  
    8585    *------------------------------------------------------------------------*/
    8686 invalid:
    87     softfloat_raiseFlags( softfloat_flag_invalid );
     87    softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    8888    return
    8989        (exp == 0x7FF) && sig ? ui64_fromNaN

  • trunk/src/libs/softfloat-3e/source/i32_to_extF80.c

    r94480 r94558  
    4141#include "softfloat.h"
    4242
    43 extFloat80_t i32_to_extF80( int32_t a )
     43extFloat80_t i32_to_extF80( int32_t a SOFTFLOAT_STATE_DECL_COMMA )
    4444{
    4545    uint_fast16_t uiZ64;
    … …  
    4848    int_fast8_t shiftDist;
    4949    union { struct extFloat80M s; extFloat80_t f; } uZ;
     50    SOFTFLOAT_STATE_NOREF();
    5051
    5152    uiZ64 = 0;

  • trunk/src/libs/softfloat-3e/source/i32_to_extF80M.c

    r94480 r94558  
    4242#ifdef SOFTFLOAT_FAST_INT64
    4343
    44 void i32_to_extF80M( int32_t a, extFloat80_t *zPtr )
     44void i32_to_extF80M( int32_t a, extFloat80_t *zPtr SOFTFLOAT_STATE_DECL_COMMA )
    4545{
    4646
    47     *zPtr = i32_to_extF80( a );
     47    *zPtr = i32_to_extF80( a SOFTFLOAT_STATE_ARG_COMMA );
    4848
    4949}
    … …  
    5151#else
    5252
    53 void i32_to_extF80M( int32_t a, extFloat80_t *zPtr )
     53void i32_to_extF80M( int32_t a, extFloat80_t *zPtr SOFTFLOAT_STATE_DECL_COMMA )
    5454{
    5555    struct extFloat80M *zSPtr;
    … …  
    5959    uint32_t absA;
    6060    int_fast8_t shiftDist;
     61    SOFTFLOAT_STATE_NOREF();
    6162
    6263    zSPtr = (struct extFloat80M *) zPtr;

  • trunk/src/libs/softfloat-3e/source/i32_to_f128.c

    r94480 r94558  
    4040#include "softfloat.h"
    4141
    42 float128_t i32_to_f128( int32_t a )
     42float128_t i32_to_f128( int32_t a SOFTFLOAT_STATE_DECL_COMMA )
    4343{
    4444    uint_fast64_t uiZ64;
    … …  
    4747    int_fast8_t shiftDist;
    4848    union ui128_f128 uZ;
     49    SOFTFLOAT_STATE_NOREF();
    4950
    5051    uiZ64 = 0;

  • trunk/src/libs/softfloat-3e/source/i32_to_f128M.c

    r94480 r94558  
    4242#ifdef SOFTFLOAT_FAST_INT64
    4343
    44 void i32_to_f128M( int32_t a, float128_t *zPtr )
     44void i32_to_f128M( int32_t a, float128_t *zPtr SOFTFLOAT_STATE_DECL_COMMA )
    4545{
    4646
    47     *zPtr = i32_to_f128( a );
     47    *zPtr = i32_to_f128( a SOFTFLOAT_STATE_ARG_COMMA );
    4848
    4949}
    … …  
    5151#else
    5252
    53 void i32_to_f128M( int32_t a, float128_t *zPtr )
     53void i32_to_f128M( int32_t a, float128_t *zPtr SOFTFLOAT_STATE_DECL_COMMA )
    5454{
    5555    uint32_t *zWPtr;
    … …  
    5959    int_fast8_t shiftDist;
    6060    uint64_t normAbsA;
     61    SOFTFLOAT_STATE_NOREF();
    6162
    6263    zWPtr = (uint32_t *) zPtr;

  • trunk/src/libs/softfloat-3e/source/i32_to_f16.c

    r94480 r94558  
    4141#include "softfloat.h"
    4242
    43 float16_t i32_to_f16( int32_t a )
     43float16_t i32_to_f16( int32_t a SOFTFLOAT_STATE_DECL_COMMA )
    4444{
    4545    bool sign;
    … …  
    6565                      | ((uint32_t) (absA<<(shiftDist & 31)) != 0)
    6666                : (uint_fast16_t) absA<<shiftDist;
    67         return softfloat_roundPackToF16( sign, 0x1C - shiftDist, sig );
     67        return softfloat_roundPackToF16( sign, 0x1C - shiftDist, sig SOFTFLOAT_STATE_ARG_COMMA );
    6868    }
    6969

  • trunk/src/libs/softfloat-3e/source/i32_to_f32.c

    r94480 r94558  
    4141#include "softfloat.h"
    4242
    43 float32_t i32_to_f32( int32_t a )
     43float32_t i32_to_f32( int32_t a SOFTFLOAT_STATE_DECL_COMMA )
    4444{
    4545    bool sign;
    … …  
    5353    }
    5454    absA = sign ? -(uint_fast32_t) a : (uint_fast32_t) a;
    55     return softfloat_normRoundPackToF32( sign, 0x9C, absA );
     55    return softfloat_normRoundPackToF32( sign, 0x9C, absA SOFTFLOAT_STATE_ARG_COMMA );
    5656
    5757}

  • trunk/src/libs/softfloat-3e/source/i32_to_f64.c

    r94480 r94558  
    4141#include "softfloat.h"
    4242
    43 float64_t i32_to_f64( int32_t a )
     43float64_t i32_to_f64( int32_t a SOFTFLOAT_STATE_DECL_COMMA )
    4444{
    4545    uint_fast64_t uiZ;
    … …  
    4848    int_fast8_t shiftDist;
    4949    union ui64_f64 uZ;
     50    SOFTFLOAT_STATE_NOREF();
    5051
    5152    if ( ! a ) {

  • trunk/src/libs/softfloat-3e/source/i64_to_extF80.c

    r94480 r94558  
    4141#include "softfloat.h"
    4242
    43 extFloat80_t i64_to_extF80( int64_t a )
     43extFloat80_t i64_to_extF80( int64_t a SOFTFLOAT_STATE_DECL_COMMA )
    4444{
    4545    uint_fast16_t uiZ64;
    … …  
    4848    int_fast8_t shiftDist;
    4949    union { struct extFloat80M s; extFloat80_t f; } uZ;
     50    SOFTFLOAT_STATE_NOREF();
    5051
    5152    uiZ64 = 0;

  • trunk/src/libs/softfloat-3e/source/i64_to_extF80M.c

    r94480 r94558  
    4242#ifdef SOFTFLOAT_FAST_INT64
    4343
    44 void i64_to_extF80M( int64_t a, extFloat80_t *zPtr )
     44void i64_to_extF80M( int64_t a, extFloat80_t *zPtr SOFTFLOAT_STATE_DECL_COMMA )
    4545{
    4646
    47     *zPtr = i64_to_extF80( a );
     47    *zPtr = i64_to_extF80( a SOFTFLOAT_STATE_ARG_COMMA );
    4848
    4949}
    … …  
    5151#else
    5252
    53 void i64_to_extF80M( int64_t a, extFloat80_t *zPtr )
     53void i64_to_extF80M( int64_t a, extFloat80_t *zPtr SOFTFLOAT_STATE_DECL_COMMA )
    5454{
    5555    struct extFloat80M *zSPtr;
    … …  
    5959    uint64_t absA;
    6060    int_fast8_t shiftDist;
     61    SOFTFLOAT_STATE_NOREF();
    6162
    6263    zSPtr = (struct extFloat80M *) zPtr;

  • trunk/src/libs/softfloat-3e/source/i64_to_f128.c

    r94480 r94558  
    4040#include "softfloat.h"
    4141
    42 float128_t i64_to_f128( int64_t a )
     42float128_t i64_to_f128( int64_t a SOFTFLOAT_STATE_DECL_COMMA )
    4343{
    4444    uint_fast64_t uiZ64, uiZ0;
    … …  
    4848    struct uint128 zSig;
    4949    union ui128_f128 uZ;
     50    SOFTFLOAT_STATE_NOREF();
    5051
    5152    if ( ! a ) {

  • trunk/src/libs/softfloat-3e/source/i64_to_f128M.c

    r94480 r94558  
    4242#ifdef SOFTFLOAT_FAST_INT64
    4343
    44 void i64_to_f128M( int64_t a, float128_t *zPtr )
     44void i64_to_f128M( int64_t a, float128_t *zPtr SOFTFLOAT_STATE_DECL_COMMA )
    4545{
    4646
    47     *zPtr = i64_to_f128( a );
     47    *zPtr = i64_to_f128( a SOFTFLOAT_STATE_ARG_COMMA );
    4848
    4949}
    … …  
    5151#else
    5252
    53 void i64_to_f128M( int64_t a, float128_t *zPtr )
     53void i64_to_f128M( int64_t a, float128_t *zPtr SOFTFLOAT_STATE_DECL_COMMA )
    5454{
    5555    uint32_t *zWPtr;
    … …  
    5959    uint_fast8_t shiftDist;
    6060    uint32_t *ptr;
     61    SOFTFLOAT_STATE_NOREF();
    6162
    6263    zWPtr = (uint32_t *) zPtr;

  • trunk/src/libs/softfloat-3e/source/i64_to_f16.c

    r94480 r94558  
    4141#include "softfloat.h"
    4242
    43 float16_t i64_to_f16( int64_t a )
     43float16_t i64_to_f16( int64_t a SOFTFLOAT_STATE_DECL_COMMA )
    4444{
    4545    bool sign;
    … …  
    6464                ? softfloat_shortShiftRightJam64( absA, -shiftDist )
    6565                : (uint_fast16_t) absA<<shiftDist;
    66         return softfloat_roundPackToF16( sign, 0x1C - shiftDist, sig );
     66        return softfloat_roundPackToF16( sign, 0x1C - shiftDist, sig SOFTFLOAT_STATE_ARG_COMMA );
    6767    }
    6868

  • trunk/src/libs/softfloat-3e/source/i64_to_f32.c

    r94480 r94558  
    4141#include "softfloat.h"
    4242
    43 float32_t i64_to_f32( int64_t a )
     43float32_t i64_to_f32( int64_t a SOFTFLOAT_STATE_DECL_COMMA )
    4444{
    4545    bool sign;
    … …  
    6464                ? softfloat_shortShiftRightJam64( absA, -shiftDist )
    6565                : (uint_fast32_t) absA<<shiftDist;
    66         return softfloat_roundPackToF32( sign, 0x9C - shiftDist, sig );
     66        return softfloat_roundPackToF32( sign, 0x9C - shiftDist, sig SOFTFLOAT_STATE_ARG_COMMA );
    6767    }
    6868

  • trunk/src/libs/softfloat-3e/source/i64_to_f64.c

    r94480 r94558  
    4141#include "softfloat.h"
    4242
    43 float64_t i64_to_f64( int64_t a )
     43float64_t i64_to_f64( int64_t a SOFTFLOAT_STATE_DECL_COMMA )
    4444{
    4545    bool sign;
    … …  
    5353    }
    5454    absA = sign ? -(uint_fast64_t) a : (uint_fast64_t) a;
    55     return softfloat_normRoundPackToF64( sign, 0x43C, absA );
     55    return softfloat_normRoundPackToF64( sign, 0x43C, absA SOFTFLOAT_STATE_ARG_COMMA );
    5656
    5757}

  • trunk/src/libs/softfloat-3e/source/include/internals.h

    r94480 r94558  
    5959/*----------------------------------------------------------------------------
    6060*----------------------------------------------------------------------------*/
    61 uint_fast32_t softfloat_roundToUI32( bool, uint_fast64_t, uint_fast8_t, bool );
     61uint_fast32_t softfloat_roundToUI32( bool, uint_fast64_t, uint_fast8_t, bool SOFTFLOAT_STATE_DECL_COMMA );
    6262
    6363#ifdef SOFTFLOAT_FAST_INT64
    6464uint_fast64_t
    6565 softfloat_roundToUI64(
    66      bool, uint_fast64_t, uint_fast64_t, uint_fast8_t, bool );
     66     bool, uint_fast64_t, uint_fast64_t, uint_fast8_t, bool SOFTFLOAT_STATE_DECL_COMMA );
    6767#else
    68 uint_fast64_t softfloat_roundMToUI64( bool, uint32_t *, uint_fast8_t, bool );
    69 #endif
    70 
    71 int_fast32_t softfloat_roundToI32( bool, uint_fast64_t, uint_fast8_t, bool );
     68uint_fast64_t softfloat_roundMToUI64( bool, uint32_t *, uint_fast8_t, bool SOFTFLOAT_STATE_DECL_COMMA );
     69#endif
     70
     71int_fast32_t softfloat_roundToI32( bool, uint_fast64_t, uint_fast8_t, bool SOFTFLOAT_STATE_DECL_COMMA );
    7272
    7373#ifdef SOFTFLOAT_FAST_INT64
    7474int_fast64_t
    7575 softfloat_roundToI64(
    76      bool, uint_fast64_t, uint_fast64_t, uint_fast8_t, bool );
     76     bool, uint_fast64_t, uint_fast64_t, uint_fast8_t, bool SOFTFLOAT_STATE_DECL_COMMA );
    7777#else
    78 int_fast64_t softfloat_roundMToI64( bool, uint32_t *, uint_fast8_t, bool );
     78int_fast64_t softfloat_roundMToI64( bool, uint32_t *, uint_fast8_t, bool SOFTFLOAT_STATE_DECL_COMMA );
    7979#endif
    8080
    … …  
    9191struct exp8_sig16 softfloat_normSubnormalF16Sig( uint_fast16_t );
    9292
    93 float16_t softfloat_roundPackToF16( bool, int_fast16_t, uint_fast16_t );
    94 float16_t softfloat_normRoundPackToF16( bool, int_fast16_t, uint_fast16_t );
    95 
    96 float16_t softfloat_addMagsF16( uint_fast16_t, uint_fast16_t );
    97 float16_t softfloat_subMagsF16( uint_fast16_t, uint_fast16_t );
     93float16_t softfloat_roundPackToF16( bool, int_fast16_t, uint_fast16_t SOFTFLOAT_STATE_DECL_COMMA );
     94float16_t softfloat_normRoundPackToF16( bool, int_fast16_t, uint_fast16_t SOFTFLOAT_STATE_DECL_COMMA );
     95
     96float16_t softfloat_addMagsF16( uint_fast16_t, uint_fast16_t SOFTFLOAT_STATE_DECL_COMMA );
     97float16_t softfloat_subMagsF16( uint_fast16_t, uint_fast16_t SOFTFLOAT_STATE_DECL_COMMA );
    9898float16_t
    9999 softfloat_mulAddF16(
    100      uint_fast16_t, uint_fast16_t, uint_fast16_t, uint_fast8_t );
     100     uint_fast16_t, uint_fast16_t, uint_fast16_t, uint_fast8_t SOFTFLOAT_STATE_DECL_COMMA );
    101101
    102102/*----------------------------------------------------------------------------
    … …  
    112112struct exp16_sig32 softfloat_normSubnormalF32Sig( uint_fast32_t );
    113113
    114 float32_t softfloat_roundPackToF32( bool, int_fast16_t, uint_fast32_t );
    115 float32_t softfloat_normRoundPackToF32( bool, int_fast16_t, uint_fast32_t );
    116 
    117 float32_t softfloat_addMagsF32( uint_fast32_t, uint_fast32_t );
    118 float32_t softfloat_subMagsF32( uint_fast32_t, uint_fast32_t );
     114float32_t softfloat_roundPackToF32( bool, int_fast16_t, uint_fast32_t SOFTFLOAT_STATE_DECL_COMMA );
     115float32_t softfloat_normRoundPackToF32( bool, int_fast16_t, uint_fast32_t SOFTFLOAT_STATE_DECL_COMMA );
     116
     117float32_t softfloat_addMagsF32( uint_fast32_t, uint_fast32_t SOFTFLOAT_STATE_DECL_COMMA );
     118float32_t softfloat_subMagsF32( uint_fast32_t, uint_fast32_t SOFTFLOAT_STATE_DECL_COMMA );
    119119float32_t
    120120 softfloat_mulAddF32(
    121      uint_fast32_t, uint_fast32_t, uint_fast32_t, uint_fast8_t );
     121     uint_fast32_t, uint_fast32_t, uint_fast32_t, uint_fast8_t SOFTFLOAT_STATE_DECL_COMMA );
    122122
    123123/*----------------------------------------------------------------------------
    … …  
    133133struct exp16_sig64 softfloat_normSubnormalF64Sig( uint_fast64_t );
    134134
    135 float64_t softfloat_roundPackToF64( bool, int_fast16_t, uint_fast64_t );
    136 float64_t softfloat_normRoundPackToF64( bool, int_fast16_t, uint_fast64_t );
    137 
    138 float64_t softfloat_addMagsF64( uint_fast64_t, uint_fast64_t, bool );
    139 float64_t softfloat_subMagsF64( uint_fast64_t, uint_fast64_t, bool );
     135float64_t softfloat_roundPackToF64( bool, int_fast16_t, uint_fast64_t SOFTFLOAT_STATE_DECL_COMMA );
     136float64_t softfloat_normRoundPackToF64( bool, int_fast16_t, uint_fast64_t SOFTFLOAT_STATE_DECL_COMMA );
     137
     138float64_t softfloat_addMagsF64( uint_fast64_t, uint_fast64_t, bool SOFTFLOAT_STATE_DECL_COMMA );
     139float64_t softfloat_subMagsF64( uint_fast64_t, uint_fast64_t, bool SOFTFLOAT_STATE_DECL_COMMA );
    140140float64_t
    141141 softfloat_mulAddF64(
    142      uint_fast64_t, uint_fast64_t, uint_fast64_t, uint_fast8_t );
     142     uint_fast64_t, uint_fast64_t, uint_fast64_t, uint_fast8_t SOFTFLOAT_STATE_DECL_COMMA );
    143143
    144144/*----------------------------------------------------------------------------
    … …  
    160160extFloat80_t
    161161 softfloat_roundPackToExtF80(
    162      bool, int_fast32_t, uint_fast64_t, uint_fast64_t, uint_fast8_t );
     162     bool, int_fast32_t, uint_fast64_t, uint_fast64_t, uint_fast8_t SOFTFLOAT_STATE_DECL_COMMA );
    163163extFloat80_t
    164164 softfloat_normRoundPackToExtF80(
    165      bool, int_fast32_t, uint_fast64_t, uint_fast64_t, uint_fast8_t );
     165     bool, int_fast32_t, uint_fast64_t, uint_fast64_t, uint_fast8_t SOFTFLOAT_STATE_DECL_COMMA );
    166166
    167167extFloat80_t
    168168 softfloat_addMagsExtF80(
    169      uint_fast16_t, uint_fast64_t, uint_fast16_t, uint_fast64_t, bool );
     169     uint_fast16_t, uint_fast64_t, uint_fast16_t, uint_fast64_t, bool SOFTFLOAT_STATE_DECL_COMMA );
    170170extFloat80_t
    171171 softfloat_subMagsExtF80(
    172      uint_fast16_t, uint_fast64_t, uint_fast16_t, uint_fast64_t, bool );
     172     uint_fast16_t, uint_fast64_t, uint_fast16_t, uint_fast64_t, bool SOFTFLOAT_STATE_DECL_COMMA );
    173173
    174174/*----------------------------------------------------------------------------
    … …  
    187187float128_t
    188188 softfloat_roundPackToF128(
    189      bool, int_fast32_t, uint_fast64_t, uint_fast64_t, uint_fast64_t );
     189     bool, int_fast32_t, uint_fast64_t, uint_fast64_t, uint_fast64_t SOFTFLOAT_STATE_DECL_COMMA );
    190190float128_t
    191191 softfloat_normRoundPackToF128(
    192      bool, int_fast32_t, uint_fast64_t, uint_fast64_t );
     192     bool, int_fast32_t, uint_fast64_t, uint_fast64_t SOFTFLOAT_STATE_DECL_COMMA );
    193193
    194194float128_t
    195195 softfloat_addMagsF128(
    196      uint_fast64_t, uint_fast64_t, uint_fast64_t, uint_fast64_t, bool );
     196     uint_fast64_t, uint_fast64_t, uint_fast64_t, uint_fast64_t, bool SOFTFLOAT_STATE_DECL_COMMA );
    197197float128_t
    198198 softfloat_subMagsF128(
    199      uint_fast64_t, uint_fast64_t, uint_fast64_t, uint_fast64_t, bool );
     199     uint_fast64_t, uint_fast64_t, uint_fast64_t, uint_fast64_t, bool SOFTFLOAT_STATE_DECL_COMMA );
    200200float128_t
    201201 softfloat_mulAddF128(
    … …  
    207207     uint_fast64_t,
    208208     uint_fast8_t
     209     SOFTFLOAT_STATE_DECL_COMMA
    209210 );
    210211
    … …  
    219220     const struct extFloat80M *,
    220221     struct extFloat80M *
    221  );
    222 void softfloat_invalidExtF80M( struct extFloat80M * );
     222     SOFTFLOAT_STATE_DECL_COMMA
     223 );
     224void softfloat_invalidExtF80M( struct extFloat80M * SOFTFLOAT_STATE_DECL_COMMA );
    223225
    224226int softfloat_normExtF80SigM( uint64_t * );
    … …  
    226228void
    227229 softfloat_roundPackMToExtF80M(
    228      bool, int32_t, uint32_t *, uint_fast8_t, struct extFloat80M * );
     230     bool, int32_t, uint32_t *, uint_fast8_t, struct extFloat80M * SOFTFLOAT_STATE_DECL_COMMA );
    229231void
    230232 softfloat_normRoundPackMToExtF80M(
    231      bool, int32_t, uint32_t *, uint_fast8_t, struct extFloat80M * );
     233     bool, int32_t, uint32_t *, uint_fast8_t, struct extFloat80M * SOFTFLOAT_STATE_DECL_COMMA );
    232234
    233235void
    … …  
    237239     struct extFloat80M *,
    238240     bool
     241     SOFTFLOAT_STATE_DECL_COMMA
    239242 );
    240243
    241244int
    242245 softfloat_compareNonnormExtF80M(
    243      const struct extFloat80M *, const struct extFloat80M * );
     246     const struct extFloat80M *, const struct extFloat80M * SOFTFLOAT_STATE_DECL_COMMA );
    244247
    245248/*----------------------------------------------------------------------------
    … …  
    254257bool
    255258 softfloat_tryPropagateNaNF128M(
    256      const uint32_t *, const uint32_t *, uint32_t * );
    257 void softfloat_invalidF128M( uint32_t * );
     259     const uint32_t *, const uint32_t *, uint32_t * SOFTFLOAT_STATE_DECL_COMMA );
     260void softfloat_invalidF128M( uint32_t * SOFTFLOAT_STATE_DECL_COMMA );
    258261
    259262int softfloat_shiftNormSigF128M( const uint32_t *, uint_fast8_t, uint32_t * );
    260263
    261 void softfloat_roundPackMToF128M( bool, int32_t, uint32_t *, uint32_t * );
    262 void softfloat_normRoundPackMToF128M( bool, int32_t, uint32_t *, uint32_t * );
    263 
    264 void
    265  softfloat_addF128M( const uint32_t *, const uint32_t *, uint32_t *, bool );
     264void softfloat_roundPackMToF128M( bool, int32_t, uint32_t *, uint32_t * SOFTFLOAT_STATE_DECL_COMMA );
     265void softfloat_normRoundPackMToF128M( bool, int32_t, uint32_t *, uint32_t * SOFTFLOAT_STATE_DECL_COMMA );
     266
     267void
     268 softfloat_addF128M( const uint32_t *, const uint32_t *, uint32_t *, bool SOFTFLOAT_STATE_DECL_COMMA );
    266269void
    267270 softfloat_mulAddF128M(
    … …  
    271274     uint32_t *,
    272275     uint_fast8_t
    273  );
    274 
    275 #endif
    276 
    277 #endif
    278 
     276     SOFTFLOAT_STATE_DECL_COMMA
     277 );
     278
     279#endif
     280
     281#endif
     282

  • trunk/src/libs/softfloat-3e/source/include/softfloat.h

    r94480 r94558  
    4747#define softfloat_h 1
    4848
     49#include <iprt/cdefs.h>
    4950#include <stdbool.h>
    5051#include <stdint.h>
    … …  
    5556#endif
    5657
     58RT_C_DECLS_BEGIN
     59
    5760/*----------------------------------------------------------------------------
    5861| Software floating-point underflow tininess-detection mode.
    5962*----------------------------------------------------------------------------*/
     63#ifndef VBOX_WITHOUT_SOFTFLOAT_GLOBALS
    6064extern THREAD_LOCAL uint_fast8_t softfloat_detectTininess;
     65#else
     66# define softfloat_detectTininess (pState->detectTininess)
     67#endif
    6168enum {
    6269    softfloat_tininess_beforeRounding = 0,
    … …  
    6875| SoftFloat is compiled with macro 'SOFTFLOAT_ROUND_ODD' defined.)
    6976*----------------------------------------------------------------------------*/
     77#ifndef VBOX_WITHOUT_SOFTFLOAT_GLOBALS
    7078extern THREAD_LOCAL uint_fast8_t softfloat_roundingMode;
     79#else
     80# define softfloat_roundingMode (pState->roundingMode)
     81#endif
    7182enum {
    7283    softfloat_round_near_even   = 0,
    … …  
    8192| Software floating-point exception flags.
    8293*----------------------------------------------------------------------------*/
     94#ifndef VBOX_WITHOUT_SOFTFLOAT_GLOBALS
    8395extern THREAD_LOCAL uint_fast8_t softfloat_exceptionFlags;
     96#else
     97# define softfloat_exceptionFlags (pState->exceptionFlags)
     98#endif
    8499enum {
     100#ifndef VBOX
    85101    softfloat_flag_inexact   =  1,
    86102    softfloat_flag_underflow =  2,
    … …  
    88104    softfloat_flag_infinite  =  8,
    89105    softfloat_flag_invalid   = 16
     106#else /* VBox: Match X86_FSW_?E */
     107    softfloat_flag_invalid   = 1<<0 /**< X86_FSW_IE */,
     108    //softfloat_flag_ X86_FSW_DE          RT_BIT_32(1)
     109    softfloat_flag_infinite  = 1<<2 /**< X86_FSW_ZE */,
     110    softfloat_flag_overflow  = 1<<3 /**< X86_FSW_OE */,
     111    softfloat_flag_underflow = 1<<4 /**< X86_FSW_UE */,
     112    softfloat_flag_inexact   = 1<<5 /**< X86_FSW_PE */,
     113    softfloat_flag_c1        = 1<<7 /**< X86_FSW_C1 - round up indicator. wrong place. */
     114#endif
    90115};
    91116
    … …  
    93118| Routine to raise any or all of the software floating-point exception flags.
    94119*----------------------------------------------------------------------------*/
    95 void softfloat_raiseFlags( uint_fast8_t );
     120void softfloat_raiseFlags( uint_fast8_t SOFTFLOAT_STATE_DECL_COMMA );
    96121
    97122/*----------------------------------------------------------------------------
    98123| Integer-to-floating-point conversion routines.
    99124*----------------------------------------------------------------------------*/
    100 float16_t ui32_to_f16( uint32_t );
    101 float32_t ui32_to_f32( uint32_t );
    102 float64_t ui32_to_f64( uint32_t );
    103 #ifdef SOFTFLOAT_FAST_INT64
    104 extFloat80_t ui32_to_extF80( uint32_t );
    105 float128_t ui32_to_f128( uint32_t );
    106 #endif
    107 void ui32_to_extF80M( uint32_t, extFloat80_t * );
    108 void ui32_to_f128M( uint32_t, float128_t * );
    109 float16_t ui64_to_f16( uint64_t );
    110 float32_t ui64_to_f32( uint64_t );
    111 float64_t ui64_to_f64( uint64_t );
    112 #ifdef SOFTFLOAT_FAST_INT64
    113 extFloat80_t ui64_to_extF80( uint64_t );
    114 float128_t ui64_to_f128( uint64_t );
    115 #endif
    116 void ui64_to_extF80M( uint64_t, extFloat80_t * );
    117 void ui64_to_f128M( uint64_t, float128_t * );
    118 float16_t i32_to_f16( int32_t );
    119 float32_t i32_to_f32( int32_t );
    120 float64_t i32_to_f64( int32_t );
    121 #ifdef SOFTFLOAT_FAST_INT64
    122 extFloat80_t i32_to_extF80( int32_t );
    123 float128_t i32_to_f128( int32_t );
    124 #endif
    125 void i32_to_extF80M( int32_t, extFloat80_t * );
    126 void i32_to_f128M( int32_t, float128_t * );
    127 float16_t i64_to_f16( int64_t );
    128 float32_t i64_to_f32( int64_t );
    129 float64_t i64_to_f64( int64_t );
    130 #ifdef SOFTFLOAT_FAST_INT64
    131 extFloat80_t i64_to_extF80( int64_t );
    132 float128_t i64_to_f128( int64_t );
    133 #endif
    134 void i64_to_extF80M( int64_t, extFloat80_t * );
    135 void i64_to_f128M( int64_t, float128_t * );
     125float16_t ui32_to_f16( uint32_t SOFTFLOAT_STATE_DECL_COMMA );
     126float32_t ui32_to_f32( uint32_t SOFTFLOAT_STATE_DECL_COMMA );
     127float64_t ui32_to_f64( uint32_t SOFTFLOAT_STATE_DECL_COMMA );
     128#ifdef SOFTFLOAT_FAST_INT64
     129extFloat80_t ui32_to_extF80( uint32_t SOFTFLOAT_STATE_DECL_COMMA );
     130float128_t ui32_to_f128( uint32_t SOFTFLOAT_STATE_DECL_COMMA );
     131#endif
     132void ui32_to_extF80M( uint32_t, extFloat80_t * SOFTFLOAT_STATE_DECL_COMMA );
     133void ui32_to_f128M( uint32_t, float128_t * SOFTFLOAT_STATE_DECL_COMMA );
     134float16_t ui64_to_f16( uint64_t SOFTFLOAT_STATE_DECL_COMMA );
     135float32_t ui64_to_f32( uint64_t SOFTFLOAT_STATE_DECL_COMMA );
     136float64_t ui64_to_f64( uint64_t SOFTFLOAT_STATE_DECL_COMMA );
     137#ifdef SOFTFLOAT_FAST_INT64
     138extFloat80_t ui64_to_extF80( uint64_t SOFTFLOAT_STATE_DECL_COMMA );
     139float128_t ui64_to_f128( uint64_t SOFTFLOAT_STATE_DECL_COMMA );
     140#endif
     141void ui64_to_extF80M( uint64_t, extFloat80_t * SOFTFLOAT_STATE_DECL_COMMA );
     142void ui64_to_f128M( uint64_t, float128_t * SOFTFLOAT_STATE_DECL_COMMA );
     143float16_t i32_to_f16( int32_t SOFTFLOAT_STATE_DECL_COMMA );
     144float32_t i32_to_f32( int32_t SOFTFLOAT_STATE_DECL_COMMA );
     145float64_t i32_to_f64( int32_t SOFTFLOAT_STATE_DECL_COMMA );
     146#ifdef SOFTFLOAT_FAST_INT64
     147extFloat80_t i32_to_extF80( int32_t SOFTFLOAT_STATE_DECL_COMMA );
     148float128_t i32_to_f128( int32_t SOFTFLOAT_STATE_DECL_COMMA );
     149#endif
     150void i32_to_extF80M( int32_t, extFloat80_t * SOFTFLOAT_STATE_DECL_COMMA );
     151void i32_to_f128M( int32_t, float128_t * SOFTFLOAT_STATE_DECL_COMMA );
     152float16_t i64_to_f16( int64_t SOFTFLOAT_STATE_DECL_COMMA );
     153float32_t i64_to_f32( int64_t SOFTFLOAT_STATE_DECL_COMMA );
     154float64_t i64_to_f64( int64_t SOFTFLOAT_STATE_DECL_COMMA );
     155#ifdef SOFTFLOAT_FAST_INT64
     156extFloat80_t i64_to_extF80( int64_t SOFTFLOAT_STATE_DECL_COMMA );
     157float128_t i64_to_f128( int64_t SOFTFLOAT_STATE_DECL_COMMA );
     158#endif
     159void i64_to_extF80M( int64_t, extFloat80_t * SOFTFLOAT_STATE_DECL_COMMA );
     160void i64_to_f128M( int64_t, float128_t * SOFTFLOAT_STATE_DECL_COMMA );
    136161
    137162/*----------------------------------------------------------------------------
    138163| 16-bit (half-precision) floating-point operations.
    139164*----------------------------------------------------------------------------*/
    140 uint_fast32_t f16_to_ui32( float16_t, uint_fast8_t, bool );
    141 uint_fast64_t f16_to_ui64( float16_t, uint_fast8_t, bool );
    142 int_fast32_t f16_to_i32( float16_t, uint_fast8_t, bool );
    143 int_fast64_t f16_to_i64( float16_t, uint_fast8_t, bool );
    144 uint_fast32_t f16_to_ui32_r_minMag( float16_t, bool );
    145 uint_fast64_t f16_to_ui64_r_minMag( float16_t, bool );
    146 int_fast32_t f16_to_i32_r_minMag( float16_t, bool );
    147 int_fast64_t f16_to_i64_r_minMag( float16_t, bool );
    148 float32_t f16_to_f32( float16_t );
    149 float64_t f16_to_f64( float16_t );
    150 #ifdef SOFTFLOAT_FAST_INT64
    151 extFloat80_t f16_to_extF80( float16_t );
    152 float128_t f16_to_f128( float16_t );
    153 #endif
    154 void f16_to_extF80M( float16_t, extFloat80_t * );
    155 void f16_to_f128M( float16_t, float128_t * );
    156 float16_t f16_roundToInt( float16_t, uint_fast8_t, bool );
    157 float16_t f16_add( float16_t, float16_t );
    158 float16_t f16_sub( float16_t, float16_t );
    159 float16_t f16_mul( float16_t, float16_t );
    160 float16_t f16_mulAdd( float16_t, float16_t, float16_t );
    161 float16_t f16_div( float16_t, float16_t );
    162 float16_t f16_rem( float16_t, float16_t );
    163 float16_t f16_sqrt( float16_t );
    164 bool f16_eq( float16_t, float16_t );
    165 bool f16_le( float16_t, float16_t );
    166 bool f16_lt( float16_t, float16_t );
    167 bool f16_eq_signaling( float16_t, float16_t );
    168 bool f16_le_quiet( float16_t, float16_t );
    169 bool f16_lt_quiet( float16_t, float16_t );
     165uint_fast32_t f16_to_ui32( float16_t, uint_fast8_t, bool SOFTFLOAT_STATE_DECL_COMMA );
     166uint_fast64_t f16_to_ui64( float16_t, uint_fast8_t, bool SOFTFLOAT_STATE_DECL_COMMA );
     167int_fast32_t f16_to_i32( float16_t, uint_fast8_t, bool SOFTFLOAT_STATE_DECL_COMMA );
     168int_fast64_t f16_to_i64( float16_t, uint_fast8_t, bool SOFTFLOAT_STATE_DECL_COMMA );
     169uint_fast32_t f16_to_ui32_r_minMag( float16_t, bool SOFTFLOAT_STATE_DECL_COMMA );
     170uint_fast64_t f16_to_ui64_r_minMag( float16_t, bool SOFTFLOAT_STATE_DECL_COMMA );
     171int_fast32_t f16_to_i32_r_minMag( float16_t, bool SOFTFLOAT_STATE_DECL_COMMA );
     172int_fast64_t f16_to_i64_r_minMag( float16_t, bool SOFTFLOAT_STATE_DECL_COMMA );
     173float32_t f16_to_f32( float16_t SOFTFLOAT_STATE_DECL_COMMA );
     174float64_t f16_to_f64( float16_t SOFTFLOAT_STATE_DECL_COMMA );
     175#ifdef SOFTFLOAT_FAST_INT64
     176extFloat80_t f16_to_extF80( float16_t SOFTFLOAT_STATE_DECL_COMMA );
     177float128_t f16_to_f128( float16_t SOFTFLOAT_STATE_DECL_COMMA );
     178#endif
     179void f16_to_extF80M( float16_t, extFloat80_t * SOFTFLOAT_STATE_DECL_COMMA );
     180void f16_to_f128M( float16_t, float128_t * SOFTFLOAT_STATE_DECL_COMMA );
     181float16_t f16_roundToInt( float16_t, uint_fast8_t, bool SOFTFLOAT_STATE_DECL_COMMA );
     182float16_t f16_add( float16_t, float16_t SOFTFLOAT_STATE_DECL_COMMA  );
     183float16_t f16_sub( float16_t, float16_t SOFTFLOAT_STATE_DECL_COMMA  );
     184float16_t f16_mul( float16_t, float16_t SOFTFLOAT_STATE_DECL_COMMA  );
     185float16_t f16_mulAdd( float16_t, float16_t, float16_t SOFTFLOAT_STATE_DECL_COMMA  );
     186float16_t f16_div( float16_t, float16_t SOFTFLOAT_STATE_DECL_COMMA  );
     187float16_t f16_rem( float16_t, float16_t SOFTFLOAT_STATE_DECL_COMMA  );
     188float16_t f16_sqrt( float16_t SOFTFLOAT_STATE_DECL_COMMA  );
     189bool f16_eq( float16_t, float16_t SOFTFLOAT_STATE_DECL_COMMA  );
     190bool f16_le( float16_t, float16_t SOFTFLOAT_STATE_DECL_COMMA  );
     191bool f16_lt( float16_t, float16_t SOFTFLOAT_STATE_DECL_COMMA  );
     192bool f16_eq_signaling( float16_t, float16_t SOFTFLOAT_STATE_DECL_COMMA  );
     193bool f16_le_quiet( float16_t, float16_t SOFTFLOAT_STATE_DECL_COMMA  );
     194bool f16_lt_quiet( float16_t, float16_t SOFTFLOAT_STATE_DECL_COMMA  );
    170195bool f16_isSignalingNaN( float16_t );
    171196
    … …  
    173198| 32-bit (single-precision) floating-point operations.
    174199*----------------------------------------------------------------------------*/
    175 uint_fast32_t f32_to_ui32( float32_t, uint_fast8_t, bool );
    176 uint_fast64_t f32_to_ui64( float32_t, uint_fast8_t, bool );
    177 int_fast32_t f32_to_i32( float32_t, uint_fast8_t, bool );
    178 int_fast64_t f32_to_i64( float32_t, uint_fast8_t, bool );
    179 uint_fast32_t f32_to_ui32_r_minMag( float32_t, bool );
    180 uint_fast64_t f32_to_ui64_r_minMag( float32_t, bool );
    181 int_fast32_t f32_to_i32_r_minMag( float32_t, bool );
    182 int_fast64_t f32_to_i64_r_minMag( float32_t, bool );
    183 float16_t f32_to_f16( float32_t );
    184 float64_t f32_to_f64( float32_t );
    185 #ifdef SOFTFLOAT_FAST_INT64
    186 extFloat80_t f32_to_extF80( float32_t );
    187 float128_t f32_to_f128( float32_t );
    188 #endif
    189 void f32_to_extF80M( float32_t, extFloat80_t * );
    190 void f32_to_f128M( float32_t, float128_t * );
    191 float32_t f32_roundToInt( float32_t, uint_fast8_t, bool );
    192 float32_t f32_add( float32_t, float32_t );
    193 float32_t f32_sub( float32_t, float32_t );
    194 float32_t f32_mul( float32_t, float32_t );
    195 float32_t f32_mulAdd( float32_t, float32_t, float32_t );
    196 float32_t f32_div( float32_t, float32_t );
    197 float32_t f32_rem( float32_t, float32_t );
    198 float32_t f32_sqrt( float32_t );
    199 bool f32_eq( float32_t, float32_t );
    200 bool f32_le( float32_t, float32_t );
    201 bool f32_lt( float32_t, float32_t );
    202 bool f32_eq_signaling( float32_t, float32_t );
    203 bool f32_le_quiet( float32_t, float32_t );
    204 bool f32_lt_quiet( float32_t, float32_t );
     200uint_fast32_t f32_to_ui32( float32_t, uint_fast8_t, bool SOFTFLOAT_STATE_DECL_COMMA );
     201uint_fast64_t f32_to_ui64( float32_t, uint_fast8_t, bool SOFTFLOAT_STATE_DECL_COMMA );
     202int_fast32_t f32_to_i32( float32_t, uint_fast8_t, bool SOFTFLOAT_STATE_DECL_COMMA );
     203int_fast64_t f32_to_i64( float32_t, uint_fast8_t, bool SOFTFLOAT_STATE_DECL_COMMA );
     204uint_fast32_t f32_to_ui32_r_minMag( float32_t, bool SOFTFLOAT_STATE_DECL_COMMA );
     205uint_fast64_t f32_to_ui64_r_minMag( float32_t, bool SOFTFLOAT_STATE_DECL_COMMA );
     206int_fast32_t f32_to_i32_r_minMag( float32_t, bool SOFTFLOAT_STATE_DECL_COMMA );
     207int_fast64_t f32_to_i64_r_minMag( float32_t, bool SOFTFLOAT_STATE_DECL_COMMA );
     208float16_t f32_to_f16( float32_t SOFTFLOAT_STATE_DECL_COMMA );
     209float64_t f32_to_f64( float32_t SOFTFLOAT_STATE_DECL_COMMA );
     210#ifdef SOFTFLOAT_FAST_INT64
     211extFloat80_t f32_to_extF80( float32_t SOFTFLOAT_STATE_DECL_COMMA );
     212float128_t f32_to_f128( float32_t SOFTFLOAT_STATE_DECL_COMMA );
     213#endif
     214void f32_to_extF80M( float32_t, extFloat80_t * SOFTFLOAT_STATE_DECL_COMMA );
     215void f32_to_f128M( float32_t, float128_t * SOFTFLOAT_STATE_DECL_COMMA );
     216float32_t f32_roundToInt( float32_t, uint_fast8_t, bool SOFTFLOAT_STATE_DECL_COMMA );
     217float32_t f32_add( float32_t, float32_t SOFTFLOAT_STATE_DECL_COMMA );
     218float32_t f32_sub( float32_t, float32_t SOFTFLOAT_STATE_DECL_COMMA );
     219float32_t f32_mul( float32_t, float32_t SOFTFLOAT_STATE_DECL_COMMA );
     220float32_t f32_mulAdd( float32_t, float32_t, float32_t SOFTFLOAT_STATE_DECL_COMMA );
     221float32_t f32_div( float32_t, float32_t SOFTFLOAT_STATE_DECL_COMMA );
     222float32_t f32_rem( float32_t, float32_t SOFTFLOAT_STATE_DECL_COMMA );
     223float32_t f32_sqrt( float32_t SOFTFLOAT_STATE_DECL_COMMA );
     224bool f32_eq( float32_t, float32_t SOFTFLOAT_STATE_DECL_COMMA );
     225bool f32_le( float32_t, float32_t SOFTFLOAT_STATE_DECL_COMMA );
     226bool f32_lt( float32_t, float32_t SOFTFLOAT_STATE_DECL_COMMA );
     227bool f32_eq_signaling( float32_t, float32_t SOFTFLOAT_STATE_DECL_COMMA );
     228bool f32_le_quiet( float32_t, float32_t SOFTFLOAT_STATE_DECL_COMMA );
     229bool f32_lt_quiet( float32_t, float32_t SOFTFLOAT_STATE_DECL_COMMA );
    205230bool f32_isSignalingNaN( float32_t );
    206231
    … …  
    208233| 64-bit (double-precision) floating-point operations.
    209234*----------------------------------------------------------------------------*/
    210 uint_fast32_t f64_to_ui32( float64_t, uint_fast8_t, bool );
    211 uint_fast64_t f64_to_ui64( float64_t, uint_fast8_t, bool );
    212 int_fast32_t f64_to_i32( float64_t, uint_fast8_t, bool );
    213 int_fast64_t f64_to_i64( float64_t, uint_fast8_t, bool );
    214 uint_fast32_t f64_to_ui32_r_minMag( float64_t, bool );
    215 uint_fast64_t f64_to_ui64_r_minMag( float64_t, bool );
    216 int_fast32_t f64_to_i32_r_minMag( float64_t, bool );
    217 int_fast64_t f64_to_i64_r_minMag( float64_t, bool );
    218 float16_t f64_to_f16( float64_t );
    219 float32_t f64_to_f32( float64_t );
    220 #ifdef SOFTFLOAT_FAST_INT64
    221 extFloat80_t f64_to_extF80( float64_t );
    222 float128_t f64_to_f128( float64_t );
    223 #endif
    224 void f64_to_extF80M( float64_t, extFloat80_t * );
    225 void f64_to_f128M( float64_t, float128_t * );
    226 float64_t f64_roundToInt( float64_t, uint_fast8_t, bool );
    227 float64_t f64_add( float64_t, float64_t );
    228 float64_t f64_sub( float64_t, float64_t );
    229 float64_t f64_mul( float64_t, float64_t );
    230 float64_t f64_mulAdd( float64_t, float64_t, float64_t );
    231 float64_t f64_div( float64_t, float64_t );
    232 float64_t f64_rem( float64_t, float64_t );
    233 float64_t f64_sqrt( float64_t );
    234 bool f64_eq( float64_t, float64_t );
    235 bool f64_le( float64_t, float64_t );
    236 bool f64_lt( float64_t, float64_t );
    237 bool f64_eq_signaling( float64_t, float64_t );
    238 bool f64_le_quiet( float64_t, float64_t );
    239 bool f64_lt_quiet( float64_t, float64_t );
     235uint_fast32_t f64_to_ui32( float64_t, uint_fast8_t, bool SOFTFLOAT_STATE_DECL_COMMA );
     236uint_fast64_t f64_to_ui64( float64_t, uint_fast8_t, bool SOFTFLOAT_STATE_DECL_COMMA );
     237int_fast32_t f64_to_i32( float64_t, uint_fast8_t, bool SOFTFLOAT_STATE_DECL_COMMA );
     238int_fast64_t f64_to_i64( float64_t, uint_fast8_t, bool SOFTFLOAT_STATE_DECL_COMMA );
     239uint_fast32_t f64_to_ui32_r_minMag( float64_t, bool SOFTFLOAT_STATE_DECL_COMMA );
     240uint_fast64_t f64_to_ui64_r_minMag( float64_t, bool SOFTFLOAT_STATE_DECL_COMMA );
     241int_fast32_t f64_to_i32_r_minMag( float64_t, bool SOFTFLOAT_STATE_DECL_COMMA );
     242int_fast64_t f64_to_i64_r_minMag( float64_t, bool SOFTFLOAT_STATE_DECL_COMMA );
     243float16_t f64_to_f16( float64_t SOFTFLOAT_STATE_DECL_COMMA );
     244float32_t f64_to_f32( float64_t SOFTFLOAT_STATE_DECL_COMMA );
     245#ifdef SOFTFLOAT_FAST_INT64
     246extFloat80_t f64_to_extF80( float64_t SOFTFLOAT_STATE_DECL_COMMA );
     247float128_t f64_to_f128( float64_t SOFTFLOAT_STATE_DECL_COMMA );
     248#endif
     249void f64_to_extF80M( float64_t, extFloat80_t * SOFTFLOAT_STATE_DECL_COMMA );
     250void f64_to_f128M( float64_t, float128_t * SOFTFLOAT_STATE_DECL_COMMA );
     251float64_t f64_roundToInt( float64_t, uint_fast8_t, bool SOFTFLOAT_STATE_DECL_COMMA );
     252float64_t f64_add( float64_t, float64_t SOFTFLOAT_STATE_DECL_COMMA );
     253float64_t f64_sub( float64_t, float64_t SOFTFLOAT_STATE_DECL_COMMA );
     254float64_t f64_mul( float64_t, float64_t SOFTFLOAT_STATE_DECL_COMMA );
     255float64_t f64_mulAdd( float64_t, float64_t, float64_t SOFTFLOAT_STATE_DECL_COMMA );
     256float64_t f64_div( float64_t, float64_t SOFTFLOAT_STATE_DECL_COMMA );
     257float64_t f64_rem( float64_t, float64_t SOFTFLOAT_STATE_DECL_COMMA );
     258float64_t f64_sqrt( float64_t SOFTFLOAT_STATE_DECL_COMMA );
     259bool f64_eq( float64_t, float64_t SOFTFLOAT_STATE_DECL_COMMA );
     260bool f64_le( float64_t, float64_t SOFTFLOAT_STATE_DECL_COMMA );
     261bool f64_lt( float64_t, float64_t SOFTFLOAT_STATE_DECL_COMMA );
     262bool f64_eq_signaling( float64_t, float64_t SOFTFLOAT_STATE_DECL_COMMA );
     263bool f64_le_quiet( float64_t, float64_t SOFTFLOAT_STATE_DECL_COMMA );
     264bool f64_lt_quiet( float64_t, float64_t SOFTFLOAT_STATE_DECL_COMMA );
    240265bool f64_isSignalingNaN( float64_t );
    241266
    … …  
    244269| Valid values are 32, 64, and 80.
    245270*----------------------------------------------------------------------------*/
     271#ifndef VBOX_WITHOUT_SOFTFLOAT_GLOBALS
    246272extern THREAD_LOCAL uint_fast8_t extF80_roundingPrecision;
     273#else
     274# define extF80_roundingPrecision (pState->roundingPrecision)
     275#endif
    247276
    248277/*----------------------------------------------------------------------------
    … …  
    250279*----------------------------------------------------------------------------*/
    251280#ifdef SOFTFLOAT_FAST_INT64
    252 uint_fast32_t extF80_to_ui32( extFloat80_t, uint_fast8_t, bool );
    253 uint_fast64_t extF80_to_ui64( extFloat80_t, uint_fast8_t, bool );
    254 int_fast32_t extF80_to_i32( extFloat80_t, uint_fast8_t, bool );
    255 int_fast64_t extF80_to_i64( extFloat80_t, uint_fast8_t, bool );
    256 uint_fast32_t extF80_to_ui32_r_minMag( extFloat80_t, bool );
    257 uint_fast64_t extF80_to_ui64_r_minMag( extFloat80_t, bool );
    258 int_fast32_t extF80_to_i32_r_minMag( extFloat80_t, bool );
    259 int_fast64_t extF80_to_i64_r_minMag( extFloat80_t, bool );
    260 float16_t extF80_to_f16( extFloat80_t );
    261 float32_t extF80_to_f32( extFloat80_t );
    262 float64_t extF80_to_f64( extFloat80_t );
    263 float128_t extF80_to_f128( extFloat80_t );
    264 extFloat80_t extF80_roundToInt( extFloat80_t, uint_fast8_t, bool );
    265 extFloat80_t extF80_add( extFloat80_t, extFloat80_t );
    266 extFloat80_t extF80_sub( extFloat80_t, extFloat80_t );
    267 extFloat80_t extF80_mul( extFloat80_t, extFloat80_t );
    268 extFloat80_t extF80_div( extFloat80_t, extFloat80_t );
    269 extFloat80_t extF80_rem( extFloat80_t, extFloat80_t );
    270 extFloat80_t extF80_sqrt( extFloat80_t );
    271 bool extF80_eq( extFloat80_t, extFloat80_t );
    272 bool extF80_le( extFloat80_t, extFloat80_t );
    273 bool extF80_lt( extFloat80_t, extFloat80_t );
    274 bool extF80_eq_signaling( extFloat80_t, extFloat80_t );
    275 bool extF80_le_quiet( extFloat80_t, extFloat80_t );
    276 bool extF80_lt_quiet( extFloat80_t, extFloat80_t );
     281uint_fast32_t extF80_to_ui32( extFloat80_t, uint_fast8_t, bool SOFTFLOAT_STATE_DECL_COMMA );
     282uint_fast64_t extF80_to_ui64( extFloat80_t, uint_fast8_t, bool SOFTFLOAT_STATE_DECL_COMMA );
     283int_fast32_t extF80_to_i32( extFloat80_t, uint_fast8_t, bool SOFTFLOAT_STATE_DECL_COMMA );
     284int_fast64_t extF80_to_i64( extFloat80_t, uint_fast8_t, bool SOFTFLOAT_STATE_DECL_COMMA );
     285uint_fast32_t extF80_to_ui32_r_minMag( extFloat80_t, bool SOFTFLOAT_STATE_DECL_COMMA );
     286uint_fast64_t extF80_to_ui64_r_minMag( extFloat80_t, bool SOFTFLOAT_STATE_DECL_COMMA );
     287int_fast32_t extF80_to_i32_r_minMag( extFloat80_t, bool SOFTFLOAT_STATE_DECL_COMMA );
     288int_fast64_t extF80_to_i64_r_minMag( extFloat80_t, bool SOFTFLOAT_STATE_DECL_COMMA );
     289float16_t extF80_to_f16( extFloat80_t SOFTFLOAT_STATE_DECL_COMMA );
     290float32_t extF80_to_f32( extFloat80_t SOFTFLOAT_STATE_DECL_COMMA );
     291float64_t extF80_to_f64( extFloat80_t SOFTFLOAT_STATE_DECL_COMMA );
     292float128_t extF80_to_f128( extFloat80_t SOFTFLOAT_STATE_DECL_COMMA );
     293extFloat80_t extF80_roundToInt( extFloat80_t, uint_fast8_t, bool SOFTFLOAT_STATE_DECL_COMMA );
     294extFloat80_t extF80_add( extFloat80_t, extFloat80_t SOFTFLOAT_STATE_DECL_COMMA );
     295extFloat80_t extF80_sub( extFloat80_t, extFloat80_t SOFTFLOAT_STATE_DECL_COMMA );
     296extFloat80_t extF80_mul( extFloat80_t, extFloat80_t SOFTFLOAT_STATE_DECL_COMMA );
     297extFloat80_t extF80_div( extFloat80_t, extFloat80_t SOFTFLOAT_STATE_DECL_COMMA );
     298extFloat80_t extF80_rem( extFloat80_t, extFloat80_t SOFTFLOAT_STATE_DECL_COMMA );
     299extFloat80_t extF80_sqrt( extFloat80_t SOFTFLOAT_STATE_DECL_COMMA );
     300bool extF80_eq( extFloat80_t, extFloat80_t SOFTFLOAT_STATE_DECL_COMMA );
     301bool extF80_le( extFloat80_t, extFloat80_t SOFTFLOAT_STATE_DECL_COMMA );
     302bool extF80_lt( extFloat80_t, extFloat80_t SOFTFLOAT_STATE_DECL_COMMA );
     303bool extF80_eq_signaling( extFloat80_t, extFloat80_t SOFTFLOAT_STATE_DECL_COMMA );
     304bool extF80_le_quiet( extFloat80_t, extFloat80_t SOFTFLOAT_STATE_DECL_COMMA );
     305bool extF80_lt_quiet( extFloat80_t, extFloat80_t SOFTFLOAT_STATE_DECL_COMMA );
    277306bool extF80_isSignalingNaN( extFloat80_t );
    278307#endif
    279 uint_fast32_t extF80M_to_ui32( const extFloat80_t *, uint_fast8_t, bool );
    280 uint_fast64_t extF80M_to_ui64( const extFloat80_t *, uint_fast8_t, bool );
    281 int_fast32_t extF80M_to_i32( const extFloat80_t *, uint_fast8_t, bool );
    282 int_fast64_t extF80M_to_i64( const extFloat80_t *, uint_fast8_t, bool );
    283 uint_fast32_t extF80M_to_ui32_r_minMag( const extFloat80_t *, bool );
    284 uint_fast64_t extF80M_to_ui64_r_minMag( const extFloat80_t *, bool );
    285 int_fast32_t extF80M_to_i32_r_minMag( const extFloat80_t *, bool );
    286 int_fast64_t extF80M_to_i64_r_minMag( const extFloat80_t *, bool );
    287 float16_t extF80M_to_f16( const extFloat80_t * );
    288 float32_t extF80M_to_f32( const extFloat80_t * );
    289 float64_t extF80M_to_f64( const extFloat80_t * );
    290 void extF80M_to_f128M( const extFloat80_t *, float128_t * );
     308uint_fast32_t extF80M_to_ui32( const extFloat80_t *, uint_fast8_t, bool SOFTFLOAT_STATE_DECL_COMMA );
     309uint_fast64_t extF80M_to_ui64( const extFloat80_t *, uint_fast8_t, bool SOFTFLOAT_STATE_DECL_COMMA );
     310int_fast32_t extF80M_to_i32( const extFloat80_t *, uint_fast8_t, bool SOFTFLOAT_STATE_DECL_COMMA );
     311int_fast64_t extF80M_to_i64( const extFloat80_t *, uint_fast8_t, bool SOFTFLOAT_STATE_DECL_COMMA );
     312uint_fast32_t extF80M_to_ui32_r_minMag( const extFloat80_t *, bool SOFTFLOAT_STATE_DECL_COMMA );
     313uint_fast64_t extF80M_to_ui64_r_minMag( const extFloat80_t *, bool SOFTFLOAT_STATE_DECL_COMMA );
     314int_fast32_t extF80M_to_i32_r_minMag( const extFloat80_t *, bool SOFTFLOAT_STATE_DECL_COMMA );
     315int_fast64_t extF80M_to_i64_r_minMag( const extFloat80_t *, bool SOFTFLOAT_STATE_DECL_COMMA );
     316float16_t extF80M_to_f16( const extFloat80_t * SOFTFLOAT_STATE_DECL_COMMA );
     317float32_t extF80M_to_f32( const extFloat80_t * SOFTFLOAT_STATE_DECL_COMMA );
     318float64_t extF80M_to_f64( const extFloat80_t * SOFTFLOAT_STATE_DECL_COMMA );
     319void extF80M_to_f128M( const extFloat80_t *, float128_t * SOFTFLOAT_STATE_DECL_COMMA );
    291320void
    292321 extF80M_roundToInt(
    293      const extFloat80_t *, uint_fast8_t, bool, extFloat80_t * );
    294 void extF80M_add( const extFloat80_t *, const extFloat80_t *, extFloat80_t * );
    295 void extF80M_sub( const extFloat80_t *, const extFloat80_t *, extFloat80_t * );
    296 void extF80M_mul( const extFloat80_t *, const extFloat80_t *, extFloat80_t * );
    297 void extF80M_div( const extFloat80_t *, const extFloat80_t *, extFloat80_t * );
    298 void extF80M_rem( const extFloat80_t *, const extFloat80_t *, extFloat80_t * );
    299 void extF80M_sqrt( const extFloat80_t *, extFloat80_t * );
    300 bool extF80M_eq( const extFloat80_t *, const extFloat80_t * );
    301 bool extF80M_le( const extFloat80_t *, const extFloat80_t * );
    302 bool extF80M_lt( const extFloat80_t *, const extFloat80_t * );
    303 bool extF80M_eq_signaling( const extFloat80_t *, const extFloat80_t * );
    304 bool extF80M_le_quiet( const extFloat80_t *, const extFloat80_t * );
    305 bool extF80M_lt_quiet( const extFloat80_t *, const extFloat80_t * );
     322     const extFloat80_t *, uint_fast8_t, bool, extFloat80_t * SOFTFLOAT_STATE_DECL_COMMA );
     323void extF80M_add( const extFloat80_t *, const extFloat80_t *, extFloat80_t * SOFTFLOAT_STATE_DECL_COMMA );
     324void extF80M_sub( const extFloat80_t *, const extFloat80_t *, extFloat80_t * SOFTFLOAT_STATE_DECL_COMMA );
     325void extF80M_mul( const extFloat80_t *, const extFloat80_t *, extFloat80_t * SOFTFLOAT_STATE_DECL_COMMA );
     326void extF80M_div( const extFloat80_t *, const extFloat80_t *, extFloat80_t * SOFTFLOAT_STATE_DECL_COMMA );
     327void extF80M_rem( const extFloat80_t *, const extFloat80_t *, extFloat80_t * SOFTFLOAT_STATE_DECL_COMMA );
     328void extF80M_sqrt( const extFloat80_t *, extFloat80_t * SOFTFLOAT_STATE_DECL_COMMA );
     329bool extF80M_eq( const extFloat80_t *, const extFloat80_t * SOFTFLOAT_STATE_DECL_COMMA );
     330bool extF80M_le( const extFloat80_t *, const extFloat80_t * SOFTFLOAT_STATE_DECL_COMMA );
     331bool extF80M_lt( const extFloat80_t *, const extFloat80_t * SOFTFLOAT_STATE_DECL_COMMA );
     332bool extF80M_eq_signaling( const extFloat80_t *, const extFloat80_t * SOFTFLOAT_STATE_DECL_COMMA );
     333bool extF80M_le_quiet( const extFloat80_t *, const extFloat80_t * SOFTFLOAT_STATE_DECL_COMMA );
     334bool extF80M_lt_quiet( const extFloat80_t *, const extFloat80_t * SOFTFLOAT_STATE_DECL_COMMA );
    306335bool extF80M_isSignalingNaN( const extFloat80_t * );
    307336
    … …  
    310339*----------------------------------------------------------------------------*/
    311340#ifdef SOFTFLOAT_FAST_INT64
    312 uint_fast32_t f128_to_ui32( float128_t, uint_fast8_t, bool );
    313 uint_fast64_t f128_to_ui64( float128_t, uint_fast8_t, bool );
    314 int_fast32_t f128_to_i32( float128_t, uint_fast8_t, bool );
    315 int_fast64_t f128_to_i64( float128_t, uint_fast8_t, bool );
    316 uint_fast32_t f128_to_ui32_r_minMag( float128_t, bool );
    317 uint_fast64_t f128_to_ui64_r_minMag( float128_t, bool );
    318 int_fast32_t f128_to_i32_r_minMag( float128_t, bool );
    319 int_fast64_t f128_to_i64_r_minMag( float128_t, bool );
    320 float16_t f128_to_f16( float128_t );
    321 float32_t f128_to_f32( float128_t );
    322 float64_t f128_to_f64( float128_t );
    323 extFloat80_t f128_to_extF80( float128_t );
    324 float128_t f128_roundToInt( float128_t, uint_fast8_t, bool );
    325 float128_t f128_add( float128_t, float128_t );
    326 float128_t f128_sub( float128_t, float128_t );
    327 float128_t f128_mul( float128_t, float128_t );
    328 float128_t f128_mulAdd( float128_t, float128_t, float128_t );
    329 float128_t f128_div( float128_t, float128_t );
    330 float128_t f128_rem( float128_t, float128_t );
    331 float128_t f128_sqrt( float128_t );
    332 bool f128_eq( float128_t, float128_t );
    333 bool f128_le( float128_t, float128_t );
    334 bool f128_lt( float128_t, float128_t );
    335 bool f128_eq_signaling( float128_t, float128_t );
    336 bool f128_le_quiet( float128_t, float128_t );
    337 bool f128_lt_quiet( float128_t, float128_t );
     341uint_fast32_t f128_to_ui32( float128_t, uint_fast8_t, bool SOFTFLOAT_STATE_DECL_COMMA );
     342uint_fast64_t f128_to_ui64( float128_t, uint_fast8_t, bool SOFTFLOAT_STATE_DECL_COMMA );
     343int_fast32_t f128_to_i32( float128_t, uint_fast8_t, bool SOFTFLOAT_STATE_DECL_COMMA );
     344int_fast64_t f128_to_i64( float128_t, uint_fast8_t, bool SOFTFLOAT_STATE_DECL_COMMA );
     345uint_fast32_t f128_to_ui32_r_minMag( float128_t, bool SOFTFLOAT_STATE_DECL_COMMA );
     346uint_fast64_t f128_to_ui64_r_minMag( float128_t, bool SOFTFLOAT_STATE_DECL_COMMA );
     347int_fast32_t f128_to_i32_r_minMag( float128_t, bool SOFTFLOAT_STATE_DECL_COMMA );
     348int_fast64_t f128_to_i64_r_minMag( float128_t, bool SOFTFLOAT_STATE_DECL_COMMA );
     349float16_t f128_to_f16( float128_t SOFTFLOAT_STATE_DECL_COMMA );
     350float32_t f128_to_f32( float128_t SOFTFLOAT_STATE_DECL_COMMA );
     351float64_t f128_to_f64( float128_t SOFTFLOAT_STATE_DECL_COMMA );
     352extFloat80_t f128_to_extF80( float128_t SOFTFLOAT_STATE_DECL_COMMA );
     353float128_t f128_roundToInt( float128_t, uint_fast8_t, bool SOFTFLOAT_STATE_DECL_COMMA );
     354float128_t f128_add( float128_t, float128_t SOFTFLOAT_STATE_DECL_COMMA );
     355float128_t f128_sub( float128_t, float128_t SOFTFLOAT_STATE_DECL_COMMA );
     356float128_t f128_mul( float128_t, float128_t SOFTFLOAT_STATE_DECL_COMMA );
     357float128_t f128_mulAdd( float128_t, float128_t, float128_t SOFTFLOAT_STATE_DECL_COMMA );
     358float128_t f128_div( float128_t, float128_t SOFTFLOAT_STATE_DECL_COMMA );
     359float128_t f128_rem( float128_t, float128_t SOFTFLOAT_STATE_DECL_COMMA );
     360float128_t f128_sqrt( float128_t SOFTFLOAT_STATE_DECL_COMMA );
     361bool f128_eq( float128_t, float128_t SOFTFLOAT_STATE_DECL_COMMA );
     362bool f128_le( float128_t, float128_t SOFTFLOAT_STATE_DECL_COMMA );
     363bool f128_lt( float128_t, float128_t SOFTFLOAT_STATE_DECL_COMMA );
     364bool f128_eq_signaling( float128_t, float128_t SOFTFLOAT_STATE_DECL_COMMA );
     365bool f128_le_quiet( float128_t, float128_t SOFTFLOAT_STATE_DECL_COMMA );
     366bool f128_lt_quiet( float128_t, float128_t SOFTFLOAT_STATE_DECL_COMMA );
    338367bool f128_isSignalingNaN( float128_t );
    339368#endif
    340 uint_fast32_t f128M_to_ui32( const float128_t *, uint_fast8_t, bool );
    341 uint_fast64_t f128M_to_ui64( const float128_t *, uint_fast8_t, bool );
    342 int_fast32_t f128M_to_i32( const float128_t *, uint_fast8_t, bool );
    343 int_fast64_t f128M_to_i64( const float128_t *, uint_fast8_t, bool );
    344 uint_fast32_t f128M_to_ui32_r_minMag( const float128_t *, bool );
    345 uint_fast64_t f128M_to_ui64_r_minMag( const float128_t *, bool );
    346 int_fast32_t f128M_to_i32_r_minMag( const float128_t *, bool );
    347 int_fast64_t f128M_to_i64_r_minMag( const float128_t *, bool );
    348 float16_t f128M_to_f16( const float128_t * );
    349 float32_t f128M_to_f32( const float128_t * );
    350 float64_t f128M_to_f64( const float128_t * );
    351 void f128M_to_extF80M( const float128_t *, extFloat80_t * );
    352 void f128M_roundToInt( const float128_t *, uint_fast8_t, bool, float128_t * );
    353 void f128M_add( const float128_t *, const float128_t *, float128_t * );
    354 void f128M_sub( const float128_t *, const float128_t *, float128_t * );
    355 void f128M_mul( const float128_t *, const float128_t *, float128_t * );
     369uint_fast32_t f128M_to_ui32( const float128_t *, uint_fast8_t, bool SOFTFLOAT_STATE_DECL_COMMA );
     370uint_fast64_t f128M_to_ui64( const float128_t *, uint_fast8_t, bool SOFTFLOAT_STATE_DECL_COMMA );
     371int_fast32_t f128M_to_i32( const float128_t *, uint_fast8_t, bool SOFTFLOAT_STATE_DECL_COMMA );
     372int_fast64_t f128M_to_i64( const float128_t *, uint_fast8_t, bool SOFTFLOAT_STATE_DECL_COMMA );
     373uint_fast32_t f128M_to_ui32_r_minMag( const float128_t *, bool SOFTFLOAT_STATE_DECL_COMMA );
     374uint_fast64_t f128M_to_ui64_r_minMag( const float128_t *, bool SOFTFLOAT_STATE_DECL_COMMA );
     375int_fast32_t f128M_to_i32_r_minMag( const float128_t *, bool SOFTFLOAT_STATE_DECL_COMMA );
     376int_fast64_t f128M_to_i64_r_minMag( const float128_t *, bool SOFTFLOAT_STATE_DECL_COMMA );
     377float16_t f128M_to_f16( const float128_t * SOFTFLOAT_STATE_DECL_COMMA );
     378float32_t f128M_to_f32( const float128_t * SOFTFLOAT_STATE_DECL_COMMA );
     379float64_t f128M_to_f64( const float128_t * SOFTFLOAT_STATE_DECL_COMMA );
     380void f128M_to_extF80M( const float128_t *, extFloat80_t * SOFTFLOAT_STATE_DECL_COMMA );
     381void f128M_roundToInt( const float128_t *, uint_fast8_t, bool, float128_t * SOFTFLOAT_STATE_DECL_COMMA );
     382void f128M_add( const float128_t *, const float128_t *, float128_t * SOFTFLOAT_STATE_DECL_COMMA );
     383void f128M_sub( const float128_t *, const float128_t *, float128_t * SOFTFLOAT_STATE_DECL_COMMA );
     384void f128M_mul( const float128_t *, const float128_t *, float128_t * SOFTFLOAT_STATE_DECL_COMMA );
    356385void
    357386 f128M_mulAdd(
    358      const float128_t *, const float128_t *, const float128_t *, float128_t *
     387     const float128_t *, const float128_t *, const float128_t *, float128_t * SOFTFLOAT_STATE_DECL_COMMA
    359388 );
    360 void f128M_div( const float128_t *, const float128_t *, float128_t * );
    361 void f128M_rem( const float128_t *, const float128_t *, float128_t * );
    362 void f128M_sqrt( const float128_t *, float128_t * );
    363 bool f128M_eq( const float128_t *, const float128_t * );
    364 bool f128M_le( const float128_t *, const float128_t * );
    365 bool f128M_lt( const float128_t *, const float128_t * );
    366 bool f128M_eq_signaling( const float128_t *, const float128_t * );
    367 bool f128M_le_quiet( const float128_t *, const float128_t * );
    368 bool f128M_lt_quiet( const float128_t *, const float128_t * );
     389void f128M_div( const float128_t *, const float128_t *, float128_t * SOFTFLOAT_STATE_DECL_COMMA );
     390void f128M_rem( const float128_t *, const float128_t *, float128_t * SOFTFLOAT_STATE_DECL_COMMA );
     391void f128M_sqrt( const float128_t *, float128_t * SOFTFLOAT_STATE_DECL_COMMA );
     392bool f128M_eq( const float128_t *, const float128_t * SOFTFLOAT_STATE_DECL_COMMA );
     393bool f128M_le( const float128_t *, const float128_t * SOFTFLOAT_STATE_DECL_COMMA );
     394bool f128M_lt( const float128_t *, const float128_t * SOFTFLOAT_STATE_DECL_COMMA );
     395bool f128M_eq_signaling( const float128_t *, const float128_t * SOFTFLOAT_STATE_DECL_COMMA );
     396bool f128M_le_quiet( const float128_t *, const float128_t * SOFTFLOAT_STATE_DECL_COMMA );
     397bool f128M_lt_quiet( const float128_t *, const float128_t * SOFTFLOAT_STATE_DECL_COMMA );
    369398bool f128M_isSignalingNaN( const float128_t * );
    370399
    371 #endif
    372 
     400RT_C_DECLS_END
     401
     402#endif
     403

  • trunk/src/libs/softfloat-3e/source/include/softfloat_types.h

    r94480 r94558  
    7878typedef struct extFloat80M extFloat80_t;
    7979
     80/*----------------------------------------------------------------------------
     81| VBox: The four globals as non-globals.
     82*----------------------------------------------------------------------------*/
     83#ifndef VBOX_WITH_SOFTFLOAT_GLOBALS
     84# define VBOX_WITHOUT_SOFTFLOAT_GLOBALS
     85# define SOFTFLOAT_STATE_ARG            pState
     86# define SOFTFLOAT_STATE_ARG_COMMA      , pState
     87# define SOFTFLOAT_STATE_DECL           softfloat_state_t *pState
     88# define SOFTFLOAT_STATE_DECL_COMMA     , softfloat_state_t *pState
     89# define SOFTFLOAT_STATE_NOREF()        (void)pState
     90typedef struct softfloat_state
     91{
     92    /* softfloat_tininess_beforeRounding or softfloat_tininess_afterRounding */
     93    uint8_t detectTininess;
     94    /* softfloat_round_near_even and friends. */
     95    uint8_t roundingMode;
     96    /* softfloat_flag_inexact and friends. */
     97    uint8_t exceptionFlags;
     98    /* extF80: rounding precsision: 32, 64 or 80 */
     99    uint8_t roundingPrecision;
     100} softfloat_state_t;
     101# define SOFTFLOAT_STATE_INIT_DEFAULTS() { softfloat_round_near_even, softfloat_tininess_afterRounding, 0, 80 }
     102#else
     103# undef  VBOX_WITHOUT_SOFTFLOAT_GLOBALS
     104# define SOFTFLOAT_STATE_ARG
     105# define SOFTFLOAT_STATE_ARG_COMMA
     106# define SOFTFLOAT_STATE_DECL
     107# define SOFTFLOAT_STATE_DECL_COMMA
     108# define SOFTFLOAT_STATE_NOREF()        (void)0
    80109#endif
    81110
     111#endif
     112

  • trunk/src/libs/softfloat-3e/source/s_addExtF80M.c

    r94480 r94558  
    4848     struct extFloat80M *zSPtr,
    4949     bool negateB
     50     SOFTFLOAT_STATE_DECL_COMMA
    5051 )
    5152{
    … …  
    6061    void
    6162     (*roundPackRoutinePtr)(
    62          bool, int32_t, uint32_t *, uint_fast8_t, struct extFloat80M * );
     63         bool, int32_t, uint32_t *, uint_fast8_t, struct extFloat80M * SOFTFLOAT_STATE_DECL_COMMA );
    6364    int32_t expDiff;
    6465    uint32_t extSigX[3], sigZExtra;
    … …  
    7374    *------------------------------------------------------------------------*/
    7475    if ( (expA == 0x7FFF) || (expB == 0x7FFF) ) {
    75         if ( softfloat_tryPropagateNaNExtF80M( aSPtr, bSPtr, zSPtr ) ) return;
     76        if ( softfloat_tryPropagateNaNExtF80M( aSPtr, bSPtr, zSPtr SOFTFLOAT_STATE_ARG_COMMA ) ) return;
    7677        uiZ64 = uiA64;
    7778        if ( expB == 0x7FFF ) {
    7879            uiZ64 = uiB64 ^ packToExtF80UI64( negateB, 0 );
    7980            if ( (expA == 0x7FFF) && (uiZ64 != uiA64) ) {
    80                 softfloat_invalidExtF80M( zSPtr );
     81                softfloat_invalidExtF80M( zSPtr SOFTFLOAT_STATE_ARG_COMMA );
    8182                return;
    8283            }
    … …  
    181182 roundPack:
    182183    (*roundPackRoutinePtr)(
    183         signZ, expA, extSigX, extF80_roundingPrecision, zSPtr );
     184        signZ, expA, extSigX, extF80_roundingPrecision, zSPtr SOFTFLOAT_STATE_ARG_COMMA );
    184185
    185186}

  • trunk/src/libs/softfloat-3e/source/s_addF128M.c

    r94480 r94558  
    4848     uint32_t *zWPtr,
    4949     bool negateB
     50     SOFTFLOAT_STATE_DECL_COMMA
    5051 )
    5152{
    … …  
    6970    uint32_t extSigZ[5], wordSigZ;
    7071    uint_fast8_t carry;
    71     void (*roundPackRoutinePtr)( bool, int32_t, uint32_t *, uint32_t * );
     72    void (*roundPackRoutinePtr)( bool, int32_t, uint32_t *, uint32_t * SOFTFLOAT_STATE_DECL_COMMA );
    7273
    7374    /*------------------------------------------------------------------------
    … …  
    8081    *------------------------------------------------------------------------*/
    8182    if ( (expA == 0x7FFF) || (expB == 0x7FFF) ) {
    82         if ( softfloat_tryPropagateNaNF128M( aWPtr, bWPtr, zWPtr ) ) return;
     83        if ( softfloat_tryPropagateNaNF128M( aWPtr, bWPtr, zWPtr SOFTFLOAT_STATE_ARG_COMMA ) ) return;
    8384        uiZ96 = uiA96;
    8485        if ( expB == 0x7FFF ) {
    8586            uiZ96 = uiB96 ^ packToF128UI96( negateB, 0, 0 );
    8687            if ( (expA == 0x7FFF) && (uiZ96 != uiA96) ) {
    87                 softfloat_invalidF128M( zWPtr );
     88                softfloat_invalidF128M( zWPtr SOFTFLOAT_STATE_ARG_COMMA );
    8889                return;
    8990            }
    … …  
    206207        roundPackRoutinePtr = softfloat_roundPackMToF128M;
    207208    }
    208     (*roundPackRoutinePtr)( signZ, expA, extSigZ, zWPtr );
     209    (*roundPackRoutinePtr)( signZ, expA, extSigZ, zWPtr SOFTFLOAT_STATE_ARG_COMMA );
    209210
    210211}

  • trunk/src/libs/softfloat-3e/source/s_addMagsExtF80.c

    r94480 r94558  
    4949     uint_fast64_t uiB0,
    5050     bool signZ
     51     SOFTFLOAT_STATE_DECL_COMMA
    5152 )
    5253{
    … …  
    141142    return
    142143        softfloat_roundPackToExtF80(
    143             signZ, expZ, sigZ, sigZExtra, extF80_roundingPrecision );
     144            signZ, expZ, sigZ, sigZExtra, extF80_roundingPrecision SOFTFLOAT_STATE_ARG_COMMA );
    144145    /*------------------------------------------------------------------------
    145146    *------------------------------------------------------------------------*/
    146147 propagateNaN:
    147     uiZ = softfloat_propagateNaNExtF80UI( uiA64, uiA0, uiB64, uiB0 );
     148    uiZ = softfloat_propagateNaNExtF80UI( uiA64, uiA0, uiB64, uiB0 SOFTFLOAT_STATE_ARG_COMMA );
    148149    uiZ64 = uiZ.v64;
    149150    uiZ0  = uiZ.v0;

  • trunk/src/libs/softfloat-3e/source/s_addMagsF128.c

    r94480 r94558  
    4848     uint_fast64_t uiB0,
    4949     bool signZ
     50     SOFTFLOAT_STATE_DECL_COMMA
    5051 )
    5152{
    … …  
    144145 roundAndPack:
    145146    return
    146         softfloat_roundPackToF128( signZ, expZ, sigZ.v64, sigZ.v0, sigZExtra );
     147        softfloat_roundPackToF128( signZ, expZ, sigZ.v64, sigZ.v0, sigZExtra SOFTFLOAT_STATE_ARG_COMMA );
    147148 propagateNaN:
    148     uiZ = softfloat_propagateNaNF128UI( uiA64, uiA0, uiB64, uiB0 );
     149    uiZ = softfloat_propagateNaNF128UI( uiA64, uiA0, uiB64, uiB0 SOFTFLOAT_STATE_ARG_COMMA );
    149150 uiZ:
    150151    uZ.ui = uiZ;

  • trunk/src/libs/softfloat-3e/source/s_addMagsF16.c

    r94480 r94558  
    4242#include "softfloat.h"
    4343
    44 float16_t softfloat_addMagsF16( uint_fast16_t uiA, uint_fast16_t uiB )
     44float16_t softfloat_addMagsF16( uint_fast16_t uiA, uint_fast16_t uiB SOFTFLOAT_STATE_DECL_COMMA )
    4545{
    4646    int_fast8_t expA;
    … …  
    142142        }
    143143    }
    144     return softfloat_roundPackToF16( signZ, expZ, sigZ );
     144    return softfloat_roundPackToF16( signZ, expZ, sigZ SOFTFLOAT_STATE_ARG_COMMA );
    145145    /*------------------------------------------------------------------------
    146146    *------------------------------------------------------------------------*/
    147147 propagateNaN:
    148     uiZ = softfloat_propagateNaNF16UI( uiA, uiB );
     148    uiZ = softfloat_propagateNaNF16UI( uiA, uiB SOFTFLOAT_STATE_ARG_COMMA );
    149149    goto uiZ;
    150150    /*------------------------------------------------------------------------
    … …  
    161161            if ( (uint16_t) (uiZ<<1) == 0xF800 ) {
    162162                softfloat_raiseFlags(
    163                     softfloat_flag_overflow | softfloat_flag_inexact );
     163                    softfloat_flag_overflow | softfloat_flag_inexact
     164                    SOFTFLOAT_STATE_ARG_COMMA );
    164165            }
    165166        }

  • trunk/src/libs/softfloat-3e/source/s_addMagsF32.c

    r94480 r94558  
    4141#include "specialize.h"
    4242
    43 float32_t softfloat_addMagsF32( uint_fast32_t uiA, uint_fast32_t uiB )
     43float32_t softfloat_addMagsF32( uint_fast32_t uiA, uint_fast32_t uiB SOFTFLOAT_STATE_DECL_COMMA )
    4444{
    4545    int_fast16_t expA;
    … …  
    114114        }
    115115    }
    116     return softfloat_roundPackToF32( signZ, expZ, sigZ );
     116    return softfloat_roundPackToF32( signZ, expZ, sigZ SOFTFLOAT_STATE_ARG_COMMA );
    117117    /*------------------------------------------------------------------------
    118118    *------------------------------------------------------------------------*/
    119119 propagateNaN:
    120     uiZ = softfloat_propagateNaNF32UI( uiA, uiB );
     120    uiZ = softfloat_propagateNaNF32UI( uiA, uiB SOFTFLOAT_STATE_ARG_COMMA );
    121121 uiZ:
    122122    uZ.ui = uiZ;

  • trunk/src/libs/softfloat-3e/source/s_addMagsF64.c

    r94480 r94558  
    4242
    4343float64_t
    44  softfloat_addMagsF64( uint_fast64_t uiA, uint_fast64_t uiB, bool signZ )
     44 softfloat_addMagsF64( uint_fast64_t uiA, uint_fast64_t uiB, bool signZ SOFTFLOAT_STATE_DECL_COMMA )
    4545{
    4646    int_fast16_t expA;
    … …  
    116116        }
    117117    }
    118     return softfloat_roundPackToF64( signZ, expZ, sigZ );
     118    return softfloat_roundPackToF64( signZ, expZ, sigZ SOFTFLOAT_STATE_ARG_COMMA );
    119119    /*------------------------------------------------------------------------
    120120    *------------------------------------------------------------------------*/
    121121 propagateNaN:
    122     uiZ = softfloat_propagateNaNF64UI( uiA, uiB );
     122    uiZ = softfloat_propagateNaNF64UI( uiA, uiB SOFTFLOAT_STATE_ARG_COMMA );
    123123 uiZ:
    124124    uZ.ui = uiZ;

  • trunk/src/libs/softfloat-3e/source/s_invalidExtF80M.c

    r94480 r94558  
    3939#include "softfloat.h"
    4040
    41 void softfloat_invalidExtF80M( struct extFloat80M *zSPtr )
     41void softfloat_invalidExtF80M( struct extFloat80M *zSPtr SOFTFLOAT_STATE_DECL_COMMA )
    4242{
    4343
    44     softfloat_raiseFlags( softfloat_flag_invalid );
     44    softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    4545    zSPtr->signExp = defaultNaNExtF80UI64;
    4646    zSPtr->signif  = defaultNaNExtF80UI0;

  • trunk/src/libs/softfloat-3e/source/s_invalidF128M.c

    r94480 r94558  
    4141#include "softfloat.h"
    4242
    43 void softfloat_invalidF128M( uint32_t *zWPtr )
     43void softfloat_invalidF128M( uint32_t *zWPtr SOFTFLOAT_STATE_DECL_COMMA )
    4444{
    4545
    46     softfloat_raiseFlags( softfloat_flag_invalid );
     46    softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    4747    zWPtr[indexWord( 4, 3 )] = defaultNaNF128UI96;
    4848    zWPtr[indexWord( 4, 2 )] = defaultNaNF128UI64;

  • trunk/src/libs/softfloat-3e/source/s_mulAddF128.c

    r94480 r94558  
    5151     uint_fast64_t uiC0,
    5252     uint_fast8_t op
     53     SOFTFLOAT_STATE_DECL_COMMA
    5354 )
    5455{
    … …  
    309310    return
    310311        softfloat_roundPackToF128(
    311             signZ, expZ - 1, sigZ.v64, sigZ.v0, sigZExtra );
     312            signZ, expZ - 1, sigZ.v64, sigZ.v0, sigZExtra SOFTFLOAT_STATE_ARG_COMMA );
    312313    /*------------------------------------------------------------------------
    313314    *------------------------------------------------------------------------*/
    314315 propagateNaN_ABC:
    315     uiZ = softfloat_propagateNaNF128UI( uiA64, uiA0, uiB64, uiB0 );
     316    uiZ = softfloat_propagateNaNF128UI( uiA64, uiA0, uiB64, uiB0 SOFTFLOAT_STATE_ARG_COMMA );
    316317    goto propagateNaN_ZC;
    317318    /*------------------------------------------------------------------------
    … …  
    325326        if ( signZ == signC ) goto uiZ;
    326327    }
    327     softfloat_raiseFlags( softfloat_flag_invalid );
     328    softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    328329    uiZ.v64 = defaultNaNF128UI64;
    329330    uiZ.v0  = defaultNaNF128UI0;
    330331 propagateNaN_ZC:
    331     uiZ = softfloat_propagateNaNF128UI( uiZ.v64, uiZ.v0, uiC64, uiC0 );
     332    uiZ = softfloat_propagateNaNF128UI( uiZ.v64, uiZ.v0, uiC64, uiC0 SOFTFLOAT_STATE_ARG_COMMA );
    332333    goto uiZ;
    333334    /*------------------------------------------------------------------------

  • trunk/src/libs/softfloat-3e/source/s_mulAddF128M.c

    r94480 r94558  
    4949     uint32_t *zWPtr,
    5050     uint_fast8_t op
     51     SOFTFLOAT_STATE_DECL_COMMA
    5152 )
    5253{
    … …  
    7879    uint32_t *extSigPtr;
    7980    uint_fast8_t carry;
    80     void (*roundPackRoutinePtr)( bool, int32_t, uint32_t *, uint32_t * );
     81    void (*roundPackRoutinePtr)( bool, int32_t, uint32_t *, uint32_t * SOFTFLOAT_STATE_DECL_COMMA );
    8182
    8283    /*------------------------------------------------------------------------
    … …  
    9697    prodIsInfinite = false;
    9798    if ( (expA == 0x7FFF) || (expB == 0x7FFF) ) {
    98         if ( softfloat_tryPropagateNaNF128M( aWPtr, bWPtr, zWPtr ) ) {
     99        if ( softfloat_tryPropagateNaNF128M( aWPtr, bWPtr, zWPtr SOFTFLOAT_STATE_ARG_COMMA ) ) {
    99100            goto propagateNaN_ZC;
    100101        }
    … …  
    334335    roundPackRoutinePtr = softfloat_roundPackMToF128M;
    335336 doRoundPack:
    336     (*roundPackRoutinePtr)( signZ, expZ, extSigPtr, zWPtr );
     337    (*roundPackRoutinePtr)( signZ, expZ, extSigPtr, zWPtr SOFTFLOAT_STATE_ARG_COMMA );
    337338    return;
    338339    /*------------------------------------------------------------------------
    339340    *------------------------------------------------------------------------*/
    340341 invalid:
    341     softfloat_invalidF128M( zWPtr );
     342    softfloat_invalidF128M( zWPtr SOFTFLOAT_STATE_ARG_COMMA );
    342343 propagateNaN_ZC:
    343     softfloat_propagateNaNF128M( zWPtr, cWPtr, zWPtr );
     344    softfloat_propagateNaNF128M( zWPtr, cWPtr, zWPtr SOFTFLOAT_STATE_ARG_COMMA );
    344345    return;
    345346    /*------------------------------------------------------------------------

  • trunk/src/libs/softfloat-3e/source/s_mulAddF16.c

    r94480 r94558  
    4444float16_t
    4545 softfloat_mulAddF16(
    46      uint_fast16_t uiA, uint_fast16_t uiB, uint_fast16_t uiC, uint_fast8_t op )
     46     uint_fast16_t uiA, uint_fast16_t uiB, uint_fast16_t uiC, uint_fast8_t op SOFTFLOAT_STATE_DECL_COMMA )
    4747{
    4848    bool signA;
    … …  
    189189    }
    190190 roundPack:
    191     return softfloat_roundPackToF16( signZ, expZ, sigZ );
     191    return softfloat_roundPackToF16( signZ, expZ, sigZ SOFTFLOAT_STATE_ARG_COMMA );
    192192    /*------------------------------------------------------------------------
    193193    *------------------------------------------------------------------------*/
    194194 propagateNaN_ABC:
    195     uiZ = softfloat_propagateNaNF16UI( uiA, uiB );
     195    uiZ = softfloat_propagateNaNF16UI( uiA, uiB SOFTFLOAT_STATE_ARG_COMMA );
    196196    goto propagateNaN_ZC;
    197197    /*------------------------------------------------------------------------
    … …  
    204204        if ( signProd == signC ) goto uiZ;
    205205    }
    206     softfloat_raiseFlags( softfloat_flag_invalid );
     206    softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    207207    uiZ = defaultNaNF16UI;
    208208 propagateNaN_ZC:
    209     uiZ = softfloat_propagateNaNF16UI( uiZ, uiC );
     209    uiZ = softfloat_propagateNaNF16UI( uiZ, uiC SOFTFLOAT_STATE_ARG_COMMA );
    210210    goto uiZ;
    211211    /*------------------------------------------------------------------------

  • trunk/src/libs/softfloat-3e/source/s_mulAddF32.c

    r94480 r94558  
    4444float32_t
    4545 softfloat_mulAddF32(
    46      uint_fast32_t uiA, uint_fast32_t uiB, uint_fast32_t uiC, uint_fast8_t op )
     46     uint_fast32_t uiA, uint_fast32_t uiB, uint_fast32_t uiC, uint_fast8_t op SOFTFLOAT_STATE_DECL_COMMA )
    4747{
    4848    bool signA;
    … …  
    187187    }
    188188 roundPack:
    189     return softfloat_roundPackToF32( signZ, expZ, sigZ );
     189    return softfloat_roundPackToF32( signZ, expZ, sigZ SOFTFLOAT_STATE_ARG_COMMA );
    190190    /*------------------------------------------------------------------------
    191191    *------------------------------------------------------------------------*/
    192192 propagateNaN_ABC:
    193     uiZ = softfloat_propagateNaNF32UI( uiA, uiB );
     193    uiZ = softfloat_propagateNaNF32UI( uiA, uiB SOFTFLOAT_STATE_ARG_COMMA );
    194194    goto propagateNaN_ZC;
    195195    /*------------------------------------------------------------------------
    … …  
    202202        if ( signProd == signC ) goto uiZ;
    203203    }
    204     softfloat_raiseFlags( softfloat_flag_invalid );
     204    softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    205205    uiZ = defaultNaNF32UI;
    206206 propagateNaN_ZC:
    207     uiZ = softfloat_propagateNaNF32UI( uiZ, uiC );
     207    uiZ = softfloat_propagateNaNF32UI( uiZ, uiC SOFTFLOAT_STATE_ARG_COMMA );
    208208    goto uiZ;
    209209    /*------------------------------------------------------------------------

  • trunk/src/libs/softfloat-3e/source/s_mulAddF64.c

    r94483 r94558  
    4646float64_t
    4747 softfloat_mulAddF64(
    48      uint_fast64_t uiA, uint_fast64_t uiB, uint_fast64_t uiC, uint_fast8_t op )
     48     uint_fast64_t uiA, uint_fast64_t uiB, uint_fast64_t uiC, uint_fast8_t op SOFTFLOAT_STATE_DECL_COMMA )
    4949{
    5050    bool signA;
    … …  
    206206    }
    207207 roundPack:
    208     return softfloat_roundPackToF64( signZ, expZ, sigZ );
     208    return softfloat_roundPackToF64( signZ, expZ, sigZ SOFTFLOAT_STATE_ARG_COMMA );
    209209    /*------------------------------------------------------------------------
    210210    *------------------------------------------------------------------------*/
    211211 propagateNaN_ABC:
    212     uiZ = softfloat_propagateNaNF64UI( uiA, uiB );
     212    uiZ = softfloat_propagateNaNF64UI( uiA, uiB SOFTFLOAT_STATE_ARG_COMMA );
    213213    goto propagateNaN_ZC;
    214214    /*------------------------------------------------------------------------
    … …  
    221221        if ( signZ == signC ) goto uiZ;
    222222    }
    223     softfloat_raiseFlags( softfloat_flag_invalid );
     223    softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    224224    uiZ = defaultNaNF64UI;
    225225 propagateNaN_ZC:
    226     uiZ = softfloat_propagateNaNF64UI( uiZ, uiC );
     226    uiZ = softfloat_propagateNaNF64UI( uiZ, uiC SOFTFLOAT_STATE_ARG_COMMA );
    227227    goto uiZ;
    228228    /*------------------------------------------------------------------------
    … …  
    246246float64_t
    247247 softfloat_mulAddF64(
    248      uint_fast64_t uiA, uint_fast64_t uiB, uint_fast64_t uiC, uint_fast8_t op )
     248     uint_fast64_t uiA, uint_fast64_t uiB, uint_fast64_t uiC, uint_fast8_t op SOFTFLOAT_STATE_DECL_COMMA )
    249249{
    250250    bool signA;
    … …  
    457457    if ( sig128Z[indexWord( 4, 1 )] || sig128Z[indexWord( 4, 0 )] ) sigZ |= 1;
    458458 roundPack:
    459     return softfloat_roundPackToF64( signZ, expZ - 1, sigZ );
     459    return softfloat_roundPackToF64( signZ, expZ - 1, sigZ SOFTFLOAT_STATE_ARG_COMMA );
    460460    /*------------------------------------------------------------------------
    461461    *------------------------------------------------------------------------*/
    462462 propagateNaN_ABC:
    463     uiZ = softfloat_propagateNaNF64UI( uiA, uiB );
     463    uiZ = softfloat_propagateNaNF64UI( uiA, uiB SOFTFLOAT_STATE_ARG_COMMA );
    464464    goto propagateNaN_ZC;
    465465    /*------------------------------------------------------------------------
    … …  
    472472        if ( signZ == signC ) goto uiZ;
    473473    }
    474     softfloat_raiseFlags( softfloat_flag_invalid );
     474    softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    475475    uiZ = defaultNaNF64UI;
    476476 propagateNaN_ZC:
    477     uiZ = softfloat_propagateNaNF64UI( uiZ, uiC );
     477    uiZ = softfloat_propagateNaNF64UI( uiZ, uiC SOFTFLOAT_STATE_ARG_COMMA );
    478478    goto uiZ;
    479479    /*------------------------------------------------------------------------

  • trunk/src/libs/softfloat-3e/source/s_normRoundPackMToExtF80M.c

    r94480 r94558  
    4747     uint_fast8_t roundingPrecision,
    4848     struct extFloat80M *zSPtr
     49     SOFTFLOAT_STATE_DECL_COMMA
    4950 )
    5051{
    … …  
    7374    }
    7475    softfloat_roundPackMToExtF80M(
    75         sign, exp, extSigPtr, roundingPrecision, zSPtr );
     76        sign, exp, extSigPtr, roundingPrecision, zSPtr SOFTFLOAT_STATE_ARG_COMMA );
    7677
    7778}

  • trunk/src/libs/softfloat-3e/source/s_normRoundPackMToF128M.c

    r94480 r94558  
    4242void
    4343 softfloat_normRoundPackMToF128M(
    44      bool sign, int32_t exp, uint32_t *extSigPtr, uint32_t *zWPtr )
     44     bool sign, int32_t exp, uint32_t *extSigPtr, uint32_t *zWPtr SOFTFLOAT_STATE_DECL_COMMA )
    4545{
    4646    const uint32_t *ptr;
    … …  
    6868        softfloat_shiftLeft160M( extSigPtr, shiftDist, extSigPtr );
    6969    }
    70     softfloat_roundPackMToF128M( sign, exp, extSigPtr, zWPtr );
     70    softfloat_roundPackMToF128M( sign, exp, extSigPtr, zWPtr SOFTFLOAT_STATE_ARG_COMMA );
    7171
    7272}

  • trunk/src/libs/softfloat-3e/source/s_normRoundPackToExtF80.c

    r94480 r94558  
    4747     uint_fast64_t sigExtra,
    4848     uint_fast8_t roundingPrecision
     49     SOFTFLOAT_STATE_DECL_COMMA
    4950 )
    5051{
    … …  
    6667    return
    6768        softfloat_roundPackToExtF80(
    68             sign, exp, sig, sigExtra, roundingPrecision );
     69            sign, exp, sig, sigExtra, roundingPrecision SOFTFLOAT_STATE_ARG_COMMA );
    6970
    7071}

  • trunk/src/libs/softfloat-3e/source/s_normRoundPackToF128.c

    r94480 r94558  
    4242float128_t
    4343 softfloat_normRoundPackToF128(
    44      bool sign, int_fast32_t exp, uint_fast64_t sig64, uint_fast64_t sig0 )
     44     bool sign, int_fast32_t exp, uint_fast64_t sig64, uint_fast64_t sig0 SOFTFLOAT_STATE_DECL_COMMA )
    4545{
    4646    int_fast8_t shiftDist;
    … …  
    7676        sigExtra = sig128Extra.extra;
    7777    }
    78     return softfloat_roundPackToF128( sign, exp, sig64, sig0, sigExtra );
     78    return softfloat_roundPackToF128( sign, exp, sig64, sig0, sigExtra SOFTFLOAT_STATE_ARG_COMMA );
    7979
    8080}

  • trunk/src/libs/softfloat-3e/source/s_normRoundPackToF16.c

    r94480 r94558  
    4141
    4242float16_t
    43  softfloat_normRoundPackToF16( bool sign, int_fast16_t exp, uint_fast16_t sig )
     43 softfloat_normRoundPackToF16( bool sign, int_fast16_t exp, uint_fast16_t sig SOFTFLOAT_STATE_DECL_COMMA )
    4444{
    4545    int_fast8_t shiftDist;
    … …  
    5252        return uZ.f;
    5353    } else {
    54         return softfloat_roundPackToF16( sign, exp, sig<<shiftDist );
     54        return softfloat_roundPackToF16( sign, exp, sig<<shiftDist SOFTFLOAT_STATE_ARG_COMMA );
    5555    }
    5656

  • trunk/src/libs/softfloat-3e/source/s_normRoundPackToF32.c

    r94480 r94558  
    4141
    4242float32_t
    43  softfloat_normRoundPackToF32( bool sign, int_fast16_t exp, uint_fast32_t sig )
     43 softfloat_normRoundPackToF32( bool sign, int_fast16_t exp, uint_fast32_t sig SOFTFLOAT_STATE_DECL_COMMA )
    4444{
    4545    int_fast8_t shiftDist;
    … …  
    5252        return uZ.f;
    5353    } else {
    54         return softfloat_roundPackToF32( sign, exp, sig<<shiftDist );
     54        return softfloat_roundPackToF32( sign, exp, sig<<shiftDist SOFTFLOAT_STATE_ARG_COMMA );
    5555    }
    5656

  • trunk/src/libs/softfloat-3e/source/s_normRoundPackToF64.c

    r94480 r94558  
    4141
    4242float64_t
    43  softfloat_normRoundPackToF64( bool sign, int_fast16_t exp, uint_fast64_t sig )
     43 softfloat_normRoundPackToF64( bool sign, int_fast16_t exp, uint_fast64_t sig SOFTFLOAT_STATE_DECL_COMMA )
    4444{
    4545    int_fast8_t shiftDist;
    … …  
    5252        return uZ.f;
    5353    } else {
    54         return softfloat_roundPackToF64( sign, exp, sig<<shiftDist );
     54        return softfloat_roundPackToF64( sign, exp, sig<<shiftDist SOFTFLOAT_STATE_ARG_COMMA );
    5555    }
    5656

  • trunk/src/libs/softfloat-3e/source/s_roundMToI64.c

    r94480 r94558  
    4444int_fast64_t
    4545 softfloat_roundMToI64(
    46      bool sign, uint32_t *extSigPtr, uint_fast8_t roundingMode, bool exact )
     46     bool sign, uint32_t *extSigPtr, uint_fast8_t roundingMode, bool exact SOFTFLOAT_STATE_DECL_COMMA )
    4747{
    4848    uint64_t sig;
    … …  
    9696    *------------------------------------------------------------------------*/
    9797 invalid:
    98     softfloat_raiseFlags( softfloat_flag_invalid );
     98    softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    9999    return sign ? i64_fromNegOverflow : i64_fromPosOverflow;
    100100

  • trunk/src/libs/softfloat-3e/source/s_roundMToUI64.c

    r94480 r94558  
    4444uint_fast64_t
    4545 softfloat_roundMToUI64(
    46      bool sign, uint32_t *extSigPtr, uint_fast8_t roundingMode, bool exact )
     46     bool sign, uint32_t *extSigPtr, uint_fast8_t roundingMode, bool exact SOFTFLOAT_STATE_DECL_COMMA)
    4747{
    4848    uint64_t sig;
    … …  
    9292    *------------------------------------------------------------------------*/
    9393 invalid:
    94     softfloat_raiseFlags( softfloat_flag_invalid );
     94    softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    9595    return sign ? ui64_fromNegOverflow : ui64_fromPosOverflow;
    9696

  • trunk/src/libs/softfloat-3e/source/s_roundPackMToExtF80M.c

    r94480 r94558  
    4848     uint_fast8_t roundingPrecision,
    4949     struct extFloat80M *zSPtr
     50     SOFTFLOAT_STATE_DECL_COMMA
    5051 )
    5152{
    … …  
    99100            roundBits = sig & roundMask;
    100101            if ( roundBits ) {
    101                 if ( isTiny ) softfloat_raiseFlags( softfloat_flag_underflow );
     102                if ( isTiny ) softfloat_raiseFlags( softfloat_flag_underflow SOFTFLOAT_STATE_ARG_COMMA );
    102103                softfloat_exceptionFlags |= softfloat_flag_inexact;
    103104#ifdef SOFTFLOAT_ROUND_ODD
    … …  
    175176            sigExtra = extSigPtr[indexWordLo( 3 )];
    176177            if ( sigExtra ) {
    177                 if ( isTiny ) softfloat_raiseFlags( softfloat_flag_underflow );
     178                if ( isTiny ) softfloat_raiseFlags( softfloat_flag_underflow SOFTFLOAT_STATE_ARG_COMMA );
    178179                softfloat_exceptionFlags |= softfloat_flag_inexact;
    179180#ifdef SOFTFLOAT_ROUND_ODD
    … …  
    211212 overflow:
    212213            softfloat_raiseFlags(
    213                 softfloat_flag_overflow | softfloat_flag_inexact );
     214                softfloat_flag_overflow | softfloat_flag_inexact
     215                SOFTFLOAT_STATE_ARG_COMMA );
    214216            if (
    215217                   roundNearEven

  • trunk/src/libs/softfloat-3e/source/s_roundPackMToF128M.c

    r94480 r94558  
    4343void
    4444 softfloat_roundPackMToF128M(
    45      bool sign, int32_t exp, uint32_t *extSigPtr, uint32_t *zWPtr )
     45     bool sign, int32_t exp, uint32_t *extSigPtr, uint32_t *zWPtr SOFTFLOAT_STATE_DECL_COMMA )
    4646{
    4747    uint_fast8_t roundingMode;
    … …  
    8383            sigExtra = extSigPtr[indexWordLo( 5 )];
    8484            if ( isTiny && sigExtra ) {
    85                 softfloat_raiseFlags( softfloat_flag_underflow );
     85                softfloat_raiseFlags( softfloat_flag_underflow SOFTFLOAT_STATE_ARG_COMMA );
    8686            }
    8787            doIncrement = (0x80000000 <= sigExtra);
    … …  
    105105            *----------------------------------------------------------------*/
    106106            softfloat_raiseFlags(
    107                 softfloat_flag_overflow | softfloat_flag_inexact );
     107                softfloat_flag_overflow | softfloat_flag_inexact
     108                SOFTFLOAT_STATE_ARG_COMMA );
    108109            if (
    109110                   roundNearEven

  • trunk/src/libs/softfloat-3e/source/s_roundPackToExtF80.c

    r94480 r94558  
    4848     uint_fast64_t sigExtra,
    4949     uint_fast8_t roundingPrecision
     50     SOFTFLOAT_STATE_DECL_COMMA
    5051 )
    5152{
    … …  
    9495            roundBits = sig & roundMask;
    9596            if ( roundBits ) {
    96                 if ( isTiny ) softfloat_raiseFlags( softfloat_flag_underflow );
     97                if ( isTiny ) softfloat_raiseFlags( softfloat_flag_underflow SOFTFLOAT_STATE_ARG_COMMA );
    9798                softfloat_exceptionFlags |= softfloat_flag_inexact;
     99                if ( roundIncrement ) softfloat_exceptionFlags |= softfloat_flag_c1; /* VBox */
    98100#ifdef SOFTFLOAT_ROUND_ODD
    99101                if ( roundingMode == softfloat_round_odd ) {
    … …  
    122124    if ( roundBits ) {
    123125        softfloat_exceptionFlags |= softfloat_flag_inexact;
     126        if ( roundIncrement ) softfloat_exceptionFlags |= softfloat_flag_c1; /* VBox */
    124127#ifdef SOFTFLOAT_ROUND_ODD
    125128        if ( roundingMode == softfloat_round_odd ) {
    … …  
    168171            sigExtra = sig64Extra.extra;
    169172            if ( sigExtra ) {
    170                 if ( isTiny ) softfloat_raiseFlags( softfloat_flag_underflow );
    171                 softfloat_exceptionFlags |= softfloat_flag_inexact;
     173                if ( isTiny ) softfloat_raiseFlags( softfloat_flag_underflow SOFTFLOAT_STATE_ARG_COMMA );
    172174#ifdef SOFTFLOAT_ROUND_ODD
    173175                if ( roundingMode == softfloat_round_odd ) {
    … …  
    188190            }
    189191            if ( doIncrement ) {
     192                softfloat_exceptionFlags |= softfloat_flag_c1; /* VBox */
    190193                ++sig;
    191194                sig &=
    … …  
    207210 overflow:
    208211            softfloat_raiseFlags(
    209                 softfloat_flag_overflow | softfloat_flag_inexact );
     212                softfloat_flag_overflow | softfloat_flag_inexact
     213                SOFTFLOAT_STATE_ARG_COMMA );
    210214            if (
    211215                   roundNearEven
    … …  
    235239    }
    236240    if ( doIncrement ) {
     241        softfloat_exceptionFlags |= softfloat_flag_c1; /* VBox */
    237242        ++sig;
    238243        if ( ! sig ) {

  • trunk/src/libs/softfloat-3e/source/s_roundPackToF128.c

    r94480 r94558  
    4848     uint_fast64_t sig0,
    4949     uint_fast64_t sigExtra
     50     SOFTFLOAT_STATE_DECL_COMMA
    5051 )
    5152{
    … …  
    9293            exp = 0;
    9394            if ( isTiny && sigExtra ) {
    94                 softfloat_raiseFlags( softfloat_flag_underflow );
     95                softfloat_raiseFlags( softfloat_flag_underflow SOFTFLOAT_STATE_ARG_COMMA );
    9596            }
    9697            doIncrement = (UINT64_C( 0x8000000000000000 ) <= sigExtra);
    … …  
    118119            *----------------------------------------------------------------*/
    119120            softfloat_raiseFlags(
    120                 softfloat_flag_overflow | softfloat_flag_inexact );
     121                softfloat_flag_overflow | softfloat_flag_inexact
     122                SOFTFLOAT_STATE_ARG_COMMA );
    121123            if (
    122124                   roundNearEven

  • trunk/src/libs/softfloat-3e/source/s_roundPackToF16.c

    r94480 r94558  
    4242
    4343float16_t
    44  softfloat_roundPackToF16( bool sign, int_fast16_t exp, uint_fast16_t sig )
     44 softfloat_roundPackToF16( bool sign, int_fast16_t exp, uint_fast16_t sig SOFTFLOAT_STATE_DECL_COMMA )
    4545{
    4646    uint_fast8_t roundingMode;
    … …  
    7777            roundBits = sig & 0xF;
    7878            if ( isTiny && roundBits ) {
    79                 softfloat_raiseFlags( softfloat_flag_underflow );
     79                softfloat_raiseFlags( softfloat_flag_underflow SOFTFLOAT_STATE_ARG_COMMA );
    8080            }
    8181        } else if ( (0x1D < exp) || (0x8000 <= sig + roundIncrement) ) {
    … …  
    8383            *----------------------------------------------------------------*/
    8484            softfloat_raiseFlags(
    85                 softfloat_flag_overflow | softfloat_flag_inexact );
     85                softfloat_flag_overflow | softfloat_flag_inexact
     86                SOFTFLOAT_STATE_ARG_COMMA );
    8687            uiZ = packToF16UI( sign, 0x1F, 0 ) - ! roundIncrement;
    8788            goto uiZ;

  • trunk/src/libs/softfloat-3e/source/s_roundPackToF32.c

    r94480 r94558  
    4242
    4343float32_t
    44  softfloat_roundPackToF32( bool sign, int_fast16_t exp, uint_fast32_t sig )
     44 softfloat_roundPackToF32( bool sign, int_fast16_t exp, uint_fast32_t sig SOFTFLOAT_STATE_DECL_COMMA )
    4545{
    4646    uint_fast8_t roundingMode;
    … …  
    7777            roundBits = sig & 0x7F;
    7878            if ( isTiny && roundBits ) {
    79                 softfloat_raiseFlags( softfloat_flag_underflow );
     79                softfloat_raiseFlags( softfloat_flag_underflow SOFTFLOAT_STATE_ARG_COMMA );
    8080            }
    8181        } else if ( (0xFD < exp) || (0x80000000 <= sig + roundIncrement) ) {
    … …  
    8383            *----------------------------------------------------------------*/
    8484            softfloat_raiseFlags(
    85                 softfloat_flag_overflow | softfloat_flag_inexact );
     85                softfloat_flag_overflow | softfloat_flag_inexact
     86                SOFTFLOAT_STATE_ARG_COMMA );
    8687            uiZ = packToF32UI( sign, 0xFF, 0 ) - ! roundIncrement;
    8788            goto uiZ;

  • trunk/src/libs/softfloat-3e/source/s_roundPackToF64.c

    r94480 r94558  
    4242
    4343float64_t
    44  softfloat_roundPackToF64( bool sign, int_fast16_t exp, uint_fast64_t sig )
     44 softfloat_roundPackToF64( bool sign, int_fast16_t exp, uint_fast64_t sig SOFTFLOAT_STATE_DECL_COMMA )
    4545{
    4646    uint_fast8_t roundingMode;
    … …  
    7878            roundBits = sig & 0x3FF;
    7979            if ( isTiny && roundBits ) {
    80                 softfloat_raiseFlags( softfloat_flag_underflow );
     80                softfloat_raiseFlags( softfloat_flag_underflow SOFTFLOAT_STATE_ARG_COMMA );
    8181            }
    8282        } else if (
    … …  
    8787            *----------------------------------------------------------------*/
    8888            softfloat_raiseFlags(
    89                 softfloat_flag_overflow | softfloat_flag_inexact );
     89                softfloat_flag_overflow | softfloat_flag_inexact
     90                SOFTFLOAT_STATE_ARG_COMMA );
    9091            uiZ = packToF64UI( sign, 0x7FF, 0 ) - ! roundIncrement;
    9192            goto uiZ;

  • trunk/src/libs/softfloat-3e/source/s_roundToI32.c

    r94480 r94558  
    4444int_fast32_t
    4545 softfloat_roundToI32(
    46      bool sign, uint_fast64_t sig, uint_fast8_t roundingMode, bool exact )
     46     bool sign, uint_fast64_t sig, uint_fast8_t roundingMode, bool exact SOFTFLOAT_STATE_DECL_COMMA )
    4747{
    4848    uint_fast16_t roundIncrement, roundBits;
    … …  
    9292    *------------------------------------------------------------------------*/
    9393 invalid:
    94     softfloat_raiseFlags( softfloat_flag_invalid );
     94    softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    9595    return sign ? i32_fromNegOverflow : i32_fromPosOverflow;
    9696

  • trunk/src/libs/softfloat-3e/source/s_roundToI64.c

    r94480 r94558  
    4949     uint_fast8_t roundingMode,
    5050     bool exact
     51     SOFTFLOAT_STATE_DECL_COMMA
    5152 )
    5253{
    … …  
    9596    *------------------------------------------------------------------------*/
    9697 invalid:
    97     softfloat_raiseFlags( softfloat_flag_invalid );
     98    softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    9899    return sign ? i64_fromNegOverflow : i64_fromPosOverflow;
    99100

  • trunk/src/libs/softfloat-3e/source/s_roundToUI32.c

    r94480 r94558  
    4444uint_fast32_t
    4545 softfloat_roundToUI32(
    46      bool sign, uint_fast64_t sig, uint_fast8_t roundingMode, bool exact )
     46     bool sign, uint_fast64_t sig, uint_fast8_t roundingMode, bool exact SOFTFLOAT_STATE_DECL_COMMA)
    4747{
    4848    uint_fast16_t roundIncrement, roundBits;
    … …  
    8787    *------------------------------------------------------------------------*/
    8888 invalid:
    89     softfloat_raiseFlags( softfloat_flag_invalid );
     89    softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    9090    return sign ? ui32_fromNegOverflow : ui32_fromPosOverflow;
    9191

  • trunk/src/libs/softfloat-3e/source/s_roundToUI64.c

    r94480 r94558  
    4949     uint_fast8_t roundingMode,
    5050     bool exact
     51     SOFTFLOAT_STATE_DECL_COMMA
    5152 )
    5253{
    … …  
    9192    *------------------------------------------------------------------------*/
    9293 invalid:
    93     softfloat_raiseFlags( softfloat_flag_invalid );
     94    softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    9495    return sign ? ui64_fromNegOverflow : ui64_fromPosOverflow;
    9596

  • trunk/src/libs/softfloat-3e/source/s_subMagsExtF80.c

    r94480 r94558  
    4949     uint_fast64_t uiB0,
    5050     bool signZ
     51     SOFTFLOAT_STATE_DECL_COMMA
    5152 )
    5253{
    … …  
    7879            goto propagateNaN;
    7980        }
    80         softfloat_raiseFlags( softfloat_flag_invalid );
     81        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    8182        uiZ64 = defaultNaNExtF80UI64;
    8283        uiZ0  = defaultNaNExtF80UI0;
    … …  
    143144    return
    144145        softfloat_normRoundPackToExtF80(
    145             signZ, expZ, sig128.v64, sig128.v0, extF80_roundingPrecision );
     146            signZ, expZ, sig128.v64, sig128.v0, extF80_roundingPrecision SOFTFLOAT_STATE_ARG_COMMA );
    146147    /*------------------------------------------------------------------------
    147148    *------------------------------------------------------------------------*/
    148149 propagateNaN:
    149     uiZ = softfloat_propagateNaNExtF80UI( uiA64, uiA0, uiB64, uiB0 );
     150    uiZ = softfloat_propagateNaNExtF80UI( uiA64, uiA0, uiB64, uiB0 SOFTFLOAT_STATE_ARG_COMMA );
    150151    uiZ64 = uiZ.v64;
    151152    uiZ0  = uiZ.v0;

  • trunk/src/libs/softfloat-3e/source/s_subMagsF128.c

    r94480 r94558  
    4949     uint_fast64_t uiB0,
    5050     bool signZ
     51     SOFTFLOAT_STATE_DECL_COMMA
    5152 )
    5253{
    … …  
    7273    if ( expA == 0x7FFF ) {
    7374        if ( sigA.v64 | sigA.v0 | sigB.v64 | sigB.v0 ) goto propagateNaN;
    74         softfloat_raiseFlags( softfloat_flag_invalid );
     75        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    7576        uiZ.v64 = defaultNaNF128UI64;
    7677        uiZ.v0  = defaultNaNF128UI0;
    … …  
    129130    sigZ = softfloat_sub128( sigA.v64, sigA.v0, sigB.v64, sigB.v0 );
    130131 normRoundPack:
    131     return softfloat_normRoundPackToF128( signZ, expZ - 5, sigZ.v64, sigZ.v0 );
     132    return softfloat_normRoundPackToF128( signZ, expZ - 5, sigZ.v64, sigZ.v0 SOFTFLOAT_STATE_ARG_COMMA );
    132133 propagateNaN:
    133     uiZ = softfloat_propagateNaNF128UI( uiA64, uiA0, uiB64, uiB0 );
     134    uiZ = softfloat_propagateNaNF128UI( uiA64, uiA0, uiB64, uiB0 SOFTFLOAT_STATE_ARG_COMMA );
    134135 uiZ:
    135136    uZ.ui = uiZ;

  • trunk/src/libs/softfloat-3e/source/s_subMagsF16.c

    r94480 r94558  
    4242#include "softfloat.h"
    4343
    44 float16_t softfloat_subMagsF16( uint_fast16_t uiA, uint_fast16_t uiB )
     44float16_t softfloat_subMagsF16( uint_fast16_t uiA, uint_fast16_t uiB SOFTFLOAT_STATE_DECL_COMMA )
    4545{
    4646    int_fast8_t expA;
    … …  
    7272        if ( expA == 0x1F ) {
    7373            if ( sigA | sigB ) goto propagateNaN;
    74             softfloat_raiseFlags( softfloat_flag_invalid );
     74            softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    7575            uiZ = defaultNaNF16UI;
    7676            goto uiZ;
    … …  
    148148            }
    149149        }
    150         return softfloat_roundPackToF16( signZ, expZ, sigZ );
     150        return softfloat_roundPackToF16( signZ, expZ, sigZ SOFTFLOAT_STATE_ARG_COMMA );
    151151    }
    152152    /*------------------------------------------------------------------------
    153153    *------------------------------------------------------------------------*/
    154154 propagateNaN:
    155     uiZ = softfloat_propagateNaNF16UI( uiA, uiB );
     155    uiZ = softfloat_propagateNaNF16UI( uiA, uiB SOFTFLOAT_STATE_ARG_COMMA );
    156156    goto uiZ;
    157157    /*------------------------------------------------------------------------

  • trunk/src/libs/softfloat-3e/source/s_subMagsF32.c

    r94480 r94558  
    4242#include "softfloat.h"
    4343
    44 float32_t softfloat_subMagsF32( uint_fast32_t uiA, uint_fast32_t uiB )
     44float32_t softfloat_subMagsF32( uint_fast32_t uiA, uint_fast32_t uiB SOFTFLOAT_STATE_DECL_COMMA )
    4545{
    4646    int_fast16_t expA;
    … …  
    7171        if ( expA == 0xFF ) {
    7272            if ( sigA | sigB ) goto propagateNaN;
    73             softfloat_raiseFlags( softfloat_flag_invalid );
     73            softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    7474            uiZ = defaultNaNF32UI;
    7575            goto uiZ;
    … …  
    129129        return
    130130            softfloat_normRoundPackToF32(
    131                 signZ, expZ, sigX - softfloat_shiftRightJam32( sigY, expDiff )
     131                signZ, expZ, sigX - softfloat_shiftRightJam32( sigY, expDiff ) SOFTFLOAT_STATE_ARG_COMMA
    132132            );
    133133    }
    … …  
    135135    *------------------------------------------------------------------------*/
    136136 propagateNaN:
    137     uiZ = softfloat_propagateNaNF32UI( uiA, uiB );
     137    uiZ = softfloat_propagateNaNF32UI( uiA, uiB SOFTFLOAT_STATE_ARG_COMMA );
    138138 uiZ:
    139139    uZ.ui = uiZ;

  • trunk/src/libs/softfloat-3e/source/s_subMagsF64.c

    r94480 r94558  
    4343
    4444float64_t
    45  softfloat_subMagsF64( uint_fast64_t uiA, uint_fast64_t uiB, bool signZ )
     45 softfloat_subMagsF64( uint_fast64_t uiA, uint_fast64_t uiB, bool signZ SOFTFLOAT_STATE_DECL_COMMA )
    4646{
    4747    int_fast16_t expA;
    … …  
    7171        if ( expA == 0x7FF ) {
    7272            if ( sigA | sigB ) goto propagateNaN;
    73             softfloat_raiseFlags( softfloat_flag_invalid );
     73            softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
    7474            uiZ = defaultNaNF64UI;
    7575            goto uiZ;
    … …  
    128128            sigZ = sigA - sigB;
    129129        }
    130         return softfloat_normRoundPackToF64( signZ, expZ - 1, sigZ );
     130        return softfloat_normRoundPackToF64( signZ, expZ - 1, sigZ SOFTFLOAT_STATE_ARG_COMMA );
    131131    }
    132132    /*------------------------------------------------------------------------
    133133    *------------------------------------------------------------------------*/
    134134 propagateNaN:
    135     uiZ = softfloat_propagateNaNF64UI( uiA, uiB );
     135    uiZ = softfloat_propagateNaNF64UI( uiA, uiB SOFTFLOAT_STATE_ARG_COMMA );
    136136 uiZ:
    137137    uZ.ui = uiZ;

  • trunk/src/libs/softfloat-3e/source/s_tryPropagateNaNExtF80M.c

    r94480 r94558  
    4545     const struct extFloat80M *bSPtr,
    4646     struct extFloat80M *zSPtr
     47     SOFTFLOAT_STATE_DECL_COMMA
    4748 )
    4849{
    … …  
    5859    return false;
    5960 propagateNaN:
    60     softfloat_propagateNaNExtF80M( aSPtr, bSPtr, zSPtr );
     61    softfloat_propagateNaNExtF80M( aSPtr, bSPtr, zSPtr SOFTFLOAT_STATE_ARG_COMMA );
    6162    return true;
    6263

  • trunk/src/libs/softfloat-3e/source/s_tryPropagateNaNF128M.c

    r94480 r94558  
    4343bool
    4444 softfloat_tryPropagateNaNF128M(
    45      const uint32_t *aWPtr, const uint32_t *bWPtr, uint32_t *zWPtr )
     45     const uint32_t *aWPtr, const uint32_t *bWPtr, uint32_t *zWPtr SOFTFLOAT_STATE_DECL_COMMA )
    4646{
    4747
    4848    if ( softfloat_isNaNF128M( aWPtr ) || softfloat_isNaNF128M( bWPtr ) ) {
    49         softfloat_propagateNaNF128M( aWPtr, bWPtr, zWPtr );
     49        softfloat_propagateNaNF128M( aWPtr, bWPtr, zWPtr SOFTFLOAT_STATE_ARG_COMMA );
    5050        return true;
    5151    }

  • trunk/src/libs/softfloat-3e/source/softfloat_state.c

    r94480 r94558  
    4545#endif
    4646
     47#ifndef VBOX_WITHOUT_SOFTFLOAT_GLOBALS
    4748THREAD_LOCAL uint_fast8_t softfloat_roundingMode = softfloat_round_near_even;
    4849THREAD_LOCAL uint_fast8_t softfloat_detectTininess = init_detectTininess;
    … …  
    5051
    5152THREAD_LOCAL uint_fast8_t extF80_roundingPrecision = 80;
    52 
     53#endif

  • trunk/src/libs/softfloat-3e/source/ui32_to_extF80.c

    r94480 r94558  
    4040#include "softfloat.h"
    4141
    42 extFloat80_t ui32_to_extF80( uint32_t a )
     42extFloat80_t ui32_to_extF80( uint32_t a SOFTFLOAT_STATE_DECL_COMMA )
    4343{
    4444    uint_fast16_t uiZ64;
    4545    int_fast8_t shiftDist;
    4646    union { struct extFloat80M s; extFloat80_t f; } uZ;
     47    SOFTFLOAT_STATE_NOREF();
    4748
    4849    uiZ64 = 0;

  • trunk/src/libs/softfloat-3e/source/ui32_to_extF80M.c

    r94480 r94558  
    4242#ifdef SOFTFLOAT_FAST_INT64
    4343
    44 void ui32_to_extF80M( uint32_t a, extFloat80_t *zPtr )
     44void ui32_to_extF80M( uint32_t a, extFloat80_t *zPtr SOFTFLOAT_STATE_DECL_COMMA )
    4545{
    4646
    47     *zPtr = ui32_to_extF80( a );
     47    *zPtr = ui32_to_extF80( a SOFTFLOAT_STATE_ARG_COMMA );
    4848
    4949}
    … …  
    5151#else
    5252
    53 void ui32_to_extF80M( uint32_t a, extFloat80_t *zPtr )
     53void ui32_to_extF80M( uint32_t a, extFloat80_t *zPtr SOFTFLOAT_STATE_DECL_COMMA )
    5454{
    5555    struct extFloat80M *zSPtr;
    … …  
    5757    uint64_t sigZ;
    5858    int_fast8_t shiftDist;
     59    SOFTFLOAT_STATE_NOREF();
    5960
    6061    zSPtr = (struct extFloat80M *) zPtr;

  • trunk/src/libs/softfloat-3e/source/ui32_to_f128.c

    r94480 r94558  
    4040#include "softfloat.h"
    4141
    42 float128_t ui32_to_f128( uint32_t a )
     42float128_t ui32_to_f128( uint32_t a SOFTFLOAT_STATE_DECL_COMMA )
    4343{
    4444    uint_fast64_t uiZ64;
    4545    int_fast8_t shiftDist;
    4646    union ui128_f128 uZ;
     47    SOFTFLOAT_STATE_NOREF();
    4748
    4849    uiZ64 = 0;

  • trunk/src/libs/softfloat-3e/source/ui32_to_f128M.c

    r94480 r94558  
    4242#ifdef SOFTFLOAT_FAST_INT64
    4343
    44 void ui32_to_f128M( uint32_t a, float128_t *zPtr )
     44void ui32_to_f128M( uint32_t a, float128_t *zPtr SOFTFLOAT_STATE_DECL_COMMA )
    4545{
    4646
    47     *zPtr = ui32_to_f128( a );
     47    *zPtr = ui32_to_f128( a SOFTFLOAT_STATE_ARG_COMMA );
    4848
    4949}
    … …  
    5151#else
    5252
    53 void ui32_to_f128M( uint32_t a, float128_t *zPtr )
     53void ui32_to_f128M( uint32_t a, float128_t *zPtr SOFTFLOAT_STATE_DECL_COMMA )
    5454{
    5555    uint32_t *zWPtr, uiZ96, uiZ64;
    5656    int_fast8_t shiftDist;
    5757    uint64_t normA;
     58    SOFTFLOAT_STATE_NOREF();
    5859
    5960    zWPtr = (uint32_t *) zPtr;

  • trunk/src/libs/softfloat-3e/source/ui32_to_f16.c

    r94480 r94558  
    4040#include "softfloat.h"
    4141
    42 float16_t ui32_to_f16( uint32_t a )
     42float16_t ui32_to_f16( uint32_t a SOFTFLOAT_STATE_DECL_COMMA )
    4343{
    4444    int_fast8_t shiftDist;
    … …  
    5959                ? a>>(-shiftDist) | ((uint32_t) (a<<(shiftDist & 31)) != 0)
    6060                : (uint_fast16_t) a<<shiftDist;
    61         return softfloat_roundPackToF16( 0, 0x1C - shiftDist, sig );
     61        return softfloat_roundPackToF16( 0, 0x1C - shiftDist, sig SOFTFLOAT_STATE_ARG_COMMA );
    6262    }
    6363

  • trunk/src/libs/softfloat-3e/source/ui32_to_f32.c

    r94480 r94558  
    4040#include "softfloat.h"
    4141
    42 float32_t ui32_to_f32( uint32_t a )
     42float32_t ui32_to_f32( uint32_t a SOFTFLOAT_STATE_DECL_COMMA )
    4343{
    4444    union ui32_f32 uZ;
    … …  
    4949    }
    5050    if ( a & 0x80000000 ) {
    51         return softfloat_roundPackToF32( 0, 0x9D, a>>1 | (a & 1) );
     51        return softfloat_roundPackToF32( 0, 0x9D, a>>1 | (a & 1) SOFTFLOAT_STATE_ARG_COMMA );
    5252    } else {
    53         return softfloat_normRoundPackToF32( 0, 0x9C, a );
     53        return softfloat_normRoundPackToF32( 0, 0x9C, a SOFTFLOAT_STATE_ARG_COMMA );
    5454    }
    5555

  • trunk/src/libs/softfloat-3e/source/ui32_to_f64.c

    r94480 r94558  
    4040#include "softfloat.h"
    4141
    42 float64_t ui32_to_f64( uint32_t a )
     42float64_t ui32_to_f64( uint32_t a SOFTFLOAT_STATE_DECL_COMMA )
    4343{
    4444    uint_fast64_t uiZ;
    4545    int_fast8_t shiftDist;
    4646    union ui64_f64 uZ;
     47    SOFTFLOAT_STATE_NOREF();
    4748
    4849    if ( ! a ) {

  • trunk/src/libs/softfloat-3e/source/ui64_to_extF80.c

    r94480 r94558  
    4040#include "softfloat.h"
    4141
    42 extFloat80_t ui64_to_extF80( uint64_t a )
     42extFloat80_t ui64_to_extF80( uint64_t a SOFTFLOAT_STATE_DECL_COMMA )
    4343{
    4444    uint_fast16_t uiZ64;
    4545    int_fast8_t shiftDist;
    4646    union { struct extFloat80M s; extFloat80_t f; } uZ;
     47    SOFTFLOAT_STATE_NOREF();
    4748
    4849    uiZ64 = 0;

  • trunk/src/libs/softfloat-3e/source/ui64_to_extF80M.c

    r94480 r94558  
    4242#ifdef SOFTFLOAT_FAST_INT64
    4343
    44 void ui64_to_extF80M( uint64_t a, extFloat80_t *zPtr )
     44void ui64_to_extF80M( uint64_t a, extFloat80_t *zPtr SOFTFLOAT_STATE_DECL_COMMA )
    4545{
    4646
    47     *zPtr = ui64_to_extF80( a );
     47    *zPtr = ui64_to_extF80( a SOFTFLOAT_STATE_ARG_COMMA );
    4848
    4949}
    … …  
    5151#else
    5252
    53 void ui64_to_extF80M( uint64_t a, extFloat80_t *zPtr )
     53void ui64_to_extF80M( uint64_t a, extFloat80_t *zPtr SOFTFLOAT_STATE_DECL_COMMA )
    5454{
    5555    struct extFloat80M *zSPtr;
    … …  
    5757    uint64_t sigZ;
    5858    int_fast8_t shiftDist;
     59    SOFTFLOAT_STATE_NOREF();
    5960
    6061    zSPtr = (struct extFloat80M *) zPtr;

  • trunk/src/libs/softfloat-3e/source/ui64_to_f128.c

    r94480 r94558  
    4040#include "softfloat.h"
    4141
    42 float128_t ui64_to_f128( uint64_t a )
     42float128_t ui64_to_f128( uint64_t a SOFTFLOAT_STATE_DECL_COMMA )
    4343{
    4444    uint_fast64_t uiZ64, uiZ0;
    … …  
    4646    struct uint128 zSig;
    4747    union ui128_f128 uZ;
     48    SOFTFLOAT_STATE_NOREF();
    4849
    4950    if ( ! a ) {

  • trunk/src/libs/softfloat-3e/source/ui64_to_f128M.c

    r94480 r94558  
    4242#ifdef SOFTFLOAT_FAST_INT64
    4343
    44 void ui64_to_f128M( uint64_t a, float128_t *zPtr )
     44void ui64_to_f128M( uint64_t a, float128_t *zPtr SOFTFLOAT_STATE_DECL_COMMA )
    4545{
    4646
    47     *zPtr = ui64_to_f128( a );
     47    *zPtr = ui64_to_f128( a SOFTFLOAT_STATE_ARG_COMMA );
    4848
    4949}
    … …  
    5151#else
    5252
    53 void ui64_to_f128M( uint64_t a, float128_t *zPtr )
     53void ui64_to_f128M( uint64_t a, float128_t *zPtr SOFTFLOAT_STATE_DECL_COMMA )
    5454{
    5555    uint32_t *zWPtr, uiZ96, uiZ64;
    5656    uint_fast8_t shiftDist;
    5757    uint32_t *ptr;
     58    SOFTFLOAT_STATE_NOREF();
    5859
    5960    zWPtr = (uint32_t *) zPtr;

  • trunk/src/libs/softfloat-3e/source/ui64_to_f16.c

    r94480 r94558  
    4040#include "softfloat.h"
    4141
    42 float16_t ui64_to_f16( uint64_t a )
     42float16_t ui64_to_f16( uint64_t a SOFTFLOAT_STATE_DECL_COMMA )
    4343{
    4444    int_fast8_t shiftDist;
    … …  
    5858            (shiftDist < 0) ? softfloat_shortShiftRightJam64( a, -shiftDist )
    5959                : (uint_fast16_t) a<<shiftDist;
    60         return softfloat_roundPackToF16( 0, 0x1C - shiftDist, sig );
     60        return softfloat_roundPackToF16( 0, 0x1C - shiftDist, sig SOFTFLOAT_STATE_ARG_COMMA );
    6161    }
    6262

  • trunk/src/libs/softfloat-3e/source/ui64_to_f32.c

    r94480 r94558  
    4040#include "softfloat.h"
    4141
    42 float32_t ui64_to_f32( uint64_t a )
     42float32_t ui64_to_f32( uint64_t a SOFTFLOAT_STATE_DECL_COMMA )
    4343{
    4444    int_fast8_t shiftDist;
    … …  
    5858            (shiftDist < 0) ? softfloat_shortShiftRightJam64( a, -shiftDist )
    5959                : (uint_fast32_t) a<<shiftDist;
    60         return softfloat_roundPackToF32( 0, 0x9C - shiftDist, sig );
     60        return softfloat_roundPackToF32( 0, 0x9C - shiftDist, sig SOFTFLOAT_STATE_ARG_COMMA );
    6161    }
    6262

  • trunk/src/libs/softfloat-3e/source/ui64_to_f64.c

    r94480 r94558  
    4040#include "softfloat.h"
    4141
    42 float64_t ui64_to_f64( uint64_t a )
     42float64_t ui64_to_f64( uint64_t a SOFTFLOAT_STATE_DECL_COMMA )
    4343{
    4444    union ui64_f64 uZ;
    … …  
    5151        return
    5252            softfloat_roundPackToF64(
    53                 0, 0x43D, softfloat_shortShiftRightJam64( a, 1 ) );
     53                0, 0x43D, softfloat_shortShiftRightJam64( a, 1 ) SOFTFLOAT_STATE_ARG_COMMA );
    5454    } else {
    55         return softfloat_normRoundPackToF64( 0, 0x43C, a );
     55        return softfloat_normRoundPackToF64( 0, 0x43C, a SOFTFLOAT_STATE_ARG_COMMA );
    5656    }
    5757
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