about summary refs log tree commit diff
path: root/soft-fp
diff options
context:
space:
mode:
Diffstat (limited to 'soft-fp')
-rw-r--r--soft-fp/double.h142
-rw-r--r--soft-fp/extended.h142
-rw-r--r--soft-fp/op-2.h41
-rw-r--r--soft-fp/op-4.h14
-rw-r--r--soft-fp/op-common.h2
-rw-r--r--soft-fp/quad.h142
-rw-r--r--soft-fp/single.h2
-rw-r--r--soft-fp/soft-fp.h72
8 files changed, 279 insertions, 278 deletions
diff --git a/soft-fp/double.h b/soft-fp/double.h
index 8653f69138..3824276b74 100644
--- a/soft-fp/double.h
+++ b/soft-fp/double.h
@@ -31,15 +31,15 @@
    <http://www.gnu.org/licenses/>.  */
 
 #if _FP_W_TYPE_SIZE < 32
-#error "Here's a nickel kid.  Go buy yourself a real computer."
+# error "Here's a nickel kid.  Go buy yourself a real computer."
 #endif
 
 #if _FP_W_TYPE_SIZE < 64
-#define _FP_FRACTBITS_D		(2 * _FP_W_TYPE_SIZE)
-#define _FP_FRACTBITS_DW_D	(4 * _FP_W_TYPE_SIZE)
+# define _FP_FRACTBITS_D	(2 * _FP_W_TYPE_SIZE)
+# define _FP_FRACTBITS_DW_D	(4 * _FP_W_TYPE_SIZE)
 #else
-#define _FP_FRACTBITS_D		_FP_W_TYPE_SIZE
-#define _FP_FRACTBITS_DW_D	(2 * _FP_W_TYPE_SIZE)
+# define _FP_FRACTBITS_D	_FP_W_TYPE_SIZE
+# define _FP_FRACTBITS_DW_D	(2 * _FP_W_TYPE_SIZE)
 #endif
 
 #define _FP_FRACBITS_D		53
@@ -74,101 +74,101 @@ union _FP_UNION_D
 {
   DFtype flt;
   struct _FP_STRUCT_LAYOUT {
-#if __BYTE_ORDER == __BIG_ENDIAN
+# if __BYTE_ORDER == __BIG_ENDIAN
     unsigned sign  : 1;
     unsigned exp   : _FP_EXPBITS_D;
     unsigned frac1 : _FP_FRACBITS_D - (_FP_IMPLBIT_D != 0) - _FP_W_TYPE_SIZE;
     unsigned frac0 : _FP_W_TYPE_SIZE;
-#else
+# else
     unsigned frac0 : _FP_W_TYPE_SIZE;
     unsigned frac1 : _FP_FRACBITS_D - (_FP_IMPLBIT_D != 0) - _FP_W_TYPE_SIZE;
     unsigned exp   : _FP_EXPBITS_D;
     unsigned sign  : 1;
-#endif
+# endif
   } 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)		\
+# 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)		\
+# 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)		\
+# 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)	\
+# 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)	\
+# 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)		\
+# 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)		\
+# 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)	\
+# 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)	\
+# 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_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_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_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_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_FRAC_HIGH_DW_D(X)	_FP_FRAC_HIGH_4(X)
 
 #else
 
@@ -176,101 +176,101 @@ union _FP_UNION_D
 {
   DFtype flt;
   struct _FP_STRUCT_LAYOUT {
-#if __BYTE_ORDER == __BIG_ENDIAN
+# if __BYTE_ORDER == __BIG_ENDIAN
     unsigned sign   : 1;
     unsigned exp    : _FP_EXPBITS_D;
     _FP_W_TYPE frac : _FP_FRACBITS_D - (_FP_IMPLBIT_D != 0);
-#else
+# else
     _FP_W_TYPE frac : _FP_FRACBITS_D - (_FP_IMPLBIT_D != 0);
     unsigned exp    : _FP_EXPBITS_D;
     unsigned sign   : 1;
-#endif
+# endif
   } 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)		\
+# 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)		\
+# 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)		\
+# 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)	\
+# 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)	\
+# 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)		\
+# 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)		\
+# 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)	\
+# 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)	\
+# 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_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_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_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_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_FRAC_HIGH_DW_D(X)	_FP_FRAC_HIGH_2(X)
 
 #endif /* W_TYPE_SIZE < 64 */
diff --git a/soft-fp/extended.h b/soft-fp/extended.h
index c8b1583086..de8c20c0c8 100644
--- a/soft-fp/extended.h
+++ b/soft-fp/extended.h
@@ -28,15 +28,15 @@
    <http://www.gnu.org/licenses/>.  */
 
 #if _FP_W_TYPE_SIZE < 32
-#error "Here's a nickel, kid. Go buy yourself a real computer."
+# error "Here's a nickel, kid. Go buy yourself a real computer."
 #endif
 
 #if _FP_W_TYPE_SIZE < 64
-#define _FP_FRACTBITS_E         (4*_FP_W_TYPE_SIZE)
-#define _FP_FRACTBITS_DW_E	(8*_FP_W_TYPE_SIZE)
+# define _FP_FRACTBITS_E	(4*_FP_W_TYPE_SIZE)
+# define _FP_FRACTBITS_DW_E	(8*_FP_W_TYPE_SIZE)
 #else
-#define _FP_FRACTBITS_E		(2*_FP_W_TYPE_SIZE)
-#define _FP_FRACTBITS_DW_E	(4*_FP_W_TYPE_SIZE)
+# define _FP_FRACTBITS_E	(2*_FP_W_TYPE_SIZE)
+# define _FP_FRACTBITS_DW_E	(4*_FP_W_TYPE_SIZE)
 #endif
 
 #define _FP_FRACBITS_E		64
