Index: trunk/src/libs/softfloat-3e/source/8086-SSE/s_extF80MToCommonNaN.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/8086-SSE/s_extF80MToCommonNaN.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/8086-SSE/s_extF80MToCommonNaN.c	(revision 94558)
@@ -49,9 +49,9 @@
 void
  softfloat_extF80MToCommonNaN(
-     const struct extFloat80M *aSPtr, struct commonNaN *zPtr )
+     const struct extFloat80M *aSPtr, struct commonNaN *zPtr SOFTFLOAT_STATE_DECL_COMMA )
 {
 
     if ( extF80M_isSignalingNaN( (const extFloat80_t *) aSPtr ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
     }
     zPtr->sign = signExtF80UI64( aSPtr->signExp );
Index: trunk/src/libs/softfloat-3e/source/8086-SSE/s_extF80UIToCommonNaN.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/8086-SSE/s_extF80UIToCommonNaN.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/8086-SSE/s_extF80UIToCommonNaN.c	(revision 94558)
@@ -49,9 +49,9 @@
 void
  softfloat_extF80UIToCommonNaN(
-     uint_fast16_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr )
+     uint_fast16_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr SOFTFLOAT_STATE_DECL_COMMA )
 {
 
     if ( softfloat_isSigNaNExtF80UI( uiA64, uiA0 ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
     }
     zPtr->sign = uiA64>>15;
Index: trunk/src/libs/softfloat-3e/source/8086-SSE/s_f128MToCommonNaN.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/8086-SSE/s_f128MToCommonNaN.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/8086-SSE/s_f128MToCommonNaN.c	(revision 94558)
@@ -50,9 +50,9 @@
 *----------------------------------------------------------------------------*/
 void
- softfloat_f128MToCommonNaN( const uint32_t *aWPtr, struct commonNaN *zPtr )
+ softfloat_f128MToCommonNaN( const uint32_t *aWPtr, struct commonNaN *zPtr SOFTFLOAT_STATE_DECL_COMMA )
 {
 
     if ( f128M_isSignalingNaN( (const float128_t *) aWPtr ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
     }
     zPtr->sign = aWPtr[indexWordHi( 4 )]>>31;
Index: trunk/src/libs/softfloat-3e/source/8086-SSE/s_f128UIToCommonNaN.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/8086-SSE/s_f128UIToCommonNaN.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/8086-SSE/s_f128UIToCommonNaN.c	(revision 94558)
@@ -50,10 +50,10 @@
 void
  softfloat_f128UIToCommonNaN(
-     uint_fast64_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr )
+     uint_fast64_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr SOFTFLOAT_STATE_DECL_COMMA )
 {
     struct uint128 NaNSig;
 
     if ( softfloat_isSigNaNF128UI( uiA64, uiA0 ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
     }
     NaNSig = softfloat_shortShiftLeft128( uiA64, uiA0, 16 );
Index: trunk/src/libs/softfloat-3e/source/8086-SSE/s_f16UIToCommonNaN.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/8086-SSE/s_f16UIToCommonNaN.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/8086-SSE/s_f16UIToCommonNaN.c	(revision 94558)
@@ -46,9 +46,9 @@
 | exception is raised.
 *----------------------------------------------------------------------------*/
-void softfloat_f16UIToCommonNaN( uint_fast16_t uiA, struct commonNaN *zPtr )
+void softfloat_f16UIToCommonNaN( uint_fast16_t uiA, struct commonNaN *zPtr SOFTFLOAT_STATE_DECL_COMMA )
 {
 
     if ( softfloat_isSigNaNF16UI( uiA ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
     }
     zPtr->sign = uiA>>15;
Index: trunk/src/libs/softfloat-3e/source/8086-SSE/s_f32UIToCommonNaN.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/8086-SSE/s_f32UIToCommonNaN.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/8086-SSE/s_f32UIToCommonNaN.c	(revision 94558)
@@ -46,9 +46,9 @@
 | exception is raised.
 *----------------------------------------------------------------------------*/
-void softfloat_f32UIToCommonNaN( uint_fast32_t uiA, struct commonNaN *zPtr )
+void softfloat_f32UIToCommonNaN( uint_fast32_t uiA, struct commonNaN *zPtr SOFTFLOAT_STATE_DECL_COMMA )
 {
 
     if ( softfloat_isSigNaNF32UI( uiA ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
     }
     zPtr->sign = uiA>>31;
Index: trunk/src/libs/softfloat-3e/source/8086-SSE/s_f64UIToCommonNaN.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/8086-SSE/s_f64UIToCommonNaN.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/8086-SSE/s_f64UIToCommonNaN.c	(revision 94558)
@@ -46,9 +46,9 @@
 | exception is raised.
 *----------------------------------------------------------------------------*/
-void softfloat_f64UIToCommonNaN( uint_fast64_t uiA, struct commonNaN *zPtr )
+void softfloat_f64UIToCommonNaN( uint_fast64_t uiA, struct commonNaN *zPtr SOFTFLOAT_STATE_DECL_COMMA )
 {
 
     if ( softfloat_isSigNaNF64UI( uiA ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
     }
     zPtr->sign = uiA>>63;
Index: trunk/src/libs/softfloat-3e/source/8086-SSE/s_propagateNaNExtF80M.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/8086-SSE/s_propagateNaNExtF80M.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/8086-SSE/s_propagateNaNExtF80M.c	(revision 94558)
@@ -53,4 +53,5 @@
      const struct extFloat80M *bSPtr,
      struct extFloat80M *zSPtr
+     SOFTFLOAT_STATE_DECL_COMMA
  )
 {
@@ -67,10 +68,10 @@
     sPtr = aSPtr;
     if ( ! bSPtr ) {
-        if ( isSigNaNA ) softfloat_raiseFlags( softfloat_flag_invalid );
+        if ( isSigNaNA ) softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
         goto copy;
     }
     isSigNaNB = extF80M_isSignalingNaN( (const extFloat80_t *) bSPtr );
     if ( isSigNaNA | isSigNaNB ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
         if ( isSigNaNA ) {
             uiB64 = bSPtr->signExp;
Index: trunk/src/libs/softfloat-3e/source/8086-SSE/s_propagateNaNExtF80UI.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/8086-SSE/s_propagateNaNExtF80UI.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/8086-SSE/s_propagateNaNExtF80UI.c	(revision 94558)
@@ -57,4 +57,5 @@
      uint_fast16_t uiB64,
      uint_fast64_t uiB0
+     SOFTFLOAT_STATE_DECL_COMMA
  )
 {
@@ -76,5 +77,5 @@
     *------------------------------------------------------------------------*/
     if ( isSigNaNA | isSigNaNB ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
         if ( isSigNaNA ) {
             if ( isSigNaNB ) goto returnLargerMag;
Index: trunk/src/libs/softfloat-3e/source/8086-SSE/s_propagateNaNF128M.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/8086-SSE/s_propagateNaNF128M.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/8086-SSE/s_propagateNaNF128M.c	(revision 94558)
@@ -52,5 +52,5 @@
 void
  softfloat_propagateNaNF128M(
-     const uint32_t *aWPtr, const uint32_t *bWPtr, uint32_t *zWPtr )
+     const uint32_t *aWPtr, const uint32_t *bWPtr, uint32_t *zWPtr SOFTFLOAT_STATE_DECL_COMMA )
 {
     bool isSigNaNA;
@@ -63,5 +63,5 @@
             || (bWPtr && f128M_isSignalingNaN( (const float128_t *) bWPtr ))
     ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
         if ( isSigNaNA ) goto copy;
     }
Index: trunk/src/libs/softfloat-3e/source/8086-SSE/s_propagateNaNF128UI.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/8086-SSE/s_propagateNaNF128UI.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/8086-SSE/s_propagateNaNF128UI.c	(revision 94558)
@@ -57,4 +57,5 @@
      uint_fast64_t uiB64,
      uint_fast64_t uiB0
+     SOFTFLOAT_STATE_DECL_COMMA
  )
 {
@@ -64,5 +65,5 @@
     isSigNaNA = softfloat_isSigNaNF128UI( uiA64, uiA0 );
     if ( isSigNaNA || softfloat_isSigNaNF128UI( uiB64, uiB0 ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
         if ( isSigNaNA ) goto returnNonsigA;
     }
Index: trunk/src/libs/softfloat-3e/source/8086-SSE/s_propagateNaNF16UI.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/8086-SSE/s_propagateNaNF16UI.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/8086-SSE/s_propagateNaNF16UI.c	(revision 94558)
@@ -49,5 +49,5 @@
 *----------------------------------------------------------------------------*/
 uint_fast16_t
- softfloat_propagateNaNF16UI( uint_fast16_t uiA, uint_fast16_t uiB )
+ softfloat_propagateNaNF16UI( uint_fast16_t uiA, uint_fast16_t uiB SOFTFLOAT_STATE_DECL_COMMA )
 {
     bool isSigNaNA;
@@ -55,5 +55,5 @@
     isSigNaNA = softfloat_isSigNaNF16UI( uiA );
     if ( isSigNaNA || softfloat_isSigNaNF16UI( uiB ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
         if ( isSigNaNA ) return uiA | 0x0200;
     }
Index: trunk/src/libs/softfloat-3e/source/8086-SSE/s_propagateNaNF32UI.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/8086-SSE/s_propagateNaNF32UI.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/8086-SSE/s_propagateNaNF32UI.c	(revision 94558)
@@ -49,5 +49,5 @@
 *----------------------------------------------------------------------------*/
 uint_fast32_t
- softfloat_propagateNaNF32UI( uint_fast32_t uiA, uint_fast32_t uiB )
+ softfloat_propagateNaNF32UI( uint_fast32_t uiA, uint_fast32_t uiB SOFTFLOAT_STATE_DECL_COMMA )
 {
     bool isSigNaNA;
@@ -55,5 +55,5 @@
     isSigNaNA = softfloat_isSigNaNF32UI( uiA );
     if ( isSigNaNA || softfloat_isSigNaNF32UI( uiB ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
         if ( isSigNaNA ) return uiA | 0x00400000;
     }
Index: trunk/src/libs/softfloat-3e/source/8086-SSE/s_propagateNaNF64UI.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/8086-SSE/s_propagateNaNF64UI.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/8086-SSE/s_propagateNaNF64UI.c	(revision 94558)
@@ -49,5 +49,5 @@
 *----------------------------------------------------------------------------*/
 uint_fast64_t
- softfloat_propagateNaNF64UI( uint_fast64_t uiA, uint_fast64_t uiB )
+ softfloat_propagateNaNF64UI( uint_fast64_t uiA, uint_fast64_t uiB SOFTFLOAT_STATE_DECL_COMMA )
 {
     bool isSigNaNA;
@@ -55,5 +55,5 @@
     isSigNaNA = softfloat_isSigNaNF64UI( uiA );
     if ( isSigNaNA || softfloat_isSigNaNF64UI( uiB ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
         if ( isSigNaNA ) return uiA | UINT64_C( 0x0008000000000000 );
     }
Index: trunk/src/libs/softfloat-3e/source/8086-SSE/softfloat_raiseFlags.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/8086-SSE/softfloat_raiseFlags.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/8086-SSE/softfloat_raiseFlags.c	(revision 94558)
@@ -44,8 +44,12 @@
 | should be simply `softfloat_exceptionFlags |= flags;'.
 *----------------------------------------------------------------------------*/
-void softfloat_raiseFlags( uint_fast8_t flags )
+void softfloat_raiseFlags( uint_fast8_t flags SOFTFLOAT_STATE_ARG_COMMA )
 {
 
+#ifdef VBOX_WITHOUT_SOFTFLOAT_GLOBALS
     softfloat_exceptionFlags |= flags;
+#else
+    pState->exceptionFlags   |= flags;
+#endif
 
 }
Index: trunk/src/libs/softfloat-3e/source/8086-SSE/specialize.h
===================================================================
--- trunk/src/libs/softfloat-3e/source/8086-SSE/specialize.h	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/8086-SSE/specialize.h	(revision 94558)
@@ -101,5 +101,5 @@
 | exception is raised.
 *----------------------------------------------------------------------------*/
-void softfloat_f16UIToCommonNaN( uint_fast16_t uiA, struct commonNaN *zPtr );
+void softfloat_f16UIToCommonNaN( uint_fast16_t uiA, struct commonNaN *zPtr SOFTFLOAT_STATE_DECL_COMMA );
 
 /*----------------------------------------------------------------------------
@@ -116,5 +116,5 @@
 *----------------------------------------------------------------------------*/
 uint_fast16_t
- softfloat_propagateNaNF16UI( uint_fast16_t uiA, uint_fast16_t uiB );
+ softfloat_propagateNaNF16UI( uint_fast16_t uiA, uint_fast16_t uiB SOFTFLOAT_STATE_DECL_COMMA );
 
 /*----------------------------------------------------------------------------
@@ -136,5 +136,5 @@
 | exception is raised.
 *----------------------------------------------------------------------------*/
-void softfloat_f32UIToCommonNaN( uint_fast32_t uiA, struct commonNaN *zPtr );
+void softfloat_f32UIToCommonNaN( uint_fast32_t uiA, struct commonNaN *zPtr SOFTFLOAT_STATE_DECL_COMMA );
 
 /*----------------------------------------------------------------------------
@@ -151,5 +151,5 @@
 *----------------------------------------------------------------------------*/
 uint_fast32_t
- softfloat_propagateNaNF32UI( uint_fast32_t uiA, uint_fast32_t uiB );
+ softfloat_propagateNaNF32UI( uint_fast32_t uiA, uint_fast32_t uiB SOFTFLOAT_STATE_DECL_COMMA );
 
 /*----------------------------------------------------------------------------
@@ -171,5 +171,5 @@
 | exception is raised.
 *----------------------------------------------------------------------------*/
-void softfloat_f64UIToCommonNaN( uint_fast64_t uiA, struct commonNaN *zPtr );
+void softfloat_f64UIToCommonNaN( uint_fast64_t uiA, struct commonNaN *zPtr SOFTFLOAT_STATE_DECL_COMMA );
 
 /*----------------------------------------------------------------------------
@@ -186,5 +186,5 @@
 *----------------------------------------------------------------------------*/
 uint_fast64_t
- softfloat_propagateNaNF64UI( uint_fast64_t uiA, uint_fast64_t uiB );
+ softfloat_propagateNaNF64UI( uint_fast64_t uiA, uint_fast64_t uiB SOFTFLOAT_STATE_DECL_COMMA );
 
 /*----------------------------------------------------------------------------
@@ -218,5 +218,5 @@
 void
  softfloat_extF80UIToCommonNaN(
-     uint_fast16_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr );
+     uint_fast16_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr SOFTFLOAT_STATE_DECL_COMMA );
 
 /*----------------------------------------------------------------------------
@@ -242,4 +242,5 @@
      uint_fast16_t uiB64,
      uint_fast64_t uiB0
+     SOFTFLOAT_STATE_DECL_COMMA
  );
 
@@ -267,5 +268,5 @@
 void
  softfloat_f128UIToCommonNaN(
-     uint_fast64_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr );
+     uint_fast64_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr SOFTFLOAT_STATE_DECL_COMMA );
 
 /*----------------------------------------------------------------------------
@@ -290,4 +291,5 @@
      uint_fast64_t uiB64,
      uint_fast64_t uiB0
+     SOFTFLOAT_STATE_DECL_COMMA
  );
 
@@ -307,5 +309,5 @@
 void
  softfloat_extF80MToCommonNaN(
-     const struct extFloat80M *aSPtr, struct commonNaN *zPtr );
+     const struct extFloat80M *aSPtr, struct commonNaN *zPtr SOFTFLOAT_STATE_DECL_COMMA );
 
 /*----------------------------------------------------------------------------
@@ -329,4 +331,5 @@
      const struct extFloat80M *bSPtr,
      struct extFloat80M *zSPtr
+     SOFTFLOAT_STATE_DECL_COMMA
  );
 
@@ -348,5 +351,5 @@
 *----------------------------------------------------------------------------*/
 void
- softfloat_f128MToCommonNaN( const uint32_t *aWPtr, struct commonNaN *zPtr );
+ softfloat_f128MToCommonNaN( const uint32_t *aWPtr, struct commonNaN *zPtr SOFTFLOAT_STATE_DECL_COMMA );
 
 /*----------------------------------------------------------------------------
@@ -369,5 +372,5 @@
 void
  softfloat_propagateNaNF128M(
-     const uint32_t *aWPtr, const uint32_t *bWPtr, uint32_t *zWPtr );
+     const uint32_t *aWPtr, const uint32_t *bWPtr, uint32_t *zWPtr SOFTFLOAT_STATE_DECL_COMMA );
 
 #endif
Index: trunk/src/libs/softfloat-3e/source/8086/s_extF80MToCommonNaN.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/8086/s_extF80MToCommonNaN.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/8086/s_extF80MToCommonNaN.c	(revision 94558)
@@ -49,9 +49,9 @@
 void
  softfloat_extF80MToCommonNaN(
-     const struct extFloat80M *aSPtr, struct commonNaN *zPtr )
+     const struct extFloat80M *aSPtr, struct commonNaN *zPtr SOFTFLOAT_STATE_DECL_COMMA )
 {
 
     if ( extF80M_isSignalingNaN( (const extFloat80_t *) aSPtr ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
     }
     zPtr->sign = signExtF80UI64( aSPtr->signExp );
Index: trunk/src/libs/softfloat-3e/source/8086/s_extF80UIToCommonNaN.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/8086/s_extF80UIToCommonNaN.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/8086/s_extF80UIToCommonNaN.c	(revision 94558)
@@ -49,9 +49,9 @@
 void
  softfloat_extF80UIToCommonNaN(
-     uint_fast16_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr )
+     uint_fast16_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr SOFTFLOAT_STATE_DECL_COMMA )
 {
 
     if ( softfloat_isSigNaNExtF80UI( uiA64, uiA0 ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
     }
     zPtr->sign = uiA64>>15;
Index: trunk/src/libs/softfloat-3e/source/8086/s_f128MToCommonNaN.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/8086/s_f128MToCommonNaN.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/8086/s_f128MToCommonNaN.c	(revision 94558)
@@ -50,9 +50,9 @@
 *----------------------------------------------------------------------------*/
 void
- softfloat_f128MToCommonNaN( const uint32_t *aWPtr, struct commonNaN *zPtr )
+ softfloat_f128MToCommonNaN( const uint32_t *aWPtr, struct commonNaN *zPtr SOFTFLOAT_STATE_DECL_COMMA )
 {
 
     if ( f128M_isSignalingNaN( (const float128_t *) aWPtr ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
     }
     zPtr->sign = aWPtr[indexWordHi( 4 )]>>31;
Index: trunk/src/libs/softfloat-3e/source/8086/s_f128UIToCommonNaN.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/8086/s_f128UIToCommonNaN.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/8086/s_f128UIToCommonNaN.c	(revision 94558)
@@ -50,10 +50,10 @@
 void
  softfloat_f128UIToCommonNaN(
-     uint_fast64_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr )
+     uint_fast64_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr SOFTFLOAT_STATE_DECL_COMMA )
 {
     struct uint128 NaNSig;
 
     if ( softfloat_isSigNaNF128UI( uiA64, uiA0 ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
     }
     NaNSig = softfloat_shortShiftLeft128( uiA64, uiA0, 16 );
Index: trunk/src/libs/softfloat-3e/source/8086/s_f16UIToCommonNaN.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/8086/s_f16UIToCommonNaN.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/8086/s_f16UIToCommonNaN.c	(revision 94558)
@@ -46,9 +46,9 @@
 | exception is raised.
 *----------------------------------------------------------------------------*/
-void softfloat_f16UIToCommonNaN( uint_fast16_t uiA, struct commonNaN *zPtr )
+void softfloat_f16UIToCommonNaN( uint_fast16_t uiA, struct commonNaN *zPtr SOFTFLOAT_STATE_DECL_COMMA )
 {
 
     if ( softfloat_isSigNaNF16UI( uiA ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
     }
     zPtr->sign = uiA>>15;
Index: trunk/src/libs/softfloat-3e/source/8086/s_f32UIToCommonNaN.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/8086/s_f32UIToCommonNaN.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/8086/s_f32UIToCommonNaN.c	(revision 94558)
@@ -46,9 +46,9 @@
 | exception is raised.
 *----------------------------------------------------------------------------*/
-void softfloat_f32UIToCommonNaN( uint_fast32_t uiA, struct commonNaN *zPtr )
+void softfloat_f32UIToCommonNaN( uint_fast32_t uiA, struct commonNaN *zPtr SOFTFLOAT_STATE_DECL_COMMA )
 {
 
     if ( softfloat_isSigNaNF32UI( uiA ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
     }
     zPtr->sign = uiA>>31;
Index: trunk/src/libs/softfloat-3e/source/8086/s_f64UIToCommonNaN.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/8086/s_f64UIToCommonNaN.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/8086/s_f64UIToCommonNaN.c	(revision 94558)
@@ -46,9 +46,9 @@
 | exception is raised.
 *----------------------------------------------------------------------------*/
-void softfloat_f64UIToCommonNaN( uint_fast64_t uiA, struct commonNaN *zPtr )
+void softfloat_f64UIToCommonNaN( uint_fast64_t uiA, struct commonNaN *zPtr SOFTFLOAT_STATE_DECL_COMMA )
 {
 
     if ( softfloat_isSigNaNF64UI( uiA ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
     }
     zPtr->sign = uiA>>63;
Index: trunk/src/libs/softfloat-3e/source/8086/s_propagateNaNExtF80M.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/8086/s_propagateNaNExtF80M.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/8086/s_propagateNaNExtF80M.c	(revision 94558)
@@ -53,4 +53,5 @@
      const struct extFloat80M *bSPtr,
      struct extFloat80M *zSPtr
+     SOFTFLOAT_STATE_DECL_COMMA
  )
 {
@@ -67,10 +68,10 @@
     sPtr = aSPtr;
     if ( ! bSPtr ) {
-        if ( isSigNaNA ) softfloat_raiseFlags( softfloat_flag_invalid );
+        if ( isSigNaNA ) softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
         goto copy;
     }
     isSigNaNB = extF80M_isSignalingNaN( (const extFloat80_t *) bSPtr );
     if ( isSigNaNA | isSigNaNB ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
         if ( isSigNaNA ) {
             uiB64 = bSPtr->signExp;
Index: trunk/src/libs/softfloat-3e/source/8086/s_propagateNaNExtF80UI.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/8086/s_propagateNaNExtF80UI.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/8086/s_propagateNaNExtF80UI.c	(revision 94558)
@@ -57,4 +57,5 @@
      uint_fast16_t uiB64,
      uint_fast64_t uiB0
+     SOFTFLOAT_STATE_DECL_COMMA
  )
 {
@@ -76,5 +77,5 @@
     *------------------------------------------------------------------------*/
     if ( isSigNaNA | isSigNaNB ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
         if ( isSigNaNA ) {
             if ( isSigNaNB ) goto returnLargerMag;
Index: trunk/src/libs/softfloat-3e/source/8086/s_propagateNaNF128M.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/8086/s_propagateNaNF128M.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/8086/s_propagateNaNF128M.c	(revision 94558)
@@ -52,5 +52,5 @@
 void
  softfloat_propagateNaNF128M(
-     const uint32_t *aWPtr, const uint32_t *bWPtr, uint32_t *zWPtr )
+     const uint32_t *aWPtr, const uint32_t *bWPtr, uint32_t *zWPtr SOFTFLOAT_STATE_DECL_COMMA )
 {
     bool isSigNaNA;
@@ -62,10 +62,10 @@
     ptr = aWPtr;
     if ( ! bWPtr ) {
-        if ( isSigNaNA ) softfloat_raiseFlags( softfloat_flag_invalid );
+        if ( isSigNaNA ) softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
         goto copy;
     }
     isSigNaNB = f128M_isSignalingNaN( (const float128_t *) bWPtr );
     if ( isSigNaNA | isSigNaNB ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
         if ( isSigNaNA ) {
             if ( isSigNaNB ) goto returnLargerUIMag;
Index: trunk/src/libs/softfloat-3e/source/8086/s_propagateNaNF128UI.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/8086/s_propagateNaNF128UI.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/8086/s_propagateNaNF128UI.c	(revision 94558)
@@ -57,4 +57,5 @@
      uint_fast64_t uiB64,
      uint_fast64_t uiB0
+     SOFTFLOAT_STATE_DECL_COMMA
  )
 {
@@ -75,5 +76,5 @@
     *------------------------------------------------------------------------*/
     if ( isSigNaNA | isSigNaNB ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
         if ( isSigNaNA ) {
             if ( isSigNaNB ) goto returnLargerMag;
Index: trunk/src/libs/softfloat-3e/source/8086/s_propagateNaNF16UI.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/8086/s_propagateNaNF16UI.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/8086/s_propagateNaNF16UI.c	(revision 94558)
@@ -49,5 +49,5 @@
 *----------------------------------------------------------------------------*/
 uint_fast16_t
- softfloat_propagateNaNF16UI( uint_fast16_t uiA, uint_fast16_t uiB )
+ softfloat_propagateNaNF16UI( uint_fast16_t uiA, uint_fast16_t uiB SOFTFLOAT_STATE_DECL_COMMA )
 {
     bool isSigNaNA, isSigNaNB;
@@ -66,5 +66,5 @@
     *------------------------------------------------------------------------*/
     if ( isSigNaNA | isSigNaNB ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
         if ( isSigNaNA ) {
             if ( isSigNaNB ) goto returnLargerMag;
Index: trunk/src/libs/softfloat-3e/source/8086/s_propagateNaNF32UI.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/8086/s_propagateNaNF32UI.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/8086/s_propagateNaNF32UI.c	(revision 94558)
@@ -49,5 +49,5 @@
 *----------------------------------------------------------------------------*/
 uint_fast32_t
- softfloat_propagateNaNF32UI( uint_fast32_t uiA, uint_fast32_t uiB )
+ softfloat_propagateNaNF32UI( uint_fast32_t uiA, uint_fast32_t uiB SOFTFLOAT_STATE_DECL_COMMA )
 {
     bool isSigNaNA, isSigNaNB;
@@ -66,5 +66,5 @@
     *------------------------------------------------------------------------*/
     if ( isSigNaNA | isSigNaNB ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
         if ( isSigNaNA ) {
             if ( isSigNaNB ) goto returnLargerMag;
Index: trunk/src/libs/softfloat-3e/source/8086/s_propagateNaNF64UI.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/8086/s_propagateNaNF64UI.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/8086/s_propagateNaNF64UI.c	(revision 94558)
@@ -49,5 +49,5 @@
 *----------------------------------------------------------------------------*/
 uint_fast64_t
- softfloat_propagateNaNF64UI( uint_fast64_t uiA, uint_fast64_t uiB )
+ softfloat_propagateNaNF64UI( uint_fast64_t uiA, uint_fast64_t uiB SOFTFLOAT_STATE_DECL_COMMA )
 {
     bool isSigNaNA, isSigNaNB;
@@ -66,5 +66,5 @@
     *------------------------------------------------------------------------*/
     if ( isSigNaNA | isSigNaNB ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
         if ( isSigNaNA ) {
             if ( isSigNaNB ) goto returnLargerMag;
Index: trunk/src/libs/softfloat-3e/source/8086/softfloat_raiseFlags.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/8086/softfloat_raiseFlags.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/8086/softfloat_raiseFlags.c	(revision 94558)
@@ -44,8 +44,12 @@
 | should be simply `softfloat_exceptionFlags |= flags;'.
 *----------------------------------------------------------------------------*/
-void softfloat_raiseFlags( uint_fast8_t flags )
+void softfloat_raiseFlags( uint_fast8_t flags SOFTFLOAT_STATE_DECL_COMMA )
 {
 
+#ifdef VBOX_WITHOUT_SOFTFLOAT_GLOBALS
     softfloat_exceptionFlags |= flags;
+#else
+    pState->exceptionFlags   |= flags;
+#endif
 
 }
Index: trunk/src/libs/softfloat-3e/source/8086/specialize.h
===================================================================
--- trunk/src/libs/softfloat-3e/source/8086/specialize.h	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/8086/specialize.h	(revision 94558)
@@ -101,5 +101,5 @@
 | exception is raised.
 *----------------------------------------------------------------------------*/
-void softfloat_f16UIToCommonNaN( uint_fast16_t uiA, struct commonNaN *zPtr );
+void softfloat_f16UIToCommonNaN( uint_fast16_t uiA, struct commonNaN *zPtr SOFTFLOAT_STATE_DECL_COMMA );
 
 /*----------------------------------------------------------------------------
@@ -116,5 +116,5 @@
 *----------------------------------------------------------------------------*/
 uint_fast16_t
- softfloat_propagateNaNF16UI( uint_fast16_t uiA, uint_fast16_t uiB );
+ softfloat_propagateNaNF16UI( uint_fast16_t uiA, uint_fast16_t uiB SOFTFLOAT_STATE_DECL_COMMA );
 
 /*----------------------------------------------------------------------------
@@ -136,5 +136,5 @@
 | exception is raised.
 *----------------------------------------------------------------------------*/
-void softfloat_f32UIToCommonNaN( uint_fast32_t uiA, struct commonNaN *zPtr );
+void softfloat_f32UIToCommonNaN( uint_fast32_t uiA, struct commonNaN *zPtr SOFTFLOAT_STATE_DECL_COMMA );
 
 /*----------------------------------------------------------------------------
@@ -151,5 +151,5 @@
 *----------------------------------------------------------------------------*/
 uint_fast32_t
- softfloat_propagateNaNF32UI( uint_fast32_t uiA, uint_fast32_t uiB );
+ softfloat_propagateNaNF32UI( uint_fast32_t uiA, uint_fast32_t uiB SOFTFLOAT_STATE_DECL_COMMA );
 
 /*----------------------------------------------------------------------------
@@ -171,5 +171,5 @@
 | exception is raised.
 *----------------------------------------------------------------------------*/
-void softfloat_f64UIToCommonNaN( uint_fast64_t uiA, struct commonNaN *zPtr );
+void softfloat_f64UIToCommonNaN( uint_fast64_t uiA, struct commonNaN *zPtr SOFTFLOAT_STATE_DECL_COMMA );
 
 /*----------------------------------------------------------------------------
@@ -186,5 +186,5 @@
 *----------------------------------------------------------------------------*/
 uint_fast64_t
- softfloat_propagateNaNF64UI( uint_fast64_t uiA, uint_fast64_t uiB );
+ softfloat_propagateNaNF64UI( uint_fast64_t uiA, uint_fast64_t uiB SOFTFLOAT_STATE_DECL_COMMA );
 
 /*----------------------------------------------------------------------------
@@ -218,5 +218,5 @@
 void
  softfloat_extF80UIToCommonNaN(
-     uint_fast16_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr );
+     uint_fast16_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr SOFTFLOAT_STATE_DECL_COMMA );
 
 /*----------------------------------------------------------------------------
@@ -242,4 +242,5 @@
      uint_fast16_t uiB64,
      uint_fast64_t uiB0
+     SOFTFLOAT_STATE_DECL_COMMA
  );
 
@@ -267,5 +268,5 @@
 void
  softfloat_f128UIToCommonNaN(
-     uint_fast64_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr );
+     uint_fast64_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr SOFTFLOAT_STATE_DECL_COMMA );
 
 /*----------------------------------------------------------------------------
@@ -290,4 +291,5 @@
      uint_fast64_t uiB64,
      uint_fast64_t uiB0
+     SOFTFLOAT_STATE_DECL_COMMA
  );
 
@@ -307,5 +309,5 @@
 void
  softfloat_extF80MToCommonNaN(
-     const struct extFloat80M *aSPtr, struct commonNaN *zPtr );
+     const struct extFloat80M *aSPtr, struct commonNaN *zPtr SOFTFLOAT_STATE_DECL_COMMA );
 
 /*----------------------------------------------------------------------------
@@ -329,4 +331,5 @@
      const struct extFloat80M *bSPtr,
      struct extFloat80M *zSPtr
+     SOFTFLOAT_STATE_DECL_COMMA
  );
 
@@ -348,5 +351,5 @@
 *----------------------------------------------------------------------------*/
 void
- softfloat_f128MToCommonNaN( const uint32_t *aWPtr, struct commonNaN *zPtr );
+ softfloat_f128MToCommonNaN( const uint32_t *aWPtr, struct commonNaN *zPtr SOFTFLOAT_STATE_DECL_COMMA );
 
 /*----------------------------------------------------------------------------
@@ -369,5 +372,5 @@
 void
  softfloat_propagateNaNF128M(
-     const uint32_t *aWPtr, const uint32_t *bWPtr, uint32_t *zWPtr );
+     const uint32_t *aWPtr, const uint32_t *bWPtr, uint32_t *zWPtr SOFTFLOAT_STATE_DECL_COMMA );
 
 #endif
Index: trunk/src/libs/softfloat-3e/source/ARM-VFPv2-defaultNaN/s_propagateNaNExtF80M.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/ARM-VFPv2-defaultNaN/s_propagateNaNExtF80M.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/ARM-VFPv2-defaultNaN/s_propagateNaNExtF80M.c	(revision 94558)
@@ -52,4 +52,5 @@
      const struct extFloat80M *bSPtr,
      struct extFloat80M *zSPtr
+     SOFTFLOAT_STATE_DECL_COMMA
  )
 {
@@ -66,5 +67,5 @@
                         softfloat_isSigNaNExtF80UI( ui64, ui0 )))
     ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
     }
     zSPtr->signExp = defaultNaNExtF80UI64;
Index: trunk/src/libs/softfloat-3e/source/ARM-VFPv2-defaultNaN/s_propagateNaNExtF80UI.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/ARM-VFPv2-defaultNaN/s_propagateNaNExtF80UI.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/ARM-VFPv2-defaultNaN/s_propagateNaNExtF80UI.c	(revision 94558)
@@ -56,4 +56,5 @@
      uint_fast16_t uiB64,
      uint_fast64_t uiB0
+     SOFTFLOAT_STATE_DECL_COMMA
  )
 {
@@ -64,5 +65,5 @@
         || softfloat_isSigNaNExtF80UI( uiB64, uiB0 )
     ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
     }
     uiZ.v64 = defaultNaNExtF80UI64;
Index: trunk/src/libs/softfloat-3e/source/ARM-VFPv2-defaultNaN/s_propagateNaNF128M.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/ARM-VFPv2-defaultNaN/s_propagateNaNF128M.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/ARM-VFPv2-defaultNaN/s_propagateNaNF128M.c	(revision 94558)
@@ -51,5 +51,5 @@
 void
  softfloat_propagateNaNF128M(
-     const uint32_t *aWPtr, const uint32_t *bWPtr, uint32_t *zWPtr )
+     const uint32_t *aWPtr, const uint32_t *bWPtr, uint32_t *zWPtr SOFTFLOAT_STATE_DECL_COMMA )
 {
 
@@ -58,5 +58,5 @@
             || (bWPtr && f128M_isSignalingNaN( (const float128_t *) bWPtr ))
     ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
     }
     zWPtr[indexWord( 4, 3 )] = defaultNaNF128UI96;
Index: trunk/src/libs/softfloat-3e/source/ARM-VFPv2-defaultNaN/s_propagateNaNF128UI.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/ARM-VFPv2-defaultNaN/s_propagateNaNF128UI.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/ARM-VFPv2-defaultNaN/s_propagateNaNF128UI.c	(revision 94558)
@@ -56,4 +56,5 @@
      uint_fast64_t uiB64,
      uint_fast64_t uiB0
+     SOFTFLOAT_STATE_DECL_COMMA
  )
 {
@@ -64,5 +65,5 @@
         || softfloat_isSigNaNF128UI( uiB64, uiB0 )
     ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
     }
     uiZ.v64 = defaultNaNF128UI64;
Index: trunk/src/libs/softfloat-3e/source/ARM-VFPv2-defaultNaN/s_propagateNaNF16UI.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/ARM-VFPv2-defaultNaN/s_propagateNaNF16UI.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/ARM-VFPv2-defaultNaN/s_propagateNaNF16UI.c	(revision 94558)
@@ -47,9 +47,9 @@
 *----------------------------------------------------------------------------*/
 uint_fast16_t
- softfloat_propagateNaNF16UI( uint_fast16_t uiA, uint_fast16_t uiB )
+ softfloat_propagateNaNF16UI( uint_fast16_t uiA, uint_fast16_t uiB SOFTFLOAT_STATE_DECL_COMMA )
 {
 
     if ( softfloat_isSigNaNF16UI( uiA ) || softfloat_isSigNaNF16UI( uiB ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
     }
     return defaultNaNF16UI;
Index: trunk/src/libs/softfloat-3e/source/ARM-VFPv2-defaultNaN/s_propagateNaNF32UI.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/ARM-VFPv2-defaultNaN/s_propagateNaNF32UI.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/ARM-VFPv2-defaultNaN/s_propagateNaNF32UI.c	(revision 94558)
@@ -47,9 +47,9 @@
 *----------------------------------------------------------------------------*/
 uint_fast32_t
- softfloat_propagateNaNF32UI( uint_fast32_t uiA, uint_fast32_t uiB )
+ softfloat_propagateNaNF32UI( uint_fast32_t uiA, uint_fast32_t uiB SOFTFLOAT_STATE_DECL_COMMA )
 {
 
     if ( softfloat_isSigNaNF32UI( uiA ) || softfloat_isSigNaNF32UI( uiB ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
     }
     return defaultNaNF32UI;
Index: trunk/src/libs/softfloat-3e/source/ARM-VFPv2-defaultNaN/s_propagateNaNF64UI.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/ARM-VFPv2-defaultNaN/s_propagateNaNF64UI.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/ARM-VFPv2-defaultNaN/s_propagateNaNF64UI.c	(revision 94558)
@@ -47,9 +47,9 @@
 *----------------------------------------------------------------------------*/
 uint_fast64_t
- softfloat_propagateNaNF64UI( uint_fast64_t uiA, uint_fast64_t uiB )
+ softfloat_propagateNaNF64UI( uint_fast64_t uiA, uint_fast64_t uiB SOFTFLOAT_STATE_DECL_COMMA )
 {
 
     if ( softfloat_isSigNaNF64UI( uiA ) || softfloat_isSigNaNF64UI( uiB ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
     }
     return defaultNaNF64UI;
Index: trunk/src/libs/softfloat-3e/source/ARM-VFPv2-defaultNaN/softfloat_raiseFlags.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/ARM-VFPv2-defaultNaN/softfloat_raiseFlags.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/ARM-VFPv2-defaultNaN/softfloat_raiseFlags.c	(revision 94558)
@@ -44,8 +44,12 @@
 | should be simply 'softfloat_exceptionFlags |= flags;'.
 *----------------------------------------------------------------------------*/
-void softfloat_raiseFlags( uint_fast8_t flags )
+void softfloat_raiseFlags( uint_fast8_t flags SOFTFLOAT_STATE_ARG_COMMA )
 {
 
+#ifdef VBOX_WITHOUT_SOFTFLOAT_GLOBALS
     softfloat_exceptionFlags |= flags;
+#else
+    pState->exceptionFlags   |= flags;
+#endif
 
 }
Index: trunk/src/libs/softfloat-3e/source/ARM-VFPv2-defaultNaN/specialize.h
===================================================================
--- trunk/src/libs/softfloat-3e/source/ARM-VFPv2-defaultNaN/specialize.h	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/ARM-VFPv2-defaultNaN/specialize.h	(revision 94558)
@@ -94,5 +94,9 @@
 | exception is raised.
 *----------------------------------------------------------------------------*/
+#ifdef VBOX_WITHOUT_SOFTFLOAT_GLOBALS
 #define softfloat_f16UIToCommonNaN( uiA, zPtr ) if ( ! ((uiA) & 0x0200) ) softfloat_raiseFlags( softfloat_flag_invalid )
+#else
+# define softfloat_f16UIToCommonNaN( uiA, zPtr, pState ) if ( ! ((uiA) & 0x0200) ) softfloat_raiseFlags( softfloat_flag_invalid, pState )
+#endif
 
 /*----------------------------------------------------------------------------
@@ -109,5 +113,5 @@
 *----------------------------------------------------------------------------*/
 uint_fast16_t
- softfloat_propagateNaNF16UI( uint_fast16_t uiA, uint_fast16_t uiB );
+ softfloat_propagateNaNF16UI( uint_fast16_t uiA, uint_fast16_t uiB SOFTFLOAT_STATE_DECL_COMMA );
 
 /*----------------------------------------------------------------------------
@@ -129,5 +133,9 @@
 | exception is raised.
 *----------------------------------------------------------------------------*/
+#ifdef VBOX_WITHOUT_SOFTFLOAT_GLOBALS
 #define softfloat_f32UIToCommonNaN( uiA, zPtr ) if ( ! ((uiA) & 0x00400000) ) softfloat_raiseFlags( softfloat_flag_invalid )
+#else
+# define softfloat_f32UIToCommonNaN( uiA, zPtr, pState ) if ( ! ((uiA) & 0x00400000) ) softfloat_raiseFlags( softfloat_flag_invalid, pState )
+#endif
 
 /*----------------------------------------------------------------------------
@@ -144,5 +152,5 @@
 *----------------------------------------------------------------------------*/
 uint_fast32_t
- softfloat_propagateNaNF32UI( uint_fast32_t uiA, uint_fast32_t uiB );
+ softfloat_propagateNaNF32UI( uint_fast32_t uiA, uint_fast32_t uiB SOFTFLOAT_STATE_DECL_COMMA );
 
 /*----------------------------------------------------------------------------
@@ -164,5 +172,9 @@
 | exception is raised.
 *----------------------------------------------------------------------------*/
+#ifdef VBOX_WITHOUT_SOFTFLOAT_GLOBALS
 #define softfloat_f64UIToCommonNaN( uiA, zPtr ) if ( ! ((uiA) & UINT64_C( 0x0008000000000000 )) ) softfloat_raiseFlags( softfloat_flag_invalid )
+#else
+# define softfloat_f64UIToCommonNaN( uiA, zPtr, pState ) if ( ! ((uiA) & UINT64_C( 0x0008000000000000 )) ) softfloat_raiseFlags( softfloat_flag_invalid, pState )
+#endif
 
 /*----------------------------------------------------------------------------
@@ -179,5 +191,5 @@
 *----------------------------------------------------------------------------*/
 uint_fast64_t
- softfloat_propagateNaNF64UI( uint_fast64_t uiA, uint_fast64_t uiB );
+ softfloat_propagateNaNF64UI( uint_fast64_t uiA, uint_fast64_t uiB SOFTFLOAT_STATE_DECL_COMMA );
 
 /*----------------------------------------------------------------------------
@@ -209,5 +221,9 @@
 | exception is raised.
 *----------------------------------------------------------------------------*/
+#ifdef VBOX_WITHOUT_SOFTFLOAT_GLOBALS
 #define softfloat_extF80UIToCommonNaN( uiA64, uiA0, zPtr ) if ( ! ((uiA0) & UINT64_C( 0x4000000000000000 )) ) softfloat_raiseFlags( softfloat_flag_invalid )
+#else
+# define softfloat_extF80UIToCommonNaN( uiA64, uiA0, zPtr, pState ) if ( ! ((uiA0) & UINT64_C( 0x4000000000000000 )) ) softfloat_raiseFlags( softfloat_flag_invalid, pState )
+#endif
 
 /*----------------------------------------------------------------------------
@@ -244,4 +260,5 @@
      uint_fast16_t uiB64,
      uint_fast64_t uiB0
+     SOFTFLOAT_STATE_DECL_COMMA
  );
 
@@ -267,5 +284,9 @@
 | is raised.
 *----------------------------------------------------------------------------*/
+#ifdef VBOX_WITHOUT_SOFTFLOAT_GLOBALS
 #define softfloat_f128UIToCommonNaN( uiA64, uiA0, zPtr ) if ( ! ((uiA64) & UINT64_C( 0x0000800000000000 )) ) softfloat_raiseFlags( softfloat_flag_invalid )
+#else
+# define softfloat_f128UIToCommonNaN( uiA64, uiA0, zPtr, pState ) if ( ! ((uiA64) & UINT64_C( 0x0000800000000000 )) ) softfloat_raiseFlags( softfloat_flag_invalid, pState)
+#endif
 
 /*----------------------------------------------------------------------------
@@ -301,4 +322,5 @@
      uint_fast64_t uiB64,
      uint_fast64_t uiB0
+     SOFTFLOAT_STATE_DECL_COMMA
  );
 
@@ -316,5 +338,9 @@
 | NaN, the invalid exception is raised.
 *----------------------------------------------------------------------------*/
+#ifdef VBOX_WITHOUT_SOFTFLOAT_GLOBALS
 #define softfloat_extF80MToCommonNaN( aSPtr, zPtr ) if ( ! ((aSPtr)->signif & UINT64_C( 0x4000000000000000 )) ) softfloat_raiseFlags( softfloat_flag_invalid )
+#else
+# define softfloat_extF80MToCommonNaN( aSPtr, zPtr, pState ) if ( ! ((aSPtr)->signif & UINT64_C( 0x4000000000000000 )) ) softfloat_raiseFlags( softfloat_flag_invalid, pState )
+#endif
 
 /*----------------------------------------------------------------------------
@@ -349,4 +375,5 @@
      const struct extFloat80M *bSPtr,
      struct extFloat80M *zSPtr
+     SOFTFLOAT_STATE_DECL_COMMA
  );
 
@@ -367,5 +394,9 @@
 | to form a 128-bit floating-point value.
 *----------------------------------------------------------------------------*/
+#ifdef VBOX_WITHOUT_SOFTFLOAT_GLOBALS
 #define softfloat_f128MToCommonNaN( aWPtr, zPtr ) if ( ! ((aWPtr)[indexWordHi( 4 )] & UINT64_C( 0x0000800000000000 )) ) softfloat_raiseFlags( softfloat_flag_invalid )
+#else
+# define softfloat_f128MToCommonNaN( aWPtr, zPtr ) if ( ! ((aWPtr)[indexWordHi( 4 )] & UINT64_C( 0x0000800000000000 )) ) softfloat_raiseFlags( softfloat_flag_invalid, pState )
+#endif
 
 /*----------------------------------------------------------------------------
@@ -400,8 +431,8 @@
 void
  softfloat_propagateNaNF128M(
-     const uint32_t *aWPtr, const uint32_t *bWPtr, uint32_t *zWPtr );
-
-#endif
-
-#endif
-
+     const uint32_t *aWPtr, const uint32_t *bWPtr, uint32_t *zWPtr SOFTFLOAT_STATE_DECL_COMMA );
+
+#endif
+
+#endif
+
Index: trunk/src/libs/softfloat-3e/source/ARM-VFPv2/s_extF80MToCommonNaN.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/ARM-VFPv2/s_extF80MToCommonNaN.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/ARM-VFPv2/s_extF80MToCommonNaN.c	(revision 94558)
@@ -49,9 +49,9 @@
 void
  softfloat_extF80MToCommonNaN(
-     const struct extFloat80M *aSPtr, struct commonNaN *zPtr )
+     const struct extFloat80M *aSPtr, struct commonNaN *zPtr SOFTFLOAT_STATE_DECL_COMMA )
 {
 
     if ( extF80M_isSignalingNaN( (const extFloat80_t *) aSPtr ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
     }
     zPtr->sign = signExtF80UI64( aSPtr->signExp );
Index: trunk/src/libs/softfloat-3e/source/ARM-VFPv2/s_extF80UIToCommonNaN.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/ARM-VFPv2/s_extF80UIToCommonNaN.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/ARM-VFPv2/s_extF80UIToCommonNaN.c	(revision 94558)
@@ -49,9 +49,9 @@
 void
  softfloat_extF80UIToCommonNaN(
-     uint_fast16_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr )
+     uint_fast16_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr SOFTFLOAT_STATE_DECL_COMMA )
 {
 
     if ( softfloat_isSigNaNExtF80UI( uiA64, uiA0 ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
     }
     zPtr->sign = uiA64>>15;
Index: trunk/src/libs/softfloat-3e/source/ARM-VFPv2/s_f128MToCommonNaN.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/ARM-VFPv2/s_f128MToCommonNaN.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/ARM-VFPv2/s_f128MToCommonNaN.c	(revision 94558)
@@ -50,9 +50,9 @@
 *----------------------------------------------------------------------------*/
 void
- softfloat_f128MToCommonNaN( const uint32_t *aWPtr, struct commonNaN *zPtr )
+ softfloat_f128MToCommonNaN( const uint32_t *aWPtr, struct commonNaN *zPtr SOFTFLOAT_STATE_DECL_COMMA )
 {
 
     if ( f128M_isSignalingNaN( (const float128_t *) aWPtr ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
     }
     zPtr->sign = aWPtr[indexWordHi( 4 )]>>31;
Index: trunk/src/libs/softfloat-3e/source/ARM-VFPv2/s_f128UIToCommonNaN.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/ARM-VFPv2/s_f128UIToCommonNaN.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/ARM-VFPv2/s_f128UIToCommonNaN.c	(revision 94558)
@@ -50,10 +50,10 @@
 void
  softfloat_f128UIToCommonNaN(
-     uint_fast64_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr )
+     uint_fast64_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr SOFTFLOAT_STATE_DECL_COMMA )
 {
     struct uint128 NaNSig;
 
     if ( softfloat_isSigNaNF128UI( uiA64, uiA0 ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
     }
     NaNSig = softfloat_shortShiftLeft128( uiA64, uiA0, 16 );
Index: trunk/src/libs/softfloat-3e/source/ARM-VFPv2/s_f16UIToCommonNaN.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/ARM-VFPv2/s_f16UIToCommonNaN.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/ARM-VFPv2/s_f16UIToCommonNaN.c	(revision 94558)
@@ -46,9 +46,9 @@
 | exception is raised.
 *----------------------------------------------------------------------------*/
-void softfloat_f16UIToCommonNaN( uint_fast16_t uiA, struct commonNaN *zPtr )
+void softfloat_f16UIToCommonNaN( uint_fast16_t uiA, struct commonNaN *zPtr SOFTFLOAT_STATE_DECL_COMMA )
 {
 
     if ( softfloat_isSigNaNF16UI( uiA ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
     }
     zPtr->sign = uiA>>15;
Index: trunk/src/libs/softfloat-3e/source/ARM-VFPv2/s_f32UIToCommonNaN.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/ARM-VFPv2/s_f32UIToCommonNaN.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/ARM-VFPv2/s_f32UIToCommonNaN.c	(revision 94558)
@@ -46,9 +46,9 @@
 | exception is raised.
 *----------------------------------------------------------------------------*/
-void softfloat_f32UIToCommonNaN( uint_fast32_t uiA, struct commonNaN *zPtr )
+void softfloat_f32UIToCommonNaN( uint_fast32_t uiA, struct commonNaN *zPtr SOFTFLOAT_STATE_DECL_COMMA )
 {
 
     if ( softfloat_isSigNaNF32UI( uiA ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
     }
     zPtr->sign = uiA>>31;
Index: trunk/src/libs/softfloat-3e/source/ARM-VFPv2/s_f64UIToCommonNaN.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/ARM-VFPv2/s_f64UIToCommonNaN.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/ARM-VFPv2/s_f64UIToCommonNaN.c	(revision 94558)
@@ -46,9 +46,9 @@
 | exception is raised.
 *----------------------------------------------------------------------------*/
-void softfloat_f64UIToCommonNaN( uint_fast64_t uiA, struct commonNaN *zPtr )
+void softfloat_f64UIToCommonNaN( uint_fast64_t uiA, struct commonNaN *zPtr SOFTFLOAT_STATE_DECL_COMMA )
 {
 
     if ( softfloat_isSigNaNF64UI( uiA ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
     }
     zPtr->sign = uiA>>63;
Index: trunk/src/libs/softfloat-3e/source/ARM-VFPv2/s_propagateNaNExtF80M.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/ARM-VFPv2/s_propagateNaNExtF80M.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/ARM-VFPv2/s_propagateNaNExtF80M.c	(revision 94558)
@@ -53,4 +53,5 @@
      const struct extFloat80M *bSPtr,
      struct extFloat80M *zSPtr
+     SOFTFLOAT_STATE_DECL_COMMA
  )
 {
@@ -67,5 +68,5 @@
                     && extF80M_isSignalingNaN( (const extFloat80_t *) bSPtr ))
     ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
         if ( isSigNaNA ) goto copyNonsig;
         goto copyNonsigB;
Index: trunk/src/libs/softfloat-3e/source/ARM-VFPv2/s_propagateNaNExtF80UI.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/ARM-VFPv2/s_propagateNaNExtF80UI.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/ARM-VFPv2/s_propagateNaNExtF80UI.c	(revision 94558)
@@ -57,4 +57,5 @@
      uint_fast16_t uiB64,
      uint_fast64_t uiB0
+     SOFTFLOAT_STATE_DECL_COMMA
  )
 {
@@ -64,5 +65,5 @@
     isSigNaNA = softfloat_isSigNaNExtF80UI( uiA64, uiA0 );
     if ( isSigNaNA || softfloat_isSigNaNExtF80UI( uiB64, uiB0 ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
         if ( isSigNaNA ) goto returnNonsigA;
         goto returnNonsigB;
Index: trunk/src/libs/softfloat-3e/source/ARM-VFPv2/s_propagateNaNF128M.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/ARM-VFPv2/s_propagateNaNF128M.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/ARM-VFPv2/s_propagateNaNF128M.c	(revision 94558)
@@ -52,5 +52,5 @@
 void
  softfloat_propagateNaNF128M(
-     const uint32_t *aWPtr, const uint32_t *bWPtr, uint32_t *zWPtr )
+     const uint32_t *aWPtr, const uint32_t *bWPtr, uint32_t *zWPtr SOFTFLOAT_STATE_DECL_COMMA )
 {
     const uint32_t *ptr;
@@ -63,5 +63,5 @@
             || (bWPtr && f128M_isSignalingNaN( (const float128_t *) bWPtr ))
     ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
         if ( ! isSigNaNA ) ptr = bWPtr;
         goto copyNonsig;
Index: trunk/src/libs/softfloat-3e/source/ARM-VFPv2/s_propagateNaNF128UI.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/ARM-VFPv2/s_propagateNaNF128UI.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/ARM-VFPv2/s_propagateNaNF128UI.c	(revision 94558)
@@ -57,4 +57,5 @@
      uint_fast64_t uiB64,
      uint_fast64_t uiB0
+     SOFTFLOAT_STATE_DECL_COMMA
  )
 {
@@ -64,5 +65,5 @@
     isSigNaNA = softfloat_isSigNaNF128UI( uiA64, uiA0 );
     if ( isSigNaNA || softfloat_isSigNaNF128UI( uiB64, uiB0 ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
         if ( isSigNaNA ) goto returnNonsigA;
         goto returnNonsigB;
Index: trunk/src/libs/softfloat-3e/source/ARM-VFPv2/s_propagateNaNF16UI.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/ARM-VFPv2/s_propagateNaNF16UI.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/ARM-VFPv2/s_propagateNaNF16UI.c	(revision 94558)
@@ -49,5 +49,5 @@
 *----------------------------------------------------------------------------*/
 uint_fast16_t
- softfloat_propagateNaNF16UI( uint_fast16_t uiA, uint_fast16_t uiB )
+ softfloat_propagateNaNF16UI( uint_fast16_t uiA, uint_fast16_t uiB SOFTFLOAT_STATE_DECL_COMMA )
 {
     bool isSigNaNA;
@@ -55,5 +55,5 @@
     isSigNaNA = softfloat_isSigNaNF16UI( uiA );
     if ( isSigNaNA || softfloat_isSigNaNF16UI( uiB ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
         return (isSigNaNA ? uiA : uiB) | 0x0200;
     }
Index: trunk/src/libs/softfloat-3e/source/ARM-VFPv2/s_propagateNaNF32UI.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/ARM-VFPv2/s_propagateNaNF32UI.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/ARM-VFPv2/s_propagateNaNF32UI.c	(revision 94558)
@@ -49,5 +49,5 @@
 *----------------------------------------------------------------------------*/
 uint_fast32_t
- softfloat_propagateNaNF32UI( uint_fast32_t uiA, uint_fast32_t uiB )
+ softfloat_propagateNaNF32UI( uint_fast32_t uiA, uint_fast32_t uiB SOFTFLOAT_STATE_DECL_COMMA )
 {
     bool isSigNaNA;
@@ -55,5 +55,5 @@
     isSigNaNA = softfloat_isSigNaNF32UI( uiA );
     if ( isSigNaNA || softfloat_isSigNaNF32UI( uiB ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
         return (isSigNaNA ? uiA : uiB) | 0x00400000;
     }
Index: trunk/src/libs/softfloat-3e/source/ARM-VFPv2/s_propagateNaNF64UI.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/ARM-VFPv2/s_propagateNaNF64UI.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/ARM-VFPv2/s_propagateNaNF64UI.c	(revision 94558)
@@ -49,5 +49,5 @@
 *----------------------------------------------------------------------------*/
 uint_fast64_t
- softfloat_propagateNaNF64UI( uint_fast64_t uiA, uint_fast64_t uiB )
+ softfloat_propagateNaNF64UI( uint_fast64_t uiA, uint_fast64_t uiB SOFTFLOAT_STATE_DECL_COMMA )
 {
     bool isSigNaNA;
@@ -55,5 +55,5 @@
     isSigNaNA = softfloat_isSigNaNF64UI( uiA );
     if ( isSigNaNA || softfloat_isSigNaNF64UI( uiB ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
         return (isSigNaNA ? uiA : uiB) | UINT64_C( 0x0008000000000000 );
     }
Index: trunk/src/libs/softfloat-3e/source/ARM-VFPv2/softfloat_raiseFlags.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/ARM-VFPv2/softfloat_raiseFlags.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/ARM-VFPv2/softfloat_raiseFlags.c	(revision 94558)
@@ -44,8 +44,12 @@
 | should be simply 'softfloat_exceptionFlags |= flags;'.
 *----------------------------------------------------------------------------*/
-void softfloat_raiseFlags( uint_fast8_t flags )
+void softfloat_raiseFlags( uint_fast8_t flags SOFTFLOAT_STATE_ARG_COMMA )
 {
 
+#ifdef VBOX_WITHOUT_SOFTFLOAT_GLOBALS
     softfloat_exceptionFlags |= flags;
+#else
+    pState->exceptionFlags   |= flags;
+#endif
 
 }
Index: trunk/src/libs/softfloat-3e/source/ARM-VFPv2/specialize.h
===================================================================
--- trunk/src/libs/softfloat-3e/source/ARM-VFPv2/specialize.h	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/ARM-VFPv2/specialize.h	(revision 94558)
@@ -101,5 +101,5 @@
 | exception is raised.
 *----------------------------------------------------------------------------*/
-void softfloat_f16UIToCommonNaN( uint_fast16_t uiA, struct commonNaN *zPtr );
+void softfloat_f16UIToCommonNaN( uint_fast16_t uiA, struct commonNaN *zPtr SOFTFLOAT_STATE_DECL_COMMA );
 
 /*----------------------------------------------------------------------------
@@ -116,5 +116,5 @@
 *----------------------------------------------------------------------------*/
 uint_fast16_t
- softfloat_propagateNaNF16UI( uint_fast16_t uiA, uint_fast16_t uiB );
+ softfloat_propagateNaNF16UI( uint_fast16_t uiA, uint_fast16_t uiB SOFTFLOAT_STATE_DECL_COMMA );
 
 /*----------------------------------------------------------------------------
@@ -136,5 +136,5 @@
 | exception is raised.
 *----------------------------------------------------------------------------*/
-void softfloat_f32UIToCommonNaN( uint_fast32_t uiA, struct commonNaN *zPtr );
+void softfloat_f32UIToCommonNaN( uint_fast32_t uiA, struct commonNaN *zPtr SOFTFLOAT_STATE_DECL_COMMA );
 
 /*----------------------------------------------------------------------------
@@ -151,5 +151,5 @@
 *----------------------------------------------------------------------------*/
 uint_fast32_t
- softfloat_propagateNaNF32UI( uint_fast32_t uiA, uint_fast32_t uiB );
+ softfloat_propagateNaNF32UI( uint_fast32_t uiA, uint_fast32_t uiB SOFTFLOAT_STATE_DECL_COMMA );
 
 /*----------------------------------------------------------------------------
@@ -171,5 +171,5 @@
 | exception is raised.
 *----------------------------------------------------------------------------*/
-void softfloat_f64UIToCommonNaN( uint_fast64_t uiA, struct commonNaN *zPtr );
+void softfloat_f64UIToCommonNaN( uint_fast64_t uiA, struct commonNaN *zPtr SOFTFLOAT_STATE_DECL_COMMA );
 
 /*----------------------------------------------------------------------------
@@ -186,5 +186,5 @@
 *----------------------------------------------------------------------------*/
 uint_fast64_t
- softfloat_propagateNaNF64UI( uint_fast64_t uiA, uint_fast64_t uiB );
+ softfloat_propagateNaNF64UI( uint_fast64_t uiA, uint_fast64_t uiB SOFTFLOAT_STATE_DECL_COMMA );
 
 /*----------------------------------------------------------------------------
@@ -218,5 +218,5 @@
 void
  softfloat_extF80UIToCommonNaN(
-     uint_fast16_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr );
+     uint_fast16_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr SOFTFLOAT_STATE_DECL_COMMA );
 
 /*----------------------------------------------------------------------------
@@ -242,4 +242,5 @@
      uint_fast16_t uiB64,
      uint_fast64_t uiB0
+     SOFTFLOAT_STATE_DECL_COMMA
  );
 
@@ -267,5 +268,5 @@
 void
  softfloat_f128UIToCommonNaN(
-     uint_fast64_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr );
+     uint_fast64_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr SOFTFLOAT_STATE_DECL_COMMA );
 
 /*----------------------------------------------------------------------------
@@ -290,4 +291,5 @@
      uint_fast64_t uiB64,
      uint_fast64_t uiB0
+     SOFTFLOAT_STATE_DECL_COMMA
  );
 
@@ -307,5 +309,5 @@
 void
  softfloat_extF80MToCommonNaN(
-     const struct extFloat80M *aSPtr, struct commonNaN *zPtr );
+     const struct extFloat80M *aSPtr, struct commonNaN *zPtr SOFTFLOAT_STATE_DECL_COMMA );
 
 /*----------------------------------------------------------------------------
@@ -329,4 +331,5 @@
      const struct extFloat80M *bSPtr,
      struct extFloat80M *zSPtr
+     SOFTFLOAT_STATE_DECL_COMMA
  );
 
@@ -348,5 +351,5 @@
 *----------------------------------------------------------------------------*/
 void
- softfloat_f128MToCommonNaN( const uint32_t *aWPtr, struct commonNaN *zPtr );
+ softfloat_f128MToCommonNaN( const uint32_t *aWPtr, struct commonNaN *zPtr SOFTFLOAT_STATE_DECL_COMMA );
 
 /*----------------------------------------------------------------------------
@@ -369,5 +372,5 @@
 void
  softfloat_propagateNaNF128M(
-     const uint32_t *aWPtr, const uint32_t *bWPtr, uint32_t *zWPtr );
+     const uint32_t *aWPtr, const uint32_t *bWPtr, uint32_t *zWPtr SOFTFLOAT_STATE_DECL_COMMA );
 
 #endif
Index: trunk/src/libs/softfloat-3e/source/extF80M_add.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/extF80M_add.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/extF80M_add.c	(revision 94558)
@@ -44,5 +44,5 @@
 void
  extF80M_add(
-     const extFloat80_t *aPtr, const extFloat80_t *bPtr, extFloat80_t *zPtr )
+     const extFloat80_t *aPtr, const extFloat80_t *bPtr, extFloat80_t *zPtr SOFTFLOAT_STATE_DECL_COMMA )
 {
     const struct extFloat80M *aSPtr, *bSPtr;
@@ -56,5 +56,5 @@
     extFloat80_t
         (*magsFuncPtr)(
-            uint_fast16_t, uint_fast64_t, uint_fast16_t, uint_fast64_t, bool );
+            uint_fast16_t, uint_fast64_t, uint_fast16_t, uint_fast64_t, bool SOFTFLOAT_STATE_DECL_COMMA );
 #endif
 
@@ -69,12 +69,12 @@
 #if defined INLINE_LEVEL && (2 <= INLINE_LEVEL)
     if ( signA == signB ) {
-        *zPtr = softfloat_addMagsExtF80( uiA64, uiA0, uiB64, uiB0, signA );
+        *zPtr = softfloat_addMagsExtF80( uiA64, uiA0, uiB64, uiB0, signA SOFTFLOAT_STATE_ARG_COMMA );
     } else {
-        *zPtr = softfloat_subMagsExtF80( uiA64, uiA0, uiB64, uiB0, signA );
+        *zPtr = softfloat_subMagsExtF80( uiA64, uiA0, uiB64, uiB0, signA SOFTFLOAT_STATE_ARG_COMMA );
     }
 #else
     magsFuncPtr =
         (signA == signB) ? softfloat_addMagsExtF80 : softfloat_subMagsExtF80;
-    *zPtr = (*magsFuncPtr)( uiA64, uiA0, uiB64, uiB0, signA );
+    *zPtr = (*magsFuncPtr)( uiA64, uiA0, uiB64, uiB0, signA SOFTFLOAT_STATE_ARG_COMMA );
 #endif
 
@@ -85,5 +85,5 @@
 void
  extF80M_add(
-     const extFloat80_t *aPtr, const extFloat80_t *bPtr, extFloat80_t *zPtr )
+     const extFloat80_t *aPtr, const extFloat80_t *bPtr, extFloat80_t *zPtr SOFTFLOAT_STATE_DECL_COMMA )
 {
 
@@ -93,4 +93,5 @@
         (struct extFloat80M *) zPtr,
         false
+        SOFTFLOAT_STATE_ARG_COMMA
     );
 
Index: trunk/src/libs/softfloat-3e/source/extF80M_div.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/extF80M_div.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/extF80M_div.c	(revision 94558)
@@ -46,8 +46,8 @@
 void
  extF80M_div(
-     const extFloat80_t *aPtr, const extFloat80_t *bPtr, extFloat80_t *zPtr )
+     const extFloat80_t *aPtr, const extFloat80_t *bPtr, extFloat80_t *zPtr SOFTFLOAT_STATE_DECL_COMMA )
 {
 
-    *zPtr = extF80_div( *aPtr, *bPtr );
+    *zPtr = extF80_div( *aPtr, *bPtr SOFTFLOAT_STATE_ARG_COMMA );
 
 }
@@ -57,5 +57,5 @@
 void
  extF80M_div(
-     const extFloat80_t *aPtr, const extFloat80_t *bPtr, extFloat80_t *zPtr )
+     const extFloat80_t *aPtr, const extFloat80_t *bPtr, extFloat80_t *zPtr SOFTFLOAT_STATE_DECL_COMMA )
 {
     const struct extFloat80M *aSPtr, *bSPtr;
@@ -90,5 +90,5 @@
     *------------------------------------------------------------------------*/
     if ( (expA == 0x7FFF) || (expB == 0x7FFF) ) {
-        if ( softfloat_tryPropagateNaNExtF80M( aSPtr, bSPtr, zSPtr ) ) return;
+        if ( softfloat_tryPropagateNaNExtF80M( aSPtr, bSPtr, zSPtr SOFTFLOAT_STATE_ARG_COMMA ) ) return;
         if ( expA == 0x7FFF ) {
             if ( expB == 0x7FFF ) goto invalid;
@@ -105,5 +105,5 @@
         if ( ! x64 ) {
             if ( ! sigA ) goto invalid;
-            softfloat_raiseFlags( softfloat_flag_infinite );
+            softfloat_raiseFlags( softfloat_flag_infinite SOFTFLOAT_STATE_ARG_COMMA );
             goto infinity;
         }
@@ -167,10 +167,10 @@
     y[indexWord( 3, 2 )] = (qs[1]<<3) + (x64>>32);
     softfloat_roundPackMToExtF80M(
-        signZ, expZ, y, extF80_roundingPrecision, zSPtr );
+        signZ, expZ, y, extF80_roundingPrecision, zSPtr SOFTFLOAT_STATE_ARG_COMMA );
     return;
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  invalid:
-    softfloat_invalidExtF80M( zSPtr );
+    softfloat_invalidExtF80M( zSPtr SOFTFLOAT_STATE_ARG_COMMA );
     return;
     /*------------------------------------------------------------------------
Index: trunk/src/libs/softfloat-3e/source/extF80M_eq.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/extF80M_eq.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/extF80M_eq.c	(revision 94558)
@@ -44,8 +44,8 @@
 #ifdef SOFTFLOAT_FAST_INT64
 
-bool extF80M_eq( const extFloat80_t *aPtr, const extFloat80_t *bPtr )
+bool extF80M_eq( const extFloat80_t *aPtr, const extFloat80_t *bPtr SOFTFLOAT_STATE_DECL_COMMA )
 {
 
-    return extF80_eq( *aPtr, *bPtr );
+    return extF80_eq( *aPtr, *bPtr SOFTFLOAT_STATE_ARG_COMMA );
 
 }
@@ -53,5 +53,5 @@
 #else
 
-bool extF80M_eq( const extFloat80_t *aPtr, const extFloat80_t *bPtr )
+bool extF80M_eq( const extFloat80_t *aPtr, const extFloat80_t *bPtr SOFTFLOAT_STATE_DECL_COMMA )
 {
     const struct extFloat80M *aSPtr, *bSPtr;
@@ -78,5 +78,5 @@
             || softfloat_isSigNaNExtF80UI( uiB64, uiB0 )
         ) {
-            softfloat_raiseFlags( softfloat_flag_invalid );
+            softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
         }
         return false;
Index: trunk/src/libs/softfloat-3e/source/extF80M_eq_signaling.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/extF80M_eq_signaling.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/extF80M_eq_signaling.c	(revision 94558)
@@ -43,8 +43,8 @@
 #ifdef SOFTFLOAT_FAST_INT64
 
-bool extF80M_eq_signaling( const extFloat80_t *aPtr, const extFloat80_t *bPtr )
+bool extF80M_eq_signaling( const extFloat80_t *aPtr, const extFloat80_t *bPtr SOFTFLOAT_STATE_DECL_COMMA )
 {
 
-    return extF80_eq_signaling( *aPtr, *bPtr );
+    return extF80_eq_signaling( *aPtr, *bPtr SOFTFLOAT_STATE_ARG_COMMA );
 
 }
@@ -52,5 +52,5 @@
 #else
 
-bool extF80M_eq_signaling( const extFloat80_t *aPtr, const extFloat80_t *bPtr )
+bool extF80M_eq_signaling( const extFloat80_t *aPtr, const extFloat80_t *bPtr SOFTFLOAT_STATE_DECL_COMMA )
 {
     const struct extFloat80M *aSPtr, *bSPtr;
@@ -73,5 +73,5 @@
     *------------------------------------------------------------------------*/
     if ( isNaNExtF80UI( uiA64, uiA0 ) || isNaNExtF80UI( uiB64, uiB0 ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
         return false;
     }
Index: trunk/src/libs/softfloat-3e/source/extF80M_le.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/extF80M_le.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/extF80M_le.c	(revision 94558)
@@ -43,8 +43,8 @@
 #ifdef SOFTFLOAT_FAST_INT64
 
-bool extF80M_le( const extFloat80_t *aPtr, const extFloat80_t *bPtr )
+bool extF80M_le( const extFloat80_t *aPtr, const extFloat80_t *bPtr SOFTFLOAT_STATE_DECL_COMMA )
 {
 
-    return extF80_le( *aPtr, *bPtr );
+    return extF80_le( *aPtr, *bPtr SOFTFLOAT_STATE_ARG_COMMA );
 
 }
@@ -52,5 +52,5 @@
 #else
 
-bool extF80M_le( const extFloat80_t *aPtr, const extFloat80_t *bPtr )
+bool extF80M_le( const extFloat80_t *aPtr, const extFloat80_t *bPtr SOFTFLOAT_STATE_DECL_COMMA )
 {
     const struct extFloat80M *aSPtr, *bSPtr;
@@ -74,5 +74,5 @@
     *------------------------------------------------------------------------*/
     if ( isNaNExtF80UI( uiA64, uiA0 ) || isNaNExtF80UI( uiB64, uiB0 ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
         return false;
     }
Index: trunk/src/libs/softfloat-3e/source/extF80M_le_quiet.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/extF80M_le_quiet.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/extF80M_le_quiet.c	(revision 94558)
@@ -44,8 +44,8 @@
 #ifdef SOFTFLOAT_FAST_INT64
 
-bool extF80M_le_quiet( const extFloat80_t *aPtr, const extFloat80_t *bPtr )
+bool extF80M_le_quiet( const extFloat80_t *aPtr, const extFloat80_t *bPtr SOFTFLOAT_STATE_DECL_COMMA )
 {
 
-    return extF80_le_quiet( *aPtr, *bPtr );
+    return extF80_le_quiet( *aPtr, *bPtr SOFTFLOAT_STATE_ARG_COMMA );
 
 }
@@ -53,5 +53,5 @@
 #else
 
-bool extF80M_le_quiet( const extFloat80_t *aPtr, const extFloat80_t *bPtr )
+bool extF80M_le_quiet( const extFloat80_t *aPtr, const extFloat80_t *bPtr SOFTFLOAT_STATE_DECL_COMMA )
 {
     const struct extFloat80M *aSPtr, *bSPtr;
@@ -79,5 +79,5 @@
             || softfloat_isSigNaNExtF80UI( uiB64, uiB0 )
         ) {
-            softfloat_raiseFlags( softfloat_flag_invalid );
+            softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
         }
         return false;
Index: trunk/src/libs/softfloat-3e/source/extF80M_lt.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/extF80M_lt.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/extF80M_lt.c	(revision 94558)
@@ -43,8 +43,8 @@
 #ifdef SOFTFLOAT_FAST_INT64
 
-bool extF80M_lt( const extFloat80_t *aPtr, const extFloat80_t *bPtr )
+bool extF80M_lt( const extFloat80_t *aPtr, const extFloat80_t *bPtr SOFTFLOAT_STATE_DECL_COMMA )
 {
 
-    return extF80_lt( *aPtr, *bPtr );
+    return extF80_lt( *aPtr, *bPtr SOFTFLOAT_STATE_ARG_COMMA );
 
 }
@@ -52,5 +52,5 @@
 #else
 
-bool extF80M_lt( const extFloat80_t *aPtr, const extFloat80_t *bPtr )
+bool extF80M_lt( const extFloat80_t *aPtr, const extFloat80_t *bPtr SOFTFLOAT_STATE_DECL_COMMA )
 {
     const struct extFloat80M *aSPtr, *bSPtr;
@@ -74,5 +74,5 @@
     *------------------------------------------------------------------------*/
     if ( isNaNExtF80UI( uiA64, uiA0 ) || isNaNExtF80UI( uiB64, uiB0 ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
         return false;
     }
Index: trunk/src/libs/softfloat-3e/source/extF80M_lt_quiet.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/extF80M_lt_quiet.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/extF80M_lt_quiet.c	(revision 94558)
@@ -44,8 +44,8 @@
 #ifdef SOFTFLOAT_FAST_INT64
 
-bool extF80M_lt_quiet( const extFloat80_t *aPtr, const extFloat80_t *bPtr )
+bool extF80M_lt_quiet( const extFloat80_t *aPtr, const extFloat80_t *bPtr SOFTFLOAT_STATE_DECL_COMMA )
 {
 
-    return extF80_lt_quiet( *aPtr, *bPtr );
+    return extF80_lt_quiet( *aPtr, *bPtr SOFTFLOAT_STATE_ARG_COMMA );
 
 }
@@ -53,5 +53,5 @@
 #else
 
-bool extF80M_lt_quiet( const extFloat80_t *aPtr, const extFloat80_t *bPtr )
+bool extF80M_lt_quiet( const extFloat80_t *aPtr, const extFloat80_t *bPtr SOFTFLOAT_STATE_DECL_COMMA )
 {
     const struct extFloat80M *aSPtr, *bSPtr;
@@ -79,5 +79,5 @@
             || softfloat_isSigNaNExtF80UI( uiB64, uiB0 )
         ) {
-            softfloat_raiseFlags( softfloat_flag_invalid );
+            softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
         }
         return false;
Index: trunk/src/libs/softfloat-3e/source/extF80M_mul.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/extF80M_mul.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/extF80M_mul.c	(revision 94558)
@@ -46,8 +46,8 @@
 void
  extF80M_mul(
-     const extFloat80_t *aPtr, const extFloat80_t *bPtr, extFloat80_t *zPtr )
+     const extFloat80_t *aPtr, const extFloat80_t *bPtr, extFloat80_t *zPtr SOFTFLOAT_STATE_DECL_COMMA )
 {
 
-    *zPtr = extF80_mul( *aPtr, *bPtr );
+    *zPtr = extF80_mul( *aPtr, *bPtr SOFTFLOAT_STATE_ARG_COMMA );
 
 }
@@ -57,5 +57,5 @@
 void
  extF80M_mul(
-     const extFloat80_t *aPtr, const extFloat80_t *bPtr, extFloat80_t *zPtr )
+     const extFloat80_t *aPtr, const extFloat80_t *bPtr, extFloat80_t *zPtr SOFTFLOAT_STATE_DECL_COMMA )
 {
     const struct extFloat80M *aSPtr, *bSPtr;
@@ -86,10 +86,10 @@
     *------------------------------------------------------------------------*/
     if ( (expA == 0x7FFF) || (expB == 0x7FFF) ) {
-        if ( softfloat_tryPropagateNaNExtF80M( aSPtr, bSPtr, zSPtr ) ) return;
+        if ( softfloat_tryPropagateNaNExtF80M( aSPtr, bSPtr, zSPtr SOFTFLOAT_STATE_ARG_COMMA ) ) return;
         if (
                (! aSPtr->signif && (expA != 0x7FFF))
             || (! bSPtr->signif && (expB != 0x7FFF))
         ) {
-            softfloat_invalidExtF80M( zSPtr );
+            softfloat_invalidExtF80M( zSPtr SOFTFLOAT_STATE_ARG_COMMA );
             return;
         }
@@ -123,5 +123,5 @@
     }
     softfloat_roundPackMToExtF80M(
-        signZ, expZ, extSigZPtr, extF80_roundingPrecision, zSPtr );
+        signZ, expZ, extSigZPtr, extF80_roundingPrecision, zSPtr SOFTFLOAT_STATE_ARG_COMMA );
     return;
     /*------------------------------------------------------------------------
Index: trunk/src/libs/softfloat-3e/source/extF80M_rem.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/extF80M_rem.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/extF80M_rem.c	(revision 94558)
@@ -46,8 +46,8 @@
 void
  extF80M_rem(
-     const extFloat80_t *aPtr, const extFloat80_t *bPtr, extFloat80_t *zPtr )
+     const extFloat80_t *aPtr, const extFloat80_t *bPtr, extFloat80_t *zPtr SOFTFLOAT_STATE_DECL_COMMA )
 {
 
-    *zPtr = extF80_rem( *aPtr, *bPtr );
+    *zPtr = extF80_rem( *aPtr, *bPtr SOFTFLOAT_STATE_ARG_COMMA );
 
 }
@@ -57,5 +57,5 @@
 void
  extF80M_rem(
-     const extFloat80_t *aPtr, const extFloat80_t *bPtr, extFloat80_t *zPtr )
+     const extFloat80_t *aPtr, const extFloat80_t *bPtr, extFloat80_t *zPtr SOFTFLOAT_STATE_DECL_COMMA )
 {
     const struct extFloat80M *aSPtr, *bSPtr;
@@ -83,5 +83,5 @@
     *------------------------------------------------------------------------*/
     if ( (expA == 0x7FFF) || (expB == 0x7FFF) ) {
-        if ( softfloat_tryPropagateNaNExtF80M( aSPtr, bSPtr, zSPtr ) ) return;
+        if ( softfloat_tryPropagateNaNExtF80M( aSPtr, bSPtr, zSPtr SOFTFLOAT_STATE_ARG_COMMA ) ) return;
         if ( expA == 0x7FFF ) goto invalid;
         /*--------------------------------------------------------------------
@@ -182,10 +182,10 @@
         softfloat_negX96M( remPtr );
     }
-    softfloat_normRoundPackMToExtF80M( signRem, expB + 2, remPtr, 80, zSPtr );
+    softfloat_normRoundPackMToExtF80M( signRem, expB + 2, remPtr, 80, zSPtr SOFTFLOAT_STATE_ARG_COMMA );
     return;
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  invalid:
-    softfloat_invalidExtF80M( zSPtr );
+    softfloat_invalidExtF80M( zSPtr SOFTFLOAT_STATE_ARG_COMMA );
     return;
     /*------------------------------------------------------------------------
Index: trunk/src/libs/softfloat-3e/source/extF80M_roundToInt.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/extF80M_roundToInt.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/extF80M_roundToInt.c	(revision 94558)
@@ -50,8 +50,9 @@
      bool exact,
      extFloat80_t *zPtr
+     SOFTFLOAT_STATE_DECL_COMMA
  )
 {
 
-    *zPtr = extF80_roundToInt( *aPtr, roundingMode, exact );
+    *zPtr = extF80_roundToInt( *aPtr, roundingMode, exact SOFTFLOAT_STATE_ARG_COMMA );
 
 }
@@ -65,4 +66,5 @@
      bool exact,
      extFloat80_t *zPtr
+     SOFTFLOAT_STATE_DECL_COMMA
  )
 {
@@ -129,5 +131,5 @@
         if ( exp == 0x7FFF ) {
             if ( sigA & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) {
-                softfloat_propagateNaNExtF80M( aSPtr, 0, zSPtr );
+                softfloat_propagateNaNExtF80M( aSPtr, 0, zSPtr SOFTFLOAT_STATE_ARG_COMMA );
                 return;
             }
Index: trunk/src/libs/softfloat-3e/source/extF80M_sqrt.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/extF80M_sqrt.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/extF80M_sqrt.c	(revision 94558)
@@ -44,8 +44,8 @@
 #ifdef SOFTFLOAT_FAST_INT64
 
-void extF80M_sqrt( const extFloat80_t *aPtr, extFloat80_t *zPtr )
+void extF80M_sqrt( const extFloat80_t *aPtr, extFloat80_t *zPtr SOFTFLOAT_STATE_DECL_COMMA )
 {
 
-    *zPtr = extF80_sqrt( *aPtr );
+    *zPtr = extF80_sqrt( *aPtr SOFTFLOAT_STATE_ARG_COMMA );
 
 }
@@ -53,5 +53,5 @@
 #else
 
-void extF80M_sqrt( const extFloat80_t *aPtr, extFloat80_t *zPtr )
+void extF80M_sqrt( const extFloat80_t *aPtr, extFloat80_t *zPtr SOFTFLOAT_STATE_DECL_COMMA )
 {
     const struct extFloat80M *aSPtr;
@@ -79,5 +79,5 @@
     if ( expA == 0x7FFF ) {
         if ( rem64 & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) {
-            softfloat_propagateNaNExtF80M( aSPtr, 0, zSPtr );
+            softfloat_propagateNaNExtF80M( aSPtr, 0, zSPtr SOFTFLOAT_STATE_ARG_COMMA );
             return;
         }
@@ -162,10 +162,10 @@
     }
     softfloat_roundPackMToExtF80M(
-        0, expZ, extSigZ, extF80_roundingPrecision, zSPtr );
+        0, expZ, extSigZ, extF80_roundingPrecision, zSPtr SOFTFLOAT_STATE_ARG_COMMA );
     return;
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  invalid:
-    softfloat_invalidExtF80M( zSPtr );
+    softfloat_invalidExtF80M( zSPtr SOFTFLOAT_STATE_ARG_COMMA );
     return;
     /*------------------------------------------------------------------------
Index: trunk/src/libs/softfloat-3e/source/extF80M_sub.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/extF80M_sub.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/extF80M_sub.c	(revision 94558)
@@ -44,5 +44,5 @@
 void
  extF80M_sub(
-     const extFloat80_t *aPtr, const extFloat80_t *bPtr, extFloat80_t *zPtr )
+     const extFloat80_t *aPtr, const extFloat80_t *bPtr, extFloat80_t *zPtr SOFTFLOAT_STATE_DECL_COMMA )
 {
     const struct extFloat80M *aSPtr, *bSPtr;
@@ -56,5 +56,5 @@
     extFloat80_t
         (*magsFuncPtr)(
-            uint_fast16_t, uint_fast64_t, uint_fast16_t, uint_fast64_t, bool );
+            uint_fast16_t, uint_fast64_t, uint_fast16_t, uint_fast64_t, bool SOFTFLOAT_STATE_DECL_COMMA );
 #endif
 
@@ -69,12 +69,12 @@
 #if defined INLINE_LEVEL && (2 <= INLINE_LEVEL)
     if ( signA == signB ) {
-        *zPtr = softfloat_subMagsExtF80( uiA64, uiA0, uiB64, uiB0, signA );
+        *zPtr = softfloat_subMagsExtF80( uiA64, uiA0, uiB64, uiB0, signA SOFTFLOAT_STATE_ARG_COMMA );
     } else {
-        *zPtr = softfloat_addMagsExtF80( uiA64, uiA0, uiB64, uiB0, signA );
+        *zPtr = softfloat_addMagsExtF80( uiA64, uiA0, uiB64, uiB0, signA SOFTFLOAT_STATE_ARG_COMMA );
     }
 #else
     magsFuncPtr =
         (signA == signB) ? softfloat_subMagsExtF80 : softfloat_addMagsExtF80;
-    *zPtr = (*magsFuncPtr)( uiA64, uiA0, uiB64, uiB0, signA );
+    *zPtr = (*magsFuncPtr)( uiA64, uiA0, uiB64, uiB0, signA SOFTFLOAT_STATE_ARG_COMMA );
 #endif
 
@@ -85,5 +85,5 @@
 void
  extF80M_sub(
-     const extFloat80_t *aPtr, const extFloat80_t *bPtr, extFloat80_t *zPtr )
+     const extFloat80_t *aPtr, const extFloat80_t *bPtr, extFloat80_t *zPtr SOFTFLOAT_STATE_DECL_COMMA )
 {
 
@@ -93,4 +93,5 @@
         (struct extFloat80M *) zPtr,
         true
+        SOFTFLOAT_STATE_ARG_COMMA
     );
 
Index: trunk/src/libs/softfloat-3e/source/extF80M_to_f128M.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/extF80M_to_f128M.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/extF80M_to_f128M.c	(revision 94558)
@@ -44,8 +44,8 @@
 #ifdef SOFTFLOAT_FAST_INT64
 
-void extF80M_to_f128M( const extFloat80_t *aPtr, float128_t *zPtr )
+void extF80M_to_f128M( const extFloat80_t *aPtr, float128_t *zPtr SOFTFLOAT_STATE_DECL_COMMA )
 {
 
-    *zPtr = extF80_to_f128( *aPtr );
+    *zPtr = extF80_to_f128( *aPtr SOFTFLOAT_STATE_ARG_COMMA );
 
 }
@@ -53,5 +53,5 @@
 #else
 
-void extF80M_to_f128M( const extFloat80_t *aPtr, float128_t *zPtr )
+void extF80M_to_f128M( const extFloat80_t *aPtr, float128_t *zPtr SOFTFLOAT_STATE_DECL_COMMA )
 {
     const struct extFloat80M *aSPtr;
@@ -79,5 +79,5 @@
     if ( exp == 0x7FFF ) {
         if ( sig & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) {
-            softfloat_extF80MToCommonNaN( aSPtr, &commonNaN );
+            softfloat_extF80MToCommonNaN( aSPtr, &commonNaN SOFTFLOAT_STATE_ARG_COMMA );
             softfloat_commonNaNToF128M( &commonNaN, zWPtr );
             return;
Index: trunk/src/libs/softfloat-3e/source/extF80M_to_f16.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/extF80M_to_f16.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/extF80M_to_f16.c	(revision 94558)
@@ -44,8 +44,8 @@
 #ifdef SOFTFLOAT_FAST_INT64
 
-float16_t extF80M_to_f16( const extFloat80_t *aPtr )
+float16_t extF80M_to_f16( const extFloat80_t *aPtr SOFTFLOAT_STATE_DECL_COMMA )
 {
 
-    return extF80_to_f16( *aPtr );
+    return extF80_to_f16( *aPtr SOFTFLOAT_STATE_ARG_COMMA );
 
 }
@@ -53,5 +53,5 @@
 #else
 
-float16_t extF80M_to_f16( const extFloat80_t *aPtr )
+float16_t extF80M_to_f16( const extFloat80_t *aPtr SOFTFLOAT_STATE_DECL_COMMA )
 {
     const struct extFloat80M *aSPtr;
@@ -77,5 +77,5 @@
     if ( exp == 0x7FFF ) {
         if ( sig & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) {
-            softfloat_extF80MToCommonNaN( aSPtr, &commonNaN );
+            softfloat_extF80MToCommonNaN( aSPtr, &commonNaN SOFTFLOAT_STATE_ARG_COMMA );
             uiZ = softfloat_commonNaNToF16UI( &commonNaN );
         } else {
@@ -100,5 +100,5 @@
         if ( exp < -0x40 ) exp = -0x40;
     }
-    return softfloat_roundPackToF16( sign, exp, sig16 );
+    return softfloat_roundPackToF16( sign, exp, sig16 SOFTFLOAT_STATE_ARG_COMMA );
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
Index: trunk/src/libs/softfloat-3e/source/extF80M_to_f32.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/extF80M_to_f32.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/extF80M_to_f32.c	(revision 94558)
@@ -44,8 +44,8 @@
 #ifdef SOFTFLOAT_FAST_INT64
 
-float32_t extF80M_to_f32( const extFloat80_t *aPtr )
+float32_t extF80M_to_f32( const extFloat80_t *aPtr SOFTFLOAT_STATE_DECL_COMMA )
 {
 
-    return extF80_to_f32( *aPtr );
+    return extF80_to_f32( *aPtr SOFTFLOAT_STATE_ARG_COMMA );
 
 }
@@ -53,5 +53,5 @@
 #else
 
-float32_t extF80M_to_f32( const extFloat80_t *aPtr )
+float32_t extF80M_to_f32( const extFloat80_t *aPtr SOFTFLOAT_STATE_DECL_COMMA )
 {
     const struct extFloat80M *aSPtr;
@@ -77,5 +77,5 @@
     if ( exp == 0x7FFF ) {
         if ( sig & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) {
-            softfloat_extF80MToCommonNaN( aSPtr, &commonNaN );
+            softfloat_extF80MToCommonNaN( aSPtr, &commonNaN SOFTFLOAT_STATE_ARG_COMMA );
             uiZ = softfloat_commonNaNToF32UI( &commonNaN );
         } else {
@@ -100,5 +100,5 @@
         if ( exp < -0x1000 ) exp = -0x1000;
     }
-    return softfloat_roundPackToF32( sign, exp, sig32 );
+    return softfloat_roundPackToF32( sign, exp, sig32 SOFTFLOAT_STATE_ARG_COMMA );
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
Index: trunk/src/libs/softfloat-3e/source/extF80M_to_f64.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/extF80M_to_f64.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/extF80M_to_f64.c	(revision 94558)
@@ -44,8 +44,8 @@
 #ifdef SOFTFLOAT_FAST_INT64
 
-float64_t extF80M_to_f64( const extFloat80_t *aPtr )
+float64_t extF80M_to_f64( const extFloat80_t *aPtr SOFTFLOAT_STATE_DECL_COMMA )
 {
 
-    return extF80_to_f64( *aPtr );
+    return extF80_to_f64( *aPtr SOFTFLOAT_STATE_ARG_COMMA );
 
 }
@@ -53,5 +53,5 @@
 #else
 
-float64_t extF80M_to_f64( const extFloat80_t *aPtr )
+float64_t extF80M_to_f64( const extFloat80_t *aPtr SOFTFLOAT_STATE_DECL_COMMA )
 {
     const struct extFloat80M *aSPtr;
@@ -77,5 +77,5 @@
     if ( exp == 0x7FFF ) {
         if ( sig & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) {
-            softfloat_extF80MToCommonNaN( aSPtr, &commonNaN );
+            softfloat_extF80MToCommonNaN( aSPtr, &commonNaN SOFTFLOAT_STATE_ARG_COMMA );
             uiZ = softfloat_commonNaNToF64UI( &commonNaN );
         } else {
@@ -100,5 +100,5 @@
         if ( exp < -0x1000 ) exp = -0x1000;
     }
-    return softfloat_roundPackToF64( sign, exp, sig );
+    return softfloat_roundPackToF64( sign, exp, sig SOFTFLOAT_STATE_ARG_COMMA );
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
Index: trunk/src/libs/softfloat-3e/source/extF80M_to_i32.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/extF80M_to_i32.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/extF80M_to_i32.c	(revision 94558)
@@ -46,8 +46,8 @@
 int_fast32_t
  extF80M_to_i32(
-     const extFloat80_t *aPtr, uint_fast8_t roundingMode, bool exact )
+     const extFloat80_t *aPtr, uint_fast8_t roundingMode, bool exact SOFTFLOAT_STATE_DECL_COMMA )
 {
 
-    return extF80_to_i32( *aPtr, roundingMode, exact );
+    return extF80_to_i32( *aPtr, roundingMode, exact SOFTFLOAT_STATE_ARG_COMMA );
 
 }
@@ -57,5 +57,5 @@
 int_fast32_t
  extF80M_to_i32(
-     const extFloat80_t *aPtr, uint_fast8_t roundingMode, bool exact )
+     const extFloat80_t *aPtr, uint_fast8_t roundingMode, bool exact SOFTFLOAT_STATE_DECL_COMMA )
 {
     const struct extFloat80M *aSPtr;
@@ -86,9 +86,9 @@
         sig = softfloat_shiftRightJam64( sig, shiftDist );
     }
-    return softfloat_roundToI32( sign, sig, roundingMode, exact );
+    return softfloat_roundToI32( sign, sig, roundingMode, exact SOFTFLOAT_STATE_ARG_COMMA );
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  invalid:
-    softfloat_raiseFlags( softfloat_flag_invalid );
+    softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
     return
         (exp == 0x7FFF) && (sig & UINT64_C( 0x7FFFFFFFFFFFFFFF )) ? i32_fromNaN
Index: trunk/src/libs/softfloat-3e/source/extF80M_to_i32_r_minMag.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/extF80M_to_i32_r_minMag.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/extF80M_to_i32_r_minMag.c	(revision 94558)
@@ -44,8 +44,8 @@
 #ifdef SOFTFLOAT_FAST_INT64
 
-int_fast32_t extF80M_to_i32_r_minMag( const extFloat80_t *aPtr, bool exact )
+int_fast32_t extF80M_to_i32_r_minMag( const extFloat80_t *aPtr, bool exact SOFTFLOAT_STATE_DECL_COMMA )
 {
 
-    return extF80_to_i32_r_minMag( *aPtr, exact );
+    return extF80_to_i32_r_minMag( *aPtr, exact SOFTFLOAT_STATE_ARG_COMMA );
 
 }
@@ -53,5 +53,5 @@
 #else
 
-int_fast32_t extF80M_to_i32_r_minMag( const extFloat80_t *aPtr, bool exact )
+int_fast32_t extF80M_to_i32_r_minMag( const extFloat80_t *aPtr, bool exact SOFTFLOAT_STATE_DECL_COMMA )
 {
     const struct extFloat80M *aSPtr;
@@ -110,5 +110,5 @@
     *------------------------------------------------------------------------*/
  invalid:
-    softfloat_raiseFlags( softfloat_flag_invalid );
+    softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
     return
         (exp == 0x7FFF) && (sig & UINT64_C( 0x7FFFFFFFFFFFFFFF )) ? i32_fromNaN
Index: trunk/src/libs/softfloat-3e/source/extF80M_to_i64.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/extF80M_to_i64.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/extF80M_to_i64.c	(revision 94558)
@@ -46,8 +46,8 @@
 int_fast64_t
  extF80M_to_i64(
-     const extFloat80_t *aPtr, uint_fast8_t roundingMode, bool exact )
+     const extFloat80_t *aPtr, uint_fast8_t roundingMode, bool exact SOFTFLOAT_STATE_DECL_COMMA )
 {
 
-    return extF80_to_i64( *aPtr, roundingMode, exact );
+    return extF80_to_i64( *aPtr, roundingMode, exact SOFTFLOAT_STATE_ARG_COMMA );
 
 }
@@ -57,5 +57,5 @@
 int_fast64_t
  extF80M_to_i64(
-     const extFloat80_t *aPtr, uint_fast8_t roundingMode, bool exact )
+     const extFloat80_t *aPtr, uint_fast8_t roundingMode, bool exact SOFTFLOAT_STATE_DECL_COMMA )
 {
     const struct extFloat80M *aSPtr;
@@ -78,5 +78,5 @@
     shiftDist = 0x403E - exp;
     if ( shiftDist < 0 ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
         return
             (exp == 0x7FFF) && (sig & UINT64_C( 0x7FFFFFFFFFFFFFFF ))
@@ -90,5 +90,5 @@
     extSig[indexWord( 3, 0 )] = 0;
     if ( shiftDist ) softfloat_shiftRightJam96M( extSig, shiftDist, extSig );
-    return softfloat_roundMToI64( sign, extSig, roundingMode, exact );
+    return softfloat_roundMToI64( sign, extSig, roundingMode, exact SOFTFLOAT_STATE_ARG_COMMA );
 
 }
Index: trunk/src/libs/softfloat-3e/source/extF80M_to_i64_r_minMag.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/extF80M_to_i64_r_minMag.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/extF80M_to_i64_r_minMag.c	(revision 94558)
@@ -44,8 +44,8 @@
 #ifdef SOFTFLOAT_FAST_INT64
 
-int_fast64_t extF80M_to_i64_r_minMag( const extFloat80_t *aPtr, bool exact )
+int_fast64_t extF80M_to_i64_r_minMag( const extFloat80_t *aPtr, bool exact SOFTFLOAT_STATE_DECL_COMMA )
 {
 
-    return extF80_to_i64_r_minMag( *aPtr, exact );
+    return extF80_to_i64_r_minMag( *aPtr, exact SOFTFLOAT_STATE_ARG_COMMA );
 
 }
@@ -53,5 +53,5 @@
 #else
 
-int_fast64_t extF80M_to_i64_r_minMag( const extFloat80_t *aPtr, bool exact )
+int_fast64_t extF80M_to_i64_r_minMag( const extFloat80_t *aPtr, bool exact SOFTFLOAT_STATE_DECL_COMMA )
 {
     const struct extFloat80M *aSPtr;
@@ -105,5 +105,5 @@
     *------------------------------------------------------------------------*/
  invalid:
-    softfloat_raiseFlags( softfloat_flag_invalid );
+    softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
     return
         (exp == 0x7FFF) && (sig & UINT64_C( 0x7FFFFFFFFFFFFFFF )) ? i64_fromNaN
Index: trunk/src/libs/softfloat-3e/source/extF80M_to_ui32.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/extF80M_to_ui32.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/extF80M_to_ui32.c	(revision 94558)
@@ -46,8 +46,8 @@
 uint_fast32_t
  extF80M_to_ui32(
-     const extFloat80_t *aPtr, uint_fast8_t roundingMode, bool exact )
+     const extFloat80_t *aPtr, uint_fast8_t roundingMode, bool exact SOFTFLOAT_STATE_DECL_COMMA )
 {
 
-    return extF80_to_ui32( *aPtr, roundingMode, exact );
+    return extF80_to_ui32( *aPtr, roundingMode, exact SOFTFLOAT_STATE_ARG_COMMA );
 
 }
@@ -57,5 +57,5 @@
 uint_fast32_t
  extF80M_to_ui32(
-     const extFloat80_t *aPtr, uint_fast8_t roundingMode, bool exact )
+     const extFloat80_t *aPtr, uint_fast8_t roundingMode, bool exact SOFTFLOAT_STATE_DECL_COMMA )
 {
     const struct extFloat80M *aSPtr;
@@ -86,9 +86,9 @@
         sig = softfloat_shiftRightJam64( sig, shiftDist );
     }
-    return softfloat_roundToUI32( sign, sig, roundingMode, exact );
+    return softfloat_roundToUI32( sign, sig, roundingMode, exact SOFTFLOAT_STATE_ARG_COMMA );
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  invalid:
-    softfloat_raiseFlags( softfloat_flag_invalid );
+    softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
     return
         (exp == 0x7FFF) && (sig & UINT64_C( 0x7FFFFFFFFFFFFFFF ))
Index: trunk/src/libs/softfloat-3e/source/extF80M_to_ui32_r_minMag.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/extF80M_to_ui32_r_minMag.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/extF80M_to_ui32_r_minMag.c	(revision 94558)
@@ -44,8 +44,8 @@
 #ifdef SOFTFLOAT_FAST_INT64
 
-uint_fast32_t extF80M_to_ui32_r_minMag( const extFloat80_t *aPtr, bool exact )
+uint_fast32_t extF80M_to_ui32_r_minMag( const extFloat80_t *aPtr, bool exact SOFTFLOAT_STATE_DECL_COMMA )
 {
 
-    return extF80_to_ui32_r_minMag( *aPtr, exact );
+    return extF80_to_ui32_r_minMag( *aPtr, exact SOFTFLOAT_STATE_ARG_COMMA );
 
 }
@@ -53,5 +53,5 @@
 #else
 
-uint_fast32_t extF80M_to_ui32_r_minMag( const extFloat80_t *aPtr, bool exact )
+uint_fast32_t extF80M_to_ui32_r_minMag( const extFloat80_t *aPtr, bool exact SOFTFLOAT_STATE_DECL_COMMA )
 {
     const struct extFloat80M *aSPtr;
@@ -100,5 +100,5 @@
     *------------------------------------------------------------------------*/
  invalid:
-    softfloat_raiseFlags( softfloat_flag_invalid );
+    softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
     return
         (exp == 0x7FFF) && (sig & UINT64_C( 0x7FFFFFFFFFFFFFFF ))
Index: trunk/src/libs/softfloat-3e/source/extF80M_to_ui64.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/extF80M_to_ui64.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/extF80M_to_ui64.c	(revision 94558)
@@ -46,8 +46,8 @@
 uint_fast64_t
  extF80M_to_ui64(
-     const extFloat80_t *aPtr, uint_fast8_t roundingMode, bool exact )
+     const extFloat80_t *aPtr, uint_fast8_t roundingMode, bool exact SOFTFLOAT_STATE_DECL_COMMA )
 {
 
-    return extF80_to_ui64( *aPtr, roundingMode, exact );
+    return extF80_to_ui64( *aPtr, roundingMode, exact SOFTFLOAT_STATE_ARG_COMMA );
 
 }
@@ -57,5 +57,5 @@
 uint_fast64_t
  extF80M_to_ui64(
-     const extFloat80_t *aPtr, uint_fast8_t roundingMode, bool exact )
+     const extFloat80_t *aPtr, uint_fast8_t roundingMode, bool exact SOFTFLOAT_STATE_DECL_COMMA )
 {
     const struct extFloat80M *aSPtr;
@@ -78,5 +78,5 @@
     shiftDist = 0x403E - exp;
     if ( shiftDist < 0 ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
         return
             (exp == 0x7FFF) && (sig & UINT64_C( 0x7FFFFFFFFFFFFFFF ))
@@ -90,5 +90,5 @@
     extSig[indexWord( 3, 0 )] = 0;
     if ( shiftDist ) softfloat_shiftRightJam96M( extSig, shiftDist, extSig );
-    return softfloat_roundMToUI64( sign, extSig, roundingMode, exact );
+    return softfloat_roundMToUI64( sign, extSig, roundingMode, exact SOFTFLOAT_STATE_ARG_COMMA);
 
 }
Index: trunk/src/libs/softfloat-3e/source/extF80M_to_ui64_r_minMag.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/extF80M_to_ui64_r_minMag.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/extF80M_to_ui64_r_minMag.c	(revision 94558)
@@ -44,8 +44,8 @@
 #ifdef SOFTFLOAT_FAST_INT64
 
-uint_fast64_t extF80M_to_ui64_r_minMag( const extFloat80_t *aPtr, bool exact )
+uint_fast64_t extF80M_to_ui64_r_minMag( const extFloat80_t *aPtr, bool exact SOFTFLOAT_STATE_DECL_COMMA )
 {
 
-    return extF80_to_ui64_r_minMag( *aPtr, exact );
+    return extF80_to_ui64_r_minMag( *aPtr, exact SOFTFLOAT_STATE_ARG_COMMA );
 
 }
@@ -53,5 +53,5 @@
 #else
 
-uint_fast64_t extF80M_to_ui64_r_minMag( const extFloat80_t *aPtr, bool exact )
+uint_fast64_t extF80M_to_ui64_r_minMag( const extFloat80_t *aPtr, bool exact SOFTFLOAT_STATE_DECL_COMMA )
 {
     const struct extFloat80M *aSPtr;
@@ -97,5 +97,5 @@
     *------------------------------------------------------------------------*/
  invalid:
-    softfloat_raiseFlags( softfloat_flag_invalid );
+    softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
     return
         (exp == 0x7FFF) && (sig & UINT64_C( 0x7FFFFFFFFFFFFFFF ))
Index: trunk/src/libs/softfloat-3e/source/extF80_add.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/extF80_add.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/extF80_add.c	(revision 94558)
@@ -41,5 +41,5 @@
 #include "softfloat.h"
 
-extFloat80_t extF80_add( extFloat80_t a, extFloat80_t b )
+extFloat80_t extF80_add( extFloat80_t a, extFloat80_t b SOFTFLOAT_STATE_DECL_COMMA )
 {
     union { struct extFloat80M s; extFloat80_t f; } uA;
@@ -54,5 +54,5 @@
     extFloat80_t
         (*magsFuncPtr)(
-            uint_fast16_t, uint_fast64_t, uint_fast16_t, uint_fast64_t, bool );
+            uint_fast16_t, uint_fast64_t, uint_fast16_t, uint_fast64_t, bool SOFTFLOAT_STATE_DECL_COMMA );
 #endif
 
@@ -67,12 +67,12 @@
 #if defined INLINE_LEVEL && (2 <= INLINE_LEVEL)
     if ( signA == signB ) {
-        return softfloat_addMagsExtF80( uiA64, uiA0, uiB64, uiB0, signA );
+        return softfloat_addMagsExtF80( uiA64, uiA0, uiB64, uiB0, signA SOFTFLOAT_STATE_ARG_COMMA );
     } else {
-        return softfloat_subMagsExtF80( uiA64, uiA0, uiB64, uiB0, signA );
+        return softfloat_subMagsExtF80( uiA64, uiA0, uiB64, uiB0, signA SOFTFLOAT_STATE_ARG_COMMA );
     }
 #else
     magsFuncPtr =
         (signA == signB) ? softfloat_addMagsExtF80 : softfloat_subMagsExtF80;
-    return (*magsFuncPtr)( uiA64, uiA0, uiB64, uiB0, signA );
+    return (*magsFuncPtr)( uiA64, uiA0, uiB64, uiB0, signA SOFTFLOAT_STATE_ARG_COMMA );
 #endif
 
Index: trunk/src/libs/softfloat-3e/source/extF80_div.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/extF80_div.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/extF80_div.c	(revision 94558)
@@ -42,5 +42,5 @@
 #include "softfloat.h"
 
-extFloat80_t extF80_div( extFloat80_t a, extFloat80_t b )
+extFloat80_t extF80_div( extFloat80_t a, extFloat80_t b SOFTFLOAT_STATE_DECL_COMMA )
 {
     union { struct extFloat80M s; extFloat80_t f; } uA;
@@ -107,5 +107,5 @@
         if ( ! sigB ) {
             if ( ! sigA ) goto invalid;
-            softfloat_raiseFlags( softfloat_flag_infinite );
+            softfloat_raiseFlags( softfloat_flag_infinite SOFTFLOAT_STATE_ARG_COMMA );
             goto infinity;
         }
@@ -169,9 +169,9 @@
     return
         softfloat_roundPackToExtF80(
-            signZ, expZ, sigZ, sigZExtra, extF80_roundingPrecision );
+            signZ, expZ, sigZ, sigZExtra, extF80_roundingPrecision SOFTFLOAT_STATE_ARG_COMMA );
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  propagateNaN:
-    uiZ = softfloat_propagateNaNExtF80UI( uiA64, uiA0, uiB64, uiB0 );
+    uiZ = softfloat_propagateNaNExtF80UI( uiA64, uiA0, uiB64, uiB0 SOFTFLOAT_STATE_ARG_COMMA );
     uiZ64 = uiZ.v64;
     uiZ0  = uiZ.v0;
@@ -180,5 +180,5 @@
     *------------------------------------------------------------------------*/
  invalid:
-    softfloat_raiseFlags( softfloat_flag_invalid );
+    softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
     uiZ64 = defaultNaNExtF80UI64;
     uiZ0  = defaultNaNExtF80UI0;
Index: trunk/src/libs/softfloat-3e/source/extF80_eq.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/extF80_eq.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/extF80_eq.c	(revision 94558)
@@ -42,5 +42,5 @@
 #include "softfloat.h"
 
-bool extF80_eq( extFloat80_t a, extFloat80_t b )
+bool extF80_eq( extFloat80_t a, extFloat80_t b SOFTFLOAT_STATE_DECL_COMMA )
 {
     union { struct extFloat80M s; extFloat80_t f; } uA;
@@ -62,5 +62,5 @@
             || softfloat_isSigNaNExtF80UI( uiB64, uiB0 )
         ) {
-            softfloat_raiseFlags( softfloat_flag_invalid );
+            softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
         }
         return false;
Index: trunk/src/libs/softfloat-3e/source/extF80_eq_signaling.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/extF80_eq_signaling.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/extF80_eq_signaling.c	(revision 94558)
@@ -41,5 +41,5 @@
 #include "softfloat.h"
 
-bool extF80_eq_signaling( extFloat80_t a, extFloat80_t b )
+bool extF80_eq_signaling( extFloat80_t a, extFloat80_t b SOFTFLOAT_STATE_DECL_COMMA )
 {
     union { struct extFloat80M s; extFloat80_t f; } uA;
@@ -57,5 +57,5 @@
     uiB0  = uB.s.signif;
     if ( isNaNExtF80UI( uiA64, uiA0 ) || isNaNExtF80UI( uiB64, uiB0 ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
         return false;
     }
Index: trunk/src/libs/softfloat-3e/source/extF80_le.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/extF80_le.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/extF80_le.c	(revision 94558)
@@ -42,5 +42,5 @@
 #include "softfloat.h"
 
-bool extF80_le( extFloat80_t a, extFloat80_t b )
+bool extF80_le( extFloat80_t a, extFloat80_t b SOFTFLOAT_STATE_DECL_COMMA )
 {
     union { struct extFloat80M s; extFloat80_t f; } uA;
@@ -59,5 +59,5 @@
     uiB0  = uB.s.signif;
     if ( isNaNExtF80UI( uiA64, uiA0 ) || isNaNExtF80UI( uiB64, uiB0 ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
         return false;
     }
Index: trunk/src/libs/softfloat-3e/source/extF80_le_quiet.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/extF80_le_quiet.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/extF80_le_quiet.c	(revision 94558)
@@ -42,5 +42,5 @@
 #include "softfloat.h"
 
-bool extF80_le_quiet( extFloat80_t a, extFloat80_t b )
+bool extF80_le_quiet( extFloat80_t a, extFloat80_t b SOFTFLOAT_STATE_DECL_COMMA )
 {
     union { struct extFloat80M s; extFloat80_t f; } uA;
@@ -63,5 +63,5 @@
             || softfloat_isSigNaNExtF80UI( uiB64, uiB0 )
         ) {
-            softfloat_raiseFlags( softfloat_flag_invalid );
+            softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
         }
         return false;
Index: trunk/src/libs/softfloat-3e/source/extF80_lt.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/extF80_lt.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/extF80_lt.c	(revision 94558)
@@ -42,5 +42,5 @@
 #include "softfloat.h"
 
-bool extF80_lt( extFloat80_t a, extFloat80_t b )
+bool extF80_lt( extFloat80_t a, extFloat80_t b SOFTFLOAT_STATE_DECL_COMMA )
 {
     union { struct extFloat80M s; extFloat80_t f; } uA;
@@ -59,5 +59,5 @@
     uiB0  = uB.s.signif;
     if ( isNaNExtF80UI( uiA64, uiA0 ) || isNaNExtF80UI( uiB64, uiB0 ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
         return false;
     }
Index: trunk/src/libs/softfloat-3e/source/extF80_lt_quiet.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/extF80_lt_quiet.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/extF80_lt_quiet.c	(revision 94558)
@@ -42,5 +42,5 @@
 #include "softfloat.h"
 
-bool extF80_lt_quiet( extFloat80_t a, extFloat80_t b )
+bool extF80_lt_quiet( extFloat80_t a, extFloat80_t b SOFTFLOAT_STATE_DECL_COMMA )
 {
     union { struct extFloat80M s; extFloat80_t f; } uA;
@@ -63,5 +63,5 @@
             || softfloat_isSigNaNExtF80UI( uiB64, uiB0 )
         ) {
-            softfloat_raiseFlags( softfloat_flag_invalid );
+            softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
         }
         return false;
Index: trunk/src/libs/softfloat-3e/source/extF80_mul.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/extF80_mul.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/extF80_mul.c	(revision 94558)
@@ -42,5 +42,5 @@
 #include "softfloat.h"
 
-extFloat80_t extF80_mul( extFloat80_t a, extFloat80_t b )
+extFloat80_t extF80_mul( extFloat80_t a, extFloat80_t b SOFTFLOAT_STATE_DECL_COMMA )
 {
     union { struct extFloat80M s; extFloat80_t f; } uA;
@@ -125,9 +125,9 @@
     return
         softfloat_roundPackToExtF80(
-            signZ, expZ, sig128Z.v64, sig128Z.v0, extF80_roundingPrecision );
+            signZ, expZ, sig128Z.v64, sig128Z.v0, extF80_roundingPrecision SOFTFLOAT_STATE_ARG_COMMA );
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  propagateNaN:
-    uiZ = softfloat_propagateNaNExtF80UI( uiA64, uiA0, uiB64, uiB0 );
+    uiZ = softfloat_propagateNaNExtF80UI( uiA64, uiA0, uiB64, uiB0 SOFTFLOAT_STATE_ARG_COMMA );
     uiZ64 = uiZ.v64;
     uiZ0  = uiZ.v0;
@@ -137,5 +137,5 @@
  infArg:
     if ( ! magBits ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
         uiZ64 = defaultNaNExtF80UI64;
         uiZ0  = defaultNaNExtF80UI0;
Index: trunk/src/libs/softfloat-3e/source/extF80_rem.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/extF80_rem.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/extF80_rem.c	(revision 94558)
@@ -42,5 +42,5 @@
 #include "softfloat.h"
 
-extFloat80_t extF80_rem( extFloat80_t a, extFloat80_t b )
+extFloat80_t extF80_rem( extFloat80_t a, extFloat80_t b SOFTFLOAT_STATE_DECL_COMMA )
 {
     union { struct extFloat80M s; extFloat80_t f; } uA;
@@ -193,9 +193,9 @@
     return
         softfloat_normRoundPackToExtF80(
-            signRem, rem.v64 | rem.v0 ? expB + 32 : 0, rem.v64, rem.v0, 80 );
+            signRem, rem.v64 | rem.v0 ? expB + 32 : 0, rem.v64, rem.v0, 80 SOFTFLOAT_STATE_ARG_COMMA );
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  propagateNaN:
-    uiZ = softfloat_propagateNaNExtF80UI( uiA64, uiA0, uiB64, uiB0 );
+    uiZ = softfloat_propagateNaNExtF80UI( uiA64, uiA0, uiB64, uiB0 SOFTFLOAT_STATE_ARG_COMMA );
     uiZ64 = uiZ.v64;
     uiZ0  = uiZ.v0;
@@ -204,5 +204,5 @@
     *------------------------------------------------------------------------*/
  invalid:
-    softfloat_raiseFlags( softfloat_flag_invalid );
+    softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
     uiZ64 = defaultNaNExtF80UI64;
     uiZ0  = defaultNaNExtF80UI0;
Index: trunk/src/libs/softfloat-3e/source/extF80_roundToInt.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/extF80_roundToInt.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/extF80_roundToInt.c	(revision 94558)
@@ -44,5 +44,5 @@
 
 extFloat80_t
- extF80_roundToInt( extFloat80_t a, uint_fast8_t roundingMode, bool exact )
+ extF80_roundToInt( extFloat80_t a, uint_fast8_t roundingMode, bool exact SOFTFLOAT_STATE_DECL_COMMA )
 {
     union { struct extFloat80M s; extFloat80_t f; } uA;
@@ -81,5 +81,5 @@
         if ( exp == 0x7FFF ) {
             if ( sigA & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) {
-                uiZ = softfloat_propagateNaNExtF80UI( uiA64, sigA, 0, 0 );
+                uiZ = softfloat_propagateNaNExtF80UI( uiA64, sigA, 0, 0 SOFTFLOAT_STATE_ARG_COMMA );
                 uiZ64 = uiZ.v64;
                 sigZ  = uiZ.v0;
Index: trunk/src/libs/softfloat-3e/source/extF80_sqrt.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/extF80_sqrt.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/extF80_sqrt.c	(revision 94558)
@@ -42,5 +42,5 @@
 #include "softfloat.h"
 
-extFloat80_t extF80_sqrt( extFloat80_t a )
+extFloat80_t extF80_sqrt( extFloat80_t a SOFTFLOAT_STATE_DECL_COMMA )
 {
     union { struct extFloat80M s; extFloat80_t f; } uA;
@@ -74,5 +74,5 @@
     if ( expA == 0x7FFF ) {
         if ( sigA & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) {
-            uiZ = softfloat_propagateNaNExtF80UI( uiA64, uiA0, 0, 0 );
+            uiZ = softfloat_propagateNaNExtF80UI( uiA64, uiA0, 0, 0 SOFTFLOAT_STATE_ARG_COMMA );
             uiZ64 = uiZ.v64;
             uiZ0  = uiZ.v0;
@@ -155,9 +155,9 @@
     return
         softfloat_roundPackToExtF80(
-            0, expZ, sigZ, sigZExtra, extF80_roundingPrecision );
+            0, expZ, sigZ, sigZExtra, extF80_roundingPrecision SOFTFLOAT_STATE_ARG_COMMA );
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  invalid:
-    softfloat_raiseFlags( softfloat_flag_invalid );
+    softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
     uiZ64 = defaultNaNExtF80UI64;
     uiZ0  = defaultNaNExtF80UI0;
Index: trunk/src/libs/softfloat-3e/source/extF80_sub.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/extF80_sub.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/extF80_sub.c	(revision 94558)
@@ -41,5 +41,5 @@
 #include "softfloat.h"
 
-extFloat80_t extF80_sub( extFloat80_t a, extFloat80_t b )
+extFloat80_t extF80_sub( extFloat80_t a, extFloat80_t b SOFTFLOAT_STATE_DECL_COMMA )
 {
     union { struct extFloat80M s; extFloat80_t f; } uA;
@@ -54,5 +54,5 @@
     extFloat80_t
         (*magsFuncPtr)(
-            uint_fast16_t, uint_fast64_t, uint_fast16_t, uint_fast64_t, bool );
+            uint_fast16_t, uint_fast64_t, uint_fast16_t, uint_fast64_t, bool SOFTFLOAT_STATE_DECL_COMMA );
 #endif
 
@@ -67,12 +67,12 @@
 #if defined INLINE_LEVEL && (2 <= INLINE_LEVEL)
     if ( signA == signB ) {
-        return softfloat_subMagsExtF80( uiA64, uiA0, uiB64, uiB0, signA );
+        return softfloat_subMagsExtF80( uiA64, uiA0, uiB64, uiB0, signA SOFTFLOAT_STATE_ARG_COMMA );
     } else {
-        return softfloat_addMagsExtF80( uiA64, uiA0, uiB64, uiB0, signA );
+        return softfloat_addMagsExtF80( uiA64, uiA0, uiB64, uiB0, signA SOFTFLOAT_STATE_ARG_COMMA );
     }
 #else
     magsFuncPtr =
         (signA == signB) ? softfloat_subMagsExtF80 : softfloat_addMagsExtF80;
-    return (*magsFuncPtr)( uiA64, uiA0, uiB64, uiB0, signA );
+    return (*magsFuncPtr)( uiA64, uiA0, uiB64, uiB0, signA SOFTFLOAT_STATE_ARG_COMMA );
 #endif
 
Index: trunk/src/libs/softfloat-3e/source/extF80_to_f128.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/extF80_to_f128.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/extF80_to_f128.c	(revision 94558)
@@ -42,5 +42,5 @@
 #include "softfloat.h"
 
-float128_t extF80_to_f128( extFloat80_t a )
+float128_t extF80_to_f128( extFloat80_t a SOFTFLOAT_STATE_DECL_COMMA )
 {
     union { struct extFloat80M s; extFloat80_t f; } uA;
@@ -61,5 +61,5 @@
     frac = uiA0 & UINT64_C( 0x7FFFFFFFFFFFFFFF );
     if ( (exp == 0x7FFF) && frac ) {
-        softfloat_extF80UIToCommonNaN( uiA64, uiA0, &commonNaN );
+        softfloat_extF80UIToCommonNaN( uiA64, uiA0, &commonNaN SOFTFLOAT_STATE_ARG_COMMA );
         uiZ = softfloat_commonNaNToF128UI( &commonNaN );
     } else {
Index: trunk/src/libs/softfloat-3e/source/extF80_to_f16.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/extF80_to_f16.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/extF80_to_f16.c	(revision 94558)
@@ -42,5 +42,5 @@
 #include "softfloat.h"
 
-float16_t extF80_to_f16( extFloat80_t a )
+float16_t extF80_to_f16( extFloat80_t a SOFTFLOAT_STATE_DECL_COMMA )
 {
     union { struct extFloat80M s; extFloat80_t f; } uA;
@@ -66,5 +66,5 @@
     if ( exp == 0x7FFF ) {
         if ( sig & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) {
-            softfloat_extF80UIToCommonNaN( uiA64, uiA0, &commonNaN );
+            softfloat_extF80UIToCommonNaN( uiA64, uiA0, &commonNaN SOFTFLOAT_STATE_ARG_COMMA );
             uiZ = softfloat_commonNaNToF16UI( &commonNaN );
         } else {
@@ -86,5 +86,5 @@
         if ( exp < -0x40 ) exp = -0x40;
     }
-    return softfloat_roundPackToF16( sign, exp, sig16 );
+    return softfloat_roundPackToF16( sign, exp, sig16 SOFTFLOAT_STATE_ARG_COMMA );
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
Index: trunk/src/libs/softfloat-3e/source/extF80_to_f32.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/extF80_to_f32.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/extF80_to_f32.c	(revision 94558)
@@ -42,5 +42,5 @@
 #include "softfloat.h"
 
-float32_t extF80_to_f32( extFloat80_t a )
+float32_t extF80_to_f32( extFloat80_t a SOFTFLOAT_STATE_DECL_COMMA )
 {
     union { struct extFloat80M s; extFloat80_t f; } uA;
@@ -66,5 +66,5 @@
     if ( exp == 0x7FFF ) {
         if ( sig & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) {
-            softfloat_extF80UIToCommonNaN( uiA64, uiA0, &commonNaN );
+            softfloat_extF80UIToCommonNaN( uiA64, uiA0, &commonNaN SOFTFLOAT_STATE_ARG_COMMA );
             uiZ = softfloat_commonNaNToF32UI( &commonNaN );
         } else {
@@ -86,5 +86,5 @@
         if ( exp < -0x1000 ) exp = -0x1000;
     }
-    return softfloat_roundPackToF32( sign, exp, sig32 );
+    return softfloat_roundPackToF32( sign, exp, sig32 SOFTFLOAT_STATE_ARG_COMMA );
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
Index: trunk/src/libs/softfloat-3e/source/extF80_to_f64.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/extF80_to_f64.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/extF80_to_f64.c	(revision 94558)
@@ -42,5 +42,5 @@
 #include "softfloat.h"
 
-float64_t extF80_to_f64( extFloat80_t a )
+float64_t extF80_to_f64( extFloat80_t a SOFTFLOAT_STATE_DECL_COMMA )
 {
     union { struct extFloat80M s; extFloat80_t f; } uA;
@@ -72,5 +72,5 @@
     if ( exp == 0x7FFF ) {
         if ( sig & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) {
-            softfloat_extF80UIToCommonNaN( uiA64, uiA0, &commonNaN );
+            softfloat_extF80UIToCommonNaN( uiA64, uiA0, &commonNaN SOFTFLOAT_STATE_ARG_COMMA );
             uiZ = softfloat_commonNaNToF64UI( &commonNaN );
         } else {
@@ -86,5 +86,5 @@
         if ( exp < -0x1000 ) exp = -0x1000;
     }
-    return softfloat_roundPackToF64( sign, exp, sig );
+    return softfloat_roundPackToF64( sign, exp, sig SOFTFLOAT_STATE_ARG_COMMA );
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
Index: trunk/src/libs/softfloat-3e/source/extF80_to_i32.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/extF80_to_i32.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/extF80_to_i32.c	(revision 94558)
@@ -43,5 +43,5 @@
 
 int_fast32_t
- extF80_to_i32( extFloat80_t a, uint_fast8_t roundingMode, bool exact )
+ extF80_to_i32( extFloat80_t a, uint_fast8_t roundingMode, bool exact SOFTFLOAT_STATE_DECL_COMMA )
 {
     union { struct extFloat80M s; extFloat80_t f; } uA;
@@ -68,5 +68,5 @@
         sign = 1;
 #else
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
         return i32_fromNaN;
 #endif
@@ -78,5 +78,5 @@
     if ( shiftDist <= 0 ) shiftDist = 1;
     sig = softfloat_shiftRightJam64( sig, shiftDist );
-    return softfloat_roundToI32( sign, sig, roundingMode, exact );
+    return softfloat_roundToI32( sign, sig, roundingMode, exact SOFTFLOAT_STATE_ARG_COMMA );
 
 }
Index: trunk/src/libs/softfloat-3e/source/extF80_to_i32_r_minMag.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/extF80_to_i32_r_minMag.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/extF80_to_i32_r_minMag.c	(revision 94558)
@@ -42,5 +42,5 @@
 #include "softfloat.h"
 
-int_fast32_t extF80_to_i32_r_minMag( extFloat80_t a, bool exact )
+int_fast32_t extF80_to_i32_r_minMag( extFloat80_t a, bool exact SOFTFLOAT_STATE_DECL_COMMA )
 {
     union { struct extFloat80M s; extFloat80_t f; } uA;
@@ -80,5 +80,5 @@
             return -0x7FFFFFFF - 1;
         }
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
         return
             (exp == 0x7FFF) && (sig & UINT64_C( 0x7FFFFFFFFFFFFFFF ))
Index: trunk/src/libs/softfloat-3e/source/extF80_to_i64.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/extF80_to_i64.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/extF80_to_i64.c	(revision 94558)
@@ -43,5 +43,5 @@
 
 int_fast64_t
- extF80_to_i64( extFloat80_t a, uint_fast8_t roundingMode, bool exact )
+ extF80_to_i64( extFloat80_t a, uint_fast8_t roundingMode, bool exact SOFTFLOAT_STATE_DECL_COMMA )
 {
     union { struct extFloat80M s; extFloat80_t f; } uA;
@@ -68,5 +68,5 @@
         *--------------------------------------------------------------------*/
         if ( shiftDist ) {
-            softfloat_raiseFlags( softfloat_flag_invalid );
+            softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
             return
                 (exp == 0x7FFF) && (sig & UINT64_C( 0x7FFFFFFFFFFFFFFF ))
@@ -84,5 +84,5 @@
         sigExtra = sig64Extra.extra;
     }
-    return softfloat_roundToI64( sign, sig, sigExtra, roundingMode, exact );
+    return softfloat_roundToI64( sign, sig, sigExtra, roundingMode, exact SOFTFLOAT_STATE_ARG_COMMA );
 
 }
Index: trunk/src/libs/softfloat-3e/source/extF80_to_i64_r_minMag.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/extF80_to_i64_r_minMag.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/extF80_to_i64_r_minMag.c	(revision 94558)
@@ -42,5 +42,5 @@
 #include "softfloat.h"
 
-int_fast64_t extF80_to_i64_r_minMag( extFloat80_t a, bool exact )
+int_fast64_t extF80_to_i64_r_minMag( extFloat80_t a, bool exact SOFTFLOAT_STATE_DECL_COMMA )
 {
     union { struct extFloat80M s; extFloat80_t f; } uA;
@@ -77,5 +77,5 @@
             return -INT64_C( 0x7FFFFFFFFFFFFFFF ) - 1;
         }
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
         return
             (exp == 0x7FFF) && (sig & UINT64_C( 0x7FFFFFFFFFFFFFFF ))
Index: trunk/src/libs/softfloat-3e/source/extF80_to_ui32.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/extF80_to_ui32.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/extF80_to_ui32.c	(revision 94558)
@@ -43,5 +43,5 @@
 
 uint_fast32_t
- extF80_to_ui32( extFloat80_t a, uint_fast8_t roundingMode, bool exact )
+ extF80_to_ui32( extFloat80_t a, uint_fast8_t roundingMode, bool exact SOFTFLOAT_STATE_DECL_COMMA )
 {
     union { struct extFloat80M s; extFloat80_t f; } uA;
@@ -68,5 +68,5 @@
         sign = 1;
 #else
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
         return ui32_fromNaN;
 #endif
@@ -78,5 +78,5 @@
     if ( shiftDist <= 0 ) shiftDist = 1;
     sig = softfloat_shiftRightJam64( sig, shiftDist );
-    return softfloat_roundToUI32( sign, sig, roundingMode, exact );
+    return softfloat_roundToUI32( sign, sig, roundingMode, exact SOFTFLOAT_STATE_ARG_COMMA );
 
 }
Index: trunk/src/libs/softfloat-3e/source/extF80_to_ui32_r_minMag.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/extF80_to_ui32_r_minMag.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/extF80_to_ui32_r_minMag.c	(revision 94558)
@@ -42,5 +42,5 @@
 #include "softfloat.h"
 
-uint_fast32_t extF80_to_ui32_r_minMag( extFloat80_t a, bool exact )
+uint_fast32_t extF80_to_ui32_r_minMag( extFloat80_t a, bool exact SOFTFLOAT_STATE_DECL_COMMA )
 {
     union { struct extFloat80M s; extFloat80_t f; } uA;
@@ -71,5 +71,5 @@
     sign = signExtF80UI64( uiA64 );
     if ( sign || (shiftDist < 32) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
         return
             (exp == 0x7FFF) && (sig & UINT64_C( 0x7FFFFFFFFFFFFFFF ))
Index: trunk/src/libs/softfloat-3e/source/extF80_to_ui64.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/extF80_to_ui64.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/extF80_to_ui64.c	(revision 94558)
@@ -43,5 +43,5 @@
 
 uint_fast64_t
- extF80_to_ui64( extFloat80_t a, uint_fast8_t roundingMode, bool exact )
+ extF80_to_ui64( extFloat80_t a, uint_fast8_t roundingMode, bool exact SOFTFLOAT_STATE_DECL_COMMA )
 {
     union { struct extFloat80M s; extFloat80_t f; } uA;
@@ -65,5 +65,5 @@
     shiftDist = 0x403E - exp;
     if ( shiftDist < 0 ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
         return
             (exp == 0x7FFF) && (sig & UINT64_C( 0x7FFFFFFFFFFFFFFF ))
@@ -79,5 +79,5 @@
         sigExtra = sig64Extra.extra;
     }
-    return softfloat_roundToUI64( sign, sig, sigExtra, roundingMode, exact );
+    return softfloat_roundToUI64( sign, sig, sigExtra, roundingMode, exact SOFTFLOAT_STATE_ARG_COMMA );
 
 }
Index: trunk/src/libs/softfloat-3e/source/extF80_to_ui64_r_minMag.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/extF80_to_ui64_r_minMag.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/extF80_to_ui64_r_minMag.c	(revision 94558)
@@ -42,5 +42,5 @@
 #include "softfloat.h"
 
-uint_fast64_t extF80_to_ui64_r_minMag( extFloat80_t a, bool exact )
+uint_fast64_t extF80_to_ui64_r_minMag( extFloat80_t a, bool exact SOFTFLOAT_STATE_DECL_COMMA )
 {
     union { struct extFloat80M s; extFloat80_t f; } uA;
@@ -71,5 +71,5 @@
     sign = signExtF80UI64( uiA64 );
     if ( sign || (shiftDist < 0) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
         return
             (exp == 0x7FFF) && (sig & UINT64_C( 0x7FFFFFFFFFFFFFFF ))
Index: trunk/src/libs/softfloat-3e/source/f128M_add.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f128M_add.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f128M_add.c	(revision 94558)
@@ -44,5 +44,5 @@
 
 void
- f128M_add( const float128_t *aPtr, const float128_t *bPtr, float128_t *zPtr )
+ f128M_add( const float128_t *aPtr, const float128_t *bPtr, float128_t *zPtr SOFTFLOAT_STATE_DECL_COMMA )
 {
     const uint64_t *aWPtr, *bWPtr;
@@ -54,5 +54,5 @@
     float128_t
         (*magsFuncPtr)(
-            uint_fast64_t, uint_fast64_t, uint_fast64_t, uint_fast64_t, bool );
+            uint_fast64_t, uint_fast64_t, uint_fast64_t, uint_fast64_t, bool SOFTFLOAT_STATE_DECL_COMMA );
 #endif
 
@@ -67,12 +67,12 @@
 #if defined INLINE_LEVEL && (2 <= INLINE_LEVEL)
     if ( signA == signB ) {
-        *zPtr = softfloat_addMagsF128( uiA64, uiA0, uiB64, uiB0, signA );
+        *zPtr = softfloat_addMagsF128( uiA64, uiA0, uiB64, uiB0, signA SOFTFLOAT_STATE_ARG_COMMA );
     } else {
-        *zPtr = softfloat_subMagsF128( uiA64, uiA0, uiB64, uiB0, signA );
+        *zPtr = softfloat_subMagsF128( uiA64, uiA0, uiB64, uiB0, signA SOFTFLOAT_STATE_ARG_COMMA );
     }
 #else
     magsFuncPtr =
         (signA == signB) ? softfloat_addMagsF128 : softfloat_subMagsF128;
-    *zPtr = (*magsFuncPtr)( uiA64, uiA0, uiB64, uiB0, signA );
+    *zPtr = (*magsFuncPtr)( uiA64, uiA0, uiB64, uiB0, signA SOFTFLOAT_STATE_ARG_COMMA );
 #endif
 
@@ -82,5 +82,5 @@
 
 void
- f128M_add( const float128_t *aPtr, const float128_t *bPtr, float128_t *zPtr )
+ f128M_add( const float128_t *aPtr, const float128_t *bPtr, float128_t *zPtr SOFTFLOAT_STATE_DECL_COMMA )
 {
 
@@ -90,4 +90,5 @@
         (uint32_t *) zPtr,
         false
+        SOFTFLOAT_STATE_ARG_COMMA
     );
 
Index: trunk/src/libs/softfloat-3e/source/f128M_div.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f128M_div.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f128M_div.c	(revision 94558)
@@ -45,8 +45,8 @@
 
 void
- f128M_div( const float128_t *aPtr, const float128_t *bPtr, float128_t *zPtr )
+ f128M_div( const float128_t *aPtr, const float128_t *bPtr, float128_t *zPtr SOFTFLOAT_STATE_DECL_COMMA )
 {
 
-    *zPtr = f128_div( *aPtr, *bPtr );
+    *zPtr = f128_div( *aPtr, *bPtr SOFTFLOAT_STATE_ARG_COMMA );
 
 }
@@ -55,5 +55,5 @@
 
 void
- f128M_div( const float128_t *aPtr, const float128_t *bPtr, float128_t *zPtr )
+ f128M_div( const float128_t *aPtr, const float128_t *bPtr, float128_t *zPtr SOFTFLOAT_STATE_DECL_COMMA )
 {
     const uint32_t *aWPtr, *bWPtr;
@@ -89,5 +89,5 @@
     *------------------------------------------------------------------------*/
     if ( (expA == 0x7FFF) || (expB == 0x7FFF) ) {
-        if ( softfloat_tryPropagateNaNF128M( aWPtr, bWPtr, zWPtr ) ) return;
+        if ( softfloat_tryPropagateNaNF128M( aWPtr, bWPtr, zWPtr SOFTFLOAT_STATE_ARG_COMMA ) ) return;
         if ( expA == 0x7FFF ) {
             if ( expB == 0x7FFF ) goto invalid;
@@ -105,5 +105,5 @@
     }
     if ( expB == -128 ) {
-        softfloat_raiseFlags( softfloat_flag_infinite );
+        softfloat_raiseFlags( softfloat_flag_infinite SOFTFLOAT_STATE_ARG_COMMA );
         goto infinity;
     }
@@ -162,10 +162,10 @@
     y[indexWord( 5, 3 )] = q64;
     y[indexWord( 5, 4 )] = q64>>32;
-    softfloat_roundPackMToF128M( signZ, expZ, y, zWPtr );
+    softfloat_roundPackMToF128M( signZ, expZ, y, zWPtr SOFTFLOAT_STATE_ARG_COMMA );
     return;
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  invalid:
-    softfloat_invalidF128M( zWPtr );
+    softfloat_invalidF128M( zWPtr SOFTFLOAT_STATE_ARG_COMMA );
     return;
     /*------------------------------------------------------------------------
Index: trunk/src/libs/softfloat-3e/source/f128M_eq.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f128M_eq.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f128M_eq.c	(revision 94558)
@@ -44,8 +44,8 @@
 #ifdef SOFTFLOAT_FAST_INT64
 
-bool f128M_eq( const float128_t *aPtr, const float128_t *bPtr )
+bool f128M_eq( const float128_t *aPtr, const float128_t *bPtr SOFTFLOAT_STATE_DECL_COMMA )
 {
 
-    return f128_eq( *aPtr, *bPtr );
+    return f128_eq( *aPtr, *bPtr SOFTFLOAT_STATE_ARG_COMMA );
 
 }
@@ -53,5 +53,5 @@
 #else
 
-bool f128M_eq( const float128_t *aPtr, const float128_t *bPtr )
+bool f128M_eq( const float128_t *aPtr, const float128_t *bPtr SOFTFLOAT_STATE_DECL_COMMA )
 {
     const uint32_t *aWPtr, *bWPtr;
@@ -91,5 +91,5 @@
         || f128M_isSignalingNaN( (const float128_t *) bWPtr )
     ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
     }
     return false;
Index: trunk/src/libs/softfloat-3e/source/f128M_eq_signaling.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f128M_eq_signaling.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f128M_eq_signaling.c	(revision 94558)
@@ -44,8 +44,8 @@
 #ifdef SOFTFLOAT_FAST_INT64
 
-bool f128M_eq_signaling( const float128_t *aPtr, const float128_t *bPtr )
+bool f128M_eq_signaling( const float128_t *aPtr, const float128_t *bPtr SOFTFLOAT_STATE_DECL_COMMA )
 {
 
-    return f128_eq_signaling( *aPtr, *bPtr );
+    return f128_eq_signaling( *aPtr, *bPtr SOFTFLOAT_STATE_ARG_COMMA );
 
 }
@@ -53,5 +53,5 @@
 #else
 
-bool f128M_eq_signaling( const float128_t *aPtr, const float128_t *bPtr )
+bool f128M_eq_signaling( const float128_t *aPtr, const float128_t *bPtr SOFTFLOAT_STATE_DECL_COMMA )
 {
     const uint32_t *aWPtr, *bWPtr;
@@ -63,5 +63,5 @@
     bWPtr = (const uint32_t *) bPtr;
     if ( softfloat_isNaNF128M( aWPtr ) || softfloat_isNaNF128M( bWPtr ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
         return false;
     }
Index: trunk/src/libs/softfloat-3e/source/f128M_le.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f128M_le.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f128M_le.c	(revision 94558)
@@ -43,8 +43,8 @@
 #ifdef SOFTFLOAT_FAST_INT64
 
-bool f128M_le( const float128_t *aPtr, const float128_t *bPtr )
+bool f128M_le( const float128_t *aPtr, const float128_t *bPtr SOFTFLOAT_STATE_DECL_COMMA )
 {
 
-    return f128_le( *aPtr, *bPtr );
+    return f128_le( *aPtr, *bPtr SOFTFLOAT_STATE_ARG_COMMA );
 
 }
@@ -52,5 +52,5 @@
 #else
 
-bool f128M_le( const float128_t *aPtr, const float128_t *bPtr )
+bool f128M_le( const float128_t *aPtr, const float128_t *bPtr SOFTFLOAT_STATE_DECL_COMMA )
 {
     const uint32_t *aWPtr, *bWPtr;
@@ -62,5 +62,5 @@
     bWPtr = (const uint32_t *) bPtr;
     if ( softfloat_isNaNF128M( aWPtr ) || softfloat_isNaNF128M( bWPtr ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
         return false;
     }
Index: trunk/src/libs/softfloat-3e/source/f128M_le_quiet.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f128M_le_quiet.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f128M_le_quiet.c	(revision 94558)
@@ -44,8 +44,8 @@
 #ifdef SOFTFLOAT_FAST_INT64
 
-bool f128M_le_quiet( const float128_t *aPtr, const float128_t *bPtr )
+bool f128M_le_quiet( const float128_t *aPtr, const float128_t *bPtr SOFTFLOAT_STATE_DECL_COMMA )
 {
 
-    return f128_le_quiet( *aPtr, *bPtr );
+    return f128_le_quiet( *aPtr, *bPtr SOFTFLOAT_STATE_ARG_COMMA );
 
 }
@@ -53,5 +53,5 @@
 #else
 
-bool f128M_le_quiet( const float128_t *aPtr, const float128_t *bPtr )
+bool f128M_le_quiet( const float128_t *aPtr, const float128_t *bPtr SOFTFLOAT_STATE_DECL_COMMA )
 {
     const uint32_t *aWPtr, *bWPtr;
@@ -64,5 +64,5 @@
     if ( softfloat_isNaNF128M( aWPtr ) || softfloat_isNaNF128M( bWPtr ) ) {
         if ( f128M_isSignalingNaN( aPtr ) || f128M_isSignalingNaN( bPtr ) ) {
-            softfloat_raiseFlags( softfloat_flag_invalid );
+            softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
         }
         return false;
Index: trunk/src/libs/softfloat-3e/source/f128M_lt.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f128M_lt.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f128M_lt.c	(revision 94558)
@@ -43,8 +43,8 @@
 #ifdef SOFTFLOAT_FAST_INT64
 
-bool f128M_lt( const float128_t *aPtr, const float128_t *bPtr )
+bool f128M_lt( const float128_t *aPtr, const float128_t *bPtr SOFTFLOAT_STATE_DECL_COMMA )
 {
 
-    return f128_lt( *aPtr, *bPtr );
+    return f128_lt( *aPtr, *bPtr SOFTFLOAT_STATE_ARG_COMMA );
 
 }
@@ -52,5 +52,5 @@
 #else
 
-bool f128M_lt( const float128_t *aPtr, const float128_t *bPtr )
+bool f128M_lt( const float128_t *aPtr, const float128_t *bPtr SOFTFLOAT_STATE_DECL_COMMA )
 {
     const uint32_t *aWPtr, *bWPtr;
@@ -62,5 +62,5 @@
     bWPtr = (const uint32_t *) bPtr;
     if ( softfloat_isNaNF128M( aWPtr ) || softfloat_isNaNF128M( bWPtr ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
         return false;
     }
Index: trunk/src/libs/softfloat-3e/source/f128M_lt_quiet.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f128M_lt_quiet.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f128M_lt_quiet.c	(revision 94558)
@@ -44,8 +44,8 @@
 #ifdef SOFTFLOAT_FAST_INT64
 
-bool f128M_lt_quiet( const float128_t *aPtr, const float128_t *bPtr )
+bool f128M_lt_quiet( const float128_t *aPtr, const float128_t *bPtr SOFTFLOAT_STATE_DECL_COMMA )
 {
 
-    return f128_lt_quiet( *aPtr, *bPtr );
+    return f128_lt_quiet( *aPtr, *bPtr SOFTFLOAT_STATE_ARG_COMMA );
 
 }
@@ -53,5 +53,5 @@
 #else
 
-bool f128M_lt_quiet( const float128_t *aPtr, const float128_t *bPtr )
+bool f128M_lt_quiet( const float128_t *aPtr, const float128_t *bPtr SOFTFLOAT_STATE_DECL_COMMA )
 {
     const uint32_t *aWPtr, *bWPtr;
@@ -64,5 +64,5 @@
     if ( softfloat_isNaNF128M( aWPtr ) || softfloat_isNaNF128M( bWPtr ) ) {
         if ( f128M_isSignalingNaN( aPtr ) || f128M_isSignalingNaN( bPtr ) ) {
-            softfloat_raiseFlags( softfloat_flag_invalid );
+            softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
         }
         return false;
Index: trunk/src/libs/softfloat-3e/source/f128M_mul.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f128M_mul.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f128M_mul.c	(revision 94558)
@@ -45,8 +45,8 @@
 
 void
- f128M_mul( const float128_t *aPtr, const float128_t *bPtr, float128_t *zPtr )
+ f128M_mul( const float128_t *aPtr, const float128_t *bPtr, float128_t *zPtr SOFTFLOAT_STATE_DECL_COMMA )
 {
 
-    *zPtr = f128_mul( *aPtr, *bPtr );
+    *zPtr = f128_mul( *aPtr, *bPtr SOFTFLOAT_STATE_ARG_COMMA );
 
 }
@@ -55,5 +55,5 @@
 
 void
- f128M_mul( const float128_t *aPtr, const float128_t *bPtr, float128_t *zPtr )
+ f128M_mul( const float128_t *aPtr, const float128_t *bPtr, float128_t *zPtr SOFTFLOAT_STATE_DECL_COMMA )
 {
     const uint32_t *aWPtr, *bWPtr;
@@ -86,5 +86,5 @@
     *------------------------------------------------------------------------*/
     if ( (expA == 0x7FFF) || (expB == 0x7FFF) ) {
-        if ( softfloat_tryPropagateNaNF128M( aWPtr, bWPtr, zWPtr ) ) return;
+        if ( softfloat_tryPropagateNaNF128M( aWPtr, bWPtr, zWPtr SOFTFLOAT_STATE_ARG_COMMA ) ) return;
         ptr = aWPtr;
         if ( ! expA ) goto possiblyInvalid;
@@ -97,5 +97,5 @@
                               | ptr[indexWord( 4, 0 )])
             ) {
-                softfloat_invalidF128M( zWPtr );
+                softfloat_invalidF128M( zWPtr SOFTFLOAT_STATE_ARG_COMMA );
                 return;
             }
@@ -141,5 +141,5 @@
     }
     softfloat_shortShiftLeft160M( extSigZPtr, shiftDist, extSigZPtr );
-    softfloat_roundPackMToF128M( signZ, expZ, extSigZPtr, zWPtr );
+    softfloat_roundPackMToF128M( signZ, expZ, extSigZPtr, zWPtr SOFTFLOAT_STATE_ARG_COMMA );
     return;
     /*------------------------------------------------------------------------
Index: trunk/src/libs/softfloat-3e/source/f128M_mulAdd.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f128M_mulAdd.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f128M_mulAdd.c	(revision 94558)
@@ -48,4 +48,5 @@
      const float128_t *cPtr,
      float128_t *zPtr
+     SOFTFLOAT_STATE_DECL_COMMA
  )
 {
@@ -64,5 +65,5 @@
     uiC64 = cWPtr[indexWord( 2, 1 )];
     uiC0  = cWPtr[indexWord( 2, 0 )];
-    *zPtr = softfloat_mulAddF128( uiA64, uiA0, uiB64, uiB0, uiC64, uiC0, 0 );
+    *zPtr = softfloat_mulAddF128( uiA64, uiA0, uiB64, uiB0, uiC64, uiC0, 0 SOFTFLOAT_STATE_ARG_COMMA );
 
 }
@@ -76,4 +77,5 @@
      const float128_t *cPtr,
      float128_t *zPtr
+     SOFTFLOAT_STATE_DECL_COMMA
  )
 {
@@ -85,4 +87,5 @@
         (uint32_t *) zPtr,
         0
+        SOFTFLOAT_STATE_ARG_COMMA
     );
 
Index: trunk/src/libs/softfloat-3e/source/f128M_rem.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f128M_rem.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f128M_rem.c	(revision 94558)
@@ -45,8 +45,8 @@
 
 void
- f128M_rem( const float128_t *aPtr, const float128_t *bPtr, float128_t *zPtr )
+ f128M_rem( const float128_t *aPtr, const float128_t *bPtr, float128_t *zPtr SOFTFLOAT_STATE_DECL_COMMA )
 {
 
-    *zPtr = f128_rem( *aPtr, *bPtr );
+    *zPtr = f128_rem( *aPtr, *bPtr SOFTFLOAT_STATE_ARG_COMMA );
 
 }
@@ -55,5 +55,5 @@
 
 void
- f128M_rem( const float128_t *aPtr, const float128_t *bPtr, float128_t *zPtr )
+ f128M_rem( const float128_t *aPtr, const float128_t *bPtr, float128_t *zPtr SOFTFLOAT_STATE_DECL_COMMA )
 {
     const uint32_t *aWPtr, *bWPtr;
@@ -80,5 +80,5 @@
     *------------------------------------------------------------------------*/
     if ( (expA == 0x7FFF) || (expB == 0x7FFF) ) {
-        if ( softfloat_tryPropagateNaNF128M( aWPtr, bWPtr, zWPtr ) ) return;
+        if ( softfloat_tryPropagateNaNF128M( aWPtr, bWPtr, zWPtr SOFTFLOAT_STATE_ARG_COMMA ) ) return;
         if ( expA == 0x7FFF ) goto invalid;
         goto copyA;
@@ -162,10 +162,10 @@
     remPtr -= indexMultiwordLo( 5, 4 );
     remPtr[indexWordHi( 5 )] = 0;
-    softfloat_normRoundPackMToF128M( signRem, expB + 18, remPtr, zWPtr );
+    softfloat_normRoundPackMToF128M( signRem, expB + 18, remPtr, zWPtr SOFTFLOAT_STATE_ARG_COMMA );
     return;
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  invalid:
-    softfloat_invalidF128M( zWPtr );
+    softfloat_invalidF128M( zWPtr SOFTFLOAT_STATE_ARG_COMMA );
     return;
     /*------------------------------------------------------------------------
Index: trunk/src/libs/softfloat-3e/source/f128M_roundToInt.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f128M_roundToInt.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f128M_roundToInt.c	(revision 94558)
@@ -50,8 +50,9 @@
      bool exact,
      float128_t *zPtr
+     SOFTFLOAT_STATE_DECL_COMMA
  )
 {
 
-    *zPtr = f128_roundToInt( *aPtr, roundingMode, exact );
+    *zPtr = f128_roundToInt( *aPtr, roundingMode, exact SOFTFLOAT_STATE_ARG_COMMA );
 
 }
@@ -65,4 +66,5 @@
      bool exact,
      float128_t *zPtr
+     SOFTFLOAT_STATE_DECL_COMMA
  )
 {
@@ -134,5 +136,5 @@
                                 | aWPtr[indexWord( 4, 0 )]))
         ) {
-            softfloat_propagateNaNF128M( aWPtr, 0, zWPtr );
+            softfloat_propagateNaNF128M( aWPtr, 0, zWPtr SOFTFLOAT_STATE_ARG_COMMA );
             return;
         }
Index: trunk/src/libs/softfloat-3e/source/f128M_sqrt.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f128M_sqrt.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f128M_sqrt.c	(revision 94558)
@@ -44,8 +44,8 @@
 #ifdef SOFTFLOAT_FAST_INT64
 
-void f128M_sqrt( const float128_t *aPtr, float128_t *zPtr )
+void f128M_sqrt( const float128_t *aPtr, float128_t *zPtr SOFTFLOAT_STATE_DECL_COMMA )
 {
 
-    *zPtr = f128_sqrt( *aPtr );
+    *zPtr = f128_sqrt( *aPtr SOFTFLOAT_STATE_ARG_COMMA );
 
 }
@@ -53,5 +53,5 @@
 #else
 
-void f128M_sqrt( const float128_t *aPtr, float128_t *zPtr )
+void f128M_sqrt( const float128_t *aPtr, float128_t *zPtr SOFTFLOAT_STATE_DECL_COMMA )
 {
     const uint32_t *aWPtr;
@@ -86,5 +86,5 @@
                         | aWPtr[indexWord( 4, 0 )])
         ) {
-            softfloat_propagateNaNF128M( aWPtr, 0, zWPtr );
+            softfloat_propagateNaNF128M( aWPtr, 0, zWPtr SOFTFLOAT_STATE_ARG_COMMA );
             return;
         }
@@ -208,10 +208,10 @@
         }
     }
-    softfloat_roundPackMToF128M( 0, expZ, y, zWPtr );
+    softfloat_roundPackMToF128M( 0, expZ, y, zWPtr SOFTFLOAT_STATE_ARG_COMMA );
     return;
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  invalid:
-    softfloat_invalidF128M( zWPtr );
+    softfloat_invalidF128M( zWPtr SOFTFLOAT_STATE_ARG_COMMA );
     return;
     /*------------------------------------------------------------------------
Index: trunk/src/libs/softfloat-3e/source/f128M_sub.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f128M_sub.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f128M_sub.c	(revision 94558)
@@ -44,5 +44,5 @@
 
 void
- f128M_sub( const float128_t *aPtr, const float128_t *bPtr, float128_t *zPtr )
+ f128M_sub( const float128_t *aPtr, const float128_t *bPtr, float128_t *zPtr SOFTFLOAT_STATE_DECL_COMMA )
 {
     const uint64_t *aWPtr, *bWPtr;
@@ -54,5 +54,5 @@
     float128_t
         (*magsFuncPtr)(
-            uint_fast64_t, uint_fast64_t, uint_fast64_t, uint_fast64_t, bool );
+            uint_fast64_t, uint_fast64_t, uint_fast64_t, uint_fast64_t, bool SOFTFLOAT_STATE_DECL_COMMA );
 #endif
 
@@ -67,12 +67,12 @@
 #if defined INLINE_LEVEL && (2 <= INLINE_LEVEL)
     if ( signA == signB ) {
-        *zPtr = softfloat_subMagsF128( uiA64, uiA0, uiB64, uiB0, signA );
+        *zPtr = softfloat_subMagsF128( uiA64, uiA0, uiB64, uiB0, signA SOFTFLOAT_STATE_ARG_COMMA );
     } else {
-        *zPtr = softfloat_addMagsF128( uiA64, uiA0, uiB64, uiB0, signA );
+        *zPtr = softfloat_addMagsF128( uiA64, uiA0, uiB64, uiB0, signA SOFTFLOAT_STATE_ARG_COMMA );
     }
 #else
     magsFuncPtr =
         (signA == signB) ? softfloat_subMagsF128 : softfloat_addMagsF128;
-    *zPtr = (*magsFuncPtr)( uiA64, uiA0, uiB64, uiB0, signA );
+    *zPtr = (*magsFuncPtr)( uiA64, uiA0, uiB64, uiB0, signA SOFTFLOAT_STATE_ARG_COMMA );
 #endif
 
@@ -82,5 +82,5 @@
 
 void
- f128M_sub( const float128_t *aPtr, const float128_t *bPtr, float128_t *zPtr )
+ f128M_sub( const float128_t *aPtr, const float128_t *bPtr, float128_t *zPtr SOFTFLOAT_STATE_DECL_COMMA )
 {
 
@@ -90,4 +90,5 @@
         (uint32_t *) zPtr,
         true
+        SOFTFLOAT_STATE_ARG_COMMA
     );
 
Index: trunk/src/libs/softfloat-3e/source/f128M_to_extF80M.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f128M_to_extF80M.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f128M_to_extF80M.c	(revision 94558)
@@ -44,8 +44,8 @@
 #ifdef SOFTFLOAT_FAST_INT64
 
-void f128M_to_extF80M( const float128_t *aPtr, extFloat80_t *zPtr )
+void f128M_to_extF80M( const float128_t *aPtr, extFloat80_t *zPtr SOFTFLOAT_STATE_DECL_COMMA )
 {
 
-    *zPtr = f128_to_extF80( *aPtr );
+    *zPtr = f128_to_extF80( *aPtr SOFTFLOAT_STATE_ARG_COMMA );
 
 }
@@ -53,5 +53,5 @@
 #else
 
-void f128M_to_extF80M( const float128_t *aPtr, extFloat80_t *zPtr )
+void f128M_to_extF80M( const float128_t *aPtr, extFloat80_t *zPtr SOFTFLOAT_STATE_DECL_COMMA )
 {
     const uint32_t *aWPtr;
@@ -76,5 +76,5 @@
     if ( exp == 0x7FFF ) {
         if ( softfloat_isNaNF128M( aWPtr ) ) {
-            softfloat_f128MToCommonNaN( aWPtr, &commonNaN );
+            softfloat_f128MToCommonNaN( aWPtr, &commonNaN SOFTFLOAT_STATE_ARG_COMMA );
             softfloat_commonNaNToExtF80M( &commonNaN, zSPtr );
             return;
@@ -94,5 +94,5 @@
     if ( sig[indexWord( 4, 0 )] ) sig[indexWord( 4, 1 )] |= 1;
     softfloat_roundPackMToExtF80M(
-        sign, exp, &sig[indexMultiwordHi( 4, 3 )], 80, zSPtr );
+        sign, exp, &sig[indexMultiwordHi( 4, 3 )], 80, zSPtr SOFTFLOAT_STATE_ARG_COMMA );
 
 }
Index: trunk/src/libs/softfloat-3e/source/f128M_to_f16.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f128M_to_f16.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f128M_to_f16.c	(revision 94558)
@@ -44,8 +44,8 @@
 #ifdef SOFTFLOAT_FAST_INT64
 
-float16_t f128M_to_f16( const float128_t *aPtr )
+float16_t f128M_to_f16( const float128_t *aPtr SOFTFLOAT_STATE_DECL_COMMA )
 {
 
-    return f128_to_f16( *aPtr );
+    return f128_to_f16( *aPtr SOFTFLOAT_STATE_ARG_COMMA );
 
 }
@@ -53,5 +53,5 @@
 #else
 
-float16_t f128M_to_f16( const float128_t *aPtr )
+float16_t f128M_to_f16( const float128_t *aPtr SOFTFLOAT_STATE_DECL_COMMA )
 {
     const uint32_t *aWPtr;
@@ -81,5 +81,5 @@
     if ( exp == 0x7FFF ) {
         if ( frac32 ) {
-            softfloat_f128MToCommonNaN( aWPtr, &commonNaN );
+            softfloat_f128MToCommonNaN( aWPtr, &commonNaN SOFTFLOAT_STATE_ARG_COMMA );
             uiZ = softfloat_commonNaNToF16UI( &commonNaN );
         } else {
@@ -101,5 +101,5 @@
         if ( exp < -0x40 ) exp = -0x40;
     }
-    return softfloat_roundPackToF16( sign, exp, frac16 | 0x4000 );
+    return softfloat_roundPackToF16( sign, exp, frac16 | 0x4000 SOFTFLOAT_STATE_ARG_COMMA );
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
Index: trunk/src/libs/softfloat-3e/source/f128M_to_f32.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f128M_to_f32.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f128M_to_f32.c	(revision 94558)
@@ -44,8 +44,8 @@
 #ifdef SOFTFLOAT_FAST_INT64
 
-float32_t f128M_to_f32( const float128_t *aPtr )
+float32_t f128M_to_f32( const float128_t *aPtr SOFTFLOAT_STATE_DECL_COMMA )
 {
 
-    return f128_to_f32( *aPtr );
+    return f128_to_f32( *aPtr SOFTFLOAT_STATE_ARG_COMMA );
 
 }
@@ -53,5 +53,5 @@
 #else
 
-float32_t f128M_to_f32( const float128_t *aPtr )
+float32_t f128M_to_f32( const float128_t *aPtr SOFTFLOAT_STATE_DECL_COMMA )
 {
     const uint32_t *aWPtr;
@@ -77,5 +77,5 @@
     if ( exp == 0x7FFF ) {
         if ( frac64 ) {
-            softfloat_f128MToCommonNaN( aWPtr, &commonNaN );
+            softfloat_f128MToCommonNaN( aWPtr, &commonNaN SOFTFLOAT_STATE_ARG_COMMA );
             uiZ = softfloat_commonNaNToF32UI( &commonNaN );
         } else {
@@ -97,5 +97,5 @@
         if ( exp < -0x1000 ) exp = -0x1000;
     }
-    return softfloat_roundPackToF32( sign, exp, frac32 | 0x40000000 );
+    return softfloat_roundPackToF32( sign, exp, frac32 | 0x40000000 SOFTFLOAT_STATE_ARG_COMMA );
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
Index: trunk/src/libs/softfloat-3e/source/f128M_to_f64.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f128M_to_f64.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f128M_to_f64.c	(revision 94558)
@@ -44,8 +44,8 @@
 #ifdef SOFTFLOAT_FAST_INT64
 
-float64_t f128M_to_f64( const float128_t *aPtr )
+float64_t f128M_to_f64( const float128_t *aPtr SOFTFLOAT_STATE_DECL_COMMA )
 {
 
-    return f128_to_f64( *aPtr );
+    return f128_to_f64( *aPtr SOFTFLOAT_STATE_ARG_COMMA );
 
 }
@@ -53,5 +53,5 @@
 #else
 
-float64_t f128M_to_f64( const float128_t *aPtr )
+float64_t f128M_to_f64( const float128_t *aPtr SOFTFLOAT_STATE_DECL_COMMA )
 {
     const uint32_t *aWPtr;
@@ -76,5 +76,5 @@
     if ( exp == 0x7FFF ) {
         if ( frac64 || aWPtr[indexWord( 4, 1 )] | aWPtr[indexWord( 4, 0 )] ) {
-            softfloat_f128MToCommonNaN( aWPtr, &commonNaN );
+            softfloat_f128MToCommonNaN( aWPtr, &commonNaN SOFTFLOAT_STATE_ARG_COMMA );
             uiZ = softfloat_commonNaNToF64UI( &commonNaN );
         } else {
@@ -100,5 +100,5 @@
     return
         softfloat_roundPackToF64(
-            sign, exp, frac64 | UINT64_C( 0x4000000000000000 ) );
+            sign, exp, frac64 | UINT64_C( 0x4000000000000000 ) SOFTFLOAT_STATE_ARG_COMMA );
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
Index: trunk/src/libs/softfloat-3e/source/f128M_to_i32.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f128M_to_i32.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f128M_to_i32.c	(revision 94558)
@@ -45,8 +45,8 @@
 
 int_fast32_t
- f128M_to_i32( const float128_t *aPtr, uint_fast8_t roundingMode, bool exact )
+ f128M_to_i32( const float128_t *aPtr, uint_fast8_t roundingMode, bool exact SOFTFLOAT_STATE_DECL_COMMA )
 {
 
-    return f128_to_i32( *aPtr, roundingMode, exact );
+    return f128_to_i32( *aPtr, roundingMode, exact SOFTFLOAT_STATE_ARG_COMMA );
 
 }
@@ -55,5 +55,5 @@
 
 int_fast32_t
- f128M_to_i32( const float128_t *aPtr, uint_fast8_t roundingMode, bool exact )
+ f128M_to_i32( const float128_t *aPtr, uint_fast8_t roundingMode, bool exact SOFTFLOAT_STATE_DECL_COMMA )
 {
     const uint32_t *aWPtr;
@@ -81,5 +81,5 @@
         sign = 1;
 #else
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
         return i32_fromNaN;
 #endif
@@ -91,5 +91,5 @@
     shiftDist = 0x4023 - exp;
     if ( 0 < shiftDist ) sig64 = softfloat_shiftRightJam64( sig64, shiftDist );
-    return softfloat_roundToI32( sign, sig64, roundingMode, exact );
+    return softfloat_roundToI32( sign, sig64, roundingMode, exact SOFTFLOAT_STATE_ARG_COMMA );
 
 }
Index: trunk/src/libs/softfloat-3e/source/f128M_to_i32_r_minMag.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f128M_to_i32_r_minMag.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f128M_to_i32_r_minMag.c	(revision 94558)
@@ -44,8 +44,8 @@
 #ifdef SOFTFLOAT_FAST_INT64
 
-int_fast32_t f128M_to_i32_r_minMag( const float128_t *aPtr, bool exact )
+int_fast32_t f128M_to_i32_r_minMag( const float128_t *aPtr, bool exact SOFTFLOAT_STATE_DECL_COMMA )
 {
 
-    return f128_to_i32_r_minMag( *aPtr, exact );
+    return f128_to_i32_r_minMag( *aPtr, exact SOFTFLOAT_STATE_ARG_COMMA );
 
 }
@@ -53,5 +53,5 @@
 #else
 
-int_fast32_t f128M_to_i32_r_minMag( const float128_t *aPtr, bool exact )
+int_fast32_t f128M_to_i32_r_minMag( const float128_t *aPtr, bool exact SOFTFLOAT_STATE_DECL_COMMA )
 {
     const uint32_t *aWPtr;
@@ -96,5 +96,5 @@
     *------------------------------------------------------------------------*/
  invalid:
-    softfloat_raiseFlags( softfloat_flag_invalid );
+    softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
     return
         (exp == 0x7FFF) && sig64 ? i32_fromNaN
Index: trunk/src/libs/softfloat-3e/source/f128M_to_i64.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f128M_to_i64.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f128M_to_i64.c	(revision 94558)
@@ -45,8 +45,8 @@
 
 int_fast64_t
- f128M_to_i64( const float128_t *aPtr, uint_fast8_t roundingMode, bool exact )
+ f128M_to_i64( const float128_t *aPtr, uint_fast8_t roundingMode, bool exact SOFTFLOAT_STATE_DECL_COMMA )
 {
 
-    return f128_to_i64( *aPtr, roundingMode, exact );
+    return f128_to_i64( *aPtr, roundingMode, exact SOFTFLOAT_STATE_ARG_COMMA );
 
 }
@@ -55,5 +55,5 @@
 
 int_fast64_t
- f128M_to_i64( const float128_t *aPtr, uint_fast8_t roundingMode, bool exact )
+ f128M_to_i64( const float128_t *aPtr, uint_fast8_t roundingMode, bool exact SOFTFLOAT_STATE_DECL_COMMA )
 {
     const uint32_t *aWPtr;
@@ -76,5 +76,5 @@
     shiftDist = 0x404F - exp;
     if ( shiftDist < 17 ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
         return
             (exp == 0x7FFF)
@@ -95,5 +95,5 @@
     return
         softfloat_roundMToI64(
-            sign, sig + indexMultiwordLo( 4, 3 ), roundingMode, exact );
+            sign, sig + indexMultiwordLo( 4, 3 ), roundingMode, exact SOFTFLOAT_STATE_ARG_COMMA );
 
 }
Index: trunk/src/libs/softfloat-3e/source/f128M_to_i64_r_minMag.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f128M_to_i64_r_minMag.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f128M_to_i64_r_minMag.c	(revision 94558)
@@ -44,8 +44,8 @@
 #ifdef SOFTFLOAT_FAST_INT64
 
-int_fast64_t f128M_to_i64_r_minMag( const float128_t *aPtr, bool exact )
+int_fast64_t f128M_to_i64_r_minMag( const float128_t *aPtr, bool exact SOFTFLOAT_STATE_DECL_COMMA )
 {
 
-    return f128_to_i64_r_minMag( *aPtr, exact );
+    return f128_to_i64_r_minMag( *aPtr, exact SOFTFLOAT_STATE_ARG_COMMA );
 
 }
@@ -53,5 +53,5 @@
 #else
 
-int_fast64_t f128M_to_i64_r_minMag( const float128_t *aPtr, bool exact )
+int_fast64_t f128M_to_i64_r_minMag( const float128_t *aPtr, bool exact SOFTFLOAT_STATE_DECL_COMMA )
 {
     const uint32_t *aWPtr;
@@ -110,5 +110,5 @@
     *------------------------------------------------------------------------*/
  invalid:
-    softfloat_raiseFlags( softfloat_flag_invalid );
+    softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
     return
         (exp == 0x7FFF)
Index: trunk/src/libs/softfloat-3e/source/f128M_to_ui32.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f128M_to_ui32.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f128M_to_ui32.c	(revision 94558)
@@ -45,8 +45,8 @@
 
 uint_fast32_t
- f128M_to_ui32( const float128_t *aPtr, uint_fast8_t roundingMode, bool exact )
+ f128M_to_ui32( const float128_t *aPtr, uint_fast8_t roundingMode, bool exact SOFTFLOAT_STATE_DECL_COMMA )
 {
 
-    return f128_to_ui32( *aPtr, roundingMode, exact );
+    return f128_to_ui32( *aPtr, roundingMode, exact SOFTFLOAT_STATE_ARG_COMMA );
 
 }
@@ -55,5 +55,5 @@
 
 uint_fast32_t
- f128M_to_ui32( const float128_t *aPtr, uint_fast8_t roundingMode, bool exact )
+ f128M_to_ui32( const float128_t *aPtr, uint_fast8_t roundingMode, bool exact SOFTFLOAT_STATE_DECL_COMMA )
 {
     const uint32_t *aWPtr;
@@ -81,5 +81,5 @@
         sign = 1;
 #else
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
         return ui32_fromNaN;
 #endif
@@ -91,5 +91,5 @@
     shiftDist = 0x4023 - exp;
     if ( 0 < shiftDist ) sig64 = softfloat_shiftRightJam64( sig64, shiftDist );
-    return softfloat_roundToUI32( sign, sig64, roundingMode, exact );
+    return softfloat_roundToUI32( sign, sig64, roundingMode, exact SOFTFLOAT_STATE_ARG_COMMA );
 
 }
Index: trunk/src/libs/softfloat-3e/source/f128M_to_ui32_r_minMag.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f128M_to_ui32_r_minMag.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f128M_to_ui32_r_minMag.c	(revision 94558)
@@ -44,8 +44,8 @@
 #ifdef SOFTFLOAT_FAST_INT64
 
-uint_fast32_t f128M_to_ui32_r_minMag( const float128_t *aPtr, bool exact )
+uint_fast32_t f128M_to_ui32_r_minMag( const float128_t *aPtr, bool exact SOFTFLOAT_STATE_DECL_COMMA )
 {
 
-    return f128_to_ui32_r_minMag( *aPtr, exact );
+    return f128_to_ui32_r_minMag( *aPtr, exact SOFTFLOAT_STATE_ARG_COMMA );
 
 }
@@ -53,5 +53,5 @@
 #else
 
-uint_fast32_t f128M_to_ui32_r_minMag( const float128_t *aPtr, bool exact )
+uint_fast32_t f128M_to_ui32_r_minMag( const float128_t *aPtr, bool exact SOFTFLOAT_STATE_DECL_COMMA )
 {
     const uint32_t *aWPtr;
@@ -83,5 +83,5 @@
     sign = signF128UI96( uiA96 );
     if ( sign || (shiftDist < 17) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
         return
             (exp == 0x7FFF) && sig64 ? ui32_fromNaN
Index: trunk/src/libs/softfloat-3e/source/f128M_to_ui64.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f128M_to_ui64.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f128M_to_ui64.c	(revision 94558)
@@ -45,8 +45,8 @@
 
 uint_fast64_t
- f128M_to_ui64( const float128_t *aPtr, uint_fast8_t roundingMode, bool exact )
+ f128M_to_ui64( const float128_t *aPtr, uint_fast8_t roundingMode, bool exact SOFTFLOAT_STATE_DECL_COMMA )
 {
 
-    return f128_to_ui64( *aPtr, roundingMode, exact );
+    return f128_to_ui64( *aPtr, roundingMode, exact SOFTFLOAT_STATE_ARG_COMMA );
 
 }
@@ -55,5 +55,5 @@
 
 uint_fast64_t
- f128M_to_ui64( const float128_t *aPtr, uint_fast8_t roundingMode, bool exact )
+ f128M_to_ui64( const float128_t *aPtr, uint_fast8_t roundingMode, bool exact SOFTFLOAT_STATE_DECL_COMMA )
 {
     const uint32_t *aWPtr;
@@ -76,5 +76,5 @@
     shiftDist = 0x404F - exp;
     if ( shiftDist < 17 ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
         return
             (exp == 0x7FFF)
@@ -95,5 +95,5 @@
     return
         softfloat_roundMToUI64(
-            sign, sig + indexMultiwordLo( 4, 3 ), roundingMode, exact );
+            sign, sig + indexMultiwordLo( 4, 3 ), roundingMode, exact SOFTFLOAT_STATE_ARG_COMMA);
 
 }
Index: trunk/src/libs/softfloat-3e/source/f128M_to_ui64_r_minMag.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f128M_to_ui64_r_minMag.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f128M_to_ui64_r_minMag.c	(revision 94558)
@@ -44,8 +44,8 @@
 #ifdef SOFTFLOAT_FAST_INT64
 
-uint_fast64_t f128M_to_ui64_r_minMag( const float128_t *aPtr, bool exact )
+uint_fast64_t f128M_to_ui64_r_minMag( const float128_t *aPtr, bool exact SOFTFLOAT_STATE_DECL_COMMA )
 {
 
-    return f128_to_ui64_r_minMag( *aPtr, exact );
+    return f128_to_ui64_r_minMag( *aPtr, exact SOFTFLOAT_STATE_ARG_COMMA );
 
 }
@@ -53,5 +53,5 @@
 #else
 
-uint_fast64_t f128M_to_ui64_r_minMag( const float128_t *aPtr, bool exact )
+uint_fast64_t f128M_to_ui64_r_minMag( const float128_t *aPtr, bool exact SOFTFLOAT_STATE_DECL_COMMA )
 {
     const uint32_t *aWPtr;
@@ -100,5 +100,5 @@
     *------------------------------------------------------------------------*/
  invalid:
-    softfloat_raiseFlags( softfloat_flag_invalid );
+    softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
     return
         (exp == 0x7FFF)
Index: trunk/src/libs/softfloat-3e/source/f128_add.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f128_add.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f128_add.c	(revision 94558)
@@ -41,5 +41,5 @@
 #include "softfloat.h"
 
-float128_t f128_add( float128_t a, float128_t b )
+float128_t f128_add( float128_t a, float128_t b SOFTFLOAT_STATE_DECL_COMMA )
 {
     union ui128_f128 uA;
@@ -52,5 +52,5 @@
     float128_t
         (*magsFuncPtr)(
-            uint_fast64_t, uint_fast64_t, uint_fast64_t, uint_fast64_t, bool );
+            uint_fast64_t, uint_fast64_t, uint_fast64_t, uint_fast64_t, bool SOFTFLOAT_STATE_DECL_COMMA );
 #endif
 
@@ -65,12 +65,12 @@
 #if defined INLINE_LEVEL && (2 <= INLINE_LEVEL)
     if ( signA == signB ) {
-        return softfloat_addMagsF128( uiA64, uiA0, uiB64, uiB0, signA );
+        return softfloat_addMagsF128( uiA64, uiA0, uiB64, uiB0, signA SOFTFLOAT_STATE_ARG_COMMA );
     } else {
-        return softfloat_subMagsF128( uiA64, uiA0, uiB64, uiB0, signA );
+        return softfloat_subMagsF128( uiA64, uiA0, uiB64, uiB0, signA SOFTFLOAT_STATE_ARG_COMMA );
     }
 #else
     magsFuncPtr =
         (signA == signB) ? softfloat_addMagsF128 : softfloat_subMagsF128;
-    return (*magsFuncPtr)( uiA64, uiA0, uiB64, uiB0, signA );
+    return (*magsFuncPtr)( uiA64, uiA0, uiB64, uiB0, signA SOFTFLOAT_STATE_ARG_COMMA );
 #endif
 
Index: trunk/src/libs/softfloat-3e/source/f128_div.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f128_div.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f128_div.c	(revision 94558)
@@ -42,5 +42,5 @@
 #include "softfloat.h"
 
-float128_t f128_div( float128_t a, float128_t b )
+float128_t f128_div( float128_t a, float128_t b SOFTFLOAT_STATE_DECL_COMMA )
 {
     union ui128_f128 uA;
@@ -104,5 +104,5 @@
         if ( ! (sigB.v64 | sigB.v0) ) {
             if ( ! (expA | sigA.v64 | sigA.v0) ) goto invalid;
-            softfloat_raiseFlags( softfloat_flag_infinite );
+            softfloat_raiseFlags( softfloat_flag_infinite SOFTFLOAT_STATE_ARG_COMMA );
             goto infinity;
         }
@@ -168,14 +168,14 @@
         );
     return
-        softfloat_roundPackToF128( signZ, expZ, sigZ.v64, sigZ.v0, sigZExtra );
+        softfloat_roundPackToF128( signZ, expZ, sigZ.v64, sigZ.v0, sigZExtra SOFTFLOAT_STATE_ARG_COMMA );
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  propagateNaN:
-    uiZ = softfloat_propagateNaNF128UI( uiA64, uiA0, uiB64, uiB0 );
+    uiZ = softfloat_propagateNaNF128UI( uiA64, uiA0, uiB64, uiB0 SOFTFLOAT_STATE_ARG_COMMA );
     goto uiZ;
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  invalid:
-    softfloat_raiseFlags( softfloat_flag_invalid );
+    softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
     uiZ.v64 = defaultNaNF128UI64;
     uiZ.v0  = defaultNaNF128UI0;
Index: trunk/src/libs/softfloat-3e/source/f128_eq.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f128_eq.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f128_eq.c	(revision 94558)
@@ -42,5 +42,5 @@
 #include "softfloat.h"
 
-bool f128_eq( float128_t a, float128_t b )
+bool f128_eq( float128_t a, float128_t b SOFTFLOAT_STATE_DECL_COMMA )
 {
     union ui128_f128 uA;
@@ -60,5 +60,5 @@
             || softfloat_isSigNaNF128UI( uiB64, uiB0 )
         ) {
-            softfloat_raiseFlags( softfloat_flag_invalid );
+            softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
         }
         return false;
Index: trunk/src/libs/softfloat-3e/source/f128_eq_signaling.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f128_eq_signaling.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f128_eq_signaling.c	(revision 94558)
@@ -41,5 +41,5 @@
 #include "softfloat.h"
 
-bool f128_eq_signaling( float128_t a, float128_t b )
+bool f128_eq_signaling( float128_t a, float128_t b SOFTFLOAT_STATE_DECL_COMMA )
 {
     union ui128_f128 uA;
@@ -55,5 +55,5 @@
     uiB0  = uB.ui.v0;
     if ( isNaNF128UI( uiA64, uiA0 ) || isNaNF128UI( uiB64, uiB0 ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
         return false;
     }
Index: trunk/src/libs/softfloat-3e/source/f128_le.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f128_le.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f128_le.c	(revision 94558)
@@ -41,5 +41,5 @@
 #include "softfloat.h"
 
-bool f128_le( float128_t a, float128_t b )
+bool f128_le( float128_t a, float128_t b SOFTFLOAT_STATE_DECL_COMMA )
 {
     union ui128_f128 uA;
@@ -56,5 +56,5 @@
     uiB0  = uB.ui.v0;
     if ( isNaNF128UI( uiA64, uiA0 ) || isNaNF128UI( uiB64, uiB0 ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
         return false;
     }
Index: trunk/src/libs/softfloat-3e/source/f128_le_quiet.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f128_le_quiet.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f128_le_quiet.c	(revision 94558)
@@ -42,5 +42,5 @@
 #include "softfloat.h"
 
-bool f128_le_quiet( float128_t a, float128_t b )
+bool f128_le_quiet( float128_t a, float128_t b SOFTFLOAT_STATE_DECL_COMMA )
 {
     union ui128_f128 uA;
@@ -61,5 +61,5 @@
             || softfloat_isSigNaNF128UI( uiB64, uiB0 )
         ) {
-            softfloat_raiseFlags( softfloat_flag_invalid );
+            softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
         }
         return false;
Index: trunk/src/libs/softfloat-3e/source/f128_lt.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f128_lt.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f128_lt.c	(revision 94558)
@@ -41,5 +41,5 @@
 #include "softfloat.h"
 
-bool f128_lt( float128_t a, float128_t b )
+bool f128_lt( float128_t a, float128_t b SOFTFLOAT_STATE_DECL_COMMA )
 {
     union ui128_f128 uA;
@@ -56,5 +56,5 @@
     uiB0  = uB.ui.v0;
     if ( isNaNF128UI( uiA64, uiA0 ) || isNaNF128UI( uiB64, uiB0 ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
         return false;
     }
Index: trunk/src/libs/softfloat-3e/source/f128_lt_quiet.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f128_lt_quiet.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f128_lt_quiet.c	(revision 94558)
@@ -42,5 +42,5 @@
 #include "softfloat.h"
 
-bool f128_lt_quiet( float128_t a, float128_t b )
+bool f128_lt_quiet( float128_t a, float128_t b SOFTFLOAT_STATE_DECL_COMMA )
 {
     union ui128_f128 uA;
@@ -61,5 +61,5 @@
             || softfloat_isSigNaNF128UI( uiB64, uiB0 )
         ) {
-            softfloat_raiseFlags( softfloat_flag_invalid );
+            softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
         }
         return false;
Index: trunk/src/libs/softfloat-3e/source/f128_mul.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f128_mul.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f128_mul.c	(revision 94558)
@@ -42,5 +42,5 @@
 #include "softfloat.h"
 
-float128_t f128_mul( float128_t a, float128_t b )
+float128_t f128_mul( float128_t a, float128_t b SOFTFLOAT_STATE_DECL_COMMA )
 {
     union ui128_f128 uA;
@@ -133,9 +133,9 @@
     }
     return
-        softfloat_roundPackToF128( signZ, expZ, sigZ.v64, sigZ.v0, sigZExtra );
+        softfloat_roundPackToF128( signZ, expZ, sigZ.v64, sigZ.v0, sigZExtra SOFTFLOAT_STATE_ARG_COMMA );
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  propagateNaN:
-    uiZ = softfloat_propagateNaNF128UI( uiA64, uiA0, uiB64, uiB0 );
+    uiZ = softfloat_propagateNaNF128UI( uiA64, uiA0, uiB64, uiB0 SOFTFLOAT_STATE_ARG_COMMA );
     goto uiZ;
     /*------------------------------------------------------------------------
@@ -143,5 +143,5 @@
  infArg:
     if ( ! magBits ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
         uiZ.v64 = defaultNaNF128UI64;
         uiZ.v0  = defaultNaNF128UI0;
Index: trunk/src/libs/softfloat-3e/source/f128_mulAdd.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f128_mulAdd.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f128_mulAdd.c	(revision 94558)
@@ -40,5 +40,5 @@
 #include "softfloat.h"
 
-float128_t f128_mulAdd( float128_t a, float128_t b, float128_t c )
+float128_t f128_mulAdd( float128_t a, float128_t b, float128_t c SOFTFLOAT_STATE_DECL_COMMA )
 {
     union ui128_f128 uA;
@@ -58,5 +58,5 @@
     uiC64 = uC.ui.v64;
     uiC0  = uC.ui.v0;
-    return softfloat_mulAddF128( uiA64, uiA0, uiB64, uiB0, uiC64, uiC0, 0 );
+    return softfloat_mulAddF128( uiA64, uiA0, uiB64, uiB0, uiC64, uiC0, 0 SOFTFLOAT_STATE_ARG_COMMA );
 
 }
Index: trunk/src/libs/softfloat-3e/source/f128_rem.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f128_rem.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f128_rem.c	(revision 94558)
@@ -42,5 +42,5 @@
 #include "softfloat.h"
 
-float128_t f128_rem( float128_t a, float128_t b )
+float128_t f128_rem( float128_t a, float128_t b SOFTFLOAT_STATE_DECL_COMMA )
 {
     union ui128_f128 uA;
@@ -171,14 +171,14 @@
         rem = softfloat_sub128( 0, 0, rem.v64, rem.v0 );
     }
-    return softfloat_normRoundPackToF128( signRem, expB - 1, rem.v64, rem.v0 );
+    return softfloat_normRoundPackToF128( signRem, expB - 1, rem.v64, rem.v0 SOFTFLOAT_STATE_ARG_COMMA );
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  propagateNaN:
-    uiZ = softfloat_propagateNaNF128UI( uiA64, uiA0, uiB64, uiB0 );
+    uiZ = softfloat_propagateNaNF128UI( uiA64, uiA0, uiB64, uiB0 SOFTFLOAT_STATE_ARG_COMMA );
     goto uiZ;
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  invalid:
-    softfloat_raiseFlags( softfloat_flag_invalid );
+    softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
     uiZ.v64 = defaultNaNF128UI64;
     uiZ.v0  = defaultNaNF128UI0;
Index: trunk/src/libs/softfloat-3e/source/f128_roundToInt.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f128_roundToInt.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f128_roundToInt.c	(revision 94558)
@@ -44,5 +44,5 @@
 
 float128_t
- f128_roundToInt( float128_t a, uint_fast8_t roundingMode, bool exact )
+ f128_roundToInt( float128_t a, uint_fast8_t roundingMode, bool exact SOFTFLOAT_STATE_DECL_COMMA )
 {
     union ui128_f128 uA;
@@ -68,5 +68,5 @@
         if ( 0x406F <= exp ) {
             if ( (exp == 0x7FFF) && (fracF128UI64( uiA64 ) | uiA0) ) {
-                uiZ = softfloat_propagateNaNF128UI( uiA64, uiA0, 0, 0 );
+                uiZ = softfloat_propagateNaNF128UI( uiA64, uiA0, 0, 0 SOFTFLOAT_STATE_ARG_COMMA );
                 goto uiZ;
             }
Index: trunk/src/libs/softfloat-3e/source/f128_sqrt.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f128_sqrt.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f128_sqrt.c	(revision 94558)
@@ -42,5 +42,5 @@
 #include "softfloat.h"
 
-float128_t f128_sqrt( float128_t a )
+float128_t f128_sqrt( float128_t a SOFTFLOAT_STATE_DECL_COMMA )
 {
     union ui128_f128 uA;
@@ -74,5 +74,5 @@
     if ( expA == 0x7FFF ) {
         if ( sigA.v64 | sigA.v0 ) {
-            uiZ = softfloat_propagateNaNF128UI( uiA64, uiA0, 0, 0 );
+            uiZ = softfloat_propagateNaNF128UI( uiA64, uiA0, 0, 0 SOFTFLOAT_STATE_ARG_COMMA );
             goto uiZ;
         }
@@ -187,9 +187,9 @@
         }
     }
-    return softfloat_roundPackToF128( 0, expZ, sigZ.v64, sigZ.v0, sigZExtra );
+    return softfloat_roundPackToF128( 0, expZ, sigZ.v64, sigZ.v0, sigZExtra SOFTFLOAT_STATE_ARG_COMMA );
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  invalid:
-    softfloat_raiseFlags( softfloat_flag_invalid );
+    softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
     uiZ.v64 = defaultNaNF128UI64;
     uiZ.v0  = defaultNaNF128UI0;
Index: trunk/src/libs/softfloat-3e/source/f128_sub.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f128_sub.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f128_sub.c	(revision 94558)
@@ -41,5 +41,5 @@
 #include "softfloat.h"
 
-float128_t f128_sub( float128_t a, float128_t b )
+float128_t f128_sub( float128_t a, float128_t b SOFTFLOAT_STATE_DECL_COMMA )
 {
     union ui128_f128 uA;
@@ -52,5 +52,5 @@
     float128_t
         (*magsFuncPtr)(
-            uint_fast64_t, uint_fast64_t, uint_fast64_t, uint_fast64_t, bool );
+            uint_fast64_t, uint_fast64_t, uint_fast64_t, uint_fast64_t, bool SOFTFLOAT_STATE_DECL_COMMA );
 #endif
 
@@ -65,12 +65,12 @@
 #if defined INLINE_LEVEL && (2 <= INLINE_LEVEL)
     if ( signA == signB ) {
-        return softfloat_subMagsF128( uiA64, uiA0, uiB64, uiB0, signA );
+        return softfloat_subMagsF128( uiA64, uiA0, uiB64, uiB0, signA SOFTFLOAT_STATE_ARG_COMMA );
     } else {
-        return softfloat_addMagsF128( uiA64, uiA0, uiB64, uiB0, signA );
+        return softfloat_addMagsF128( uiA64, uiA0, uiB64, uiB0, signA SOFTFLOAT_STATE_ARG_COMMA );
     }
 #else
     magsFuncPtr =
         (signA == signB) ? softfloat_subMagsF128 : softfloat_addMagsF128;
-    return (*magsFuncPtr)( uiA64, uiA0, uiB64, uiB0, signA );
+    return (*magsFuncPtr)( uiA64, uiA0, uiB64, uiB0, signA SOFTFLOAT_STATE_ARG_COMMA );
 #endif
 
Index: trunk/src/libs/softfloat-3e/source/f128_to_extF80.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f128_to_extF80.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f128_to_extF80.c	(revision 94558)
@@ -42,5 +42,5 @@
 #include "softfloat.h"
 
-extFloat80_t f128_to_extF80( float128_t a )
+extFloat80_t f128_to_extF80( float128_t a SOFTFLOAT_STATE_DECL_COMMA )
 {
     union ui128_f128 uA;
@@ -70,5 +70,5 @@
     if ( exp == 0x7FFF ) {
         if ( frac64 | frac0 ) {
-            softfloat_f128UIToCommonNaN( uiA64, uiA0, &commonNaN );
+            softfloat_f128UIToCommonNaN( uiA64, uiA0, &commonNaN SOFTFLOAT_STATE_ARG_COMMA );
             uiZ = softfloat_commonNaNToExtF80UI( &commonNaN );
             uiZ64 = uiZ.v64;
@@ -98,5 +98,5 @@
         softfloat_shortShiftLeft128(
             frac64 | UINT64_C( 0x0001000000000000 ), frac0, 15 );
-    return softfloat_roundPackToExtF80( sign, exp, sig128.v64, sig128.v0, 80 );
+    return softfloat_roundPackToExtF80( sign, exp, sig128.v64, sig128.v0, 80 SOFTFLOAT_STATE_ARG_COMMA );
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
Index: trunk/src/libs/softfloat-3e/source/f128_to_f16.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f128_to_f16.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f128_to_f16.c	(revision 94558)
@@ -42,5 +42,5 @@
 #include "softfloat.h"
 
-float16_t f128_to_f16( float128_t a )
+float16_t f128_to_f16( float128_t a SOFTFLOAT_STATE_DECL_COMMA )
 {
     union ui128_f128 uA;
@@ -65,5 +65,5 @@
     if ( exp == 0x7FFF ) {
         if ( frac64 ) {
-            softfloat_f128UIToCommonNaN( uiA64, uiA0, &commonNaN );
+            softfloat_f128UIToCommonNaN( uiA64, uiA0, &commonNaN SOFTFLOAT_STATE_ARG_COMMA );
             uiZ = softfloat_commonNaNToF16UI( &commonNaN );
         } else {
@@ -85,5 +85,5 @@
         if ( exp < -0x40 ) exp = -0x40;
     }
-    return softfloat_roundPackToF16( sign, exp, frac16 | 0x4000 );
+    return softfloat_roundPackToF16( sign, exp, frac16 | 0x4000 SOFTFLOAT_STATE_ARG_COMMA );
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
Index: trunk/src/libs/softfloat-3e/source/f128_to_f32.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f128_to_f32.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f128_to_f32.c	(revision 94558)
@@ -42,5 +42,5 @@
 #include "softfloat.h"
 
-float32_t f128_to_f32( float128_t a )
+float32_t f128_to_f32( float128_t a SOFTFLOAT_STATE_DECL_COMMA )
 {
     union ui128_f128 uA;
@@ -65,5 +65,5 @@
     if ( exp == 0x7FFF ) {
         if ( frac64 ) {
-            softfloat_f128UIToCommonNaN( uiA64, uiA0, &commonNaN );
+            softfloat_f128UIToCommonNaN( uiA64, uiA0, &commonNaN SOFTFLOAT_STATE_ARG_COMMA );
             uiZ = softfloat_commonNaNToF32UI( &commonNaN );
         } else {
@@ -85,5 +85,5 @@
         if ( exp < -0x1000 ) exp = -0x1000;
     }
-    return softfloat_roundPackToF32( sign, exp, frac32 | 0x40000000 );
+    return softfloat_roundPackToF32( sign, exp, frac32 | 0x40000000 SOFTFLOAT_STATE_ARG_COMMA );
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
Index: trunk/src/libs/softfloat-3e/source/f128_to_f64.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f128_to_f64.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f128_to_f64.c	(revision 94558)
@@ -42,5 +42,5 @@
 #include "softfloat.h"
 
-float64_t f128_to_f64( float128_t a )
+float64_t f128_to_f64( float128_t a SOFTFLOAT_STATE_DECL_COMMA )
 {
     union ui128_f128 uA;
@@ -67,5 +67,5 @@
     if ( exp == 0x7FFF ) {
         if ( frac64 | frac0 ) {
-            softfloat_f128UIToCommonNaN( uiA64, uiA0, &commonNaN );
+            softfloat_f128UIToCommonNaN( uiA64, uiA0, &commonNaN SOFTFLOAT_STATE_ARG_COMMA );
             uiZ = softfloat_commonNaNToF64UI( &commonNaN );
         } else {
@@ -90,5 +90,5 @@
     return
         softfloat_roundPackToF64(
-            sign, exp, frac64 | UINT64_C( 0x4000000000000000 ) );
+            sign, exp, frac64 | UINT64_C( 0x4000000000000000 ) SOFTFLOAT_STATE_ARG_COMMA );
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
Index: trunk/src/libs/softfloat-3e/source/f128_to_i32.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f128_to_i32.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f128_to_i32.c	(revision 94558)
@@ -42,5 +42,5 @@
 #include "softfloat.h"
 
-int_fast32_t f128_to_i32( float128_t a, uint_fast8_t roundingMode, bool exact )
+int_fast32_t f128_to_i32( float128_t a, uint_fast8_t roundingMode, bool exact SOFTFLOAT_STATE_DECL_COMMA )
 {
     union ui128_f128 uA;
@@ -69,5 +69,5 @@
         sign = 1;
 #else
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
         return i32_fromNaN;
 #endif
@@ -80,5 +80,5 @@
     shiftDist = 0x4023 - exp;
     if ( 0 < shiftDist ) sig64 = softfloat_shiftRightJam64( sig64, shiftDist );
-    return softfloat_roundToI32( sign, sig64, roundingMode, exact );
+    return softfloat_roundToI32( sign, sig64, roundingMode, exact SOFTFLOAT_STATE_ARG_COMMA );
 
 }
Index: trunk/src/libs/softfloat-3e/source/f128_to_i32_r_minMag.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f128_to_i32_r_minMag.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f128_to_i32_r_minMag.c	(revision 94558)
@@ -42,5 +42,5 @@
 #include "softfloat.h"
 
-int_fast32_t f128_to_i32_r_minMag( float128_t a, bool exact )
+int_fast32_t f128_to_i32_r_minMag( float128_t a, bool exact SOFTFLOAT_STATE_DECL_COMMA )
 {
     union ui128_f128 uA;
@@ -81,5 +81,5 @@
             return -0x7FFFFFFF - 1;
         }
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
         return
             (exp == 0x7FFF) && sig64 ? i32_fromNaN
Index: trunk/src/libs/softfloat-3e/source/f128_to_i64.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f128_to_i64.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f128_to_i64.c	(revision 94558)
@@ -42,5 +42,5 @@
 #include "softfloat.h"
 
-int_fast64_t f128_to_i64( float128_t a, uint_fast8_t roundingMode, bool exact )
+int_fast64_t f128_to_i64( float128_t a, uint_fast8_t roundingMode, bool exact SOFTFLOAT_STATE_DECL_COMMA )
 {
     union ui128_f128 uA;
@@ -69,5 +69,5 @@
         *--------------------------------------------------------------------*/
         if ( shiftDist < -15 ) {
-            softfloat_raiseFlags( softfloat_flag_invalid );
+            softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
             return
                 (exp == 0x7FFF) && (sig64 | sig0) ? i64_fromNaN
@@ -90,5 +90,5 @@
         sig0  = sigExtra.extra;
     }
-    return softfloat_roundToI64( sign, sig64, sig0, roundingMode, exact );
+    return softfloat_roundToI64( sign, sig64, sig0, roundingMode, exact SOFTFLOAT_STATE_ARG_COMMA );
 
 }
Index: trunk/src/libs/softfloat-3e/source/f128_to_i64_r_minMag.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f128_to_i64_r_minMag.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f128_to_i64_r_minMag.c	(revision 94558)
@@ -42,5 +42,5 @@
 #include "softfloat.h"
 
-int_fast64_t f128_to_i64_r_minMag( float128_t a, bool exact )
+int_fast64_t f128_to_i64_r_minMag( float128_t a, bool exact SOFTFLOAT_STATE_DECL_COMMA )
 {
     union ui128_f128 uA;
@@ -78,5 +78,5 @@
                 return -INT64_C( 0x7FFFFFFFFFFFFFFF ) - 1;
             }
-            softfloat_raiseFlags( softfloat_flag_invalid );
+            softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
             return
                 (exp == 0x7FFF) && (sig64 | sig0) ? i64_fromNaN
Index: trunk/src/libs/softfloat-3e/source/f128_to_ui32.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f128_to_ui32.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f128_to_ui32.c	(revision 94558)
@@ -43,5 +43,5 @@
 
 uint_fast32_t
- f128_to_ui32( float128_t a, uint_fast8_t roundingMode, bool exact )
+ f128_to_ui32( float128_t a, uint_fast8_t roundingMode, bool exact SOFTFLOAT_STATE_DECL_COMMA )
 {
     union ui128_f128 uA;
@@ -69,5 +69,5 @@
         sign = 1;
 #else
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
         return ui32_fromNaN;
 #endif
@@ -81,5 +81,5 @@
         sig64 = softfloat_shiftRightJam64( sig64, shiftDist );
     }
-    return softfloat_roundToUI32( sign, sig64, roundingMode, exact );
+    return softfloat_roundToUI32( sign, sig64, roundingMode, exact SOFTFLOAT_STATE_ARG_COMMA );
 
 }
Index: trunk/src/libs/softfloat-3e/source/f128_to_ui32_r_minMag.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f128_to_ui32_r_minMag.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f128_to_ui32_r_minMag.c	(revision 94558)
@@ -42,5 +42,5 @@
 #include "softfloat.h"
 
-uint_fast32_t f128_to_ui32_r_minMag( float128_t a, bool exact )
+uint_fast32_t f128_to_ui32_r_minMag( float128_t a, bool exact SOFTFLOAT_STATE_DECL_COMMA )
 {
     union ui128_f128 uA;
@@ -72,5 +72,5 @@
     sign = signF128UI64( uiA64 );
     if ( sign || (shiftDist < 17) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
         return
             (exp == 0x7FFF) && sig64 ? ui32_fromNaN
Index: trunk/src/libs/softfloat-3e/source/f128_to_ui64.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f128_to_ui64.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f128_to_ui64.c	(revision 94558)
@@ -43,5 +43,5 @@
 
 uint_fast64_t
- f128_to_ui64( float128_t a, uint_fast8_t roundingMode, bool exact )
+ f128_to_ui64( float128_t a, uint_fast8_t roundingMode, bool exact SOFTFLOAT_STATE_DECL_COMMA )
 {
     union ui128_f128 uA;
@@ -70,5 +70,5 @@
         *--------------------------------------------------------------------*/
         if ( shiftDist < -15 ) {
-            softfloat_raiseFlags( softfloat_flag_invalid );
+            softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
             return
                 (exp == 0x7FFF) && (sig64 | sig0) ? ui64_fromNaN
@@ -91,5 +91,5 @@
         sig0  = sigExtra.extra;
     }
-    return softfloat_roundToUI64( sign, sig64, sig0, roundingMode, exact );
+    return softfloat_roundToUI64( sign, sig64, sig0, roundingMode, exact SOFTFLOAT_STATE_ARG_COMMA );
 
 }
Index: trunk/src/libs/softfloat-3e/source/f128_to_ui64_r_minMag.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f128_to_ui64_r_minMag.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f128_to_ui64_r_minMag.c	(revision 94558)
@@ -42,5 +42,5 @@
 #include "softfloat.h"
 
-uint_fast64_t f128_to_ui64_r_minMag( float128_t a, bool exact )
+uint_fast64_t f128_to_ui64_r_minMag( float128_t a, bool exact SOFTFLOAT_STATE_DECL_COMMA )
 {
     union ui128_f128 uA;
@@ -97,5 +97,5 @@
     *------------------------------------------------------------------------*/
  invalid:
-    softfloat_raiseFlags( softfloat_flag_invalid );
+    softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
     return
         (exp == 0x7FFF) && (sig64 | sig0) ? ui64_fromNaN
Index: trunk/src/libs/softfloat-3e/source/f16_add.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f16_add.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f16_add.c	(revision 94558)
@@ -41,5 +41,5 @@
 #include "softfloat.h"
 
-float16_t f16_add( float16_t a, float16_t b )
+float16_t f16_add( float16_t a, float16_t b SOFTFLOAT_STATE_DECL_COMMA )
 {
     union ui16_f16 uA;
@@ -48,5 +48,5 @@
     uint_fast16_t uiB;
 #if ! defined INLINE_LEVEL || (INLINE_LEVEL < 1)
-    float16_t (*magsFuncPtr)( uint_fast16_t, uint_fast16_t );
+    float16_t (*magsFuncPtr)( uint_fast16_t, uint_fast16_t SOFTFLOAT_STATE_DECL_COMMA );
 #endif
 
@@ -57,12 +57,12 @@
 #if defined INLINE_LEVEL && (1 <= INLINE_LEVEL)
     if ( signF16UI( uiA ^ uiB ) ) {
-        return softfloat_subMagsF16( uiA, uiB );
+        return softfloat_subMagsF16( uiA, uiB SOFTFLOAT_STATE_ARG_COMMA );
     } else {
-        return softfloat_addMagsF16( uiA, uiB );
+        return softfloat_addMagsF16( uiA, uiB SOFTFLOAT_STATE_ARG_COMMA );
     }
 #else
     magsFuncPtr =
         signF16UI( uiA ^ uiB ) ? softfloat_subMagsF16 : softfloat_addMagsF16;
-    return (*magsFuncPtr)( uiA, uiB );
+    return (*magsFuncPtr)( uiA, uiB SOFTFLOAT_STATE_ARG_COMMA );
 #endif
 
Index: trunk/src/libs/softfloat-3e/source/f16_div.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f16_div.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f16_div.c	(revision 94558)
@@ -45,5 +45,5 @@
 extern const uint16_t softfloat_approxRecip_1k1s[];
 
-float16_t f16_div( float16_t a, float16_t b )
+float16_t f16_div( float16_t a, float16_t b SOFTFLOAT_STATE_DECL_COMMA  )
 {
     union ui16_f16 uA;
@@ -103,5 +103,5 @@
         if ( ! sigB ) {
             if ( ! (expA | sigA) ) goto invalid;
-            softfloat_raiseFlags( softfloat_flag_infinite );
+            softfloat_raiseFlags( softfloat_flag_infinite SOFTFLOAT_STATE_ARG_COMMA );
             goto infinity;
         }
@@ -158,14 +158,14 @@
     }
 #endif
-    return softfloat_roundPackToF16( signZ, expZ, sigZ );
+    return softfloat_roundPackToF16( signZ, expZ, sigZ SOFTFLOAT_STATE_ARG_COMMA );
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  propagateNaN:
-    uiZ = softfloat_propagateNaNF16UI( uiA, uiB );
+    uiZ = softfloat_propagateNaNF16UI( uiA, uiB SOFTFLOAT_STATE_ARG_COMMA );
     goto uiZ;
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  invalid:
-    softfloat_raiseFlags( softfloat_flag_invalid );
+    softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
     uiZ = defaultNaNF16UI;
     goto uiZ;
Index: trunk/src/libs/softfloat-3e/source/f16_eq.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f16_eq.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f16_eq.c	(revision 94558)
@@ -42,5 +42,5 @@
 #include "softfloat.h"
 
-bool f16_eq( float16_t a, float16_t b )
+bool f16_eq( float16_t a, float16_t b SOFTFLOAT_STATE_DECL_COMMA  )
 {
     union ui16_f16 uA;
@@ -57,5 +57,5 @@
             softfloat_isSigNaNF16UI( uiA ) || softfloat_isSigNaNF16UI( uiB )
         ) {
-            softfloat_raiseFlags( softfloat_flag_invalid );
+            softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
         }
         return false;
Index: trunk/src/libs/softfloat-3e/source/f16_eq_signaling.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f16_eq_signaling.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f16_eq_signaling.c	(revision 94558)
@@ -41,5 +41,5 @@
 #include "softfloat.h"
 
-bool f16_eq_signaling( float16_t a, float16_t b )
+bool f16_eq_signaling( float16_t a, float16_t b SOFTFLOAT_STATE_DECL_COMMA  )
 {
     union ui16_f16 uA;
@@ -53,5 +53,5 @@
     uiB = uB.ui;
     if ( isNaNF16UI( uiA ) || isNaNF16UI( uiB ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
         return false;
     }
Index: trunk/src/libs/softfloat-3e/source/f16_le.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f16_le.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f16_le.c	(revision 94558)
@@ -41,5 +41,5 @@
 #include "softfloat.h"
 
-bool f16_le( float16_t a, float16_t b )
+bool f16_le( float16_t a, float16_t b SOFTFLOAT_STATE_DECL_COMMA  )
 {
     union ui16_f16 uA;
@@ -54,5 +54,5 @@
     uiB = uB.ui;
     if ( isNaNF16UI( uiA ) || isNaNF16UI( uiB ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
         return false;
     }
Index: trunk/src/libs/softfloat-3e/source/f16_le_quiet.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f16_le_quiet.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f16_le_quiet.c	(revision 94558)
@@ -42,5 +42,5 @@
 #include "softfloat.h"
 
-bool f16_le_quiet( float16_t a, float16_t b )
+bool f16_le_quiet( float16_t a, float16_t b SOFTFLOAT_STATE_DECL_COMMA  )
 {
     union ui16_f16 uA;
@@ -58,5 +58,5 @@
             softfloat_isSigNaNF16UI( uiA ) || softfloat_isSigNaNF16UI( uiB )
         ) {
-            softfloat_raiseFlags( softfloat_flag_invalid );
+            softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
         }
         return false;
Index: trunk/src/libs/softfloat-3e/source/f16_lt.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f16_lt.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f16_lt.c	(revision 94558)
@@ -41,5 +41,5 @@
 #include "softfloat.h"
 
-bool f16_lt( float16_t a, float16_t b )
+bool f16_lt( float16_t a, float16_t b SOFTFLOAT_STATE_DECL_COMMA  )
 {
     union ui16_f16 uA;
@@ -54,5 +54,5 @@
     uiB = uB.ui;
     if ( isNaNF16UI( uiA ) || isNaNF16UI( uiB ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
         return false;
     }
Index: trunk/src/libs/softfloat-3e/source/f16_lt_quiet.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f16_lt_quiet.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f16_lt_quiet.c	(revision 94558)
@@ -42,5 +42,5 @@
 #include "softfloat.h"
 
-bool f16_lt_quiet( float16_t a, float16_t b )
+bool f16_lt_quiet( float16_t a, float16_t b SOFTFLOAT_STATE_DECL_COMMA )
 {
     union ui16_f16 uA;
@@ -58,5 +58,5 @@
             softfloat_isSigNaNF16UI( uiA ) || softfloat_isSigNaNF16UI( uiB )
         ) {
-            softfloat_raiseFlags( softfloat_flag_invalid );
+            softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
         }
         return false;
Index: trunk/src/libs/softfloat-3e/source/f16_mul.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f16_mul.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f16_mul.c	(revision 94558)
@@ -42,5 +42,5 @@
 #include "softfloat.h"
 
-float16_t f16_mul( float16_t a, float16_t b )
+float16_t f16_mul( float16_t a, float16_t b SOFTFLOAT_STATE_DECL_COMMA  )
 {
     union ui16_f16 uA;
@@ -113,9 +113,9 @@
         sigZ <<= 1;
     }
-    return softfloat_roundPackToF16( signZ, expZ, sigZ );
+    return softfloat_roundPackToF16( signZ, expZ, sigZ SOFTFLOAT_STATE_ARG_COMMA );
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  propagateNaN:
-    uiZ = softfloat_propagateNaNF16UI( uiA, uiB );
+    uiZ = softfloat_propagateNaNF16UI( uiA, uiB SOFTFLOAT_STATE_ARG_COMMA );
     goto uiZ;
     /*------------------------------------------------------------------------
@@ -123,5 +123,5 @@
  infArg:
     if ( ! magBits ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
         uiZ = defaultNaNF16UI;
     } else {
Index: trunk/src/libs/softfloat-3e/source/f16_mulAdd.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f16_mulAdd.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f16_mulAdd.c	(revision 94558)
@@ -40,5 +40,5 @@
 #include "softfloat.h"
 
-float16_t f16_mulAdd( float16_t a, float16_t b, float16_t c )
+float16_t f16_mulAdd( float16_t a, float16_t b, float16_t c SOFTFLOAT_STATE_DECL_COMMA  )
 {
     union ui16_f16 uA;
@@ -55,5 +55,5 @@
     uC.f = c;
     uiC = uC.ui;
-    return softfloat_mulAddF16( uiA, uiB, uiC, 0 );
+    return softfloat_mulAddF16( uiA, uiB, uiC, 0 SOFTFLOAT_STATE_ARG_COMMA );
 
 }
Index: trunk/src/libs/softfloat-3e/source/f16_rem.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f16_rem.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f16_rem.c	(revision 94558)
@@ -42,5 +42,5 @@
 #include "softfloat.h"
 
-float16_t f16_rem( float16_t a, float16_t b )
+float16_t f16_rem( float16_t a, float16_t b SOFTFLOAT_STATE_DECL_COMMA  )
 {
     union ui16_f16 uA;
@@ -155,12 +155,12 @@
         rem = -rem;
     }
-    return softfloat_normRoundPackToF16( signRem, expB, rem );
+    return softfloat_normRoundPackToF16( signRem, expB, rem SOFTFLOAT_STATE_ARG_COMMA );
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  propagateNaN:
-    uiZ = softfloat_propagateNaNF16UI( uiA, uiB );
+    uiZ = softfloat_propagateNaNF16UI( uiA, uiB SOFTFLOAT_STATE_ARG_COMMA );
     goto uiZ;
  invalid:
-    softfloat_raiseFlags( softfloat_flag_invalid );
+    softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
     uiZ = defaultNaNF16UI;
  uiZ:
Index: trunk/src/libs/softfloat-3e/source/f16_roundToInt.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f16_roundToInt.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f16_roundToInt.c	(revision 94558)
@@ -43,5 +43,5 @@
 #include <iprt/cdefs.h> /* VBox: for RT_FALL_THROUGH */
 
-float16_t f16_roundToInt( float16_t a, uint_fast8_t roundingMode, bool exact )
+float16_t f16_roundToInt( float16_t a, uint_fast8_t roundingMode, bool exact SOFTFLOAT_STATE_DECL_COMMA  )
 {
     union ui16_f16 uA;
@@ -87,5 +87,5 @@
     if ( 0x19 <= exp ) {
         if ( (exp == 0x1F) && fracF16UI( uiA ) ) {
-            uiZ = softfloat_propagateNaNF16UI( uiA, 0 );
+            uiZ = softfloat_propagateNaNF16UI( uiA, 0 SOFTFLOAT_STATE_ARG_COMMA );
             goto uiZ;
         }
Index: trunk/src/libs/softfloat-3e/source/f16_sqrt.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f16_sqrt.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f16_sqrt.c	(revision 94558)
@@ -45,5 +45,5 @@
 extern const uint16_t softfloat_approxRecipSqrt_1k1s[];
 
-float16_t f16_sqrt( float16_t a )
+float16_t f16_sqrt( float16_t a SOFTFLOAT_STATE_DECL_COMMA  )
 {
     union ui16_f16 uA;
@@ -73,5 +73,5 @@
     if ( expA == 0x1F ) {
         if ( sigA ) {
-            uiZ = softfloat_propagateNaNF16UI( uiA, 0 );
+            uiZ = softfloat_propagateNaNF16UI( uiA, 0 SOFTFLOAT_STATE_ARG_COMMA );
             goto uiZ;
         }
@@ -123,9 +123,9 @@
         }
     }
-    return softfloat_roundPackToF16( 0, expZ, sigZ );
+    return softfloat_roundPackToF16( 0, expZ, sigZ SOFTFLOAT_STATE_ARG_COMMA );
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  invalid:
-    softfloat_raiseFlags( softfloat_flag_invalid );
+    softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
     uiZ = defaultNaNF16UI;
  uiZ:
Index: trunk/src/libs/softfloat-3e/source/f16_sub.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f16_sub.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f16_sub.c	(revision 94558)
@@ -41,5 +41,5 @@
 #include "softfloat.h"
 
-float16_t f16_sub( float16_t a, float16_t b )
+float16_t f16_sub( float16_t a, float16_t b SOFTFLOAT_STATE_DECL_COMMA  )
 {
     union ui16_f16 uA;
@@ -48,5 +48,5 @@
     uint_fast16_t uiB;
 #if ! defined INLINE_LEVEL || (INLINE_LEVEL < 1)
-    float16_t (*magsFuncPtr)( uint_fast16_t, uint_fast16_t );
+    float16_t (*magsFuncPtr)( uint_fast16_t, uint_fast16_t SOFTFLOAT_STATE_DECL_COMMA );
 #endif
 
@@ -57,12 +57,12 @@
 #if defined INLINE_LEVEL && (1 <= INLINE_LEVEL)
     if ( signF16UI( uiA ^ uiB ) ) {
-        return softfloat_addMagsF16( uiA, uiB );
+        return softfloat_addMagsF16( uiA, uiB SOFTFLOAT_STATE_ARG_COMMA );
     } else {
-        return softfloat_subMagsF16( uiA, uiB );
+        return softfloat_subMagsF16( uiA, uiB SOFTFLOAT_STATE_ARG_COMMA );
     }
 #else
     magsFuncPtr =
         signF16UI( uiA ^ uiB ) ? softfloat_addMagsF16 : softfloat_subMagsF16;
-    return (*magsFuncPtr)( uiA, uiB );
+    return (*magsFuncPtr)( uiA, uiB SOFTFLOAT_STATE_ARG_COMMA );
 #endif
 
Index: trunk/src/libs/softfloat-3e/source/f16_to_extF80.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f16_to_extF80.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f16_to_extF80.c	(revision 94558)
@@ -42,5 +42,5 @@
 #include "softfloat.h"
 
-extFloat80_t f16_to_extF80( float16_t a )
+extFloat80_t f16_to_extF80( float16_t a SOFTFLOAT_STATE_DECL_COMMA )
 {
     union ui16_f16 uA;
@@ -67,5 +67,5 @@
     if ( exp == 0x1F ) {
         if ( frac ) {
-            softfloat_f16UIToCommonNaN( uiA, &commonNaN );
+            softfloat_f16UIToCommonNaN( uiA, &commonNaN SOFTFLOAT_STATE_ARG_COMMA );
             uiZ = softfloat_commonNaNToExtF80UI( &commonNaN );
             uiZ64 = uiZ.v64;
Index: trunk/src/libs/softfloat-3e/source/f16_to_extF80M.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f16_to_extF80M.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f16_to_extF80M.c	(revision 94558)
@@ -44,8 +44,8 @@
 #ifdef SOFTFLOAT_FAST_INT64
 
-void f16_to_extF80M( float16_t a, extFloat80_t *zPtr )
+void f16_to_extF80M( float16_t a, extFloat80_t *zPtr SOFTFLOAT_STATE_DECL_COMMA )
 {
 
-    *zPtr = f16_to_extF80( a );
+    *zPtr = f16_to_extF80( a SOFTFLOAT_STATE_ARG_COMMA );
 
 }
@@ -53,5 +53,5 @@
 #else
 
-void f16_to_extF80M( float16_t a, extFloat80_t *zPtr )
+void f16_to_extF80M( float16_t a, extFloat80_t *zPtr SOFTFLOAT_STATE_DECL_COMMA )
 {
     struct extFloat80M *zSPtr;
@@ -78,5 +78,5 @@
     if ( exp == 0x1F ) {
         if ( frac ) {
-            softfloat_f16UIToCommonNaN( uiA, &commonNaN );
+            softfloat_f16UIToCommonNaN( uiA, &commonNaN SOFTFLOAT_STATE_ARG_COMMA );
             softfloat_commonNaNToExtF80M( &commonNaN, zSPtr );
             return;
Index: trunk/src/libs/softfloat-3e/source/f16_to_f128.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f16_to_f128.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f16_to_f128.c	(revision 94558)
@@ -42,5 +42,5 @@
 #include "softfloat.h"
 
-float128_t f16_to_f128( float16_t a )
+float128_t f16_to_f128( float16_t a SOFTFLOAT_STATE_DECL_COMMA )
 {
     union ui16_f16 uA;
@@ -65,5 +65,5 @@
     if ( exp == 0x1F ) {
         if ( frac ) {
-            softfloat_f16UIToCommonNaN( uiA, &commonNaN );
+            softfloat_f16UIToCommonNaN( uiA, &commonNaN SOFTFLOAT_STATE_ARG_COMMA );
             uiZ = softfloat_commonNaNToF128UI( &commonNaN );
         } else {
Index: trunk/src/libs/softfloat-3e/source/f16_to_f128M.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f16_to_f128M.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f16_to_f128M.c	(revision 94558)
@@ -44,8 +44,8 @@
 #ifdef SOFTFLOAT_FAST_INT64
 
-void f16_to_f128M( float16_t a, float128_t *zPtr )
+void f16_to_f128M( float16_t a, float128_t *zPtr SOFTFLOAT_STATE_DECL_COMMA )
 {
 
-    *zPtr = f16_to_f128( a );
+    *zPtr = f16_to_f128( a SOFTFLOAT_STATE_ARG_COMMA );
 
 }
@@ -53,5 +53,5 @@
 #else
 
-void f16_to_f128M( float16_t a, float128_t *zPtr )
+void f16_to_f128M( float16_t a, float128_t *zPtr SOFTFLOAT_STATE_DECL_COMMA )
 {
     uint32_t *zWPtr;
@@ -79,5 +79,5 @@
     if ( exp == 0x1F ) {
         if ( frac ) {
-            softfloat_f16UIToCommonNaN( uiA, &commonNaN );
+            softfloat_f16UIToCommonNaN( uiA, &commonNaN SOFTFLOAT_STATE_ARG_COMMA );
             softfloat_commonNaNToF128M( &commonNaN, zWPtr );
             return;
Index: trunk/src/libs/softfloat-3e/source/f16_to_f32.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f16_to_f32.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f16_to_f32.c	(revision 94558)
@@ -42,5 +42,5 @@
 #include "softfloat.h"
 
-float32_t f16_to_f32( float16_t a )
+float32_t f16_to_f32( float16_t a SOFTFLOAT_STATE_DECL_COMMA )
 {
     union ui16_f16 uA;
@@ -65,5 +65,5 @@
     if ( exp == 0x1F ) {
         if ( frac ) {
-            softfloat_f16UIToCommonNaN( uiA, &commonNaN );
+            softfloat_f16UIToCommonNaN( uiA, &commonNaN SOFTFLOAT_STATE_ARG_COMMA );
             uiZ = softfloat_commonNaNToF32UI( &commonNaN );
         } else {
Index: trunk/src/libs/softfloat-3e/source/f16_to_f64.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f16_to_f64.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f16_to_f64.c	(revision 94558)
@@ -42,5 +42,5 @@
 #include "softfloat.h"
 
-float64_t f16_to_f64( float16_t a )
+float64_t f16_to_f64( float16_t a SOFTFLOAT_STATE_DECL_COMMA )
 {
     union ui16_f16 uA;
@@ -65,5 +65,5 @@
     if ( exp == 0x1F ) {
         if ( frac ) {
-            softfloat_f16UIToCommonNaN( uiA, &commonNaN );
+            softfloat_f16UIToCommonNaN( uiA, &commonNaN SOFTFLOAT_STATE_ARG_COMMA );
             uiZ = softfloat_commonNaNToF64UI( &commonNaN );
         } else {
Index: trunk/src/libs/softfloat-3e/source/f16_to_i32.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f16_to_i32.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f16_to_i32.c	(revision 94558)
@@ -42,5 +42,5 @@
 #include "softfloat.h"
 
-int_fast32_t f16_to_i32( float16_t a, uint_fast8_t roundingMode, bool exact )
+int_fast32_t f16_to_i32( float16_t a, uint_fast8_t roundingMode, bool exact SOFTFLOAT_STATE_DECL_COMMA )
 {
     union ui16_f16 uA;
@@ -62,5 +62,5 @@
     *------------------------------------------------------------------------*/
     if ( exp == 0x1F ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
         return
             frac ? i32_fromNaN
@@ -82,5 +82,5 @@
     return
         softfloat_roundToI32(
-            sign, (uint_fast32_t) sig32, roundingMode, exact );
+            sign, (uint_fast32_t) sig32, roundingMode, exact SOFTFLOAT_STATE_ARG_COMMA );
 
 }
Index: trunk/src/libs/softfloat-3e/source/f16_to_i32_r_minMag.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f16_to_i32_r_minMag.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f16_to_i32_r_minMag.c	(revision 94558)
@@ -42,5 +42,5 @@
 #include "softfloat.h"
 
-int_fast32_t f16_to_i32_r_minMag( float16_t a, bool exact )
+int_fast32_t f16_to_i32_r_minMag( float16_t a, bool exact SOFTFLOAT_STATE_DECL_COMMA )
 {
     union ui16_f16 uA;
@@ -71,5 +71,5 @@
     sign = signF16UI( uiA );
     if ( exp == 0x1F ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
         return
             (exp == 0x1F) && frac ? i32_fromNaN
Index: trunk/src/libs/softfloat-3e/source/f16_to_i64.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f16_to_i64.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f16_to_i64.c	(revision 94558)
@@ -42,5 +42,5 @@
 #include "softfloat.h"
 
-int_fast64_t f16_to_i64( float16_t a, uint_fast8_t roundingMode, bool exact )
+int_fast64_t f16_to_i64( float16_t a, uint_fast8_t roundingMode, bool exact SOFTFLOAT_STATE_DECL_COMMA )
 {
     union ui16_f16 uA;
@@ -62,5 +62,5 @@
     *------------------------------------------------------------------------*/
     if ( exp == 0x1F ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
         return
             frac ? i64_fromNaN
@@ -82,5 +82,5 @@
     return
         softfloat_roundToI32(
-            sign, (uint_fast32_t) sig32, roundingMode, exact );
+            sign, (uint_fast32_t) sig32, roundingMode, exact SOFTFLOAT_STATE_ARG_COMMA );
 
 }
Index: trunk/src/libs/softfloat-3e/source/f16_to_i64_r_minMag.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f16_to_i64_r_minMag.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f16_to_i64_r_minMag.c	(revision 94558)
@@ -42,5 +42,5 @@
 #include "softfloat.h"
 
-int_fast64_t f16_to_i64_r_minMag( float16_t a, bool exact )
+int_fast64_t f16_to_i64_r_minMag( float16_t a, bool exact SOFTFLOAT_STATE_DECL_COMMA )
 {
     union ui16_f16 uA;
@@ -71,5 +71,5 @@
     sign = signF16UI( uiA );
     if ( exp == 0x1F ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
         return
             (exp == 0x1F) && frac ? i64_fromNaN
Index: trunk/src/libs/softfloat-3e/source/f16_to_ui32.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f16_to_ui32.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f16_to_ui32.c	(revision 94558)
@@ -42,5 +42,5 @@
 #include "softfloat.h"
 
-uint_fast32_t f16_to_ui32( float16_t a, uint_fast8_t roundingMode, bool exact )
+uint_fast32_t f16_to_ui32( float16_t a, uint_fast8_t roundingMode, bool exact SOFTFLOAT_STATE_DECL_COMMA )
 {
     union ui16_f16 uA;
@@ -62,5 +62,5 @@
     *------------------------------------------------------------------------*/
     if ( exp == 0x1F ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
         return
             frac ? ui32_fromNaN
@@ -79,5 +79,5 @@
         if ( 0 < shiftDist ) sig32 <<= shiftDist;
     }
-    return softfloat_roundToUI32( sign, sig32, roundingMode, exact );
+    return softfloat_roundToUI32( sign, sig32, roundingMode, exact SOFTFLOAT_STATE_ARG_COMMA );
 
 }
Index: trunk/src/libs/softfloat-3e/source/f16_to_ui32_r_minMag.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f16_to_ui32_r_minMag.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f16_to_ui32_r_minMag.c	(revision 94558)
@@ -42,5 +42,5 @@
 #include "softfloat.h"
 
-uint_fast32_t f16_to_ui32_r_minMag( float16_t a, bool exact )
+uint_fast32_t f16_to_ui32_r_minMag( float16_t a, bool exact SOFTFLOAT_STATE_DECL_COMMA )
 {
     union ui16_f16 uA;
@@ -71,5 +71,5 @@
     sign = signF16UI( uiA );
     if ( sign || (exp == 0x1F) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
         return
             (exp == 0x1F) && frac ? ui32_fromNaN
Index: trunk/src/libs/softfloat-3e/source/f16_to_ui64.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f16_to_ui64.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f16_to_ui64.c	(revision 94558)
@@ -42,5 +42,5 @@
 #include "softfloat.h"
 
-uint_fast64_t f16_to_ui64( float16_t a, uint_fast8_t roundingMode, bool exact )
+uint_fast64_t f16_to_ui64( float16_t a, uint_fast8_t roundingMode, bool exact SOFTFLOAT_STATE_DECL_COMMA )
 {
     union ui16_f16 uA;
@@ -65,5 +65,5 @@
     *------------------------------------------------------------------------*/
     if ( exp == 0x1F ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
         return
             frac ? ui64_fromNaN
@@ -85,10 +85,10 @@
     return
         softfloat_roundToUI64(
-            sign, sig32>>12, (uint_fast64_t) sig32<<52, roundingMode, exact );
+            sign, sig32>>12, (uint_fast64_t) sig32<<52, roundingMode, exact SOFTFLOAT_STATE_ARG_COMMA );
 #else
     extSig[indexWord( 3, 2 )] = 0;
     extSig[indexWord( 3, 1 )] = sig32>>12;
     extSig[indexWord( 3, 0 )] = sig32<<20;
-    return softfloat_roundMToUI64( sign, extSig, roundingMode, exact );
+    return softfloat_roundMToUI64( sign, extSig, roundingMode, exact SOFTFLOAT_STATE_ARG_COMMA);
 #endif
 
Index: trunk/src/libs/softfloat-3e/source/f16_to_ui64_r_minMag.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f16_to_ui64_r_minMag.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f16_to_ui64_r_minMag.c	(revision 94558)
@@ -42,5 +42,5 @@
 #include "softfloat.h"
 
-uint_fast64_t f16_to_ui64_r_minMag( float16_t a, bool exact )
+uint_fast64_t f16_to_ui64_r_minMag( float16_t a, bool exact SOFTFLOAT_STATE_DECL_COMMA )
 {
     union ui16_f16 uA;
@@ -71,5 +71,5 @@
     sign = signF16UI( uiA );
     if ( sign || (exp == 0x1F) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
         return
             (exp == 0x1F) && frac ? ui64_fromNaN
Index: trunk/src/libs/softfloat-3e/source/f32_add.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f32_add.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f32_add.c	(revision 94558)
@@ -41,5 +41,5 @@
 #include "softfloat.h"
 
-float32_t f32_add( float32_t a, float32_t b )
+float32_t f32_add( float32_t a, float32_t b SOFTFLOAT_STATE_DECL_COMMA )
 {
     union ui32_f32 uA;
@@ -48,5 +48,5 @@
     uint_fast32_t uiB;
 #if ! defined INLINE_LEVEL || (INLINE_LEVEL < 1)
-    float32_t (*magsFuncPtr)( uint_fast32_t, uint_fast32_t );
+    float32_t (*magsFuncPtr)( uint_fast32_t, uint_fast32_t SOFTFLOAT_STATE_DECL_COMMA );
 #endif
 
@@ -57,12 +57,12 @@
 #if defined INLINE_LEVEL && (1 <= INLINE_LEVEL)
     if ( signF32UI( uiA ^ uiB ) ) {
-        return softfloat_subMagsF32( uiA, uiB );
+        return softfloat_subMagsF32( uiA, uiB SOFTFLOAT_STATE_ARG_COMMA );
     } else {
-        return softfloat_addMagsF32( uiA, uiB );
+        return softfloat_addMagsF32( uiA, uiB SOFTFLOAT_STATE_ARG_COMMA );
     }
 #else
     magsFuncPtr =
         signF32UI( uiA ^ uiB ) ? softfloat_subMagsF32 : softfloat_addMagsF32;
-    return (*magsFuncPtr)( uiA, uiB );
+    return (*magsFuncPtr)( uiA, uiB SOFTFLOAT_STATE_ARG_COMMA );
 #endif
 
Index: trunk/src/libs/softfloat-3e/source/f32_div.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f32_div.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f32_div.c	(revision 94558)
@@ -42,5 +42,5 @@
 #include "softfloat.h"
 
-float32_t f32_div( float32_t a, float32_t b )
+float32_t f32_div( float32_t a, float32_t b SOFTFLOAT_STATE_DECL_COMMA )
 {
     union ui32_f32 uA;
@@ -99,5 +99,5 @@
         if ( ! sigB ) {
             if ( ! (expA | sigA) ) goto invalid;
-            softfloat_raiseFlags( softfloat_flag_infinite );
+            softfloat_raiseFlags( softfloat_flag_infinite SOFTFLOAT_STATE_ARG_COMMA );
             goto infinity;
         }
@@ -152,14 +152,14 @@
     }
 #endif
-    return softfloat_roundPackToF32( signZ, expZ, sigZ );
+    return softfloat_roundPackToF32( signZ, expZ, sigZ SOFTFLOAT_STATE_ARG_COMMA );
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  propagateNaN:
-    uiZ = softfloat_propagateNaNF32UI( uiA, uiB );
+    uiZ = softfloat_propagateNaNF32UI( uiA, uiB SOFTFLOAT_STATE_ARG_COMMA );
     goto uiZ;
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  invalid:
-    softfloat_raiseFlags( softfloat_flag_invalid );
+    softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
     uiZ = defaultNaNF32UI;
     goto uiZ;
Index: trunk/src/libs/softfloat-3e/source/f32_eq.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f32_eq.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f32_eq.c	(revision 94558)
@@ -42,5 +42,5 @@
 #include "softfloat.h"
 
-bool f32_eq( float32_t a, float32_t b )
+bool f32_eq( float32_t a, float32_t b SOFTFLOAT_STATE_DECL_COMMA )
 {
     union ui32_f32 uA;
@@ -57,5 +57,5 @@
             softfloat_isSigNaNF32UI( uiA ) || softfloat_isSigNaNF32UI( uiB )
         ) {
-            softfloat_raiseFlags( softfloat_flag_invalid );
+            softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
         }
         return false;
Index: trunk/src/libs/softfloat-3e/source/f32_eq_signaling.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f32_eq_signaling.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f32_eq_signaling.c	(revision 94558)
@@ -41,5 +41,5 @@
 #include "softfloat.h"
 
-bool f32_eq_signaling( float32_t a, float32_t b )
+bool f32_eq_signaling( float32_t a, float32_t b SOFTFLOAT_STATE_DECL_COMMA )
 {
     union ui32_f32 uA;
@@ -53,5 +53,5 @@
     uiB = uB.ui;
     if ( isNaNF32UI( uiA ) || isNaNF32UI( uiB ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
         return false;
     }
Index: trunk/src/libs/softfloat-3e/source/f32_le.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f32_le.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f32_le.c	(revision 94558)
@@ -41,5 +41,5 @@
 #include "softfloat.h"
 
-bool f32_le( float32_t a, float32_t b )
+bool f32_le( float32_t a, float32_t b SOFTFLOAT_STATE_DECL_COMMA )
 {
     union ui32_f32 uA;
@@ -54,5 +54,5 @@
     uiB = uB.ui;
     if ( isNaNF32UI( uiA ) || isNaNF32UI( uiB ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
         return false;
     }
Index: trunk/src/libs/softfloat-3e/source/f32_le_quiet.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f32_le_quiet.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f32_le_quiet.c	(revision 94558)
@@ -42,5 +42,5 @@
 #include "softfloat.h"
 
-bool f32_le_quiet( float32_t a, float32_t b )
+bool f32_le_quiet( float32_t a, float32_t b SOFTFLOAT_STATE_DECL_COMMA )
 {
     union ui32_f32 uA;
@@ -58,5 +58,5 @@
             softfloat_isSigNaNF32UI( uiA ) || softfloat_isSigNaNF32UI( uiB )
         ) {
-            softfloat_raiseFlags( softfloat_flag_invalid );
+            softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
         }
         return false;
Index: trunk/src/libs/softfloat-3e/source/f32_lt.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f32_lt.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f32_lt.c	(revision 94558)
@@ -41,5 +41,5 @@
 #include "softfloat.h"
 
-bool f32_lt( float32_t a, float32_t b )
+bool f32_lt( float32_t a, float32_t b SOFTFLOAT_STATE_DECL_COMMA )
 {
     union ui32_f32 uA;
@@ -54,5 +54,5 @@
     uiB = uB.ui;
     if ( isNaNF32UI( uiA ) || isNaNF32UI( uiB ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
         return false;
     }
Index: trunk/src/libs/softfloat-3e/source/f32_lt_quiet.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f32_lt_quiet.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f32_lt_quiet.c	(revision 94558)
@@ -42,5 +42,5 @@
 #include "softfloat.h"
 
-bool f32_lt_quiet( float32_t a, float32_t b )
+bool f32_lt_quiet( float32_t a, float32_t b SOFTFLOAT_STATE_DECL_COMMA )
 {
     union ui32_f32 uA;
@@ -58,5 +58,5 @@
             softfloat_isSigNaNF32UI( uiA ) || softfloat_isSigNaNF32UI( uiB )
         ) {
-            softfloat_raiseFlags( softfloat_flag_invalid );
+            softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
         }
         return false;
Index: trunk/src/libs/softfloat-3e/source/f32_mul.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f32_mul.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f32_mul.c	(revision 94558)
@@ -42,5 +42,5 @@
 #include "softfloat.h"
 
-float32_t f32_mul( float32_t a, float32_t b )
+float32_t f32_mul( float32_t a, float32_t b SOFTFLOAT_STATE_DECL_COMMA )
 {
     union ui32_f32 uA;
@@ -110,9 +110,9 @@
         sigZ <<= 1;
     }
-    return softfloat_roundPackToF32( signZ, expZ, sigZ );
+    return softfloat_roundPackToF32( signZ, expZ, sigZ SOFTFLOAT_STATE_ARG_COMMA );
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  propagateNaN:
-    uiZ = softfloat_propagateNaNF32UI( uiA, uiB );
+    uiZ = softfloat_propagateNaNF32UI( uiA, uiB SOFTFLOAT_STATE_ARG_COMMA );
     goto uiZ;
     /*------------------------------------------------------------------------
@@ -120,5 +120,5 @@
  infArg:
     if ( ! magBits ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
         uiZ = defaultNaNF32UI;
     } else {
Index: trunk/src/libs/softfloat-3e/source/f32_mulAdd.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f32_mulAdd.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f32_mulAdd.c	(revision 94558)
@@ -40,5 +40,5 @@
 #include "softfloat.h"
 
-float32_t f32_mulAdd( float32_t a, float32_t b, float32_t c )
+float32_t f32_mulAdd( float32_t a, float32_t b, float32_t c SOFTFLOAT_STATE_DECL_COMMA )
 {
     union ui32_f32 uA;
@@ -55,5 +55,5 @@
     uC.f = c;
     uiC = uC.ui;
-    return softfloat_mulAddF32( uiA, uiB, uiC, 0 );
+    return softfloat_mulAddF32( uiA, uiB, uiC, 0 SOFTFLOAT_STATE_ARG_COMMA );
 
 }
Index: trunk/src/libs/softfloat-3e/source/f32_rem.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f32_rem.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f32_rem.c	(revision 94558)
@@ -42,5 +42,5 @@
 #include "softfloat.h"
 
-float32_t f32_rem( float32_t a, float32_t b )
+float32_t f32_rem( float32_t a, float32_t b SOFTFLOAT_STATE_DECL_COMMA )
 {
     union ui32_f32 uA;
@@ -152,12 +152,12 @@
         rem = -rem;
     }
-    return softfloat_normRoundPackToF32( signRem, expB, rem );
+    return softfloat_normRoundPackToF32( signRem, expB, rem SOFTFLOAT_STATE_ARG_COMMA );
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  propagateNaN:
-    uiZ = softfloat_propagateNaNF32UI( uiA, uiB );
+    uiZ = softfloat_propagateNaNF32UI( uiA, uiB SOFTFLOAT_STATE_ARG_COMMA );
     goto uiZ;
  invalid:
-    softfloat_raiseFlags( softfloat_flag_invalid );
+    softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
     uiZ = defaultNaNF32UI;
  uiZ:
Index: trunk/src/libs/softfloat-3e/source/f32_roundToInt.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f32_roundToInt.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f32_roundToInt.c	(revision 94558)
@@ -43,5 +43,5 @@
 #include <iprt/cdefs.h> /* VBox: for RT_FALL_THROUGH */
 
-float32_t f32_roundToInt( float32_t a, uint_fast8_t roundingMode, bool exact )
+float32_t f32_roundToInt( float32_t a, uint_fast8_t roundingMode, bool exact SOFTFLOAT_STATE_DECL_COMMA )
 {
     union ui32_f32 uA;
@@ -87,5 +87,5 @@
     if ( 0x96 <= exp ) {
         if ( (exp == 0xFF) && fracF32UI( uiA ) ) {
-            uiZ = softfloat_propagateNaNF32UI( uiA, 0 );
+            uiZ = softfloat_propagateNaNF32UI( uiA, 0 SOFTFLOAT_STATE_ARG_COMMA );
             goto uiZ;
         }
Index: trunk/src/libs/softfloat-3e/source/f32_sqrt.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f32_sqrt.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f32_sqrt.c	(revision 94558)
@@ -42,5 +42,5 @@
 #include "softfloat.h"
 
-float32_t f32_sqrt( float32_t a )
+float32_t f32_sqrt( float32_t a SOFTFLOAT_STATE_DECL_COMMA )
 {
     union ui32_f32 uA;
@@ -66,5 +66,5 @@
     if ( expA == 0xFF ) {
         if ( sigA ) {
-            uiZ = softfloat_propagateNaNF32UI( uiA, 0 );
+            uiZ = softfloat_propagateNaNF32UI( uiA, 0 SOFTFLOAT_STATE_ARG_COMMA );
             goto uiZ;
         }
@@ -108,9 +108,9 @@
         }
     }
-    return softfloat_roundPackToF32( 0, expZ, sigZ );
+    return softfloat_roundPackToF32( 0, expZ, sigZ SOFTFLOAT_STATE_ARG_COMMA );
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  invalid:
-    softfloat_raiseFlags( softfloat_flag_invalid );
+    softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
     uiZ = defaultNaNF32UI;
  uiZ:
Index: trunk/src/libs/softfloat-3e/source/f32_sub.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f32_sub.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f32_sub.c	(revision 94558)
@@ -41,5 +41,5 @@
 #include "softfloat.h"
 
-float32_t f32_sub( float32_t a, float32_t b )
+float32_t f32_sub( float32_t a, float32_t b SOFTFLOAT_STATE_DECL_COMMA )
 {
     union ui32_f32 uA;
@@ -48,5 +48,5 @@
     uint_fast32_t uiB;
 #if ! defined INLINE_LEVEL || (INLINE_LEVEL < 1)
-    float32_t (*magsFuncPtr)( uint_fast32_t, uint_fast32_t );
+    float32_t (*magsFuncPtr)( uint_fast32_t, uint_fast32_t SOFTFLOAT_STATE_DECL_COMMA );
 #endif
 
@@ -57,12 +57,12 @@
 #if defined INLINE_LEVEL && (1 <= INLINE_LEVEL)
     if ( signF32UI( uiA ^ uiB ) ) {
-        return softfloat_addMagsF32( uiA, uiB );
+        return softfloat_addMagsF32( uiA, uiB SOFTFLOAT_STATE_ARG_COMMA );
     } else {
-        return softfloat_subMagsF32( uiA, uiB );
+        return softfloat_subMagsF32( uiA, uiB SOFTFLOAT_STATE_ARG_COMMA );
     }
 #else
     magsFuncPtr =
         signF32UI( uiA ^ uiB ) ? softfloat_addMagsF32 : softfloat_subMagsF32;
-    return (*magsFuncPtr)( uiA, uiB );
+    return (*magsFuncPtr)( uiA, uiB SOFTFLOAT_STATE_ARG_COMMA );
 #endif
 
Index: trunk/src/libs/softfloat-3e/source/f32_to_extF80.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f32_to_extF80.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f32_to_extF80.c	(revision 94558)
@@ -42,5 +42,5 @@
 #include "softfloat.h"
 
-extFloat80_t f32_to_extF80( float32_t a )
+extFloat80_t f32_to_extF80( float32_t a SOFTFLOAT_STATE_DECL_COMMA )
 {
     union ui32_f32 uA;
@@ -67,5 +67,5 @@
     if ( exp == 0xFF ) {
         if ( frac ) {
-            softfloat_f32UIToCommonNaN( uiA, &commonNaN );
+            softfloat_f32UIToCommonNaN( uiA, &commonNaN SOFTFLOAT_STATE_ARG_COMMA );
             uiZ = softfloat_commonNaNToExtF80UI( &commonNaN );
             uiZ64 = uiZ.v64;
Index: trunk/src/libs/softfloat-3e/source/f32_to_extF80M.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f32_to_extF80M.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f32_to_extF80M.c	(revision 94558)
@@ -44,8 +44,8 @@
 #ifdef SOFTFLOAT_FAST_INT64
 
-void f32_to_extF80M( float32_t a, extFloat80_t *zPtr )
+void f32_to_extF80M( float32_t a, extFloat80_t *zPtr SOFTFLOAT_STATE_DECL_COMMA )
 {
 
-    *zPtr = f32_to_extF80( a );
+    *zPtr = f32_to_extF80( a SOFTFLOAT_STATE_ARG_COMMA );
 
 }
@@ -53,5 +53,5 @@
 #else
 
-void f32_to_extF80M( float32_t a, extFloat80_t *zPtr )
+void f32_to_extF80M( float32_t a, extFloat80_t *zPtr SOFTFLOAT_STATE_DECL_COMMA )
 {
     struct extFloat80M *zSPtr;
@@ -78,5 +78,5 @@
     if ( exp == 0xFF ) {
         if ( frac ) {
-            softfloat_f32UIToCommonNaN( uiA, &commonNaN );
+            softfloat_f32UIToCommonNaN( uiA, &commonNaN SOFTFLOAT_STATE_ARG_COMMA );
             softfloat_commonNaNToExtF80M( &commonNaN, zSPtr );
             return;
Index: trunk/src/libs/softfloat-3e/source/f32_to_f128.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f32_to_f128.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f32_to_f128.c	(revision 94558)
@@ -42,5 +42,5 @@
 #include "softfloat.h"
 
-float128_t f32_to_f128( float32_t a )
+float128_t f32_to_f128( float32_t a SOFTFLOAT_STATE_DECL_COMMA )
 {
     union ui32_f32 uA;
@@ -65,5 +65,5 @@
     if ( exp == 0xFF ) {
         if ( frac ) {
-            softfloat_f32UIToCommonNaN( uiA, &commonNaN );
+            softfloat_f32UIToCommonNaN( uiA, &commonNaN SOFTFLOAT_STATE_ARG_COMMA );
             uiZ = softfloat_commonNaNToF128UI( &commonNaN );
         } else {
Index: trunk/src/libs/softfloat-3e/source/f32_to_f128M.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f32_to_f128M.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f32_to_f128M.c	(revision 94558)
@@ -44,8 +44,8 @@
 #ifdef SOFTFLOAT_FAST_INT64
 
-void f32_to_f128M( float32_t a, float128_t *zPtr )
+void f32_to_f128M( float32_t a, float128_t *zPtr SOFTFLOAT_STATE_DECL_COMMA )
 {
 
-    *zPtr = f32_to_f128( a );
+    *zPtr = f32_to_f128( a SOFTFLOAT_STATE_ARG_COMMA );
 
 }
@@ -53,5 +53,5 @@
 #else
 
-void f32_to_f128M( float32_t a, float128_t *zPtr )
+void f32_to_f128M( float32_t a, float128_t *zPtr SOFTFLOAT_STATE_DECL_COMMA )
 {
     uint32_t *zWPtr;
@@ -81,5 +81,5 @@
     if ( exp == 0xFF ) {
         if ( frac ) {
-            softfloat_f32UIToCommonNaN( uiA, &commonNaN );
+            softfloat_f32UIToCommonNaN( uiA, &commonNaN SOFTFLOAT_STATE_ARG_COMMA );
             softfloat_commonNaNToF128M( &commonNaN, zWPtr );
             return;
Index: trunk/src/libs/softfloat-3e/source/f32_to_f16.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f32_to_f16.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f32_to_f16.c	(revision 94558)
@@ -42,5 +42,5 @@
 #include "softfloat.h"
 
-float16_t f32_to_f16( float32_t a )
+float16_t f32_to_f16( float32_t a SOFTFLOAT_STATE_DECL_COMMA )
 {
     union ui32_f32 uA;
@@ -64,5 +64,5 @@
     if ( exp == 0xFF ) {
         if ( frac ) {
-            softfloat_f32UIToCommonNaN( uiA, &commonNaN );
+            softfloat_f32UIToCommonNaN( uiA, &commonNaN SOFTFLOAT_STATE_ARG_COMMA );
             uiZ = softfloat_commonNaNToF16UI( &commonNaN );
         } else {
@@ -80,5 +80,5 @@
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
-    return softfloat_roundPackToF16( sign, exp - 0x71, frac16 | 0x4000 );
+    return softfloat_roundPackToF16( sign, exp - 0x71, frac16 | 0x4000 SOFTFLOAT_STATE_ARG_COMMA );
  uiZ:
     uZ.ui = uiZ;
Index: trunk/src/libs/softfloat-3e/source/f32_to_f64.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f32_to_f64.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f32_to_f64.c	(revision 94558)
@@ -42,5 +42,5 @@
 #include "softfloat.h"
 
-float64_t f32_to_f64( float32_t a )
+float64_t f32_to_f64( float32_t a SOFTFLOAT_STATE_DECL_COMMA )
 {
     union ui32_f32 uA;
@@ -65,5 +65,5 @@
     if ( exp == 0xFF ) {
         if ( frac ) {
-            softfloat_f32UIToCommonNaN( uiA, &commonNaN );
+            softfloat_f32UIToCommonNaN( uiA, &commonNaN SOFTFLOAT_STATE_ARG_COMMA );
             uiZ = softfloat_commonNaNToF64UI( &commonNaN );
         } else {
Index: trunk/src/libs/softfloat-3e/source/f32_to_i32.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f32_to_i32.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f32_to_i32.c	(revision 94558)
@@ -42,5 +42,5 @@
 #include "softfloat.h"
 
-int_fast32_t f32_to_i32( float32_t a, uint_fast8_t roundingMode, bool exact )
+int_fast32_t f32_to_i32( float32_t a, uint_fast8_t roundingMode, bool exact SOFTFLOAT_STATE_DECL_COMMA )
 {
     union ui32_f32 uA;
@@ -68,5 +68,5 @@
         sign = 1;
 #else
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
         return i32_fromNaN;
 #endif
@@ -79,5 +79,5 @@
     shiftDist = 0xAA - exp;
     if ( 0 < shiftDist ) sig64 = softfloat_shiftRightJam64( sig64, shiftDist );
-    return softfloat_roundToI32( sign, sig64, roundingMode, exact );
+    return softfloat_roundToI32( sign, sig64, roundingMode, exact SOFTFLOAT_STATE_ARG_COMMA );
 
 }
Index: trunk/src/libs/softfloat-3e/source/f32_to_i32_r_minMag.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f32_to_i32_r_minMag.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f32_to_i32_r_minMag.c	(revision 94558)
@@ -42,5 +42,5 @@
 #include "softfloat.h"
 
-int_fast32_t f32_to_i32_r_minMag( float32_t a, bool exact )
+int_fast32_t f32_to_i32_r_minMag( float32_t a, bool exact SOFTFLOAT_STATE_DECL_COMMA )
 {
     union ui32_f32 uA;
@@ -72,5 +72,5 @@
     if ( shiftDist <= 0 ) {
         if ( uiA == packToF32UI( 1, 0x9E, 0 ) ) return -0x7FFFFFFF - 1;
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
         return
             (exp == 0xFF) && sig ? i32_fromNaN
Index: trunk/src/libs/softfloat-3e/source/f32_to_i64.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f32_to_i64.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f32_to_i64.c	(revision 94558)
@@ -42,5 +42,5 @@
 #include "softfloat.h"
 
-int_fast64_t f32_to_i64( float32_t a, uint_fast8_t roundingMode, bool exact )
+int_fast64_t f32_to_i64( float32_t a, uint_fast8_t roundingMode, bool exact SOFTFLOAT_STATE_DECL_COMMA )
 {
     union ui32_f32 uA;
@@ -68,5 +68,5 @@
     shiftDist = 0xBE - exp;
     if ( shiftDist < 0 ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
         return
             (exp == 0xFF) && sig ? i64_fromNaN
@@ -84,5 +84,5 @@
         extra = sig64Extra.extra;
     }
-    return softfloat_roundToI64( sign, sig64, extra, roundingMode, exact );
+    return softfloat_roundToI64( sign, sig64, extra, roundingMode, exact SOFTFLOAT_STATE_ARG_COMMA );
 #else
     extSig[indexWord( 3, 2 )] = sig<<8;
@@ -90,5 +90,5 @@
     extSig[indexWord( 3, 0 )] = 0;
     if ( shiftDist ) softfloat_shiftRightJam96M( extSig, shiftDist, extSig );
-    return softfloat_roundMToI64( sign, extSig, roundingMode, exact );
+    return softfloat_roundMToI64( sign, extSig, roundingMode, exact SOFTFLOAT_STATE_ARG_COMMA );
 #endif
 
Index: trunk/src/libs/softfloat-3e/source/f32_to_i64_r_minMag.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f32_to_i64_r_minMag.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f32_to_i64_r_minMag.c	(revision 94558)
@@ -42,5 +42,5 @@
 #include "softfloat.h"
 
-int_fast64_t f32_to_i64_r_minMag( float32_t a, bool exact )
+int_fast64_t f32_to_i64_r_minMag( float32_t a, bool exact SOFTFLOAT_STATE_DECL_COMMA )
 {
     union ui32_f32 uA;
@@ -75,5 +75,5 @@
             return -INT64_C( 0x7FFFFFFFFFFFFFFF ) - 1;
         }
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
         return
             (exp == 0xFF) && sig ? i64_fromNaN
Index: trunk/src/libs/softfloat-3e/source/f32_to_ui32.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f32_to_ui32.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f32_to_ui32.c	(revision 94558)
@@ -42,5 +42,5 @@
 #include "softfloat.h"
 
-uint_fast32_t f32_to_ui32( float32_t a, uint_fast8_t roundingMode, bool exact )
+uint_fast32_t f32_to_ui32( float32_t a, uint_fast8_t roundingMode, bool exact SOFTFLOAT_STATE_DECL_COMMA )
 {
     union ui32_f32 uA;
@@ -68,5 +68,5 @@
         sign = 1;
 #else
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
         return ui32_fromNaN;
 #endif
@@ -79,5 +79,5 @@
     shiftDist = 0xAA - exp;
     if ( 0 < shiftDist ) sig64 = softfloat_shiftRightJam64( sig64, shiftDist );
-    return softfloat_roundToUI32( sign, sig64, roundingMode, exact );
+    return softfloat_roundToUI32( sign, sig64, roundingMode, exact SOFTFLOAT_STATE_ARG_COMMA );
 
 }
Index: trunk/src/libs/softfloat-3e/source/f32_to_ui32_r_minMag.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f32_to_ui32_r_minMag.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f32_to_ui32_r_minMag.c	(revision 94558)
@@ -42,5 +42,5 @@
 #include "softfloat.h"
 
-uint_fast32_t f32_to_ui32_r_minMag( float32_t a, bool exact )
+uint_fast32_t f32_to_ui32_r_minMag( float32_t a, bool exact SOFTFLOAT_STATE_DECL_COMMA )
 {
     union ui32_f32 uA;
@@ -71,5 +71,5 @@
     sign = signF32UI( uiA );
     if ( sign || (shiftDist < 0) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
         return
             (exp == 0xFF) && sig ? ui32_fromNaN
Index: trunk/src/libs/softfloat-3e/source/f32_to_ui64.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f32_to_ui64.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f32_to_ui64.c	(revision 94558)
@@ -42,5 +42,5 @@
 #include "softfloat.h"
 
-uint_fast64_t f32_to_ui64( float32_t a, uint_fast8_t roundingMode, bool exact )
+uint_fast64_t f32_to_ui64( float32_t a, uint_fast8_t roundingMode, bool exact SOFTFLOAT_STATE_DECL_COMMA )
 {
     union ui32_f32 uA;
@@ -68,5 +68,5 @@
     shiftDist = 0xBE - exp;
     if ( shiftDist < 0 ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
         return
             (exp == 0xFF) && sig ? ui64_fromNaN
@@ -84,5 +84,5 @@
         extra = sig64Extra.extra;
     }
-    return softfloat_roundToUI64( sign, sig64, extra, roundingMode, exact );
+    return softfloat_roundToUI64( sign, sig64, extra, roundingMode, exact SOFTFLOAT_STATE_ARG_COMMA );
 #else
     extSig[indexWord( 3, 2 )] = sig<<8;
@@ -90,5 +90,5 @@
     extSig[indexWord( 3, 0 )] = 0;
     if ( shiftDist ) softfloat_shiftRightJam96M( extSig, shiftDist, extSig );
-    return softfloat_roundMToUI64( sign, extSig, roundingMode, exact );
+    return softfloat_roundMToUI64( sign, extSig, roundingMode, exact SOFTFLOAT_STATE_ARG_COMMA);
 #endif
 
Index: trunk/src/libs/softfloat-3e/source/f32_to_ui64_r_minMag.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f32_to_ui64_r_minMag.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f32_to_ui64_r_minMag.c	(revision 94558)
@@ -42,5 +42,5 @@
 #include "softfloat.h"
 
-uint_fast64_t f32_to_ui64_r_minMag( float32_t a, bool exact )
+uint_fast64_t f32_to_ui64_r_minMag( float32_t a, bool exact SOFTFLOAT_STATE_DECL_COMMA )
 {
     union ui32_f32 uA;
@@ -71,5 +71,5 @@
     sign = signF32UI( uiA );
     if ( sign || (shiftDist < 0) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
         return
             (exp == 0xFF) && sig ? ui64_fromNaN
Index: trunk/src/libs/softfloat-3e/source/f64_add.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f64_add.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f64_add.c	(revision 94558)
@@ -41,5 +41,5 @@
 #include "softfloat.h"
 
-float64_t f64_add( float64_t a, float64_t b )
+float64_t f64_add( float64_t a, float64_t b SOFTFLOAT_STATE_DECL_COMMA )
 {
     union ui64_f64 uA;
@@ -50,5 +50,5 @@
     bool signB;
 #if ! defined INLINE_LEVEL || (INLINE_LEVEL < 2)
-    float64_t (*magsFuncPtr)( uint_fast64_t, uint_fast64_t, bool );
+    float64_t (*magsFuncPtr)( uint_fast64_t, uint_fast64_t, bool SOFTFLOAT_STATE_DECL_COMMA );
 #endif
 
@@ -61,12 +61,12 @@
 #if defined INLINE_LEVEL && (2 <= INLINE_LEVEL)
     if ( signA == signB ) {
-        return softfloat_addMagsF64( uiA, uiB, signA );
+        return softfloat_addMagsF64( uiA, uiB, signA SOFTFLOAT_STATE_ARG_COMMA );
     } else {
-        return softfloat_subMagsF64( uiA, uiB, signA );
+        return softfloat_subMagsF64( uiA, uiB, signA SOFTFLOAT_STATE_ARG_COMMA );
     }
 #else
     magsFuncPtr =
         (signA == signB) ? softfloat_addMagsF64 : softfloat_subMagsF64;
-    return (*magsFuncPtr)( uiA, uiB, signA );
+    return (*magsFuncPtr)( uiA, uiB, signA SOFTFLOAT_STATE_ARG_COMMA );
 #endif
 
Index: trunk/src/libs/softfloat-3e/source/f64_div.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f64_div.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f64_div.c	(revision 94558)
@@ -42,5 +42,5 @@
 #include "softfloat.h"
 
-float64_t f64_div( float64_t a, float64_t b )
+float64_t f64_div( float64_t a, float64_t b SOFTFLOAT_STATE_DECL_COMMA )
 {
     union ui64_f64 uA;
@@ -96,5 +96,5 @@
         if ( ! sigB ) {
             if ( ! (expA | sigA) ) goto invalid;
-            softfloat_raiseFlags( softfloat_flag_infinite );
+            softfloat_raiseFlags( softfloat_flag_infinite SOFTFLOAT_STATE_ARG_COMMA );
             goto infinity;
         }
@@ -144,14 +144,14 @@
         }
     }
-    return softfloat_roundPackToF64( signZ, expZ, sigZ );
+    return softfloat_roundPackToF64( signZ, expZ, sigZ SOFTFLOAT_STATE_ARG_COMMA );
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  propagateNaN:
-    uiZ = softfloat_propagateNaNF64UI( uiA, uiB );
+    uiZ = softfloat_propagateNaNF64UI( uiA, uiB SOFTFLOAT_STATE_ARG_COMMA );
     goto uiZ;
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  invalid:
-    softfloat_raiseFlags( softfloat_flag_invalid );
+    softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
     uiZ = defaultNaNF64UI;
     goto uiZ;
Index: trunk/src/libs/softfloat-3e/source/f64_eq.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f64_eq.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f64_eq.c	(revision 94558)
@@ -42,5 +42,5 @@
 #include "softfloat.h"
 
-bool f64_eq( float64_t a, float64_t b )
+bool f64_eq( float64_t a, float64_t b SOFTFLOAT_STATE_DECL_COMMA )
 {
     union ui64_f64 uA;
@@ -57,5 +57,5 @@
             softfloat_isSigNaNF64UI( uiA ) || softfloat_isSigNaNF64UI( uiB )
         ) {
-            softfloat_raiseFlags( softfloat_flag_invalid );
+            softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
         }
         return false;
Index: trunk/src/libs/softfloat-3e/source/f64_eq_signaling.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f64_eq_signaling.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f64_eq_signaling.c	(revision 94558)
@@ -41,5 +41,5 @@
 #include "softfloat.h"
 
-bool f64_eq_signaling( float64_t a, float64_t b )
+bool f64_eq_signaling( float64_t a, float64_t b SOFTFLOAT_STATE_DECL_COMMA )
 {
     union ui64_f64 uA;
@@ -53,5 +53,5 @@
     uiB = uB.ui;
     if ( isNaNF64UI( uiA ) || isNaNF64UI( uiB ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
         return false;
     }
Index: trunk/src/libs/softfloat-3e/source/f64_le.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f64_le.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f64_le.c	(revision 94558)
@@ -41,5 +41,5 @@
 #include "softfloat.h"
 
-bool f64_le( float64_t a, float64_t b )
+bool f64_le( float64_t a, float64_t b SOFTFLOAT_STATE_DECL_COMMA )
 {
     union ui64_f64 uA;
@@ -54,5 +54,5 @@
     uiB = uB.ui;
     if ( isNaNF64UI( uiA ) || isNaNF64UI( uiB ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
         return false;
     }
Index: trunk/src/libs/softfloat-3e/source/f64_le_quiet.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f64_le_quiet.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f64_le_quiet.c	(revision 94558)
@@ -42,5 +42,5 @@
 #include "softfloat.h"
 
-bool f64_le_quiet( float64_t a, float64_t b )
+bool f64_le_quiet( float64_t a, float64_t b SOFTFLOAT_STATE_DECL_COMMA )
 {
     union ui64_f64 uA;
@@ -58,5 +58,5 @@
             softfloat_isSigNaNF64UI( uiA ) || softfloat_isSigNaNF64UI( uiB )
         ) {
-            softfloat_raiseFlags( softfloat_flag_invalid );
+            softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
         }
         return false;
Index: trunk/src/libs/softfloat-3e/source/f64_lt.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f64_lt.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f64_lt.c	(revision 94558)
@@ -41,5 +41,5 @@
 #include "softfloat.h"
 
-bool f64_lt( float64_t a, float64_t b )
+bool f64_lt( float64_t a, float64_t b SOFTFLOAT_STATE_DECL_COMMA )
 {
     union ui64_f64 uA;
@@ -54,5 +54,5 @@
     uiB = uB.ui;
     if ( isNaNF64UI( uiA ) || isNaNF64UI( uiB ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
         return false;
     }
Index: trunk/src/libs/softfloat-3e/source/f64_lt_quiet.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f64_lt_quiet.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f64_lt_quiet.c	(revision 94558)
@@ -42,5 +42,5 @@
 #include "softfloat.h"
 
-bool f64_lt_quiet( float64_t a, float64_t b )
+bool f64_lt_quiet( float64_t a, float64_t b SOFTFLOAT_STATE_DECL_COMMA )
 {
     union ui64_f64 uA;
@@ -58,5 +58,5 @@
             softfloat_isSigNaNF64UI( uiA ) || softfloat_isSigNaNF64UI( uiB )
         ) {
-            softfloat_raiseFlags( softfloat_flag_invalid );
+            softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
         }
         return false;
Index: trunk/src/libs/softfloat-3e/source/f64_mul.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f64_mul.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f64_mul.c	(revision 94558)
@@ -42,5 +42,5 @@
 #include "softfloat.h"
 
-float64_t f64_mul( float64_t a, float64_t b )
+float64_t f64_mul( float64_t a, float64_t b SOFTFLOAT_STATE_DECL_COMMA )
 {
     union ui64_f64 uA;
@@ -123,9 +123,9 @@
         sigZ <<= 1;
     }
-    return softfloat_roundPackToF64( signZ, expZ, sigZ );
+    return softfloat_roundPackToF64( signZ, expZ, sigZ SOFTFLOAT_STATE_ARG_COMMA );
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  propagateNaN:
-    uiZ = softfloat_propagateNaNF64UI( uiA, uiB );
+    uiZ = softfloat_propagateNaNF64UI( uiA, uiB SOFTFLOAT_STATE_ARG_COMMA );
     goto uiZ;
     /*------------------------------------------------------------------------
@@ -133,5 +133,5 @@
  infArg:
     if ( ! magBits ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
         uiZ = defaultNaNF64UI;
     } else {
Index: trunk/src/libs/softfloat-3e/source/f64_mulAdd.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f64_mulAdd.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f64_mulAdd.c	(revision 94558)
@@ -40,5 +40,5 @@
 #include "softfloat.h"
 
-float64_t f64_mulAdd( float64_t a, float64_t b, float64_t c )
+float64_t f64_mulAdd( float64_t a, float64_t b, float64_t c SOFTFLOAT_STATE_DECL_COMMA )
 {
     union ui64_f64 uA;
@@ -55,5 +55,5 @@
     uC.f = c;
     uiC = uC.ui;
-    return softfloat_mulAddF64( uiA, uiB, uiC, 0 );
+    return softfloat_mulAddF64( uiA, uiB, uiC, 0 SOFTFLOAT_STATE_ARG_COMMA );
 
 }
Index: trunk/src/libs/softfloat-3e/source/f64_rem.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f64_rem.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f64_rem.c	(revision 94558)
@@ -42,5 +42,5 @@
 #include "softfloat.h"
 
-float64_t f64_rem( float64_t a, float64_t b )
+float64_t f64_rem( float64_t a, float64_t b SOFTFLOAT_STATE_DECL_COMMA )
 {
     union ui64_f64 uA;
@@ -173,12 +173,12 @@
         rem = -rem;
     }
-    return softfloat_normRoundPackToF64( signRem, expB, rem );
+    return softfloat_normRoundPackToF64( signRem, expB, rem SOFTFLOAT_STATE_ARG_COMMA );
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  propagateNaN:
-    uiZ = softfloat_propagateNaNF64UI( uiA, uiB );
+    uiZ = softfloat_propagateNaNF64UI( uiA, uiB SOFTFLOAT_STATE_ARG_COMMA );
     goto uiZ;
  invalid:
-    softfloat_raiseFlags( softfloat_flag_invalid );
+    softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
     uiZ = defaultNaNF64UI;
  uiZ:
Index: trunk/src/libs/softfloat-3e/source/f64_roundToInt.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f64_roundToInt.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f64_roundToInt.c	(revision 94558)
@@ -43,5 +43,5 @@
 #include <iprt/cdefs.h> /* VBox: for RT_FALL_THROUGH */
 
-float64_t f64_roundToInt( float64_t a, uint_fast8_t roundingMode, bool exact )
+float64_t f64_roundToInt( float64_t a, uint_fast8_t roundingMode, bool exact SOFTFLOAT_STATE_DECL_COMMA )
 {
     union ui64_f64 uA;
@@ -87,5 +87,5 @@
     if ( 0x433 <= exp ) {
         if ( (exp == 0x7FF) && fracF64UI( uiA ) ) {
-            uiZ = softfloat_propagateNaNF64UI( uiA, 0 );
+            uiZ = softfloat_propagateNaNF64UI( uiA, 0 SOFTFLOAT_STATE_ARG_COMMA );
             goto uiZ;
         }
Index: trunk/src/libs/softfloat-3e/source/f64_sqrt.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f64_sqrt.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f64_sqrt.c	(revision 94558)
@@ -42,5 +42,5 @@
 #include "softfloat.h"
 
-float64_t f64_sqrt( float64_t a )
+float64_t f64_sqrt( float64_t a SOFTFLOAT_STATE_DECL_COMMA )
 {
     union ui64_f64 uA;
@@ -68,5 +68,5 @@
     if ( expA == 0x7FF ) {
         if ( sigA ) {
-            uiZ = softfloat_propagateNaNF64UI( uiA, 0 );
+            uiZ = softfloat_propagateNaNF64UI( uiA, 0 SOFTFLOAT_STATE_ARG_COMMA );
             goto uiZ;
         }
@@ -120,9 +120,9 @@
         }
     }
-    return softfloat_roundPackToF64( 0, expZ, sigZ );
+    return softfloat_roundPackToF64( 0, expZ, sigZ SOFTFLOAT_STATE_ARG_COMMA );
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  invalid:
-    softfloat_raiseFlags( softfloat_flag_invalid );
+    softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
     uiZ = defaultNaNF64UI;
  uiZ:
Index: trunk/src/libs/softfloat-3e/source/f64_sub.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f64_sub.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f64_sub.c	(revision 94558)
@@ -41,5 +41,5 @@
 #include "softfloat.h"
 
-float64_t f64_sub( float64_t a, float64_t b )
+float64_t f64_sub( float64_t a, float64_t b SOFTFLOAT_STATE_DECL_COMMA )
 {
     union ui64_f64 uA;
@@ -50,5 +50,5 @@
     bool signB;
 #if ! defined INLINE_LEVEL || (INLINE_LEVEL < 2)
-    float64_t (*magsFuncPtr)( uint_fast64_t, uint_fast64_t, bool );
+    float64_t (*magsFuncPtr)( uint_fast64_t, uint_fast64_t, bool SOFTFLOAT_STATE_DECL_COMMA );
 #endif
 
@@ -61,12 +61,12 @@
 #if defined INLINE_LEVEL && (2 <= INLINE_LEVEL)
     if ( signA == signB ) {
-        return softfloat_subMagsF64( uiA, uiB, signA );
+        return softfloat_subMagsF64( uiA, uiB, signA SOFTFLOAT_STATE_ARG_COMMA );
     } else {
-        return softfloat_addMagsF64( uiA, uiB, signA );
+        return softfloat_addMagsF64( uiA, uiB, signA SOFTFLOAT_STATE_ARG_COMMA );
     }
 #else
     magsFuncPtr =
         (signA == signB) ? softfloat_subMagsF64 : softfloat_addMagsF64;
-    return (*magsFuncPtr)( uiA, uiB, signA );
+    return (*magsFuncPtr)( uiA, uiB, signA SOFTFLOAT_STATE_ARG_COMMA );
 #endif
 
Index: trunk/src/libs/softfloat-3e/source/f64_to_extF80.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f64_to_extF80.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f64_to_extF80.c	(revision 94558)
@@ -42,5 +42,5 @@
 #include "softfloat.h"
 
-extFloat80_t f64_to_extF80( float64_t a )
+extFloat80_t f64_to_extF80( float64_t a SOFTFLOAT_STATE_DECL_COMMA )
 {
     union ui64_f64 uA;
@@ -67,5 +67,5 @@
     if ( exp == 0x7FF ) {
         if ( frac ) {
-            softfloat_f64UIToCommonNaN( uiA, &commonNaN );
+            softfloat_f64UIToCommonNaN( uiA, &commonNaN SOFTFLOAT_STATE_ARG_COMMA );
             uiZ = softfloat_commonNaNToExtF80UI( &commonNaN );
             uiZ64 = uiZ.v64;
Index: trunk/src/libs/softfloat-3e/source/f64_to_extF80M.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f64_to_extF80M.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f64_to_extF80M.c	(revision 94558)
@@ -44,8 +44,8 @@
 #ifdef SOFTFLOAT_FAST_INT64
 
-void f64_to_extF80M( float64_t a, extFloat80_t *zPtr )
+void f64_to_extF80M( float64_t a, extFloat80_t *zPtr SOFTFLOAT_STATE_DECL_COMMA )
 {
 
-    *zPtr = f64_to_extF80( a );
+    *zPtr = f64_to_extF80( a SOFTFLOAT_STATE_ARG_COMMA );
 
 }
@@ -53,5 +53,5 @@
 #else
 
-void f64_to_extF80M( float64_t a, extFloat80_t *zPtr )
+void f64_to_extF80M( float64_t a, extFloat80_t *zPtr SOFTFLOAT_STATE_DECL_COMMA )
 {
     struct extFloat80M *zSPtr;
@@ -78,5 +78,5 @@
     if ( exp == 0x7FF ) {
         if ( frac ) {
-            softfloat_f64UIToCommonNaN( uiA, &commonNaN );
+            softfloat_f64UIToCommonNaN( uiA, &commonNaN SOFTFLOAT_STATE_ARG_COMMA );
             softfloat_commonNaNToExtF80M( &commonNaN, zSPtr );
             return;
Index: trunk/src/libs/softfloat-3e/source/f64_to_f128.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f64_to_f128.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f64_to_f128.c	(revision 94558)
@@ -42,5 +42,5 @@
 #include "softfloat.h"
 
-float128_t f64_to_f128( float64_t a )
+float128_t f64_to_f128( float64_t a SOFTFLOAT_STATE_DECL_COMMA )
 {
     union ui64_f64 uA;
@@ -66,5 +66,5 @@
     if ( exp == 0x7FF ) {
         if ( frac ) {
-            softfloat_f64UIToCommonNaN( uiA, &commonNaN );
+            softfloat_f64UIToCommonNaN( uiA, &commonNaN SOFTFLOAT_STATE_ARG_COMMA );
             uiZ = softfloat_commonNaNToF128UI( &commonNaN );
         } else {
Index: trunk/src/libs/softfloat-3e/source/f64_to_f128M.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f64_to_f128M.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f64_to_f128M.c	(revision 94558)
@@ -44,8 +44,8 @@
 #ifdef SOFTFLOAT_FAST_INT64
 
-void f64_to_f128M( float64_t a, float128_t *zPtr )
+void f64_to_f128M( float64_t a, float128_t *zPtr SOFTFLOAT_STATE_DECL_COMMA )
 {
 
-    *zPtr = f64_to_f128( a );
+    *zPtr = f64_to_f128( a SOFTFLOAT_STATE_ARG_COMMA );
 
 }
@@ -53,5 +53,5 @@
 #else
 
-void f64_to_f128M( float64_t a, float128_t *zPtr )
+void f64_to_f128M( float64_t a, float128_t *zPtr SOFTFLOAT_STATE_DECL_COMMA )
 {
     uint32_t *zWPtr;
@@ -80,5 +80,5 @@
     if ( exp == 0x7FF ) {
         if ( frac ) {
-            softfloat_f64UIToCommonNaN( uiA, &commonNaN );
+            softfloat_f64UIToCommonNaN( uiA, &commonNaN SOFTFLOAT_STATE_ARG_COMMA );
             softfloat_commonNaNToF128M( &commonNaN, zWPtr );
             return;
Index: trunk/src/libs/softfloat-3e/source/f64_to_f16.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f64_to_f16.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f64_to_f16.c	(revision 94558)
@@ -42,5 +42,5 @@
 #include "softfloat.h"
 
-float16_t f64_to_f16( float64_t a )
+float16_t f64_to_f16( float64_t a SOFTFLOAT_STATE_DECL_COMMA )
 {
     union ui64_f64 uA;
@@ -64,5 +64,5 @@
     if ( exp == 0x7FF ) {
         if ( frac ) {
-            softfloat_f64UIToCommonNaN( uiA, &commonNaN );
+            softfloat_f64UIToCommonNaN( uiA, &commonNaN SOFTFLOAT_STATE_ARG_COMMA );
             uiZ = softfloat_commonNaNToF16UI( &commonNaN );
         } else {
@@ -80,5 +80,5 @@
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
-    return softfloat_roundPackToF16( sign, exp - 0x3F1, frac16 | 0x4000 );
+    return softfloat_roundPackToF16( sign, exp - 0x3F1, frac16 | 0x4000 SOFTFLOAT_STATE_ARG_COMMA );
  uiZ:
     uZ.ui = uiZ;
Index: trunk/src/libs/softfloat-3e/source/f64_to_f32.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f64_to_f32.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f64_to_f32.c	(revision 94558)
@@ -42,5 +42,5 @@
 #include "softfloat.h"
 
-float32_t f64_to_f32( float64_t a )
+float32_t f64_to_f32( float64_t a SOFTFLOAT_STATE_DECL_COMMA )
 {
     union ui64_f64 uA;
@@ -64,5 +64,5 @@
     if ( exp == 0x7FF ) {
         if ( frac ) {
-            softfloat_f64UIToCommonNaN( uiA, &commonNaN );
+            softfloat_f64UIToCommonNaN( uiA, &commonNaN SOFTFLOAT_STATE_ARG_COMMA );
             uiZ = softfloat_commonNaNToF32UI( &commonNaN );
         } else {
@@ -80,5 +80,5 @@
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
-    return softfloat_roundPackToF32( sign, exp - 0x381, frac32 | 0x40000000 );
+    return softfloat_roundPackToF32( sign, exp - 0x381, frac32 | 0x40000000 SOFTFLOAT_STATE_ARG_COMMA );
  uiZ:
     uZ.ui = uiZ;
Index: trunk/src/libs/softfloat-3e/source/f64_to_i32.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f64_to_i32.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f64_to_i32.c	(revision 94558)
@@ -42,5 +42,5 @@
 #include "softfloat.h"
 
-int_fast32_t f64_to_i32( float64_t a, uint_fast8_t roundingMode, bool exact )
+int_fast32_t f64_to_i32( float64_t a, uint_fast8_t roundingMode, bool exact SOFTFLOAT_STATE_DECL_COMMA )
 {
     union ui64_f64 uA;
@@ -67,5 +67,5 @@
         sign = 1;
 #else
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
         return i32_fromNaN;
 #endif
@@ -77,5 +77,5 @@
     shiftDist = 0x427 - exp;
     if ( 0 < shiftDist ) sig = softfloat_shiftRightJam64( sig, shiftDist );
-    return softfloat_roundToI32( sign, sig, roundingMode, exact );
+    return softfloat_roundToI32( sign, sig, roundingMode, exact SOFTFLOAT_STATE_ARG_COMMA );
 
 }
Index: trunk/src/libs/softfloat-3e/source/f64_to_i32_r_minMag.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f64_to_i32_r_minMag.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f64_to_i32_r_minMag.c	(revision 94558)
@@ -42,5 +42,5 @@
 #include "softfloat.h"
 
-int_fast32_t f64_to_i32_r_minMag( float64_t a, bool exact )
+int_fast32_t f64_to_i32_r_minMag( float64_t a, bool exact SOFTFLOAT_STATE_DECL_COMMA )
 {
     union ui64_f64 uA;
@@ -79,5 +79,5 @@
             return -0x7FFFFFFF - 1;
         }
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
         return
             (exp == 0x7FF) && sig ? i32_fromNaN
Index: trunk/src/libs/softfloat-3e/source/f64_to_i64.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f64_to_i64.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f64_to_i64.c	(revision 94558)
@@ -42,5 +42,5 @@
 #include "softfloat.h"
 
-int_fast64_t f64_to_i64( float64_t a, uint_fast8_t roundingMode, bool exact )
+int_fast64_t f64_to_i64( float64_t a, uint_fast8_t roundingMode, bool exact SOFTFLOAT_STATE_DECL_COMMA )
 {
     union ui64_f64 uA;
@@ -77,5 +77,5 @@
     return
         softfloat_roundToI64(
-            sign, sigExtra.v, sigExtra.extra, roundingMode, exact );
+            sign, sigExtra.v, sigExtra.extra, roundingMode, exact SOFTFLOAT_STATE_ARG_COMMA );
 #else
     extSig[indexWord( 3, 0 )] = 0;
@@ -90,10 +90,10 @@
         softfloat_shiftRightJam96M( extSig, shiftDist, extSig );
     }
-    return softfloat_roundMToI64( sign, extSig, roundingMode, exact );
+    return softfloat_roundMToI64( sign, extSig, roundingMode, exact SOFTFLOAT_STATE_ARG_COMMA );
 #endif
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  invalid:
-    softfloat_raiseFlags( softfloat_flag_invalid );
+    softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
     return
         (exp == 0x7FF) && fracF64UI( uiA ) ? i64_fromNaN
Index: trunk/src/libs/softfloat-3e/source/f64_to_i64_r_minMag.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f64_to_i64_r_minMag.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f64_to_i64_r_minMag.c	(revision 94558)
@@ -42,5 +42,5 @@
 #include "softfloat.h"
 
-int_fast64_t f64_to_i64_r_minMag( float64_t a, bool exact )
+int_fast64_t f64_to_i64_r_minMag( float64_t a, bool exact SOFTFLOAT_STATE_DECL_COMMA )
 {
     union ui64_f64 uA;
@@ -69,5 +69,5 @@
                 return -INT64_C( 0x7FFFFFFFFFFFFFFF ) - 1;
             }
-            softfloat_raiseFlags( softfloat_flag_invalid );
+            softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
             return
                 (exp == 0x7FF) && sig ? i64_fromNaN
Index: trunk/src/libs/softfloat-3e/source/f64_to_ui32.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f64_to_ui32.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f64_to_ui32.c	(revision 94558)
@@ -42,5 +42,5 @@
 #include "softfloat.h"
 
-uint_fast32_t f64_to_ui32( float64_t a, uint_fast8_t roundingMode, bool exact )
+uint_fast32_t f64_to_ui32( float64_t a, uint_fast8_t roundingMode, bool exact SOFTFLOAT_STATE_DECL_COMMA )
 {
     union ui64_f64 uA;
@@ -67,5 +67,5 @@
         sign = 1;
 #else
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
         return ui32_fromNaN;
 #endif
@@ -77,5 +77,5 @@
     shiftDist = 0x427 - exp;
     if ( 0 < shiftDist ) sig = softfloat_shiftRightJam64( sig, shiftDist );
-    return softfloat_roundToUI32( sign, sig, roundingMode, exact );
+    return softfloat_roundToUI32( sign, sig, roundingMode, exact SOFTFLOAT_STATE_ARG_COMMA );
 
 }
Index: trunk/src/libs/softfloat-3e/source/f64_to_ui32_r_minMag.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f64_to_ui32_r_minMag.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f64_to_ui32_r_minMag.c	(revision 94558)
@@ -42,5 +42,5 @@
 #include "softfloat.h"
 
-uint_fast32_t f64_to_ui32_r_minMag( float64_t a, bool exact )
+uint_fast32_t f64_to_ui32_r_minMag( float64_t a, bool exact SOFTFLOAT_STATE_DECL_COMMA )
 {
     union ui64_f64 uA;
@@ -71,5 +71,5 @@
     sign = signF64UI( uiA );
     if ( sign || (shiftDist < 21) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
         return
             (exp == 0x7FF) && sig ? ui32_fromNaN
Index: trunk/src/libs/softfloat-3e/source/f64_to_ui64.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f64_to_ui64.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f64_to_ui64.c	(revision 94558)
@@ -42,5 +42,5 @@
 #include "softfloat.h"
 
-uint_fast64_t f64_to_ui64( float64_t a, uint_fast8_t roundingMode, bool exact )
+uint_fast64_t f64_to_ui64( float64_t a, uint_fast8_t roundingMode, bool exact SOFTFLOAT_STATE_DECL_COMMA )
 {
     union ui64_f64 uA;
@@ -77,5 +77,5 @@
     return
         softfloat_roundToUI64(
-            sign, sigExtra.v, sigExtra.extra, roundingMode, exact );
+            sign, sigExtra.v, sigExtra.extra, roundingMode, exact SOFTFLOAT_STATE_ARG_COMMA );
 #else
     extSig[indexWord( 3, 0 )] = 0;
@@ -90,10 +90,10 @@
         softfloat_shiftRightJam96M( extSig, shiftDist, extSig );
     }
-    return softfloat_roundMToUI64( sign, extSig, roundingMode, exact );
+    return softfloat_roundMToUI64( sign, extSig, roundingMode, exact SOFTFLOAT_STATE_ARG_COMMA);
 #endif
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  invalid:
-    softfloat_raiseFlags( softfloat_flag_invalid );
+    softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
     return
         (exp == 0x7FF) && fracF64UI( uiA ) ? ui64_fromNaN
Index: trunk/src/libs/softfloat-3e/source/f64_to_ui64_r_minMag.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/f64_to_ui64_r_minMag.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/f64_to_ui64_r_minMag.c	(revision 94558)
@@ -42,5 +42,5 @@
 #include "softfloat.h"
 
-uint_fast64_t f64_to_ui64_r_minMag( float64_t a, bool exact )
+uint_fast64_t f64_to_ui64_r_minMag( float64_t a, bool exact SOFTFLOAT_STATE_DECL_COMMA )
 {
     union ui64_f64 uA;
@@ -85,5 +85,5 @@
     *------------------------------------------------------------------------*/
  invalid:
-    softfloat_raiseFlags( softfloat_flag_invalid );
+    softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
     return
         (exp == 0x7FF) && sig ? ui64_fromNaN
Index: trunk/src/libs/softfloat-3e/source/i32_to_extF80.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/i32_to_extF80.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/i32_to_extF80.c	(revision 94558)
@@ -41,5 +41,5 @@
 #include "softfloat.h"
 
-extFloat80_t i32_to_extF80( int32_t a )
+extFloat80_t i32_to_extF80( int32_t a SOFTFLOAT_STATE_DECL_COMMA )
 {
     uint_fast16_t uiZ64;
@@ -48,4 +48,5 @@
     int_fast8_t shiftDist;
     union { struct extFloat80M s; extFloat80_t f; } uZ;
+    SOFTFLOAT_STATE_NOREF();
 
     uiZ64 = 0;
Index: trunk/src/libs/softfloat-3e/source/i32_to_extF80M.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/i32_to_extF80M.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/i32_to_extF80M.c	(revision 94558)
@@ -42,8 +42,8 @@
 #ifdef SOFTFLOAT_FAST_INT64
 
-void i32_to_extF80M( int32_t a, extFloat80_t *zPtr )
+void i32_to_extF80M( int32_t a, extFloat80_t *zPtr SOFTFLOAT_STATE_DECL_COMMA )
 {
 
-    *zPtr = i32_to_extF80( a );
+    *zPtr = i32_to_extF80( a SOFTFLOAT_STATE_ARG_COMMA );
 
 }
@@ -51,5 +51,5 @@
 #else
 
-void i32_to_extF80M( int32_t a, extFloat80_t *zPtr )
+void i32_to_extF80M( int32_t a, extFloat80_t *zPtr SOFTFLOAT_STATE_DECL_COMMA )
 {
     struct extFloat80M *zSPtr;
@@ -59,4 +59,5 @@
     uint32_t absA;
     int_fast8_t shiftDist;
+    SOFTFLOAT_STATE_NOREF();
 
     zSPtr = (struct extFloat80M *) zPtr;
Index: trunk/src/libs/softfloat-3e/source/i32_to_f128.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/i32_to_f128.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/i32_to_f128.c	(revision 94558)
@@ -40,5 +40,5 @@
 #include "softfloat.h"
 
-float128_t i32_to_f128( int32_t a )
+float128_t i32_to_f128( int32_t a SOFTFLOAT_STATE_DECL_COMMA )
 {
     uint_fast64_t uiZ64;
@@ -47,4 +47,5 @@
     int_fast8_t shiftDist;
     union ui128_f128 uZ;
+    SOFTFLOAT_STATE_NOREF();
 
     uiZ64 = 0;
Index: trunk/src/libs/softfloat-3e/source/i32_to_f128M.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/i32_to_f128M.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/i32_to_f128M.c	(revision 94558)
@@ -42,8 +42,8 @@
 #ifdef SOFTFLOAT_FAST_INT64
 
-void i32_to_f128M( int32_t a, float128_t *zPtr )
+void i32_to_f128M( int32_t a, float128_t *zPtr SOFTFLOAT_STATE_DECL_COMMA )
 {
 
-    *zPtr = i32_to_f128( a );
+    *zPtr = i32_to_f128( a SOFTFLOAT_STATE_ARG_COMMA );
 
 }
@@ -51,5 +51,5 @@
 #else
 
-void i32_to_f128M( int32_t a, float128_t *zPtr )
+void i32_to_f128M( int32_t a, float128_t *zPtr SOFTFLOAT_STATE_DECL_COMMA )
 {
     uint32_t *zWPtr;
@@ -59,4 +59,5 @@
     int_fast8_t shiftDist;
     uint64_t normAbsA;
+    SOFTFLOAT_STATE_NOREF();
 
     zWPtr = (uint32_t *) zPtr;
Index: trunk/src/libs/softfloat-3e/source/i32_to_f16.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/i32_to_f16.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/i32_to_f16.c	(revision 94558)
@@ -41,5 +41,5 @@
 #include "softfloat.h"
 
-float16_t i32_to_f16( int32_t a )
+float16_t i32_to_f16( int32_t a SOFTFLOAT_STATE_DECL_COMMA )
 {
     bool sign;
@@ -65,5 +65,5 @@
                       | ((uint32_t) (absA<<(shiftDist & 31)) != 0)
                 : (uint_fast16_t) absA<<shiftDist;
-        return softfloat_roundPackToF16( sign, 0x1C - shiftDist, sig );
+        return softfloat_roundPackToF16( sign, 0x1C - shiftDist, sig SOFTFLOAT_STATE_ARG_COMMA );
     }
 
Index: trunk/src/libs/softfloat-3e/source/i32_to_f32.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/i32_to_f32.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/i32_to_f32.c	(revision 94558)
@@ -41,5 +41,5 @@
 #include "softfloat.h"
 
-float32_t i32_to_f32( int32_t a )
+float32_t i32_to_f32( int32_t a SOFTFLOAT_STATE_DECL_COMMA )
 {
     bool sign;
@@ -53,5 +53,5 @@
     }
     absA = sign ? -(uint_fast32_t) a : (uint_fast32_t) a;
-    return softfloat_normRoundPackToF32( sign, 0x9C, absA );
+    return softfloat_normRoundPackToF32( sign, 0x9C, absA SOFTFLOAT_STATE_ARG_COMMA );
 
 }
Index: trunk/src/libs/softfloat-3e/source/i32_to_f64.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/i32_to_f64.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/i32_to_f64.c	(revision 94558)
@@ -41,5 +41,5 @@
 #include "softfloat.h"
 
-float64_t i32_to_f64( int32_t a )
+float64_t i32_to_f64( int32_t a SOFTFLOAT_STATE_DECL_COMMA )
 {
     uint_fast64_t uiZ;
@@ -48,4 +48,5 @@
     int_fast8_t shiftDist;
     union ui64_f64 uZ;
+    SOFTFLOAT_STATE_NOREF();
 
     if ( ! a ) {
Index: trunk/src/libs/softfloat-3e/source/i64_to_extF80.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/i64_to_extF80.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/i64_to_extF80.c	(revision 94558)
@@ -41,5 +41,5 @@
 #include "softfloat.h"
 
-extFloat80_t i64_to_extF80( int64_t a )
+extFloat80_t i64_to_extF80( int64_t a SOFTFLOAT_STATE_DECL_COMMA )
 {
     uint_fast16_t uiZ64;
@@ -48,4 +48,5 @@
     int_fast8_t shiftDist;
     union { struct extFloat80M s; extFloat80_t f; } uZ;
+    SOFTFLOAT_STATE_NOREF();
 
     uiZ64 = 0;
Index: trunk/src/libs/softfloat-3e/source/i64_to_extF80M.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/i64_to_extF80M.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/i64_to_extF80M.c	(revision 94558)
@@ -42,8 +42,8 @@
 #ifdef SOFTFLOAT_FAST_INT64
 
-void i64_to_extF80M( int64_t a, extFloat80_t *zPtr )
+void i64_to_extF80M( int64_t a, extFloat80_t *zPtr SOFTFLOAT_STATE_DECL_COMMA )
 {
 
-    *zPtr = i64_to_extF80( a );
+    *zPtr = i64_to_extF80( a SOFTFLOAT_STATE_ARG_COMMA );
 
 }
@@ -51,5 +51,5 @@
 #else
 
-void i64_to_extF80M( int64_t a, extFloat80_t *zPtr )
+void i64_to_extF80M( int64_t a, extFloat80_t *zPtr SOFTFLOAT_STATE_DECL_COMMA )
 {
     struct extFloat80M *zSPtr;
@@ -59,4 +59,5 @@
     uint64_t absA;
     int_fast8_t shiftDist;
+    SOFTFLOAT_STATE_NOREF();
 
     zSPtr = (struct extFloat80M *) zPtr;
Index: trunk/src/libs/softfloat-3e/source/i64_to_f128.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/i64_to_f128.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/i64_to_f128.c	(revision 94558)
@@ -40,5 +40,5 @@
 #include "softfloat.h"
 
-float128_t i64_to_f128( int64_t a )
+float128_t i64_to_f128( int64_t a SOFTFLOAT_STATE_DECL_COMMA )
 {
     uint_fast64_t uiZ64, uiZ0;
@@ -48,4 +48,5 @@
     struct uint128 zSig;
     union ui128_f128 uZ;
+    SOFTFLOAT_STATE_NOREF();
 
     if ( ! a ) {
Index: trunk/src/libs/softfloat-3e/source/i64_to_f128M.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/i64_to_f128M.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/i64_to_f128M.c	(revision 94558)
@@ -42,8 +42,8 @@
 #ifdef SOFTFLOAT_FAST_INT64
 
-void i64_to_f128M( int64_t a, float128_t *zPtr )
+void i64_to_f128M( int64_t a, float128_t *zPtr SOFTFLOAT_STATE_DECL_COMMA )
 {
 
-    *zPtr = i64_to_f128( a );
+    *zPtr = i64_to_f128( a SOFTFLOAT_STATE_ARG_COMMA );
 
 }
@@ -51,5 +51,5 @@
 #else
 
-void i64_to_f128M( int64_t a, float128_t *zPtr )
+void i64_to_f128M( int64_t a, float128_t *zPtr SOFTFLOAT_STATE_DECL_COMMA )
 {
     uint32_t *zWPtr;
@@ -59,4 +59,5 @@
     uint_fast8_t shiftDist;
     uint32_t *ptr;
+    SOFTFLOAT_STATE_NOREF();
 
     zWPtr = (uint32_t *) zPtr;
Index: trunk/src/libs/softfloat-3e/source/i64_to_f16.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/i64_to_f16.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/i64_to_f16.c	(revision 94558)
@@ -41,5 +41,5 @@
 #include "softfloat.h"
 
-float16_t i64_to_f16( int64_t a )
+float16_t i64_to_f16( int64_t a SOFTFLOAT_STATE_DECL_COMMA )
 {
     bool sign;
@@ -64,5 +64,5 @@
                 ? softfloat_shortShiftRightJam64( absA, -shiftDist )
                 : (uint_fast16_t) absA<<shiftDist;
-        return softfloat_roundPackToF16( sign, 0x1C - shiftDist, sig );
+        return softfloat_roundPackToF16( sign, 0x1C - shiftDist, sig SOFTFLOAT_STATE_ARG_COMMA );
     }
 
Index: trunk/src/libs/softfloat-3e/source/i64_to_f32.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/i64_to_f32.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/i64_to_f32.c	(revision 94558)
@@ -41,5 +41,5 @@
 #include "softfloat.h"
 
-float32_t i64_to_f32( int64_t a )
+float32_t i64_to_f32( int64_t a SOFTFLOAT_STATE_DECL_COMMA )
 {
     bool sign;
@@ -64,5 +64,5 @@
                 ? softfloat_shortShiftRightJam64( absA, -shiftDist )
                 : (uint_fast32_t) absA<<shiftDist;
-        return softfloat_roundPackToF32( sign, 0x9C - shiftDist, sig );
+        return softfloat_roundPackToF32( sign, 0x9C - shiftDist, sig SOFTFLOAT_STATE_ARG_COMMA );
     }
 
Index: trunk/src/libs/softfloat-3e/source/i64_to_f64.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/i64_to_f64.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/i64_to_f64.c	(revision 94558)
@@ -41,5 +41,5 @@
 #include "softfloat.h"
 
-float64_t i64_to_f64( int64_t a )
+float64_t i64_to_f64( int64_t a SOFTFLOAT_STATE_DECL_COMMA )
 {
     bool sign;
@@ -53,5 +53,5 @@
     }
     absA = sign ? -(uint_fast64_t) a : (uint_fast64_t) a;
-    return softfloat_normRoundPackToF64( sign, 0x43C, absA );
+    return softfloat_normRoundPackToF64( sign, 0x43C, absA SOFTFLOAT_STATE_ARG_COMMA );
 
 }
Index: trunk/src/libs/softfloat-3e/source/include/internals.h
===================================================================
--- trunk/src/libs/softfloat-3e/source/include/internals.h	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/include/internals.h	(revision 94558)
@@ -59,22 +59,22 @@
 /*----------------------------------------------------------------------------
 *----------------------------------------------------------------------------*/
-uint_fast32_t softfloat_roundToUI32( bool, uint_fast64_t, uint_fast8_t, bool );
+uint_fast32_t softfloat_roundToUI32( bool, uint_fast64_t, uint_fast8_t, bool SOFTFLOAT_STATE_DECL_COMMA );
 
 #ifdef SOFTFLOAT_FAST_INT64
 uint_fast64_t
  softfloat_roundToUI64(
-     bool, uint_fast64_t, uint_fast64_t, uint_fast8_t, bool );
+     bool, uint_fast64_t, uint_fast64_t, uint_fast8_t, bool SOFTFLOAT_STATE_DECL_COMMA );
 #else
-uint_fast64_t softfloat_roundMToUI64( bool, uint32_t *, uint_fast8_t, bool );
-#endif
-
-int_fast32_t softfloat_roundToI32( bool, uint_fast64_t, uint_fast8_t, bool );
+uint_fast64_t softfloat_roundMToUI64( bool, uint32_t *, uint_fast8_t, bool SOFTFLOAT_STATE_DECL_COMMA );
+#endif
+
+int_fast32_t softfloat_roundToI32( bool, uint_fast64_t, uint_fast8_t, bool SOFTFLOAT_STATE_DECL_COMMA );
 
 #ifdef SOFTFLOAT_FAST_INT64
 int_fast64_t
  softfloat_roundToI64(
-     bool, uint_fast64_t, uint_fast64_t, uint_fast8_t, bool );
+     bool, uint_fast64_t, uint_fast64_t, uint_fast8_t, bool SOFTFLOAT_STATE_DECL_COMMA );
 #else
-int_fast64_t softfloat_roundMToI64( bool, uint32_t *, uint_fast8_t, bool );
+int_fast64_t softfloat_roundMToI64( bool, uint32_t *, uint_fast8_t, bool SOFTFLOAT_STATE_DECL_COMMA );
 #endif
 
@@ -91,12 +91,12 @@
 struct exp8_sig16 softfloat_normSubnormalF16Sig( uint_fast16_t );
 
-float16_t softfloat_roundPackToF16( bool, int_fast16_t, uint_fast16_t );
-float16_t softfloat_normRoundPackToF16( bool, int_fast16_t, uint_fast16_t );
-
-float16_t softfloat_addMagsF16( uint_fast16_t, uint_fast16_t );
-float16_t softfloat_subMagsF16( uint_fast16_t, uint_fast16_t );
+float16_t softfloat_roundPackToF16( bool, int_fast16_t, uint_fast16_t SOFTFLOAT_STATE_DECL_COMMA );
+float16_t softfloat_normRoundPackToF16( bool, int_fast16_t, uint_fast16_t SOFTFLOAT_STATE_DECL_COMMA );
+
+float16_t softfloat_addMagsF16( uint_fast16_t, uint_fast16_t SOFTFLOAT_STATE_DECL_COMMA );
+float16_t softfloat_subMagsF16( uint_fast16_t, uint_fast16_t SOFTFLOAT_STATE_DECL_COMMA );
 float16_t
  softfloat_mulAddF16(
-     uint_fast16_t, uint_fast16_t, uint_fast16_t, uint_fast8_t );
+     uint_fast16_t, uint_fast16_t, uint_fast16_t, uint_fast8_t SOFTFLOAT_STATE_DECL_COMMA );
 
 /*----------------------------------------------------------------------------
@@ -112,12 +112,12 @@
 struct exp16_sig32 softfloat_normSubnormalF32Sig( uint_fast32_t );
 
-float32_t softfloat_roundPackToF32( bool, int_fast16_t, uint_fast32_t );
-float32_t softfloat_normRoundPackToF32( bool, int_fast16_t, uint_fast32_t );
-
-float32_t softfloat_addMagsF32( uint_fast32_t, uint_fast32_t );
-float32_t softfloat_subMagsF32( uint_fast32_t, uint_fast32_t );
+float32_t softfloat_roundPackToF32( bool, int_fast16_t, uint_fast32_t SOFTFLOAT_STATE_DECL_COMMA );
+float32_t softfloat_normRoundPackToF32( bool, int_fast16_t, uint_fast32_t SOFTFLOAT_STATE_DECL_COMMA );
+
+float32_t softfloat_addMagsF32( uint_fast32_t, uint_fast32_t SOFTFLOAT_STATE_DECL_COMMA );
+float32_t softfloat_subMagsF32( uint_fast32_t, uint_fast32_t SOFTFLOAT_STATE_DECL_COMMA );
 float32_t
  softfloat_mulAddF32(
-     uint_fast32_t, uint_fast32_t, uint_fast32_t, uint_fast8_t );
+     uint_fast32_t, uint_fast32_t, uint_fast32_t, uint_fast8_t SOFTFLOAT_STATE_DECL_COMMA );
 
 /*----------------------------------------------------------------------------
@@ -133,12 +133,12 @@
 struct exp16_sig64 softfloat_normSubnormalF64Sig( uint_fast64_t );
 
-float64_t softfloat_roundPackToF64( bool, int_fast16_t, uint_fast64_t );
-float64_t softfloat_normRoundPackToF64( bool, int_fast16_t, uint_fast64_t );
-
-float64_t softfloat_addMagsF64( uint_fast64_t, uint_fast64_t, bool );
-float64_t softfloat_subMagsF64( uint_fast64_t, uint_fast64_t, bool );
+float64_t softfloat_roundPackToF64( bool, int_fast16_t, uint_fast64_t SOFTFLOAT_STATE_DECL_COMMA );
+float64_t softfloat_normRoundPackToF64( bool, int_fast16_t, uint_fast64_t SOFTFLOAT_STATE_DECL_COMMA );
+
+float64_t softfloat_addMagsF64( uint_fast64_t, uint_fast64_t, bool SOFTFLOAT_STATE_DECL_COMMA );
+float64_t softfloat_subMagsF64( uint_fast64_t, uint_fast64_t, bool SOFTFLOAT_STATE_DECL_COMMA );
 float64_t
  softfloat_mulAddF64(
-     uint_fast64_t, uint_fast64_t, uint_fast64_t, uint_fast8_t );
+     uint_fast64_t, uint_fast64_t, uint_fast64_t, uint_fast8_t SOFTFLOAT_STATE_DECL_COMMA );
 
 /*----------------------------------------------------------------------------
@@ -160,15 +160,15 @@
 extFloat80_t
  softfloat_roundPackToExtF80(
-     bool, int_fast32_t, uint_fast64_t, uint_fast64_t, uint_fast8_t );
+     bool, int_fast32_t, uint_fast64_t, uint_fast64_t, uint_fast8_t SOFTFLOAT_STATE_DECL_COMMA );
 extFloat80_t
  softfloat_normRoundPackToExtF80(
-     bool, int_fast32_t, uint_fast64_t, uint_fast64_t, uint_fast8_t );
+     bool, int_fast32_t, uint_fast64_t, uint_fast64_t, uint_fast8_t SOFTFLOAT_STATE_DECL_COMMA );
 
 extFloat80_t
  softfloat_addMagsExtF80(
-     uint_fast16_t, uint_fast64_t, uint_fast16_t, uint_fast64_t, bool );
+     uint_fast16_t, uint_fast64_t, uint_fast16_t, uint_fast64_t, bool SOFTFLOAT_STATE_DECL_COMMA );
 extFloat80_t
  softfloat_subMagsExtF80(
-     uint_fast16_t, uint_fast64_t, uint_fast16_t, uint_fast64_t, bool );
+     uint_fast16_t, uint_fast64_t, uint_fast16_t, uint_fast64_t, bool SOFTFLOAT_STATE_DECL_COMMA );
 
 /*----------------------------------------------------------------------------
@@ -187,15 +187,15 @@
 float128_t
  softfloat_roundPackToF128(
-     bool, int_fast32_t, uint_fast64_t, uint_fast64_t, uint_fast64_t );
+     bool, int_fast32_t, uint_fast64_t, uint_fast64_t, uint_fast64_t SOFTFLOAT_STATE_DECL_COMMA );
 float128_t
  softfloat_normRoundPackToF128(
-     bool, int_fast32_t, uint_fast64_t, uint_fast64_t );
+     bool, int_fast32_t, uint_fast64_t, uint_fast64_t SOFTFLOAT_STATE_DECL_COMMA );
 
 float128_t
  softfloat_addMagsF128(
-     uint_fast64_t, uint_fast64_t, uint_fast64_t, uint_fast64_t, bool );
+     uint_fast64_t, uint_fast64_t, uint_fast64_t, uint_fast64_t, bool SOFTFLOAT_STATE_DECL_COMMA );
 float128_t
  softfloat_subMagsF128(
-     uint_fast64_t, uint_fast64_t, uint_fast64_t, uint_fast64_t, bool );
+     uint_fast64_t, uint_fast64_t, uint_fast64_t, uint_fast64_t, bool SOFTFLOAT_STATE_DECL_COMMA );
 float128_t
  softfloat_mulAddF128(
@@ -207,4 +207,5 @@
      uint_fast64_t,
      uint_fast8_t
+     SOFTFLOAT_STATE_DECL_COMMA
  );
 
@@ -219,6 +220,7 @@
      const struct extFloat80M *,
      struct extFloat80M *
- );
-void softfloat_invalidExtF80M( struct extFloat80M * );
+     SOFTFLOAT_STATE_DECL_COMMA
+ );
+void softfloat_invalidExtF80M( struct extFloat80M * SOFTFLOAT_STATE_DECL_COMMA );
 
 int softfloat_normExtF80SigM( uint64_t * );
@@ -226,8 +228,8 @@
 void
  softfloat_roundPackMToExtF80M(
-     bool, int32_t, uint32_t *, uint_fast8_t, struct extFloat80M * );
+     bool, int32_t, uint32_t *, uint_fast8_t, struct extFloat80M * SOFTFLOAT_STATE_DECL_COMMA );
 void
  softfloat_normRoundPackMToExtF80M(
-     bool, int32_t, uint32_t *, uint_fast8_t, struct extFloat80M * );
+     bool, int32_t, uint32_t *, uint_fast8_t, struct extFloat80M * SOFTFLOAT_STATE_DECL_COMMA );
 
 void
@@ -237,9 +239,10 @@
      struct extFloat80M *,
      bool
+     SOFTFLOAT_STATE_DECL_COMMA
  );
 
 int
  softfloat_compareNonnormExtF80M(
-     const struct extFloat80M *, const struct extFloat80M * );
+     const struct extFloat80M *, const struct extFloat80M * SOFTFLOAT_STATE_DECL_COMMA );
 
 /*----------------------------------------------------------------------------
@@ -254,14 +257,14 @@
 bool
  softfloat_tryPropagateNaNF128M(
-     const uint32_t *, const uint32_t *, uint32_t * );
-void softfloat_invalidF128M( uint32_t * );
+     const uint32_t *, const uint32_t *, uint32_t * SOFTFLOAT_STATE_DECL_COMMA );
+void softfloat_invalidF128M( uint32_t * SOFTFLOAT_STATE_DECL_COMMA );
 
 int softfloat_shiftNormSigF128M( const uint32_t *, uint_fast8_t, uint32_t * );
 
-void softfloat_roundPackMToF128M( bool, int32_t, uint32_t *, uint32_t * );
-void softfloat_normRoundPackMToF128M( bool, int32_t, uint32_t *, uint32_t * );
-
-void
- softfloat_addF128M( const uint32_t *, const uint32_t *, uint32_t *, bool );
+void softfloat_roundPackMToF128M( bool, int32_t, uint32_t *, uint32_t * SOFTFLOAT_STATE_DECL_COMMA );
+void softfloat_normRoundPackMToF128M( bool, int32_t, uint32_t *, uint32_t * SOFTFLOAT_STATE_DECL_COMMA );
+
+void
+ softfloat_addF128M( const uint32_t *, const uint32_t *, uint32_t *, bool SOFTFLOAT_STATE_DECL_COMMA );
 void
  softfloat_mulAddF128M(
@@ -271,8 +274,9 @@
      uint32_t *,
      uint_fast8_t
- );
-
-#endif
-
-#endif
-
+     SOFTFLOAT_STATE_DECL_COMMA
+ );
+
+#endif
+
+#endif
+
Index: trunk/src/libs/softfloat-3e/source/include/softfloat.h
===================================================================
--- trunk/src/libs/softfloat-3e/source/include/softfloat.h	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/include/softfloat.h	(revision 94558)
@@ -47,4 +47,5 @@
 #define softfloat_h 1
 
+#include <iprt/cdefs.h>
 #include <stdbool.h>
 #include <stdint.h>
@@ -55,8 +56,14 @@
 #endif
 
+RT_C_DECLS_BEGIN
+
 /*----------------------------------------------------------------------------
 | Software floating-point underflow tininess-detection mode.
 *----------------------------------------------------------------------------*/
+#ifndef VBOX_WITHOUT_SOFTFLOAT_GLOBALS
 extern THREAD_LOCAL uint_fast8_t softfloat_detectTininess;
+#else
+# define softfloat_detectTininess (pState->detectTininess)
+#endif
 enum {
     softfloat_tininess_beforeRounding = 0,
@@ -68,5 +75,9 @@
 | SoftFloat is compiled with macro 'SOFTFLOAT_ROUND_ODD' defined.)
 *----------------------------------------------------------------------------*/
+#ifndef VBOX_WITHOUT_SOFTFLOAT_GLOBALS
 extern THREAD_LOCAL uint_fast8_t softfloat_roundingMode;
+#else
+# define softfloat_roundingMode (pState->roundingMode)
+#endif
 enum {
     softfloat_round_near_even   = 0,
@@ -81,6 +92,11 @@
 | Software floating-point exception flags.
 *----------------------------------------------------------------------------*/
+#ifndef VBOX_WITHOUT_SOFTFLOAT_GLOBALS
 extern THREAD_LOCAL uint_fast8_t softfloat_exceptionFlags;
+#else
+# define softfloat_exceptionFlags (pState->exceptionFlags)
+#endif
 enum {
+#ifndef VBOX
     softfloat_flag_inexact   =  1,
     softfloat_flag_underflow =  2,
@@ -88,4 +104,13 @@
     softfloat_flag_infinite  =  8,
     softfloat_flag_invalid   = 16
+#else /* VBox: Match X86_FSW_?E */
+    softfloat_flag_invalid   = 1<<0 /**< X86_FSW_IE */,
+    //softfloat_flag_ X86_FSW_DE          RT_BIT_32(1)
+    softfloat_flag_infinite  = 1<<2 /**< X86_FSW_ZE */,
+    softfloat_flag_overflow  = 1<<3 /**< X86_FSW_OE */,
+    softfloat_flag_underflow = 1<<4 /**< X86_FSW_UE */,
+    softfloat_flag_inexact   = 1<<5 /**< X86_FSW_PE */,
+    softfloat_flag_c1        = 1<<7 /**< X86_FSW_C1 - round up indicator. wrong place. */
+#endif
 };
 
@@ -93,79 +118,79 @@
 | Routine to raise any or all of the software floating-point exception flags.
 *----------------------------------------------------------------------------*/
-void softfloat_raiseFlags( uint_fast8_t );
+void softfloat_raiseFlags( uint_fast8_t SOFTFLOAT_STATE_DECL_COMMA );
 
 /*----------------------------------------------------------------------------
 | Integer-to-floating-point conversion routines.
 *----------------------------------------------------------------------------*/
-float16_t ui32_to_f16( uint32_t );
-float32_t ui32_to_f32( uint32_t );
-float64_t ui32_to_f64( uint32_t );
-#ifdef SOFTFLOAT_FAST_INT64
-extFloat80_t ui32_to_extF80( uint32_t );
-float128_t ui32_to_f128( uint32_t );
-#endif
-void ui32_to_extF80M( uint32_t, extFloat80_t * );
-void ui32_to_f128M( uint32_t, float128_t * );
-float16_t ui64_to_f16( uint64_t );
-float32_t ui64_to_f32( uint64_t );
-float64_t ui64_to_f64( uint64_t );
-#ifdef SOFTFLOAT_FAST_INT64
-extFloat80_t ui64_to_extF80( uint64_t );
-float128_t ui64_to_f128( uint64_t );
-#endif
-void ui64_to_extF80M( uint64_t, extFloat80_t * );
-void ui64_to_f128M( uint64_t, float128_t * );
-float16_t i32_to_f16( int32_t );
-float32_t i32_to_f32( int32_t );
-float64_t i32_to_f64( int32_t );
-#ifdef SOFTFLOAT_FAST_INT64
-extFloat80_t i32_to_extF80( int32_t );
-float128_t i32_to_f128( int32_t );
-#endif
-void i32_to_extF80M( int32_t, extFloat80_t * );
-void i32_to_f128M( int32_t, float128_t * );
-float16_t i64_to_f16( int64_t );
-float32_t i64_to_f32( int64_t );
-float64_t i64_to_f64( int64_t );
-#ifdef SOFTFLOAT_FAST_INT64
-extFloat80_t i64_to_extF80( int64_t );
-float128_t i64_to_f128( int64_t );
-#endif
-void i64_to_extF80M( int64_t, extFloat80_t * );
-void i64_to_f128M( int64_t, float128_t * );
+float16_t ui32_to_f16( uint32_t SOFTFLOAT_STATE_DECL_COMMA );
+float32_t ui32_to_f32( uint32_t SOFTFLOAT_STATE_DECL_COMMA );
+float64_t ui32_to_f64( uint32_t SOFTFLOAT_STATE_DECL_COMMA );
+#ifdef SOFTFLOAT_FAST_INT64
+extFloat80_t ui32_to_extF80( uint32_t SOFTFLOAT_STATE_DECL_COMMA );
+float128_t ui32_to_f128( uint32_t SOFTFLOAT_STATE_DECL_COMMA );
+#endif
+void ui32_to_extF80M( uint32_t, extFloat80_t * SOFTFLOAT_STATE_DECL_COMMA );
+void ui32_to_f128M( uint32_t, float128_t * SOFTFLOAT_STATE_DECL_COMMA );
+float16_t ui64_to_f16( uint64_t SOFTFLOAT_STATE_DECL_COMMA );
+float32_t ui64_to_f32( uint64_t SOFTFLOAT_STATE_DECL_COMMA );
+float64_t ui64_to_f64( uint64_t SOFTFLOAT_STATE_DECL_COMMA );
+#ifdef SOFTFLOAT_FAST_INT64
+extFloat80_t ui64_to_extF80( uint64_t SOFTFLOAT_STATE_DECL_COMMA );
+float128_t ui64_to_f128( uint64_t SOFTFLOAT_STATE_DECL_COMMA );
+#endif
+void ui64_to_extF80M( uint64_t, extFloat80_t * SOFTFLOAT_STATE_DECL_COMMA );
+void ui64_to_f128M( uint64_t, float128_t * SOFTFLOAT_STATE_DECL_COMMA );
+float16_t i32_to_f16( int32_t SOFTFLOAT_STATE_DECL_COMMA );
+float32_t i32_to_f32( int32_t SOFTFLOAT_STATE_DECL_COMMA );
+float64_t i32_to_f64( int32_t SOFTFLOAT_STATE_DECL_COMMA );
+#ifdef SOFTFLOAT_FAST_INT64
+extFloat80_t i32_to_extF80( int32_t SOFTFLOAT_STATE_DECL_COMMA );
+float128_t i32_to_f128( int32_t SOFTFLOAT_STATE_DECL_COMMA );
+#endif
+void i32_to_extF80M( int32_t, extFloat80_t * SOFTFLOAT_STATE_DECL_COMMA );
+void i32_to_f128M( int32_t, float128_t * SOFTFLOAT_STATE_DECL_COMMA );
+float16_t i64_to_f16( int64_t SOFTFLOAT_STATE_DECL_COMMA );
+float32_t i64_to_f32( int64_t SOFTFLOAT_STATE_DECL_COMMA );
+float64_t i64_to_f64( int64_t SOFTFLOAT_STATE_DECL_COMMA );
+#ifdef SOFTFLOAT_FAST_INT64
+extFloat80_t i64_to_extF80( int64_t SOFTFLOAT_STATE_DECL_COMMA );
+float128_t i64_to_f128( int64_t SOFTFLOAT_STATE_DECL_COMMA );
+#endif
+void i64_to_extF80M( int64_t, extFloat80_t * SOFTFLOAT_STATE_DECL_COMMA );
+void i64_to_f128M( int64_t, float128_t * SOFTFLOAT_STATE_DECL_COMMA );
 
 /*----------------------------------------------------------------------------
 | 16-bit (half-precision) floating-point operations.
 *----------------------------------------------------------------------------*/
-uint_fast32_t f16_to_ui32( float16_t, uint_fast8_t, bool );
-uint_fast64_t f16_to_ui64( float16_t, uint_fast8_t, bool );
-int_fast32_t f16_to_i32( float16_t, uint_fast8_t, bool );
-int_fast64_t f16_to_i64( float16_t, uint_fast8_t, bool );
-uint_fast32_t f16_to_ui32_r_minMag( float16_t, bool );
-uint_fast64_t f16_to_ui64_r_minMag( float16_t, bool );
-int_fast32_t f16_to_i32_r_minMag( float16_t, bool );
-int_fast64_t f16_to_i64_r_minMag( float16_t, bool );
-float32_t f16_to_f32( float16_t );
-float64_t f16_to_f64( float16_t );
-#ifdef SOFTFLOAT_FAST_INT64
-extFloat80_t f16_to_extF80( float16_t );
-float128_t f16_to_f128( float16_t );
-#endif
-void f16_to_extF80M( float16_t, extFloat80_t * );
-void f16_to_f128M( float16_t, float128_t * );
-float16_t f16_roundToInt( float16_t, uint_fast8_t, bool );
-float16_t f16_add( float16_t, float16_t );
-float16_t f16_sub( float16_t, float16_t );
-float16_t f16_mul( float16_t, float16_t );
-float16_t f16_mulAdd( float16_t, float16_t, float16_t );
-float16_t f16_div( float16_t, float16_t );
-float16_t f16_rem( float16_t, float16_t );
-float16_t f16_sqrt( float16_t );
-bool f16_eq( float16_t, float16_t );
-bool f16_le( float16_t, float16_t );
-bool f16_lt( float16_t, float16_t );
-bool f16_eq_signaling( float16_t, float16_t );
-bool f16_le_quiet( float16_t, float16_t );
-bool f16_lt_quiet( float16_t, float16_t );
+uint_fast32_t f16_to_ui32( float16_t, uint_fast8_t, bool SOFTFLOAT_STATE_DECL_COMMA );
+uint_fast64_t f16_to_ui64( float16_t, uint_fast8_t, bool SOFTFLOAT_STATE_DECL_COMMA );
+int_fast32_t f16_to_i32( float16_t, uint_fast8_t, bool SOFTFLOAT_STATE_DECL_COMMA );
+int_fast64_t f16_to_i64( float16_t, uint_fast8_t, bool SOFTFLOAT_STATE_DECL_COMMA );
+uint_fast32_t f16_to_ui32_r_minMag( float16_t, bool SOFTFLOAT_STATE_DECL_COMMA );
+uint_fast64_t f16_to_ui64_r_minMag( float16_t, bool SOFTFLOAT_STATE_DECL_COMMA );
+int_fast32_t f16_to_i32_r_minMag( float16_t, bool SOFTFLOAT_STATE_DECL_COMMA );
+int_fast64_t f16_to_i64_r_minMag( float16_t, bool SOFTFLOAT_STATE_DECL_COMMA );
+float32_t f16_to_f32( float16_t SOFTFLOAT_STATE_DECL_COMMA );
+float64_t f16_to_f64( float16_t SOFTFLOAT_STATE_DECL_COMMA );
+#ifdef SOFTFLOAT_FAST_INT64
+extFloat80_t f16_to_extF80( float16_t SOFTFLOAT_STATE_DECL_COMMA );
+float128_t f16_to_f128( float16_t SOFTFLOAT_STATE_DECL_COMMA );
+#endif
+void f16_to_extF80M( float16_t, extFloat80_t * SOFTFLOAT_STATE_DECL_COMMA );
+void f16_to_f128M( float16_t, float128_t * SOFTFLOAT_STATE_DECL_COMMA );
+float16_t f16_roundToInt( float16_t, uint_fast8_t, bool SOFTFLOAT_STATE_DECL_COMMA );
+float16_t f16_add( float16_t, float16_t SOFTFLOAT_STATE_DECL_COMMA  );
+float16_t f16_sub( float16_t, float16_t SOFTFLOAT_STATE_DECL_COMMA  );
+float16_t f16_mul( float16_t, float16_t SOFTFLOAT_STATE_DECL_COMMA  );
+float16_t f16_mulAdd( float16_t, float16_t, float16_t SOFTFLOAT_STATE_DECL_COMMA  );
+float16_t f16_div( float16_t, float16_t SOFTFLOAT_STATE_DECL_COMMA  );
+float16_t f16_rem( float16_t, float16_t SOFTFLOAT_STATE_DECL_COMMA  );
+float16_t f16_sqrt( float16_t SOFTFLOAT_STATE_DECL_COMMA  );
+bool f16_eq( float16_t, float16_t SOFTFLOAT_STATE_DECL_COMMA  );
+bool f16_le( float16_t, float16_t SOFTFLOAT_STATE_DECL_COMMA  );
+bool f16_lt( float16_t, float16_t SOFTFLOAT_STATE_DECL_COMMA  );
+bool f16_eq_signaling( float16_t, float16_t SOFTFLOAT_STATE_DECL_COMMA  );
+bool f16_le_quiet( float16_t, float16_t SOFTFLOAT_STATE_DECL_COMMA  );
+bool f16_lt_quiet( float16_t, float16_t SOFTFLOAT_STATE_DECL_COMMA  );
 bool f16_isSignalingNaN( float16_t );
 
@@ -173,34 +198,34 @@
 | 32-bit (single-precision) floating-point operations.
 *----------------------------------------------------------------------------*/
-uint_fast32_t f32_to_ui32( float32_t, uint_fast8_t, bool );
-uint_fast64_t f32_to_ui64( float32_t, uint_fast8_t, bool );
-int_fast32_t f32_to_i32( float32_t, uint_fast8_t, bool );
-int_fast64_t f32_to_i64( float32_t, uint_fast8_t, bool );
-uint_fast32_t f32_to_ui32_r_minMag( float32_t, bool );
-uint_fast64_t f32_to_ui64_r_minMag( float32_t, bool );
-int_fast32_t f32_to_i32_r_minMag( float32_t, bool );
-int_fast64_t f32_to_i64_r_minMag( float32_t, bool );
-float16_t f32_to_f16( float32_t );
-float64_t f32_to_f64( float32_t );
-#ifdef SOFTFLOAT_FAST_INT64
-extFloat80_t f32_to_extF80( float32_t );
-float128_t f32_to_f128( float32_t );
-#endif
-void f32_to_extF80M( float32_t, extFloat80_t * );
-void f32_to_f128M( float32_t, float128_t * );
-float32_t f32_roundToInt( float32_t, uint_fast8_t, bool );
-float32_t f32_add( float32_t, float32_t );
-float32_t f32_sub( float32_t, float32_t );
-float32_t f32_mul( float32_t, float32_t );
-float32_t f32_mulAdd( float32_t, float32_t, float32_t );
-float32_t f32_div( float32_t, float32_t );
-float32_t f32_rem( float32_t, float32_t );
-float32_t f32_sqrt( float32_t );
-bool f32_eq( float32_t, float32_t );
-bool f32_le( float32_t, float32_t );
-bool f32_lt( float32_t, float32_t );
-bool f32_eq_signaling( float32_t, float32_t );
-bool f32_le_quiet( float32_t, float32_t );
-bool f32_lt_quiet( float32_t, float32_t );
+uint_fast32_t f32_to_ui32( float32_t, uint_fast8_t, bool SOFTFLOAT_STATE_DECL_COMMA );
+uint_fast64_t f32_to_ui64( float32_t, uint_fast8_t, bool SOFTFLOAT_STATE_DECL_COMMA );
+int_fast32_t f32_to_i32( float32_t, uint_fast8_t, bool SOFTFLOAT_STATE_DECL_COMMA );
+int_fast64_t f32_to_i64( float32_t, uint_fast8_t, bool SOFTFLOAT_STATE_DECL_COMMA );
+uint_fast32_t f32_to_ui32_r_minMag( float32_t, bool SOFTFLOAT_STATE_DECL_COMMA );
+uint_fast64_t f32_to_ui64_r_minMag( float32_t, bool SOFTFLOAT_STATE_DECL_COMMA );
+int_fast32_t f32_to_i32_r_minMag( float32_t, bool SOFTFLOAT_STATE_DECL_COMMA );
+int_fast64_t f32_to_i64_r_minMag( float32_t, bool SOFTFLOAT_STATE_DECL_COMMA );
+float16_t f32_to_f16( float32_t SOFTFLOAT_STATE_DECL_COMMA );
+float64_t f32_to_f64( float32_t SOFTFLOAT_STATE_DECL_COMMA );
+#ifdef SOFTFLOAT_FAST_INT64
+extFloat80_t f32_to_extF80( float32_t SOFTFLOAT_STATE_DECL_COMMA );
+float128_t f32_to_f128( float32_t SOFTFLOAT_STATE_DECL_COMMA );
+#endif
+void f32_to_extF80M( float32_t, extFloat80_t * SOFTFLOAT_STATE_DECL_COMMA );
+void f32_to_f128M( float32_t, float128_t * SOFTFLOAT_STATE_DECL_COMMA );
+float32_t f32_roundToInt( float32_t, uint_fast8_t, bool SOFTFLOAT_STATE_DECL_COMMA );
+float32_t f32_add( float32_t, float32_t SOFTFLOAT_STATE_DECL_COMMA );
+float32_t f32_sub( float32_t, float32_t SOFTFLOAT_STATE_DECL_COMMA );
+float32_t f32_mul( float32_t, float32_t SOFTFLOAT_STATE_DECL_COMMA );
+float32_t f32_mulAdd( float32_t, float32_t, float32_t SOFTFLOAT_STATE_DECL_COMMA );
+float32_t f32_div( float32_t, float32_t SOFTFLOAT_STATE_DECL_COMMA );
+float32_t f32_rem( float32_t, float32_t SOFTFLOAT_STATE_DECL_COMMA );
+float32_t f32_sqrt( float32_t SOFTFLOAT_STATE_DECL_COMMA );
+bool f32_eq( float32_t, float32_t SOFTFLOAT_STATE_DECL_COMMA );
+bool f32_le( float32_t, float32_t SOFTFLOAT_STATE_DECL_COMMA );
+bool f32_lt( float32_t, float32_t SOFTFLOAT_STATE_DECL_COMMA );
+bool f32_eq_signaling( float32_t, float32_t SOFTFLOAT_STATE_DECL_COMMA );
+bool f32_le_quiet( float32_t, float32_t SOFTFLOAT_STATE_DECL_COMMA );
+bool f32_lt_quiet( float32_t, float32_t SOFTFLOAT_STATE_DECL_COMMA );
 bool f32_isSignalingNaN( float32_t );
 
@@ -208,34 +233,34 @@
 | 64-bit (double-precision) floating-point operations.
 *----------------------------------------------------------------------------*/
-uint_fast32_t f64_to_ui32( float64_t, uint_fast8_t, bool );
-uint_fast64_t f64_to_ui64( float64_t, uint_fast8_t, bool );
-int_fast32_t f64_to_i32( float64_t, uint_fast8_t, bool );
-int_fast64_t f64_to_i64( float64_t, uint_fast8_t, bool );
-uint_fast32_t f64_to_ui32_r_minMag( float64_t, bool );
-uint_fast64_t f64_to_ui64_r_minMag( float64_t, bool );
-int_fast32_t f64_to_i32_r_minMag( float64_t, bool );
-int_fast64_t f64_to_i64_r_minMag( float64_t, bool );
-float16_t f64_to_f16( float64_t );
-float32_t f64_to_f32( float64_t );
-#ifdef SOFTFLOAT_FAST_INT64
-extFloat80_t f64_to_extF80( float64_t );
-float128_t f64_to_f128( float64_t );
-#endif
-void f64_to_extF80M( float64_t, extFloat80_t * );
-void f64_to_f128M( float64_t, float128_t * );
-float64_t f64_roundToInt( float64_t, uint_fast8_t, bool );
-float64_t f64_add( float64_t, float64_t );
-float64_t f64_sub( float64_t, float64_t );
-float64_t f64_mul( float64_t, float64_t );
-float64_t f64_mulAdd( float64_t, float64_t, float64_t );
-float64_t f64_div( float64_t, float64_t );
-float64_t f64_rem( float64_t, float64_t );
-float64_t f64_sqrt( float64_t );
-bool f64_eq( float64_t, float64_t );
-bool f64_le( float64_t, float64_t );
-bool f64_lt( float64_t, float64_t );
-bool f64_eq_signaling( float64_t, float64_t );
-bool f64_le_quiet( float64_t, float64_t );
-bool f64_lt_quiet( float64_t, float64_t );
+uint_fast32_t f64_to_ui32( float64_t, uint_fast8_t, bool SOFTFLOAT_STATE_DECL_COMMA );
+uint_fast64_t f64_to_ui64( float64_t, uint_fast8_t, bool SOFTFLOAT_STATE_DECL_COMMA );
+int_fast32_t f64_to_i32( float64_t, uint_fast8_t, bool SOFTFLOAT_STATE_DECL_COMMA );
+int_fast64_t f64_to_i64( float64_t, uint_fast8_t, bool SOFTFLOAT_STATE_DECL_COMMA );
+uint_fast32_t f64_to_ui32_r_minMag( float64_t, bool SOFTFLOAT_STATE_DECL_COMMA );
+uint_fast64_t f64_to_ui64_r_minMag( float64_t, bool SOFTFLOAT_STATE_DECL_COMMA );
+int_fast32_t f64_to_i32_r_minMag( float64_t, bool SOFTFLOAT_STATE_DECL_COMMA );
+int_fast64_t f64_to_i64_r_minMag( float64_t, bool SOFTFLOAT_STATE_DECL_COMMA );
+float16_t f64_to_f16( float64_t SOFTFLOAT_STATE_DECL_COMMA );
+float32_t f64_to_f32( float64_t SOFTFLOAT_STATE_DECL_COMMA );
+#ifdef SOFTFLOAT_FAST_INT64
+extFloat80_t f64_to_extF80( float64_t SOFTFLOAT_STATE_DECL_COMMA );
+float128_t f64_to_f128( float64_t SOFTFLOAT_STATE_DECL_COMMA );
+#endif
+void f64_to_extF80M( float64_t, extFloat80_t * SOFTFLOAT_STATE_DECL_COMMA );
+void f64_to_f128M( float64_t, float128_t * SOFTFLOAT_STATE_DECL_COMMA );
+float64_t f64_roundToInt( float64_t, uint_fast8_t, bool SOFTFLOAT_STATE_DECL_COMMA );
+float64_t f64_add( float64_t, float64_t SOFTFLOAT_STATE_DECL_COMMA );
+float64_t f64_sub( float64_t, float64_t SOFTFLOAT_STATE_DECL_COMMA );
+float64_t f64_mul( float64_t, float64_t SOFTFLOAT_STATE_DECL_COMMA );
+float64_t f64_mulAdd( float64_t, float64_t, float64_t SOFTFLOAT_STATE_DECL_COMMA );
+float64_t f64_div( float64_t, float64_t SOFTFLOAT_STATE_DECL_COMMA );
+float64_t f64_rem( float64_t, float64_t SOFTFLOAT_STATE_DECL_COMMA );
+float64_t f64_sqrt( float64_t SOFTFLOAT_STATE_DECL_COMMA );
+bool f64_eq( float64_t, float64_t SOFTFLOAT_STATE_DECL_COMMA );
+bool f64_le( float64_t, float64_t SOFTFLOAT_STATE_DECL_COMMA );
+bool f64_lt( float64_t, float64_t SOFTFLOAT_STATE_DECL_COMMA );
+bool f64_eq_signaling( float64_t, float64_t SOFTFLOAT_STATE_DECL_COMMA );
+bool f64_le_quiet( float64_t, float64_t SOFTFLOAT_STATE_DECL_COMMA );
+bool f64_lt_quiet( float64_t, float64_t SOFTFLOAT_STATE_DECL_COMMA );
 bool f64_isSignalingNaN( float64_t );
 
@@ -244,5 +269,9 @@
 | Valid values are 32, 64, and 80.
 *----------------------------------------------------------------------------*/
+#ifndef VBOX_WITHOUT_SOFTFLOAT_GLOBALS
 extern THREAD_LOCAL uint_fast8_t extF80_roundingPrecision;
+#else
+# define extF80_roundingPrecision (pState->roundingPrecision)
+#endif
 
 /*----------------------------------------------------------------------------
@@ -250,58 +279,58 @@
 *----------------------------------------------------------------------------*/
 #ifdef SOFTFLOAT_FAST_INT64
-uint_fast32_t extF80_to_ui32( extFloat80_t, uint_fast8_t, bool );
-uint_fast64_t extF80_to_ui64( extFloat80_t, uint_fast8_t, bool );
-int_fast32_t extF80_to_i32( extFloat80_t, uint_fast8_t, bool );
-int_fast64_t extF80_to_i64( extFloat80_t, uint_fast8_t, bool );
-uint_fast32_t extF80_to_ui32_r_minMag( extFloat80_t, bool );
-uint_fast64_t extF80_to_ui64_r_minMag( extFloat80_t, bool );
-int_fast32_t extF80_to_i32_r_minMag( extFloat80_t, bool );
-int_fast64_t extF80_to_i64_r_minMag( extFloat80_t, bool );
-float16_t extF80_to_f16( extFloat80_t );
-float32_t extF80_to_f32( extFloat80_t );
-float64_t extF80_to_f64( extFloat80_t );
-float128_t extF80_to_f128( extFloat80_t );
-extFloat80_t extF80_roundToInt( extFloat80_t, uint_fast8_t, bool );
-extFloat80_t extF80_add( extFloat80_t, extFloat80_t );
-extFloat80_t extF80_sub( extFloat80_t, extFloat80_t );
-extFloat80_t extF80_mul( extFloat80_t, extFloat80_t );
-extFloat80_t extF80_div( extFloat80_t, extFloat80_t );
-extFloat80_t extF80_rem( extFloat80_t, extFloat80_t );
-extFloat80_t extF80_sqrt( extFloat80_t );
-bool extF80_eq( extFloat80_t, extFloat80_t );
-bool extF80_le( extFloat80_t, extFloat80_t );
-bool extF80_lt( extFloat80_t, extFloat80_t );
-bool extF80_eq_signaling( extFloat80_t, extFloat80_t );
-bool extF80_le_quiet( extFloat80_t, extFloat80_t );
-bool extF80_lt_quiet( extFloat80_t, extFloat80_t );
+uint_fast32_t extF80_to_ui32( extFloat80_t, uint_fast8_t, bool SOFTFLOAT_STATE_DECL_COMMA );
+uint_fast64_t extF80_to_ui64( extFloat80_t, uint_fast8_t, bool SOFTFLOAT_STATE_DECL_COMMA );
+int_fast32_t extF80_to_i32( extFloat80_t, uint_fast8_t, bool SOFTFLOAT_STATE_DECL_COMMA );
+int_fast64_t extF80_to_i64( extFloat80_t, uint_fast8_t, bool SOFTFLOAT_STATE_DECL_COMMA );
+uint_fast32_t extF80_to_ui32_r_minMag( extFloat80_t, bool SOFTFLOAT_STATE_DECL_COMMA );
+uint_fast64_t extF80_to_ui64_r_minMag( extFloat80_t, bool SOFTFLOAT_STATE_DECL_COMMA );
+int_fast32_t extF80_to_i32_r_minMag( extFloat80_t, bool SOFTFLOAT_STATE_DECL_COMMA );
+int_fast64_t extF80_to_i64_r_minMag( extFloat80_t, bool SOFTFLOAT_STATE_DECL_COMMA );
+float16_t extF80_to_f16( extFloat80_t SOFTFLOAT_STATE_DECL_COMMA );
+float32_t extF80_to_f32( extFloat80_t SOFTFLOAT_STATE_DECL_COMMA );
+float64_t extF80_to_f64( extFloat80_t SOFTFLOAT_STATE_DECL_COMMA );
+float128_t extF80_to_f128( extFloat80_t SOFTFLOAT_STATE_DECL_COMMA );
+extFloat80_t extF80_roundToInt( extFloat80_t, uint_fast8_t, bool SOFTFLOAT_STATE_DECL_COMMA );
+extFloat80_t extF80_add( extFloat80_t, extFloat80_t SOFTFLOAT_STATE_DECL_COMMA );
+extFloat80_t extF80_sub( extFloat80_t, extFloat80_t SOFTFLOAT_STATE_DECL_COMMA );
+extFloat80_t extF80_mul( extFloat80_t, extFloat80_t SOFTFLOAT_STATE_DECL_COMMA );
+extFloat80_t extF80_div( extFloat80_t, extFloat80_t SOFTFLOAT_STATE_DECL_COMMA );
+extFloat80_t extF80_rem( extFloat80_t, extFloat80_t SOFTFLOAT_STATE_DECL_COMMA );
+extFloat80_t extF80_sqrt( extFloat80_t SOFTFLOAT_STATE_DECL_COMMA );
+bool extF80_eq( extFloat80_t, extFloat80_t SOFTFLOAT_STATE_DECL_COMMA );
+bool extF80_le( extFloat80_t, extFloat80_t SOFTFLOAT_STATE_DECL_COMMA );
+bool extF80_lt( extFloat80_t, extFloat80_t SOFTFLOAT_STATE_DECL_COMMA );
+bool extF80_eq_signaling( extFloat80_t, extFloat80_t SOFTFLOAT_STATE_DECL_COMMA );
+bool extF80_le_quiet( extFloat80_t, extFloat80_t SOFTFLOAT_STATE_DECL_COMMA );
+bool extF80_lt_quiet( extFloat80_t, extFloat80_t SOFTFLOAT_STATE_DECL_COMMA );
 bool extF80_isSignalingNaN( extFloat80_t );
 #endif
-uint_fast32_t extF80M_to_ui32( const extFloat80_t *, uint_fast8_t, bool );
-uint_fast64_t extF80M_to_ui64( const extFloat80_t *, uint_fast8_t, bool );
-int_fast32_t extF80M_to_i32( const extFloat80_t *, uint_fast8_t, bool );
-int_fast64_t extF80M_to_i64( const extFloat80_t *, uint_fast8_t, bool );
-uint_fast32_t extF80M_to_ui32_r_minMag( const extFloat80_t *, bool );
-uint_fast64_t extF80M_to_ui64_r_minMag( const extFloat80_t *, bool );
-int_fast32_t extF80M_to_i32_r_minMag( const extFloat80_t *, bool );
-int_fast64_t extF80M_to_i64_r_minMag( const extFloat80_t *, bool );
-float16_t extF80M_to_f16( const extFloat80_t * );
-float32_t extF80M_to_f32( const extFloat80_t * );
-float64_t extF80M_to_f64( const extFloat80_t * );
-void extF80M_to_f128M( const extFloat80_t *, float128_t * );
+uint_fast32_t extF80M_to_ui32( const extFloat80_t *, uint_fast8_t, bool SOFTFLOAT_STATE_DECL_COMMA );
+uint_fast64_t extF80M_to_ui64( const extFloat80_t *, uint_fast8_t, bool SOFTFLOAT_STATE_DECL_COMMA );
+int_fast32_t extF80M_to_i32( const extFloat80_t *, uint_fast8_t, bool SOFTFLOAT_STATE_DECL_COMMA );
+int_fast64_t extF80M_to_i64( const extFloat80_t *, uint_fast8_t, bool SOFTFLOAT_STATE_DECL_COMMA );
+uint_fast32_t extF80M_to_ui32_r_minMag( const extFloat80_t *, bool SOFTFLOAT_STATE_DECL_COMMA );
+uint_fast64_t extF80M_to_ui64_r_minMag( const extFloat80_t *, bool SOFTFLOAT_STATE_DECL_COMMA );
+int_fast32_t extF80M_to_i32_r_minMag( const extFloat80_t *, bool SOFTFLOAT_STATE_DECL_COMMA );
+int_fast64_t extF80M_to_i64_r_minMag( const extFloat80_t *, bool SOFTFLOAT_STATE_DECL_COMMA );
+float16_t extF80M_to_f16( const extFloat80_t * SOFTFLOAT_STATE_DECL_COMMA );
+float32_t extF80M_to_f32( const extFloat80_t * SOFTFLOAT_STATE_DECL_COMMA );
+float64_t extF80M_to_f64( const extFloat80_t * SOFTFLOAT_STATE_DECL_COMMA );
+void extF80M_to_f128M( const extFloat80_t *, float128_t * SOFTFLOAT_STATE_DECL_COMMA );
 void
  extF80M_roundToInt(
-     const extFloat80_t *, uint_fast8_t, bool, extFloat80_t * );
-void extF80M_add( const extFloat80_t *, const extFloat80_t *, extFloat80_t * );
-void extF80M_sub( const extFloat80_t *, const extFloat80_t *, extFloat80_t * );
-void extF80M_mul( const extFloat80_t *, const extFloat80_t *, extFloat80_t * );
-void extF80M_div( const extFloat80_t *, const extFloat80_t *, extFloat80_t * );
-void extF80M_rem( const extFloat80_t *, const extFloat80_t *, extFloat80_t * );
-void extF80M_sqrt( const extFloat80_t *, extFloat80_t * );
-bool extF80M_eq( const extFloat80_t *, const extFloat80_t * );
-bool extF80M_le( const extFloat80_t *, const extFloat80_t * );
-bool extF80M_lt( const extFloat80_t *, const extFloat80_t * );
-bool extF80M_eq_signaling( const extFloat80_t *, const extFloat80_t * );
-bool extF80M_le_quiet( const extFloat80_t *, const extFloat80_t * );
-bool extF80M_lt_quiet( const extFloat80_t *, const extFloat80_t * );
+     const extFloat80_t *, uint_fast8_t, bool, extFloat80_t * SOFTFLOAT_STATE_DECL_COMMA );
+void extF80M_add( const extFloat80_t *, const extFloat80_t *, extFloat80_t * SOFTFLOAT_STATE_DECL_COMMA );
+void extF80M_sub( const extFloat80_t *, const extFloat80_t *, extFloat80_t * SOFTFLOAT_STATE_DECL_COMMA );
+void extF80M_mul( const extFloat80_t *, const extFloat80_t *, extFloat80_t * SOFTFLOAT_STATE_DECL_COMMA );
+void extF80M_div( const extFloat80_t *, const extFloat80_t *, extFloat80_t * SOFTFLOAT_STATE_DECL_COMMA );
+void extF80M_rem( const extFloat80_t *, const extFloat80_t *, extFloat80_t * SOFTFLOAT_STATE_DECL_COMMA );
+void extF80M_sqrt( const extFloat80_t *, extFloat80_t * SOFTFLOAT_STATE_DECL_COMMA );
+bool extF80M_eq( const extFloat80_t *, const extFloat80_t * SOFTFLOAT_STATE_DECL_COMMA );
+bool extF80M_le( const extFloat80_t *, const extFloat80_t * SOFTFLOAT_STATE_DECL_COMMA );
+bool extF80M_lt( const extFloat80_t *, const extFloat80_t * SOFTFLOAT_STATE_DECL_COMMA );
+bool extF80M_eq_signaling( const extFloat80_t *, const extFloat80_t * SOFTFLOAT_STATE_DECL_COMMA );
+bool extF80M_le_quiet( const extFloat80_t *, const extFloat80_t * SOFTFLOAT_STATE_DECL_COMMA );
+bool extF80M_lt_quiet( const extFloat80_t *, const extFloat80_t * SOFTFLOAT_STATE_DECL_COMMA );
 bool extF80M_isSignalingNaN( const extFloat80_t * );
 
@@ -310,63 +339,65 @@
 *----------------------------------------------------------------------------*/
 #ifdef SOFTFLOAT_FAST_INT64
-uint_fast32_t f128_to_ui32( float128_t, uint_fast8_t, bool );
-uint_fast64_t f128_to_ui64( float128_t, uint_fast8_t, bool );
-int_fast32_t f128_to_i32( float128_t, uint_fast8_t, bool );
-int_fast64_t f128_to_i64( float128_t, uint_fast8_t, bool );
-uint_fast32_t f128_to_ui32_r_minMag( float128_t, bool );
-uint_fast64_t f128_to_ui64_r_minMag( float128_t, bool );
-int_fast32_t f128_to_i32_r_minMag( float128_t, bool );
-int_fast64_t f128_to_i64_r_minMag( float128_t, bool );
-float16_t f128_to_f16( float128_t );
-float32_t f128_to_f32( float128_t );
-float64_t f128_to_f64( float128_t );
-extFloat80_t f128_to_extF80( float128_t );
-float128_t f128_roundToInt( float128_t, uint_fast8_t, bool );
-float128_t f128_add( float128_t, float128_t );
-float128_t f128_sub( float128_t, float128_t );
-float128_t f128_mul( float128_t, float128_t );
-float128_t f128_mulAdd( float128_t, float128_t, float128_t );
-float128_t f128_div( float128_t, float128_t );
-float128_t f128_rem( float128_t, float128_t );
-float128_t f128_sqrt( float128_t );
-bool f128_eq( float128_t, float128_t );
-bool f128_le( float128_t, float128_t );
-bool f128_lt( float128_t, float128_t );
-bool f128_eq_signaling( float128_t, float128_t );
-bool f128_le_quiet( float128_t, float128_t );
-bool f128_lt_quiet( float128_t, float128_t );
+uint_fast32_t f128_to_ui32( float128_t, uint_fast8_t, bool SOFTFLOAT_STATE_DECL_COMMA );
+uint_fast64_t f128_to_ui64( float128_t, uint_fast8_t, bool SOFTFLOAT_STATE_DECL_COMMA );
+int_fast32_t f128_to_i32( float128_t, uint_fast8_t, bool SOFTFLOAT_STATE_DECL_COMMA );
+int_fast64_t f128_to_i64( float128_t, uint_fast8_t, bool SOFTFLOAT_STATE_DECL_COMMA );
+uint_fast32_t f128_to_ui32_r_minMag( float128_t, bool SOFTFLOAT_STATE_DECL_COMMA );
+uint_fast64_t f128_to_ui64_r_minMag( float128_t, bool SOFTFLOAT_STATE_DECL_COMMA );
+int_fast32_t f128_to_i32_r_minMag( float128_t, bool SOFTFLOAT_STATE_DECL_COMMA );
+int_fast64_t f128_to_i64_r_minMag( float128_t, bool SOFTFLOAT_STATE_DECL_COMMA );
+float16_t f128_to_f16( float128_t SOFTFLOAT_STATE_DECL_COMMA );
+float32_t f128_to_f32( float128_t SOFTFLOAT_STATE_DECL_COMMA );
+float64_t f128_to_f64( float128_t SOFTFLOAT_STATE_DECL_COMMA );
+extFloat80_t f128_to_extF80( float128_t SOFTFLOAT_STATE_DECL_COMMA );
+float128_t f128_roundToInt( float128_t, uint_fast8_t, bool SOFTFLOAT_STATE_DECL_COMMA );
+float128_t f128_add( float128_t, float128_t SOFTFLOAT_STATE_DECL_COMMA );
+float128_t f128_sub( float128_t, float128_t SOFTFLOAT_STATE_DECL_COMMA );
+float128_t f128_mul( float128_t, float128_t SOFTFLOAT_STATE_DECL_COMMA );
+float128_t f128_mulAdd( float128_t, float128_t, float128_t SOFTFLOAT_STATE_DECL_COMMA );
+float128_t f128_div( float128_t, float128_t SOFTFLOAT_STATE_DECL_COMMA );
+float128_t f128_rem( float128_t, float128_t SOFTFLOAT_STATE_DECL_COMMA );
+float128_t f128_sqrt( float128_t SOFTFLOAT_STATE_DECL_COMMA );
+bool f128_eq( float128_t, float128_t SOFTFLOAT_STATE_DECL_COMMA );
+bool f128_le( float128_t, float128_t SOFTFLOAT_STATE_DECL_COMMA );
+bool f128_lt( float128_t, float128_t SOFTFLOAT_STATE_DECL_COMMA );
+bool f128_eq_signaling( float128_t, float128_t SOFTFLOAT_STATE_DECL_COMMA );
+bool f128_le_quiet( float128_t, float128_t SOFTFLOAT_STATE_DECL_COMMA );
+bool f128_lt_quiet( float128_t, float128_t SOFTFLOAT_STATE_DECL_COMMA );
 bool f128_isSignalingNaN( float128_t );
 #endif
-uint_fast32_t f128M_to_ui32( const float128_t *, uint_fast8_t, bool );
-uint_fast64_t f128M_to_ui64( const float128_t *, uint_fast8_t, bool );
-int_fast32_t f128M_to_i32( const float128_t *, uint_fast8_t, bool );
-int_fast64_t f128M_to_i64( const float128_t *, uint_fast8_t, bool );
-uint_fast32_t f128M_to_ui32_r_minMag( const float128_t *, bool );
-uint_fast64_t f128M_to_ui64_r_minMag( const float128_t *, bool );
-int_fast32_t f128M_to_i32_r_minMag( const float128_t *, bool );
-int_fast64_t f128M_to_i64_r_minMag( const float128_t *, bool );
-float16_t f128M_to_f16( const float128_t * );
-float32_t f128M_to_f32( const float128_t * );
-float64_t f128M_to_f64( const float128_t * );
-void f128M_to_extF80M( const float128_t *, extFloat80_t * );
-void f128M_roundToInt( const float128_t *, uint_fast8_t, bool, float128_t * );
-void f128M_add( const float128_t *, const float128_t *, float128_t * );
-void f128M_sub( const float128_t *, const float128_t *, float128_t * );
-void f128M_mul( const float128_t *, const float128_t *, float128_t * );
+uint_fast32_t f128M_to_ui32( const float128_t *, uint_fast8_t, bool SOFTFLOAT_STATE_DECL_COMMA );
+uint_fast64_t f128M_to_ui64( const float128_t *, uint_fast8_t, bool SOFTFLOAT_STATE_DECL_COMMA );
+int_fast32_t f128M_to_i32( const float128_t *, uint_fast8_t, bool SOFTFLOAT_STATE_DECL_COMMA );
+int_fast64_t f128M_to_i64( const float128_t *, uint_fast8_t, bool SOFTFLOAT_STATE_DECL_COMMA );
+uint_fast32_t f128M_to_ui32_r_minMag( const float128_t *, bool SOFTFLOAT_STATE_DECL_COMMA );
+uint_fast64_t f128M_to_ui64_r_minMag( const float128_t *, bool SOFTFLOAT_STATE_DECL_COMMA );
+int_fast32_t f128M_to_i32_r_minMag( const float128_t *, bool SOFTFLOAT_STATE_DECL_COMMA );
+int_fast64_t f128M_to_i64_r_minMag( const float128_t *, bool SOFTFLOAT_STATE_DECL_COMMA );
+float16_t f128M_to_f16( const float128_t * SOFTFLOAT_STATE_DECL_COMMA );
+float32_t f128M_to_f32( const float128_t * SOFTFLOAT_STATE_DECL_COMMA );
+float64_t f128M_to_f64( const float128_t * SOFTFLOAT_STATE_DECL_COMMA );
+void f128M_to_extF80M( const float128_t *, extFloat80_t * SOFTFLOAT_STATE_DECL_COMMA );
+void f128M_roundToInt( const float128_t *, uint_fast8_t, bool, float128_t * SOFTFLOAT_STATE_DECL_COMMA );
+void f128M_add( const float128_t *, const float128_t *, float128_t * SOFTFLOAT_STATE_DECL_COMMA );
+void f128M_sub( const float128_t *, const float128_t *, float128_t * SOFTFLOAT_STATE_DECL_COMMA );
+void f128M_mul( const float128_t *, const float128_t *, float128_t * SOFTFLOAT_STATE_DECL_COMMA );
 void
  f128M_mulAdd(
-     const float128_t *, const float128_t *, const float128_t *, float128_t *
+     const float128_t *, const float128_t *, const float128_t *, float128_t * SOFTFLOAT_STATE_DECL_COMMA
  );
-void f128M_div( const float128_t *, const float128_t *, float128_t * );
-void f128M_rem( const float128_t *, const float128_t *, float128_t * );
-void f128M_sqrt( const float128_t *, float128_t * );
-bool f128M_eq( const float128_t *, const float128_t * );
-bool f128M_le( const float128_t *, const float128_t * );
-bool f128M_lt( const float128_t *, const float128_t * );
-bool f128M_eq_signaling( const float128_t *, const float128_t * );
-bool f128M_le_quiet( const float128_t *, const float128_t * );
-bool f128M_lt_quiet( const float128_t *, const float128_t * );
+void f128M_div( const float128_t *, const float128_t *, float128_t * SOFTFLOAT_STATE_DECL_COMMA );
+void f128M_rem( const float128_t *, const float128_t *, float128_t * SOFTFLOAT_STATE_DECL_COMMA );
+void f128M_sqrt( const float128_t *, float128_t * SOFTFLOAT_STATE_DECL_COMMA );
+bool f128M_eq( const float128_t *, const float128_t * SOFTFLOAT_STATE_DECL_COMMA );
+bool f128M_le( const float128_t *, const float128_t * SOFTFLOAT_STATE_DECL_COMMA );
+bool f128M_lt( const float128_t *, const float128_t * SOFTFLOAT_STATE_DECL_COMMA );
+bool f128M_eq_signaling( const float128_t *, const float128_t * SOFTFLOAT_STATE_DECL_COMMA );
+bool f128M_le_quiet( const float128_t *, const float128_t * SOFTFLOAT_STATE_DECL_COMMA );
+bool f128M_lt_quiet( const float128_t *, const float128_t * SOFTFLOAT_STATE_DECL_COMMA );
 bool f128M_isSignalingNaN( const float128_t * );
 
-#endif
-
+RT_C_DECLS_END
+
+#endif
+
Index: trunk/src/libs/softfloat-3e/source/include/softfloat_types.h
===================================================================
--- trunk/src/libs/softfloat-3e/source/include/softfloat_types.h	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/include/softfloat_types.h	(revision 94558)
@@ -78,4 +78,35 @@
 typedef struct extFloat80M extFloat80_t;
 
+/*----------------------------------------------------------------------------
+| VBox: The four globals as non-globals.
+*----------------------------------------------------------------------------*/
+#ifndef VBOX_WITH_SOFTFLOAT_GLOBALS
+# define VBOX_WITHOUT_SOFTFLOAT_GLOBALS
+# define SOFTFLOAT_STATE_ARG            pState
+# define SOFTFLOAT_STATE_ARG_COMMA      , pState
+# define SOFTFLOAT_STATE_DECL           softfloat_state_t *pState
+# define SOFTFLOAT_STATE_DECL_COMMA     , softfloat_state_t *pState
+# define SOFTFLOAT_STATE_NOREF()        (void)pState
+typedef struct softfloat_state
+{
+    /* softfloat_tininess_beforeRounding or softfloat_tininess_afterRounding */
+    uint8_t detectTininess;
+    /* softfloat_round_near_even and friends. */
+    uint8_t roundingMode;
+    /* softfloat_flag_inexact and friends. */
+    uint8_t exceptionFlags;
+    /* extF80: rounding precsision: 32, 64 or 80 */
+    uint8_t roundingPrecision;
+} softfloat_state_t;
+# define SOFTFLOAT_STATE_INIT_DEFAULTS() { softfloat_round_near_even, softfloat_tininess_afterRounding, 0, 80 }
+#else
+# undef  VBOX_WITHOUT_SOFTFLOAT_GLOBALS
+# define SOFTFLOAT_STATE_ARG
+# define SOFTFLOAT_STATE_ARG_COMMA
+# define SOFTFLOAT_STATE_DECL
+# define SOFTFLOAT_STATE_DECL_COMMA
+# define SOFTFLOAT_STATE_NOREF()        (void)0
 #endif
 
+#endif
+
Index: trunk/src/libs/softfloat-3e/source/s_addExtF80M.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/s_addExtF80M.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/s_addExtF80M.c	(revision 94558)
@@ -48,4 +48,5 @@
      struct extFloat80M *zSPtr,
      bool negateB
+     SOFTFLOAT_STATE_DECL_COMMA
  )
 {
@@ -60,5 +61,5 @@
     void
      (*roundPackRoutinePtr)(
-         bool, int32_t, uint32_t *, uint_fast8_t, struct extFloat80M * );
+         bool, int32_t, uint32_t *, uint_fast8_t, struct extFloat80M * SOFTFLOAT_STATE_DECL_COMMA );
     int32_t expDiff;
     uint32_t extSigX[3], sigZExtra;
@@ -73,10 +74,10 @@
     *------------------------------------------------------------------------*/
     if ( (expA == 0x7FFF) || (expB == 0x7FFF) ) {
-        if ( softfloat_tryPropagateNaNExtF80M( aSPtr, bSPtr, zSPtr ) ) return;
+        if ( softfloat_tryPropagateNaNExtF80M( aSPtr, bSPtr, zSPtr SOFTFLOAT_STATE_ARG_COMMA ) ) return;
         uiZ64 = uiA64;
         if ( expB == 0x7FFF ) {
             uiZ64 = uiB64 ^ packToExtF80UI64( negateB, 0 );
             if ( (expA == 0x7FFF) && (uiZ64 != uiA64) ) {
-                softfloat_invalidExtF80M( zSPtr );
+                softfloat_invalidExtF80M( zSPtr SOFTFLOAT_STATE_ARG_COMMA );
                 return;
             }
@@ -181,5 +182,5 @@
  roundPack:
     (*roundPackRoutinePtr)(
-        signZ, expA, extSigX, extF80_roundingPrecision, zSPtr );
+        signZ, expA, extSigX, extF80_roundingPrecision, zSPtr SOFTFLOAT_STATE_ARG_COMMA );
 
 }
Index: trunk/src/libs/softfloat-3e/source/s_addF128M.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/s_addF128M.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/s_addF128M.c	(revision 94558)
@@ -48,4 +48,5 @@
      uint32_t *zWPtr,
      bool negateB
+     SOFTFLOAT_STATE_DECL_COMMA
  )
 {
@@ -69,5 +70,5 @@
     uint32_t extSigZ[5], wordSigZ;
     uint_fast8_t carry;
-    void (*roundPackRoutinePtr)( bool, int32_t, uint32_t *, uint32_t * );
+    void (*roundPackRoutinePtr)( bool, int32_t, uint32_t *, uint32_t * SOFTFLOAT_STATE_DECL_COMMA );
 
     /*------------------------------------------------------------------------
@@ -80,10 +81,10 @@
     *------------------------------------------------------------------------*/
     if ( (expA == 0x7FFF) || (expB == 0x7FFF) ) {
-        if ( softfloat_tryPropagateNaNF128M( aWPtr, bWPtr, zWPtr ) ) return;
+        if ( softfloat_tryPropagateNaNF128M( aWPtr, bWPtr, zWPtr SOFTFLOAT_STATE_ARG_COMMA ) ) return;
         uiZ96 = uiA96;
         if ( expB == 0x7FFF ) {
             uiZ96 = uiB96 ^ packToF128UI96( negateB, 0, 0 );
             if ( (expA == 0x7FFF) && (uiZ96 != uiA96) ) {
-                softfloat_invalidF128M( zWPtr );
+                softfloat_invalidF128M( zWPtr SOFTFLOAT_STATE_ARG_COMMA );
                 return;
             }
@@ -206,5 +207,5 @@
         roundPackRoutinePtr = softfloat_roundPackMToF128M;
     }
-    (*roundPackRoutinePtr)( signZ, expA, extSigZ, zWPtr );
+    (*roundPackRoutinePtr)( signZ, expA, extSigZ, zWPtr SOFTFLOAT_STATE_ARG_COMMA );
 
 }
Index: trunk/src/libs/softfloat-3e/source/s_addMagsExtF80.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/s_addMagsExtF80.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/s_addMagsExtF80.c	(revision 94558)
@@ -49,4 +49,5 @@
      uint_fast64_t uiB0,
      bool signZ
+     SOFTFLOAT_STATE_DECL_COMMA
  )
 {
@@ -141,9 +142,9 @@
     return
         softfloat_roundPackToExtF80(
-            signZ, expZ, sigZ, sigZExtra, extF80_roundingPrecision );
+            signZ, expZ, sigZ, sigZExtra, extF80_roundingPrecision SOFTFLOAT_STATE_ARG_COMMA );
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  propagateNaN:
-    uiZ = softfloat_propagateNaNExtF80UI( uiA64, uiA0, uiB64, uiB0 );
+    uiZ = softfloat_propagateNaNExtF80UI( uiA64, uiA0, uiB64, uiB0 SOFTFLOAT_STATE_ARG_COMMA );
     uiZ64 = uiZ.v64;
     uiZ0  = uiZ.v0;
Index: trunk/src/libs/softfloat-3e/source/s_addMagsF128.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/s_addMagsF128.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/s_addMagsF128.c	(revision 94558)
@@ -48,4 +48,5 @@
      uint_fast64_t uiB0,
      bool signZ
+     SOFTFLOAT_STATE_DECL_COMMA
  )
 {
@@ -144,7 +145,7 @@
  roundAndPack:
     return
-        softfloat_roundPackToF128( signZ, expZ, sigZ.v64, sigZ.v0, sigZExtra );
+        softfloat_roundPackToF128( signZ, expZ, sigZ.v64, sigZ.v0, sigZExtra SOFTFLOAT_STATE_ARG_COMMA );
  propagateNaN:
-    uiZ = softfloat_propagateNaNF128UI( uiA64, uiA0, uiB64, uiB0 );
+    uiZ = softfloat_propagateNaNF128UI( uiA64, uiA0, uiB64, uiB0 SOFTFLOAT_STATE_ARG_COMMA );
  uiZ:
     uZ.ui = uiZ;
Index: trunk/src/libs/softfloat-3e/source/s_addMagsF16.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/s_addMagsF16.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/s_addMagsF16.c	(revision 94558)
@@ -42,5 +42,5 @@
 #include "softfloat.h"
 
-float16_t softfloat_addMagsF16( uint_fast16_t uiA, uint_fast16_t uiB )
+float16_t softfloat_addMagsF16( uint_fast16_t uiA, uint_fast16_t uiB SOFTFLOAT_STATE_DECL_COMMA )
 {
     int_fast8_t expA;
@@ -142,9 +142,9 @@
         }
     }
-    return softfloat_roundPackToF16( signZ, expZ, sigZ );
+    return softfloat_roundPackToF16( signZ, expZ, sigZ SOFTFLOAT_STATE_ARG_COMMA );
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  propagateNaN:
-    uiZ = softfloat_propagateNaNF16UI( uiA, uiB );
+    uiZ = softfloat_propagateNaNF16UI( uiA, uiB SOFTFLOAT_STATE_ARG_COMMA );
     goto uiZ;
     /*------------------------------------------------------------------------
@@ -161,5 +161,6 @@
             if ( (uint16_t) (uiZ<<1) == 0xF800 ) {
                 softfloat_raiseFlags(
-                    softfloat_flag_overflow | softfloat_flag_inexact );
+                    softfloat_flag_overflow | softfloat_flag_inexact
+                    SOFTFLOAT_STATE_ARG_COMMA );
             }
         }
Index: trunk/src/libs/softfloat-3e/source/s_addMagsF32.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/s_addMagsF32.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/s_addMagsF32.c	(revision 94558)
@@ -41,5 +41,5 @@
 #include "specialize.h"
 
-float32_t softfloat_addMagsF32( uint_fast32_t uiA, uint_fast32_t uiB )
+float32_t softfloat_addMagsF32( uint_fast32_t uiA, uint_fast32_t uiB SOFTFLOAT_STATE_DECL_COMMA )
 {
     int_fast16_t expA;
@@ -114,9 +114,9 @@
         }
     }
-    return softfloat_roundPackToF32( signZ, expZ, sigZ );
+    return softfloat_roundPackToF32( signZ, expZ, sigZ SOFTFLOAT_STATE_ARG_COMMA );
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  propagateNaN:
-    uiZ = softfloat_propagateNaNF32UI( uiA, uiB );
+    uiZ = softfloat_propagateNaNF32UI( uiA, uiB SOFTFLOAT_STATE_ARG_COMMA );
  uiZ:
     uZ.ui = uiZ;
Index: trunk/src/libs/softfloat-3e/source/s_addMagsF64.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/s_addMagsF64.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/s_addMagsF64.c	(revision 94558)
@@ -42,5 +42,5 @@
 
 float64_t
- softfloat_addMagsF64( uint_fast64_t uiA, uint_fast64_t uiB, bool signZ )
+ softfloat_addMagsF64( uint_fast64_t uiA, uint_fast64_t uiB, bool signZ SOFTFLOAT_STATE_DECL_COMMA )
 {
     int_fast16_t expA;
@@ -116,9 +116,9 @@
         }
     }
-    return softfloat_roundPackToF64( signZ, expZ, sigZ );
+    return softfloat_roundPackToF64( signZ, expZ, sigZ SOFTFLOAT_STATE_ARG_COMMA );
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  propagateNaN:
-    uiZ = softfloat_propagateNaNF64UI( uiA, uiB );
+    uiZ = softfloat_propagateNaNF64UI( uiA, uiB SOFTFLOAT_STATE_ARG_COMMA );
  uiZ:
     uZ.ui = uiZ;
Index: trunk/src/libs/softfloat-3e/source/s_invalidExtF80M.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/s_invalidExtF80M.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/s_invalidExtF80M.c	(revision 94558)
@@ -39,8 +39,8 @@
 #include "softfloat.h"
 
-void softfloat_invalidExtF80M( struct extFloat80M *zSPtr )
+void softfloat_invalidExtF80M( struct extFloat80M *zSPtr SOFTFLOAT_STATE_DECL_COMMA )
 {
 
-    softfloat_raiseFlags( softfloat_flag_invalid );
+    softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
     zSPtr->signExp = defaultNaNExtF80UI64;
     zSPtr->signif  = defaultNaNExtF80UI0;
Index: trunk/src/libs/softfloat-3e/source/s_invalidF128M.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/s_invalidF128M.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/s_invalidF128M.c	(revision 94558)
@@ -41,8 +41,8 @@
 #include "softfloat.h"
 
-void softfloat_invalidF128M( uint32_t *zWPtr )
+void softfloat_invalidF128M( uint32_t *zWPtr SOFTFLOAT_STATE_DECL_COMMA )
 {
 
-    softfloat_raiseFlags( softfloat_flag_invalid );
+    softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
     zWPtr[indexWord( 4, 3 )] = defaultNaNF128UI96;
     zWPtr[indexWord( 4, 2 )] = defaultNaNF128UI64;
Index: trunk/src/libs/softfloat-3e/source/s_mulAddF128.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/s_mulAddF128.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/s_mulAddF128.c	(revision 94558)
@@ -51,4 +51,5 @@
      uint_fast64_t uiC0,
      uint_fast8_t op
+     SOFTFLOAT_STATE_DECL_COMMA
  )
 {
@@ -309,9 +310,9 @@
     return
         softfloat_roundPackToF128(
-            signZ, expZ - 1, sigZ.v64, sigZ.v0, sigZExtra );
+            signZ, expZ - 1, sigZ.v64, sigZ.v0, sigZExtra SOFTFLOAT_STATE_ARG_COMMA );
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  propagateNaN_ABC:
-    uiZ = softfloat_propagateNaNF128UI( uiA64, uiA0, uiB64, uiB0 );
+    uiZ = softfloat_propagateNaNF128UI( uiA64, uiA0, uiB64, uiB0 SOFTFLOAT_STATE_ARG_COMMA );
     goto propagateNaN_ZC;
     /*------------------------------------------------------------------------
@@ -325,9 +326,9 @@
         if ( signZ == signC ) goto uiZ;
     }
-    softfloat_raiseFlags( softfloat_flag_invalid );
+    softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
     uiZ.v64 = defaultNaNF128UI64;
     uiZ.v0  = defaultNaNF128UI0;
  propagateNaN_ZC:
-    uiZ = softfloat_propagateNaNF128UI( uiZ.v64, uiZ.v0, uiC64, uiC0 );
+    uiZ = softfloat_propagateNaNF128UI( uiZ.v64, uiZ.v0, uiC64, uiC0 SOFTFLOAT_STATE_ARG_COMMA );
     goto uiZ;
     /*------------------------------------------------------------------------
Index: trunk/src/libs/softfloat-3e/source/s_mulAddF128M.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/s_mulAddF128M.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/s_mulAddF128M.c	(revision 94558)
@@ -49,4 +49,5 @@
      uint32_t *zWPtr,
      uint_fast8_t op
+     SOFTFLOAT_STATE_DECL_COMMA
  )
 {
@@ -78,5 +79,5 @@
     uint32_t *extSigPtr;
     uint_fast8_t carry;
-    void (*roundPackRoutinePtr)( bool, int32_t, uint32_t *, uint32_t * );
+    void (*roundPackRoutinePtr)( bool, int32_t, uint32_t *, uint32_t * SOFTFLOAT_STATE_DECL_COMMA );
 
     /*------------------------------------------------------------------------
@@ -96,5 +97,5 @@
     prodIsInfinite = false;
     if ( (expA == 0x7FFF) || (expB == 0x7FFF) ) {
-        if ( softfloat_tryPropagateNaNF128M( aWPtr, bWPtr, zWPtr ) ) {
+        if ( softfloat_tryPropagateNaNF128M( aWPtr, bWPtr, zWPtr SOFTFLOAT_STATE_ARG_COMMA ) ) {
             goto propagateNaN_ZC;
         }
@@ -334,12 +335,12 @@
     roundPackRoutinePtr = softfloat_roundPackMToF128M;
  doRoundPack:
-    (*roundPackRoutinePtr)( signZ, expZ, extSigPtr, zWPtr );
+    (*roundPackRoutinePtr)( signZ, expZ, extSigPtr, zWPtr SOFTFLOAT_STATE_ARG_COMMA );
     return;
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  invalid:
-    softfloat_invalidF128M( zWPtr );
+    softfloat_invalidF128M( zWPtr SOFTFLOAT_STATE_ARG_COMMA );
  propagateNaN_ZC:
-    softfloat_propagateNaNF128M( zWPtr, cWPtr, zWPtr );
+    softfloat_propagateNaNF128M( zWPtr, cWPtr, zWPtr SOFTFLOAT_STATE_ARG_COMMA );
     return;
     /*------------------------------------------------------------------------
Index: trunk/src/libs/softfloat-3e/source/s_mulAddF16.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/s_mulAddF16.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/s_mulAddF16.c	(revision 94558)
@@ -44,5 +44,5 @@
 float16_t
  softfloat_mulAddF16(
-     uint_fast16_t uiA, uint_fast16_t uiB, uint_fast16_t uiC, uint_fast8_t op )
+     uint_fast16_t uiA, uint_fast16_t uiB, uint_fast16_t uiC, uint_fast8_t op SOFTFLOAT_STATE_DECL_COMMA )
 {
     bool signA;
@@ -189,9 +189,9 @@
     }
  roundPack:
-    return softfloat_roundPackToF16( signZ, expZ, sigZ );
+    return softfloat_roundPackToF16( signZ, expZ, sigZ SOFTFLOAT_STATE_ARG_COMMA );
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  propagateNaN_ABC:
-    uiZ = softfloat_propagateNaNF16UI( uiA, uiB );
+    uiZ = softfloat_propagateNaNF16UI( uiA, uiB SOFTFLOAT_STATE_ARG_COMMA );
     goto propagateNaN_ZC;
     /*------------------------------------------------------------------------
@@ -204,8 +204,8 @@
         if ( signProd == signC ) goto uiZ;
     }
-    softfloat_raiseFlags( softfloat_flag_invalid );
+    softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
     uiZ = defaultNaNF16UI;
  propagateNaN_ZC:
-    uiZ = softfloat_propagateNaNF16UI( uiZ, uiC );
+    uiZ = softfloat_propagateNaNF16UI( uiZ, uiC SOFTFLOAT_STATE_ARG_COMMA );
     goto uiZ;
     /*------------------------------------------------------------------------
Index: trunk/src/libs/softfloat-3e/source/s_mulAddF32.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/s_mulAddF32.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/s_mulAddF32.c	(revision 94558)
@@ -44,5 +44,5 @@
 float32_t
  softfloat_mulAddF32(
-     uint_fast32_t uiA, uint_fast32_t uiB, uint_fast32_t uiC, uint_fast8_t op )
+     uint_fast32_t uiA, uint_fast32_t uiB, uint_fast32_t uiC, uint_fast8_t op SOFTFLOAT_STATE_DECL_COMMA )
 {
     bool signA;
@@ -187,9 +187,9 @@
     }
  roundPack:
-    return softfloat_roundPackToF32( signZ, expZ, sigZ );
+    return softfloat_roundPackToF32( signZ, expZ, sigZ SOFTFLOAT_STATE_ARG_COMMA );
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  propagateNaN_ABC:
-    uiZ = softfloat_propagateNaNF32UI( uiA, uiB );
+    uiZ = softfloat_propagateNaNF32UI( uiA, uiB SOFTFLOAT_STATE_ARG_COMMA );
     goto propagateNaN_ZC;
     /*------------------------------------------------------------------------
@@ -202,8 +202,8 @@
         if ( signProd == signC ) goto uiZ;
     }
-    softfloat_raiseFlags( softfloat_flag_invalid );
+    softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
     uiZ = defaultNaNF32UI;
  propagateNaN_ZC:
-    uiZ = softfloat_propagateNaNF32UI( uiZ, uiC );
+    uiZ = softfloat_propagateNaNF32UI( uiZ, uiC SOFTFLOAT_STATE_ARG_COMMA );
     goto uiZ;
     /*------------------------------------------------------------------------
Index: trunk/src/libs/softfloat-3e/source/s_mulAddF64.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/s_mulAddF64.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/s_mulAddF64.c	(revision 94558)
@@ -46,5 +46,5 @@
 float64_t
  softfloat_mulAddF64(
-     uint_fast64_t uiA, uint_fast64_t uiB, uint_fast64_t uiC, uint_fast8_t op )
+     uint_fast64_t uiA, uint_fast64_t uiB, uint_fast64_t uiC, uint_fast8_t op SOFTFLOAT_STATE_DECL_COMMA )
 {
     bool signA;
@@ -206,9 +206,9 @@
     }
  roundPack:
-    return softfloat_roundPackToF64( signZ, expZ, sigZ );
+    return softfloat_roundPackToF64( signZ, expZ, sigZ SOFTFLOAT_STATE_ARG_COMMA );
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  propagateNaN_ABC:
-    uiZ = softfloat_propagateNaNF64UI( uiA, uiB );
+    uiZ = softfloat_propagateNaNF64UI( uiA, uiB SOFTFLOAT_STATE_ARG_COMMA );
     goto propagateNaN_ZC;
     /*------------------------------------------------------------------------
@@ -221,8 +221,8 @@
         if ( signZ == signC ) goto uiZ;
     }
-    softfloat_raiseFlags( softfloat_flag_invalid );
+    softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
     uiZ = defaultNaNF64UI;
  propagateNaN_ZC:
-    uiZ = softfloat_propagateNaNF64UI( uiZ, uiC );
+    uiZ = softfloat_propagateNaNF64UI( uiZ, uiC SOFTFLOAT_STATE_ARG_COMMA );
     goto uiZ;
     /*------------------------------------------------------------------------
@@ -246,5 +246,5 @@
 float64_t
  softfloat_mulAddF64(
-     uint_fast64_t uiA, uint_fast64_t uiB, uint_fast64_t uiC, uint_fast8_t op )
+     uint_fast64_t uiA, uint_fast64_t uiB, uint_fast64_t uiC, uint_fast8_t op SOFTFLOAT_STATE_DECL_COMMA )
 {
     bool signA;
@@ -457,9 +457,9 @@
     if ( sig128Z[indexWord( 4, 1 )] || sig128Z[indexWord( 4, 0 )] ) sigZ |= 1;
  roundPack:
-    return softfloat_roundPackToF64( signZ, expZ - 1, sigZ );
+    return softfloat_roundPackToF64( signZ, expZ - 1, sigZ SOFTFLOAT_STATE_ARG_COMMA );
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  propagateNaN_ABC:
-    uiZ = softfloat_propagateNaNF64UI( uiA, uiB );
+    uiZ = softfloat_propagateNaNF64UI( uiA, uiB SOFTFLOAT_STATE_ARG_COMMA );
     goto propagateNaN_ZC;
     /*------------------------------------------------------------------------
@@ -472,8 +472,8 @@
         if ( signZ == signC ) goto uiZ;
     }
-    softfloat_raiseFlags( softfloat_flag_invalid );
+    softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
     uiZ = defaultNaNF64UI;
  propagateNaN_ZC:
-    uiZ = softfloat_propagateNaNF64UI( uiZ, uiC );
+    uiZ = softfloat_propagateNaNF64UI( uiZ, uiC SOFTFLOAT_STATE_ARG_COMMA );
     goto uiZ;
     /*------------------------------------------------------------------------
Index: trunk/src/libs/softfloat-3e/source/s_normRoundPackMToExtF80M.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/s_normRoundPackMToExtF80M.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/s_normRoundPackMToExtF80M.c	(revision 94558)
@@ -47,4 +47,5 @@
      uint_fast8_t roundingPrecision,
      struct extFloat80M *zSPtr
+     SOFTFLOAT_STATE_DECL_COMMA
  )
 {
@@ -73,5 +74,5 @@
     }
     softfloat_roundPackMToExtF80M(
-        sign, exp, extSigPtr, roundingPrecision, zSPtr );
+        sign, exp, extSigPtr, roundingPrecision, zSPtr SOFTFLOAT_STATE_ARG_COMMA );
 
 }
Index: trunk/src/libs/softfloat-3e/source/s_normRoundPackMToF128M.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/s_normRoundPackMToF128M.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/s_normRoundPackMToF128M.c	(revision 94558)
@@ -42,5 +42,5 @@
 void
  softfloat_normRoundPackMToF128M(
-     bool sign, int32_t exp, uint32_t *extSigPtr, uint32_t *zWPtr )
+     bool sign, int32_t exp, uint32_t *extSigPtr, uint32_t *zWPtr SOFTFLOAT_STATE_DECL_COMMA )
 {
     const uint32_t *ptr;
@@ -68,5 +68,5 @@
         softfloat_shiftLeft160M( extSigPtr, shiftDist, extSigPtr );
     }
-    softfloat_roundPackMToF128M( sign, exp, extSigPtr, zWPtr );
+    softfloat_roundPackMToF128M( sign, exp, extSigPtr, zWPtr SOFTFLOAT_STATE_ARG_COMMA );
 
 }
Index: trunk/src/libs/softfloat-3e/source/s_normRoundPackToExtF80.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/s_normRoundPackToExtF80.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/s_normRoundPackToExtF80.c	(revision 94558)
@@ -47,4 +47,5 @@
      uint_fast64_t sigExtra,
      uint_fast8_t roundingPrecision
+     SOFTFLOAT_STATE_DECL_COMMA
  )
 {
@@ -66,5 +67,5 @@
     return
         softfloat_roundPackToExtF80(
-            sign, exp, sig, sigExtra, roundingPrecision );
+            sign, exp, sig, sigExtra, roundingPrecision SOFTFLOAT_STATE_ARG_COMMA );
 
 }
Index: trunk/src/libs/softfloat-3e/source/s_normRoundPackToF128.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/s_normRoundPackToF128.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/s_normRoundPackToF128.c	(revision 94558)
@@ -42,5 +42,5 @@
 float128_t
  softfloat_normRoundPackToF128(
-     bool sign, int_fast32_t exp, uint_fast64_t sig64, uint_fast64_t sig0 )
+     bool sign, int_fast32_t exp, uint_fast64_t sig64, uint_fast64_t sig0 SOFTFLOAT_STATE_DECL_COMMA )
 {
     int_fast8_t shiftDist;
@@ -76,5 +76,5 @@
         sigExtra = sig128Extra.extra;
     }
-    return softfloat_roundPackToF128( sign, exp, sig64, sig0, sigExtra );
+    return softfloat_roundPackToF128( sign, exp, sig64, sig0, sigExtra SOFTFLOAT_STATE_ARG_COMMA );
 
 }
Index: trunk/src/libs/softfloat-3e/source/s_normRoundPackToF16.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/s_normRoundPackToF16.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/s_normRoundPackToF16.c	(revision 94558)
@@ -41,5 +41,5 @@
 
 float16_t
- softfloat_normRoundPackToF16( bool sign, int_fast16_t exp, uint_fast16_t sig )
+ softfloat_normRoundPackToF16( bool sign, int_fast16_t exp, uint_fast16_t sig SOFTFLOAT_STATE_DECL_COMMA )
 {
     int_fast8_t shiftDist;
@@ -52,5 +52,5 @@
         return uZ.f;
     } else {
-        return softfloat_roundPackToF16( sign, exp, sig<<shiftDist );
+        return softfloat_roundPackToF16( sign, exp, sig<<shiftDist SOFTFLOAT_STATE_ARG_COMMA );
     }
 
Index: trunk/src/libs/softfloat-3e/source/s_normRoundPackToF32.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/s_normRoundPackToF32.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/s_normRoundPackToF32.c	(revision 94558)
@@ -41,5 +41,5 @@
 
 float32_t
- softfloat_normRoundPackToF32( bool sign, int_fast16_t exp, uint_fast32_t sig )
+ softfloat_normRoundPackToF32( bool sign, int_fast16_t exp, uint_fast32_t sig SOFTFLOAT_STATE_DECL_COMMA )
 {
     int_fast8_t shiftDist;
@@ -52,5 +52,5 @@
         return uZ.f;
     } else {
-        return softfloat_roundPackToF32( sign, exp, sig<<shiftDist );
+        return softfloat_roundPackToF32( sign, exp, sig<<shiftDist SOFTFLOAT_STATE_ARG_COMMA );
     }
 
Index: trunk/src/libs/softfloat-3e/source/s_normRoundPackToF64.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/s_normRoundPackToF64.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/s_normRoundPackToF64.c	(revision 94558)
@@ -41,5 +41,5 @@
 
 float64_t
- softfloat_normRoundPackToF64( bool sign, int_fast16_t exp, uint_fast64_t sig )
+ softfloat_normRoundPackToF64( bool sign, int_fast16_t exp, uint_fast64_t sig SOFTFLOAT_STATE_DECL_COMMA )
 {
     int_fast8_t shiftDist;
@@ -52,5 +52,5 @@
         return uZ.f;
     } else {
-        return softfloat_roundPackToF64( sign, exp, sig<<shiftDist );
+        return softfloat_roundPackToF64( sign, exp, sig<<shiftDist SOFTFLOAT_STATE_ARG_COMMA );
     }
 
Index: trunk/src/libs/softfloat-3e/source/s_roundMToI64.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/s_roundMToI64.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/s_roundMToI64.c	(revision 94558)
@@ -44,5 +44,5 @@
 int_fast64_t
  softfloat_roundMToI64(
-     bool sign, uint32_t *extSigPtr, uint_fast8_t roundingMode, bool exact )
+     bool sign, uint32_t *extSigPtr, uint_fast8_t roundingMode, bool exact SOFTFLOAT_STATE_DECL_COMMA )
 {
     uint64_t sig;
@@ -96,5 +96,5 @@
     *------------------------------------------------------------------------*/
  invalid:
-    softfloat_raiseFlags( softfloat_flag_invalid );
+    softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
     return sign ? i64_fromNegOverflow : i64_fromPosOverflow;
 
Index: trunk/src/libs/softfloat-3e/source/s_roundMToUI64.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/s_roundMToUI64.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/s_roundMToUI64.c	(revision 94558)
@@ -44,5 +44,5 @@
 uint_fast64_t
  softfloat_roundMToUI64(
-     bool sign, uint32_t *extSigPtr, uint_fast8_t roundingMode, bool exact )
+     bool sign, uint32_t *extSigPtr, uint_fast8_t roundingMode, bool exact SOFTFLOAT_STATE_DECL_COMMA)
 {
     uint64_t sig;
@@ -92,5 +92,5 @@
     *------------------------------------------------------------------------*/
  invalid:
-    softfloat_raiseFlags( softfloat_flag_invalid );
+    softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
     return sign ? ui64_fromNegOverflow : ui64_fromPosOverflow;
 
Index: trunk/src/libs/softfloat-3e/source/s_roundPackMToExtF80M.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/s_roundPackMToExtF80M.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/s_roundPackMToExtF80M.c	(revision 94558)
@@ -48,4 +48,5 @@
      uint_fast8_t roundingPrecision,
      struct extFloat80M *zSPtr
+     SOFTFLOAT_STATE_DECL_COMMA
  )
 {
@@ -99,5 +100,5 @@
             roundBits = sig & roundMask;
             if ( roundBits ) {
-                if ( isTiny ) softfloat_raiseFlags( softfloat_flag_underflow );
+                if ( isTiny ) softfloat_raiseFlags( softfloat_flag_underflow SOFTFLOAT_STATE_ARG_COMMA );
                 softfloat_exceptionFlags |= softfloat_flag_inexact;
 #ifdef SOFTFLOAT_ROUND_ODD
@@ -175,5 +176,5 @@
             sigExtra = extSigPtr[indexWordLo( 3 )];
             if ( sigExtra ) {
-                if ( isTiny ) softfloat_raiseFlags( softfloat_flag_underflow );
+                if ( isTiny ) softfloat_raiseFlags( softfloat_flag_underflow SOFTFLOAT_STATE_ARG_COMMA );
                 softfloat_exceptionFlags |= softfloat_flag_inexact;
 #ifdef SOFTFLOAT_ROUND_ODD
@@ -211,5 +212,6 @@
  overflow:
             softfloat_raiseFlags(
-                softfloat_flag_overflow | softfloat_flag_inexact );
+                softfloat_flag_overflow | softfloat_flag_inexact
+                SOFTFLOAT_STATE_ARG_COMMA );
             if (
                    roundNearEven
Index: trunk/src/libs/softfloat-3e/source/s_roundPackMToF128M.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/s_roundPackMToF128M.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/s_roundPackMToF128M.c	(revision 94558)
@@ -43,5 +43,5 @@
 void
  softfloat_roundPackMToF128M(
-     bool sign, int32_t exp, uint32_t *extSigPtr, uint32_t *zWPtr )
+     bool sign, int32_t exp, uint32_t *extSigPtr, uint32_t *zWPtr SOFTFLOAT_STATE_DECL_COMMA )
 {
     uint_fast8_t roundingMode;
@@ -83,5 +83,5 @@
             sigExtra = extSigPtr[indexWordLo( 5 )];
             if ( isTiny && sigExtra ) {
-                softfloat_raiseFlags( softfloat_flag_underflow );
+                softfloat_raiseFlags( softfloat_flag_underflow SOFTFLOAT_STATE_ARG_COMMA );
             }
             doIncrement = (0x80000000 <= sigExtra);
@@ -105,5 +105,6 @@
             *----------------------------------------------------------------*/
             softfloat_raiseFlags(
-                softfloat_flag_overflow | softfloat_flag_inexact );
+                softfloat_flag_overflow | softfloat_flag_inexact
+                SOFTFLOAT_STATE_ARG_COMMA );
             if (
                    roundNearEven
Index: trunk/src/libs/softfloat-3e/source/s_roundPackToExtF80.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/s_roundPackToExtF80.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/s_roundPackToExtF80.c	(revision 94558)
@@ -48,4 +48,5 @@
      uint_fast64_t sigExtra,
      uint_fast8_t roundingPrecision
+     SOFTFLOAT_STATE_DECL_COMMA
  )
 {
@@ -94,6 +95,7 @@
             roundBits = sig & roundMask;
             if ( roundBits ) {
-                if ( isTiny ) softfloat_raiseFlags( softfloat_flag_underflow );
+                if ( isTiny ) softfloat_raiseFlags( softfloat_flag_underflow SOFTFLOAT_STATE_ARG_COMMA );
                 softfloat_exceptionFlags |= softfloat_flag_inexact;
+                if ( roundIncrement ) softfloat_exceptionFlags |= softfloat_flag_c1; /* VBox */
 #ifdef SOFTFLOAT_ROUND_ODD
                 if ( roundingMode == softfloat_round_odd ) {
@@ -122,4 +124,5 @@
     if ( roundBits ) {
         softfloat_exceptionFlags |= softfloat_flag_inexact;
+        if ( roundIncrement ) softfloat_exceptionFlags |= softfloat_flag_c1; /* VBox */
 #ifdef SOFTFLOAT_ROUND_ODD
         if ( roundingMode == softfloat_round_odd ) {
@@ -168,6 +171,5 @@
             sigExtra = sig64Extra.extra;
             if ( sigExtra ) {
-                if ( isTiny ) softfloat_raiseFlags( softfloat_flag_underflow );
-                softfloat_exceptionFlags |= softfloat_flag_inexact;
+                if ( isTiny ) softfloat_raiseFlags( softfloat_flag_underflow SOFTFLOAT_STATE_ARG_COMMA );
 #ifdef SOFTFLOAT_ROUND_ODD
                 if ( roundingMode == softfloat_round_odd ) {
@@ -188,4 +190,5 @@
             }
             if ( doIncrement ) {
+                softfloat_exceptionFlags |= softfloat_flag_c1; /* VBox */
                 ++sig;
                 sig &=
@@ -207,5 +210,6 @@
  overflow:
             softfloat_raiseFlags(
-                softfloat_flag_overflow | softfloat_flag_inexact );
+                softfloat_flag_overflow | softfloat_flag_inexact
+                SOFTFLOAT_STATE_ARG_COMMA );
             if (
                    roundNearEven
@@ -235,4 +239,5 @@
     }
     if ( doIncrement ) {
+        softfloat_exceptionFlags |= softfloat_flag_c1; /* VBox */
         ++sig;
         if ( ! sig ) {
Index: trunk/src/libs/softfloat-3e/source/s_roundPackToF128.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/s_roundPackToF128.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/s_roundPackToF128.c	(revision 94558)
@@ -48,4 +48,5 @@
      uint_fast64_t sig0,
      uint_fast64_t sigExtra
+     SOFTFLOAT_STATE_DECL_COMMA
  )
 {
@@ -92,5 +93,5 @@
             exp = 0;
             if ( isTiny && sigExtra ) {
-                softfloat_raiseFlags( softfloat_flag_underflow );
+                softfloat_raiseFlags( softfloat_flag_underflow SOFTFLOAT_STATE_ARG_COMMA );
             }
             doIncrement = (UINT64_C( 0x8000000000000000 ) <= sigExtra);
@@ -118,5 +119,6 @@
             *----------------------------------------------------------------*/
             softfloat_raiseFlags(
-                softfloat_flag_overflow | softfloat_flag_inexact );
+                softfloat_flag_overflow | softfloat_flag_inexact
+                SOFTFLOAT_STATE_ARG_COMMA );
             if (
                    roundNearEven
Index: trunk/src/libs/softfloat-3e/source/s_roundPackToF16.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/s_roundPackToF16.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/s_roundPackToF16.c	(revision 94558)
@@ -42,5 +42,5 @@
 
 float16_t
- softfloat_roundPackToF16( bool sign, int_fast16_t exp, uint_fast16_t sig )
+ softfloat_roundPackToF16( bool sign, int_fast16_t exp, uint_fast16_t sig SOFTFLOAT_STATE_DECL_COMMA )
 {
     uint_fast8_t roundingMode;
@@ -77,5 +77,5 @@
             roundBits = sig & 0xF;
             if ( isTiny && roundBits ) {
-                softfloat_raiseFlags( softfloat_flag_underflow );
+                softfloat_raiseFlags( softfloat_flag_underflow SOFTFLOAT_STATE_ARG_COMMA );
             }
         } else if ( (0x1D < exp) || (0x8000 <= sig + roundIncrement) ) {
@@ -83,5 +83,6 @@
             *----------------------------------------------------------------*/
             softfloat_raiseFlags(
-                softfloat_flag_overflow | softfloat_flag_inexact );
+                softfloat_flag_overflow | softfloat_flag_inexact
+                SOFTFLOAT_STATE_ARG_COMMA );
             uiZ = packToF16UI( sign, 0x1F, 0 ) - ! roundIncrement;
             goto uiZ;
Index: trunk/src/libs/softfloat-3e/source/s_roundPackToF32.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/s_roundPackToF32.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/s_roundPackToF32.c	(revision 94558)
@@ -42,5 +42,5 @@
 
 float32_t
- softfloat_roundPackToF32( bool sign, int_fast16_t exp, uint_fast32_t sig )
+ softfloat_roundPackToF32( bool sign, int_fast16_t exp, uint_fast32_t sig SOFTFLOAT_STATE_DECL_COMMA )
 {
     uint_fast8_t roundingMode;
@@ -77,5 +77,5 @@
             roundBits = sig & 0x7F;
             if ( isTiny && roundBits ) {
-                softfloat_raiseFlags( softfloat_flag_underflow );
+                softfloat_raiseFlags( softfloat_flag_underflow SOFTFLOAT_STATE_ARG_COMMA );
             }
         } else if ( (0xFD < exp) || (0x80000000 <= sig + roundIncrement) ) {
@@ -83,5 +83,6 @@
             *----------------------------------------------------------------*/
             softfloat_raiseFlags(
-                softfloat_flag_overflow | softfloat_flag_inexact );
+                softfloat_flag_overflow | softfloat_flag_inexact
+                SOFTFLOAT_STATE_ARG_COMMA );
             uiZ = packToF32UI( sign, 0xFF, 0 ) - ! roundIncrement;
             goto uiZ;
Index: trunk/src/libs/softfloat-3e/source/s_roundPackToF64.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/s_roundPackToF64.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/s_roundPackToF64.c	(revision 94558)
@@ -42,5 +42,5 @@
 
 float64_t
- softfloat_roundPackToF64( bool sign, int_fast16_t exp, uint_fast64_t sig )
+ softfloat_roundPackToF64( bool sign, int_fast16_t exp, uint_fast64_t sig SOFTFLOAT_STATE_DECL_COMMA )
 {
     uint_fast8_t roundingMode;
@@ -78,5 +78,5 @@
             roundBits = sig & 0x3FF;
             if ( isTiny && roundBits ) {
-                softfloat_raiseFlags( softfloat_flag_underflow );
+                softfloat_raiseFlags( softfloat_flag_underflow SOFTFLOAT_STATE_ARG_COMMA );
             }
         } else if (
@@ -87,5 +87,6 @@
             *----------------------------------------------------------------*/
             softfloat_raiseFlags(
-                softfloat_flag_overflow | softfloat_flag_inexact );
+                softfloat_flag_overflow | softfloat_flag_inexact
+                SOFTFLOAT_STATE_ARG_COMMA );
             uiZ = packToF64UI( sign, 0x7FF, 0 ) - ! roundIncrement;
             goto uiZ;
Index: trunk/src/libs/softfloat-3e/source/s_roundToI32.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/s_roundToI32.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/s_roundToI32.c	(revision 94558)
@@ -44,5 +44,5 @@
 int_fast32_t
  softfloat_roundToI32(
-     bool sign, uint_fast64_t sig, uint_fast8_t roundingMode, bool exact )
+     bool sign, uint_fast64_t sig, uint_fast8_t roundingMode, bool exact SOFTFLOAT_STATE_DECL_COMMA )
 {
     uint_fast16_t roundIncrement, roundBits;
@@ -92,5 +92,5 @@
     *------------------------------------------------------------------------*/
  invalid:
-    softfloat_raiseFlags( softfloat_flag_invalid );
+    softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
     return sign ? i32_fromNegOverflow : i32_fromPosOverflow;
 
Index: trunk/src/libs/softfloat-3e/source/s_roundToI64.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/s_roundToI64.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/s_roundToI64.c	(revision 94558)
@@ -49,4 +49,5 @@
      uint_fast8_t roundingMode,
      bool exact
+     SOFTFLOAT_STATE_DECL_COMMA
  )
 {
@@ -95,5 +96,5 @@
     *------------------------------------------------------------------------*/
  invalid:
-    softfloat_raiseFlags( softfloat_flag_invalid );
+    softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
     return sign ? i64_fromNegOverflow : i64_fromPosOverflow;
 
Index: trunk/src/libs/softfloat-3e/source/s_roundToUI32.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/s_roundToUI32.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/s_roundToUI32.c	(revision 94558)
@@ -44,5 +44,5 @@
 uint_fast32_t
  softfloat_roundToUI32(
-     bool sign, uint_fast64_t sig, uint_fast8_t roundingMode, bool exact )
+     bool sign, uint_fast64_t sig, uint_fast8_t roundingMode, bool exact SOFTFLOAT_STATE_DECL_COMMA)
 {
     uint_fast16_t roundIncrement, roundBits;
@@ -87,5 +87,5 @@
     *------------------------------------------------------------------------*/
  invalid:
-    softfloat_raiseFlags( softfloat_flag_invalid );
+    softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
     return sign ? ui32_fromNegOverflow : ui32_fromPosOverflow;
 
Index: trunk/src/libs/softfloat-3e/source/s_roundToUI64.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/s_roundToUI64.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/s_roundToUI64.c	(revision 94558)
@@ -49,4 +49,5 @@
      uint_fast8_t roundingMode,
      bool exact
+     SOFTFLOAT_STATE_DECL_COMMA
  )
 {
@@ -91,5 +92,5 @@
     *------------------------------------------------------------------------*/
  invalid:
-    softfloat_raiseFlags( softfloat_flag_invalid );
+    softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
     return sign ? ui64_fromNegOverflow : ui64_fromPosOverflow;
 
Index: trunk/src/libs/softfloat-3e/source/s_subMagsExtF80.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/s_subMagsExtF80.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/s_subMagsExtF80.c	(revision 94558)
@@ -49,4 +49,5 @@
      uint_fast64_t uiB0,
      bool signZ
+     SOFTFLOAT_STATE_DECL_COMMA
  )
 {
@@ -78,5 +79,5 @@
             goto propagateNaN;
         }
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
         uiZ64 = defaultNaNExtF80UI64;
         uiZ0  = defaultNaNExtF80UI0;
@@ -143,9 +144,9 @@
     return
         softfloat_normRoundPackToExtF80(
-            signZ, expZ, sig128.v64, sig128.v0, extF80_roundingPrecision );
+            signZ, expZ, sig128.v64, sig128.v0, extF80_roundingPrecision SOFTFLOAT_STATE_ARG_COMMA );
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  propagateNaN:
-    uiZ = softfloat_propagateNaNExtF80UI( uiA64, uiA0, uiB64, uiB0 );
+    uiZ = softfloat_propagateNaNExtF80UI( uiA64, uiA0, uiB64, uiB0 SOFTFLOAT_STATE_ARG_COMMA );
     uiZ64 = uiZ.v64;
     uiZ0  = uiZ.v0;
Index: trunk/src/libs/softfloat-3e/source/s_subMagsF128.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/s_subMagsF128.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/s_subMagsF128.c	(revision 94558)
@@ -49,4 +49,5 @@
      uint_fast64_t uiB0,
      bool signZ
+     SOFTFLOAT_STATE_DECL_COMMA
  )
 {
@@ -72,5 +73,5 @@
     if ( expA == 0x7FFF ) {
         if ( sigA.v64 | sigA.v0 | sigB.v64 | sigB.v0 ) goto propagateNaN;
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
         uiZ.v64 = defaultNaNF128UI64;
         uiZ.v0  = defaultNaNF128UI0;
@@ -129,7 +130,7 @@
     sigZ = softfloat_sub128( sigA.v64, sigA.v0, sigB.v64, sigB.v0 );
  normRoundPack:
-    return softfloat_normRoundPackToF128( signZ, expZ - 5, sigZ.v64, sigZ.v0 );
+    return softfloat_normRoundPackToF128( signZ, expZ - 5, sigZ.v64, sigZ.v0 SOFTFLOAT_STATE_ARG_COMMA );
  propagateNaN:
-    uiZ = softfloat_propagateNaNF128UI( uiA64, uiA0, uiB64, uiB0 );
+    uiZ = softfloat_propagateNaNF128UI( uiA64, uiA0, uiB64, uiB0 SOFTFLOAT_STATE_ARG_COMMA );
  uiZ:
     uZ.ui = uiZ;
Index: trunk/src/libs/softfloat-3e/source/s_subMagsF16.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/s_subMagsF16.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/s_subMagsF16.c	(revision 94558)
@@ -42,5 +42,5 @@
 #include "softfloat.h"
 
-float16_t softfloat_subMagsF16( uint_fast16_t uiA, uint_fast16_t uiB )
+float16_t softfloat_subMagsF16( uint_fast16_t uiA, uint_fast16_t uiB SOFTFLOAT_STATE_DECL_COMMA )
 {
     int_fast8_t expA;
@@ -72,5 +72,5 @@
         if ( expA == 0x1F ) {
             if ( sigA | sigB ) goto propagateNaN;
-            softfloat_raiseFlags( softfloat_flag_invalid );
+            softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
             uiZ = defaultNaNF16UI;
             goto uiZ;
@@ -148,10 +148,10 @@
             }
         }
-        return softfloat_roundPackToF16( signZ, expZ, sigZ );
+        return softfloat_roundPackToF16( signZ, expZ, sigZ SOFTFLOAT_STATE_ARG_COMMA );
     }
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  propagateNaN:
-    uiZ = softfloat_propagateNaNF16UI( uiA, uiB );
+    uiZ = softfloat_propagateNaNF16UI( uiA, uiB SOFTFLOAT_STATE_ARG_COMMA );
     goto uiZ;
     /*------------------------------------------------------------------------
Index: trunk/src/libs/softfloat-3e/source/s_subMagsF32.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/s_subMagsF32.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/s_subMagsF32.c	(revision 94558)
@@ -42,5 +42,5 @@
 #include "softfloat.h"
 
-float32_t softfloat_subMagsF32( uint_fast32_t uiA, uint_fast32_t uiB )
+float32_t softfloat_subMagsF32( uint_fast32_t uiA, uint_fast32_t uiB SOFTFLOAT_STATE_DECL_COMMA )
 {
     int_fast16_t expA;
@@ -71,5 +71,5 @@
         if ( expA == 0xFF ) {
             if ( sigA | sigB ) goto propagateNaN;
-            softfloat_raiseFlags( softfloat_flag_invalid );
+            softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
             uiZ = defaultNaNF32UI;
             goto uiZ;
@@ -129,5 +129,5 @@
         return
             softfloat_normRoundPackToF32(
-                signZ, expZ, sigX - softfloat_shiftRightJam32( sigY, expDiff )
+                signZ, expZ, sigX - softfloat_shiftRightJam32( sigY, expDiff ) SOFTFLOAT_STATE_ARG_COMMA
             );
     }
@@ -135,5 +135,5 @@
     *------------------------------------------------------------------------*/
  propagateNaN:
-    uiZ = softfloat_propagateNaNF32UI( uiA, uiB );
+    uiZ = softfloat_propagateNaNF32UI( uiA, uiB SOFTFLOAT_STATE_ARG_COMMA );
  uiZ:
     uZ.ui = uiZ;
Index: trunk/src/libs/softfloat-3e/source/s_subMagsF64.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/s_subMagsF64.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/s_subMagsF64.c	(revision 94558)
@@ -43,5 +43,5 @@
 
 float64_t
- softfloat_subMagsF64( uint_fast64_t uiA, uint_fast64_t uiB, bool signZ )
+ softfloat_subMagsF64( uint_fast64_t uiA, uint_fast64_t uiB, bool signZ SOFTFLOAT_STATE_DECL_COMMA )
 {
     int_fast16_t expA;
@@ -71,5 +71,5 @@
         if ( expA == 0x7FF ) {
             if ( sigA | sigB ) goto propagateNaN;
-            softfloat_raiseFlags( softfloat_flag_invalid );
+            softfloat_raiseFlags( softfloat_flag_invalid SOFTFLOAT_STATE_ARG_COMMA );
             uiZ = defaultNaNF64UI;
             goto uiZ;
@@ -128,10 +128,10 @@
             sigZ = sigA - sigB;
         }
-        return softfloat_normRoundPackToF64( signZ, expZ - 1, sigZ );
+        return softfloat_normRoundPackToF64( signZ, expZ - 1, sigZ SOFTFLOAT_STATE_ARG_COMMA );
     }
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  propagateNaN:
-    uiZ = softfloat_propagateNaNF64UI( uiA, uiB );
+    uiZ = softfloat_propagateNaNF64UI( uiA, uiB SOFTFLOAT_STATE_ARG_COMMA );
  uiZ:
     uZ.ui = uiZ;
Index: trunk/src/libs/softfloat-3e/source/s_tryPropagateNaNExtF80M.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/s_tryPropagateNaNExtF80M.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/s_tryPropagateNaNExtF80M.c	(revision 94558)
@@ -45,4 +45,5 @@
      const struct extFloat80M *bSPtr,
      struct extFloat80M *zSPtr
+     SOFTFLOAT_STATE_DECL_COMMA
  )
 {
@@ -58,5 +59,5 @@
     return false;
  propagateNaN:
-    softfloat_propagateNaNExtF80M( aSPtr, bSPtr, zSPtr );
+    softfloat_propagateNaNExtF80M( aSPtr, bSPtr, zSPtr SOFTFLOAT_STATE_ARG_COMMA );
     return true;
 
Index: trunk/src/libs/softfloat-3e/source/s_tryPropagateNaNF128M.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/s_tryPropagateNaNF128M.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/s_tryPropagateNaNF128M.c	(revision 94558)
@@ -43,9 +43,9 @@
 bool
  softfloat_tryPropagateNaNF128M(
-     const uint32_t *aWPtr, const uint32_t *bWPtr, uint32_t *zWPtr )
+     const uint32_t *aWPtr, const uint32_t *bWPtr, uint32_t *zWPtr SOFTFLOAT_STATE_DECL_COMMA )
 {
 
     if ( softfloat_isNaNF128M( aWPtr ) || softfloat_isNaNF128M( bWPtr ) ) {
-        softfloat_propagateNaNF128M( aWPtr, bWPtr, zWPtr );
+        softfloat_propagateNaNF128M( aWPtr, bWPtr, zWPtr SOFTFLOAT_STATE_ARG_COMMA );
         return true;
     }
Index: trunk/src/libs/softfloat-3e/source/softfloat_state.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/softfloat_state.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/softfloat_state.c	(revision 94558)
@@ -45,4 +45,5 @@
 #endif
 
+#ifndef VBOX_WITHOUT_SOFTFLOAT_GLOBALS
 THREAD_LOCAL uint_fast8_t softfloat_roundingMode = softfloat_round_near_even;
 THREAD_LOCAL uint_fast8_t softfloat_detectTininess = init_detectTininess;
@@ -50,3 +51,3 @@
 
 THREAD_LOCAL uint_fast8_t extF80_roundingPrecision = 80;
-
+#endif
Index: trunk/src/libs/softfloat-3e/source/ui32_to_extF80.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/ui32_to_extF80.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/ui32_to_extF80.c	(revision 94558)
@@ -40,9 +40,10 @@
 #include "softfloat.h"
 
-extFloat80_t ui32_to_extF80( uint32_t a )
+extFloat80_t ui32_to_extF80( uint32_t a SOFTFLOAT_STATE_DECL_COMMA )
 {
     uint_fast16_t uiZ64;
     int_fast8_t shiftDist;
     union { struct extFloat80M s; extFloat80_t f; } uZ;
+    SOFTFLOAT_STATE_NOREF();
 
     uiZ64 = 0;
Index: trunk/src/libs/softfloat-3e/source/ui32_to_extF80M.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/ui32_to_extF80M.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/ui32_to_extF80M.c	(revision 94558)
@@ -42,8 +42,8 @@
 #ifdef SOFTFLOAT_FAST_INT64
 
-void ui32_to_extF80M( uint32_t a, extFloat80_t *zPtr )
+void ui32_to_extF80M( uint32_t a, extFloat80_t *zPtr SOFTFLOAT_STATE_DECL_COMMA )
 {
 
-    *zPtr = ui32_to_extF80( a );
+    *zPtr = ui32_to_extF80( a SOFTFLOAT_STATE_ARG_COMMA );
 
 }
@@ -51,5 +51,5 @@
 #else
 
-void ui32_to_extF80M( uint32_t a, extFloat80_t *zPtr )
+void ui32_to_extF80M( uint32_t a, extFloat80_t *zPtr SOFTFLOAT_STATE_DECL_COMMA )
 {
     struct extFloat80M *zSPtr;
@@ -57,4 +57,5 @@
     uint64_t sigZ;
     int_fast8_t shiftDist;
+    SOFTFLOAT_STATE_NOREF();
 
     zSPtr = (struct extFloat80M *) zPtr;
Index: trunk/src/libs/softfloat-3e/source/ui32_to_f128.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/ui32_to_f128.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/ui32_to_f128.c	(revision 94558)
@@ -40,9 +40,10 @@
 #include "softfloat.h"
 
-float128_t ui32_to_f128( uint32_t a )
+float128_t ui32_to_f128( uint32_t a SOFTFLOAT_STATE_DECL_COMMA )
 {
     uint_fast64_t uiZ64;
     int_fast8_t shiftDist;
     union ui128_f128 uZ;
+    SOFTFLOAT_STATE_NOREF();
 
     uiZ64 = 0;
Index: trunk/src/libs/softfloat-3e/source/ui32_to_f128M.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/ui32_to_f128M.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/ui32_to_f128M.c	(revision 94558)
@@ -42,8 +42,8 @@
 #ifdef SOFTFLOAT_FAST_INT64
 
-void ui32_to_f128M( uint32_t a, float128_t *zPtr )
+void ui32_to_f128M( uint32_t a, float128_t *zPtr SOFTFLOAT_STATE_DECL_COMMA )
 {
 
-    *zPtr = ui32_to_f128( a );
+    *zPtr = ui32_to_f128( a SOFTFLOAT_STATE_ARG_COMMA );
 
 }
@@ -51,9 +51,10 @@
 #else
 
-void ui32_to_f128M( uint32_t a, float128_t *zPtr )
+void ui32_to_f128M( uint32_t a, float128_t *zPtr SOFTFLOAT_STATE_DECL_COMMA )
 {
     uint32_t *zWPtr, uiZ96, uiZ64;
     int_fast8_t shiftDist;
     uint64_t normA;
+    SOFTFLOAT_STATE_NOREF();
 
     zWPtr = (uint32_t *) zPtr;
Index: trunk/src/libs/softfloat-3e/source/ui32_to_f16.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/ui32_to_f16.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/ui32_to_f16.c	(revision 94558)
@@ -40,5 +40,5 @@
 #include "softfloat.h"
 
-float16_t ui32_to_f16( uint32_t a )
+float16_t ui32_to_f16( uint32_t a SOFTFLOAT_STATE_DECL_COMMA )
 {
     int_fast8_t shiftDist;
@@ -59,5 +59,5 @@
                 ? a>>(-shiftDist) | ((uint32_t) (a<<(shiftDist & 31)) != 0)
                 : (uint_fast16_t) a<<shiftDist;
-        return softfloat_roundPackToF16( 0, 0x1C - shiftDist, sig );
+        return softfloat_roundPackToF16( 0, 0x1C - shiftDist, sig SOFTFLOAT_STATE_ARG_COMMA );
     }
 
Index: trunk/src/libs/softfloat-3e/source/ui32_to_f32.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/ui32_to_f32.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/ui32_to_f32.c	(revision 94558)
@@ -40,5 +40,5 @@
 #include "softfloat.h"
 
-float32_t ui32_to_f32( uint32_t a )
+float32_t ui32_to_f32( uint32_t a SOFTFLOAT_STATE_DECL_COMMA )
 {
     union ui32_f32 uZ;
@@ -49,7 +49,7 @@
     }
     if ( a & 0x80000000 ) {
-        return softfloat_roundPackToF32( 0, 0x9D, a>>1 | (a & 1) );
+        return softfloat_roundPackToF32( 0, 0x9D, a>>1 | (a & 1) SOFTFLOAT_STATE_ARG_COMMA );
     } else {
-        return softfloat_normRoundPackToF32( 0, 0x9C, a );
+        return softfloat_normRoundPackToF32( 0, 0x9C, a SOFTFLOAT_STATE_ARG_COMMA );
     }
 
Index: trunk/src/libs/softfloat-3e/source/ui32_to_f64.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/ui32_to_f64.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/ui32_to_f64.c	(revision 94558)
@@ -40,9 +40,10 @@
 #include "softfloat.h"
 
-float64_t ui32_to_f64( uint32_t a )
+float64_t ui32_to_f64( uint32_t a SOFTFLOAT_STATE_DECL_COMMA )
 {
     uint_fast64_t uiZ;
     int_fast8_t shiftDist;
     union ui64_f64 uZ;
+    SOFTFLOAT_STATE_NOREF();
 
     if ( ! a ) {
Index: trunk/src/libs/softfloat-3e/source/ui64_to_extF80.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/ui64_to_extF80.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/ui64_to_extF80.c	(revision 94558)
@@ -40,9 +40,10 @@
 #include "softfloat.h"
 
-extFloat80_t ui64_to_extF80( uint64_t a )
+extFloat80_t ui64_to_extF80( uint64_t a SOFTFLOAT_STATE_DECL_COMMA )
 {
     uint_fast16_t uiZ64;
     int_fast8_t shiftDist;
     union { struct extFloat80M s; extFloat80_t f; } uZ;
+    SOFTFLOAT_STATE_NOREF();
 
     uiZ64 = 0;
Index: trunk/src/libs/softfloat-3e/source/ui64_to_extF80M.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/ui64_to_extF80M.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/ui64_to_extF80M.c	(revision 94558)
@@ -42,8 +42,8 @@
 #ifdef SOFTFLOAT_FAST_INT64
 
-void ui64_to_extF80M( uint64_t a, extFloat80_t *zPtr )
+void ui64_to_extF80M( uint64_t a, extFloat80_t *zPtr SOFTFLOAT_STATE_DECL_COMMA )
 {
 
-    *zPtr = ui64_to_extF80( a );
+    *zPtr = ui64_to_extF80( a SOFTFLOAT_STATE_ARG_COMMA );
 
 }
@@ -51,5 +51,5 @@
 #else
 
-void ui64_to_extF80M( uint64_t a, extFloat80_t *zPtr )
+void ui64_to_extF80M( uint64_t a, extFloat80_t *zPtr SOFTFLOAT_STATE_DECL_COMMA )
 {
     struct extFloat80M *zSPtr;
@@ -57,4 +57,5 @@
     uint64_t sigZ;
     int_fast8_t shiftDist;
+    SOFTFLOAT_STATE_NOREF();
 
     zSPtr = (struct extFloat80M *) zPtr;
Index: trunk/src/libs/softfloat-3e/source/ui64_to_f128.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/ui64_to_f128.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/ui64_to_f128.c	(revision 94558)
@@ -40,5 +40,5 @@
 #include "softfloat.h"
 
-float128_t ui64_to_f128( uint64_t a )
+float128_t ui64_to_f128( uint64_t a SOFTFLOAT_STATE_DECL_COMMA )
 {
     uint_fast64_t uiZ64, uiZ0;
@@ -46,4 +46,5 @@
     struct uint128 zSig;
     union ui128_f128 uZ;
+    SOFTFLOAT_STATE_NOREF();
 
     if ( ! a ) {
Index: trunk/src/libs/softfloat-3e/source/ui64_to_f128M.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/ui64_to_f128M.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/ui64_to_f128M.c	(revision 94558)
@@ -42,8 +42,8 @@
 #ifdef SOFTFLOAT_FAST_INT64
 
-void ui64_to_f128M( uint64_t a, float128_t *zPtr )
+void ui64_to_f128M( uint64_t a, float128_t *zPtr SOFTFLOAT_STATE_DECL_COMMA )
 {
 
-    *zPtr = ui64_to_f128( a );
+    *zPtr = ui64_to_f128( a SOFTFLOAT_STATE_ARG_COMMA );
 
 }
@@ -51,9 +51,10 @@
 #else
 
-void ui64_to_f128M( uint64_t a, float128_t *zPtr )
+void ui64_to_f128M( uint64_t a, float128_t *zPtr SOFTFLOAT_STATE_DECL_COMMA )
 {
     uint32_t *zWPtr, uiZ96, uiZ64;
     uint_fast8_t shiftDist;
     uint32_t *ptr;
+    SOFTFLOAT_STATE_NOREF();
 
     zWPtr = (uint32_t *) zPtr;
Index: trunk/src/libs/softfloat-3e/source/ui64_to_f16.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/ui64_to_f16.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/ui64_to_f16.c	(revision 94558)
@@ -40,5 +40,5 @@
 #include "softfloat.h"
 
-float16_t ui64_to_f16( uint64_t a )
+float16_t ui64_to_f16( uint64_t a SOFTFLOAT_STATE_DECL_COMMA )
 {
     int_fast8_t shiftDist;
@@ -58,5 +58,5 @@
             (shiftDist < 0) ? softfloat_shortShiftRightJam64( a, -shiftDist )
                 : (uint_fast16_t) a<<shiftDist;
-        return softfloat_roundPackToF16( 0, 0x1C - shiftDist, sig );
+        return softfloat_roundPackToF16( 0, 0x1C - shiftDist, sig SOFTFLOAT_STATE_ARG_COMMA );
     }
 
Index: trunk/src/libs/softfloat-3e/source/ui64_to_f32.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/ui64_to_f32.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/ui64_to_f32.c	(revision 94558)
@@ -40,5 +40,5 @@
 #include "softfloat.h"
 
-float32_t ui64_to_f32( uint64_t a )
+float32_t ui64_to_f32( uint64_t a SOFTFLOAT_STATE_DECL_COMMA )
 {
     int_fast8_t shiftDist;
@@ -58,5 +58,5 @@
             (shiftDist < 0) ? softfloat_shortShiftRightJam64( a, -shiftDist )
                 : (uint_fast32_t) a<<shiftDist;
-        return softfloat_roundPackToF32( 0, 0x9C - shiftDist, sig );
+        return softfloat_roundPackToF32( 0, 0x9C - shiftDist, sig SOFTFLOAT_STATE_ARG_COMMA );
     }
 
Index: trunk/src/libs/softfloat-3e/source/ui64_to_f64.c
===================================================================
--- trunk/src/libs/softfloat-3e/source/ui64_to_f64.c	(revision 94552)
+++ trunk/src/libs/softfloat-3e/source/ui64_to_f64.c	(revision 94558)
@@ -40,5 +40,5 @@
 #include "softfloat.h"
 
-float64_t ui64_to_f64( uint64_t a )
+float64_t ui64_to_f64( uint64_t a SOFTFLOAT_STATE_DECL_COMMA )
 {
     union ui64_f64 uZ;
@@ -51,7 +51,7 @@
         return
             softfloat_roundPackToF64(
-                0, 0x43D, softfloat_shortShiftRightJam64( a, 1 ) );
+                0, 0x43D, softfloat_shortShiftRightJam64( a, 1 ) SOFTFLOAT_STATE_ARG_COMMA );
     } else {
-        return softfloat_normRoundPackToF64( 0, 0x43C, a );
+        return softfloat_normRoundPackToF64( 0, 0x43C, a SOFTFLOAT_STATE_ARG_COMMA );
     }
 
