[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

[Commits] r24274 - in /fsf/trunk/libc: ./ soft-fp/



Author: eglibc
Date: Thu Oct 17 00:01:48 2013
New Revision: 24274

Log:
Import glibc-mainline for 2013-10-17

Modified:
    fsf/trunk/libc/ChangeLog
    fsf/trunk/libc/soft-fp/adddf3.c
    fsf/trunk/libc/soft-fp/addsf3.c
    fsf/trunk/libc/soft-fp/addtf3.c
    fsf/trunk/libc/soft-fp/divdf3.c
    fsf/trunk/libc/soft-fp/divsf3.c
    fsf/trunk/libc/soft-fp/divtf3.c
    fsf/trunk/libc/soft-fp/double.h
    fsf/trunk/libc/soft-fp/eqdf2.c
    fsf/trunk/libc/soft-fp/eqsf2.c
    fsf/trunk/libc/soft-fp/eqtf2.c
    fsf/trunk/libc/soft-fp/extenddftf2.c
    fsf/trunk/libc/soft-fp/extended.h
    fsf/trunk/libc/soft-fp/extendsfdf2.c
    fsf/trunk/libc/soft-fp/extendsftf2.c
    fsf/trunk/libc/soft-fp/extendxftf2.c
    fsf/trunk/libc/soft-fp/fixdfdi.c
    fsf/trunk/libc/soft-fp/fixdfsi.c
    fsf/trunk/libc/soft-fp/fixdfti.c
    fsf/trunk/libc/soft-fp/fixsfdi.c
    fsf/trunk/libc/soft-fp/fixsfsi.c
    fsf/trunk/libc/soft-fp/fixsfti.c
    fsf/trunk/libc/soft-fp/fixtfdi.c
    fsf/trunk/libc/soft-fp/fixtfsi.c
    fsf/trunk/libc/soft-fp/fixtfti.c
    fsf/trunk/libc/soft-fp/fixunsdfdi.c
    fsf/trunk/libc/soft-fp/fixunsdfsi.c
    fsf/trunk/libc/soft-fp/fixunsdfti.c
    fsf/trunk/libc/soft-fp/fixunssfdi.c
    fsf/trunk/libc/soft-fp/fixunssfsi.c
    fsf/trunk/libc/soft-fp/fixunssfti.c
    fsf/trunk/libc/soft-fp/fixunstfdi.c
    fsf/trunk/libc/soft-fp/fixunstfsi.c
    fsf/trunk/libc/soft-fp/fixunstfti.c
    fsf/trunk/libc/soft-fp/floatdidf.c
    fsf/trunk/libc/soft-fp/floatdisf.c
    fsf/trunk/libc/soft-fp/floatditf.c
    fsf/trunk/libc/soft-fp/floatsidf.c
    fsf/trunk/libc/soft-fp/floatsisf.c
    fsf/trunk/libc/soft-fp/floatsitf.c
    fsf/trunk/libc/soft-fp/floattidf.c
    fsf/trunk/libc/soft-fp/floattisf.c
    fsf/trunk/libc/soft-fp/floattitf.c
    fsf/trunk/libc/soft-fp/floatundidf.c
    fsf/trunk/libc/soft-fp/floatundisf.c
    fsf/trunk/libc/soft-fp/floatunditf.c
    fsf/trunk/libc/soft-fp/floatunsidf.c
    fsf/trunk/libc/soft-fp/floatunsisf.c
    fsf/trunk/libc/soft-fp/floatunsitf.c
    fsf/trunk/libc/soft-fp/floatuntidf.c
    fsf/trunk/libc/soft-fp/floatuntisf.c
    fsf/trunk/libc/soft-fp/floatuntitf.c
    fsf/trunk/libc/soft-fp/fmadf4.c
    fsf/trunk/libc/soft-fp/fmasf4.c
    fsf/trunk/libc/soft-fp/fmatf4.c
    fsf/trunk/libc/soft-fp/gedf2.c
    fsf/trunk/libc/soft-fp/gesf2.c
    fsf/trunk/libc/soft-fp/getf2.c
    fsf/trunk/libc/soft-fp/ledf2.c
    fsf/trunk/libc/soft-fp/lesf2.c
    fsf/trunk/libc/soft-fp/letf2.c
    fsf/trunk/libc/soft-fp/muldf3.c
    fsf/trunk/libc/soft-fp/mulsf3.c
    fsf/trunk/libc/soft-fp/multf3.c
    fsf/trunk/libc/soft-fp/negdf2.c
    fsf/trunk/libc/soft-fp/negsf2.c
    fsf/trunk/libc/soft-fp/negtf2.c
    fsf/trunk/libc/soft-fp/op-1.h
    fsf/trunk/libc/soft-fp/op-2.h
    fsf/trunk/libc/soft-fp/op-4.h
    fsf/trunk/libc/soft-fp/op-8.h
    fsf/trunk/libc/soft-fp/op-common.h
    fsf/trunk/libc/soft-fp/quad.h
    fsf/trunk/libc/soft-fp/single.h
    fsf/trunk/libc/soft-fp/soft-fp.h
    fsf/trunk/libc/soft-fp/sqrtdf2.c
    fsf/trunk/libc/soft-fp/sqrtsf2.c
    fsf/trunk/libc/soft-fp/sqrttf2.c
    fsf/trunk/libc/soft-fp/subdf3.c
    fsf/trunk/libc/soft-fp/subsf3.c
    fsf/trunk/libc/soft-fp/subtf3.c
    fsf/trunk/libc/soft-fp/truncdfsf2.c
    fsf/trunk/libc/soft-fp/trunctfdf2.c
    fsf/trunk/libc/soft-fp/trunctfsf2.c
    fsf/trunk/libc/soft-fp/trunctfxf2.c
    fsf/trunk/libc/soft-fp/unorddf2.c
    fsf/trunk/libc/soft-fp/unordsf2.c
    fsf/trunk/libc/soft-fp/unordtf2.c

Modified: fsf/trunk/libc/ChangeLog
==============================================================================
--- fsf/trunk/libc/ChangeLog (original)
+++ fsf/trunk/libc/ChangeLog Thu Oct 17 00:01:48 2013
@@ -1,3 +1,93 @@
+2013-10-16  Joseph Myers  <joseph@xxxxxxxxxxxxxxxx>
+
+	* soft-fp/adddf3.c: Fix horizontal whitespace.
+	* soft-fp/addsf3.c: Likewise.
+	* soft-fp/addtf3.c: Likewise.
+	* soft-fp/divdf3.c: Likewise.
+	* soft-fp/divsf3.c: Likewise.
+	* soft-fp/divtf3.c: Likewise.
+	* soft-fp/double.h: Likewise.
+	* soft-fp/eqdf2.c: Likewise.
+	* soft-fp/eqsf2.c: Likewise.
+	* soft-fp/eqtf2.c: Likewise.
+	* soft-fp/extenddftf2.c: Likewise.
+	* soft-fp/extended.h: Likewise.
+	* soft-fp/extendsfdf2.c: Likewise.
+	* soft-fp/extendsftf2.c: Likewise.
+	* soft-fp/extendxftf2.c: Likewise.
+	* soft-fp/fixdfdi.c: Likewise.
+	* soft-fp/fixdfsi.c: Likewise.
+	* soft-fp/fixdfti.c: Likewise.
+	* soft-fp/fixsfdi.c: Likewise.
+	* soft-fp/fixsfsi.c: Likewise.
+	* soft-fp/fixsfti.c: Likewise.
+	* soft-fp/fixtfdi.c: Likewise.
+	* soft-fp/fixtfsi.c: Likewise.
+	* soft-fp/fixtfti.c: Likewise.
+	* soft-fp/fixunsdfdi.c: Likewise.
+	* soft-fp/fixunsdfsi.c: Likewise.
+	* soft-fp/fixunsdfti.c: Likewise.
+	* soft-fp/fixunssfdi.c: Likewise.
+	* soft-fp/fixunssfsi.c: Likewise.
+	* soft-fp/fixunssfti.c: Likewise.
+	* soft-fp/fixunstfdi.c: Likewise.
+	* soft-fp/fixunstfsi.c: Likewise.
+	* soft-fp/fixunstfti.c: Likewise.
+	* soft-fp/floatdidf.c: Likewise.
+	* soft-fp/floatdisf.c: Likewise.
+	* soft-fp/floatditf.c: Likewise.
+	* soft-fp/floatsidf.c: Likewise.
+	* soft-fp/floatsisf.c: Likewise.
+	* soft-fp/floatsitf.c: Likewise.
+	* soft-fp/floattidf.c: Likewise.
+	* soft-fp/floattisf.c: Likewise.
+	* soft-fp/floattitf.c: Likewise.
+	* soft-fp/floatundidf.c: Likewise.
+	* soft-fp/floatundisf.c: Likewise.
+	* soft-fp/floatunditf.c: Likewise.
+	* soft-fp/floatunsidf.c: Likewise.
+	* soft-fp/floatunsisf.c: Likewise.
+	* soft-fp/floatunsitf.c: Likewise.
+	* soft-fp/floatuntidf.c: Likewise.
+	* soft-fp/floatuntisf.c: Likewise.
+	* soft-fp/floatuntitf.c: Likewise.
+	* soft-fp/fmadf4.c: Likewise.
+	* soft-fp/fmasf4.c: Likewise.
+	* soft-fp/fmatf4.c: Likewise.
+	* soft-fp/gedf2.c: Likewise.
+	* soft-fp/gesf2.c: Likewise.
+	* soft-fp/getf2.c: Likewise.
+	* soft-fp/ledf2.c: Likewise.
+	* soft-fp/lesf2.c: Likewise.
+	* soft-fp/letf2.c: Likewise.
+	* soft-fp/muldf3.c: Likewise.
+	* soft-fp/mulsf3.c: Likewise.
+	* soft-fp/multf3.c: Likewise.
+	* soft-fp/negdf2.c: Likewise.
+	* soft-fp/negsf2.c: Likewise.
+	* soft-fp/negtf2.c: Likewise.
+	* soft-fp/op-1.h: Likewise.
+	* soft-fp/op-2.h: Likewise.
+	* soft-fp/op-4.h: Likewise.
+	* soft-fp/op-8.h: Likewise.
+	* soft-fp/op-common.h: Likewise.
+	* soft-fp/quad.h: Likewise.
+	* soft-fp/single.h: Likewise.
+	* soft-fp/soft-fp.h: Likewise.
+	* soft-fp/sqrtdf2.c: Likewise.
+	* soft-fp/sqrtsf2.c: Likewise.
+	* soft-fp/sqrttf2.c: Likewise.
+	* soft-fp/subdf3.c: Likewise.
+	* soft-fp/subsf3.c: Likewise.
+	* soft-fp/subtf3.c: Likewise.
+	* soft-fp/truncdfsf2.c: Likewise.
+	* soft-fp/trunctfdf2.c: Likewise.
+	* soft-fp/trunctfsf2.c: Likewise.
+	* soft-fp/trunctfxf2.c: Likewise.
+	* soft-fp/unorddf2.c: Likewise.
+	* soft-fp/unordsf2.c: Likewise.
+	* soft-fp/unordtf2.c: Likewise.
+
 2013-10-15  Joseph Myers  <joseph@xxxxxxxxxxxxxxxx>
 
 	* soft-fp/op-2.h (_FP_DIV_MEAT_2_gmp): Remove macro.

Modified: fsf/trunk/libc/soft-fp/adddf3.c
==============================================================================
--- fsf/trunk/libc/soft-fp/adddf3.c (original)
+++ fsf/trunk/libc/soft-fp/adddf3.c Thu Oct 17 00:01:48 2013
@@ -32,19 +32,19 @@
 #include "double.h"
 
 DFtype
-__adddf3(DFtype a, DFtype b)
+__adddf3 (DFtype a, DFtype b)
 {
   FP_DECL_EX;
-  FP_DECL_D(A);
-  FP_DECL_D(B);
-  FP_DECL_D(R);
+  FP_DECL_D (A);
+  FP_DECL_D (B);
+  FP_DECL_D (R);
   DFtype r;
 
   FP_INIT_ROUNDMODE;
-  FP_UNPACK_SEMIRAW_D(A, a);
-  FP_UNPACK_SEMIRAW_D(B, b);
-  FP_ADD_D(R, A, B);
-  FP_PACK_SEMIRAW_D(r, R);
+  FP_UNPACK_SEMIRAW_D (A, a);
+  FP_UNPACK_SEMIRAW_D (B, b);
+  FP_ADD_D (R, A, B);
+  FP_PACK_SEMIRAW_D (r, R);
   FP_HANDLE_EXCEPTIONS;
 
   return r;

Modified: fsf/trunk/libc/soft-fp/addsf3.c
==============================================================================
--- fsf/trunk/libc/soft-fp/addsf3.c (original)
+++ fsf/trunk/libc/soft-fp/addsf3.c Thu Oct 17 00:01:48 2013
@@ -32,19 +32,19 @@
 #include "single.h"
 
 SFtype
-__addsf3(SFtype a, SFtype b)
+__addsf3 (SFtype a, SFtype b)
 {
   FP_DECL_EX;
-  FP_DECL_S(A);
-  FP_DECL_S(B);
-  FP_DECL_S(R);
+  FP_DECL_S (A);
+  FP_DECL_S (B);
+  FP_DECL_S (R);
   SFtype r;
 
   FP_INIT_ROUNDMODE;
-  FP_UNPACK_SEMIRAW_S(A, a);
-  FP_UNPACK_SEMIRAW_S(B, b);
-  FP_ADD_S(R, A, B);
-  FP_PACK_SEMIRAW_S(r, R);
+  FP_UNPACK_SEMIRAW_S (A, a);
+  FP_UNPACK_SEMIRAW_S (B, b);
+  FP_ADD_S (R, A, B);
+  FP_PACK_SEMIRAW_S (r, R);
   FP_HANDLE_EXCEPTIONS;
 
   return r;

Modified: fsf/trunk/libc/soft-fp/addtf3.c
==============================================================================
--- fsf/trunk/libc/soft-fp/addtf3.c (original)
+++ fsf/trunk/libc/soft-fp/addtf3.c Thu Oct 17 00:01:48 2013
@@ -32,19 +32,19 @@
 #include "quad.h"
 
 TFtype
-__addtf3(TFtype a, TFtype b)
+__addtf3 (TFtype a, TFtype b)
 {
   FP_DECL_EX;
-  FP_DECL_Q(A);
-  FP_DECL_Q(B);
-  FP_DECL_Q(R);
+  FP_DECL_Q (A);
+  FP_DECL_Q (B);
+  FP_DECL_Q (R);
   TFtype r;
 
   FP_INIT_ROUNDMODE;
-  FP_UNPACK_SEMIRAW_Q(A, a);
-  FP_UNPACK_SEMIRAW_Q(B, b);
-  FP_ADD_Q(R, A, B);
-  FP_PACK_SEMIRAW_Q(r, R);
+  FP_UNPACK_SEMIRAW_Q (A, a);
+  FP_UNPACK_SEMIRAW_Q (B, b);
+  FP_ADD_Q (R, A, B);
+  FP_PACK_SEMIRAW_Q (r, R);
   FP_HANDLE_EXCEPTIONS;
 
   return r;

Modified: fsf/trunk/libc/soft-fp/divdf3.c
==============================================================================
--- fsf/trunk/libc/soft-fp/divdf3.c (original)
+++ fsf/trunk/libc/soft-fp/divdf3.c Thu Oct 17 00:01:48 2013
@@ -32,19 +32,19 @@
 #include "double.h"
 
 DFtype
-__divdf3(DFtype a, DFtype b)
+__divdf3 (DFtype a, DFtype b)
 {
   FP_DECL_EX;
-  FP_DECL_D(A);
-  FP_DECL_D(B);
-  FP_DECL_D(R);
+  FP_DECL_D (A);
+  FP_DECL_D (B);
+  FP_DECL_D (R);
   DFtype r;
 
   FP_INIT_ROUNDMODE;
-  FP_UNPACK_D(A, a);
-  FP_UNPACK_D(B, b);
-  FP_DIV_D(R, A, B);
-  FP_PACK_D(r, R);
+  FP_UNPACK_D (A, a);
+  FP_UNPACK_D (B, b);
+  FP_DIV_D (R, A, B);
+  FP_PACK_D (r, R);
   FP_HANDLE_EXCEPTIONS;
 
   return r;

Modified: fsf/trunk/libc/soft-fp/divsf3.c
==============================================================================
--- fsf/trunk/libc/soft-fp/divsf3.c (original)
+++ fsf/trunk/libc/soft-fp/divsf3.c Thu Oct 17 00:01:48 2013
@@ -32,19 +32,19 @@
 #include "single.h"
 
 SFtype
-__divsf3(SFtype a, SFtype b)
+__divsf3 (SFtype a, SFtype b)
 {
   FP_DECL_EX;
-  FP_DECL_S(A);
-  FP_DECL_S(B);
-  FP_DECL_S(R);
+  FP_DECL_S (A);
+  FP_DECL_S (B);
+  FP_DECL_S (R);
   SFtype r;
 
   FP_INIT_ROUNDMODE;
-  FP_UNPACK_S(A, a);
-  FP_UNPACK_S(B, b);
-  FP_DIV_S(R, A, B);
-  FP_PACK_S(r, R);
+  FP_UNPACK_S (A, a);
+  FP_UNPACK_S (B, b);
+  FP_DIV_S (R, A, B);
+  FP_PACK_S (r, R);
   FP_HANDLE_EXCEPTIONS;
 
   return r;

Modified: fsf/trunk/libc/soft-fp/divtf3.c
==============================================================================
--- fsf/trunk/libc/soft-fp/divtf3.c (original)
+++ fsf/trunk/libc/soft-fp/divtf3.c Thu Oct 17 00:01:48 2013
@@ -32,19 +32,19 @@
 #include "quad.h"
 
 TFtype
-__divtf3(TFtype a, TFtype b)
+__divtf3 (TFtype a, TFtype b)
 {
   FP_DECL_EX;
-  FP_DECL_Q(A);
-  FP_DECL_Q(B);
-  FP_DECL_Q(R);
+  FP_DECL_Q (A);
+  FP_DECL_Q (B);
+  FP_DECL_Q (R);
   TFtype r;
 
   FP_INIT_ROUNDMODE;
-  FP_UNPACK_Q(A, a);
-  FP_UNPACK_Q(B, b);
-  FP_DIV_Q(R, A, B);
-  FP_PACK_Q(r, R);
+  FP_UNPACK_Q (A, a);
+  FP_UNPACK_Q (B, b);
+  FP_DIV_Q (R, A, B);
+  FP_PACK_Q (r, R);
   FP_HANDLE_EXCEPTIONS;
 
   return r;

Modified: fsf/trunk/libc/soft-fp/double.h
==============================================================================
--- fsf/trunk/libc/soft-fp/double.h (original)
+++ fsf/trunk/libc/soft-fp/double.h Thu Oct 17 00:01:48 2013
@@ -51,22 +51,22 @@
 #define _FP_EXPMAX_D		2047
 
 #define _FP_QNANBIT_D		\
-	((_FP_W_TYPE)1 << (_FP_FRACBITS_D-2) % _FP_W_TYPE_SIZE)
+	((_FP_W_TYPE) 1 << (_FP_FRACBITS_D-2) % _FP_W_TYPE_SIZE)
 #define _FP_QNANBIT_SH_D		\
-	((_FP_W_TYPE)1 << (_FP_FRACBITS_D-2+_FP_WORKBITS) % _FP_W_TYPE_SIZE)
+	((_FP_W_TYPE) 1 << (_FP_FRACBITS_D-2+_FP_WORKBITS) % _FP_W_TYPE_SIZE)
 #define _FP_IMPLBIT_D		\
-	((_FP_W_TYPE)1 << (_FP_FRACBITS_D-1) % _FP_W_TYPE_SIZE)
+	((_FP_W_TYPE) 1 << (_FP_FRACBITS_D-1) % _FP_W_TYPE_SIZE)
 #define _FP_IMPLBIT_SH_D		\
-	((_FP_W_TYPE)1 << (_FP_FRACBITS_D-1+_FP_WORKBITS) % _FP_W_TYPE_SIZE)
+	((_FP_W_TYPE) 1 << (_FP_FRACBITS_D-1+_FP_WORKBITS) % _FP_W_TYPE_SIZE)
 #define _FP_OVERFLOW_D		\
-	((_FP_W_TYPE)1 << _FP_WFRACBITS_D % _FP_W_TYPE_SIZE)
+	((_FP_W_TYPE) 1 << _FP_WFRACBITS_D % _FP_W_TYPE_SIZE)
 
 #define _FP_WFRACBITS_DW_D	(2 * _FP_WFRACBITS_D)
 #define _FP_WFRACXBITS_DW_D	(_FP_FRACTBITS_DW_D - _FP_WFRACBITS_DW_D)
 #define _FP_HIGHBIT_DW_D	\
-  ((_FP_W_TYPE)1 << (_FP_WFRACBITS_DW_D - 1) % _FP_W_TYPE_SIZE)
-
-typedef float DFtype __attribute__((mode(DF)));
+  ((_FP_W_TYPE) 1 << (_FP_WFRACBITS_DW_D - 1) % _FP_W_TYPE_SIZE)
+
+typedef float DFtype __attribute__ ((mode (DF)));
 
 #if _FP_W_TYPE_SIZE < 64
 
@@ -86,108 +86,108 @@
     unsigned exp   : _FP_EXPBITS_D;
     unsigned sign  : 1;
 # endif
-  } bits __attribute__((packed));
+  } bits __attribute__ ((packed));
 };
 
-# define FP_DECL_D(X)		_FP_DECL(2,X)
-# define FP_UNPACK_RAW_D(X,val)	_FP_UNPACK_RAW_2(D,X,val)
-# define FP_UNPACK_RAW_DP(X,val)	_FP_UNPACK_RAW_2_P(D,X,val)
-# define FP_PACK_RAW_D(val,X)	_FP_PACK_RAW_2(D,val,X)
-# define FP_PACK_RAW_DP(val,X)			\
-  do						\
-    {						\
-      if (!FP_INHIBIT_RESULTS)			\
-	_FP_PACK_RAW_2_P(D,val,X);		\
-    }						\
-  while (0)
-
-# define FP_UNPACK_D(X,val)			\
-  do						\
-    {						\
-      _FP_UNPACK_RAW_2(D,X,val);		\
-      _FP_UNPACK_CANONICAL(D,2,X);		\
-    }						\
-  while (0)
-
-# define FP_UNPACK_DP(X,val)			\
-  do						\
-    {						\
-      _FP_UNPACK_RAW_2_P(D,X,val);		\
-      _FP_UNPACK_CANONICAL(D,2,X);		\
-    }						\
-  while (0)
-
-# define FP_UNPACK_SEMIRAW_D(X,val)		\
-  do						\
-    {						\
-      _FP_UNPACK_RAW_2(D,X,val);		\
-      _FP_UNPACK_SEMIRAW(D,2,X);		\
-    }						\
-  while (0)
-
-# define FP_UNPACK_SEMIRAW_DP(X,val)		\
-  do						\
-    {						\
-      _FP_UNPACK_RAW_2_P(D,X,val);		\
-      _FP_UNPACK_SEMIRAW(D,2,X);		\
-    }						\
-  while (0)
-
-# define FP_PACK_D(val,X)			\
-  do						\
-    {						\
-      _FP_PACK_CANONICAL(D,2,X);		\
-      _FP_PACK_RAW_2(D,val,X);			\
-    }						\
-  while (0)
-
-# define FP_PACK_DP(val,X)			\
-  do						\
-    {						\
-      _FP_PACK_CANONICAL(D,2,X);		\
-      if (!FP_INHIBIT_RESULTS)			\
-	_FP_PACK_RAW_2_P(D,val,X);		\
-    }						\
-  while (0)
-
-# define FP_PACK_SEMIRAW_D(val,X)		\
-  do						\
-    {						\
-      _FP_PACK_SEMIRAW(D,2,X);			\
-      _FP_PACK_RAW_2(D,val,X);			\
-    }						\
-  while (0)
-
-# define FP_PACK_SEMIRAW_DP(val,X)		\
-  do						\
-    {						\
-      _FP_PACK_SEMIRAW(D,2,X);			\
-      if (!FP_INHIBIT_RESULTS)			\
-	_FP_PACK_RAW_2_P(D,val,X);		\
-    }						\
-  while (0)
-
-# define FP_ISSIGNAN_D(X)		_FP_ISSIGNAN(D,2,X)
-# define FP_NEG_D(R,X)			_FP_NEG(D,2,R,X)
-# define FP_ADD_D(R,X,Y)		_FP_ADD(D,2,R,X,Y)
-# define FP_SUB_D(R,X,Y)		_FP_SUB(D,2,R,X,Y)
-# define FP_MUL_D(R,X,Y)		_FP_MUL(D,2,R,X,Y)
-# define FP_DIV_D(R,X,Y)		_FP_DIV(D,2,R,X,Y)
-# define FP_SQRT_D(R,X)			_FP_SQRT(D,2,R,X)
-# define _FP_SQRT_MEAT_D(R,S,T,X,Q)	_FP_SQRT_MEAT_2(R,S,T,X,Q)
-# define FP_FMA_D(R,X,Y,Z)		_FP_FMA(D,2,4,R,X,Y,Z)
-
-# define FP_CMP_D(r,X,Y,un)	_FP_CMP(D,2,r,X,Y,un)
-# define FP_CMP_EQ_D(r,X,Y)	_FP_CMP_EQ(D,2,r,X,Y)
-# define FP_CMP_UNORD_D(r,X,Y)	_FP_CMP_UNORD(D,2,r,X,Y)
-
-# define FP_TO_INT_D(r,X,rsz,rsg)	_FP_TO_INT(D,2,r,X,rsz,rsg)
-# define FP_FROM_INT_D(X,r,rs,rt)	_FP_FROM_INT(D,2,X,r,rs,rt)
-
-# define _FP_FRAC_HIGH_D(X)	_FP_FRAC_HIGH_2(X)
-# define _FP_FRAC_HIGH_RAW_D(X)	_FP_FRAC_HIGH_2(X)
-
-# define _FP_FRAC_HIGH_DW_D(X)	_FP_FRAC_HIGH_4(X)
+# define FP_DECL_D(X)		_FP_DECL (2, X)
+# define FP_UNPACK_RAW_D(X, val)	_FP_UNPACK_RAW_2 (D, X, val)
+# define FP_UNPACK_RAW_DP(X, val)	_FP_UNPACK_RAW_2_P (D, X, val)
+# define FP_PACK_RAW_D(val, X)	_FP_PACK_RAW_2 (D, val, X)
+# define FP_PACK_RAW_DP(val, X)			\
+  do						\
+    {						\
+      if (!FP_INHIBIT_RESULTS)			\
+	_FP_PACK_RAW_2_P (D, val, X);		\
+    }						\
+  while (0)
+
+# define FP_UNPACK_D(X, val)			\
+  do						\
+    {						\
+      _FP_UNPACK_RAW_2 (D, X, val);		\
+      _FP_UNPACK_CANONICAL (D, 2, X);		\
+    }						\
+  while (0)
+
+# define FP_UNPACK_DP(X, val)			\
+  do						\
+    {						\
+      _FP_UNPACK_RAW_2_P (D, X, val);		\
+      _FP_UNPACK_CANONICAL (D, 2, X);		\
+    }						\
+  while (0)
+
+# define FP_UNPACK_SEMIRAW_D(X, val)		\
+  do						\
+    {						\
+      _FP_UNPACK_RAW_2 (D, X, val);		\
+      _FP_UNPACK_SEMIRAW (D, 2, X);		\
+    }						\
+  while (0)
+
+# define FP_UNPACK_SEMIRAW_DP(X, val)		\
+  do						\
+    {						\
+      _FP_UNPACK_RAW_2_P (D, X, val);		\
+      _FP_UNPACK_SEMIRAW (D, 2, X);		\
+    }						\
+  while (0)
+
+# define FP_PACK_D(val, X)			\
+  do						\
+    {						\
+      _FP_PACK_CANONICAL (D, 2, X);		\
+      _FP_PACK_RAW_2 (D, val, X);		\
+    }						\
+  while (0)
+
+# define FP_PACK_DP(val, X)			\
+  do						\
+    {						\
+      _FP_PACK_CANONICAL (D, 2, X);		\
+      if (!FP_INHIBIT_RESULTS)			\
+	_FP_PACK_RAW_2_P (D, val, X);		\
+    }						\
+  while (0)
+
+# define FP_PACK_SEMIRAW_D(val, X)		\
+  do						\
+    {						\
+      _FP_PACK_SEMIRAW (D, 2, X);		\
+      _FP_PACK_RAW_2 (D, val, X);		\
+    }						\
+  while (0)
+
+# define FP_PACK_SEMIRAW_DP(val, X)		\
+  do						\
+    {						\
+      _FP_PACK_SEMIRAW (D, 2, X);		\
+      if (!FP_INHIBIT_RESULTS)			\
+	_FP_PACK_RAW_2_P (D, val, X);		\
+    }						\
+  while (0)
+
+# define FP_ISSIGNAN_D(X)		_FP_ISSIGNAN (D, 2, X)
+# define FP_NEG_D(R, X)			_FP_NEG (D, 2, R, X)
+# define FP_ADD_D(R, X, Y)		_FP_ADD (D, 2, R, X, Y)
+# define FP_SUB_D(R, X, Y)		_FP_SUB (D, 2, R, X, Y)
+# define FP_MUL_D(R, X, Y)		_FP_MUL (D, 2, R, X, Y)
+# define FP_DIV_D(R, X, Y)		_FP_DIV (D, 2, R, X, Y)
+# define FP_SQRT_D(R, X)		_FP_SQRT (D, 2, R, X)
+# define _FP_SQRT_MEAT_D(R, S, T, X, Q)	_FP_SQRT_MEAT_2 (R, S, T, X, Q)
+# define FP_FMA_D(R, X, Y, Z)		_FP_FMA (D, 2, 4, R, X, Y, Z)
+
+# define FP_CMP_D(r, X, Y, un)		_FP_CMP (D, 2, r, X, Y, un)
+# define FP_CMP_EQ_D(r, X, Y)		_FP_CMP_EQ (D, 2, r, X, Y)
+# define FP_CMP_UNORD_D(r, X, Y)	_FP_CMP_UNORD (D, 2, r, X, Y)
+
+# define FP_TO_INT_D(r, X, rsz, rsg)	_FP_TO_INT (D, 2, r, X, rsz, rsg)
+# define FP_FROM_INT_D(X, r, rs, rt)	_FP_FROM_INT (D, 2, X, r, rs, rt)
+
+# define _FP_FRAC_HIGH_D(X)	_FP_FRAC_HIGH_2 (X)
+# define _FP_FRAC_HIGH_RAW_D(X)	_FP_FRAC_HIGH_2 (X)
+
+# define _FP_FRAC_HIGH_DW_D(X)	_FP_FRAC_HIGH_4 (X)
 
 #else
 
@@ -205,110 +205,110 @@
     unsigned exp    : _FP_EXPBITS_D;
     unsigned sign   : 1;
 # endif
-  } bits __attribute__((packed));
+  } bits __attribute__ ((packed));
 };
 
-# define FP_DECL_D(X)		_FP_DECL(1,X)
-# define FP_UNPACK_RAW_D(X,val)	_FP_UNPACK_RAW_1(D,X,val)
-# define FP_UNPACK_RAW_DP(X,val)	_FP_UNPACK_RAW_1_P(D,X,val)
-# define FP_PACK_RAW_D(val,X)	_FP_PACK_RAW_1(D,val,X)
-# define FP_PACK_RAW_DP(val,X)			\
-  do						\
-    {						\
-      if (!FP_INHIBIT_RESULTS)			\
-	_FP_PACK_RAW_1_P(D,val,X);		\
-    }						\
-  while (0)
-
-# define FP_UNPACK_D(X,val)			\
-  do						\
-    {						\
-      _FP_UNPACK_RAW_1(D,X,val);		\
-      _FP_UNPACK_CANONICAL(D,1,X);		\
-    }						\
-  while (0)
-
-# define FP_UNPACK_DP(X,val)			\
-  do						\
-    {						\
-      _FP_UNPACK_RAW_1_P(D,X,val);		\
-      _FP_UNPACK_CANONICAL(D,1,X);		\
-    }						\
-  while (0)
-
-# define FP_UNPACK_SEMIRAW_D(X,val)		\
-  do						\
-    {						\
-      _FP_UNPACK_RAW_1(D,X,val);		\
-      _FP_UNPACK_SEMIRAW(D,1,X);		\
-    }						\
-  while (0)
-
-# define FP_UNPACK_SEMIRAW_DP(X,val)		\
-  do						\
-    {						\
-      _FP_UNPACK_RAW_1_P(D,X,val);		\
-      _FP_UNPACK_SEMIRAW(D,1,X);		\
-    }						\
-  while (0)
-
-# define FP_PACK_D(val,X)			\
-  do						\
-    {						\
-      _FP_PACK_CANONICAL(D,1,X);		\
-      _FP_PACK_RAW_1(D,val,X);			\
-    }						\
-  while (0)
-
-# define FP_PACK_DP(val,X)			\
-  do						\
-    {						\
-      _FP_PACK_CANONICAL(D,1,X);		\
-      if (!FP_INHIBIT_RESULTS)			\
-	_FP_PACK_RAW_1_P(D,val,X);		\
-    }						\
-  while (0)
-
-# define FP_PACK_SEMIRAW_D(val,X)		\
-  do						\
-    {						\
-      _FP_PACK_SEMIRAW(D,1,X);			\
-      _FP_PACK_RAW_1(D,val,X);			\
-    }						\
-  while (0)
-
-# define FP_PACK_SEMIRAW_DP(val,X)		\
-  do						\
-    {						\
-      _FP_PACK_SEMIRAW(D,1,X);			\
-      if (!FP_INHIBIT_RESULTS)			\
-	_FP_PACK_RAW_1_P(D,val,X);		\
-    }						\
-  while (0)
-
-# define FP_ISSIGNAN_D(X)		_FP_ISSIGNAN(D,1,X)
-# define FP_NEG_D(R,X)			_FP_NEG(D,1,R,X)
-# define FP_ADD_D(R,X,Y)		_FP_ADD(D,1,R,X,Y)
-# define FP_SUB_D(R,X,Y)		_FP_SUB(D,1,R,X,Y)
-# define FP_MUL_D(R,X,Y)		_FP_MUL(D,1,R,X,Y)
-# define FP_DIV_D(R,X,Y)		_FP_DIV(D,1,R,X,Y)
-# define FP_SQRT_D(R,X)			_FP_SQRT(D,1,R,X)
-# define _FP_SQRT_MEAT_D(R,S,T,X,Q)	_FP_SQRT_MEAT_1(R,S,T,X,Q)
-# define FP_FMA_D(R,X,Y,Z)		_FP_FMA(D,1,2,R,X,Y,Z)
+# define FP_DECL_D(X)		_FP_DECL (1, X)
+# define FP_UNPACK_RAW_D(X, val)	_FP_UNPACK_RAW_1 (D, X, val)
+# define FP_UNPACK_RAW_DP(X, val)	_FP_UNPACK_RAW_1_P (D, X, val)
+# define FP_PACK_RAW_D(val, X)	_FP_PACK_RAW_1 (D, val, X)
+# define FP_PACK_RAW_DP(val, X)			\
+  do						\
+    {						\
+      if (!FP_INHIBIT_RESULTS)			\
+	_FP_PACK_RAW_1_P (D, val, X);		\
+    }						\
+  while (0)
+
+# define FP_UNPACK_D(X, val)			\
+  do						\
+    {						\
+      _FP_UNPACK_RAW_1 (D, X, val);		\
+      _FP_UNPACK_CANONICAL (D, 1, X);		\
+    }						\
+  while (0)
+
+# define FP_UNPACK_DP(X, val)			\
+  do						\
+    {						\
+      _FP_UNPACK_RAW_1_P (D, X, val);		\
+      _FP_UNPACK_CANONICAL (D, 1, X);		\
+    }						\
+  while (0)
+
+# define FP_UNPACK_SEMIRAW_D(X, val)		\
+  do						\
+    {						\
+      _FP_UNPACK_RAW_1 (D, X, val);		\
+      _FP_UNPACK_SEMIRAW (D, 1, X);		\
+    }						\
+  while (0)
+
+# define FP_UNPACK_SEMIRAW_DP(X, val)		\
+  do						\
+    {						\
+      _FP_UNPACK_RAW_1_P (D, X, val);		\
+      _FP_UNPACK_SEMIRAW (D, 1, X);		\
+    }						\
+  while (0)
+
+# define FP_PACK_D(val, X)			\
+  do						\
+    {						\
+      _FP_PACK_CANONICAL (D, 1, X);		\
+      _FP_PACK_RAW_1 (D, val, X);		\
+    }						\
+  while (0)
+
+# define FP_PACK_DP(val, X)			\
+  do						\
+    {						\
+      _FP_PACK_CANONICAL (D, 1, X);		\
+      if (!FP_INHIBIT_RESULTS)			\
+	_FP_PACK_RAW_1_P (D, val, X);		\
+    }						\
+  while (0)
+
+# define FP_PACK_SEMIRAW_D(val, X)		\
+  do						\
+    {						\
+      _FP_PACK_SEMIRAW (D, 1, X);		\
+      _FP_PACK_RAW_1 (D, val, X);		\
+    }						\
+  while (0)
+
+# define FP_PACK_SEMIRAW_DP(val, X)		\
+  do						\
+    {						\
+      _FP_PACK_SEMIRAW (D, 1, X);		\
+      if (!FP_INHIBIT_RESULTS)			\
+	_FP_PACK_RAW_1_P (D, val, X);		\
+    }						\
+  while (0)
+
+# define FP_ISSIGNAN_D(X)		_FP_ISSIGNAN (D, 1, X)
+# define FP_NEG_D(R, X)			_FP_NEG (D, 1, R, X)
+# define FP_ADD_D(R, X, Y)		_FP_ADD (D, 1, R, X, Y)
+# define FP_SUB_D(R, X, Y)		_FP_SUB (D, 1, R, X, Y)
+# define FP_MUL_D(R, X, Y)		_FP_MUL (D, 1, R, X, Y)
+# define FP_DIV_D(R, X, Y)		_FP_DIV (D, 1, R, X, Y)
+# define FP_SQRT_D(R, X)		_FP_SQRT (D, 1, R, X)
+# define _FP_SQRT_MEAT_D(R, S, T, X, Q)	_FP_SQRT_MEAT_1 (R, S, T, X, Q)
+# define FP_FMA_D(R, X, Y, Z)		_FP_FMA (D, 1, 2, R, X, Y, Z)
 
 /* The implementation of _FP_MUL_D and _FP_DIV_D should be chosen by
    the target machine.  */
 
-# define FP_CMP_D(r,X,Y,un)	_FP_CMP(D,1,r,X,Y,un)
-# define FP_CMP_EQ_D(r,X,Y)	_FP_CMP_EQ(D,1,r,X,Y)
-# define FP_CMP_UNORD_D(r,X,Y)	_FP_CMP_UNORD(D,1,r,X,Y)
-
-# define FP_TO_INT_D(r,X,rsz,rsg)	_FP_TO_INT(D,1,r,X,rsz,rsg)
-# define FP_FROM_INT_D(X,r,rs,rt)	_FP_FROM_INT(D,1,X,r,rs,rt)
-
-# define _FP_FRAC_HIGH_D(X)	_FP_FRAC_HIGH_1(X)
-# define _FP_FRAC_HIGH_RAW_D(X)	_FP_FRAC_HIGH_1(X)
-
-# define _FP_FRAC_HIGH_DW_D(X)	_FP_FRAC_HIGH_2(X)
+# define FP_CMP_D(r, X, Y, un)		_FP_CMP (D, 1, r, X, Y, un)
+# define FP_CMP_EQ_D(r, X, Y)		_FP_CMP_EQ (D, 1, r, X, Y)
+# define FP_CMP_UNORD_D(r, X, Y)	_FP_CMP_UNORD (D, 1, r, X, Y)
+
+# define FP_TO_INT_D(r, X, rsz, rsg)	_FP_TO_INT (D, 1, r, X, rsz, rsg)
+# define FP_FROM_INT_D(X, r, rs, rt)	_FP_FROM_INT (D, 1, X, r, rs, rt)
+
+# define _FP_FRAC_HIGH_D(X)	_FP_FRAC_HIGH_1 (X)
+# define _FP_FRAC_HIGH_RAW_D(X)	_FP_FRAC_HIGH_1 (X)
+
+# define _FP_FRAC_HIGH_DW_D(X)	_FP_FRAC_HIGH_2 (X)
 
 #endif /* W_TYPE_SIZE < 64 */

Modified: fsf/trunk/libc/soft-fp/eqdf2.c
==============================================================================
--- fsf/trunk/libc/soft-fp/eqdf2.c (original)
+++ fsf/trunk/libc/soft-fp/eqdf2.c Thu Oct 17 00:01:48 2013
@@ -32,22 +32,22 @@
 #include "double.h"
 
 CMPtype
-__eqdf2(DFtype a, DFtype b)
+__eqdf2 (DFtype a, DFtype b)
 {
   FP_DECL_EX;
-  FP_DECL_D(A);
-  FP_DECL_D(B);
+  FP_DECL_D (A);
+  FP_DECL_D (B);
   CMPtype r;
 
   FP_INIT_EXCEPTIONS;
-  FP_UNPACK_RAW_D(A, a);
-  FP_UNPACK_RAW_D(B, b);
-  FP_CMP_EQ_D(r, A, B);
-  if (r && (FP_ISSIGNAN_D(A) || FP_ISSIGNAN_D(B)))
-    FP_SET_EXCEPTION(FP_EX_INVALID);
+  FP_UNPACK_RAW_D (A, a);
+  FP_UNPACK_RAW_D (B, b);
+  FP_CMP_EQ_D (r, A, B);
+  if (r && (FP_ISSIGNAN_D (A) || FP_ISSIGNAN_D (B)))
+    FP_SET_EXCEPTION (FP_EX_INVALID);
   FP_HANDLE_EXCEPTIONS;
 
   return r;
 }
 
-strong_alias(__eqdf2, __nedf2);
+strong_alias (__eqdf2, __nedf2);

Modified: fsf/trunk/libc/soft-fp/eqsf2.c
==============================================================================
--- fsf/trunk/libc/soft-fp/eqsf2.c (original)
+++ fsf/trunk/libc/soft-fp/eqsf2.c Thu Oct 17 00:01:48 2013
@@ -32,22 +32,22 @@
 #include "single.h"
 
 CMPtype
-__eqsf2(SFtype a, SFtype b)
+__eqsf2 (SFtype a, SFtype b)
 {
   FP_DECL_EX;
-  FP_DECL_S(A);
-  FP_DECL_S(B);
+  FP_DECL_S (A);
+  FP_DECL_S (B);
   CMPtype r;
 
   FP_INIT_EXCEPTIONS;
-  FP_UNPACK_RAW_S(A, a);
-  FP_UNPACK_RAW_S(B, b);
-  FP_CMP_EQ_S(r, A, B);
-  if (r && (FP_ISSIGNAN_S(A) || FP_ISSIGNAN_S(B)))
-    FP_SET_EXCEPTION(FP_EX_INVALID);
+  FP_UNPACK_RAW_S (A, a);
+  FP_UNPACK_RAW_S (B, b);
+  FP_CMP_EQ_S (r, A, B);
+  if (r && (FP_ISSIGNAN_S (A) || FP_ISSIGNAN_S (B)))
+    FP_SET_EXCEPTION (FP_EX_INVALID);
   FP_HANDLE_EXCEPTIONS;
 
   return r;
 }
 
-strong_alias(__eqsf2, __nesf2);
+strong_alias (__eqsf2, __nesf2);

Modified: fsf/trunk/libc/soft-fp/eqtf2.c
==============================================================================
--- fsf/trunk/libc/soft-fp/eqtf2.c (original)
+++ fsf/trunk/libc/soft-fp/eqtf2.c Thu Oct 17 00:01:48 2013
@@ -32,22 +32,22 @@
 #include "quad.h"
 
 CMPtype
-__eqtf2(TFtype a, TFtype b)
+__eqtf2 (TFtype a, TFtype b)
 {
   FP_DECL_EX;
-  FP_DECL_Q(A);
-  FP_DECL_Q(B);
+  FP_DECL_Q (A);
+  FP_DECL_Q (B);
   CMPtype r;
 
   FP_INIT_EXCEPTIONS;
-  FP_UNPACK_RAW_Q(A, a);
-  FP_UNPACK_RAW_Q(B, b);
-  FP_CMP_EQ_Q(r, A, B);
-  if (r && (FP_ISSIGNAN_Q(A) || FP_ISSIGNAN_Q(B)))
-    FP_SET_EXCEPTION(FP_EX_INVALID);
+  FP_UNPACK_RAW_Q (A, a);
+  FP_UNPACK_RAW_Q (B, b);
+  FP_CMP_EQ_Q (r, A, B);
+  if (r && (FP_ISSIGNAN_Q (A) || FP_ISSIGNAN_Q (B)))
+    FP_SET_EXCEPTION (FP_EX_INVALID);
   FP_HANDLE_EXCEPTIONS;
 
   return r;
 }
 
-strong_alias(__eqtf2, __netf2);
+strong_alias (__eqtf2, __netf2);

Modified: fsf/trunk/libc/soft-fp/extenddftf2.c
==============================================================================
--- fsf/trunk/libc/soft-fp/extenddftf2.c (original)
+++ fsf/trunk/libc/soft-fp/extenddftf2.c Thu Oct 17 00:01:48 2013
@@ -33,21 +33,21 @@
 #include "quad.h"
 
 TFtype
-__extenddftf2(DFtype a)
+__extenddftf2 (DFtype a)
 {
   FP_DECL_EX;
-  FP_DECL_D(A);
-  FP_DECL_Q(R);
+  FP_DECL_D (A);
+  FP_DECL_Q (R);
   TFtype r;
 
   FP_INIT_EXCEPTIONS;
-  FP_UNPACK_RAW_D(A, a);
+  FP_UNPACK_RAW_D (A, a);
 #if (2 * _FP_W_TYPE_SIZE) < _FP_FRACBITS_Q
-  FP_EXTEND(Q,D,4,2,R,A);
+  FP_EXTEND (Q, D, 4, 2, R, A);
 #else
-  FP_EXTEND(Q,D,2,1,R,A);
+  FP_EXTEND (Q, D, 2, 1, R, A);
 #endif
-  FP_PACK_RAW_Q(r, R);
+  FP_PACK_RAW_Q (r, R);
   FP_HANDLE_EXCEPTIONS;
 
   return r;

Modified: fsf/trunk/libc/soft-fp/extended.h
==============================================================================
--- fsf/trunk/libc/soft-fp/extended.h (original)
+++ fsf/trunk/libc/soft-fp/extended.h Thu Oct 17 00:01:48 2013
@@ -48,22 +48,22 @@
 #define _FP_EXPMAX_E		32767
 
 #define _FP_QNANBIT_E		\
-	((_FP_W_TYPE)1 << (_FP_FRACBITS_E-2) % _FP_W_TYPE_SIZE)
+	((_FP_W_TYPE) 1 << (_FP_FRACBITS_E-2) % _FP_W_TYPE_SIZE)
 #define _FP_QNANBIT_SH_E		\
-	((_FP_W_TYPE)1 << (_FP_FRACBITS_E-2+_FP_WORKBITS) % _FP_W_TYPE_SIZE)
+	((_FP_W_TYPE) 1 << (_FP_FRACBITS_E-2+_FP_WORKBITS) % _FP_W_TYPE_SIZE)
 #define _FP_IMPLBIT_E		\
-	((_FP_W_TYPE)1 << (_FP_FRACBITS_E-1) % _FP_W_TYPE_SIZE)
+	((_FP_W_TYPE) 1 << (_FP_FRACBITS_E-1) % _FP_W_TYPE_SIZE)
 #define _FP_IMPLBIT_SH_E		\
-	((_FP_W_TYPE)1 << (_FP_FRACBITS_E-1+_FP_WORKBITS) % _FP_W_TYPE_SIZE)
+	((_FP_W_TYPE) 1 << (_FP_FRACBITS_E-1+_FP_WORKBITS) % _FP_W_TYPE_SIZE)
 #define _FP_OVERFLOW_E		\
-	((_FP_W_TYPE)1 << (_FP_WFRACBITS_E % _FP_W_TYPE_SIZE))
+	((_FP_W_TYPE) 1 << (_FP_WFRACBITS_E % _FP_W_TYPE_SIZE))
 
 #define _FP_WFRACBITS_DW_E	(2 * _FP_WFRACBITS_E)
 #define _FP_WFRACXBITS_DW_E	(_FP_FRACTBITS_DW_E - _FP_WFRACBITS_DW_E)
 #define _FP_HIGHBIT_DW_E	\
-  ((_FP_W_TYPE)1 << (_FP_WFRACBITS_DW_E - 1) % _FP_W_TYPE_SIZE)
-
-typedef float XFtype __attribute__((mode(XF)));
+  ((_FP_W_TYPE) 1 << (_FP_WFRACBITS_DW_E - 1) % _FP_W_TYPE_SIZE)
+
+typedef float XFtype __attribute__ ((mode (XF)));
 
 #if _FP_W_TYPE_SIZE < 64
 
@@ -85,11 +85,11 @@
     unsigned exp : _FP_EXPBITS_E;
     unsigned sign : 1;
 # endif /* not bigendian */
-  } bits __attribute__((packed));
+  } bits __attribute__ ((packed));
 };
 
 