@@ -72,26 +72,26 @@ union _FP_UNION_E
    XFtype flt;
    struct _FP_STRUCT_LAYOUT
    {
-#if __BYTE_ORDER == __BIG_ENDIAN
+# if __BYTE_ORDER == __BIG_ENDIAN
       unsigned long pad1 : _FP_W_TYPE_SIZE;
       unsigned long pad2 : (_FP_W_TYPE_SIZE - 1 - _FP_EXPBITS_E);
       unsigned long sign : 1;
       unsigned long exp : _FP_EXPBITS_E;
       unsigned long frac1 : _FP_W_TYPE_SIZE;
       unsigned long frac0 : _FP_W_TYPE_SIZE;
-#else
+# else
       unsigned long frac0 : _FP_W_TYPE_SIZE;
       unsigned long frac1 : _FP_W_TYPE_SIZE;
       unsigned exp : _FP_EXPBITS_E;
       unsigned sign : 1;
-#endif /* not bigendian */
+# endif /* not bigendian */
    } 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)				\
+# define FP_UNPACK_RAW_E(X, val)			\
   do {							\
     union _FP_UNION_E _flo; _flo.flt = (val);		\
 							\
@@ -102,7 +102,7 @@ union _FP_UNION_E
     X##_s  = _flo.bits.sign;				\
   } while (0)
 
-#define FP_UNPACK_RAW_EP(X, val)			\
+# define FP_UNPACK_RAW_EP(X, val)			\
   do {							\
     union _FP_UNION_E *_flo =				\
     (union _FP_UNION_E *)(val);				\
@@ -114,7 +114,7 @@ union _FP_UNION_E
     X##_s  = _flo->bits.sign;				\
   } while (0)
 
-#define FP_PACK_RAW_E(val, X)				\
+# define FP_PACK_RAW_E(val, X)				\
   do {							\
     union _FP_UNION_E _flo;				\
 							\
@@ -128,7 +128,7 @@ union _FP_UNION_E
     (val) = _flo.flt;					\
   } while (0)
 
-#define FP_PACK_RAW_EP(val, X)				\
+# define FP_PACK_RAW_EP(val, X)				\
   do {							\
     if (!FP_INHIBIT_RESULTS)				\
       {							\
@@ -144,62 +144,62 @@ union _FP_UNION_E
       }							\
   } while (0)
 
-#define FP_UNPACK_E(X,val)		\
+# 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)		\
+# 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)	\
+# 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)	\
+# 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)		\
+# 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)		\
+# 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)	\
+# 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)	\
+# 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_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:
@@ -212,7 +212,7 @@ union _FP_UNION_E
  * in two UWtype registers instead of four.
  */
 
-#define _FP_SQRT_MEAT_E(R, S, T, X, q)			\
+# 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));			\
@@ -256,39 +256,39 @@ union _FP_UNION_E
       }							\
   } 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_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_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])
+# define _FP_FRAC_HIGH_E(X)	(X##_f[2])
+# define _FP_FRAC_HIGH_RAW_E(X)	(X##_f[1])
 
-#define _FP_FRAC_HIGH_DW_E(X)	(X##_f[4])
+# define _FP_FRAC_HIGH_DW_E(X)	(X##_f[4])
 
 #else   /* not _FP_W_TYPE_SIZE < 64 */
 union _FP_UNION_E
 {
   XFtype flt;
   struct _FP_STRUCT_LAYOUT {
-#if __BYTE_ORDER == __BIG_ENDIAN
+# if __BYTE_ORDER == __BIG_ENDIAN
     _FP_W_TYPE pad  : (_FP_W_TYPE_SIZE - 1 - _FP_EXPBITS_E);
     unsigned sign   : 1;
     unsigned exp    : _FP_EXPBITS_E;
     _FP_W_TYPE frac : _FP_W_TYPE_SIZE;
-#else
+# else
     _FP_W_TYPE frac : _FP_W_TYPE_SIZE;
     unsigned exp    : _FP_EXPBITS_E;
     unsigned sign   : 1;
-#endif
+# endif
   } 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)					\
+# define FP_UNPACK_RAW_E(X, val)				\
   do {								\
     union _FP_UNION_E _flo; _flo.flt = (val);			\
 								\
@@ -298,7 +298,7 @@ union _FP_UNION_E
     X##_s = _flo.bits.sign;					\
   } while (0)
 
-#define FP_UNPACK_RAW_EP(X, val)				\
+# define FP_UNPACK_RAW_EP(X, val)				\
   do {								\
     union _FP_UNION_E *_flo =					\
       (union _FP_UNION_E *)(val);				\
@@ -309,7 +309,7 @@ union _FP_UNION_E
     X##_s = _flo->bits.sign;					\
   } while (0)
 
-#define FP_PACK_RAW_E(val, X)					\
+# define FP_PACK_RAW_E(val, X)					\
   do {								\
     union _FP_UNION_E _flo;					\
 								\
@@ -322,7 +322,7 @@ union _FP_UNION_E
     (val) = _flo.flt;						\
   } while (0)
 
