soft-fp: fix vertical whitespace and indentation.

ChangeLog

@@ -1,3 +1,91 @@
+2013-10-14  Joseph Myers  <joseph@codesourcery.com>
+
+	* soft-fp/adddf3.c: Fix vertical whitespace and indentation.
+	* 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/floatunsidf.c: Likewise.
+	* soft-fp/floatunsisf.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-14   Ondřej Bílka  <neleai@seznam.cz>
 
 	[BZ #15672]

soft-fp/adddf3.c

@@ -31,10 +31,13 @@
 #include "soft-fp.h"
 #include "double.h"
 
-DFtype __adddf3(DFtype a, DFtype b)
+DFtype
+__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;

soft-fp/addsf3.c

@@ -31,10 +31,13 @@
 #include "soft-fp.h"
 #include "single.h"
 
-SFtype __addsf3(SFtype a, SFtype b)
+SFtype
+__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;

soft-fp/addtf3.c

@@ -31,10 +31,13 @@
 #include "soft-fp.h"
 #include "quad.h"
 
-TFtype __addtf3(TFtype a, TFtype b)
+TFtype
+__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;

soft-fp/divdf3.c

@@ -31,10 +31,13 @@
 #include "soft-fp.h"
 #include "double.h"
 
-DFtype __divdf3(DFtype a, DFtype b)
+DFtype
+__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;

soft-fp/divsf3.c

@@ -31,10 +31,13 @@
 #include "soft-fp.h"
 #include "single.h"
 
-SFtype __divsf3(SFtype a, SFtype b)
+SFtype
+__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;

soft-fp/divtf3.c

@@ -31,10 +31,13 @@
 #include "soft-fp.h"
 #include "quad.h"
 
-TFtype __divtf3(TFtype a, TFtype b)
+TFtype
+__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;

soft-fp/double.h

@@ -73,7 +73,8 @@ typedef float DFtype __attribute__((mode(DF)));
 union _FP_UNION_D
 {
   DFtype flt;
-  struct _FP_STRUCT_LAYOUT {
+  struct _FP_STRUCT_LAYOUT
+  {
 # if __BYTE_ORDER == __BIG_ENDIAN
     unsigned sign  : 1;
     unsigned exp   : _FP_EXPBITS_D;
@@ -93,60 +94,78 @@ union _FP_UNION_D
 # 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 {					\
+  do						\
+    {						\
       if (!FP_INHIBIT_RESULTS)			\
 	_FP_PACK_RAW_2_P(D,val,X);		\
-  } while (0)
+    }						\
+  while (0)
 
 # define FP_UNPACK_D(X,val)			\
-  do {					\
+  do						\
+    {						\
       _FP_UNPACK_RAW_2(D,X,val);		\
       _FP_UNPACK_CANONICAL(D,2,X);		\
-  } while (0)
+    }						\
+  while (0)
 
 # define FP_UNPACK_DP(X,val)			\
-  do {					\
+  do						\
+    {						\
       _FP_UNPACK_RAW_2_P(D,X,val);		\
       _FP_UNPACK_CANONICAL(D,2,X);		\
-  } while (0)
+    }						\
+  while (0)
 
 # define FP_UNPACK_SEMIRAW_D(X,val)		\
-  do {					\
+  do						\
+    {						\
       _FP_UNPACK_RAW_2(D,X,val);		\
       _FP_UNPACK_SEMIRAW(D,2,X);		\
-  } while (0)
+    }						\
+  while (0)
 
 # define FP_UNPACK_SEMIRAW_DP(X,val)		\
-  do {					\
+  do						\
+    {						\
       _FP_UNPACK_RAW_2_P(D,X,val);		\
       _FP_UNPACK_SEMIRAW(D,2,X);		\
-  } while (0)
+    }						\
+  while (0)
 
 # define FP_PACK_D(val,X)			\
-  do {					\
+  do						\
+    {						\
       _FP_PACK_CANONICAL(D,2,X);		\
       _FP_PACK_RAW_2(D,val,X);			\
-  } while (0)
+    }						\
+  while (0)
 
 # define FP_PACK_DP(val,X)			\
-  do {					\
+  do						\
+    {						\
       _FP_PACK_CANONICAL(D,2,X);		\
       if (!FP_INHIBIT_RESULTS)			\
 	_FP_PACK_RAW_2_P(D,val,X);		\
-  } while (0)
+    }						\
+  while (0)
 
 # define FP_PACK_SEMIRAW_D(val,X)		\
-  do {					\
+  do						\
+    {						\
       _FP_PACK_SEMIRAW(D,2,X);			\
       _FP_PACK_RAW_2(D,val,X);			\
-  } while (0)
+    }						\
+  while (0)
 
 # define FP_PACK_SEMIRAW_DP(val,X)		\
-  do {					\
+  do						\
+    {						\
       _FP_PACK_SEMIRAW(D,2,X);			\
       if (!FP_INHIBIT_RESULTS)			\
 	_FP_PACK_RAW_2_P(D,val,X);		\
-  } while (0)
+    }						\
+  while (0)
 
 # define FP_ISSIGNAN_D(X)		_FP_ISSIGNAN(D,2,X)
 # define FP_NEG_D(R,X)			_FP_NEG(D,2,R,X)
@@ -175,7 +194,8 @@ union _FP_UNION_D
 union _FP_UNION_D
 {
   DFtype flt;
-  struct _FP_STRUCT_LAYOUT {
+  struct _FP_STRUCT_LAYOUT
+  {
 # if __BYTE_ORDER == __BIG_ENDIAN
     unsigned sign   : 1;
     unsigned exp    : _FP_EXPBITS_D;
@@ -193,60 +213,78 @@ union _FP_UNION_D
 # 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 {					\
+  do						\
+    {						\
       if (!FP_INHIBIT_RESULTS)			\
 	_FP_PACK_RAW_1_P(D,val,X);		\
-  } while (0)
+    }						\
+  while (0)
 
 # define FP_UNPACK_D(X,val)			\
-  do {					\
+  do						\
+    {						\
       _FP_UNPACK_RAW_1(D,X,val);		\
       _FP_UNPACK_CANONICAL(D,1,X);		\
-  } while (0)
+    }						\
+  while (0)
 
 # define FP_UNPACK_DP(X,val)			\
-  do {					\
+  do						\
+    {						\
       _FP_UNPACK_RAW_1_P(D,X,val);		\
       _FP_UNPACK_CANONICAL(D,1,X);		\
-  } while (0)
+    }						\
+  while (0)
 
 # define FP_UNPACK_SEMIRAW_D(X,val)		\
-  do {					\
+  do						\
+    {						\
       _FP_UNPACK_RAW_1(D,X,val);		\
       _FP_UNPACK_SEMIRAW(D,1,X);		\
-  } while (0)
+    }						\
+  while (0)
 
 # define FP_UNPACK_SEMIRAW_DP(X,val)		\
-  do {					\
+  do						\
+    {						\
       _FP_UNPACK_RAW_1_P(D,X,val);		\
       _FP_UNPACK_SEMIRAW(D,1,X);		\
-  } while (0)
+    }						\
+  while (0)
 
 # define FP_PACK_D(val,X)			\
-  do {					\
+  do						\
+    {						\
       _FP_PACK_CANONICAL(D,1,X);		\
       _FP_PACK_RAW_1(D,val,X);			\
-  } while (0)
+    }						\
+  while (0)
 
 # define FP_PACK_DP(val,X)			\
-  do {					\
+  do						\
+    {						\
       _FP_PACK_CANONICAL(D,1,X);		\
       if (!FP_INHIBIT_RESULTS)			\
 	_FP_PACK_RAW_1_P(D,val,X);		\
-  } while (0)
+    }						\
+  while (0)
 
 # define FP_PACK_SEMIRAW_D(val,X)		\
-  do {					\
+  do						\
+    {						\
       _FP_PACK_SEMIRAW(D,1,X);			\
       _FP_PACK_RAW_1(D,val,X);			\
-  } while (0)
+    }						\
+  while (0)
 
 # define FP_PACK_SEMIRAW_DP(val,X)		\
-  do {					\
+  do						\
+    {						\
       _FP_PACK_SEMIRAW(D,1,X);			\
       if (!FP_INHIBIT_RESULTS)			\
 	_FP_PACK_RAW_1_P(D,val,X);		\
-  } while (0)
+    }						\
+  while (0)
 
 # define FP_ISSIGNAN_D(X)		_FP_ISSIGNAN(D,1,X)
 # define FP_NEG_D(R,X)			_FP_NEG(D,1,R,X)

soft-fp/eqdf2.c

@@ -31,10 +31,12 @@
 #include "soft-fp.h"
 #include "double.h"
 
-CMPtype __eqdf2(DFtype a, DFtype b)
+CMPtype
+__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;

soft-fp/eqsf2.c

@@ -31,10 +31,12 @@
 #include "soft-fp.h"
 #include "single.h"
 
-CMPtype __eqsf2(SFtype a, SFtype b)
+CMPtype
+__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;

soft-fp/eqtf2.c

@@ -31,10 +31,12 @@
 #include "soft-fp.h"
 #include "quad.h"
 
-CMPtype __eqtf2(TFtype a, TFtype b)
+CMPtype
+__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;

soft-fp/extenddftf2.c

@@ -32,7 +32,8 @@
 #include "double.h"
 #include "quad.h"
 
-TFtype __extenddftf2(DFtype a)
+TFtype
+__extenddftf2(DFtype a)
 {
   FP_DECL_EX;
   FP_DECL_D(A);

soft-fp/extended.h

@@ -92,105 +92,134 @@ union _FP_UNION_E
 # define FP_DECL_E(X)		_FP_DECL(4,X)
 
 # define FP_UNPACK_RAW_E(X, val)		\
-  do {							\
+  do						\
-    union _FP_UNION_E _flo; _flo.flt = (val);		\
+    {						\
+      union _FP_UNION_E _flo;			\
+      _flo.flt = (val);				\
 						\
-    X##_f[2] = 0; X##_f[3] = 0;				\
+      X##_f[2] = 0;				\
+      X##_f[3] = 0;				\
       X##_f[0] = _flo.bits.frac0;		\
       X##_f[1] = _flo.bits.frac1;		\
       X##_e  = _flo.bits.exp;			\
       X##_s  = _flo.bits.sign;			\
-  } while (0)
+    }						\
+  while (0)
 
 # define FP_UNPACK_RAW_EP(X, val)				\
-  do {							\
+  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;				\
+      X##_f[2] = 0;						\
+      X##_f[3] = 0;						\
       X##_f[0] = _flo->bits.frac0;				\
       X##_f[1] = _flo->bits.frac1;				\
       X##_e  = _flo->bits.exp;					\
       X##_s  = _flo->bits.sign;					\
-  } while (0)
+    }								\
+  while (0)
 
 # define FP_PACK_RAW_E(val, X)			\
-  do {							\
+  do						\
+    {						\
       union _FP_UNION_E _flo;			\
 						\
-    if (X##_e) X##_f[1] |= _FP_IMPLBIT_E;		\
+      if (X##_e)				\
-    else X##_f[1] &= ~(_FP_IMPLBIT_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;			\
 						\
       (val) = _flo.flt;				\
-  } while (0)
+    }						\
+  while (0)
 
 # define FP_PACK_RAW_EP(val, X)					\
-  do {							\
+  do								\
+    {								\
       if (!FP_INHIBIT_RESULTS)					\
 	{							\
-	union _FP_UNION_E *_flo =			\
+	  union _FP_UNION_E *_flo = (union _FP_UNION_E *)(val);	\
-	  (union _FP_UNION_E *)(val);			\
 								\
-	if (X##_e) X##_f[1] |= _FP_IMPLBIT_E;		\
+	  if (X##_e)						\
-	else X##_f[1] &= ~(_FP_IMPLBIT_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)
+    }								\
+  while (0)
 
 # define FP_UNPACK_E(X,val)			\
-  do {					\
+  do						\
+    {						\
       FP_UNPACK_RAW_E(X,val);			\
       _FP_UNPACK_CANONICAL(E,4,X);		\
-  } while (0)
+    }						\
+  while (0)
 
 # define FP_UNPACK_EP(X,val)			\
-  do {					\
+  do						\
+    {						\
       FP_UNPACK_RAW_EP(X,val);			\
       _FP_UNPACK_CANONICAL(E,4,X);		\
-  } while (0)
+    }						\
+  while (0)
 
 # define FP_UNPACK_SEMIRAW_E(X,val)		\
-  do {					\
+  do						\
+    {						\
       FP_UNPACK_RAW_E(X,val);			\
       _FP_UNPACK_SEMIRAW(E,4,X);		\
-  } while (0)
+    }						\
+  while (0)
 
 # define FP_UNPACK_SEMIRAW_EP(X,val)		\
-  do {					\
+  do						\
+    {						\
       FP_UNPACK_RAW_EP(X,val);			\
       _FP_UNPACK_SEMIRAW(E,4,X);		\
-  } while (0)
+    }						\
+  while (0)
 
 # define FP_PACK_E(val,X)			\
-  do {					\
+  do						\
+    {						\
       _FP_PACK_CANONICAL(E,4,X);		\
       FP_PACK_RAW_E(val,X);			\
-  } while (0)
+    }						\
+  while (0)
 
 # define FP_PACK_EP(val,X)			\
-  do {					\
+  do						\
+    {						\
       _FP_PACK_CANONICAL(E,4,X);		\
       FP_PACK_RAW_EP(val,X);			\
-  } while (0)
+    }						\
+  while (0)
 
 # define FP_PACK_SEMIRAW_E(val,X)		\
-  do {					\
+  do						\
+    {						\
       _FP_PACK_SEMIRAW(E,4,X);			\
       FP_PACK_RAW_E(val,X);			\
-  } while (0)
+    }						\
+  while (0)
 
 # define FP_PACK_SEMIRAW_EP(val,X)		\
-  do {					\
+  do						\
+    {						\
       _FP_PACK_SEMIRAW(E,4,X);			\
       FP_PACK_RAW_EP(val,X);			\
-  } while (0)
+    }						\
+  while (0)
 
 # define FP_ISSIGNAN_E(X)	_FP_ISSIGNAN(E,4,X)
 # define FP_NEG_E(R,X)		_FP_NEG(E,4,R,X)
@@ -213,7 +242,8 @@ union _FP_UNION_E
  */
 
 # define _FP_SQRT_MEAT_E(R, S, T, X, q)			\
-  do {							\
+  do							\
+    {							\
       q = (_FP_W_TYPE)1 << (_FP_W_TYPE_SIZE - 1);	\
       _FP_FRAC_SRL_4(X, (_FP_WORKBITS));		\
       while (q)						\
@@ -233,9 +263,9 @@ union _FP_UNION_E
 	{						\
 	  T##_f[0] = S##_f[0] + q;			\
 	  T##_f[1] = S##_f[1];				\
-	if (T##_f[1] < X##_f[1] || 			\
+	  if (T##_f[1] < X##_f[1]			\
-	    (T##_f[1] == X##_f[1] &&			\
+	      || (T##_f[1] == X##_f[1]			\
-	     T##_f[0] <= X##_f[0]))			\
+		  && T##_f[0] <= X##_f[0]))		\
 	    {						\
 	      S##_f[0] = T##_f[0] + q;			\
 	      S##_f[1] += (T##_f[0] > S##_f[0]);	\
@@ -248,13 +278,14 @@ union _FP_UNION_E
       _FP_FRAC_SLL_4(R, (_FP_WORKBITS));		\
       if (X##_f[0] | X##_f[1])				\
 	{						\
-	if (S##_f[1] < X##_f[1] || 			\
+	  if (S##_f[1] < X##_f[1]			\
-	    (S##_f[1] == X##_f[1] &&			\
+	      || (S##_f[1] == X##_f[1]			\
-	     S##_f[0] < X##_f[0]))			\
+		  && S##_f[0] < X##_f[0]))		\
 	    R##_f[0] |= _FP_WORK_ROUND;			\
 	  R##_f[0] |= _FP_WORK_STICKY;			\
 	}						\
-  } while (0)
+    }							\
+  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)
@@ -272,7 +303,8 @@ union _FP_UNION_E
 union _FP_UNION_E
 {
   XFtype flt;
-  struct _FP_STRUCT_LAYOUT {
+  struct _FP_STRUCT_LAYOUT
+  {
 # if __BYTE_ORDER == __BIG_ENDIAN
     _FP_W_TYPE pad  : (_FP_W_TYPE_SIZE - 1 - _FP_EXPBITS_E);
     unsigned sign   : 1;
@@ -289,102 +321,129 @@ union _FP_UNION_E
 # define FP_DECL_E(X)		_FP_DECL(2,X)
 
 # define FP_UNPACK_RAW_E(X, val)		\
-  do {								\
+  do						\
-    union _FP_UNION_E _flo; _flo.flt = (val);			\
+    {						\
+      union _FP_UNION_E _flo;			\
+      _flo.flt = (val);				\
 						\
       X##_f0 = _flo.bits.frac;			\
       X##_f1 = 0;				\
       X##_e = _flo.bits.exp;			\
       X##_s = _flo.bits.sign;			\
-  } while (0)
+    }						\
+  while (0)
 
 # define FP_UNPACK_RAW_EP(X, val)				\
-  do {								\
+  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;						\
       X##_e = _flo->bits.exp;					\
       X##_s = _flo->bits.sign;					\
-  } while (0)
+    }								\
+  while (0)
 
 # define FP_PACK_RAW_E(val, X)			\
-  do {								\
+  do						\
+    {						\
       union _FP_UNION_E _flo;			\
 						\
-    if (X##_e) X##_f0 |= _FP_IMPLBIT_E;				\
+      if (X##_e)				\
-    else X##_f0 &= ~(_FP_IMPLBIT_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;			\
 						\
       (val) = _flo.flt;				\
-  } while (0)
+    }						\
+  while (0)
 
 # define FP_PACK_RAW_EP(fs, val, X)				\
-  do {								\
+  do								\
+    {								\
       if (!FP_INHIBIT_RESULTS)					\
 	{							\
-	union _FP_UNION_E *_flo =				\
+	  union _FP_UNION_E *_flo = (union _FP_UNION_E *)(val);	\
-	  (union _FP_UNION_E *)(val);				\
 								\
-	if (X##_e) X##_f0 |= _FP_IMPLBIT_E;			\
+	  if (X##_e)						\
-	else X##_f0 &= ~(_FP_IMPLBIT_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)
+    }								\
+  while (0)
 
 
 # define FP_UNPACK_E(X,val)			\
-  do {					\
+  do						\
+    {						\
       FP_UNPACK_RAW_E(X,val);			\
       _FP_UNPACK_CANONICAL(E,2,X);		\
-  } while (0)
+    }						\
+  while (0)
 
 # define FP_UNPACK_EP(X,val)			\
-  do {					\
+  do						\
+    {						\
       FP_UNPACK_RAW_EP(X,val);			\
       _FP_UNPACK_CANONICAL(E,2,X);		\
-  } while (0)
+    }						\
+  while (0)
 
 # define FP_UNPACK_SEMIRAW_E(X,val)		\
-  do {					\
+  do						\
+    {						\
       FP_UNPACK_RAW_E(X,val);			\
       _FP_UNPACK_SEMIRAW(E,2,X);		\
-  } while (0)
+    }						\
+  while (0)
 
 # define FP_UNPACK_SEMIRAW_EP(X,val)		\
-  do {					\
+  do						\
+    {						\
       FP_UNPACK_RAW_EP(X,val);			\
       _FP_UNPACK_SEMIRAW(E,2,X);		\
-  } while (0)
+    }						\
+  while (0)
 
 # define FP_PACK_E(val,X)			\
-  do {					\
+  do						\
+    {						\
       _FP_PACK_CANONICAL(E,2,X);		\
       FP_PACK_RAW_E(val,X);			\
-  } while (0)
+    }						\
+  while (0)
 
 # define FP_PACK_EP(val,X)			\
-  do {					\
+  do						\
+    {						\
       _FP_PACK_CANONICAL(E,2,X);		\
       FP_PACK_RAW_EP(val,X);			\
-  } while (0)
+    }						\
+  while (0)
 
 # define FP_PACK_SEMIRAW_E(val,X)		\
-  do {					\
+  do						\
+    {						\
       _FP_PACK_SEMIRAW(E,2,X);			\
       FP_PACK_RAW_E(val,X);			\
-  } while (0)
+    }						\
+  while (0)
 
 # define FP_PACK_SEMIRAW_EP(val,X)		\
-  do {					\
+  do						\
+    {						\
       _FP_PACK_SEMIRAW(E,2,X);			\
       FP_PACK_RAW_EP(val,X);			\
-  } while (0)
+    }						\
+  while (0)
 
 # define FP_ISSIGNAN_E(X)	_FP_ISSIGNAN(E,2,X)
 # define FP_NEG_E(R,X)		_FP_NEG(E,2,R,X)
@@ -404,7 +463,8 @@ union _FP_UNION_E
  * have to.
  */
 # define _FP_SQRT_MEAT_E(R, S, T, X, q)			\
-  do {							\
+  do							\
+    {							\
       q = (_FP_W_TYPE)1 << (_FP_W_TYPE_SIZE - 1);	\
       _FP_FRAC_SRL_2(X, (_FP_WORKBITS));		\
       while (q)						\
@@ -426,7 +486,8 @@ union _FP_UNION_E
 	    R##_f0 |= _FP_WORK_ROUND;			\
 	  R##_f0 |= _FP_WORK_STICKY;			\
 	}						\
-  } while (0)
+    }							\
+  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)

soft-fp/extendsfdf2.c

@@ -32,7 +32,8 @@
 #include "single.h"
 #include "double.h"
 
-DFtype __extendsfdf2(SFtype a)
+DFtype
+__extendsfdf2(SFtype a)
 {
   FP_DECL_EX;
   FP_DECL_S(A);

soft-fp/extendsftf2.c

@@ -32,7 +32,8 @@
 #include "single.h"
 #include "quad.h"
 
-TFtype __extendsftf2(SFtype a)
+TFtype
+__extendsftf2(SFtype a)
 {
   FP_DECL_EX;
   FP_DECL_S(A);

soft-fp/extendxftf2.c

@@ -31,7 +31,8 @@
 #include "extended.h"
 #include "quad.h"
 
-TFtype __extendxftf2(XFtype a)
+TFtype
+__extendxftf2(XFtype a)
 {
   FP_DECL_EX;
   FP_DECL_E(A);

soft-fp/fixdfdi.c

@@ -31,7 +31,8 @@
 #include "soft-fp.h"
 #include "double.h"
 
-DItype __fixdfdi(DFtype a)
+DItype
+__fixdfdi(DFtype a)
 {
   FP_DECL_EX;
   FP_DECL_D(A);

soft-fp/fixdfsi.c

@@ -31,7 +31,8 @@
 #include "soft-fp.h"
 #include "double.h"
 
-SItype __fixdfsi(DFtype a)
+SItype
+__fixdfsi(DFtype a)
 {
   FP_DECL_EX;
   FP_DECL_D(A);

soft-fp/fixdfti.c

@@ -30,7 +30,8 @@
 #include "soft-fp.h"
 #include "double.h"
 
-TItype __fixdfti(DFtype a)
+TItype
+__fixdfti(DFtype a)
 {
   FP_DECL_EX;
   FP_DECL_D(A);

soft-fp/fixsfdi.c

@@ -31,7 +31,8 @@
 #include "soft-fp.h"
 #include "single.h"
 
-DItype __fixsfdi(SFtype a)
+DItype
+__fixsfdi(SFtype a)
 {
   FP_DECL_EX;
   FP_DECL_S(A);

soft-fp/fixsfsi.c

@@ -31,7 +31,8 @@
 #include "soft-fp.h"
 #include "single.h"
 
-SItype __fixsfsi(SFtype a)
+SItype
+__fixsfsi(SFtype a)
 {
   FP_DECL_EX;
   FP_DECL_S(A);

soft-fp/fixsfti.c

@@ -30,7 +30,8 @@
 #include "soft-fp.h"
 #include "single.h"
 
-TItype __fixsfti(SFtype a)
+TItype
+__fixsfti(SFtype a)
 {
   FP_DECL_EX;
   FP_DECL_S(A);

soft-fp/fixtfdi.c

@@ -31,7 +31,8 @@
 #include "soft-fp.h"
 #include "quad.h"
 
-DItype __fixtfdi(TFtype a)
+DItype
+__fixtfdi(TFtype a)
 {
   FP_DECL_EX;
   FP_DECL_Q(A);

soft-fp/fixtfsi.c

@@ -31,7 +31,8 @@
 #include "soft-fp.h"
 #include "quad.h"
 
-SItype __fixtfsi(TFtype a)
+SItype
+__fixtfsi(TFtype a)
 {
   FP_DECL_EX;
   FP_DECL_Q(A);

soft-fp/fixtfti.c

@@ -30,7 +30,8 @@
 #include "soft-fp.h"
 #include "quad.h"
 
-TItype __fixtfti(TFtype a)
+TItype
+__fixtfti(TFtype a)
 {
   FP_DECL_EX;
   FP_DECL_Q(A);

soft-fp/fixunsdfdi.c

@@ -31,7 +31,8 @@
 #include "soft-fp.h"
 #include "double.h"
 
-UDItype __fixunsdfdi(DFtype a)
+UDItype
+__fixunsdfdi(DFtype a)
 {
   FP_DECL_EX;
   FP_DECL_D(A);

soft-fp/fixunsdfsi.c

@@ -31,7 +31,8 @@
 #include "soft-fp.h"
 #include "double.h"
 
-USItype __fixunsdfsi(DFtype a)
+USItype
+__fixunsdfsi(DFtype a)
 {
   FP_DECL_EX;
   FP_DECL_D(A);

soft-fp/fixunsdfti.c

@@ -30,7 +30,8 @@
 #include "soft-fp.h"
 #include "double.h"
 
-UTItype __fixunsdfti(DFtype a)
+UTItype
+__fixunsdfti(DFtype a)
 {
   FP_DECL_EX;
   FP_DECL_D(A);

soft-fp/fixunssfdi.c

@@ -31,7 +31,8 @@
 #include "soft-fp.h"
 #include "single.h"
 
-UDItype __fixunssfdi(SFtype a)
+UDItype
+__fixunssfdi(SFtype a)
 {
   FP_DECL_EX;
   FP_DECL_S(A);

soft-fp/fixunssfsi.c

@@ -31,7 +31,8 @@
 #include "soft-fp.h"
 #include "single.h"
 
-USItype __fixunssfsi(SFtype a)
+USItype
+__fixunssfsi(SFtype a)
 {
   FP_DECL_EX;
   FP_DECL_S(A);

soft-fp/fixunssfti.c

@@ -30,7 +30,8 @@
 #include "soft-fp.h"
 #include "single.h"
 
-UTItype __fixunssfti(SFtype a)
+UTItype
+__fixunssfti(SFtype a)
 {
   FP_DECL_EX;
   FP_DECL_S(A);

soft-fp/fixunstfdi.c

@@ -31,7 +31,8 @@
 #include "soft-fp.h"
 #include "quad.h"
 
-UDItype __fixunstfdi(TFtype a)
+UDItype
+__fixunstfdi(TFtype a)
 {
   FP_DECL_EX;
   FP_DECL_Q(A);

soft-fp/fixunstfsi.c

@@ -31,7 +31,8 @@
 #include "soft-fp.h"
 #include "quad.h"
 
-USItype __fixunstfsi(TFtype a)
+USItype
+__fixunstfsi(TFtype a)
 {
   FP_DECL_EX;
   FP_DECL_Q(A);

soft-fp/fixunstfti.c

@@ -30,7 +30,8 @@
 #include "soft-fp.h"
 #include "quad.h"
 
-UTItype __fixunstfti(TFtype a)
+UTItype
+__fixunstfti(TFtype a)
 {
   FP_DECL_EX;
   FP_DECL_Q(A);

soft-fp/floatdidf.c

@@ -31,7 +31,8 @@
 #include "soft-fp.h"
 #include "double.h"
 
-DFtype __floatdidf(DItype i)
+DFtype
+__floatdidf(DItype i)
 {
   FP_DECL_EX;
   FP_DECL_D(A);

soft-fp/floatdisf.c

@@ -31,7 +31,8 @@
 #include "soft-fp.h"
 #include "single.h"
 
-SFtype __floatdisf(DItype i)
+SFtype
+__floatdisf(DItype i)
 {
   FP_DECL_EX;
   FP_DECL_S(A);

soft-fp/floatditf.c

@@ -32,7 +32,8 @@
 #include "soft-fp.h"
 #include "quad.h"
 
-TFtype __floatditf(DItype i)
+TFtype
+__floatditf(DItype i)
 {
   FP_DECL_Q(A);
   TFtype a;

soft-fp/floatsidf.c

@@ -32,7 +32,8 @@
 #include "soft-fp.h"
 #include "double.h"
 
-DFtype __floatsidf(SItype i)
+DFtype
+__floatsidf(SItype i)
 {
   FP_DECL_D(A);
   DFtype a;

soft-fp/floatsisf.c

@@ -31,7 +31,8 @@
 #include "soft-fp.h"
 #include "single.h"
 
-SFtype __floatsisf(SItype i)
+SFtype
+__floatsisf(SItype i)
 {
   FP_DECL_EX;
   FP_DECL_S(A);

soft-fp/floatsitf.c

@@ -32,7 +32,8 @@
 #include "soft-fp.h"
 #include "quad.h"
 
-TFtype __floatsitf(SItype i)
+TFtype
+__floatsitf(SItype i)
 {
   FP_DECL_Q(A);
   TFtype a;

soft-fp/floattidf.c

@@ -30,7 +30,8 @@
 #include "soft-fp.h"
 #include "double.h"
 
-DFtype __floattidf(TItype i)
+DFtype
+__floattidf(TItype i)
 {
   FP_DECL_EX;
   FP_DECL_D(A);

soft-fp/floattisf.c

@@ -30,7 +30,8 @@
 #include "soft-fp.h"
 #include "single.h"
 
-SFtype __floattisf(TItype i)
+SFtype
+__floattisf(TItype i)
 {
   FP_DECL_EX;
   FP_DECL_S(A);

soft-fp/floattitf.c

@@ -30,7 +30,8 @@
 #include "soft-fp.h"
 #include "quad.h"
 
-TFtype __floattitf(TItype i)
+TFtype
+__floattitf(TItype i)
 {
   FP_DECL_EX;
   FP_DECL_Q(A);

soft-fp/floatundidf.c

@@ -31,7 +31,8 @@
 #include "soft-fp.h"
 #include "double.h"
 
-DFtype __floatundidf(UDItype i)
+DFtype
+__floatundidf(UDItype i)
 {
   FP_DECL_EX;
   FP_DECL_D(A);

soft-fp/floatundisf.c

@@ -31,7 +31,8 @@
 #include "soft-fp.h"
 #include "single.h"
 
-SFtype __floatundisf(UDItype i)
+SFtype
+__floatundisf(UDItype i)
 {
   FP_DECL_EX;
   FP_DECL_S(A);

soft-fp/floatunsidf.c

@@ -32,7 +32,8 @@
 #include "soft-fp.h"
 #include "double.h"
 
-DFtype __floatunsidf(USItype i)
+DFtype
+__floatunsidf(USItype i)
 {
   FP_DECL_D(A);
   DFtype a;

soft-fp/floatunsisf.c

@@ -31,7 +31,8 @@
 #include "soft-fp.h"
 #include "single.h"
 
-SFtype __floatunsisf(USItype i)
+SFtype
+__floatunsisf(USItype i)
 {
   FP_DECL_EX;
   FP_DECL_S(A);

soft-fp/floatuntidf.c

@@ -30,7 +30,8 @@
 #include "soft-fp.h"
 #include "double.h"
 
-DFtype __floatuntidf(UTItype i)
+DFtype
+__floatuntidf(UTItype i)
 {
   FP_DECL_EX;
   FP_DECL_D(A);

soft-fp/floatuntisf.c

@@ -30,7 +30,8 @@
 #include "soft-fp.h"
 #include "single.h"
 
-SFtype __floatuntisf(UTItype i)
+SFtype
+__floatuntisf(UTItype i)
 {
   FP_DECL_EX;
   FP_DECL_S(A);

soft-fp/floatuntitf.c

@@ -30,7 +30,8 @@
 #include "soft-fp.h"
 #include "quad.h"
 
-TFtype __floatuntitf(UTItype i)
+TFtype
+__floatuntitf(UTItype i)
 {
   FP_DECL_EX;
   FP_DECL_Q(A);

soft-fp/fmadf4.c

@@ -33,7 +33,10 @@ double
 __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;

soft-fp/fmasf4.c

@@ -33,7 +33,10 @@ float
 __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;

soft-fp/fmatf4.c

@@ -33,7 +33,10 @@ long double
 __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;

soft-fp/gedf2.c

@@ -31,10 +31,12 @@
 #include "soft-fp.h"
 #include "double.h"
 
-CMPtype __gedf2(DFtype a, DFtype b)
+CMPtype
+__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;

soft-fp/gesf2.c

@@ -31,10 +31,12 @@
 #include "soft-fp.h"
 #include "single.h"
 
-CMPtype __gesf2(SFtype a, SFtype b)
+CMPtype
+__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;

soft-fp/getf2.c

@@ -31,10 +31,12 @@
 #include "soft-fp.h"
 #include "quad.h"
 
-CMPtype __getf2(TFtype a, TFtype b)
+CMPtype
+__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;

soft-fp/ledf2.c

@@ -31,10 +31,12 @@
 #include "soft-fp.h"
 #include "double.h"
 
-CMPtype __ledf2(DFtype a, DFtype b)
+CMPtype
+__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;

soft-fp/lesf2.c

@@ -31,10 +31,12 @@
 #include "soft-fp.h"
 #include "single.h"
 
-CMPtype __lesf2(SFtype a, SFtype b)
+CMPtype
+__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;

soft-fp/letf2.c

@@ -31,10 +31,12 @@
 #include "soft-fp.h"
 #include "quad.h"
 
-CMPtype __letf2(TFtype a, TFtype b)
+CMPtype
+__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;

soft-fp/muldf3.c

@@ -31,10 +31,13 @@
 #include "soft-fp.h"
 #include "double.h"
 
-DFtype __muldf3(DFtype a, DFtype b)
+DFtype
+__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;

soft-fp/mulsf3.c

@@ -31,10 +31,13 @@
 #include "soft-fp.h"
 #include "single.h"
 
-SFtype __mulsf3(SFtype a, SFtype b)
+SFtype
+__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;

soft-fp/multf3.c

@@ -31,10 +31,13 @@
 #include "soft-fp.h"
 #include "quad.h"
 
-TFtype __multf3(TFtype a, TFtype b)
+TFtype
+__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;

soft-fp/negdf2.c

@@ -31,9 +31,11 @@
 #include "soft-fp.h"
 #include "double.h"
 
-DFtype __negdf2(DFtype a)
+DFtype
+__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);

soft-fp/negsf2.c

@@ -31,9 +31,11 @@
 #include "soft-fp.h"
 #include "single.h"
 
-SFtype __negsf2(SFtype a)
+SFtype
+__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);

soft-fp/negtf2.c

@@ -31,9 +31,11 @@
 #include "soft-fp.h"
 #include "quad.h"
 
-TFtype __negtf2(TFtype a)
+TFtype
+__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);

soft-fp/op-1.h

@@ -39,12 +39,14 @@
 
 #define _FP_FRAC_ADDI_1(X,I)	(X##_f += I)
 #define _FP_FRAC_SLL_1(X,N)			\
-  do {						\
+  do						\
+    {						\
       if (__builtin_constant_p(N) && (N) == 1)	\
 	X##_f += X##_f;				\
       else					\
 	X##_f <<= (N);				\
-  } while (0)
+    }						\
+  while (0)
 #define _FP_FRAC_SRL_1(X,N)	(X##_f >>= N)
 
 /* Right shift with sticky-lsb.  */
@@ -52,15 +54,19 @@
 #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 {							\
+  do							\
+    {							\
       S = (__builtin_constant_p(N) && (N) == 1		\
-       ? X & 1 : (X << (_FP_W_TYPE_SIZE - (N))) != 0);	\
+	   ? X & 1					\
+	   : (X << (_FP_W_TYPE_SIZE - (N))) != 0);	\
       X = X >> (N);					\
-} while (0)
+    }							\
+  while (0)
 
 #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)))
+		    ? 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)
@@ -87,30 +93,35 @@ do {							\
  */
 
 #define _FP_UNPACK_RAW_1(fs, X, val)		\
-  do {								\
+  do						\
-    union _FP_UNION_##fs _flo; _flo.flt = (val);		\
+    {						\
+      union _FP_UNION_##fs _flo;		\
+      _flo.flt = (val);				\
 						\
       X##_f = _flo.bits.frac;			\
       X##_e = _flo.bits.exp;			\
       X##_s = _flo.bits.sign;			\
-  } while (0)
+    }						\
+  while (0)
 
 #define _FP_UNPACK_RAW_1_P(fs, X, val)					\
-  do {								\
+  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;						\
       X##_s = _flo->bits.sign;						\
-  } while (0)
+    }									\
+  while (0)
 
 /*
  * Repack the raw bits of a native fp value.
  */
 
 #define _FP_PACK_RAW_1(fs, val, X)		\
-  do {								\
+  do						\
+    {						\
       union _FP_UNION_##fs _flo;		\
 						\
       _flo.bits.frac = X##_f;			\
@@ -118,17 +129,19 @@ do {							\
       _flo.bits.sign = X##_s;			\
 						\
       (val) = _flo.flt;				\
-  } while (0)
+    }						\
+  while (0)
 
 #define _FP_PACK_RAW_1_P(fs, val, X)					\
-  do {								\
+  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;						\
       _flo->bits.sign = X##_s;						\
-  } while (0)
+    }									\
+  while (0)
 
 
 /*
@@ -139,28 +152,35 @@ do {							\
    multiplication immediately.  */
 
 #define _FP_MUL_MEAT_DW_1_imm(wfracbits, R, X, Y)	\
-  do {									\
+  do							\
+    {							\
       R##_f = X##_f * Y##_f;				\
-  } while (0)
+    }							\
+  while (0)
 
 #define _FP_MUL_MEAT_1_imm(wfracbits, R, X, Y)				\
-  do {									\
+  do									\
+    {									\
       _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);			\
-  } while (0)
+    }									\
+  while (0)
 
 /* Given a 1W * 1W => 2W primitive, do the extended multiplication.  */
 
 #define _FP_MUL_MEAT_DW_1_wide(wfracbits, R, X, Y, doit)	\
-  do {									\
+  do								\
+    {								\
       doit(R##_f1, R##_f0, X##_f, Y##_f);			\
-  } while (0)
+    }								\
+  while (0)
 
 #define _FP_MUL_MEAT_1_wide(wfracbits, R, X, Y, doit)			\
-  do {									\
+  do									\
+    {									\
       _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	\
@@ -168,12 +188,14 @@ do {							\
 	 at either 2B or 2B-1.  */					\
       _FP_FRAC_SRS_2(_Z, wfracbits-1, 2*wfracbits);			\
       R##_f = _Z_f0;							\
-  } while (0)
+    }									\
+  while (0)
 
 /* Finally, a simple widening multiply algorithm.  What fun!  */
 
 #define _FP_MUL_MEAT_DW_1_hard(wfracbits, R, X, Y)			\
-  do {									\
+  do									\
+    {									\
       _FP_W_TYPE _xh, _xl, _yh, _yl;					\
       _FP_FRAC_DECL_2(_a);						\
 									\
@@ -195,17 +217,20 @@ do {							\
       _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);						\
-  } while (0)
+    }									\
+  while (0)
 
 #define _FP_MUL_MEAT_1_hard(wfracbits, R, X, Y)		\
-  do {									\
+  do							\
+    {							\
       _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);	\
       R##_f = _z_f0;					\
-  } while (0)
+    }							\
+  while (0)
 
 
 /*
@@ -218,14 +243,16 @@ do {							\
    choose will depend on what the compiler does with divrem4.  */
 
 #define _FP_DIV_MEAT_1_imm(fs, R, X, Y, doit)	\
-  do {							\
+  do						\
+    {						\
       _FP_W_TYPE _q, _r;			\
       X##_f <<= (X##_f < Y##_f			\
 		 ? R##_e--, _FP_WFRACBITS_##fs	\
 		 : _FP_WFRACBITS_##fs - 1);	\
       doit(_q, _r, X##_f, Y##_f);		\
       R##_f = _q | (_r != 0);			\
-  } while (0)
+    }						\
+  while (0)
 
 /* GCC's longlong.h defines a 2W / 1W => (1W,1W) primitive udiv_qrnnd
    that may be useful in this situation.  This first is for a primitive
@@ -233,7 +260,8 @@ do {							\
    for UDIV_NEEDS_NORMALIZATION to tell which your machine needs.  */
 
 #define _FP_DIV_MEAT_1_udiv_norm(fs, R, X, Y)				\
-  do {									\
+  do									\
+    {									\
       _FP_W_TYPE _nh, _nl, _q, _r, _y;					\
 									\
       /* Normalize Y -- i.e. make the most significant bit set.  */	\
@@ -254,10 +282,12 @@ do {							\
 									\
       udiv_qrnnd(_q, _r, _nh, _nl, _y);					\
       R##_f = _q | (_r != 0);						\
-  } while (0)
+    }									\
+  while (0)
 
 #define _FP_DIV_MEAT_1_udiv(fs, R, X, Y)		\
-  do {							\
+  do							\
+    {							\
       _FP_W_TYPE _nh, _nl, _q, _r;			\
       if (X##_f < Y##_f)				\
 	{						\
@@ -272,7 +302,8 @@ do {							\
 	}						\
       udiv_qrnnd(_q, _r, _nh, _nl, Y##_f);		\
       R##_f = _q | (_r != 0);				\
-  } while (0)
+    }							\
+  while (0)
 
 
 /*
@@ -282,7 +313,8 @@ do {							\
  */
 
 #define _FP_SQRT_MEAT_1(R, S, T, X, q)		\
-  do {							\
+  do						\
+    {						\
       while (q != _FP_WORK_ROUND)		\
 	{					\
 	  T##_f = S##_f + q;			\
@@ -301,7 +333,8 @@ do {							\
 	    R##_f |= _FP_WORK_ROUND;		\
 	  R##_f |= _FP_WORK_STICKY;		\
 	}					\
-  } while (0)
+    }						\
+  while (0)
 
 /*
  * Assembly/disassembly for converting to/from integral types.

soft-fp/op-2.h

@@ -38,7 +38,7 @@
 #define _FP_FRAC_WORD_2(X,w)	(X##_f##w)
 
 #define _FP_FRAC_SLL_2(X,N)						\
-(void)(((N) < _FP_W_TYPE_SIZE)						    \
+  (void)(((N) < _FP_W_TYPE_SIZE)					\
 	 ? ({								\
 	     if (__builtin_constant_p(N) && (N) == 1)			\
 	       {							\
@@ -59,7 +59,7 @@
 
 
 #define _FP_FRAC_SRL_2(X,N)						\
-(void)(((N) < _FP_W_TYPE_SIZE)						\
+  (void)(((N) < _FP_W_TYPE_SIZE)					\
 	 ? ({								\
 	     X##_f0 = X##_f0 >> (N) | X##_f1 << (_FP_W_TYPE_SIZE - (N)); \
 	     X##_f1 >>= (N);						\
@@ -71,7 +71,7 @@
 
 /* Right shift with sticky-lsb.  */
 #define _FP_FRAC_SRST_2(X,S, N,sz)					\
-(void)(((N) < _FP_W_TYPE_SIZE)						  \
+  (void)(((N) < _FP_W_TYPE_SIZE)					\
 	 ? ({								\
 	     S = (__builtin_constant_p(N) && (N) == 1			\
 		  ? X##_f0 & 1						\
@@ -89,17 +89,17 @@
 	   }))
 
 #define _FP_FRAC_SRS_2(X,N,sz)						\
-(void)(((N) < _FP_W_TYPE_SIZE)						  \
+  (void)(((N) < _FP_W_TYPE_SIZE)					\
 	 ? ({								\
-	    X##_f0 = (X##_f1 << (_FP_W_TYPE_SIZE - (N)) | X##_f0 >> (N) | \
+	     X##_f0 = (X##_f1 << (_FP_W_TYPE_SIZE - (N)) | X##_f0 >> (N) \
-		      (__builtin_constant_p(N) && (N) == 1		  \
+		       | (__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) |		  \
+	     X##_f0 = (X##_f1 >> ((N) - _FP_W_TYPE_SIZE)		\
-		      ((((N) == _FP_W_TYPE_SIZE				  \
+		       | ((((N) == _FP_W_TYPE_SIZE			\
 			  ? 0						\
 			  : (X##_f1 << (2*_FP_W_TYPE_SIZE - (N))))	\
 			 | X##_f0) != 0));				\
@@ -119,7 +119,8 @@
   __FP_FRAC_DEC_2(X##_f1, X##_f0, Y##_f1, Y##_f0)
 
 #define _FP_FRAC_CLZ_2(R,X)			\
-  do {				\
+  do						\
+    {						\
       if (X##_f1)				\
 	__FP_CLZ(R,X##_f1);			\
       else					\
@@ -127,7 +128,8 @@
 	  __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)
@@ -153,7 +155,8 @@
 #define __FP_FRAC_SET_2(X,I1,I0)	(X##_f0 = I0, X##_f1 = I1)
 
 #define __FP_CLZ_2(R, xh, xl)			\
-  do {				\
+  do						\
+    {						\
       if (xh)					\
 	__FP_CLZ(R,xh);				\
       else					\
@@ -161,7 +164,8 @@
 	  __FP_CLZ(R,xl);			\
 	  R += _FP_W_TYPE_SIZE;			\
 	}					\
-  } while(0)
+    }						\
+  while(0)
 
 #if 0
 
@@ -179,10 +183,12 @@
 # endif
 # ifndef __FP_FRAC_DEC_2
 #  define __FP_FRAC_DEC_2(xh, xl, yh, yl)	\
-  do {					\
+  do						\
+    {						\
       UWtype _t = xl;				\
       xh -= yh + ((xl -= yl) > _t);		\
-  } while (0)
+    }						\
+  while (0)
 # endif
 
 #else
@@ -205,25 +211,29 @@
  */
 
 #define _FP_UNPACK_RAW_2(fs, X, val)		\
-  do {							\
+  do						\
-    union _FP_UNION_##fs _flo; _flo.flt = (val);	\
+    {						\
+      union _FP_UNION_##fs _flo;		\
+      _flo.flt = (val);				\
 						\
       X##_f0 = _flo.bits.frac0;			\
       X##_f1 = _flo.bits.frac1;			\
       X##_e  = _flo.bits.exp;			\
       X##_s  = _flo.bits.sign;			\
-  } while (0)
+    }						\
+  while (0)
 
 #define _FP_UNPACK_RAW_2_P(fs, X, val)					\
-  do {							\
+  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;					\
       X##_e  = _flo->bits.exp;						\
       X##_s  = _flo->bits.sign;						\
-  } while (0)
+    }									\
+  while (0)
 
 
 /*
@@ -231,7 +241,8 @@
  */
 
 #define _FP_PACK_RAW_2(fs, val, X)		\
-  do {							\
+  do						\
+    {						\
       union _FP_UNION_##fs _flo;		\
 						\
       _flo.bits.frac0 = X##_f0;			\
@@ -240,18 +251,20 @@
       _flo.bits.sign  = X##_s;			\
 						\
       (val) = _flo.flt;				\
-  } while (0)
+    }						\
+  while (0)
 
 #define _FP_PACK_RAW_2_P(fs, val, X)					\
-  do {							\
+  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;					\
       _flo->bits.exp   = X##_e;						\
       _flo->bits.sign  = X##_s;						\
-  } while (0)
+    }									\
+  while (0)
 
 
 /*
@@ -261,8 +274,10 @@
 /* Given a 1W * 1W => 2W primitive, do the extended multiplication.  */
 
 #define _FP_MUL_MEAT_DW_2_wide(wfracbits, R, X, Y, doit)		\
-  do {									\
+  do									\
-    _FP_FRAC_DECL_2(_b); _FP_FRAC_DECL_2(_c);				\
+    {									\
+      _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);				\
@@ -277,10 +292,12 @@
 		      _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)
+    }									\
+  while (0)
 
 #define _FP_MUL_MEAT_2_wide(wfracbits, R, X, Y, doit)			\
-  do {									\
+  do									\
+    {									\
       _FP_FRAC_DECL_4(_z);						\
 									\
       _FP_MUL_MEAT_DW_2_wide(wfracbits, _z, X, Y, doit);		\
@@ -291,15 +308,18 @@
       _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)
+    }									\
+  while (0)
 
 /* Given a 1W * 1W => 2W primitive, do the extended multiplication.
    Do only 3 multiplications instead of four. This one is for machines
    where multiplication is much more expensive than subtraction.  */
 
 #define _FP_MUL_MEAT_DW_2_wide_3mul(wfracbits, R, X, Y, doit)		\
-  do {									\
+  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;							\
 									\
@@ -328,10 +348,12 @@
       __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)
+    }									\
+  while (0)
 
 #define _FP_MUL_MEAT_2_wide_3mul(wfracbits, R, X, Y, doit)		\
-  do {									\
+  do									\
+    {									\
       _FP_FRAC_DECL_4(_z);						\
 									\
       _FP_MUL_MEAT_DW_2_wide_3mul(wfracbits, _z, X, Y, doit);		\
@@ -342,19 +364,25 @@
       _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)
+    }									\
+  while (0)
 
 #define _FP_MUL_MEAT_DW_2_gmp(wfracbits, R, X, Y)	\
-  do {									\
+  do							\
+    {							\
       _FP_W_TYPE _x[2], _y[2];				\
-    _x[0] = X##_f0; _x[1] = X##_f1;					\
+      _x[0] = X##_f0;					\
-    _y[0] = Y##_f0; _y[1] = Y##_f1;					\
+      _x[1] = X##_f1;					\
+      _y[0] = Y##_f0;					\
+      _y[1] = Y##_f1;					\
 							\
       mpn_mul_n(R##_f, _x, _y, 2);			\
-  } while (0)
+    }							\
+  while (0)
 
 #define _FP_MUL_MEAT_2_gmp(wfracbits, R, X, Y)				\
-  do {									\
+  do									\
+    {									\
       _FP_FRAC_DECL_4(_z);						\
 									\
       _FP_MUL_MEAT_DW_2_gmp(wfracbits, _z, X, Y);			\
@@ -365,7 +393,8 @@
       _FP_FRAC_SRS_4(_z, wfracbits-1, 2*wfracbits);			\
       R##_f0 = _z_f[0];							\
       R##_f1 = _z_f[1];							\
-  } while (0)
+    }									\
+  while (0)
 
 /* Do at most 120x120=240 bits multiplication using double floating
    point multiplication.  This is useful if floating point
@@ -377,8 +406,10 @@
    towards zero,  RESETFE should optionally reset it back.  */
 
 #define _FP_MUL_MEAT_2_120_240_double(wfracbits, R, X, Y, setfetz, resetfe) \
-  do {										\
+  do									\
-    static const double _const[] = {						\
+    {									\
+      static const double _const[] =					\
+	{								\
 	  /* 2^-24 */ 5.9604644775390625e-08,				\
 	  /* 2^-48 */ 3.5527136788005009e-15,				\
 	  /* 2^-72 */ 2.1175823681357508e-22,				\
@@ -389,7 +420,8 @@
 	  /* 2^-44 */ 5.6843418860808015e-14,				\
 	  /* 2^-68 */ 3.3881317890172014e-21,				\
 	  /* 2^-92 */ 2.0194839173657902e-28,				\
-      /* 2^-116 */ 1.2037062152420224e-35};					\
+	  /* 2^-116 */ 1.2037062152420224e-35				\
+	};								\
       double _a240, _b240, _c240, _d240, _e240, _f240,			\
 	_g240, _h240, _i240, _j240, _k240;				\
       union { double d; UDItype i; } _l240, _m240, _n240, _o240,	\
@@ -419,11 +451,11 @@
       _h240 *= _const[1];						\
       _b240 *= _const[0];						\
       _g240 *= _const[0];						\
-    _s240.d =							      _e240*_j240;\
+      _s240.d =							      _e240*_j240; \
-    _r240.d =						_d240*_j240 + _e240*_i240;\
+      _r240.d =						_d240*_j240 + _e240*_i240; \
-    _q240.d =				  _c240*_j240 + _d240*_i240 + _e240*_h240;\
+      _q240.d =				  _c240*_j240 + _d240*_i240 + _e240*_h240; \
-    _p240.d =		    _b240*_j240 + _c240*_i240 + _d240*_h240 + _e240*_g240;\
+      _p240.d =		    _b240*_j240 + _c240*_i240 + _d240*_h240 + _e240*_g240; \
-    _o240.d = _a240*_j240 + _b240*_i240 + _c240*_h240 + _d240*_g240 + _e240*_f240;\
+      _o240.d = _a240*_j240 + _b240*_i240 + _c240*_h240 + _d240*_g240 + _e240*_f240; \
       _n240.d = _a240*_i240 + _b240*_h240 + _c240*_g240 + _d240*_f240;	\
       _m240.d = _a240*_h240 + _b240*_g240 + _c240*_f240;		\
       _l240.d = _a240*_g240 + _b240*_f240;				\
@@ -444,31 +476,37 @@
       _n240.d += _const[6];						\
       _m240.d += _const[5];						\
       _l240.d += _const[4];						\
-    if (_s240.d != 0.0) _y240 = 1;						\
+      if (_s240.d != 0.0)						\
-    if (_r240.d != 0.0) _y240 = 1;						\
+	_y240 = 1;							\
-    if (_q240.d != 0.0) _y240 = 1;						\
+      if (_r240.d != 0.0)						\
-    if (_p240.d != 0.0) _y240 = 1;						\
+	_y240 = 1;							\
+      if (_q240.d != 0.0)						\
+	_y240 = 1;							\
+      if (_p240.d != 0.0)						\
+	_y240 = 1;							\
       _t240 = (DItype)_k240;						\
       _u240 = _l240.i;							\
       _v240 = _m240.i;							\
       _w240 = _n240.i;							\
       _x240 = _o240.i;							\
-    R##_f1 = (_t240 << (128 - (wfracbits - 1)))					\
+      R##_f1 = ((_t240 << (128 - (wfracbits - 1)))			\
-	     | ((_u240 & 0xffffff) >> ((wfracbits - 1) - 104));			\
+		| ((_u240 & 0xffffff) >> ((wfracbits - 1) - 104)));	\
-    R##_f0 = ((_u240 & 0xffffff) << (168 - (wfracbits - 1)))			\
+      R##_f0 = (((_u240 & 0xffffff) << (168 - (wfracbits - 1)))		\
 		| ((_v240 & 0xffffff) << (144 - (wfracbits - 1)))	\
 		| ((_w240 & 0xffffff) << (120 - (wfracbits - 1)))	\
 		| ((_x240 & 0xffffff) >> ((wfracbits - 1) - 96))	\
-	     | _y240;								\
+		| _y240);						\
       resetfe;								\
-  } while (0)
+    }									\
+  while (0)
 
 /*
  * Division algorithms:
  */
 
 #define _FP_DIV_MEAT_2_udiv(fs, R, X, Y)				\
-  do {									\
+  do									\
+    {									\
       _FP_W_TYPE _n_f2, _n_f1, _n_f0, _r_f1, _r_f0, _m_f1, _m_f0;	\
       if (_FP_FRAC_GE_2(X, Y))						\
 	{								\
@@ -532,26 +570,29 @@
 	  if (!_FP_FRAC_EQ_2(_r, _m))					\
 	    R##_f0 |= _FP_WORK_STICKY;					\
 	}								\
-  } while (0)
+    }									\
+  while (0)
 
 
 #define _FP_DIV_MEAT_2_gmp(fs, R, X, Y)					\
-  do {									\
+  do									\
+    {									\
       _FP_W_TYPE _x[4], _y[2], _z[4];					\
-    _y[0] = Y##_f0; _y[1] = Y##_f1;					\
+      _y[0] = Y##_f0;							\
+      _y[1] = Y##_f1;							\
       _x[0] = _x[3] = 0;						\
       if (_FP_FRAC_GE_2(X, Y))						\
 	{								\
-	_x[1] = (X##_f0 << (_FP_WFRACBITS_##fs-1 - _FP_W_TYPE_SIZE) |	\
+	  _x[1] = (X##_f0 << (_FP_WFRACBITS_##fs-1 - _FP_W_TYPE_SIZE)	\
-		 X##_f1 >> (_FP_W_TYPE_SIZE -				\
+		   | X##_f1 >> (_FP_W_TYPE_SIZE -			\
 				(_FP_WFRACBITS_##fs-1 - _FP_W_TYPE_SIZE))); \
 	  _x[2] = X##_f1 << (_FP_WFRACBITS_##fs-1 - _FP_W_TYPE_SIZE);	\
 	}								\
       else								\
 	{								\
 	  R##_e--;							\
-	_x[1] = (X##_f0 << (_FP_WFRACBITS_##fs - _FP_W_TYPE_SIZE) |	\
+	  _x[1] = (X##_f0 << (_FP_WFRACBITS_##fs - _FP_W_TYPE_SIZE)	\
-		 X##_f1 >> (_FP_W_TYPE_SIZE -				\
+		   | X##_f1 >> (_FP_W_TYPE_SIZE -			\
 				(_FP_WFRACBITS_##fs - _FP_W_TYPE_SIZE))); \
 	  _x[2] = X##_f1 << (_FP_WFRACBITS_##fs - _FP_W_TYPE_SIZE);	\
 	}								\
@@ -559,7 +600,8 @@
       (void) mpn_divrem (_z, 0, _x, 4, _y, 2);				\
       R##_f1 = _z[1];							\
       R##_f0 = _z[0] | ((_x[0] | _x[1]) != 0);				\
-  } while (0)
+    }									\
+  while (0)
 
 
 /*
@@ -569,7 +611,8 @@
  */
 
 #define _FP_SQRT_MEAT_2(R, S, T, X, q)				\
-  do {							\
+  do								\
+    {								\
       while (q)							\
 	{							\
 	  T##_f1 = S##_f1 + q;					\
@@ -587,8 +630,8 @@
 	{							\
 	  T##_f0 = S##_f0 + q;					\
 	  T##_f1 = S##_f1;					\
-	if (T##_f1 < X##_f1 || 				\
+	  if (T##_f1 < X##_f1					\
-	    (T##_f1 == X##_f1 && T##_f0 <= X##_f0))	\
+	      || (T##_f1 == X##_f1 && T##_f0 <= X##_f0))	\
 	    {							\
 	      S##_f0 = T##_f0 + q;				\
 	      S##_f1 += (T##_f0 > S##_f0);			\
@@ -600,12 +643,13 @@
 	}							\
       if (X##_f0 | X##_f1)					\
 	{							\
-	if (S##_f1 < X##_f1 || 				\
+	  if (S##_f1 < X##_f1					\
-	    (S##_f1 == X##_f1 && S##_f0 < X##_f0))	\
+	      || (S##_f1 == X##_f1 && S##_f0 < X##_f0))		\
 	    R##_f0 |= _FP_WORK_ROUND;				\
 	  R##_f0 |= _FP_WORK_STICKY;				\
 	}							\
-  } while (0)
+    }								\
+  while (0)
 
 
 /*
@@ -614,7 +658,7 @@
  */
 
 #define _FP_FRAC_ASSEMBLE_2(r, X, rsize)	\
-(void)((rsize <= _FP_W_TYPE_SIZE)		\
+  (void)((rsize <= _FP_W_TYPE_SIZE)		\
 	 ? ({ r = X##_f0; })			\
 	 : ({					\
 	     r = X##_f1;			\
@@ -623,10 +667,12 @@
 	   }))
 
 #define _FP_FRAC_DISASSEMBLE_2(X, r, rsize)				\
-  do {									\
+  do									\
+    {									\
       X##_f0 = r;							\
       X##_f1 = (rsize <= _FP_W_TYPE_SIZE ? 0 : r >> _FP_W_TYPE_SIZE);	\
-  } while (0)
+    }									\
+  while (0)
 
 /*
  * Convert FP values between word sizes

soft-fp/op-4.h

@@ -40,7 +40,8 @@
 #define _FP_FRAC_WORD_4(X,w)	(X##_f[w])
 
 #define _FP_FRAC_SLL_4(X,N)				\
-  do {									\
+  do							\
+    {							\
       _FP_I_TYPE _up, _down, _skip, _i;			\
       _skip = (N) / _FP_W_TYPE_SIZE;			\
       _up = (N) % _FP_W_TYPE_SIZE;			\
@@ -51,17 +52,19 @@
       else						\
 	{						\
 	  for (_i = 3; _i > _skip; --_i)		\
-	  X##_f[_i] = X##_f[_i-_skip] << _up				\
+	    X##_f[_i] = (X##_f[_i-_skip] << _up		\
-		      | X##_f[_i-_skip-1] >> _down;			\
+			 | X##_f[_i-_skip-1] >> _down);	\
 	  X##_f[_i--] = X##_f[0] << _up;		\
 	}						\
       for (; _i >= 0; --_i)				\
 	X##_f[_i] = 0;					\
-  } while (0)
+    }							\
+  while (0)
 
 /* This one was broken too */
 #define _FP_FRAC_SRL_4(X,N)				\
-  do {									\
+  do							\
+    {							\
       _FP_I_TYPE _up, _down, _skip, _i;			\
       _skip = (N) / _FP_W_TYPE_SIZE;			\
       _down = (N) % _FP_W_TYPE_SIZE;			\
@@ -72,13 +75,14 @@
       else						\
 	{						\
 	  for (_i = 0; _i < 3-_skip; ++_i)		\
-	  X##_f[_i] = X##_f[_i+_skip] >> _down				\
+	    X##_f[_i] = (X##_f[_i+_skip] >> _down	\
-		      | X##_f[_i+_skip+1] << _up;			\
+			 | X##_f[_i+_skip+1] << _up);	\
 	  X##_f[_i++] = X##_f[3] >> _down;		\
 	}						\
       for (; _i < 4; ++_i)				\
 	X##_f[_i] = 0;					\
-  } while (0)
+    }							\
+  while (0)
 
 
 /* Right shift with sticky-lsb.
@@ -87,7 +91,8 @@
  * were one then we always set the LSbit.
  */
 #define _FP_FRAC_SRST_4(X,S,N,size)			\
-  do {							\
+  do							\
+    {							\
       _FP_I_TYPE _up, _down, _skip, _i;			\
       _FP_W_TYPE _s;					\
       _skip = (N) / _FP_W_TYPE_SIZE;			\
@@ -102,21 +107,24 @@
 	{						\
 	  _s |= X##_f[_i] << _up;			\
 	  for (_i = 0; _i < 3-_skip; ++_i)		\
-	  X##_f[_i] = X##_f[_i+_skip] >> _down		\
+	    X##_f[_i] = (X##_f[_i+_skip] >> _down	\
-		      | X##_f[_i+_skip+1] << _up;	\
+			 | X##_f[_i+_skip+1] << _up);	\
 	  X##_f[_i++] = X##_f[3] >> _down;		\
 	}						\
       for (; _i < 4; ++_i)				\
 	X##_f[_i] = 0;					\
       S = (_s != 0);					\
-  } while (0)
+    }							\
+  while (0)
 
 #define _FP_FRAC_SRS_4(X,N,size)		\
-  do {						\
+  do						\
+    {						\
       int _sticky;				\
       _FP_FRAC_SRST_4(X, _sticky, N, size);	\
       X##_f[0] |= _sticky;			\
-  } while (0)
+    }						\
+  while (0)
 
 #define _FP_FRAC_ADD_4(R,X,Y)						\
   __FP_FRAC_ADD_4(R##_f[3], R##_f[2], R##_f[1], R##_f[0],		\
@@ -151,30 +159,29 @@
    && X##_f[2] == Y##_f[2] && X##_f[3] == Y##_f[3])
 
 #define _FP_FRAC_GT_4(X,Y)				\
- (X##_f[3] > Y##_f[3] ||				\
+  (X##_f[3] > Y##_f[3]					\
-  (X##_f[3] == Y##_f[3] && (X##_f[2] > Y##_f[2] ||	\
+   || (X##_f[3] == Y##_f[3]				\
-   (X##_f[2] == Y##_f[2] && (X##_f[1] > Y##_f[1] ||	\
+       && (X##_f[2] > Y##_f[2]				\
-    (X##_f[1] == Y##_f[1] && X##_f[0] > Y##_f[0])	\
+	   || (X##_f[2] == Y##_f[2]			\
-   ))							\
+	       && (X##_f[1] > Y##_f[1]			\
-  ))							\
+		   || (X##_f[1] == Y##_f[1]		\
- )
+		       && X##_f[0] > Y##_f[0]))))))
 
 #define _FP_FRAC_GE_4(X,Y)				\
- (X##_f[3] > Y##_f[3] ||				\
+  (X##_f[3] > Y##_f[3]					\
-  (X##_f[3] == Y##_f[3] && (X##_f[2] > Y##_f[2] ||	\
+   || (X##_f[3] == Y##_f[3]				\
-   (X##_f[2] == Y##_f[2] && (X##_f[1] > Y##_f[1] ||	\
+       && (X##_f[2] > Y##_f[2]				\
-    (X##_f[1] == Y##_f[1] && X##_f[0] >= Y##_f[0])	\
+	   || (X##_f[2] == Y##_f[2]			\
-   ))							\
+	       && (X##_f[1] > Y##_f[1]			\
-  ))							\
+		   || (X##_f[1] == Y##_f[1]		\
- )
+		       && X##_f[0] >= Y##_f[0]))))))
 
 
 #define _FP_FRAC_CLZ_4(R,X)			\
-  do {					\
+  do						\
-    if (X##_f[3])			\
     {						\
+      if (X##_f[3])				\
 	__FP_CLZ(R,X##_f[3]);			\
-    }					\
       else if (X##_f[2])			\
 	{					\
 	  __FP_CLZ(R,X##_f[2]);			\
@@ -190,24 +197,28 @@
 	  __FP_CLZ(R,X##_f[0]);			\
 	  R += _FP_W_TYPE_SIZE*3;		\
 	}					\
-  } while(0)
+    }						\
+  while(0)
 
 
 #define _FP_UNPACK_RAW_4(fs, X, val)		\
-  do {								\
+  do						\
-    union _FP_UNION_##fs _flo; _flo.flt = (val);		\
+    {						\
+      union _FP_UNION_##fs _flo;		\
+      _flo.flt = (val);				\
       X##_f[0] = _flo.bits.frac0;		\
       X##_f[1] = _flo.bits.frac1;		\
       X##_f[2] = _flo.bits.frac2;		\
       X##_f[3] = _flo.bits.frac3;		\
       X##_e  = _flo.bits.exp;			\
       X##_s  = _flo.bits.sign;			\
-  } while (0)
+    }						\
+  while (0)
 
 #define _FP_UNPACK_RAW_4_P(fs, X, val)					\
-  do {								\
+  do									\
-    union _FP_UNION_##fs *_flo =				\
+    {									\
-      (union _FP_UNION_##fs *)(val);				\
+      union _FP_UNION_##fs *_flo = (union _FP_UNION_##fs *)(val);	\
 									\
       X##_f[0] = _flo->bits.frac0;					\
       X##_f[1] = _flo->bits.frac1;					\
@@ -215,10 +226,12 @@
       X##_f[3] = _flo->bits.frac3;					\
       X##_e  = _flo->bits.exp;						\
       X##_s  = _flo->bits.sign;						\
-  } while (0)
+    }									\
+  while (0)
 
 #define _FP_PACK_RAW_4(fs, val, X)		\
-  do {								\
+  do						\
+    {						\
       union _FP_UNION_##fs _flo;		\
       _flo.bits.frac0 = X##_f[0];		\
       _flo.bits.frac1 = X##_f[1];		\
@@ -227,12 +240,13 @@
       _flo.bits.exp   = X##_e;			\
       _flo.bits.sign  = X##_s;			\
       (val) = _flo.flt;				\
-  } while (0)
+    }						\
+  while (0)
 
 #define _FP_PACK_RAW_4_P(fs, val, X)					\
-  do {								\
+  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##_f[0];					\
       _flo->bits.frac1 = X##_f[1];					\
@@ -240,7 +254,8 @@
       _flo->bits.frac3 = X##_f[3];					\
       _flo->bits.exp   = X##_e;						\
       _flo->bits.sign  = X##_s;						\
-  } while (0)
+    }									\
+  while (0)
 
 /*
  * Multiplication algorithms:
@@ -249,9 +264,13 @@
 /* Given a 1W * 1W => 2W primitive, do the extended multiplication.  */
 
 #define _FP_MUL_MEAT_DW_4_wide(wfracbits, R, X, Y, doit)		\
-  do {									    \
+  do									\
-    _FP_FRAC_DECL_2(_b); _FP_FRAC_DECL_2(_c);				    \
+    {									\
-    _FP_FRAC_DECL_2(_d); _FP_FRAC_DECL_2(_e); _FP_FRAC_DECL_2(_f);	    \
+      _FP_FRAC_DECL_2(_b);						\
+      _FP_FRAC_DECL_2(_c);						\
+      _FP_FRAC_DECL_2(_d);						\
+      _FP_FRAC_DECL_2(_e);						\
+      _FP_FRAC_DECL_2(_f);						\
 									\
       doit(_FP_FRAC_WORD_8(R,1), _FP_FRAC_WORD_8(R,0), X##_f[0], Y##_f[0]); \
       doit(_b_f1, _b_f0, X##_f[0], Y##_f[1]);				\
@@ -323,10 +342,12 @@
       __FP_FRAC_ADD_2(_FP_FRAC_WORD_8(R,7),_FP_FRAC_WORD_8(R,6),	\
 		      _b_f1,_b_f0,					\
 		      _FP_FRAC_WORD_8(R,7),_FP_FRAC_WORD_8(R,6));	\
-  } while (0)
+    }									\
+  while (0)
 
 #define _FP_MUL_MEAT_4_wide(wfracbits, R, X, Y, doit)			\
-  do {									    \
+  do									\
+    {									\
       _FP_FRAC_DECL_8(_z);						\
 									\
       _FP_MUL_MEAT_DW_4_wide(wfracbits, _z, X, Y, doit);		\
@@ -337,15 +358,19 @@
       _FP_FRAC_SRS_8(_z, wfracbits-1, 2*wfracbits);			\
       __FP_FRAC_SET_4(R, _FP_FRAC_WORD_8(_z,3), _FP_FRAC_WORD_8(_z,2),	\
 		      _FP_FRAC_WORD_8(_z,1), _FP_FRAC_WORD_8(_z,0));	\
-  } while (0)
+    }									\
+  while (0)
 
 #define _FP_MUL_MEAT_DW_4_gmp(wfracbits, R, X, Y)	\
-  do {									    \
+  do							\
+    {							\
       mpn_mul_n(R##_f, _x_f, _y_f, 4);			\
-  } while (0)
+    }							\
+  while (0)
 
 #define _FP_MUL_MEAT_4_gmp(wfracbits, R, X, Y)				\
-  do {									    \
+  do									\
+    {									\
       _FP_FRAC_DECL_8(_z);						\
 									\
       _FP_MUL_MEAT_DW_4_gmp(wfracbits, _z, X, Y);			\
@@ -356,30 +381,35 @@
       _FP_FRAC_SRS_8(_z, wfracbits-1, 2*wfracbits);			\
       __FP_FRAC_SET_4(R, _FP_FRAC_WORD_8(_z,3), _FP_FRAC_WORD_8(_z,2),	\
 		      _FP_FRAC_WORD_8(_z,1), _FP_FRAC_WORD_8(_z,0));	\
-  } while (0)
+    }									\
+  while (0)
 
 /*
  * Helper utility for _FP_DIV_MEAT_4_udiv:
  * pppp = m * nnn
  */
 #define umul_ppppmnnn(p3,p2,p1,p0,m,n2,n1,n0)	\
-  do {									    \
+  do						\
+    {						\
       UWtype _t;				\
       umul_ppmm(p1,p0,m,n0);			\
       umul_ppmm(p2,_t,m,n1);			\
       __FP_FRAC_ADDI_2(p2,p1,_t);		\
       umul_ppmm(p3,_t,m,n2);			\
       __FP_FRAC_ADDI_2(p3,p2,_t);		\
-  } while (0)
+    }						\
+  while (0)
 
 /*
  * Division algorithms:
  */
 
 #define _FP_DIV_MEAT_4_udiv(fs, R, X, Y)				\
-  do {									    \
+  do									\
+    {									\
       int _i;								\
-    _FP_FRAC_DECL_4(_n); _FP_FRAC_DECL_4(_m);				    \
+      _FP_FRAC_DECL_4(_n);						\
+      _FP_FRAC_DECL_4(_m);						\
       _FP_FRAC_SET_4(_n, _FP_ZEROFRAC_4);				\
       if (_FP_FRAC_GE_4(X, Y))						\
 	{								\
@@ -441,7 +471,8 @@
 		}							\
 	    }								\
 	}								\
-  } while (0)
+    }									\
+  while (0)
 
 
 /*
@@ -451,7 +482,8 @@
  */
 
 #define _FP_SQRT_MEAT_4(R, S, T, X, q)					\
-  do {								\
+  do									\
+    {									\
       while (q)								\
 	{								\
 	  T##_f[3] = S##_f[3] + q;					\
@@ -469,8 +501,8 @@
 	{								\
 	  T##_f[2] = S##_f[2] + q;					\
 	  T##_f[3] = S##_f[3];						\
-	if (T##_f[3] < X##_f[3] || 				\
+	  if (T##_f[3] < X##_f[3]					\
-	    (T##_f[3] == X##_f[3] && T##_f[2] <= X##_f[2]))	\
+	      || (T##_f[3] == X##_f[3] && T##_f[2] <= X##_f[2]))	\
 	    {								\
 	      S##_f[2] = T##_f[2] + q;					\
 	      S##_f[3] += (T##_f[2] > S##_f[2]);			\
@@ -487,9 +519,11 @@
 	  T##_f[1] = S##_f[1] + q;					\
 	  T##_f[2] = S##_f[2];						\
 	  T##_f[3] = S##_f[3];						\
-	if (T##_f[3] < X##_f[3] || 				\
+	  if (T##_f[3] < X##_f[3]					\
-	    (T##_f[3] == X##_f[3] && (T##_f[2] < X##_f[2] ||	\
+	      || (T##_f[3] == X##_f[3]					\
-	     (T##_f[2] == X##_f[2] && T##_f[1] <= X##_f[1]))))	\
+		  && (T##_f[2] < X##_f[2]				\
+		      || (T##_f[2] == X##_f[2]				\
+			  && T##_f[1] <= X##_f[1]))))			\
 	    {								\
 	      S##_f[1] = T##_f[1] + q;					\
 	      S##_f[2] += (T##_f[1] > S##_f[1]);			\
@@ -526,7 +560,8 @@
 	    R##_f[0] |= _FP_WORK_ROUND;					\
 	  R##_f[0] |= _FP_WORK_STICKY;					\
 	}								\
-  } while (0)
+    }									\
+  while (0)
 
 
 /*
@@ -538,7 +573,8 @@
 
 #ifndef __FP_FRAC_ADD_3
 # define __FP_FRAC_ADD_3(r2,r1,r0,x2,x1,x0,y2,y1,y0)		\
-  do {								\
+  do								\
+    {								\
       _FP_W_TYPE __FP_FRAC_ADD_3_c1, __FP_FRAC_ADD_3_c2;	\
       r0 = x0 + y0;						\
       __FP_FRAC_ADD_3_c1 = r0 < x0;				\
@@ -547,12 +583,14 @@
       r1 += __FP_FRAC_ADD_3_c1;					\
       __FP_FRAC_ADD_3_c2 |= r1 < __FP_FRAC_ADD_3_c1;		\
       r2 = x2 + y2 + __FP_FRAC_ADD_3_c2;			\
-  } while (0)
+    }								\
+  while (0)
 #endif
 
 #ifndef __FP_FRAC_ADD_4
 # define __FP_FRAC_ADD_4(r3,r2,r1,r0,x3,x2,x1,x0,y3,y2,y1,y0)	\
-  do {								\
+  do								\
+    {								\
       _FP_W_TYPE _c1, _c2, _c3;					\
       r0 = x0 + y0;						\
       _c1 = r0 < x0;						\
@@ -565,12 +603,14 @@
       r2 += _c2;						\
       _c3 |= r2 < _c2;						\
       r3 = x3 + y3 + _c3;					\
-  } while (0)
+    }								\
+  while (0)
 #endif
 
 #ifndef __FP_FRAC_SUB_3
 # define __FP_FRAC_SUB_3(r2,r1,r0,x2,x1,x0,y2,y1,y0)	\
-  do {								\
+  do							\
+    {							\
       _FP_W_TYPE _c1, _c2;				\
       r0 = x0 - y0;					\
       _c1 = r0 > x0;					\
@@ -579,12 +619,14 @@
       r1 -= _c1;					\
       _c2 |= _c1 && (y1 == x1);				\
       r2 = x2 - y2 - _c2;				\
-  } while (0)
+    }							\
+  while (0)
 #endif
 
 #ifndef __FP_FRAC_SUB_4
 # define __FP_FRAC_SUB_4(r3,r2,r1,r0,x3,x2,x1,x0,y3,y2,y1,y0)	\
-  do {								\
+  do								\
+    {								\
       _FP_W_TYPE _c1, _c2, _c3;					\
       r0 = x0 - y0;						\
       _c1 = r0 > x0;						\
@@ -597,36 +639,45 @@
       r2 -= _c2;						\
       _c3 |= _c2 && (y2 == x2);					\
       r3 = x3 - y3 - _c3;					\
-  } while (0)
+    }								\
+  while (0)
 #endif
 
 #ifndef __FP_FRAC_DEC_3
 # define __FP_FRAC_DEC_3(x2,x1,x0,y2,y1,y0)			\
-  do {									\
+  do								\
+    {								\
       UWtype _t0, _t1, _t2;					\
       _t0 = x0, _t1 = x1, _t2 = x2;				\
       __FP_FRAC_SUB_3 (x2, x1, x0, _t2, _t1, _t0, y2, y1, y0);	\
-  } while (0)
+    }								\
+  while (0)
 #endif
 
 #ifndef __FP_FRAC_DEC_4
 # define __FP_FRAC_DEC_4(x3,x2,x1,x0,y3,y2,y1,y0)			\
-  do {									\
+  do									\
+    {									\
       UWtype _t0, _t1, _t2, _t3;					\
       _t0 = x0, _t1 = x1, _t2 = x2, _t3 = x3;				\
       __FP_FRAC_SUB_4 (x3,x2,x1,x0,_t3,_t2,_t1,_t0, y3,y2,y1,y0);	\
-  } while (0)
+    }									\
+  while (0)
 #endif
 
 #ifndef __FP_FRAC_ADDI_4
 # define __FP_FRAC_ADDI_4(x3,x2,x1,x0,i)	\
-  do {									\
+  do						\
+    {						\
       UWtype _t;				\
       _t = ((x0 += i) < i);			\
-    x1 += _t; _t = (x1 < _t);						\
+      x1 += _t;					\
-    x2 += _t; _t = (x2 < _t);						\
+      _t = (x1 < _t);				\
+      x2 += _t;					\
+      _t = (x2 < _t);				\
       x3 += _t;					\
-  } while (0)
+    }						\
+  while (0)
 #endif
 
 /* Convert FP values between word sizes. This appears to be more
@@ -639,17 +690,20 @@
 #define _FP_FRAC_COPY_1_4(D, S)		(D##_f = S##_f[0])
 
 #define _FP_FRAC_COPY_2_4(D, S)			\
-do {						\
+  do						\
+    {						\
       D##_f0 = S##_f[0];			\
       D##_f1 = S##_f[1];			\
-} while (0)
+    }						\
+  while (0)
 
 /* Assembly/disassembly for converting to/from integral types.
  * No shifting or overflow handled here.
  */
 /* Put the FP value X into r, which is an integer of size rsize. */
 #define _FP_FRAC_ASSEMBLE_4(r, X, rsize)				\
-  do {									\
+  do									\
+    {									\
       if (rsize <= _FP_W_TYPE_SIZE)					\
 	r = X##_f[0];							\
       else if (rsize <= 2*_FP_W_TYPE_SIZE)				\
@@ -670,7 +724,8 @@ do {						\
 	  r <<= _FP_W_TYPE_SIZE;					\
 	  r += X##_f[0];						\
 	}								\
-  } while (0)
+    }									\
+  while (0)
 
 /* "No disassemble Number Five!" */
 /* move an integer of size rsize into X's fractional part. We rely on
@@ -678,24 +733,30 @@ do {						\
  * having to mask the values we store into it.
  */
 #define _FP_FRAC_DISASSEMBLE_4(X, r, rsize)				\
-  do {									\
+  do									\
+    {									\
       X##_f[0] = r;							\
       X##_f[1] = (rsize <= _FP_W_TYPE_SIZE ? 0 : r >> _FP_W_TYPE_SIZE);	\
       X##_f[2] = (rsize <= 2*_FP_W_TYPE_SIZE ? 0 : r >> 2*_FP_W_TYPE_SIZE); \
       X##_f[3] = (rsize <= 3*_FP_W_TYPE_SIZE ? 0 : r >> 3*_FP_W_TYPE_SIZE); \
-  } while (0)
+    }									\
+  while (0)
 
 #define _FP_FRAC_COPY_4_1(D, S)			\
-do {						\
+  do						\
+    {						\
       D##_f[0] = S##_f;				\
       D##_f[1] = D##_f[2] = D##_f[3] = 0;	\
-} while (0)
+    }						\
+  while (0)
 
 #define _FP_FRAC_COPY_4_2(D, S)			\
-do {						\
+  do						\
+    {						\
       D##_f[0] = S##_f0;			\
       D##_f[1] = S##_f1;			\
       D##_f[2] = D##_f[3] = 0;			\
-} while (0)
+    }						\
+  while (0)
 
 #define _FP_FRAC_COPY_4_4(D,S)	_FP_FRAC_COPY_4(D,S)

soft-fp/op-8.h

@@ -37,7 +37,8 @@
 #define _FP_FRAC_WORD_8(X,w)	(X##_f[w])
 
 #define _FP_FRAC_SLL_8(X,N)				\
-  do {									\
+  do							\
+    {							\
       _FP_I_TYPE _up, _down, _skip, _i;			\
       _skip = (N) / _FP_W_TYPE_SIZE;			\
       _up = (N) % _FP_W_TYPE_SIZE;			\
@@ -48,16 +49,18 @@
       else						\
 	{						\
 	  for (_i = 7; _i > _skip; --_i)		\
-	  X##_f[_i] = X##_f[_i-_skip] << _up				\
+	    X##_f[_i] = (X##_f[_i-_skip] << _up		\
-		      | X##_f[_i-_skip-1] >> _down;			\
+			 | X##_f[_i-_skip-1] >> _down);	\
 	  X##_f[_i--] = X##_f[0] << _up;		\
 	}						\
       for (; _i >= 0; --_i)				\
 	X##_f[_i] = 0;					\
-  } while (0)
+    }							\
+  while (0)
 
 #define _FP_FRAC_SRL_8(X,N)				\
-  do {									\
+  do							\
+    {							\
       _FP_I_TYPE _up, _down, _skip, _i;			\
       _skip = (N) / _FP_W_TYPE_SIZE;			\
       _down = (N) % _FP_W_TYPE_SIZE;			\
@@ -68,13 +71,14 @@
       else						\
 	{						\
 	  for (_i = 0; _i < 7-_skip; ++_i)		\
-	  X##_f[_i] = X##_f[_i+_skip] >> _down				\
+	    X##_f[_i] = (X##_f[_i+_skip] >> _down	\
-		      | X##_f[_i+_skip+1] << _up;			\
+			 | X##_f[_i+_skip+1] << _up);	\
 	  X##_f[_i++] = X##_f[7] >> _down;		\
 	}						\
       for (; _i < 8; ++_i)				\
 	X##_f[_i] = 0;					\
-  } while (0)
+    }							\
+  while (0)
 
 
 /* Right shift with sticky-lsb.
@@ -83,7 +87,8 @@
  * were one then we always set the LSbit.
  */
 #define _FP_FRAC_SRS_8(X,N,size)					\
-  do {									\
+  do									\
+    {									\
       _FP_I_TYPE _up, _down, _skip, _i;					\
       _FP_W_TYPE _s;							\
       _skip = (N) / _FP_W_TYPE_SIZE;					\
@@ -98,12 +103,14 @@
 	{								\
 	  _s |= X##_f[_i] << _up;					\
 	  for (_i = 0; _i < 7-_skip; ++_i)				\
-	  X##_f[_i] = X##_f[_i+_skip] >> _down				\
+	    X##_f[_i] = (X##_f[_i+_skip] >> _down			\
-		      | X##_f[_i+_skip+1] << _up;			\
+			 | X##_f[_i+_skip+1] << _up);			\
 	  X##_f[_i++] = X##_f[7] >> _down;				\
 	}								\
       for (; _i < 8; ++_i)						\
 	X##_f[_i] = 0;							\
-    /* don't fix the LSB until the very end when we're sure f[0] is stable */	\
+      /* don't fix the LSB until the very end when we're sure f[0] is	\
+	 stable */							\
       X##_f[0] |= (_s != 0);						\
-  } while (0)
+    }									\
+  while (0)

soft-fp/op-common.h

@@ -51,7 +51,8 @@
  */
 
 #define _FP_UNPACK_CANONICAL(fs, wc, X)				\
-do {									\
+  do								\
+    {								\
       switch (X##_e)						\
 	{							\
 	default:						\
@@ -89,7 +90,8 @@ do {									\
 	    }							\
 	  break;						\
 	}							\
-} while (0)
+    }								\
+  while (0)
 
 /* Finish unpacking an fp value in semi-raw mode: the mantissa is
    shifted by _FP_WORKBITS but the implicit MSB is not inserted and
@@ -99,7 +101,8 @@ do {									\
 /* A semi-raw value has overflowed to infinity.  Adjust the mantissa
    and exponent appropriately.  */
 #define _FP_OVERFLOW_SEMIRAW(fs, wc, X)			\
-do {							\
+  do							\
+    {							\
       if (FP_ROUNDMODE == FP_RND_NEAREST		\
 	  || (FP_ROUNDMODE == FP_RND_PINF && !X##_s)	\
 	  || (FP_ROUNDMODE == FP_RND_MINF && X##_s))	\
@@ -114,34 +117,40 @@ do {							\
 	}						\
       FP_SET_EXCEPTION(FP_EX_INEXACT);			\
       FP_SET_EXCEPTION(FP_EX_OVERFLOW);			\
-} while (0)
+    }							\
+  while (0)
 
 /* Check for a semi-raw value being a signaling NaN and raise the
    invalid exception if so.  */
 #define _FP_CHECK_SIGNAN_SEMIRAW(fs, wc, X)	\
-do {								\
+  do						\
+    {						\
       if (X##_e == _FP_EXPMAX_##fs		\
 	  && !_FP_FRAC_ZEROP_##wc(X)		\
 	  && _FP_FRAC_SNANP_SEMIRAW(fs, X))	\
 	FP_SET_EXCEPTION(FP_EX_INVALID);	\
-} while (0)
+    }						\
+  while (0)
 
 /* Choose a NaN result from an operation on two semi-raw NaN
    values.  */
 #define _FP_CHOOSENAN_SEMIRAW(fs, wc, R, X, Y, OP)			\
-do {									\
+  do									\
+    {									\
       /* _FP_CHOOSENAN expects raw values, so shift as required.  */	\
       _FP_FRAC_SRL_##wc(X, _FP_WORKBITS);				\
       _FP_FRAC_SRL_##wc(Y, _FP_WORKBITS);				\
       _FP_CHOOSENAN(fs, wc, R, X, Y, OP);				\
       _FP_FRAC_SLL_##wc(R, _FP_WORKBITS);				\
-} while (0)
+    }									\
+  while (0)
 
 /* Make the fractional part a quiet NaN, preserving the payload
    if possible, otherwise make it the canonical quiet NaN and set
    the sign bit accordingly.  */
 #define _FP_SETQNAN(fs, wc, X)					\
-do {									\
+  do								\
+    {								\
       if (_FP_QNANNEGATEDP)					\
 	{							\
 	  _FP_FRAC_HIGH_RAW_##fs(X) &= _FP_QNANBIT_##fs - 1;	\
@@ -153,9 +162,11 @@ do {									\
 	}							\
       else							\
 	_FP_FRAC_HIGH_RAW_##fs(X) |= _FP_QNANBIT_##fs;		\
-} while (0)
+    }								\
+  while (0)
 #define _FP_SETQNAN_SEMIRAW(fs, wc, X)				\
-do {									\
+  do								\
+    {								\
       if (_FP_QNANNEGATEDP)					\
 	{							\
 	  _FP_FRAC_HIGH_##fs(X) &= _FP_QNANBIT_SH_##fs - 1;	\
@@ -168,7 +179,8 @@ do {									\
 	}							\
       else							\
 	_FP_FRAC_HIGH_##fs(X) |= _FP_QNANBIT_SH_##fs;		\
-} while (0)
+    }								\
+  while (0)
 
 /* Test whether a biased exponent is normal (not zero or maximum).  */
 #define _FP_EXP_NORMAL(fs, wc, X)	(((X##_e + 1) & _FP_EXPMAX_##fs) > 1)
@@ -177,7 +189,8 @@ do {									\
    rounded and shifted right, with the rounding possibly increasing
    the exponent (including changing a finite value to infinity).  */
 #define _FP_PACK_SEMIRAW(fs, wc, X)				\
-do {								\
+  do								\
+    {								\
       _FP_ROUND(wc, X);						\
       if (X##_e == 0 && !_FP_FRAC_ZEROP_##wc(X))		\
 	{							\
@@ -204,7 +217,8 @@ do {								\
 	  else							\
 	    _FP_SETQNAN(fs, wc, X);				\
 	}							\
-} while (0)
+    }								\
+  while (0)
 
 /*
  * Before packing the bits back into the native fp result, take care
@@ -214,7 +228,8 @@ do {								\
  */
 
 #define _FP_PACK_CANONICAL(fs, wc, X)					\
-do {								\
+  do									\
+    {									\
       switch (X##_c)							\
 	{								\
 	case FP_CLS_NORMAL:						\
@@ -237,10 +252,12 @@ do {								\
 		      X##_c = FP_CLS_INF;				\
 		      break;						\
 		    case FP_RND_PINF:					\
-		if (!X##_s) X##_c = FP_CLS_INF;			\
+		      if (!X##_s)					\
+			X##_c = FP_CLS_INF;				\
 		      break;						\
 		    case FP_RND_MINF:					\
-		if (X##_s) X##_c = FP_CLS_INF;			\
+		      if (X##_s)					\
+			X##_c = FP_CLS_INF;				\
 		      break;						\
 		    }							\
 		  if (X##_c == FP_CLS_INF)				\
@@ -319,13 +336,14 @@ do {								\
 	    _FP_SETQNAN(fs, wc, X);					\
 	  break;							\
 	}								\
-} while (0)
+    }									\
+  while (0)
 
 /* This one accepts raw argument and not cooked,  returns
  * 1 if X is a signaling NaN.
  */
 #define _FP_ISSIGNAN(fs, wc, X)			\
-({								\
+  ({						\
     int __ret = 0;				\
     if (X##_e == _FP_EXPMAX_##fs)		\
       {						\
@@ -334,7 +352,7 @@ do {								\
 	  __ret = 1;				\
       }						\
     __ret;					\
-})
+  })
 
 
 
@@ -342,7 +360,8 @@ do {								\
 
 /* Addition on semi-raw values.  */
 #define _FP_ADD_INTERNAL(fs, wc, R, X, Y, OP)				\
-do {									 \
+  do									\
+    {									\
       if (X##_s == Y##_s)						\
 	{								\
 	  /* Addition.  */						\
@@ -760,14 +779,18 @@ do {									 \
 	    }								\
 	sub_done: ;							\
 	}								\
-} while (0)
+    }									\
+  while (0)
 
 #define _FP_ADD(fs, wc, R, X, Y) _FP_ADD_INTERNAL(fs, wc, R, X, Y, '+')
 #define _FP_SUB(fs, wc, R, X, Y)					\
-  do {									    \
+  do									\
-    if (!(Y##_e == _FP_EXPMAX_##fs && !_FP_FRAC_ZEROP_##wc(Y))) Y##_s ^= 1; \
+    {									\
+      if (!(Y##_e == _FP_EXPMAX_##fs && !_FP_FRAC_ZEROP_##wc(Y)))	\
+	Y##_s ^= 1;							\
       _FP_ADD_INTERNAL(fs, wc, R, X, Y, '-');				\
-  } while (0)
+    }									\
+  while (0)
 
 
 /*
@@ -775,11 +798,13 @@ do {									 \
  */
 
 #define _FP_NEG(fs, wc, R, X)			\
-  do {					\
+  do						\
+    {						\
       _FP_FRAC_COPY_##wc(R, X);			\
       R##_e = X##_e;				\
       R##_s = 1 ^ X##_s;			\
-  } while (0)
+    }						\
+  while (0)
 
 
 /*
@@ -787,7 +812,8 @@ do {									 \
  */
 
 #define _FP_MUL(fs, wc, R, X, Y)				\
-do {							\
+  do								\
+    {								\
       R##_s = X##_s ^ Y##_s;					\
       R##_e = X##_e + Y##_e + 1;				\
       switch (_FP_CLS_COMBINE(X##_c, Y##_c))			\
@@ -842,13 +868,15 @@ do {							\
 	default:						\
 	  abort();						\
 	}							\
-} while (0)
+    }								\
+  while (0)
 
 
 /* Fused multiply-add.  The input values should be cooked.  */
 
 #define _FP_FMA(fs, wc, dwc, R, X, Y, Z)				\
-do {								\
+  do									\
+    {									\
       FP_DECL_##fs(T);							\
       T##_s = X##_s ^ Y##_s;						\
       T##_e = X##_e + Y##_e + 1;					\
@@ -1053,7 +1081,8 @@ do {								\
 	  abort();							\
 	}								\
     done_fma: ;								\
-} while (0)
+    }									\
+  while (0)
 
 
 /*
@@ -1061,7 +1090,8 @@ do {								\
  */
 
 #define _FP_DIV(fs, wc, R, X, Y)				\
-do {							\
+  do								\
+    {								\
       R##_s = X##_s ^ Y##_s;					\
       R##_e = X##_e - Y##_e;					\
       switch (_FP_CLS_COMBINE(X##_c, Y##_c))			\
@@ -1116,7 +1146,8 @@ do {							\
 	default:						\
 	  abort();						\
 	}							\
-} while (0)
+    }								\
+  while (0)
 
 
 /*
@@ -1125,7 +1156,8 @@ do {							\
  */
 
 #define _FP_CMP(fs, wc, ret, X, Y, un)					\
-  do {									\
+  do									\
+    {									\
       /* NANs are unordered */						\
       if ((X##_e == _FP_EXPMAX_##fs && !_FP_FRAC_ZEROP_##wc(X))		\
 	  || (Y##_e == _FP_EXPMAX_##fs && !_FP_FRAC_ZEROP_##wc(Y)))	\
@@ -1159,13 +1191,15 @@ do {							\
 	  else								\
 	    ret = 0;							\
 	}								\
-  } while (0)
+    }									\
+  while (0)
 
 
 /* Simplification for strict equality.  */
 
 #define _FP_CMP_EQ(fs, wc, ret, X, Y)					\
-  do {									    \
+  do									\
+    {									\
       /* NANs are unordered */						\
       if ((X##_e == _FP_EXPMAX_##fs && !_FP_FRAC_ZEROP_##wc(X))		\
 	  || (Y##_e == _FP_EXPMAX_##fs && !_FP_FRAC_ZEROP_##wc(Y)))	\
@@ -1178,23 +1212,28 @@ do {							\
 		  && _FP_FRAC_EQ_##wc(X, Y)				\
 		  && (X##_s == Y##_s || (!X##_e && _FP_FRAC_ZEROP_##wc(X)))); \
 	}								\
-  } while (0)
+    }									\
+  while (0)
 
 /* Version to test unordered.  */
 
 #define _FP_CMP_UNORD(fs, wc, ret, X, Y)				\
-  do {									\
+  do									\
+    {									\
       ret = ((X##_e == _FP_EXPMAX_##fs && !_FP_FRAC_ZEROP_##wc(X))	\
 	     || (Y##_e == _FP_EXPMAX_##fs && !_FP_FRAC_ZEROP_##wc(Y)));	\
-  } while (0)
+    }									\
+  while (0)
 
 /*
  * Main square root routine.  The input value should be cooked.
  */
 
 #define _FP_SQRT(fs, wc, R, X)					\
-do {									\
+  do								\
-    _FP_FRAC_DECL_##wc(T); _FP_FRAC_DECL_##wc(S);			\
+    {								\
+      _FP_FRAC_DECL_##wc(T);					\
+      _FP_FRAC_DECL_##wc(S);					\
       _FP_W_TYPE q;						\
       switch (X##_c)						\
 	{							\
@@ -1240,7 +1279,8 @@ do {									\
 	  q = _FP_OVERFLOW_##fs >> 1;				\
 	  _FP_SQRT_MEAT_##wc(R, S, T, X, q);			\
 	}							\
-  } while (0)
+    }								\
+  while (0)
 
 /*
  * Convert from FP to integer.  Input is raw.
@@ -1258,7 +1298,8 @@ do {									\
  *     depending on the sign in such case.
  */
 #define _FP_TO_INT(fs, wc, r, X, rsize, rsigned)			\
-do {									\
+  do									\
+    {									\
       if (X##_e < _FP_EXPBIAS_##fs)					\
 	{								\
 	  r = 0;							\
@@ -1294,9 +1335,12 @@ do {									\
 		 mantissa.  */						\
 	      int inexact = 0;						\
 	      (void)((_FP_FRACBITS_##fs > rsize)			\
-		 ? ({ _FP_FRAC_SRST_##wc(X, inexact,			\
+		     ? ({						\
+			 _FP_FRAC_SRST_##wc(X, inexact,			\
 					    _FP_FRACBITS_##fs - rsize,	\
-					 _FP_FRACBITS_##fs); 0; })	\
+					    _FP_FRACBITS_##fs);		\
+			 0;						\
+		       })						\
 		     : 0);						\
 	      if (!_FP_FRAC_ZEROP_##wc(X))				\
 		FP_SET_EXCEPTION(FP_EX_INVALID);			\
@@ -1328,12 +1372,14 @@ do {									\
 	  if (rsigned && X##_s)						\
 	    r = -r;							\
 	}								\
-} while (0)
+    }									\
+  while (0)
 
 /* Convert integer to fp.  Output is raw.  RTYPE is unsigned even if
    input is signed.  */
 #define _FP_FROM_INT(fs, wc, X, r, rsize, rtype)			\
-  do {									     \
+  do									\
+    {									\
       if (r)								\
 	{								\
 	  rtype ur_;							\
@@ -1401,13 +1447,15 @@ do {									\
 	  X##_e = 0;							\
 	  _FP_FRAC_SET_##wc(X, _FP_ZEROFRAC_##wc);			\
 	}								\
-  } while (0)
+    }									\
+  while (0)
 
 
 /* Extend from a narrower floating-point format to a wider one.  Input
    and output are raw.  */
 #define FP_EXTEND(dfs,sfs,dwc,swc,D,S)					\
-do {									 \
+  do									\
+    {									\
       if (_FP_FRACBITS_##dfs < _FP_FRACBITS_##sfs			\
 	  || (_FP_EXPMAX_##dfs - _FP_EXPBIAS_##dfs			\
 	      < _FP_EXPMAX_##sfs - _FP_EXPBIAS_##sfs)			\
@@ -1459,12 +1507,14 @@ do {									 \
 		}							\
 	    }								\
 	}								\
-} while (0)
+    }									\
+  while (0)
 
 /* Truncate from a wider floating-point format to a narrower one.
    Input and output are semi-raw.  */
 #define FP_TRUNC(dfs,sfs,dwc,swc,D,S)					\
-do {									     \
+  do									\
+    {									\
       if (_FP_FRACBITS_##sfs < _FP_FRACBITS_##dfs			\
 	  || (_FP_EXPBIAS_##sfs < _FP_EXPBIAS_##dfs + _FP_FRACBITS_##dfs - 1 \
 	      && _FP_EXPBIAS_##sfs != _FP_EXPBIAS_##dfs))		\
@@ -1543,7 +1593,8 @@ do {									     \
 		}							\
 	    }								\
 	}								\
-} while (0)
+    }									\
+  while (0)
 
 /*
  * Helper primitives.
@@ -1554,7 +1605,8 @@ do {									     \
 #ifndef __FP_CLZ
 /* GCC 3.4 and later provide the builtins for us.  */
 # define __FP_CLZ(r, x)							\
-  do {									      \
+  do									\
+    {									\
       if (sizeof (_FP_W_TYPE) == sizeof (unsigned int))			\
 	r = __builtin_clz (x);						\
       else if (sizeof (_FP_W_TYPE) == sizeof (unsigned long))		\
@@ -1563,19 +1615,23 @@ do {									     \
 	r = __builtin_clzll (x);					\
       else								\
 	abort ();							\
-  } while (0)
+    }									\
+  while (0)
 #endif /* ndef __FP_CLZ */
 
 #define _FP_DIV_HELP_imm(q, r, n, d)		\
-  do {						\
+  do						\
+    {						\
       q = n / d, r = n % d;			\
-  } while (0)
+    }						\
+  while (0)
 
 
 /* A restoring bit-by-bit division primitive.  */
 
 #define _FP_DIV_MEAT_N_loop(fs, wc, R, X, Y)				\
-  do {									\
+  do									\
+    {									\
       int count = _FP_WFRACBITS_##fs;					\
       _FP_FRAC_DECL_##wc (u);						\
       _FP_FRAC_DECL_##wc (v);						\
@@ -1598,7 +1654,8 @@ do {									     \
       else								\
 	R##_e--;							\
       /* Subsequent rounds.  */						\
-    do {								\
+      do								\
+	{								\
 	  int msb = (_FP_WS_TYPE) _FP_FRAC_HIGH_##wc (u) < 0;		\
 	  _FP_FRAC_SLL_##wc (u, 1);					\
 	  _FP_FRAC_SLL_##wc (R, 1);					\
@@ -1607,10 +1664,12 @@ do {									     \
 	      _FP_FRAC_SUB_##wc (u, u, v);				\
 	      _FP_FRAC_LOW_##wc (R) |= 1;				\
 	    }								\
-    } while (--count > 0);						\
+	}								\
+      while (--count > 0);						\
       /* If there's anything left in U, the result is inexact.  */	\
       _FP_FRAC_LOW_##wc (R) |= !_FP_FRAC_ZEROP_##wc (u);		\
-  } while (0)
+    }									\
+  while (0)
 
 #define _FP_DIV_MEAT_1_loop(fs, R, X, Y)  _FP_DIV_MEAT_N_loop (fs, 1, R, X, Y)
 #define _FP_DIV_MEAT_2_loop(fs, R, X, Y)  _FP_DIV_MEAT_N_loop (fs, 2, R, X, Y)

soft-fp/quad.h

@@ -99,60 +99,78 @@ union _FP_UNION_Q
 # 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 {					\
+  do						\
+    {						\
       if (!FP_INHIBIT_RESULTS)			\
 	_FP_PACK_RAW_4_P(Q,val,X);		\
-  } while (0)
+    }						\
+  while (0)
 
 # define FP_UNPACK_Q(X,val)			\
-  do {					\
+  do						\
+    {						\
       _FP_UNPACK_RAW_4(Q,X,val);		\
       _FP_UNPACK_CANONICAL(Q,4,X);		\
-  } while (0)
+    }						\
+  while (0)
 
 # define FP_UNPACK_QP(X,val)			\
-  do {					\
+  do						\
+    {						\
       _FP_UNPACK_RAW_4_P(Q,X,val);		\
       _FP_UNPACK_CANONICAL(Q,4,X);		\
-  } while (0)
+    }						\
+  while (0)
 
 # define FP_UNPACK_SEMIRAW_Q(X,val)		\
-  do {					\
+  do						\
+    {						\
       _FP_UNPACK_RAW_4(Q,X,val);		\
       _FP_UNPACK_SEMIRAW(Q,4,X);		\
-  } while (0)
+    }						\
+  while (0)
 
 # define FP_UNPACK_SEMIRAW_QP(X,val)		\
-  do {					\
+  do						\
+    {						\
       _FP_UNPACK_RAW_4_P(Q,X,val);		\
       _FP_UNPACK_SEMIRAW(Q,4,X);		\
-  } while (0)
+    }						\
+  while (0)
 
 # define FP_PACK_Q(val,X)			\
-  do {					\
+  do						\
+    {						\
       _FP_PACK_CANONICAL(Q,4,X);		\
       _FP_PACK_RAW_4(Q,val,X);			\
-  } while (0)
+    }						\
+  while (0)
 
 # define FP_PACK_QP(val,X)			\
-  do {					\
+  do						\
+    {						\
       _FP_PACK_CANONICAL(Q,4,X);		\
       if (!FP_INHIBIT_RESULTS)			\
 	_FP_PACK_RAW_4_P(Q,val,X);		\
-  } while (0)
+    }						\
+  while (0)
 
 # define FP_PACK_SEMIRAW_Q(val,X)		\
-  do {					\
+  do						\
+    {						\
       _FP_PACK_SEMIRAW(Q,4,X);			\
       _FP_PACK_RAW_4(Q,val,X);			\
-  } while (0)
+    }						\
+  while (0)
 
 # define FP_PACK_SEMIRAW_QP(val,X)		\
-  do {					\
+  do						\
+    {						\
       _FP_PACK_SEMIRAW(Q,4,X);			\
       if (!FP_INHIBIT_RESULTS)			\
 	_FP_PACK_RAW_4_P(Q,val,X);		\
-  } while (0)
+    }						\
+  while (0)
 
 # define FP_ISSIGNAN_Q(X)		_FP_ISSIGNAN(Q,4,X)
 # define FP_NEG_Q(R,X)			_FP_NEG(Q,4,R,X)
@@ -180,10 +198,12 @@ union _FP_UNION_Q
 union _FP_UNION_Q
 {
   TFtype flt /* __attribute__((mode(TF))) */ ;
-  struct _FP_STRUCT_LAYOUT {
+  struct _FP_STRUCT_LAYOUT
+  {
     _FP_W_TYPE a, b;
   } longs;
-  struct _FP_STRUCT_LAYOUT {
+  struct _FP_STRUCT_LAYOUT
+  {
 # if __BYTE_ORDER == __BIG_ENDIAN
     unsigned sign    : 1;
     unsigned exp     : _FP_EXPBITS_Q;
@@ -203,60 +223,78 @@ union _FP_UNION_Q
 # 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 {					\
+  do						\
+    {						\
       if (!FP_INHIBIT_RESULTS)			\
 	_FP_PACK_RAW_2_P(Q,val,X);		\
-  } while (0)
+    }						\
+  while (0)
 
 # define FP_UNPACK_Q(X,val)			\
-  do {					\
+  do						\
+    {						\
       _FP_UNPACK_RAW_2(Q,X,val);		\
       _FP_UNPACK_CANONICAL(Q,2,X);		\
-  } while (0)
+    }						\
+  while (0)
 
 # define FP_UNPACK_QP(X,val)			\
-  do {					\
+  do						\
+    {						\
       _FP_UNPACK_RAW_2_P(Q,X,val);		\
       _FP_UNPACK_CANONICAL(Q,2,X);		\
-  } while (0)
+    }						\
+  while (0)
 
 # define FP_UNPACK_SEMIRAW_Q(X,val)		\
-  do {					\
+  do						\
+    {						\
       _FP_UNPACK_RAW_2(Q,X,val);		\
       _FP_UNPACK_SEMIRAW(Q,2,X);		\
-  } while (0)
+    }						\
+  while (0)
 
 # define FP_UNPACK_SEMIRAW_QP(X,val)		\
-  do {					\
+  do						\
+    {						\
       _FP_UNPACK_RAW_2_P(Q,X,val);		\
       _FP_UNPACK_SEMIRAW(Q,2,X);		\
-  } while (0)
+    }						\
+  while (0)
 
 # define FP_PACK_Q(val,X)			\
-  do {					\
+  do						\
+    {						\
       _FP_PACK_CANONICAL(Q,2,X);		\
       _FP_PACK_RAW_2(Q,val,X);			\
-  } while (0)
+    }						\
+  while (0)
 
 # define FP_PACK_QP(val,X)			\
-  do {					\
+  do						\
+    {						\
       _FP_PACK_CANONICAL(Q,2,X);		\
       if (!FP_INHIBIT_RESULTS)			\
 	_FP_PACK_RAW_2_P(Q,val,X);		\
-  } while (0)
+    }						\
+  while (0)
 
 # define FP_PACK_SEMIRAW_Q(val,X)		\
-  do {					\
+  do						\
+    {						\
       _FP_PACK_SEMIRAW(Q,2,X);			\
       _FP_PACK_RAW_2(Q,val,X);			\
-  } while (0)
+    }						\
+  while (0)
 
 # define FP_PACK_SEMIRAW_QP(val,X)		\
-  do {					\
+  do						\
+    {						\
       _FP_PACK_SEMIRAW(Q,2,X);			\
       if (!FP_INHIBIT_RESULTS)			\
 	_FP_PACK_RAW_2_P(Q,val,X);		\
-  } while (0)
+    }						\
+  while (0)
 
 # define FP_ISSIGNAN_Q(X)		_FP_ISSIGNAN(Q,2,X)
 # define FP_NEG_Q(R,X)			_FP_NEG(Q,2,R,X)

soft-fp/single.h

@@ -68,7 +68,8 @@ typedef float SFtype __attribute__((mode(SF)));
 union _FP_UNION_S
 {
   SFtype flt;
-  struct _FP_STRUCT_LAYOUT {
+  struct _FP_STRUCT_LAYOUT
+  {
 #if __BYTE_ORDER == __BIG_ENDIAN
     unsigned sign : 1;
     unsigned exp  : _FP_EXPBITS_S;
@@ -86,60 +87,78 @@ union _FP_UNION_S
 #define FP_UNPACK_RAW_SP(X,val)	_FP_UNPACK_RAW_1_P(S,X,val)
 #define FP_PACK_RAW_S(val,X)	_FP_PACK_RAW_1(S,val,X)
 #define FP_PACK_RAW_SP(val,X)			\
-  do {					\
+  do						\
+    {						\
       if (!FP_INHIBIT_RESULTS)			\
 	_FP_PACK_RAW_1_P(S,val,X);		\
-  } while (0)
+    }						\
+  while (0)
 
 #define FP_UNPACK_S(X,val)			\
-  do {					\
+  do						\
+    {						\
       _FP_UNPACK_RAW_1(S,X,val);		\
       _FP_UNPACK_CANONICAL(S,1,X);		\
-  } while (0)
+    }						\
+  while (0)
 
 #define FP_UNPACK_SP(X,val)			\
-  do {					\
+  do						\
+    {						\
       _FP_UNPACK_RAW_1_P(S,X,val);		\
       _FP_UNPACK_CANONICAL(S,1,X);		\
-  } while (0)
+    }						\
+  while (0)
 
 #define FP_UNPACK_SEMIRAW_S(X,val)		\
-  do {					\
+  do						\
+    {						\
       _FP_UNPACK_RAW_1(S,X,val);		\
       _FP_UNPACK_SEMIRAW(S,1,X);		\
-  } while (0)
+    }						\
+  while (0)
 
 #define FP_UNPACK_SEMIRAW_SP(X,val)		\
-  do {					\
+  do						\
+    {						\
       _FP_UNPACK_RAW_1_P(S,X,val);		\
       _FP_UNPACK_SEMIRAW(S,1,X);		\
-  } while (0)
+    }						\
+  while (0)
 
 #define FP_PACK_S(val,X)			\
-  do {					\
+  do						\
+    {						\
       _FP_PACK_CANONICAL(S,1,X);		\
       _FP_PACK_RAW_1(S,val,X);			\
-  } while (0)
+    }						\
+  while (0)
 
 #define FP_PACK_SP(val,X)			\
-  do {					\
+  do						\
+    {						\
       _FP_PACK_CANONICAL(S,1,X);		\
       if (!FP_INHIBIT_RESULTS)			\
 	_FP_PACK_RAW_1_P(S,val,X);		\
-  } while (0)
+    }						\
+  while (0)
 
 #define FP_PACK_SEMIRAW_S(val,X)		\
-  do {					\
+  do						\
+    {						\
       _FP_PACK_SEMIRAW(S,1,X);			\
       _FP_PACK_RAW_1(S,val,X);			\
-  } while (0)
+    }						\
+  while (0)
 
 #define FP_PACK_SEMIRAW_SP(val,X)		\
-  do {					\
+  do						\
+    {						\
       _FP_PACK_SEMIRAW(S,1,X);			\
       if (!FP_INHIBIT_RESULTS)			\
 	_FP_PACK_RAW_1_P(S,val,X);		\
-  } while (0)
+    }						\
+  while (0)
 
 #define FP_ISSIGNAN_S(X)		_FP_ISSIGNAN(S,1,X)
 #define FP_NEG_S(R,X)			_FP_NEG(S,1,R,X)

soft-fp/soft-fp.h

@@ -167,27 +167,34 @@
 #endif
 
 #define _FP_ROUND_NEAREST(wc, X)				\
-do {							\
+  do								\
+    {								\
       if ((_FP_FRAC_LOW_##wc(X) & 15) != _FP_WORK_ROUND)	\
 	_FP_FRAC_ADDI_##wc(X, _FP_WORK_ROUND);			\
-} while (0)
+    }								\
+  while (0)
 
 #define _FP_ROUND_ZERO(wc, X)		(void)0
 
 #define _FP_ROUND_PINF(wc, X)			\
-do {							\
+  do						\
+    {						\
       if (!X##_s && (_FP_FRAC_LOW_##wc(X) & 7))	\
 	_FP_FRAC_ADDI_##wc(X, _FP_WORK_LSB);	\
-} while (0)
+    }						\
+  while (0)
 
 #define _FP_ROUND_MINF(wc, X)			\
-do {							\
+  do						\
+    {						\
       if (X##_s && (_FP_FRAC_LOW_##wc(X) & 7))	\
 	_FP_FRAC_ADDI_##wc(X, _FP_WORK_LSB);	\
-} while (0)
+    }						\
+  while (0)
 
 #define _FP_ROUND(wc, X)			\
-do {						\
+  do						\
+    {						\
       if (_FP_FRAC_LOW_##wc(X) & 7)		\
 	{					\
 	  FP_SET_EXCEPTION(FP_EX_INEXACT);	\
@@ -207,7 +214,8 @@ do {						\
 	      break;				\
 	    }					\
 	}					\
-} while (0)
+    }						\
+  while (0)
 
 #define FP_CLS_NORMAL		0
 #define FP_CLS_ZERO		1

soft-fp/sqrtdf2.c

@@ -31,10 +31,12 @@
 #include "soft-fp.h"
 #include "double.h"
 
-DFtype __sqrtdf2(DFtype a)
+DFtype
+__sqrtdf2(DFtype a)
 {
   FP_DECL_EX;
-  FP_DECL_D(A); FP_DECL_D(R);
+  FP_DECL_D(A);
+  FP_DECL_D(R);
   DFtype r;
 
   FP_INIT_ROUNDMODE;

soft-fp/sqrtsf2.c

@@ -31,10 +31,12 @@
 #include "soft-fp.h"
 #include "single.h"
 
-SFtype __sqrtsf2(SFtype a)
+SFtype
+__sqrtsf2(SFtype a)
 {
   FP_DECL_EX;
-  FP_DECL_S(A); FP_DECL_S(R);
+  FP_DECL_S(A);
+  FP_DECL_S(R);
   SFtype r;
 
   FP_INIT_ROUNDMODE;

soft-fp/sqrttf2.c

@@ -31,10 +31,12 @@
 #include "soft-fp.h"
 #include "quad.h"
 
-TFtype __sqrttf2(TFtype a)
+TFtype
+__sqrttf2(TFtype a)
 {
   FP_DECL_EX;
-  FP_DECL_Q(A); FP_DECL_Q(R);
+  FP_DECL_Q(A);
+  FP_DECL_Q(R);
   TFtype r;
 
   FP_INIT_ROUNDMODE;

soft-fp/subdf3.c

@@ -31,10 +31,13 @@
 #include "soft-fp.h"
 #include "double.h"
 
-DFtype __subdf3(DFtype a, DFtype b)
+DFtype
+__subdf3(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;

soft-fp/subsf3.c

@@ -31,10 +31,13 @@
 #include "soft-fp.h"
 #include "single.h"
 
-SFtype __subsf3(SFtype a, SFtype b)
+SFtype
+__subsf3(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;

soft-fp/subtf3.c

@@ -31,10 +31,13 @@
 #include "soft-fp.h"
 #include "quad.h"
 
-TFtype __subtf3(TFtype a, TFtype b)
+TFtype
+__subtf3(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;

soft-fp/truncdfsf2.c

@@ -32,7 +32,8 @@
 #include "single.h"
 #include "double.h"
 
-SFtype __truncdfsf2(DFtype a)
+SFtype
+__truncdfsf2(DFtype a)
 {
   FP_DECL_EX;
   FP_DECL_D(A);

soft-fp/trunctfdf2.c

@@ -32,7 +32,8 @@
 #include "double.h"
 #include "quad.h"
 
-DFtype __trunctfdf2(TFtype a)
+DFtype
+__trunctfdf2(TFtype a)
 {
   FP_DECL_EX;
   FP_DECL_Q(A);

soft-fp/trunctfsf2.c

@@ -32,7 +32,8 @@
 #include "single.h"
 #include "quad.h"
 
-SFtype __trunctfsf2(TFtype a)
+SFtype
+__trunctfsf2(TFtype a)
 {
   FP_DECL_EX;
   FP_DECL_Q(A);

soft-fp/trunctfxf2.c

@@ -31,7 +31,8 @@
 #include "extended.h"
 #include "quad.h"
 
-XFtype __trunctfxf2(TFtype a)
+XFtype
+__trunctfxf2(TFtype a)
 {
   FP_DECL_EX;
   FP_DECL_Q(A);

soft-fp/unorddf2.c

@@ -30,10 +30,12 @@
 #include "soft-fp.h"
 #include "double.h"
 
-CMPtype __unorddf2(DFtype a, DFtype b)
+CMPtype
+__unorddf2(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;

soft-fp/unordsf2.c

@@ -30,7 +30,8 @@
 #include "soft-fp.h"
 #include "single.h"
 
-CMPtype __unordsf2(SFtype a, SFtype b)
+CMPtype
+__unordsf2(SFtype a, SFtype b)
 {
   FP_DECL_EX;
   FP_DECL_S(A);

soft-fp/unordtf2.c

@@ -30,7 +30,8 @@
 #include "soft-fp.h"
 #include "quad.h"
 
-CMPtype __unordtf2(TFtype a, TFtype b)
+CMPtype
+__unordtf2(TFtype a, TFtype b)
 {
   FP_DECL_EX;
   FP_DECL_Q(A);