-# define FP_DECL_E(X)		_FP_DECL(4,X)
+# define FP_DECL_E(X)		_FP_DECL (4, X)
 
 # define FP_UNPACK_RAW_E(X, val)		\
   do						\
@@ -109,7 +109,7 @@
 # define FP_UNPACK_RAW_EP(X, val)				\
   do								\
     {								\
-      union _FP_UNION_E *_flo = (union _FP_UNION_E *)(val);	\
+      union _FP_UNION_E *_flo = (union _FP_UNION_E *) (val);	\
 								\
       X##_f[2] = 0;						\
       X##_f[3] = 0;						\
@@ -138,97 +138,97 @@
     }						\
   while (0)
 
-# define FP_PACK_RAW_EP(val, X)					\
-  do								\
-    {								\
-      if (!FP_INHIBIT_RESULTS)					\
-	{							\
-	  union _FP_UNION_E *_flo = (union _FP_UNION_E *)(val);	\
-								\
-	  if (X##_e)						\
-	    X##_f[1] |= _FP_IMPLBIT_E;				\
-	  else							\
-	    X##_f[1] &= ~(_FP_IMPLBIT_E);			\
-	  _flo->bits.frac0 = X##_f[0];				\
-	  _flo->bits.frac1 = X##_f[1];				\
-	  _flo->bits.exp   = X##_e;				\
-	  _flo->bits.sign  = X##_s;				\
-	}							\
-    }								\
-  while (0)
-
-# define FP_UNPACK_E(X,val)			\
-  do						\
-    {						\
-      FP_UNPACK_RAW_E(X,val);			\
-      _FP_UNPACK_CANONICAL(E,4,X);		\
-    }						\
-  while (0)
-
-# define FP_UNPACK_EP(X,val)			\
-  do						\
-    {						\
-      FP_UNPACK_RAW_EP(X,val);			\
-      _FP_UNPACK_CANONICAL(E,4,X);		\
-    }						\
-  while (0)
-
-# define FP_UNPACK_SEMIRAW_E(X,val)		\
-  do						\
-    {						\
-      FP_UNPACK_RAW_E(X,val);			\
-      _FP_UNPACK_SEMIRAW(E,4,X);		\
-    }						\
-  while (0)
-
-# define FP_UNPACK_SEMIRAW_EP(X,val)		\
-  do						\
-    {						\
-      FP_UNPACK_RAW_EP(X,val);			\
-      _FP_UNPACK_SEMIRAW(E,4,X);		\
-    }						\
-  while (0)
-
-# define FP_PACK_E(val,X)			\
-  do						\
-    {						\
-      _FP_PACK_CANONICAL(E,4,X);		\
-      FP_PACK_RAW_E(val,X);			\
-    }						\
-  while (0)
-
-# define FP_PACK_EP(val,X)			\
-  do						\
-    {						\
-      _FP_PACK_CANONICAL(E,4,X);		\
-      FP_PACK_RAW_EP(val,X);			\
-    }						\
-  while (0)
-
-# define FP_PACK_SEMIRAW_E(val,X)		\
-  do						\
-    {						\
-      _FP_PACK_SEMIRAW(E,4,X);			\
-      FP_PACK_RAW_E(val,X);			\
-    }						\
-  while (0)
-
-# define FP_PACK_SEMIRAW_EP(val,X)		\
-  do						\
-    {						\
-      _FP_PACK_SEMIRAW(E,4,X);			\
-      FP_PACK_RAW_EP(val,X);			\
-    }						\
-  while (0)
-
-# define FP_ISSIGNAN_E(X)	_FP_ISSIGNAN(E,4,X)
-# define FP_NEG_E(R,X)		_FP_NEG(E,4,R,X)
-# define FP_ADD_E(R,X,Y)	_FP_ADD(E,4,R,X,Y)
-# define FP_SUB_E(R,X,Y)	_FP_SUB(E,4,R,X,Y)
-# define FP_MUL_E(R,X,Y)	_FP_MUL(E,4,R,X,Y)
-# define FP_DIV_E(R,X,Y)	_FP_DIV(E,4,R,X,Y)
-# define FP_SQRT_E(R,X)		_FP_SQRT(E,4,R,X)
-# define FP_FMA_E(R,X,Y,Z)	_FP_FMA(E,4,8,R,X,Y,Z)
+# define FP_PACK_RAW_EP(val, X)						\
+  do									\
+    {									\
+      if (!FP_INHIBIT_RESULTS)						\
+	{								\
+	  union _FP_UNION_E *_flo = (union _FP_UNION_E *) (val);	\
+									\
+	  if (X##_e)							\
+	    X##_f[1] |= _FP_IMPLBIT_E;					\
+	  else								\
+	    X##_f[1] &= ~(_FP_IMPLBIT_E);				\
+	  _flo->bits.frac0 = X##_f[0];					\
+	  _flo->bits.frac1 = X##_f[1];					\
+	  _flo->bits.exp   = X##_e;					\
+	  _flo->bits.sign  = X##_s;					\
+	}								\
+    }									\
+  while (0)
+
+# define FP_UNPACK_E(X, val)			\
+  do						\
+    {						\
+      FP_UNPACK_RAW_E (X, val);			\
+      _FP_UNPACK_CANONICAL (E, 4, X);		\
+    }						\
+  while (0)
+
+# define FP_UNPACK_EP(X, val)			\
+  do						\
+    {						\
+      FP_UNPACK_RAW_EP (X, val);		\
+      _FP_UNPACK_CANONICAL (E, 4, X);		\
+    }						\
+  while (0)
+
+# define FP_UNPACK_SEMIRAW_E(X, val)		\
+  do						\
+    {						\
+      FP_UNPACK_RAW_E (X, val);			\
+      _FP_UNPACK_SEMIRAW (E, 4, X);		\
+    }						\
+  while (0)
+
+# define FP_UNPACK_SEMIRAW_EP(X, val)		\
+  do						\
+    {						\
+      FP_UNPACK_RAW_EP (X, val);		\
+      _FP_UNPACK_SEMIRAW (E, 4, X);		\
+    }						\
+  while (0)
+
+# define FP_PACK_E(val, X)			\
+  do						\
+    {						\
+      _FP_PACK_CANONICAL (E, 4, X);		\
+      FP_PACK_RAW_E (val, X);			\
+    }						\
+  while (0)
+
+# define FP_PACK_EP(val, X)			\
+  do						\
+    {						\
+      _FP_PACK_CANONICAL (E, 4, X);		\
+      FP_PACK_RAW_EP (val, X);			\
+    }						\
+  while (0)
+
+# define FP_PACK_SEMIRAW_E(val, X)		\
+  do						\
+    {						\
+      _FP_PACK_SEMIRAW (E, 4, X);		\
+      FP_PACK_RAW_E (val, X);			\
+    }						\
+  while (0)
+
+# define FP_PACK_SEMIRAW_EP(val, X)		\
+  do						\
+    {						\
+      _FP_PACK_SEMIRAW (E, 4, X);		\
+      FP_PACK_RAW_EP (val, X);			\
+    }						\
+  while (0)
+
+# define FP_ISSIGNAN_E(X)	_FP_ISSIGNAN (E, 4, X)
+# define FP_NEG_E(R, X)		_FP_NEG (E, 4, R, X)
+# define FP_ADD_E(R, X, Y)	_FP_ADD (E, 4, R, X, Y)
+# define FP_SUB_E(R, X, Y)	_FP_SUB (E, 4, R, X, Y)
+# define FP_MUL_E(R, X, Y)	_FP_MUL (E, 4, R, X, Y)
+# define FP_DIV_E(R, X, Y)	_FP_DIV (E, 4, R, X, Y)
+# define FP_SQRT_E(R, X)	_FP_SQRT (E, 4, R, X)
+# define FP_FMA_E(R, X, Y, Z)	_FP_FMA (E, 4, 8, R, X, Y, Z)
 
 /*
  * Square root algorithms:
@@ -244,8 +244,8 @@
 # define _FP_SQRT_MEAT_E(R, S, T, X, q)			\
   do							\
     {							\
-      q = (_FP_W_TYPE)1 << (_FP_W_TYPE_SIZE - 1);	\
-      _FP_FRAC_SRL_4(X, (_FP_WORKBITS));		\
+      q = (_FP_W_TYPE) 1 << (_FP_W_TYPE_SIZE - 1);	\
+      _FP_FRAC_SRL_4 (X, (_FP_WORKBITS));		\
       while (q)						\
 	{						\
 	  T##_f[1] = S##_f[1] + q;			\
@@ -255,10 +255,10 @@
 	      X##_f[1] -= T##_f[1];			\
 	      R##_f[1] += q;				\
 	    }						\
-	  _FP_FRAC_SLL_2(X, 1);				\
+	  _FP_FRAC_SLL_2 (X, 1);			\
 	  q >>= 1;					\
 	}						\
-      q = (_FP_W_TYPE)1 << (_FP_W_TYPE_SIZE - 1);	\
+      q = (_FP_W_TYPE) 1 << (_FP_W_TYPE_SIZE - 1);	\
       while (q)						\
 	{						\
 	  T##_f[0] = S##_f[0] + q;			\
@@ -269,13 +269,13 @@
 	    {						\
 	      S##_f[0] = T##_f[0] + q;			\
 	      S##_f[1] += (T##_f[0] > S##_f[0]);	\
-	      _FP_FRAC_DEC_2(X, T);			\
+	      _FP_FRAC_DEC_2 (X, T);			\
 	      R##_f[0] += q;				\
 	    }						\
-	  _FP_FRAC_SLL_2(X, 1);				\
+	  _FP_FRAC_SLL_2 (X, 1);			\
 	  q >>= 1;					\
 	}						\
-      _FP_FRAC_SLL_4(R, (_FP_WORKBITS));		\
+      _FP_FRAC_SLL_4 (R, (_FP_WORKBITS));		\
       if (X##_f[0] | X##_f[1])				\
 	{						\
 	  if (S##_f[1] < X##_f[1]			\
@@ -287,12 +287,12 @@
     }							\
   while (0)
 
-# define FP_CMP_E(r,X,Y,un)	_FP_CMP(E,4,r,X,Y,un)
-# define FP_CMP_EQ_E(r,X,Y)	_FP_CMP_EQ(E,4,r,X,Y)
-# define FP_CMP_UNORD_E(r,X,Y)	_FP_CMP_UNORD(E,4,r,X,Y)
-
-# define FP_TO_INT_E(r,X,rsz,rsg)	_FP_TO_INT(E,4,r,X,rsz,rsg)
-# define FP_FROM_INT_E(X,r,rs,rt)	_FP_FROM_INT(E,4,X,r,rs,rt)
+# define FP_CMP_E(r, X, Y, un)		_FP_CMP (E, 4, r, X, Y, un)
+# define FP_CMP_EQ_E(r, X, Y)		_FP_CMP_EQ (E, 4, r, X, Y)
+# define FP_CMP_UNORD_E(r, X, Y)	_FP_CMP_UNORD (E, 4, r, X, Y)
+
+# define FP_TO_INT_E(r, X, rsz, rsg)	_FP_TO_INT (E, 4, r, X, rsz, rsg)
+# define FP_FROM_INT_E(X, r, rs, rt)	_FP_FROM_INT (E, 4, X, r, rs, rt)
 
 # define _FP_FRAC_HIGH_E(X)	(X##_f[2])
 # define _FP_FRAC_HIGH_RAW_E(X)	(X##_f[1])
@@ -318,7 +318,7 @@
   } bits;
 };
 
-# define FP_DECL_E(X)		_FP_DECL(2,X)
+# define FP_DECL_E(X)		_FP_DECL (2, X)
 
 # define FP_UNPACK_RAW_E(X, val)		\
   do						\
@@ -336,7 +336,7 @@
 # define FP_UNPACK_RAW_EP(X, val)				\
   do								\
     {								\
-      union _FP_UNION_E *_flo = (union _FP_UNION_E *)(val);	\
+      union _FP_UNION_E *_flo = (union _FP_UNION_E *) (val);	\
 								\
       X##_f0 = _flo->bits.frac;					\
       X##_f1 = 0;						\
@@ -362,97 +362,97 @@
     }						\
   while (0)
 
-# define FP_PACK_RAW_EP(fs, val, X)				\
-  do								\
-    {								\
-      if (!FP_INHIBIT_RESULTS)					\
-	{							\
-	  union _FP_UNION_E *_flo = (union _FP_UNION_E *)(val);	\
-								\
-	  if (X##_e)						\
-	    X##_f0 |= _FP_IMPLBIT_E;				\
-	  else							\
-	    X##_f0 &= ~(_FP_IMPLBIT_E);				\
-	  _flo->bits.frac = X##_f0;				\
-	  _flo->bits.exp  = X##_e;				\
-	  _flo->bits.sign = X##_s;				\
-	}							\
-    }								\
-  while (0)
-
-
-# define FP_UNPACK_E(X,val)			\
-  do						\
-    {						\
-      FP_UNPACK_RAW_E(X,val);			\
-      _FP_UNPACK_CANONICAL(E,2,X);		\
-    }						\
-  while (0)
-
-# define FP_UNPACK_EP(X,val)			\
-  do						\
-    {						\
-      FP_UNPACK_RAW_EP(X,val);			\
-      _FP_UNPACK_CANONICAL(E,2,X);		\
-    }						\
-  while (0)
-
-# define FP_UNPACK_SEMIRAW_E(X,val)		\
-  do						\
-    {						\
-      FP_UNPACK_RAW_E(X,val);			\
-      _FP_UNPACK_SEMIRAW(E,2,X);		\
-    }						\
-  while (0)
-
-# define FP_UNPACK_SEMIRAW_EP(X,val)		\
-  do						\
-    {						\
-      FP_UNPACK_RAW_EP(X,val);			\
-      _FP_UNPACK_SEMIRAW(E,2,X);		\
-    }						\
-  while (0)
-
-# define FP_PACK_E(val,X)			\
-  do						\
-    {						\
-      _FP_PACK_CANONICAL(E,2,X);		\
-      FP_PACK_RAW_E(val,X);			\
-    }						\
-  while (0)
-
-# define FP_PACK_EP(val,X)			\
-  do						\
-    {						\
-      _FP_PACK_CANONICAL(E,2,X);		\
-      FP_PACK_RAW_EP(val,X);			\
-    }						\
-  while (0)
-
-# define FP_PACK_SEMIRAW_E(val,X)		\
-  do						\
-    {						\
-      _FP_PACK_SEMIRAW(E,2,X);			\
-      FP_PACK_RAW_E(val,X);			\
-    }						\
-  while (0)
-
-# define FP_PACK_SEMIRAW_EP(val,X)		\
-  do						\
-    {						\
-      _FP_PACK_SEMIRAW(E,2,X);			\
-      FP_PACK_RAW_EP(val,X);			\
-    }						\
-  while (0)
-
-# define FP_ISSIGNAN_E(X)	_FP_ISSIGNAN(E,2,X)
-# define FP_NEG_E(R,X)		_FP_NEG(E,2,R,X)
-# define FP_ADD_E(R,X,Y)	_FP_ADD(E,2,R,X,Y)
-# define FP_SUB_E(R,X,Y)	_FP_SUB(E,2,R,X,Y)
-# define FP_MUL_E(R,X,Y)	_FP_MUL(E,2,R,X,Y)
-# define FP_DIV_E(R,X,Y)	_FP_DIV(E,2,R,X,Y)
-# define FP_SQRT_E(R,X)		_FP_SQRT(E,2,R,X)
-# define FP_FMA_E(R,X,Y,Z)	_FP_FMA(E,2,4,R,X,Y,Z)
+# define FP_PACK_RAW_EP(fs, val, X)					\
+  do									\
+    {									\
+      if (!FP_INHIBIT_RESULTS)						\
+	{								\
+	  union _FP_UNION_E *_flo = (union _FP_UNION_E *) (val);	\
+									\
+	  if (X##_e)							\
+	    X##_f0 |= _FP_IMPLBIT_E;					\
+	  else								\
+	    X##_f0 &= ~(_FP_IMPLBIT_E);					\
+	  _flo->bits.frac = X##_f0;					\
+	  _flo->bits.exp  = X##_e;					\
+	  _flo->bits.sign = X##_s;					\
+	}								\
+    }									\
+  while (0)
+
+
+# define FP_UNPACK_E(X, val)			\
+  do						\
+    {						\
+      FP_UNPACK_RAW_E (X, val);			\
+      _FP_UNPACK_CANONICAL (E, 2, X);		\
+    }						\
+  while (0)
+
+# define FP_UNPACK_EP(X, val)			\
+  do						\
+    {						\
+      FP_UNPACK_RAW_EP (X, val);		\
+      _FP_UNPACK_CANONICAL (E, 2, X);		\
+    }						\
+  while (0)
+
+# define FP_UNPACK_SEMIRAW_E(X, val)		\
+  do						\
+    {						\
+      FP_UNPACK_RAW_E (X, val);			\
+      _FP_UNPACK_SEMIRAW (E, 2, X);		\
+    }						\
+  while (0)
+
+# define FP_UNPACK_SEMIRAW_EP(X, val)		\
+  do						\
+    {						\
+      FP_UNPACK_RAW_EP (X, val);		\
+      _FP_UNPACK_SEMIRAW (E, 2, X);		\
+    }						\
+  while (0)
+
+# define FP_PACK_E(val, X)			\
+  do						\
+    {						\
+      _FP_PACK_CANONICAL (E, 2, X);		\
+      FP_PACK_RAW_E (val, X);			\
+    }						\
+  while (0)
+
+# define FP_PACK_EP(val, X)			\
+  do						\
+    {						\
+      _FP_PACK_CANONICAL (E, 2, X);		\
+      FP_PACK_RAW_EP (val, X);			\
+    }						\
+  while (0)
+
+# define FP_PACK_SEMIRAW_E(val, X)		\
+  do						\
+    {						\
+      _FP_PACK_SEMIRAW (E, 2, X);		\
+      FP_PACK_RAW_E (val, X);			\
+    }						\
+  while (0)
+
+# define FP_PACK_SEMIRAW_EP(val, X)		\
+  do						\
+    {						\
+      _FP_PACK_SEMIRAW (E, 2, X);		\
+      FP_PACK_RAW_EP (val, X);			\
+    }						\
+  while (0)
+
+# define FP_ISSIGNAN_E(X)	_FP_ISSIGNAN (E, 2, X)
+# define FP_NEG_E(R, X)		_FP_NEG (E, 2, R, X)
+# define FP_ADD_E(R, X, Y)	_FP_ADD (E, 2, R, X, Y)
+# define FP_SUB_E(R, X, Y)	_FP_SUB (E, 2, R, X, Y)
+# define FP_MUL_E(R, X, Y)	_FP_MUL (E, 2, R, X, Y)
+# define FP_DIV_E(R, X, Y)	_FP_DIV (E, 2, R, X, Y)
+# define FP_SQRT_E(R, X)	_FP_SQRT (E, 2, R, X)
+# define FP_FMA_E(R, X, Y, Z)	_FP_FMA (E, 2, 4, R, X, Y, Z)
 
 /*
  * Square root algorithms:
@@ -465,8 +465,8 @@
 # define _FP_SQRT_MEAT_E(R, S, T, X, q)			\
   do							\
     {							\
-      q = (_FP_W_TYPE)1 << (_FP_W_TYPE_SIZE - 1);	\
-      _FP_FRAC_SRL_2(X, (_FP_WORKBITS));		\
+      q = (_FP_W_TYPE) 1 << (_FP_W_TYPE_SIZE - 1);	\
+      _FP_FRAC_SRL_2 (X, (_FP_WORKBITS));		\
       while (q)						\
 	{						\
 	  T##_f0 = S##_f0 + q;				\
@@ -476,10 +476,10 @@
 	      X##_f0 -= T##_f0;				\
 	      R##_f0 += q;				\
 	    }						\
-	  _FP_FRAC_SLL_1(X, 1);				\
+	  _FP_FRAC_SLL_1 (X, 1);			\
 	  q >>= 1;					\
 	}						\
-      _FP_FRAC_SLL_2(R, (_FP_WORKBITS));		\
+      _FP_FRAC_SLL_2 (R, (_FP_WORKBITS));		\
       if (X##_f0)					\
 	{						\
 	  if (S##_f0 < X##_f0)				\
@@ -489,12 +489,12 @@
     }							\
   while (0)
 
-# define FP_CMP_E(r,X,Y,un)	_FP_CMP(E,2,r,X,Y,un)
-# define FP_CMP_EQ_E(r,X,Y)	_FP_CMP_EQ(E,2,r,X,Y)
-# define FP_CMP_UNORD_E(r,X,Y)	_FP_CMP_UNORD(E,2,r,X,Y)
-
-# define FP_TO_INT_E(r,X,rsz,rsg)	_FP_TO_INT(E,2,r,X,rsz,rsg)
-# define FP_FROM_INT_E(X,r,rs,rt)	_FP_FROM_INT(E,2,X,r,rs,rt)
+# define FP_CMP_E(r, X, Y, un)		_FP_CMP (E, 2, r, X, Y, un)
+# define FP_CMP_EQ_E(r, X, Y)		_FP_CMP_EQ (E, 2, r, X, Y)
+# define FP_CMP_UNORD_E(r, X, Y)	_FP_CMP_UNORD (E, 2, r, X, Y)
+
+# define FP_TO_INT_E(r, X, rsz, rsg)	_FP_TO_INT (E, 2, r, X, rsz, rsg)
+# define FP_FROM_INT_E(X, r, rs, rt)	_FP_FROM_INT (E, 2, X, r, rs, rt)
 
 # define _FP_FRAC_HIGH_E(X)	(X##_f1)
 # define _FP_FRAC_HIGH_RAW_E(X)	(X##_f0)

Modified: fsf/trunk/libc/soft-fp/extendsfdf2.c
==============================================================================
--- fsf/trunk/libc/soft-fp/extendsfdf2.c (original)
+++ fsf/trunk/libc/soft-fp/extendsfdf2.c Thu Oct 17 00:01:48 2013
@@ -33,21 +33,21 @@
 #include "double.h"
 
 DFtype
-__extendsfdf2(SFtype a)
+__extendsfdf2 (SFtype a)
 {
   FP_DECL_EX;
-  FP_DECL_S(A);
-  FP_DECL_D(R);
+  FP_DECL_S (A);
+  FP_DECL_D (R);
   DFtype r;
 
   FP_INIT_EXCEPTIONS;
-  FP_UNPACK_RAW_S(A, a);
+  FP_UNPACK_RAW_S (A, a);
 #if _FP_W_TYPE_SIZE < _FP_FRACBITS_D
-  FP_EXTEND(D,S,2,1,R,A);
+  FP_EXTEND (D, S, 2, 1, R, A);
 #else
-  FP_EXTEND(D,S,1,1,R,A);
+  FP_EXTEND (D, S, 1, 1, R, A);
 #endif
-  FP_PACK_RAW_D(r, R);
+  FP_PACK_RAW_D (r, R);
   FP_HANDLE_EXCEPTIONS;
 
   return r;

Modified: fsf/trunk/libc/soft-fp/extendsftf2.c
==============================================================================
--- fsf/trunk/libc/soft-fp/extendsftf2.c (original)
+++ fsf/trunk/libc/soft-fp/extendsftf2.c Thu Oct 17 00:01:48 2013
@@ -33,21 +33,21 @@
 #include "quad.h"
 
 TFtype
-__extendsftf2(SFtype a)
+__extendsftf2 (SFtype a)
 {
   FP_DECL_EX;
-  FP_DECL_S(A);
-  FP_DECL_Q(R);
+  FP_DECL_S (A);
+  FP_DECL_Q (R);
   TFtype r;
 
   FP_INIT_EXCEPTIONS;
-  FP_UNPACK_RAW_S(A, a);
+  FP_UNPACK_RAW_S (A, a);
 #if (2 * _FP_W_TYPE_SIZE) < _FP_FRACBITS_Q
-  FP_EXTEND(Q,S,4,1,R,A);
+  FP_EXTEND (Q, S, 4, 1, R, A);
 #else
-  FP_EXTEND(Q,S,2,1,R,A);
+  FP_EXTEND (Q, S, 2, 1, R, A);
 #endif
-  FP_PACK_RAW_Q(r, R);
+  FP_PACK_RAW_Q (r, R);
   FP_HANDLE_EXCEPTIONS;
 
   return r;

Modified: fsf/trunk/libc/soft-fp/extendxftf2.c
==============================================================================
--- fsf/trunk/libc/soft-fp/extendxftf2.c (original)
+++ fsf/trunk/libc/soft-fp/extendxftf2.c Thu Oct 17 00:01:48 2013
@@ -32,21 +32,21 @@
 #include "quad.h"
 
 TFtype
-__extendxftf2(XFtype a)
+__extendxftf2 (XFtype a)
 {
   FP_DECL_EX;
-  FP_DECL_E(A);
-  FP_DECL_Q(R);
+  FP_DECL_E (A);
+  FP_DECL_Q (R);
   TFtype r;
 
   FP_INIT_ROUNDMODE;
-  FP_UNPACK_RAW_E(A, a);
+  FP_UNPACK_RAW_E (A, a);
 #if (2 * _FP_W_TYPE_SIZE) < _FP_FRACBITS_Q
-  FP_EXTEND(Q,E,4,4,R,A);
+  FP_EXTEND (Q, E, 4, 4, R, A);
 #else
-  FP_EXTEND(Q,E,2,2,R,A);
+  FP_EXTEND (Q, E, 2, 2, R, A);
 #endif
-  FP_PACK_RAW_Q(r, R);
+  FP_PACK_RAW_Q (r, R);
   FP_HANDLE_EXCEPTIONS;
 
   return r;

Modified: fsf/trunk/libc/soft-fp/fixdfdi.c
==============================================================================
--- fsf/trunk/libc/soft-fp/fixdfdi.c (original)
+++ fsf/trunk/libc/soft-fp/fixdfdi.c Thu Oct 17 00:01:48 2013
@@ -32,15 +32,15 @@
 #include "double.h"
 
 DItype
-__fixdfdi(DFtype a)
+__fixdfdi (DFtype a)
 {
   FP_DECL_EX;
-  FP_DECL_D(A);
+  FP_DECL_D (A);
   UDItype r;
 
   FP_INIT_EXCEPTIONS;
-  FP_UNPACK_RAW_D(A, a);
-  FP_TO_INT_D(r, A, DI_BITS, 1);
+  FP_UNPACK_RAW_D (A, a);
+  FP_TO_INT_D (r, A, DI_BITS, 1);
   FP_HANDLE_EXCEPTIONS;
 
   return r;

Modified: fsf/trunk/libc/soft-fp/fixdfsi.c
==============================================================================
--- fsf/trunk/libc/soft-fp/fixdfsi.c (original)
+++ fsf/trunk/libc/soft-fp/fixdfsi.c Thu Oct 17 00:01:48 2013
@@ -32,15 +32,15 @@
 #include "double.h"
 
 SItype
-__fixdfsi(DFtype a)
+__fixdfsi (DFtype a)
 {
   FP_DECL_EX;
-  FP_DECL_D(A);
+  FP_DECL_D (A);
   USItype r;
 
   FP_INIT_EXCEPTIONS;
-  FP_UNPACK_RAW_D(A, a);
-  FP_TO_INT_D(r, A, SI_BITS, 1);
+  FP_UNPACK_RAW_D (A, a);
+  FP_TO_INT_D (r, A, SI_BITS, 1);
   FP_HANDLE_EXCEPTIONS;
 
   return r;

Modified: fsf/trunk/libc/soft-fp/fixdfti.c
==============================================================================
--- fsf/trunk/libc/soft-fp/fixdfti.c (original)
+++ fsf/trunk/libc/soft-fp/fixdfti.c Thu Oct 17 00:01:48 2013
@@ -31,15 +31,15 @@
 #include "double.h"
 
 TItype
-__fixdfti(DFtype a)
+__fixdfti (DFtype a)
 {
   FP_DECL_EX;
-  FP_DECL_D(A);
+  FP_DECL_D (A);
   UTItype r;
 
   FP_INIT_EXCEPTIONS;
-  FP_UNPACK_RAW_D(A, a);
-  FP_TO_INT_D(r, A, TI_BITS, 1);
+  FP_UNPACK_RAW_D (A, a);
+  FP_TO_INT_D (r, A, TI_BITS, 1);
   FP_HANDLE_EXCEPTIONS;
 
   return r;

Modified: fsf/trunk/libc/soft-fp/fixsfdi.c
==============================================================================
--- fsf/trunk/libc/soft-fp/fixsfdi.c (original)
+++ fsf/trunk/libc/soft-fp/fixsfdi.c Thu Oct 17 00:01:48 2013
@@ -32,15 +32,15 @@
 #include "single.h"
 
 DItype
-__fixsfdi(SFtype a)
+__fixsfdi (SFtype a)
 {
   FP_DECL_EX;
-  FP_DECL_S(A);
+  FP_DECL_S (A);
   UDItype r;
 
   FP_INIT_EXCEPTIONS;
-  FP_UNPACK_RAW_S(A, a);
-  FP_TO_INT_S(r, A, DI_BITS, 1);
+  FP_UNPACK_RAW_S (A, a);
+  FP_TO_INT_S (r, A, DI_BITS, 1);
   FP_HANDLE_EXCEPTIONS;
 
   return r;

Modified: fsf/trunk/libc/soft-fp/fixsfsi.c
==============================================================================
--- fsf/trunk/libc/soft-fp/fixsfsi.c (original)
+++ fsf/trunk/libc/soft-fp/fixsfsi.c Thu Oct 17 00:01:48 2013
@@ -32,15 +32,15 @@
 #include "single.h"
 
 SItype
-__fixsfsi(SFtype a)
+__fixsfsi (SFtype a)
 {
   FP_DECL_EX;
-  FP_DECL_S(A);
+  FP_DECL_S (A);
   USItype r;
 
   FP_INIT_EXCEPTIONS;
-  FP_UNPACK_RAW_S(A, a);
-  FP_TO_INT_S(r, A, SI_BITS, 1);
+  FP_UNPACK_RAW_S (A, a);
+  FP_TO_INT_S (r, A, SI_BITS, 1);
   FP_HANDLE_EXCEPTIONS;
 
   return r;

Modified: fsf/trunk/libc/soft-fp/fixsfti.c
==============================================================================
--- fsf/trunk/libc/soft-fp/fixsfti.c (original)
+++ fsf/trunk/libc/soft-fp/fixsfti.c Thu Oct 17 00:01:48 2013
@@ -31,15 +31,15 @@
 #include "single.h"
 
 TItype
-__fixsfti(SFtype a)
+__fixsfti (SFtype a)
 {
   FP_DECL_EX;
-  FP_DECL_S(A);
+  FP_DECL_S (A);
   UTItype r;
 
   FP_INIT_EXCEPTIONS;
-  FP_UNPACK_RAW_S(A, a);
-  FP_TO_INT_S(r, A, TI_BITS, 1);
+  FP_UNPACK_RAW_S (A, a);
+  FP_TO_INT_S (r, A, TI_BITS, 1);
   FP_HANDLE_EXCEPTIONS;
 
   return r;

Modified: fsf/trunk/libc/soft-fp/fixtfdi.c
==============================================================================
--- fsf/trunk/libc/soft-fp/fixtfdi.c (original)
+++ fsf/trunk/libc/soft-fp/fixtfdi.c Thu Oct 17 00:01:48 2013
@@ -32,15 +32,15 @@
 #include "quad.h"
 
 DItype
-__fixtfdi(TFtype a)
+__fixtfdi (TFtype a)
 {
   FP_DECL_EX;
-  FP_DECL_Q(A);
+  FP_DECL_Q (A);
   UDItype r;
 
   FP_INIT_EXCEPTIONS;
-  FP_UNPACK_RAW_Q(A, a);
-  FP_TO_INT_Q(r, A, DI_BITS, 1);
+  FP_UNPACK_RAW_Q (A, a);
+  FP_TO_INT_Q (r, A, DI_BITS, 1);
   FP_HANDLE_EXCEPTIONS;
 
   return r;

Modified: fsf/trunk/libc/soft-fp/fixtfsi.c
==============================================================================
--- fsf/trunk/libc/soft-fp/fixtfsi.c (original)
+++ fsf/trunk/libc/soft-fp/fixtfsi.c Thu Oct 17 00:01:48 2013
@@ -32,15 +32,15 @@
 #include "quad.h"
 
 SItype
-__fixtfsi(TFtype a)
+__fixtfsi (TFtype a)
 {
   FP_DECL_EX;
-  FP_DECL_Q(A);
+  FP_DECL_Q (A);
   USItype r;
 
   FP_INIT_EXCEPTIONS;
-  FP_UNPACK_RAW_Q(A, a);
-  FP_TO_INT_Q(r, A, SI_BITS, 1);
+  FP_UNPACK_RAW_Q (A, a);
+  FP_TO_INT_Q (r, A, SI_BITS, 1);
   FP_HANDLE_EXCEPTIONS;
 
   return r;

Modified: fsf/trunk/libc/soft-fp/fixtfti.c
==============================================================================
--- fsf/trunk/libc/soft-fp/fixtfti.c (original)
+++ fsf/trunk/libc/soft-fp/fixtfti.c Thu Oct 17 00:01:48 2013
@@ -31,15 +31,15 @@
 #include "quad.h"
 
 TItype
-__fixtfti(TFtype a)
+__fixtfti (TFtype a)
 {
   FP_DECL_EX;
-  FP_DECL_Q(A);
+  FP_DECL_Q (A);
   UTItype r;
 
   FP_INIT_EXCEPTIONS;
-  FP_UNPACK_RAW_Q(A, a);
-  FP_TO_INT_Q(r, A, TI_BITS, 1);
+  FP_UNPACK_RAW_Q (A, a);
+  FP_TO_INT_Q (r, A, TI_BITS, 1);
   FP_HANDLE_EXCEPTIONS;
 
   return r;

Modified: fsf/trunk/libc/soft-fp/fixunsdfdi.c
==============================================================================
--- fsf/trunk/libc/soft-fp/fixunsdfdi.c (original)
+++ fsf/trunk/libc/soft-fp/fixunsdfdi.c Thu Oct 17 00:01:48 2013
@@ -32,15 +32,15 @@
 #include "double.h"
 
 UDItype
-__fixunsdfdi(DFtype a)
+__fixunsdfdi (DFtype a)
 {
   FP_DECL_EX;
-  FP_DECL_D(A);
+  FP_DECL_D (A);
   UDItype r;
 
   FP_INIT_EXCEPTIONS;
-  FP_UNPACK_RAW_D(A, a);
-  FP_TO_INT_D(r, A, DI_BITS, 0);
+  FP_UNPACK_RAW_D (A, a);
+  FP_TO_INT_D (r, A, DI_BITS, 0);
   FP_HANDLE_EXCEPTIONS;
 
   return r;

Modified: fsf/trunk/libc/soft-fp/fixunsdfsi.c
==============================================================================
--- fsf/trunk/libc/soft-fp/fixunsdfsi.c (original)
+++ fsf/trunk/libc/soft-fp/fixunsdfsi.c Thu Oct 17 00:01:48 2013
@@ -32,15 +32,15 @@
 #include "double.h"
 
 USItype
-__fixunsdfsi(DFtype a)
+__fixunsdfsi (DFtype a)
 {
   FP_DECL_EX;
-  FP_DECL_D(A);
+  FP_DECL_D (A);
   USItype r;
 
   FP_INIT_EXCEPTIONS;
-  FP_UNPACK_RAW_D(A, a);
-  FP_TO_INT_D(r, A, SI_BITS, 0);
+  FP_UNPACK_RAW_D (A, a);
+  FP_TO_INT_D (r, A, SI_BITS, 0);
   FP_HANDLE_EXCEPTIONS;
 
   return r;

Modified: fsf/trunk/libc/soft-fp/fixunsdfti.c
==============================================================================
--- fsf/trunk/libc/soft-fp/fixunsdfti.c (original)
+++ fsf/trunk/libc/soft-fp/fixunsdfti.c Thu Oct 17 00:01:48 2013
@@ -31,15 +31,15 @@
 #include "double.h"
 
 UTItype
-__fixunsdfti(DFtype a)
+__fixunsdfti (DFtype a)
 {
   FP_DECL_EX;
-  FP_DECL_D(A);
+  FP_DECL_D (A);
   UTItype r;
 
   FP_INIT_EXCEPTIONS;
-  FP_UNPACK_RAW_D(A, a);
-  FP_TO_INT_D(r, A, TI_BITS, 0);
+  FP_UNPACK_RAW_D (A, a);
+  FP_TO_INT_D (r, A, TI_BITS, 0);
   FP_HANDLE_EXCEPTIONS;
 
   return r;

Modified: fsf/trunk/libc/soft-fp/fixunssfdi.c
==============================================================================
--- fsf/trunk/libc/soft-fp/fixunssfdi.c (original)
+++ fsf/trunk/libc/soft-fp/fixunssfdi.c Thu Oct 17 00:01:48 2013
@@ -32,15 +32,15 @@
 #include "single.h"
 
 UDItype
-__fixunssfdi(SFtype a)
+__fixunssfdi (SFtype a)
 {
   FP_DECL_EX;
-  FP_DECL_S(A);
+  FP_DECL_S (A);
   UDItype r;
 
   FP_INIT_EXCEPTIONS;
-  FP_UNPACK_RAW_S(A, a);
-  FP_TO_INT_S(r, A, DI_BITS, 0);
+  FP_UNPACK_RAW_S (A, a);
+  FP_TO_INT_S (r, A, DI_BITS, 0);
   FP_HANDLE_EXCEPTIONS;
 
   return r;

Modified: fsf/trunk/libc/soft-fp/fixunssfsi.c
==============================================================================
--- fsf/trunk/libc/soft-fp/fixunssfsi.c (original)
+++ fsf/trunk/libc/soft-fp/fixunssfsi.c Thu Oct 17 00:01:48 2013
@@ -32,15 +32,15 @@
 #include "single.h"
 
 USItype
-__fixunssfsi(SFtype a)
+__fixunssfsi (SFtype a)
 {
   FP_DECL_EX;
-  FP_DECL_S(A);
+  FP_DECL_S (A);
   USItype r;
 
   FP_INIT_EXCEPTIONS;
-  FP_UNPACK_RAW_S(A, a);
-  FP_TO_INT_S(r, A, SI_BITS, 0);
+  FP_UNPACK_RAW_S (A, a);
+  FP_TO_INT_S (r, A, SI_BITS, 0);
   FP_HANDLE_EXCEPTIONS;
 
   return r;

Modified: fsf/trunk/libc/soft-fp/fixunssfti.c
==============================================================================
--- fsf/trunk/libc/soft-fp/fixunssfti.c (original)
+++ fsf/trunk/libc/soft-fp/fixunssfti.c Thu Oct 17 00:01:48 2013
@@ -31,15 +31,15 @@
 #include "single.h"
 
 UTItype
-__fixunssfti(SFtype a)
+__fixunssfti (SFtype a)
 {
   FP_DECL_EX;
-  FP_DECL_S(A);
+  FP_DECL_S (A);
   UTItype r;
 
   FP_INIT_EXCEPTIONS;
-  FP_UNPACK_RAW_S(A, a);
-  FP_TO_INT_S(r, A, TI_BITS, 0);
+  FP_UNPACK_RAW_S (A, a);
+  FP_TO_INT_S (r, A, TI_BITS, 0);
   FP_HANDLE_EXCEPTIONS;
 
   return r;

Modified: fsf/trunk/libc/soft-fp/fixunstfdi.c
==============================================================================
--- fsf/trunk/libc/soft-fp/fixunstfdi.c (original)
+++ fsf/trunk/libc/soft-fp/fixunstfdi.c Thu Oct 17 00:01:48 2013
@@ -32,15 +32,15 @@
 #include "quad.h"
 
 UDItype
-__fixunstfdi(TFtype a)
+__fixunstfdi (TFtype a)
 {
   FP_DECL_EX;
-  FP_DECL_Q(A);
+  FP_DECL_Q (A);
   UDItype r;
 
   FP_INIT_EXCEPTIONS;
-  FP_UNPACK_RAW_Q(A, a);
-  FP_TO_INT_Q(r, A, DI_BITS, 0);
+  FP_UNPACK_RAW_Q (A, a);
+  FP_TO_INT_Q (r, A, DI_BITS, 0);
   FP_HANDLE_EXCEPTIONS;
 
   return r;

Modified: fsf/trunk/libc/soft-fp/fixunstfsi.c
==============================================================================
--- fsf/trunk/libc/soft-fp/fixunstfsi.c (original)
+++ fsf/trunk/libc/soft-fp/fixunstfsi.c Thu Oct 17 00:01:48 2013
@@ -32,15 +32,15 @@
 #include "quad.h"
 
 USItype
-__fixunstfsi(TFtype a)
+__fixunstfsi (TFtype a)
 {
   FP_DECL_EX;
-  FP_DECL_Q(A);
+  FP_DECL_Q (A);
   USItype r;
 
   FP_INIT_EXCEPTIONS;
-  FP_UNPACK_RAW_Q(A, a);
-  FP_TO_INT_Q(r, A, SI_BITS, 0);
+  FP_UNPACK_RAW_Q (A, a);
+  FP_TO_INT_Q (r, A, SI_BITS, 0);
   FP_HANDLE_EXCEPTIONS;
 
   return r;

Modified: fsf/trunk/libc/soft-fp/fixunstfti.c
==============================================================================
--- fsf/trunk/libc/soft-fp/fixunstfti.c (original)
+++ fsf/trunk/libc/soft-fp/fixunstfti.c Thu Oct 17 00:01:48 2013
@@ -31,15 +31,15 @@
 #include "quad.h"
 
 UTItype
-__fixunstfti(TFtype a)
+__fixunstfti (TFtype a)
 {
   FP_DECL_EX;
-  FP_DECL_Q(A);
+  FP_DECL_Q (A);
   UTItype r;
 
   FP_INIT_EXCEPTIONS;
-  FP_UNPACK_RAW_Q(A, a);
-  FP_TO_INT_Q(r, A, TI_BITS, 0);
+  FP_UNPACK_RAW_Q (A, a);
+  FP_TO_INT_Q (r, A, TI_BITS, 0);
   FP_HANDLE_EXCEPTIONS;
 
   return r;

Modified: fsf/trunk/libc/soft-fp/floatdidf.c
==============================================================================
--- fsf/trunk/libc/soft-fp/floatdidf.c (original)
+++ fsf/trunk/libc/soft-fp/floatdidf.c Thu Oct 17 00:01:48 2013
@@ -32,15 +32,15 @@
 #include "double.h"
 
 DFtype
-__floatdidf(DItype i)
+__floatdidf (DItype i)
 {
   FP_DECL_EX;
-  FP_DECL_D(A);
+  FP_DECL_D (A);
   DFtype a;
 
   FP_INIT_ROUNDMODE;
-  FP_FROM_INT_D(A, i, DI_BITS, UDItype);
-  FP_PACK_RAW_D(a, A);
+  FP_FROM_INT_D (A, i, DI_BITS, UDItype);
+  FP_PACK_RAW_D (a, A);
   FP_HANDLE_EXCEPTIONS;
 
   return a;

Modified: fsf/trunk/libc/soft-fp/floatdisf.c
==============================================================================
--- fsf/trunk/libc/soft-fp/floatdisf.c (original)
+++ fsf/trunk/libc/soft-fp/floatdisf.c Thu Oct 17 00:01:48 2013
@@ -32,15 +32,15 @@
 #include "single.h"
 
 SFtype
-__floatdisf(DItype i)
+__floatdisf (DItype i)
 {
   FP_DECL_EX;
-  FP_DECL_S(A);
+  FP_DECL_S (A);
   SFtype a;
 
   FP_INIT_ROUNDMODE;
-  FP_FROM_INT_S(A, i, DI_BITS, UDItype);
-  FP_PACK_RAW_S(a, A);
+  FP_FROM_INT_S (A, i, DI_BITS, UDItype);
+  FP_PACK_RAW_S (a, A);
   FP_HANDLE_EXCEPTIONS;
 
   return a;

Modified: fsf/trunk/libc/soft-fp/floatditf.c
==============================================================================
--- fsf/trunk/libc/soft-fp/floatditf.c (original)
+++ fsf/trunk/libc/soft-fp/floatditf.c Thu Oct 17 00:01:48 2013
@@ -33,13 +33,13 @@
 #include "quad.h"
 
 TFtype
-__floatditf(DItype i)
+__floatditf (DItype i)
 {
-  FP_DECL_Q(A);
+  FP_DECL_Q (A);
   TFtype a;
 
-  FP_FROM_INT_Q(A, i, DI_BITS, UDItype);
-  FP_PACK_RAW_Q(a, A);
+  FP_FROM_INT_Q (A, i, DI_BITS, UDItype);
+  FP_PACK_RAW_Q (a, A);
 
   return a;
 }

Modified: fsf/trunk/libc/soft-fp/floatsidf.c
==============================================================================
--- fsf/trunk/libc/soft-fp/floatsidf.c (original)
+++ fsf/trunk/libc/soft-fp/floatsidf.c Thu Oct 17 00:01:48 2013
@@ -33,13 +33,13 @@
 #include "double.h"
 
 DFtype
-__floatsidf(SItype i)
+__floatsidf (SItype i)
 {
-  FP_DECL_D(A);
+  FP_DECL_D (A);
   DFtype a;
 
-  FP_FROM_INT_D(A, i, SI_BITS, USItype);
-  FP_PACK_RAW_D(a, A);
+  FP_FROM_INT_D (A, i, SI_BITS, USItype);
+  FP_PACK_RAW_D (a, A);
 
   return a;
 }

Modified: fsf/trunk/libc/soft-fp/floatsisf.c
==============================================================================
--- fsf/trunk/libc/soft-fp/floatsisf.c (original)
+++ fsf/trunk/libc/soft-fp/floatsisf.c Thu Oct 17 00:01:48 2013
@@ -32,15 +32,15 @@
 #include "single.h"
 
 SFtype
-__floatsisf(SItype i)
+__floatsisf (SItype i)
 {
   FP_DECL_EX;
-  FP_DECL_S(A);
+  FP_DECL_S (A);
   SFtype a;
 
   FP_INIT_ROUNDMODE;
-  FP_FROM_INT_S(A, i, SI_BITS, USItype);
-  FP_PACK_RAW_S(a, A);
+  FP_FROM_INT_S (A, i, SI_BITS, USItype);
+  FP_PACK_RAW_S (a, A);
   FP_HANDLE_EXCEPTIONS;
 
   return a;

Modified: fsf/trunk/libc/soft-fp/floatsitf.c
==============================================================================
--- fsf/trunk/libc/soft-fp/floatsitf.c (original)
+++ fsf/trunk/libc/soft-fp/floatsitf.c Thu Oct 17 00:01:48 2013
@@ -33,13 +33,13 @@
 #include "quad.h"
 
 TFtype
-__floatsitf(SItype i)
+__floatsitf (SItype i)
 {
-  FP_DECL_Q(A);
+  FP_DECL_Q (A);
   TFtype a;
 
-  FP_FROM_INT_Q(A, i, SI_BITS, USItype);
-  FP_PACK_RAW_Q(a, A);
+  FP_FROM_INT_Q (A, i, SI_BITS, USItype);
+  FP_PACK_RAW_Q (a, A);
 
   return a;
 }

Modified: fsf/trunk/libc/soft-fp/floattidf.c
==============================================================================
--- fsf/trunk/libc/soft-fp/floattidf.c (original)
+++ fsf/trunk/libc/soft-fp/floattidf.c Thu Oct 17 00:01:48 2013
@@ -31,15 +31,15 @@
 #include "double.h"
 
 DFtype
-__floattidf(TItype i)
+__floattidf (TItype i)
 {
   FP_DECL_EX;
-  FP_DECL_D(A);
+  FP_DECL_D (A);
   DFtype a;
 
   FP_INIT_ROUNDMODE;
-  FP_FROM_INT_D(A, i, TI_BITS, UTItype);
-  FP_PACK_RAW_D(a, A);
+  FP_FROM_INT_D (A, i, TI_BITS, UTItype);
+  FP_PACK_RAW_D (a, A);
   FP_HANDLE_EXCEPTIONS;
 
   return a;

Modified: fsf/trunk/libc/soft-fp/floattisf.c
==============================================================================
--- fsf/trunk/libc/soft-fp/floattisf.c (original)
+++ fsf/trunk/libc/soft-fp/floattisf.c Thu Oct 17 00:01:48 2013
@@ -31,15 +31,15 @@
 #include "single.h"
 
 SFtype
-__floattisf(TItype i)
+__floattisf (TItype i)
 {
   FP_DECL_EX;
-  FP_DECL_S(A);
+  FP_DECL_S (A);
   SFtype a;
 
   FP_INIT_ROUNDMODE;
-  FP_FROM_INT_S(A, i, TI_BITS, UTItype);
-  FP_PACK_RAW_S(a, A);
+  FP_FROM_INT_S (A, i, TI_BITS, UTItype);
+  FP_PACK_RAW_S (a, A);
   FP_HANDLE_EXCEPTIONS;
 
   return a;

Modified: fsf/trunk/libc/soft-fp/floattitf.c
==============================================================================
--- fsf/trunk/libc/soft-fp/floattitf.c (original)
+++ fsf/trunk/libc/soft-fp/floattitf.c Thu Oct 17 00:01:48 2013
@@ -31,15 +31,15 @@
 #include "quad.h"
 
 TFtype
-__floattitf(TItype i)
+__floattitf (TItype i)
 {
   FP_DECL_EX;
-  FP_DECL_Q(A);
+  FP_DECL_Q (A);
   TFtype a;
 
   FP_INIT_ROUNDMODE;
-  FP_FROM_INT_Q(A, i, TI_BITS, UTItype);
-  FP_PACK_RAW_Q(a, A);
+  FP_FROM_INT_Q (A, i, TI_BITS, UTItype);
+  FP_PACK_RAW_Q (a, A);
   FP_HANDLE_EXCEPTIONS;
 
   return a;

Modified: fsf/trunk/libc/soft-fp/floatundidf.c
==============================================================================
--- fsf/trunk/libc/soft-fp/floatundidf.c (original)
+++ fsf/trunk/libc/soft-fp/floatundidf.c Thu Oct 17 00:01:48 2013
@@ -32,15 +32,15 @@
 #include "double.h"
 
 DFtype
-__floatundidf(UDItype i)
+__floatundidf (UDItype i)
 {
   FP_DECL_EX;
-  FP_DECL_D(A);
+  FP_DECL_D (A);
   DFtype a;
 
   FP_INIT_ROUNDMODE;
-  FP_FROM_INT_D(A, i, DI_BITS, UDItype);
-  FP_PACK_RAW_D(a, A);
+  FP_FROM_INT_D (A, i, DI_BITS, UDItype);
+  FP_PACK_RAW_D (a, A);
   FP_HANDLE_EXCEPTIONS;
 
   return a;

Modified: fsf/trunk/libc/soft-fp/floatundisf.c
==============================================================================
--- fsf/trunk/libc/soft-fp/floatundisf.c (original)
+++ fsf/trunk/libc/soft-fp/floatundisf.c Thu Oct 17 00:01:48 2013
@@ -32,15 +32,15 @@
 #include "single.h"
 
 SFtype
-__floatundisf(UDItype i)
+__floatundisf (UDItype i)
 {
   FP_DECL_EX;
-  FP_DECL_S(A);
+  FP_DECL_S (A);
   SFtype a;
 
   FP_INIT_ROUNDMODE;
-  FP_FROM_INT_S(A, i, DI_BITS, UDItype);
-  FP_PACK_RAW_S(a, A);
+  FP_FROM_INT_S (A, i, DI_BITS, UDItype);
+  FP_PACK_RAW_S (a, A);
   FP_HANDLE_EXCEPTIONS;
 
   return a;

Modified: fsf/trunk/libc/soft-fp/floatunditf.c
==============================================================================
--- fsf/trunk/libc/soft-fp/floatunditf.c (original)
+++ fsf/trunk/libc/soft-fp/floatunditf.c Thu Oct 17 00:01:48 2013
@@ -33,13 +33,13 @@
 #include "quad.h"
 
 TFtype
-__floatunditf(UDItype i)
+__floatunditf (UDItype i)
 {
-  FP_DECL_Q(A);
+  FP_DECL_Q (A);
   TFtype a;
 
-  FP_FROM_INT_Q(A, i, DI_BITS, UDItype);
-  FP_PACK_RAW_Q(a, A);
+  FP_FROM_INT_Q (A, i, DI_BITS, UDItype);
+  FP_PACK_RAW_Q (a, A);
 
   return a;
 }

Modified: fsf/trunk/libc/soft-fp/floatunsidf.c
==============================================================================
--- fsf/trunk/libc/soft-fp/floatunsidf.c (original)
+++ fsf/trunk/libc/soft-fp/floatunsidf.c Thu Oct 17 00:01:48 2013
@@ -33,13 +33,13 @@
 #include "double.h"
 
 DFtype
-__floatunsidf(USItype i)
+__floatunsidf (USItype i)
 {
-  FP_DECL_D(A);
+  FP_DECL_D (A);
   DFtype a;
 
-  FP_FROM_INT_D(A, i, SI_BITS, USItype);
-  FP_PACK_RAW_D(a, A);
+  FP_FROM_INT_D (A, i, SI_BITS, USItype);
+  FP_PACK_RAW_D (a, A);
 
   return a;
 }

Modified: fsf/trunk/libc/soft-fp/floatunsisf.c
==============================================================================
--- fsf/trunk/libc/soft-fp/floatunsisf.c (original)
+++ fsf/trunk/libc/soft-fp/floatunsisf.c Thu Oct 17 00:01:48 2013
@@ -32,15 +32,15 @@
 #include "single.h"
 
 SFtype
-__floatunsisf(USItype i)
+__floatunsisf (USItype i)
 {
   FP_DECL_EX;
-  FP_DECL_S(A);
+  FP_DECL_S (A);
   SFtype a;
 
   FP_INIT_ROUNDMODE;
-  FP_FROM_INT_S(A, i, SI_BITS, USItype);
-  FP_PACK_RAW_S(a, A);
+  FP_FROM_INT_S (A, i, SI_BITS, USItype);
+  FP_PACK_RAW_S (a, A);
   FP_HANDLE_EXCEPTIONS;
 
   return a;

Modified: fsf/trunk/libc/soft-fp/floatunsitf.c
==============================================================================
--- fsf/trunk/libc/soft-fp/floatunsitf.c (original)
+++ fsf/trunk/libc/soft-fp/floatunsitf.c Thu Oct 17 00:01:48 2013
@@ -33,13 +33,13 @@
 #include "quad.h"
 
 TFtype
-__floatunsitf(USItype i)
+__floatunsitf (USItype i)
 {
-  FP_DECL_Q(A);
+  FP_DECL_Q (A);
   TFtype a;
 
-  FP_FROM_INT_Q(A, i, SI_BITS, USItype);
-  FP_PACK_RAW_Q(a, A);
+  FP_FROM_INT_Q (A, i, SI_BITS, USItype);
+  FP_PACK_RAW_Q (a, A);
 
   return a;
 }

Modified: fsf/trunk/libc/soft-fp/floatuntidf.c
==============================================================================
--- fsf/trunk/libc/soft-fp/floatuntidf.c (original)
+++ fsf/trunk/libc/soft-fp/floatuntidf.c Thu Oct 17 00:01:48 2013
@@ -31,15 +31,15 @@
 #include "double.h"
 
 DFtype
-__floatuntidf(UTItype i)
+__floatuntidf (UTItype i)
 {
   FP_DECL_EX;
-  FP_DECL_D(A);
+  FP_DECL_D (A);
   DFtype a;
 
   FP_INIT_ROUNDMODE;
-  FP_FROM_INT_D(A, i, TI_BITS, UTItype);
-  FP_PACK_RAW_D(a, A);
+  FP_FROM_INT_D (A, i, TI_BITS, UTItype);
+  FP_PACK_RAW_D (a, A);
   FP_HANDLE_EXCEPTIONS;
 
   return a;

Modified: fsf/trunk/libc/soft-fp/floatuntisf.c
==============================================================================
--- fsf/trunk/libc/soft-fp/floatuntisf.c (original)
+++ fsf/trunk/libc/soft-fp/floatuntisf.c Thu Oct 17 00:01:48 2013
@@ -31,15 +31,15 @@
 #include "single.h"
 
 SFtype
-__floatuntisf(UTItype i)
+__floatuntisf (UTItype i)
 {
   FP_DECL_EX;
-  FP_DECL_S(A);
+  FP_DECL_S (A);
   SFtype a;
 
   FP_INIT_ROUNDMODE;
-  FP_FROM_INT_S(A, i, TI_BITS, UTItype);
-  FP_PACK_RAW_S(a, A);
+  FP_FROM_INT_S (A, i, TI_BITS, UTItype);
+  FP_PACK_RAW_S (a, A);
   FP_HANDLE_EXCEPTIONS;
 
   return a;

Modified: fsf/trunk/libc/soft-fp/floatuntitf.c
==============================================================================
--- fsf/trunk/libc/soft-fp/floatuntitf.c (original)
+++ fsf/trunk/libc/soft-fp/floatuntitf.c Thu Oct 17 00:01:48 2013
@@ -31,15 +31,15 @@
 #include "quad.h"
 
 TFtype
-__floatuntitf(UTItype i)
+__floatuntitf (UTItype i)
 {
   FP_DECL_EX;
-  FP_DECL_Q(A);
+  FP_DECL_Q (A);
   TFtype a;
 
   FP_INIT_ROUNDMODE;
-  FP_FROM_INT_Q(A, i, TI_BITS, UTItype);
-  FP_PACK_RAW_Q(a, A);
+  FP_FROM_INT_Q (A, i, TI_BITS, UTItype);
+  FP_PACK_RAW_Q (a, A);
   FP_HANDLE_EXCEPTIONS;
 
   return a;

Modified: fsf/trunk/libc/soft-fp/fmadf4.c
==============================================================================
--- fsf/trunk/libc/soft-fp/fmadf4.c (original)
+++ fsf/trunk/libc/soft-fp/fmadf4.c Thu Oct 17 00:01:48 2013
@@ -33,18 +33,18 @@
 __fma (double a, double b, double c)
 {
   FP_DECL_EX;
-  FP_DECL_D(A);
-  FP_DECL_D(B);
-  FP_DECL_D(C);
-  FP_DECL_D(R);
+  FP_DECL_D (A);
+  FP_DECL_D (B);
+  FP_DECL_D (C);
+  FP_DECL_D (R);
   double r;
 
   FP_INIT_ROUNDMODE;
-  FP_UNPACK_D(A, a);
-  FP_UNPACK_D(B, b);
-  FP_UNPACK_D(C, c);
-  FP_FMA_D(R, A, B, C);
-  FP_PACK_D(r, R);
+  FP_UNPACK_D (A, a);
+  FP_UNPACK_D (B, b);
+  FP_UNPACK_D (C, c);
+  FP_FMA_D (R, A, B, C);
+  FP_PACK_D (r, R);
   FP_HANDLE_EXCEPTIONS;
 
   return r;

Modified: fsf/trunk/libc/soft-fp/fmasf4.c
==============================================================================
--- fsf/trunk/libc/soft-fp/fmasf4.c (original)
+++ fsf/trunk/libc/soft-fp/fmasf4.c Thu Oct 17 00:01:48 2013
@@ -33,18 +33,18 @@
 __fmaf (float a, float b, float c)
 {
   FP_DECL_EX;
-  FP_DECL_S(A);
-  FP_DECL_S(B);
-  FP_DECL_S(C);
-  FP_DECL_S(R);
+  FP_DECL_S (A);
+  FP_DECL_S (B);
+  FP_DECL_S (C);
+  FP_DECL_S (R);
   float r;
 
   FP_INIT_ROUNDMODE;
-  FP_UNPACK_S(A, a);
-  FP_UNPACK_S(B, b);
-  FP_UNPACK_S(C, c);
-  FP_FMA_S(R, A, B, C);
-  FP_PACK_S(r, R);
+  FP_UNPACK_S (A, a);
+  FP_UNPACK_S (B, b);
+  FP_UNPACK_S (C, c);
+  FP_FMA_S (R, A, B, C);
+  FP_PACK_S (r, R);
   FP_HANDLE_EXCEPTIONS;
 
   return r;

Modified: fsf/trunk/libc/soft-fp/fmatf4.c
==============================================================================
--- fsf/trunk/libc/soft-fp/fmatf4.c (original)
+++ fsf/trunk/libc/soft-fp/fmatf4.c Thu Oct 17 00:01:48 2013
@@ -33,18 +33,18 @@
 __fmal (long double a, long double b, long double c)
 {
   FP_DECL_EX;
-  FP_DECL_Q(A);
-  FP_DECL_Q(B);
-  FP_DECL_Q(C);
-  FP_DECL_Q(R);
+  FP_DECL_Q (A);
+  FP_DECL_Q (B);
+  FP_DECL_Q (C);
+  FP_DECL_Q (R);
   long double r;
 
   FP_INIT_ROUNDMODE;
-  FP_UNPACK_Q(A, a);
-  FP_UNPACK_Q(B, b);
-  FP_UNPACK_Q(C, c);
-  FP_FMA_Q(R, A, B, C);
-  FP_PACK_Q(r, R);
+  FP_UNPACK_Q (A, a);
+  FP_UNPACK_Q (B, b);
+  FP_UNPACK_Q (C, c);
+  FP_FMA_Q (R, A, B, C);
+  FP_PACK_Q (r, R);
   FP_HANDLE_EXCEPTIONS;
 
   return r;

Modified: fsf/trunk/libc/soft-fp/gedf2.c
==============================================================================
--- fsf/trunk/libc/soft-fp/gedf2.c (original)
+++ fsf/trunk/libc/soft-fp/gedf2.c Thu Oct 17 00:01:48 2013
@@ -32,22 +32,22 @@
 #include "double.h"
 
 CMPtype
-__gedf2(DFtype a, DFtype b)
+__gedf2 (DFtype a, DFtype b)
 {
   FP_DECL_EX;
-  FP_DECL_D(A);
-  FP_DECL_D(B);
+  FP_DECL_D (A);
+  FP_DECL_D (B);
   CMPtype r;
 
   FP_INIT_EXCEPTIONS;
-  FP_UNPACK_RAW_D(A, a);
-  FP_UNPACK_RAW_D(B, b);
-  FP_CMP_D(r, A, B, -2);
+  FP_UNPACK_RAW_D (A, a);
+  FP_UNPACK_RAW_D (B, b);
+  FP_CMP_D (r, A, B, -2);
   if (r == -2)
-    FP_SET_EXCEPTION(FP_EX_INVALID);
+    FP_SET_EXCEPTION (FP_EX_INVALID);
   FP_HANDLE_EXCEPTIONS;
 
   return r;
 }
 
-strong_alias(__gedf2, __gtdf2);
+strong_alias (__gedf2, __gtdf2);

Modified: fsf/trunk/libc/soft-fp/gesf2.c
==============================================================================
--- fsf/trunk/libc/soft-fp/gesf2.c (original)
+++ fsf/trunk/libc/soft-fp/gesf2.c Thu Oct 17 00:01:48 2013
@@ -32,22 +32,22 @@
 #include "single.h"
 
 CMPtype
-__gesf2(SFtype a, SFtype b)
+__gesf2 (SFtype a, SFtype b)
 {
   FP_DECL_EX;
-  FP_DECL_S(A);
-  FP_DECL_S(B);
+  FP_DECL_S (A);
+  FP_DECL_S (B);
   CMPtype r;
 
   FP_INIT_EXCEPTIONS;
-  FP_UNPACK_RAW_S(A, a);
-  FP_UNPACK_RAW_S(B, b);
-  FP_CMP_S(r, A, B, -2);
+  FP_UNPACK_RAW_S (A, a);
+  FP_UNPACK_RAW_S (B, b);
+  FP_CMP_S (r, A, B, -2);
   if (r == -2)
-    FP_SET_EXCEPTION(FP_EX_INVALID);
+    FP_SET_EXCEPTION (FP_EX_INVALID);
   FP_HANDLE_EXCEPTIONS;
 
   return r;
 }
 
-strong_alias(__gesf2, __gtsf2);
+strong_alias (__gesf2, __gtsf2);

Modified: fsf/trunk/libc/soft-fp/getf2.c
==============================================================================
--- fsf/trunk/libc/soft-fp/getf2.c (original)
+++ fsf/trunk/libc/soft-fp/getf2.c Thu Oct 17 00:01:48 2013
@@ -32,22 +32,22 @@
 #include "quad.h"
 
 CMPtype
-__getf2(TFtype a, TFtype b)
+__getf2 (TFtype a, TFtype b)
 {
   FP_DECL_EX;
-  FP_DECL_Q(A);
-  FP_DECL_Q(B);
+  FP_DECL_Q (A);
+  FP_DECL_Q (B);
   CMPtype r;
 
   FP_INIT_EXCEPTIONS;
-  FP_UNPACK_RAW_Q(A, a);
-  FP_UNPACK_RAW_Q(B, b);
-  FP_CMP_Q(r, A, B, -2);
+  FP_UNPACK_RAW_Q (A, a);
+  FP_UNPACK_RAW_Q (B, b);
+  FP_CMP_Q (r, A, B, -2);
   if (r == -2)
-    FP_SET_EXCEPTION(FP_EX_INVALID);
+    FP_SET_EXCEPTION (FP_EX_INVALID);
   FP_HANDLE_EXCEPTIONS;
 
   return r;
 }
 
-strong_alias(__getf2, __gttf2);
+strong_alias (__getf2, __gttf2);

Modified: fsf/trunk/libc/soft-fp/ledf2.c
==============================================================================
--- fsf/trunk/libc/soft-fp/ledf2.c (original)
+++ fsf/trunk/libc/soft-fp/ledf2.c Thu Oct 17 00:01:48 2013
@@ -32,22 +32,22 @@
 #include "double.h"
 
 CMPtype
-__ledf2(DFtype a, DFtype b)
+__ledf2 (DFtype a, DFtype b)
 {
   FP_DECL_EX;
-  FP_DECL_D(A);
-  FP_DECL_D(B);
+  FP_DECL_D (A);
+  FP_DECL_D (B);
   CMPtype r;
 
   FP_INIT_EXCEPTIONS;
-  FP_UNPACK_RAW_D(A, a);
-  FP_UNPACK_RAW_D(B, b);
-  FP_CMP_D(r, A, B, 2);
+  FP_UNPACK_RAW_D (A, a);
+  FP_UNPACK_RAW_D (B, b);
+  FP_CMP_D (r, A, B, 2);
   if (r == 2)
-    FP_SET_EXCEPTION(FP_EX_INVALID);
+    FP_SET_EXCEPTION (FP_EX_INVALID);
   FP_HANDLE_EXCEPTIONS;
 
   return r;
 }
 
-strong_alias(__ledf2, __ltdf2);
+strong_alias (__ledf2, __ltdf2);

Modified: fsf/trunk/libc/soft-fp/lesf2.c
==============================================================================
--- fsf/trunk/libc/soft-fp/lesf2.c (original)
+++ fsf/trunk/libc/soft-fp/lesf2.c Thu Oct 17 00:01:48 2013
@@ -32,22 +32,22 @@
 #include "single.h"
 
 CMPtype
-__lesf2(SFtype a, SFtype b)
+__lesf2 (SFtype a, SFtype b)
 {
   FP_DECL_EX;
-  FP_DECL_S(A);
-  FP_DECL_S(B);
+  FP_DECL_S (A);
+  FP_DECL_S (B);
   CMPtype r;
 
   FP_INIT_EXCEPTIONS;
-  FP_UNPACK_RAW_S(A, a);
-  FP_UNPACK_RAW_S(B, b);
-  FP_CMP_S(r, A, B, 2);
+  FP_UNPACK_RAW_S (A, a);
+  FP_UNPACK_RAW_S (B, b);
+  FP_CMP_S (r, A, B, 2);
   if (r == 2)
-    FP_SET_EXCEPTION(FP_EX_INVALID);
+    FP_SET_EXCEPTION (FP_EX_INVALID);
   FP_HANDLE_EXCEPTIONS;
 
   return r;
 }
 
-strong_alias(__lesf2, __ltsf2);
+strong_alias (__lesf2, __ltsf2);

Modified: fsf/trunk/libc/soft-fp/letf2.c
==============================================================================
--- fsf/trunk/libc/soft-fp/letf2.c (original)
+++ fsf/trunk/libc/soft-fp/letf2.c Thu Oct 17 00:01:48 2013
@@ -32,22 +32,22 @@
 #include "quad.h"
 
 CMPtype
-__letf2(TFtype a, TFtype b)
+__letf2 (TFtype a, TFtype b)
 {
   FP_DECL_EX;
-  FP_DECL_Q(A);
-  FP_DECL_Q(B);
+  FP_DECL_Q (A);
+  FP_DECL_Q (B);
   CMPtype r;
 
   FP_INIT_EXCEPTIONS;
-  FP_UNPACK_RAW_Q(A, a);
-  FP_UNPACK_RAW_Q(B, b);
-  FP_CMP_Q(r, A, B, 2);
+  FP_UNPACK_RAW_Q (A, a);
+  FP_UNPACK_RAW_Q (B, b);
+  FP_CMP_Q (r, A, B, 2);
   if (r == 2)
-    FP_SET_EXCEPTION(FP_EX_INVALID);
+    FP_SET_EXCEPTION (FP_EX_INVALID);
   FP_HANDLE_EXCEPTIONS;
 
   return r;
 }
 
-strong_alias(__letf2, __lttf2);
+strong_alias (__letf2, __lttf2);

Modified: fsf/trunk/libc/soft-fp/muldf3.c
==============================================================================
--- fsf/trunk/libc/soft-fp/muldf3.c (original)
+++ fsf/trunk/libc/soft-fp/muldf3.c Thu Oct 17 00:01:48 2013
@@ -32,19 +32,19 @@
 #include "double.h"
 
 DFtype
-__muldf3(DFtype a, DFtype b)
+__muldf3 (DFtype a, DFtype b)
 {
   FP_DECL_EX;
-  FP_DECL_D(A);
-  FP_DECL_D(B);
-  FP_DECL_D(R);
+  FP_DECL_D (A);
+  FP_DECL_D (B);
+  FP_DECL_D (R);
   DFtype r;
 
   FP_INIT_ROUNDMODE;
-  FP_UNPACK_D(A, a);
-  FP_UNPACK_D(B, b);
-  FP_MUL_D(R, A, B);
-  FP_PACK_D(r, R);
+  FP_UNPACK_D (A, a);
+  FP_UNPACK_D (B, b);
+  FP_MUL_D (R, A, B);
+  FP_PACK_D (r, R);
   FP_HANDLE_EXCEPTIONS;
 
   return r;

Modified: fsf/trunk/libc/soft-fp/mulsf3.c
==============================================================================
--- fsf/trunk/libc/soft-fp/mulsf3.c (original)
+++ fsf/trunk/libc/soft-fp/mulsf3.c Thu Oct 17 00:01:48 2013
@@ -32,19 +32,19 @@
 #include "single.h"
 
 SFtype
-__mulsf3(SFtype a, SFtype b)
+__mulsf3 (SFtype a, SFtype b)
 {
   FP_DECL_EX;
-  FP_DECL_S(A);
-  FP_DECL_S(B);
-  FP_DECL_S(R);
+  FP_DECL_S (A);
+  FP_DECL_S (B);
+  FP_DECL_S (R);
   SFtype r;
 
   FP_INIT_ROUNDMODE;
-  FP_UNPACK_S(A, a);
-  FP_UNPACK_S(B, b);
-  FP_MUL_S(R, A, B);
-  FP_PACK_S(r, R);
+  FP_UNPACK_S (A, a);
+  FP_UNPACK_S (B, b);
+  FP_MUL_S (R, A, B);
+  FP_PACK_S (r, R);
   FP_HANDLE_EXCEPTIONS;
 
   return r;

Modified: fsf/trunk/libc/soft-fp/multf3.c
==============================================================================
--- fsf/trunk/libc/soft-fp/multf3.c (original)
+++ fsf/trunk/libc/soft-fp/multf3.c Thu Oct 17 00:01:48 2013
@@ -32,19 +32,19 @@
 #include "quad.h"
 
 TFtype
-__multf3(TFtype a, TFtype b)
+__multf3 (TFtype a, TFtype b)
 {
   FP_DECL_EX;
-  FP_DECL_Q(A);
-  FP_DECL_Q(B);
-  FP_DECL_Q(R);
+  FP_DECL_Q (A);
+  FP_DECL_Q (B);
+  FP_DECL_Q (R);
   TFtype r;
 
   FP_INIT_ROUNDMODE;
-  FP_UNPACK_Q(A, a);
-  FP_UNPACK_Q(B, b);
-  FP_MUL_Q(R, A, B);
-  FP_PACK_Q(r, R);
+  FP_UNPACK_Q (A, a);
+  FP_UNPACK_Q (B, b);
+  FP_MUL_Q (R, A, B);
+  FP_PACK_Q (r, R);
   FP_HANDLE_EXCEPTIONS;
 
   return r;

Modified: fsf/trunk/libc/soft-fp/negdf2.c
==============================================================================
--- fsf/trunk/libc/soft-fp/negdf2.c (original)
+++ fsf/trunk/libc/soft-fp/negdf2.c Thu Oct 17 00:01:48 2013
@@ -32,15 +32,15 @@
 #include "double.h"
 
 DFtype
-__negdf2(DFtype a)
+__negdf2 (DFtype a)
 {
-  FP_DECL_D(A);
-  FP_DECL_D(R);
+  FP_DECL_D (A);
+  FP_DECL_D (R);
   DFtype r;
 
-  FP_UNPACK_RAW_D(A, a);
-  FP_NEG_D(R, A);
-  FP_PACK_RAW_D(r, R);
+  FP_UNPACK_RAW_D (A, a);
+  FP_NEG_D (R, A);
+  FP_PACK_RAW_D (r, R);
 
   return r;
 }

Modified: fsf/trunk/libc/soft-fp/negsf2.c
==============================================================================
--- fsf/trunk/libc/soft-fp/negsf2.c (original)
+++ fsf/trunk/libc/soft-fp/negsf2.c Thu Oct 17 00:01:48 2013
@@ -32,15 +32,15 @@
 #include "single.h"
 
 SFtype
-__negsf2(SFtype a)
+__negsf2 (SFtype a)
 {
-  FP_DECL_S(A);
-  FP_DECL_S(R);
+  FP_DECL_S (A);
+  FP_DECL_S (R);
   SFtype r;
 
-  FP_UNPACK_RAW_S(A, a);
-  FP_NEG_S(R, A);
-  FP_PACK_RAW_S(r, R);
+  FP_UNPACK_RAW_S (A, a);
+  FP_NEG_S (R, A);
+  FP_PACK_RAW_S (r, R);
 
   return r;
 }

Modified: fsf/trunk/libc/soft-fp/negtf2.c
==============================================================================
--- fsf/trunk/libc/soft-fp/negtf2.c (original)
+++ fsf/trunk/libc/soft-fp/negtf2.c Thu Oct 17 00:01:48 2013
@@ -32,15 +32,15 @@
 #include "quad.h"
 
 TFtype
-__negtf2(TFtype a)
+__negtf2 (TFtype a)
 {
-  FP_DECL_Q(A);
-  FP_DECL_Q(R);
+  FP_DECL_Q (A);
+  FP_DECL_Q (R);
   TFtype r;
 
-  FP_UNPACK_RAW_Q(A, a);
-  FP_NEG_Q(R, A);
-  FP_PACK_RAW_Q(r, R);
+  FP_UNPACK_RAW_Q (A, a);
+  FP_NEG_Q (R, A);
+  FP_PACK_RAW_Q (r, R);
 
   return r;
 }

Modified: fsf/trunk/libc/soft-fp/op-1.h
==============================================================================
--- fsf/trunk/libc/soft-fp/op-1.h (original)
+++ fsf/trunk/libc/soft-fp/op-1.h Thu Oct 17 00:01:48 2013
@@ -31,61 +31,61 @@
    <http://www.gnu.org/licenses/>.  */
 
 #define _FP_FRAC_DECL_1(X)	_FP_W_TYPE X##_f
-#define _FP_FRAC_COPY_1(D,S)	(D##_f = S##_f)
-#define _FP_FRAC_SET_1(X,I)	(X##_f = I)
+#define _FP_FRAC_COPY_1(D, S)	(D##_f = S##_f)
+#define _FP_FRAC_SET_1(X, I)	(X##_f = I)
 #define _FP_FRAC_HIGH_1(X)	(X##_f)
 #define _FP_FRAC_LOW_1(X)	(X##_f)
-#define _FP_FRAC_WORD_1(X,w)	(X##_f)
-
-#define _FP_FRAC_ADDI_1(X,I)	(X##_f += I)
-#define _FP_FRAC_SLL_1(X,N)			\
-  do						\
-    {						\
-      if (__builtin_constant_p(N) && (N) == 1)	\
+#define _FP_FRAC_WORD_1(X, w)	(X##_f)
+
+#define _FP_FRAC_ADDI_1(X, I)	(X##_f += I)
+#define _FP_FRAC_SLL_1(X, N)			\
+  do						\
+    {						\
+      if (__builtin_constant_p (N) && (N) == 1)	\
 	X##_f += X##_f;				\
       else					\
 	X##_f <<= (N);				\
     }						\
   while (0)
-#define _FP_FRAC_SRL_1(X,N)	(X##_f >>= N)
+#define _FP_FRAC_SRL_1(X, N)	(X##_f >>= N)
 
 /* Right shift with sticky-lsb.  */
-#define _FP_FRAC_SRST_1(X,S,N,sz)	__FP_FRAC_SRST_1(X##_f, S, N, sz)
-#define _FP_FRAC_SRS_1(X,N,sz)	__FP_FRAC_SRS_1(X##_f, N, sz)
-
-#define __FP_FRAC_SRST_1(X,S,N,sz)			\
+#define _FP_FRAC_SRST_1(X, S, N, sz)	__FP_FRAC_SRST_1 (X##_f, S, N, sz)
+#define _FP_FRAC_SRS_1(X, N, sz)	__FP_FRAC_SRS_1 (X##_f, N, sz)
+
+#define __FP_FRAC_SRST_1(X, S, N, sz)			\
   do							\
     {							\
-      S = (__builtin_constant_p(N) && (N) == 1		\
+      S = (__builtin_constant_p (N) && (N) == 1		\
 	   ? X & 1					\
 	   : (X << (_FP_W_TYPE_SIZE - (N))) != 0);	\
       X = X >> (N);					\
     }							\
   while (0)
 
-#define __FP_FRAC_SRS_1(X,N,sz)					\
-  (X = (X >> (N) | (__builtin_constant_p(N) && (N) == 1		\
+#define __FP_FRAC_SRS_1(X, N, sz)				\
+  (X = (X >> (N) | (__builtin_constant_p (N) && (N) == 1	\
 		    ? X & 1					\
 		    : (X << (_FP_W_TYPE_SIZE - (N))) != 0)))
 
-#define _FP_FRAC_ADD_1(R,X,Y)	(R##_f = X##_f + Y##_f)
-#define _FP_FRAC_SUB_1(R,X,Y)	(R##_f = X##_f - Y##_f)
-#define _FP_FRAC_DEC_1(X,Y)	(X##_f -= Y##_f)
-#define _FP_FRAC_CLZ_1(z, X)	__FP_CLZ(z, X##_f)
+#define _FP_FRAC_ADD_1(R, X, Y)	(R##_f = X##_f + Y##_f)
+#define _FP_FRAC_SUB_1(R, X, Y)	(R##_f = X##_f - Y##_f)
+#define _FP_FRAC_DEC_1(X, Y)	(X##_f -= Y##_f)
+#define _FP_FRAC_CLZ_1(z, X)	__FP_CLZ (z, X##_f)
 
 /* Predicates */
-#define _FP_FRAC_NEGP_1(X)	((_FP_WS_TYPE)X##_f < 0)
+#define _FP_FRAC_NEGP_1(X)	((_FP_WS_TYPE) X##_f < 0)
 #define _FP_FRAC_ZEROP_1(X)	(X##_f == 0)
-#define _FP_FRAC_OVERP_1(fs,X)	(X##_f & _FP_OVERFLOW_##fs)
-#define _FP_FRAC_CLEAR_OVERP_1(fs,X)	(X##_f &= ~_FP_OVERFLOW_##fs)
-#define _FP_FRAC_HIGHBIT_DW_1(fs,X)	(X##_f & _FP_HIGHBIT_DW_##fs)
+#define _FP_FRAC_OVERP_1(fs, X)	(X##_f & _FP_OVERFLOW_##fs)
+#define _FP_FRAC_CLEAR_OVERP_1(fs, X)	(X##_f &= ~_FP_OVERFLOW_##fs)
+#define _FP_FRAC_HIGHBIT_DW_1(fs, X)	(X##_f & _FP_HIGHBIT_DW_##fs)
 #define _FP_FRAC_EQ_1(X, Y)	(X##_f == Y##_f)
 #define _FP_FRAC_GE_1(X, Y)	(X##_f >= Y##_f)
 #define _FP_FRAC_GT_1(X, Y)	(X##_f > Y##_f)
 
 #define _FP_ZEROFRAC_1		0
 #define _FP_MINFRAC_1		1
-#define _FP_MAXFRAC_1		(~(_FP_WS_TYPE)0)
+#define _FP_MAXFRAC_1		(~(_FP_WS_TYPE) 0)
 
 /*
  * Unpack the raw bits of a native fp value.  Do not classify or
@@ -107,7 +107,7 @@
 #define _FP_UNPACK_RAW_1_P(fs, X, val)					\
   do									\
     {									\
-      union _FP_UNION_##fs *_flo = (union _FP_UNION_##fs *)(val);	\
+      union _FP_UNION_##fs *_flo = (union _FP_UNION_##fs *) (val);	\
 									\
       X##_f = _flo->bits.frac;						\
       X##_e = _flo->bits.exp;						\
@@ -135,7 +135,7 @@
 #define _FP_PACK_RAW_1_P(fs, val, X)					\
   do									\
     {									\
-      union _FP_UNION_##fs *_flo = (union _FP_UNION_##fs *)(val);	\
+      union _FP_UNION_##fs *_flo = (union _FP_UNION_##fs *) (val);	\
 									\
       _flo->bits.frac = X##_f;						\
       _flo->bits.exp  = X##_e;						\
@@ -161,11 +161,11 @@
 #define _FP_MUL_MEAT_1_imm(wfracbits, R, X, Y)				\
   do									\
     {									\
-      _FP_MUL_MEAT_DW_1_imm(wfracbits, R, X, Y);			\
+      _FP_MUL_MEAT_DW_1_imm (wfracbits, R, X, Y);			\
       /* Normalize since we know where the msb of the multiplicands	\
 	 were (bit B), we know that the msb of the of the product is	\
 	 at either 2B or 2B-1.  */					\
-      _FP_FRAC_SRS_1(R, wfracbits-1, 2*wfracbits);			\
+      _FP_FRAC_SRS_1 (R, wfracbits-1, 2*wfracbits);			\
     }									\
   while (0)
 
@@ -174,19 +174,19 @@
 #define _FP_MUL_MEAT_DW_1_wide(wfracbits, R, X, Y, doit)	\
   do								\
     {								\
-      doit(R##_f1, R##_f0, X##_f, Y##_f);			\
+      doit (R##_f1, R##_f0, X##_f, Y##_f);			\
     }								\
   while (0)
 
 #define _FP_MUL_MEAT_1_wide(wfracbits, R, X, Y, doit)			\
   do									\
     {									\
-      _FP_FRAC_DECL_2(_Z);						\
-      _FP_MUL_MEAT_DW_1_wide(wfracbits, _Z, X, Y, doit);		\
+      _FP_FRAC_DECL_2 (_Z);						\
+      _FP_MUL_MEAT_DW_1_wide (wfracbits, _Z, X, Y, doit);		\
       /* Normalize since we know where the msb of the multiplicands	\
 	 were (bit B), we know that the msb of the of the product is	\
 	 at either 2B or 2B-1.  */					\
-      _FP_FRAC_SRS_2(_Z, wfracbits-1, 2*wfracbits);			\
+      _FP_FRAC_SRS_2 (_Z, wfracbits-1, 2*wfracbits);			\
       R##_f = _Z_f0;							\
     }									\
   while (0)
@@ -197,13 +197,13 @@
   do									\
     {									\
       _FP_W_TYPE _xh, _xl, _yh, _yl;					\
-      _FP_FRAC_DECL_2(_a);						\
+      _FP_FRAC_DECL_2 (_a);						\
 									\
       /* split the words in half */					\
       _xh = X##_f >> (_FP_W_TYPE_SIZE/2);				\
-      _xl = X##_f & (((_FP_W_TYPE)1 << (_FP_W_TYPE_SIZE/2)) - 1);	\
+      _xl = X##_f & (((_FP_W_TYPE) 1 << (_FP_W_TYPE_SIZE/2)) - 1);	\
       _yh = Y##_f >> (_FP_W_TYPE_SIZE/2);				\
-      _yl = Y##_f & (((_FP_W_TYPE)1 << (_FP_W_TYPE_SIZE/2)) - 1);	\
+      _yl = Y##_f & (((_FP_W_TYPE) 1 << (_FP_W_TYPE_SIZE/2)) - 1);	\
 									\
       /* multiply the pieces */						\
       R##_f0 = _xl * _yl;						\
@@ -213,21 +213,21 @@
 									\
       /* reassemble into two full words */				\
       if ((_a_f0 += _a_f1) < _a_f1)					\
-	R##_f1 += (_FP_W_TYPE)1 << (_FP_W_TYPE_SIZE/2);			\
+	R##_f1 += (_FP_W_TYPE) 1 << (_FP_W_TYPE_SIZE/2);		\
       _a_f1 = _a_f0 >> (_FP_W_TYPE_SIZE/2);				\
       _a_f0 = _a_f0 << (_FP_W_TYPE_SIZE/2);				\
-      _FP_FRAC_ADD_2(R, R, _a);						\
+      _FP_FRAC_ADD_2 (R, R, _a);					\
     }									\
   while (0)
 
 #define _FP_MUL_MEAT_1_hard(wfracbits, R, X, Y)		\
   do							\
     {							\
-      _FP_FRAC_DECL_2(_z);				\
-      _FP_MUL_MEAT_DW_1_hard(wfracbits, _z, X, Y);	\
+      _FP_FRAC_DECL_2 (_z);				\
+      _FP_MUL_MEAT_DW_1_hard (wfracbits, _z, X, Y);	\
 							\
       /* normalize */					\
-      _FP_FRAC_SRS_2(_z, wfracbits - 1, 2*wfracbits);	\
+      _FP_FRAC_SRS_2 (_z, wfracbits - 1, 2*wfracbits);	\
       R##_f = _z_f0;					\
     }							\
   while (0)
@@ -249,7 +249,7 @@
       X##_f <<= (X##_f < Y##_f			\
 		 ? R##_e--, _FP_WFRACBITS_##fs	\
 		 : _FP_WFRACBITS_##fs - 1);	\
-      doit(_q, _r, X##_f, Y##_f);		\
+      doit (_q, _r, X##_f, Y##_f);		\
       R##_f = _q | (_r != 0);			\
     }						\
   while (0)
@@ -280,7 +280,7 @@
 	  _nh = X##_f >> 1;						\
 	}								\
 									\
-      udiv_qrnnd(_q, _r, _nh, _nl, _y);					\
+      udiv_qrnnd (_q, _r, _nh, _nl, _y);				\
       R##_f = _q | (_r != 0);						\
     }									\
   while (0)
@@ -300,7 +300,7 @@
 	  _nl = X##_f << (_FP_WFRACBITS_##fs - 1);	\
 	  _nh = X##_f >> (_FP_WFRACXBITS_##fs + 1);	\
 	}						\
-      udiv_qrnnd(_q, _r, _nh, _nl, Y##_f);		\
+      udiv_qrnnd (_q, _r, _nh, _nl, Y##_f);		\
       R##_f = _q | (_r != 0);				\
     }							\
   while (0)
@@ -324,7 +324,7 @@
 	      X##_f -= T##_f;			\
 	      R##_f += q;			\
 	    }					\
-	  _FP_FRAC_SLL_1(X, 1);			\
+	  _FP_FRAC_SLL_1 (X, 1);		\
 	  q >>= 1;				\
 	}					\
       if (X##_f)				\

Modified: fsf/trunk/libc/soft-fp/op-2.h
==============================================================================
--- fsf/trunk/libc/soft-fp/op-2.h (original)
+++ fsf/trunk/libc/soft-fp/op-2.h Thu Oct 17 00:01:48 2013
@@ -31,113 +31,113 @@
    <http://www.gnu.org/licenses/>.  */
 
 #define _FP_FRAC_DECL_2(X)	_FP_W_TYPE X##_f0, X##_f1
-#define _FP_FRAC_COPY_2(D,S)	(D##_f0 = S##_f0, D##_f1 = S##_f1)
-#define _FP_FRAC_SET_2(X,I)	__FP_FRAC_SET_2(X, I)
+#define _FP_FRAC_COPY_2(D, S)	(D##_f0 = S##_f0, D##_f1 = S##_f1)
+#define _FP_FRAC_SET_2(X, I)	__FP_FRAC_SET_2 (X, I)
 #define _FP_FRAC_HIGH_2(X)	(X##_f1)
 #define _FP_FRAC_LOW_2(X)	(X##_f0)
-#define _FP_FRAC_WORD_2(X,w)	(X##_f##w)
-
-#define _FP_FRAC_SLL_2(X,N)						\
-  (void)(((N) < _FP_W_TYPE_SIZE)					\
-	 ? ({								\
-	     if (__builtin_constant_p(N) && (N) == 1)			\
-	       {							\
-		 X##_f1 = X##_f1 + X##_f1 + (((_FP_WS_TYPE)(X##_f0)) < 0); \
-		 X##_f0 += X##_f0;					\
-	       }							\
-	     else							\
-	       {							\
-		 X##_f1 = X##_f1 << (N) | X##_f0 >> (_FP_W_TYPE_SIZE - (N)); \
-		 X##_f0 <<= (N);					\
-	       }							\
-	     0;								\
-	   })								\
-	 : ({								\
-	     X##_f1 = X##_f0 << ((N) - _FP_W_TYPE_SIZE);		\
-	     X##_f0 = 0;						\
-	   }))
-
-
-#define _FP_FRAC_SRL_2(X,N)						\
-  (void)(((N) < _FP_W_TYPE_SIZE)					\
-	 ? ({								\
-	     X##_f0 = X##_f0 >> (N) | X##_f1 << (_FP_W_TYPE_SIZE - (N)); \
-	     X##_f1 >>= (N);						\
-	   })								\
-	 : ({								\
-	     X##_f0 = X##_f1 >> ((N) - _FP_W_TYPE_SIZE);		\
-	     X##_f1 = 0;						\
-	   }))
+#define _FP_FRAC_WORD_2(X, w)	(X##_f##w)
+
+#define _FP_FRAC_SLL_2(X, N)						\
+  (void) (((N) < _FP_W_TYPE_SIZE)					\
+	  ? ({								\
+	      if (__builtin_constant_p (N) && (N) == 1)			\
+		{							\
+		  X##_f1 = X##_f1 + X##_f1 + (((_FP_WS_TYPE) (X##_f0)) < 0); \
+		  X##_f0 += X##_f0;					\
+		}							\
+	      else							\
+		{							\
+		  X##_f1 = X##_f1 << (N) | X##_f0 >> (_FP_W_TYPE_SIZE - (N)); \
+		  X##_f0 <<= (N);					\
+		}							\
+	      0;							\
+	    })								\
+	  : ({								\
+	      X##_f1 = X##_f0 << ((N) - _FP_W_TYPE_SIZE);		\
+	      X##_f0 = 0;						\
+	    }))
+
+
+#define _FP_FRAC_SRL_2(X, N)						\
+  (void) (((N) < _FP_W_TYPE_SIZE)					\
+	  ? ({								\
+	      X##_f0 = X##_f0 >> (N) | X##_f1 << (_FP_W_TYPE_SIZE - (N)); \
+	      X##_f1 >>= (N);						\
+	    })								\
+	  : ({								\
+	      X##_f0 = X##_f1 >> ((N) - _FP_W_TYPE_SIZE);		\
+	      X##_f1 = 0;						\
+	    }))
 
 /* Right shift with sticky-lsb.  */
-#define _FP_FRAC_SRST_2(X,S, N,sz)					\
-  (void)(((N) < _FP_W_TYPE_SIZE)					\
-	 ? ({								\
-	     S = (__builtin_constant_p(N) && (N) == 1			\
-		  ? X##_f0 & 1						\
-		  : (X##_f0 << (_FP_W_TYPE_SIZE - (N))) != 0);		\
-	     X##_f0 = (X##_f1 << (_FP_W_TYPE_SIZE - (N)) | X##_f0 >> (N)); \
-	     X##_f1 >>= (N);						\
-	   })								\
-	 : ({								\
-	     S = ((((N) == _FP_W_TYPE_SIZE				\
-		    ? 0							\
-		    : (X##_f1 << (2*_FP_W_TYPE_SIZE - (N))))		\
-		   | X##_f0) != 0);					\
-	     X##_f0 = (X##_f1 >> ((N) - _FP_W_TYPE_SIZE));		\
-	     X##_f1 = 0;						\
-	   }))
-
-#define _FP_FRAC_SRS_2(X,N,sz)						\
-  (void)(((N) < _FP_W_TYPE_SIZE)					\
-	 ? ({								\
-	     X##_f0 = (X##_f1 << (_FP_W_TYPE_SIZE - (N)) | X##_f0 >> (N) \
-		       | (__builtin_constant_p(N) && (N) == 1		\
-			  ? X##_f0 & 1					\
-			  : (X##_f0 << (_FP_W_TYPE_SIZE - (N))) != 0));	\
-	     X##_f1 >>= (N);						\
-	   })								\
-	 : ({								\
-	     X##_f0 = (X##_f1 >> ((N) - _FP_W_TYPE_SIZE)		\
-		       | ((((N) == _FP_W_TYPE_SIZE			\
-			  ? 0						\
-			  : (X##_f1 << (2*_FP_W_TYPE_SIZE - (N))))	\
-			 | X##_f0) != 0));				\
-	     X##_f1 = 0;						\
-	   }))
-
-#define _FP_FRAC_ADDI_2(X,I)	\
-  __FP_FRAC_ADDI_2(X##_f1, X##_f0, I)
-
-#define _FP_FRAC_ADD_2(R,X,Y)	\
-  __FP_FRAC_ADD_2(R##_f1, R##_f0, X##_f1, X##_f0, Y##_f1, Y##_f0)
-
-#define _FP_FRAC_SUB_2(R,X,Y)	\
-  __FP_FRAC_SUB_2(R##_f1, R##_f0, X##_f1, X##_f0, Y##_f1, Y##_f0)
-
-#define _FP_FRAC_DEC_2(X,Y)	\
-  __FP_FRAC_DEC_2(X##_f1, X##_f0, Y##_f1, Y##_f0)
-
-#define _FP_FRAC_CLZ_2(R,X)			\
+#define _FP_FRAC_SRST_2(X, S, N, sz)					\
+  (void) (((N) < _FP_W_TYPE_SIZE)					\
+	  ? ({								\
+	      S = (__builtin_constant_p (N) && (N) == 1			\
+		   ? X##_f0 & 1						\
+		   : (X##_f0 << (_FP_W_TYPE_SIZE - (N))) != 0);		\
+	      X##_f0 = (X##_f1 << (_FP_W_TYPE_SIZE - (N)) | X##_f0 >> (N)); \
+	      X##_f1 >>= (N);						\
+	    })								\
+	  : ({								\
+	      S = ((((N) == _FP_W_TYPE_SIZE				\
+		     ? 0						\
+		     : (X##_f1 << (2*_FP_W_TYPE_SIZE - (N))))		\
+		    | X##_f0) != 0);					\
+	      X##_f0 = (X##_f1 >> ((N) - _FP_W_TYPE_SIZE));		\
+	      X##_f1 = 0;						\
+	    }))
+
+#define _FP_FRAC_SRS_2(X, N, sz)					\
+  (void) (((N) < _FP_W_TYPE_SIZE)					\
+	  ? ({								\
+	      X##_f0 = (X##_f1 << (_FP_W_TYPE_SIZE - (N)) | X##_f0 >> (N) \
+			| (__builtin_constant_p (N) && (N) == 1		\
+			   ? X##_f0 & 1					\
+			   : (X##_f0 << (_FP_W_TYPE_SIZE - (N))) != 0)); \
+	      X##_f1 >>= (N);						\
+	    })								\
+	  : ({								\
+	      X##_f0 = (X##_f1 >> ((N) - _FP_W_TYPE_SIZE)		\
+			| ((((N) == _FP_W_TYPE_SIZE			\
+			     ? 0					\
+			     : (X##_f1 << (2*_FP_W_TYPE_SIZE - (N))))	\
+			    | X##_f0) != 0));				\
+	      X##_f1 = 0;						\
+	    }))
+
+#define _FP_FRAC_ADDI_2(X, I)	\
+  __FP_FRAC_ADDI_2 (X##_f1, X##_f0, I)
+
+#define _FP_FRAC_ADD_2(R, X, Y)	\
+  __FP_FRAC_ADD_2 (R##_f1, R##_f0, X##_f1, X##_f0, Y##_f1, Y##_f0)
+
+#define _FP_FRAC_SUB_2(R, X, Y)	\
+  __FP_FRAC_SUB_2 (R##_f1, R##_f0, X##_f1, X##_f0, Y##_f1, Y##_f0)
+
+#define _FP_FRAC_DEC_2(X, Y)	\
+  __FP_FRAC_DEC_2 (X##_f1, X##_f0, Y##_f1, Y##_f0)
+
+#define _FP_FRAC_CLZ_2(R, X)			\
   do						\
     {						\
       if (X##_f1)				\
-	__FP_CLZ(R,X##_f1);			\
+	__FP_CLZ (R, X##_f1);			\
       else					\
 	{					\
-	  __FP_CLZ(R,X##_f0);			\
+	  __FP_CLZ (R, X##_f0);			\
 	  R += _FP_W_TYPE_SIZE;			\
 	}					\
     }						\
-  while(0)
+  while (0)
 
 /* Predicates */
-#define _FP_FRAC_NEGP_2(X)	((_FP_WS_TYPE)X##_f1 < 0)
+#define _FP_FRAC_NEGP_2(X)	((_FP_WS_TYPE) X##_f1 < 0)
 #define _FP_FRAC_ZEROP_2(X)	((X##_f1 | X##_f0) == 0)
-#define _FP_FRAC_OVERP_2(fs,X)	(_FP_FRAC_HIGH_##fs(X) & _FP_OVERFLOW_##fs)
-#define _FP_FRAC_CLEAR_OVERP_2(fs,X)	(_FP_FRAC_HIGH_##fs(X) &= ~_FP_OVERFLOW_##fs)
-#define _FP_FRAC_HIGHBIT_DW_2(fs,X)	\
-  (_FP_FRAC_HIGH_DW_##fs(X) & _FP_HIGHBIT_DW_##fs)
+#define _FP_FRAC_OVERP_2(fs, X)	(_FP_FRAC_HIGH_##fs (X) & _FP_OVERFLOW_##fs)
+#define _FP_FRAC_CLEAR_OVERP_2(fs, X)	(_FP_FRAC_HIGH_##fs (X) &= ~_FP_OVERFLOW_##fs)
+#define _FP_FRAC_HIGHBIT_DW_2(fs, X)	\
+  (_FP_FRAC_HIGH_DW_##fs (X) & _FP_HIGHBIT_DW_##fs)
 #define _FP_FRAC_EQ_2(X, Y)	(X##_f1 == Y##_f1 && X##_f0 == Y##_f0)
 #define _FP_FRAC_GT_2(X, Y)	\
   (X##_f1 > Y##_f1 || (X##_f1 == Y##_f1 && X##_f0 > Y##_f0))
@@ -146,26 +146,26 @@
 
 #define _FP_ZEROFRAC_2		0, 0
 #define _FP_MINFRAC_2		0, 1
-#define _FP_MAXFRAC_2		(~(_FP_WS_TYPE)0), (~(_FP_WS_TYPE)0)
+#define _FP_MAXFRAC_2		(~(_FP_WS_TYPE) 0), (~(_FP_WS_TYPE) 0)
 
 /*
  * Internals
  */
 
-#define __FP_FRAC_SET_2(X,I1,I0)	(X##_f0 = I0, X##_f1 = I1)
+#define __FP_FRAC_SET_2(X, I1, I0)	(X##_f0 = I0, X##_f1 = I1)
 
 #define __FP_CLZ_2(R, xh, xl)			\
   do						\
     {						\
       if (xh)					\
-	__FP_CLZ(R,xh);				\
+	__FP_CLZ (R, xh);			\
       else					\
 	{					\
-	  __FP_CLZ(R,xl);			\
+	  __FP_CLZ (R, xl);			\
 	  R += _FP_W_TYPE_SIZE;			\
 	}					\
     }						\
-  while(0)
+  while (0)
 
 #if 0
 
@@ -194,14 +194,14 @@
 #else
 
 # undef __FP_FRAC_ADDI_2
-# define __FP_FRAC_ADDI_2(xh, xl, i)	add_ssaaaa(xh, xl, xh, xl, 0, i)
+# define __FP_FRAC_ADDI_2(xh, xl, i)	add_ssaaaa (xh, xl, xh, xl, 0, i)
 # undef __FP_FRAC_ADD_2
 # define __FP_FRAC_ADD_2		add_ssaaaa
 # undef __FP_FRAC_SUB_2
 # define __FP_FRAC_SUB_2		sub_ddmmss
 # undef __FP_FRAC_DEC_2
 # define __FP_FRAC_DEC_2(xh, xl, yh, yl)	\
-  sub_ddmmss(xh, xl, xh, xl, yh, yl)
+  sub_ddmmss (xh, xl, xh, xl, yh, yl)
 
 #endif
 
@@ -226,7 +226,7 @@
 #define _FP_UNPACK_RAW_2_P(fs, X, val)					\
   do									\
     {									\
-      union _FP_UNION_##fs *_flo = (union _FP_UNION_##fs *)(val);	\
+      union _FP_UNION_##fs *_flo = (union _FP_UNION_##fs *) (val);	\
 									\
       X##_f0 = _flo->bits.frac0;					\
       X##_f1 = _flo->bits.frac1;					\
@@ -257,7 +257,7 @@
 #define _FP_PACK_RAW_2_P(fs, val, X)					\
   do									\
     {									\
-      union _FP_UNION_##fs *_flo = (union _FP_UNION_##fs *)(val);	\
+      union _FP_UNION_##fs *_flo = (union _FP_UNION_##fs *) (val);	\
 									\
       _flo->bits.frac0 = X##_f0;					\
       _flo->bits.frac1 = X##_f1;					\
@@ -276,38 +276,38 @@
 #define _FP_MUL_MEAT_DW_2_wide(wfracbits, R, X, Y, doit)		\
   do									\
     {									\
-      _FP_FRAC_DECL_2(_b);						\
-      _FP_FRAC_DECL_2(_c);						\
-									\
-      doit(_FP_FRAC_WORD_4(R,1), _FP_FRAC_WORD_4(R,0), X##_f0, Y##_f0);	\
-      doit(_b_f1, _b_f0, X##_f0, Y##_f1);				\
-      doit(_c_f1, _c_f0, X##_f1, Y##_f0);				\
-      doit(_FP_FRAC_WORD_4(R,3), _FP_FRAC_WORD_4(R,2), X##_f1, Y##_f1);	\
-									\
-      __FP_FRAC_ADD_3(_FP_FRAC_WORD_4(R,3),_FP_FRAC_WORD_4(R,2),	\
-		      _FP_FRAC_WORD_4(R,1), 0, _b_f1, _b_f0,		\
-		      _FP_FRAC_WORD_4(R,3),_FP_FRAC_WORD_4(R,2),	\
-		      _FP_FRAC_WORD_4(R,1));				\
-      __FP_FRAC_ADD_3(_FP_FRAC_WORD_4(R,3),_FP_FRAC_WORD_4(R,2),	\
-		      _FP_FRAC_WORD_4(R,1), 0, _c_f1, _c_f0,		\
-		      _FP_FRAC_WORD_4(R,3),_FP_FRAC_WORD_4(R,2),	\
-		      _FP_FRAC_WORD_4(R,1));				\
+      _FP_FRAC_DECL_2 (_b);						\
+      _FP_FRAC_DECL_2 (_c);						\
+									\
+      doit (_FP_FRAC_WORD_4 (R, 1), _FP_FRAC_WORD_4 (R, 0), X##_f0, Y##_f0); \
+      doit (_b_f1, _b_f0, X##_f0, Y##_f1);				\
+      doit (_c_f1, _c_f0, X##_f1, Y##_f0);				\
+      doit (_FP_FRAC_WORD_4 (R, 3), _FP_FRAC_WORD_4 (R, 2), X##_f1, Y##_f1); \
+									\
+      __FP_FRAC_ADD_3 (_FP_FRAC_WORD_4 (R, 3), _FP_FRAC_WORD_4 (R, 2),	\
+		       _FP_FRAC_WORD_4 (R, 1), 0, _b_f1, _b_f0,		\
+		       _FP_FRAC_WORD_4 (R, 3), _FP_FRAC_WORD_4 (R, 2),	\
+		       _FP_FRAC_WORD_4 (R, 1));				\
+      __FP_FRAC_ADD_3 (_FP_FRAC_WORD_4 (R, 3), _FP_FRAC_WORD_4 (R, 2),	\
+		       _FP_FRAC_WORD_4 (R, 1), 0, _c_f1, _c_f0,		\
+		       _FP_FRAC_WORD_4 (R, 3), _FP_FRAC_WORD_4 (R, 2),	\
+		       _FP_FRAC_WORD_4 (R, 1));				\
     }									\
   while (0)
 
 #define _FP_MUL_MEAT_2_wide(wfracbits, R, X, Y, doit)			\
   do									\
     {									\
-      _FP_FRAC_DECL_4(_z);						\
-									\
-      _FP_MUL_MEAT_DW_2_wide(wfracbits, _z, X, Y, doit);		\
+      _FP_FRAC_DECL_4 (_z);						\
+									\
+      _FP_MUL_MEAT_DW_2_wide (wfracbits, _z, X, Y, doit);		\
 									\
       /* Normalize since we know where the msb of the multiplicands	\
 	 were (bit B), we know that the msb of the of the product is	\
 	 at either 2B or 2B-1.  */					\
-      _FP_FRAC_SRS_4(_z, wfracbits-1, 2*wfracbits);			\
-      R##_f0 = _FP_FRAC_WORD_4(_z,0);					\
-      R##_f1 = _FP_FRAC_WORD_4(_z,1);					\
+      _FP_FRAC_SRS_4 (_z, wfracbits-1, 2*wfracbits);			\
+      R##_f0 = _FP_FRAC_WORD_4 (_z, 0);					\
+      R##_f1 = _FP_FRAC_WORD_4 (_z, 1);					\
     }									\
   while (0)
 
@@ -318,8 +318,8 @@
 #define _FP_MUL_MEAT_DW_2_wide_3mul(wfracbits, R, X, Y, doit)		\
   do									\
     {									\
-      _FP_FRAC_DECL_2(_b);						\
-      _FP_FRAC_DECL_2(_c);						\
+      _FP_FRAC_DECL_2 (_b);						\
+      _FP_FRAC_DECL_2 (_c);						\
       _FP_W_TYPE _d;							\
       int _c1, _c2;							\
 									\
@@ -327,43 +327,43 @@
       _c1 = _b_f0 < X##_f0;						\
       _b_f1 = Y##_f0 + Y##_f1;						\
       _c2 = _b_f1 < Y##_f0;						\
-      doit(_d, _FP_FRAC_WORD_4(R,0), X##_f0, Y##_f0);			\
-      doit(_FP_FRAC_WORD_4(R,2), _FP_FRAC_WORD_4(R,1), _b_f0, _b_f1);	\
-      doit(_c_f1, _c_f0, X##_f1, Y##_f1);				\
+      doit (_d, _FP_FRAC_WORD_4 (R, 0), X##_f0, Y##_f0);		\
+      doit (_FP_FRAC_WORD_4 (R, 2), _FP_FRAC_WORD_4 (R, 1), _b_f0, _b_f1); \
+      doit (_c_f1, _c_f0, X##_f1, Y##_f1);				\
 									\
       _b_f0 &= -_c2;							\
       _b_f1 &= -_c1;							\
-      __FP_FRAC_ADD_3(_FP_FRAC_WORD_4(R,3),_FP_FRAC_WORD_4(R,2),	\
-		      _FP_FRAC_WORD_4(R,1), (_c1 & _c2), 0, _d,		\
-		      0, _FP_FRAC_WORD_4(R,2), _FP_FRAC_WORD_4(R,1));	\
-      __FP_FRAC_ADDI_2(_FP_FRAC_WORD_4(R,3),_FP_FRAC_WORD_4(R,2),	\
-		       _b_f0);						\
-      __FP_FRAC_ADDI_2(_FP_FRAC_WORD_4(R,3),_FP_FRAC_WORD_4(R,2),	\
-		       _b_f1);						\
-      __FP_FRAC_DEC_3(_FP_FRAC_WORD_4(R,3),_FP_FRAC_WORD_4(R,2),	\
-		      _FP_FRAC_WORD_4(R,1),				\
-		      0, _d, _FP_FRAC_WORD_4(R,0));			\
-      __FP_FRAC_DEC_3(_FP_FRAC_WORD_4(R,3),_FP_FRAC_WORD_4(R,2),	\
-		      _FP_FRAC_WORD_4(R,1), 0, _c_f1, _c_f0);		\
-      __FP_FRAC_ADD_2(_FP_FRAC_WORD_4(R,3), _FP_FRAC_WORD_4(R,2),	\
-		      _c_f1, _c_f0,					\
-		      _FP_FRAC_WORD_4(R,3), _FP_FRAC_WORD_4(R,2));	\
+      __FP_FRAC_ADD_3 (_FP_FRAC_WORD_4 (R, 3), _FP_FRAC_WORD_4 (R, 2),	\
+		       _FP_FRAC_WORD_4 (R, 1), (_c1 & _c2), 0, _d,	\
+		       0, _FP_FRAC_WORD_4 (R, 2), _FP_FRAC_WORD_4 (R, 1)); \
+      __FP_FRAC_ADDI_2 (_FP_FRAC_WORD_4 (R, 3), _FP_FRAC_WORD_4 (R, 2),	\
+			_b_f0);						\
+      __FP_FRAC_ADDI_2 (_FP_FRAC_WORD_4 (R, 3), _FP_FRAC_WORD_4 (R, 2),	\
+			_b_f1);						\
+      __FP_FRAC_DEC_3 (_FP_FRAC_WORD_4 (R, 3), _FP_FRAC_WORD_4 (R, 2),	\
+		       _FP_FRAC_WORD_4 (R, 1),				\
+		       0, _d, _FP_FRAC_WORD_4 (R, 0));			\
+      __FP_FRAC_DEC_3 (_FP_FRAC_WORD_4 (R, 3), _FP_FRAC_WORD_4 (R, 2),	\
+		       _FP_FRAC_WORD_4 (R, 1), 0, _c_f1, _c_f0);	\
+      __FP_FRAC_ADD_2 (_FP_FRAC_WORD_4 (R, 3), _FP_FRAC_WORD_4 (R, 2),	\
+		       _c_f1, _c_f0,					\
+		       _FP_FRAC_WORD_4 (R, 3), _FP_FRAC_WORD_4 (R, 2));	\
     }									\
   while (0)
 
 #define _FP_MUL_MEAT_2_wide_3mul(wfracbits, R, X, Y, doit)		\
   do									\
     {									\
-      _FP_FRAC_DECL_4(_z);						\
-									\
-      _FP_MUL_MEAT_DW_2_wide_3mul(wfracbits, _z, X, Y, doit);		\
+      _FP_FRAC_DECL_4 (_z);						\
+									\
+      _FP_MUL_MEAT_DW_2_wide_3mul (wfracbits, _z, X, Y, doit);		\
 									\
       /* Normalize since we know where the msb of the multiplicands	\
 	 were (bit B), we know that the msb of the of the product is	\
 	 at either 2B or 2B-1.  */					\
-      _FP_FRAC_SRS_4(_z, wfracbits-1, 2*wfracbits);			\
-      R##_f0 = _FP_FRAC_WORD_4(_z,0);					\
-      R##_f1 = _FP_FRAC_WORD_4(_z,1);					\
+      _FP_FRAC_SRS_4 (_z, wfracbits-1, 2*wfracbits);			\
+      R##_f0 = _FP_FRAC_WORD_4 (_z, 0);					\
+      R##_f1 = _FP_FRAC_WORD_4 (_z, 1);					\
     }									\
   while (0)
 
@@ -376,21 +376,21 @@
       _y[0] = Y##_f0;					\
       _y[1] = Y##_f1;					\
 							\
-      mpn_mul_n(R##_f, _x, _y, 2);			\

[... 3999 lines stripped ...]
_______________________________________________
Commits mailing list
Commits@xxxxxxxxxx
http://eglibc.org/cgi-bin/mailman/listinfo/commits