-#define FP_PACK_RAW_EP(fs, val, X)				\
+# define FP_PACK_RAW_EP(fs, val, X)				\
   do {								\
     if (!FP_INHIBIT_RESULTS)					\
       {								\
@@ -338,62 +338,62 @@ union _FP_UNION_E
   } while (0)
 
 
-#define FP_UNPACK_E(X,val)		\
+# 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)		\
+# 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)	\
+# 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)	\
+# 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)		\
+# 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)		\
+# 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)	\
+# 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)	\
+# 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_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:
@@ -403,7 +403,7 @@ union _FP_UNION_E
  * in one UWtype registers instead of two, although we don't
  * have to.
  */
-#define _FP_SQRT_MEAT_E(R, S, T, X, q)			\
+# 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));			\
@@ -428,16 +428,16 @@ union _FP_UNION_E
       }							\
   } 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_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_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)
+# define _FP_FRAC_HIGH_E(X)	(X##_f1)
+# define _FP_FRAC_HIGH_RAW_E(X)	(X##_f0)
 
-#define _FP_FRAC_HIGH_DW_E(X)	(X##_f[2])
+# define _FP_FRAC_HIGH_DW_E(X)	(X##_f[2])
 
 #endif /* not _FP_W_TYPE_SIZE < 64 */
diff --git a/soft-fp/op-2.h b/soft-fp/op-2.h
index 2892d3b04c..a5275d4668 100644
--- a/soft-fp/op-2.h
+++ b/soft-fp/op-2.h
@@ -165,36 +165,37 @@
 
 #if 0
 
-#ifndef __FP_FRAC_ADDI_2
-#define __FP_FRAC_ADDI_2(xh, xl, i)	\
+# ifndef __FP_FRAC_ADDI_2
+#  define __FP_FRAC_ADDI_2(xh, xl, i)	\
   (xh += ((xl += i) < i))
-#endif
-#ifndef __FP_FRAC_ADD_2
-#define __FP_FRAC_ADD_2(rh, rl, xh, xl, yh, yl)	\
+# endif
+# ifndef __FP_FRAC_ADD_2
+#  define __FP_FRAC_ADD_2(rh, rl, xh, xl, yh, yl)	\
   (rh = xh + yh + ((rl = xl + yl) < xl))
-#endif
-#ifndef __FP_FRAC_SUB_2
-#define __FP_FRAC_SUB_2(rh, rl, xh, xl, yh, yl)	\
+# endif
+# ifndef __FP_FRAC_SUB_2
+#  define __FP_FRAC_SUB_2(rh, rl, xh, xl, yh, yl)	\
   (rh = xh - yh - ((rl = xl - yl) > xl))
-#endif
-#ifndef __FP_FRAC_DEC_2
-#define __FP_FRAC_DEC_2(xh, xl, yh, yl)	\
+# endif
+# ifndef __FP_FRAC_DEC_2
+#  define __FP_FRAC_DEC_2(xh, xl, yh, yl)	\
   do {					\
     UWtype _t = xl;			\
     xh -= yh + ((xl -= yl) > _t);	\
   } while (0)
-#endif
+# endif
 
 #else
 
-#undef __FP_FRAC_ADDI_2
-#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)
+# undef __FP_FRAC_ADDI_2
+# 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)
 
 #endif
 
diff --git a/soft-fp/op-4.h b/soft-fp/op-4.h
index 9086ba71c4..db4197d44f 100644
--- a/soft-fp/op-4.h
+++ b/soft-fp/op-4.h
@@ -537,7 +537,7 @@
   (X##_f[3] = I3, X##_f[2] = I2, X##_f[1] = I1, X##_f[0] = I0)
 
 #ifndef __FP_FRAC_ADD_3
-#define __FP_FRAC_ADD_3(r2,r1,r0,x2,x1,x0,y2,y1,y0)		\
+# define __FP_FRAC_ADD_3(r2,r1,r0,x2,x1,x0,y2,y1,y0)		\
   do {								\
     _FP_W_TYPE __FP_FRAC_ADD_3_c1, __FP_FRAC_ADD_3_c2;		\
     r0 = x0 + y0;						\
@@ -551,7 +551,7 @@
 #endif
 
 #ifndef __FP_FRAC_ADD_4
-#define __FP_FRAC_ADD_4(r3,r2,r1,r0,x3,x2,x1,x0,y3,y2,y1,y0)	\
+# define __FP_FRAC_ADD_4(r3,r2,r1,r0,x3,x2,x1,x0,y3,y2,y1,y0)	\
   do {								\
     _FP_W_TYPE _c1, _c2, _c3;					\
     r0 = x0 + y0;						\
@@ -569,7 +569,7 @@
 #endif
 
 #ifndef __FP_FRAC_SUB_3
-#define __FP_FRAC_SUB_3(r2,r1,r0,x2,x1,x0,y2,y1,y0)		\
+# define __FP_FRAC_SUB_3(r2,r1,r0,x2,x1,x0,y2,y1,y0)		\
   do {								\
     _FP_W_TYPE _c1, _c2;					\
     r0 = x0 - y0;						\
@@ -583,7 +583,7 @@
 #endif
 
 #ifndef __FP_FRAC_SUB_4
-#define __FP_FRAC_SUB_4(r3,r2,r1,r0,x3,x2,x1,x0,y3,y2,y1,y0)	\
+# define __FP_FRAC_SUB_4(r3,r2,r1,r0,x3,x2,x1,x0,y3,y2,y1,y0)	\
   do {								\
     _FP_W_TYPE _c1, _c2, _c3;					\
     r0 = x0 - y0;						\
@@ -601,7 +601,7 @@
 #endif
 
 #ifndef __FP_FRAC_DEC_3
-#define __FP_FRAC_DEC_3(x2,x1,x0,y2,y1,y0)				\
+# define __FP_FRAC_DEC_3(x2,x1,x0,y2,y1,y0)				\
   do {									\
     UWtype _t0, _t1, _t2;						\
     _t0 = x0, _t1 = x1, _t2 = x2;					\
@@ -610,7 +610,7 @@
 #endif
 
 #ifndef __FP_FRAC_DEC_4
-#define __FP_FRAC_DEC_4(x3,x2,x1,x0,y3,y2,y1,y0)			\
+# define __FP_FRAC_DEC_4(x3,x2,x1,x0,y3,y2,y1,y0)			\
   do {									\
     UWtype _t0, _t1, _t2, _t3;						\
     _t0 = x0, _t1 = x1, _t2 = x2, _t3 = x3;				\
@@ -619,7 +619,7 @@
 #endif
 
 #ifndef __FP_FRAC_ADDI_4
-#define __FP_FRAC_ADDI_4(x3,x2,x1,x0,i)					\
+# define __FP_FRAC_ADDI_4(x3,x2,x1,x0,i)				\
   do {									\
     UWtype _t;								\
     _t = ((x0 += i) < i);						\
diff --git a/soft-fp/op-common.h b/soft-fp/op-common.h
index dbc107773e..d87ffaf131 100644
--- a/soft-fp/op-common.h
+++ b/soft-fp/op-common.h
@@ -1553,7 +1553,7 @@ do {									     \
 
 #ifndef __FP_CLZ
 /* GCC 3.4 and later provide the builtins for us.  */
-#define __FP_CLZ(r, x)							      \
+# define __FP_CLZ(r, x)							      \
   do {									      \
     if (sizeof (_FP_W_TYPE) == sizeof (unsigned int))			      \
       r = __builtin_clz (x);						      \
diff --git a/soft-fp/quad.h b/soft-fp/quad.h
index 9a16bf3284..af24a5ebde 100644
--- a/soft-fp/quad.h
+++ b/soft-fp/quad.h
@@ -31,15 +31,15 @@
    <http://www.gnu.org/licenses/>.  */
 
 #if _FP_W_TYPE_SIZE < 32
-#error "Here's a nickel, kid. Go buy yourself a real computer."
+# error "Here's a nickel, kid. Go buy yourself a real computer."
 #endif
 
 #if _FP_W_TYPE_SIZE < 64
-#define _FP_FRACTBITS_Q         (4*_FP_W_TYPE_SIZE)
-#define _FP_FRACTBITS_DW_Q	(8*_FP_W_TYPE_SIZE)
+# define _FP_FRACTBITS_Q	(4*_FP_W_TYPE_SIZE)
+# define _FP_FRACTBITS_DW_Q	(8*_FP_W_TYPE_SIZE)
 #else
-#define _FP_FRACTBITS_Q		(2*_FP_W_TYPE_SIZE)
-#define _FP_FRACTBITS_DW_Q	(4*_FP_W_TYPE_SIZE)
+# define _FP_FRACTBITS_Q		(2*_FP_W_TYPE_SIZE)
+# define _FP_FRACTBITS_DW_Q	(4*_FP_W_TYPE_SIZE)
 #endif
 
 #define _FP_FRACBITS_Q		113
@@ -75,106 +75,106 @@ union _FP_UNION_Q
    TFtype flt;
    struct _FP_STRUCT_LAYOUT
    {
-#if __BYTE_ORDER == __BIG_ENDIAN
+# if __BYTE_ORDER == __BIG_ENDIAN
       unsigned sign : 1;
       unsigned exp : _FP_EXPBITS_Q;
       unsigned long frac3 : _FP_FRACBITS_Q - (_FP_IMPLBIT_Q != 0)-(_FP_W_TYPE_SIZE * 3);
       unsigned long frac2 : _FP_W_TYPE_SIZE;
       unsigned long frac1 : _FP_W_TYPE_SIZE;
       unsigned long frac0 : _FP_W_TYPE_SIZE;
-#else
+# else
       unsigned long frac0 : _FP_W_TYPE_SIZE;
       unsigned long frac1 : _FP_W_TYPE_SIZE;
       unsigned long frac2 : _FP_W_TYPE_SIZE;
       unsigned long frac3 : _FP_FRACBITS_Q - (_FP_IMPLBIT_Q != 0)-(_FP_W_TYPE_SIZE * 3);
       unsigned exp : _FP_EXPBITS_Q;
       unsigned sign : 1;
-#endif /* not bigendian */
+# endif /* not bigendian */
    } bits __attribute__((packed));
 };
 
 
-#define FP_DECL_Q(X)		_FP_DECL(4,X)
-#define FP_UNPACK_RAW_Q(X,val)	_FP_UNPACK_RAW_4(Q,X,val)
-#define FP_UNPACK_RAW_QP(X,val)	_FP_UNPACK_RAW_4_P(Q,X,val)
-#define FP_PACK_RAW_Q(val,X)	_FP_PACK_RAW_4(Q,val,X)
-#define FP_PACK_RAW_QP(val,X)		\
+# define FP_DECL_Q(X)		_FP_DECL(4,X)
+# define FP_UNPACK_RAW_Q(X,val)	_FP_UNPACK_RAW_4(Q,X,val)
+# define FP_UNPACK_RAW_QP(X,val)	_FP_UNPACK_RAW_4_P(Q,X,val)
+# define FP_PACK_RAW_Q(val,X)	_FP_PACK_RAW_4(Q,val,X)
+# define FP_PACK_RAW_QP(val,X)		\
   do {					\
     if (!FP_INHIBIT_RESULTS)		\
       _FP_PACK_RAW_4_P(Q,val,X);	\
   } while (0)
 
-#define FP_UNPACK_Q(X,val)		\
+# define FP_UNPACK_Q(X,val)		\
   do {					\
     _FP_UNPACK_RAW_4(Q,X,val);		\
     _FP_UNPACK_CANONICAL(Q,4,X);	\
   } while (0)
 
-#define FP_UNPACK_QP(X,val)		\
+# define FP_UNPACK_QP(X,val)		\
   do {					\
     _FP_UNPACK_RAW_4_P(Q,X,val);	\
     _FP_UNPACK_CANONICAL(Q,4,X);	\
   } while (0)
 
-#define FP_UNPACK_SEMIRAW_Q(X,val)	\
+# define FP_UNPACK_SEMIRAW_Q(X,val)	\
   do {					\
     _FP_UNPACK_RAW_4(Q,X,val);		\
     _FP_UNPACK_SEMIRAW(Q,4,X);		\
   } while (0)
 
-#define FP_UNPACK_SEMIRAW_QP(X,val)	\
+# define FP_UNPACK_SEMIRAW_QP(X,val)	\
   do {					\
     _FP_UNPACK_RAW_4_P(Q,X,val);	\
     _FP_UNPACK_SEMIRAW(Q,4,X);		\
   } while (0)
 
-#define FP_PACK_Q(val,X)		\
+# define FP_PACK_Q(val,X)		\
   do {					\
     _FP_PACK_CANONICAL(Q,4,X);		\
     _FP_PACK_RAW_4(Q,val,X);		\
   } while (0)
 
-#define FP_PACK_QP(val,X)		\
+# define FP_PACK_QP(val,X)		\
   do {					\
     _FP_PACK_CANONICAL(Q,4,X);		\
     if (!FP_INHIBIT_RESULTS)		\
       _FP_PACK_RAW_4_P(Q,val,X);	\
   } while (0)
 
-#define FP_PACK_SEMIRAW_Q(val,X)	\
+# define FP_PACK_SEMIRAW_Q(val,X)	\
   do {					\
     _FP_PACK_SEMIRAW(Q,4,X);		\
     _FP_PACK_RAW_4(Q,val,X);		\
   } while (0)
 
-#define FP_PACK_SEMIRAW_QP(val,X)	\
+# define FP_PACK_SEMIRAW_QP(val,X)	\
   do {					\
     _FP_PACK_SEMIRAW(Q,4,X);		\
     if (!FP_INHIBIT_RESULTS)		\
       _FP_PACK_RAW_4_P(Q,val,X);	\
   } while (0)
 
-#define FP_ISSIGNAN_Q(X)		_FP_ISSIGNAN(Q,4,X)
-#define FP_NEG_Q(R,X)			_FP_NEG(Q,4,R,X)
-#define FP_ADD_Q(R,X,Y)			_FP_ADD(Q,4,R,X,Y)
-#define FP_SUB_Q(R,X,Y)			_FP_SUB(Q,4,R,X,Y)
-#define FP_MUL_Q(R,X,Y)			_FP_MUL(Q,4,R,X,Y)
-#define FP_DIV_Q(R,X,Y)			_FP_DIV(Q,4,R,X,Y)
-#define FP_SQRT_Q(R,X)			_FP_SQRT(Q,4,R,X)
-#define _FP_SQRT_MEAT_Q(R,S,T,X,Q)	_FP_SQRT_MEAT_4(R,S,T,X,Q)
-#define FP_FMA_Q(R,X,Y,Z)		_FP_FMA(Q,4,8,R,X,Y,Z)
+# define FP_ISSIGNAN_Q(X)		_FP_ISSIGNAN(Q,4,X)
+# define FP_NEG_Q(R,X)			_FP_NEG(Q,4,R,X)
+# define FP_ADD_Q(R,X,Y)		_FP_ADD(Q,4,R,X,Y)
+# define FP_SUB_Q(R,X,Y)		_FP_SUB(Q,4,R,X,Y)
+# define FP_MUL_Q(R,X,Y)		_FP_MUL(Q,4,R,X,Y)
+# define FP_DIV_Q(R,X,Y)		_FP_DIV(Q,4,R,X,Y)
+# define FP_SQRT_Q(R,X)			_FP_SQRT(Q,4,R,X)
+# define _FP_SQRT_MEAT_Q(R,S,T,X,Q)	_FP_SQRT_MEAT_4(R,S,T,X,Q)
+# define FP_FMA_Q(R,X,Y,Z)		_FP_FMA(Q,4,8,R,X,Y,Z)
 
-#define FP_CMP_Q(r,X,Y,un)	_FP_CMP(Q,4,r,X,Y,un)
-#define FP_CMP_EQ_Q(r,X,Y)	_FP_CMP_EQ(Q,4,r,X,Y)
-#define FP_CMP_UNORD_Q(r,X,Y)	_FP_CMP_UNORD(Q,4,r,X,Y)
+# define FP_CMP_Q(r,X,Y,un)	_FP_CMP(Q,4,r,X,Y,un)
+# define FP_CMP_EQ_Q(r,X,Y)	_FP_CMP_EQ(Q,4,r,X,Y)
+# define FP_CMP_UNORD_Q(r,X,Y)	_FP_CMP_UNORD(Q,4,r,X,Y)
 
-#define FP_TO_INT_Q(r,X,rsz,rsg)	_FP_TO_INT(Q,4,r,X,rsz,rsg)
-#define FP_FROM_INT_Q(X,r,rs,rt)	_FP_FROM_INT(Q,4,X,r,rs,rt)
+# define FP_TO_INT_Q(r,X,rsz,rsg)	_FP_TO_INT(Q,4,r,X,rsz,rsg)
+# define FP_FROM_INT_Q(X,r,rs,rt)	_FP_FROM_INT(Q,4,X,r,rs,rt)
 
-#define _FP_FRAC_HIGH_Q(X)	_FP_FRAC_HIGH_4(X)
-#define _FP_FRAC_HIGH_RAW_Q(X)	_FP_FRAC_HIGH_4(X)
+# define _FP_FRAC_HIGH_Q(X)	_FP_FRAC_HIGH_4(X)
+# define _FP_FRAC_HIGH_RAW_Q(X)	_FP_FRAC_HIGH_4(X)
 
-#define _FP_FRAC_HIGH_DW_Q(X)	_FP_FRAC_HIGH_8(X)
+# define _FP_FRAC_HIGH_DW_Q(X)	_FP_FRAC_HIGH_8(X)
 
 #else   /* not _FP_W_TYPE_SIZE < 64 */
 union _FP_UNION_Q
@@ -184,100 +184,100 @@ union _FP_UNION_Q
     _FP_W_TYPE a, b;
   } longs;
   struct _FP_STRUCT_LAYOUT {
-#if __BYTE_ORDER == __BIG_ENDIAN
+# if __BYTE_ORDER == __BIG_ENDIAN
     unsigned sign    : 1;
     unsigned exp     : _FP_EXPBITS_Q;
     _FP_W_TYPE frac1 : _FP_FRACBITS_Q - (_FP_IMPLBIT_Q != 0) - _FP_W_TYPE_SIZE;
     _FP_W_TYPE frac0 : _FP_W_TYPE_SIZE;
-#else
+# else
     _FP_W_TYPE frac0 : _FP_W_TYPE_SIZE;
     _FP_W_TYPE frac1 : _FP_FRACBITS_Q - (_FP_IMPLBIT_Q != 0) - _FP_W_TYPE_SIZE;
     unsigned exp     : _FP_EXPBITS_Q;
     unsigned sign    : 1;
-#endif
+# endif
   } bits;
 };
 
-#define FP_DECL_Q(X)		_FP_DECL(2,X)
-#define FP_UNPACK_RAW_Q(X,val)	_FP_UNPACK_RAW_2(Q,X,val)
-#define FP_UNPACK_RAW_QP(X,val)	_FP_UNPACK_RAW_2_P(Q,X,val)
-#define FP_PACK_RAW_Q(val,X)	_FP_PACK_RAW_2(Q,val,X)
-#define FP_PACK_RAW_QP(val,X)		\
+# define FP_DECL_Q(X)		_FP_DECL(2,X)
+# define FP_UNPACK_RAW_Q(X,val)	_FP_UNPACK_RAW_2(Q,X,val)
+# define FP_UNPACK_RAW_QP(X,val)	_FP_UNPACK_RAW_2_P(Q,X,val)
+# define FP_PACK_RAW_Q(val,X)	_FP_PACK_RAW_2(Q,val,X)
+# define FP_PACK_RAW_QP(val,X)		\
   do {					\
     if (!FP_INHIBIT_RESULTS)		\
       _FP_PACK_RAW_2_P(Q,val,X);	\
   } while (0)
 
-#define FP_UNPACK_Q(X,val)		\
+# define FP_UNPACK_Q(X,val)		\
   do {					\
     _FP_UNPACK_RAW_2(Q,X,val);		\
     _FP_UNPACK_CANONICAL(Q,2,X);	\
   } while (0)
 
-#define FP_UNPACK_QP(X,val)		\
+# define FP_UNPACK_QP(X,val)		\
   do {					\
     _FP_UNPACK_RAW_2_P(Q,X,val);	\
     _FP_UNPACK_CANONICAL(Q,2,X);	\
   } while (0)
 
-#define FP_UNPACK_SEMIRAW_Q(X,val)	\
+# define FP_UNPACK_SEMIRAW_Q(X,val)	\
   do {					\
     _FP_UNPACK_RAW_2(Q,X,val);		\
     _FP_UNPACK_SEMIRAW(Q,2,X);		\
   } while (0)
 
-#define FP_UNPACK_SEMIRAW_QP(X,val)	\
+# define FP_UNPACK_SEMIRAW_QP(X,val)	\
   do {					\
     _FP_UNPACK_RAW_2_P(Q,X,val);	\
     _FP_UNPACK_SEMIRAW(Q,2,X);		\
   } while (0)
 
-#define FP_PACK_Q(val,X)		\
+# define FP_PACK_Q(val,X)		\
   do {					\
     _FP_PACK_CANONICAL(Q,2,X);		\
     _FP_PACK_RAW_2(Q,val,X);		\
   } while (0)
 
-#define FP_PACK_QP(val,X)		\
+# define FP_PACK_QP(val,X)		\
   do {					\
     _FP_PACK_CANONICAL(Q,2,X);		\
     if (!FP_INHIBIT_RESULTS)		\
       _FP_PACK_RAW_2_P(Q,val,X);	\
   } while (0)
 
-#define FP_PACK_SEMIRAW_Q(val,X)	\
+# define FP_PACK_SEMIRAW_Q(val,X)	\
   do {					\
     _FP_PACK_SEMIRAW(Q,2,X);		\
     _FP_PACK_RAW_2(Q,val,X);		\
   } while (0)
 
-#define FP_PACK_SEMIRAW_QP(val,X)	\
+# define FP_PACK_SEMIRAW_QP(val,X)	\
   do {					\
     _FP_PACK_SEMIRAW(Q,2,X);		\
     if (!FP_INHIBIT_RESULTS)		\
       _FP_PACK_RAW_2_P(Q,val,X);	\
   } while (0)
 
-#define FP_ISSIGNAN_Q(X)		_FP_ISSIGNAN(Q,2,X)
-#define FP_NEG_Q(R,X)			_FP_NEG(Q,2,R,X)
-#define FP_ADD_Q(R,X,Y)			_FP_ADD(Q,2,R,X,Y)
-#define FP_SUB_Q(R,X,Y)			_FP_SUB(Q,2,R,X,Y)
-#define FP_MUL_Q(R,X,Y)			_FP_MUL(Q,2,R,X,Y)
-#define FP_DIV_Q(R,X,Y)			_FP_DIV(Q,2,R,X,Y)
-#define FP_SQRT_Q(R,X)			_FP_SQRT(Q,2,R,X)
-#define _FP_SQRT_MEAT_Q(R,S,T,X,Q)	_FP_SQRT_MEAT_2(R,S,T,X,Q)
-#define FP_FMA_Q(R,X,Y,Z)		_FP_FMA(Q,2,4,R,X,Y,Z)
+# define FP_ISSIGNAN_Q(X)		_FP_ISSIGNAN(Q,2,X)
+# define FP_NEG_Q(R,X)			_FP_NEG(Q,2,R,X)
+# define FP_ADD_Q(R,X,Y)		_FP_ADD(Q,2,R,X,Y)
+# define FP_SUB_Q(R,X,Y)		_FP_SUB(Q,2,R,X,Y)
+# define FP_MUL_Q(R,X,Y)		_FP_MUL(Q,2,R,X,Y)
+# define FP_DIV_Q(R,X,Y)		_FP_DIV(Q,2,R,X,Y)
+# define FP_SQRT_Q(R,X)			_FP_SQRT(Q,2,R,X)
+# define _FP_SQRT_MEAT_Q(R,S,T,X,Q)	_FP_SQRT_MEAT_2(R,S,T,X,Q)
+# define FP_FMA_Q(R,X,Y,Z)		_FP_FMA(Q,2,4,R,X,Y,Z)
 
-#define FP_CMP_Q(r,X,Y,un)	_FP_CMP(Q,2,r,X,Y,un)
-#define FP_CMP_EQ_Q(r,X,Y)	_FP_CMP_EQ(Q,2,r,X,Y)
-#define FP_CMP_UNORD_Q(r,X,Y)	_FP_CMP_UNORD(Q,2,r,X,Y)
+# define FP_CMP_Q(r,X,Y,un)	_FP_CMP(Q,2,r,X,Y,un)
+# define FP_CMP_EQ_Q(r,X,Y)	_FP_CMP_EQ(Q,2,r,X,Y)
+# define FP_CMP_UNORD_Q(r,X,Y)	_FP_CMP_UNORD(Q,2,r,X,Y)
 
-#define FP_TO_INT_Q(r,X,rsz,rsg)	_FP_TO_INT(Q,2,r,X,rsz,rsg)
-#define FP_FROM_INT_Q(X,r,rs,rt)	_FP_FROM_INT(Q,2,X,r,rs,rt)
+# define FP_TO_INT_Q(r,X,rsz,rsg)	_FP_TO_INT(Q,2,r,X,rsz,rsg)
+# define FP_FROM_INT_Q(X,r,rs,rt)	_FP_FROM_INT(Q,2,X,r,rs,rt)
 
-#define _FP_FRAC_HIGH_Q(X)	_FP_FRAC_HIGH_2(X)
-#define _FP_FRAC_HIGH_RAW_Q(X)	_FP_FRAC_HIGH_2(X)
+# define _FP_FRAC_HIGH_Q(X)	_FP_FRAC_HIGH_2(X)
+# define _FP_FRAC_HIGH_RAW_Q(X)	_FP_FRAC_HIGH_2(X)
 
-#define _FP_FRAC_HIGH_DW_Q(X)	_FP_FRAC_HIGH_4(X)
+# define _FP_FRAC_HIGH_DW_Q(X)	_FP_FRAC_HIGH_4(X)
 
 #endif /* not _FP_W_TYPE_SIZE < 64 */
diff --git a/soft-fp/single.h b/soft-fp/single.h
index c94f31f99b..9c52a40957 100644
--- a/soft-fp/single.h
+++ b/soft-fp/single.h
@@ -31,7 +31,7 @@
    <http://www.gnu.org/licenses/>.  */
 
 #if _FP_W_TYPE_SIZE < 32
-#error "Here's a nickel kid.  Go buy yourself a real computer."
+# error "Here's a nickel kid.  Go buy yourself a real computer."
 #endif
 
 #define _FP_FRACTBITS_S		_FP_W_TYPE_SIZE
diff --git a/soft-fp/soft-fp.h b/soft-fp/soft-fp.h
index d6c4b683b8..1b7b3a7a5c 100644
--- a/soft-fp/soft-fp.h
+++ b/soft-fp/soft-fp.h
@@ -33,18 +33,18 @@
 #define SOFT_FP_H
 
 #ifdef _LIBC
-#include <sfp-machine.h>
+# include <sfp-machine.h>
 #else
-#include "sfp-machine.h"
+# include "sfp-machine.h"
 #endif
 
 /* Allow sfp-machine to have its own byte order definitions. */
 #ifndef __BYTE_ORDER
-#ifdef _LIBC
-#include <endian.h>
-#else
-#error "endianness not defined by sfp-machine.h"
-#endif
+# ifdef _LIBC
+#  include <endian.h>
+# else
+#  error "endianness not defined by sfp-machine.h"
+# endif
 #endif
 
 #define _FP_WORKBITS		3
@@ -65,22 +65,22 @@
 
 /* By default don't care about exceptions. */
 #ifndef FP_EX_INVALID
-#define FP_EX_INVALID		0
+# define FP_EX_INVALID		0
 #endif
 #ifndef FP_EX_OVERFLOW
-#define FP_EX_OVERFLOW		0
+# define FP_EX_OVERFLOW		0
 #endif
 #ifndef FP_EX_UNDERFLOW
-#define FP_EX_UNDERFLOW		0
+# define FP_EX_UNDERFLOW	0
 #endif
 #ifndef FP_EX_DIVZERO
-#define FP_EX_DIVZERO		0
+# define FP_EX_DIVZERO		0
 #endif
 #ifndef FP_EX_INEXACT
-#define FP_EX_INEXACT		0
+# define FP_EX_INEXACT		0
 #endif
 #ifndef FP_EX_DENORM
-#define FP_EX_DENORM		0
+# define FP_EX_DENORM		0
 #endif
 
 /* _FP_STRUCT_LAYOUT may be defined as an attribute to determine the
@@ -90,31 +90,31 @@
    differences in how consecutive bit-fields are laid out from the
    default expected by soft-fp.  */
 #ifndef _FP_STRUCT_LAYOUT
-#define _FP_STRUCT_LAYOUT
+# define _FP_STRUCT_LAYOUT
 #endif
 
 #ifdef _FP_DECL_EX
-#define FP_DECL_EX					\
+# define FP_DECL_EX					\
   int _fex = 0;						\
   _FP_DECL_EX
 #else
-#define FP_DECL_EX int _fex = 0
+# define FP_DECL_EX int _fex = 0
 #endif
 
 /* Initialize any machine-specific state used in FP_ROUNDMODE,
    FP_TRAPPING_EXCEPTIONS or FP_HANDLE_EXCEPTIONS.  */
 #ifndef FP_INIT_ROUNDMODE
-#define FP_INIT_ROUNDMODE do {} while (0)
+# define FP_INIT_ROUNDMODE do {} while (0)
 #endif
 
 /* Initialize any machine-specific state used in
    FP_HANDLE_EXCEPTIONS.  */
 #ifndef FP_INIT_EXCEPTIONS
-#define FP_INIT_EXCEPTIONS FP_INIT_ROUNDMODE
+# define FP_INIT_EXCEPTIONS FP_INIT_ROUNDMODE
 #endif
 
 #ifndef FP_HANDLE_EXCEPTIONS
-#define FP_HANDLE_EXCEPTIONS do {} while (0)
+# define FP_HANDLE_EXCEPTIONS do {} while (0)
 #endif
 
 #ifndef FP_INHIBIT_RESULTS
@@ -123,7 +123,7 @@
  * check if some exceptions are unmasked
  * and inhibit it in such a case.
  */
-#define FP_INHIBIT_RESULTS 0
+# define FP_INHIBIT_RESULTS 0
 #endif
 
 #define FP_SET_EXCEPTION(ex)				\
@@ -139,7 +139,7 @@
   (_fex)
 
 #ifndef FP_TRAPPING_EXCEPTIONS
-#define FP_TRAPPING_EXCEPTIONS 0
+# define FP_TRAPPING_EXCEPTIONS 0
 #endif
 
 /* A file using soft-fp may define FP_NO_EXCEPTIONS before including
@@ -152,17 +152,17 @@
    _FP_FROM_INT and the macros it calls).  */
 #ifdef FP_NO_EXCEPTIONS
 
-#undef FP_SET_EXCEPTION
-#define FP_SET_EXCEPTION(ex) do {} while (0)
+# undef FP_SET_EXCEPTION
+# define FP_SET_EXCEPTION(ex) do {} while (0)
 
-#undef FP_CUR_EXCEPTIONS
-#define FP_CUR_EXCEPTIONS 0
+# undef FP_CUR_EXCEPTIONS
+# define FP_CUR_EXCEPTIONS 0
 
-#undef FP_TRAPPING_EXCEPTIONS
-#define FP_TRAPPING_EXCEPTIONS 0
+# undef FP_TRAPPING_EXCEPTIONS
+# define FP_TRAPPING_EXCEPTIONS 0
 
-#undef FP_ROUNDMODE
-#define FP_ROUNDMODE FP_RND_ZERO
+# undef FP_ROUNDMODE
+# define FP_ROUNDMODE FP_RND_ZERO
 
 #endif
 
@@ -239,22 +239,22 @@ typedef USItype UHWtype;
 #endif
 
 #ifndef CMPtype
-#define CMPtype		int
+# define CMPtype	int
 #endif
 
 #define SI_BITS		(__CHAR_BIT__ * (int)sizeof(SItype))
 #define DI_BITS		(__CHAR_BIT__ * (int)sizeof(DItype))
 
 #ifndef umul_ppmm
-#ifdef _LIBC
-#include <stdlib/longlong.h>
-#else
-#include "longlong.h"
-#endif
+# ifdef _LIBC
+#  include <stdlib/longlong.h>
+# else
+#  include "longlong.h"
+# endif
 #endif
 
 #ifdef _LIBC
-#include <stdlib.h>
+# include <stdlib.h>
 #else
 extern void abort (void);
 #endif