soft-fp: fix vertical whitespace and indentation.

1 files changed, 205 insertions, 172 deletions

diff --git a/soft-fp/op-1.h b/soft-fp/op-1.h
index a9ad0d6..e4d84bf 100644
--- a/soft-fp/op-1.h
+++ b/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 {						\
-    if (__builtin_constant_p(N) && (N) == 1)	\
-      X##_f += X##_f;				\
-    else					\
-      X##_f <<= (N);				\
-  } while (0)
+  do						\
+    {						\
+      if (__builtin_constant_p(N) && (N) == 1)	\
+	X##_f += X##_f;				\
+      else					\
+	X##_f <<= (N);				\
+    }						\
+  while (0)
 #define _FP_FRAC_SRL_1(X,N)	(X##_f >>= N)
 
 /* 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 {							\
-  S = (__builtin_constant_p(N) && (N) == 1		\
-       ? X & 1 : (X << (_FP_W_TYPE_SIZE - (N))) != 0);	\
-  X = X >> (N);						\
-} while (0)
-
-#define __FP_FRAC_SRS_1(X,N,sz)						\
-   (X = (X >> (N) | (__builtin_constant_p(N) && (N) == 1		\
-		     ? X & 1 : (X << (_FP_W_TYPE_SIZE - (N))) != 0)))
+  do							\
+    {							\
+      S = (__builtin_constant_p(N) && (N) == 1		\
+	   ? X & 1					\
+	   : (X << (_FP_W_TYPE_SIZE - (N))) != 0);	\
+      X = X >> (N);					\
+    }							\
+  while (0)
+
+#define __FP_FRAC_SRS_1(X,N,sz)					\
+  (X = (X >> (N) | (__builtin_constant_p(N) && (N) == 1		\
+		    ? 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)
@@ -86,49 +92,56 @@ do {							\
  * normalize the data.
  */
 
-#define _FP_UNPACK_RAW_1(fs, X, val)				\
-  do {								\
-    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)
-
-#define _FP_UNPACK_RAW_1_P(fs, X, val)				\
-  do {								\
-    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)
+#define _FP_UNPACK_RAW_1(fs, X, val)		\
+  do						\
+    {						\
+      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)
+
+#define _FP_UNPACK_RAW_1_P(fs, X, val)					\
+  do									\
+    {									\
+      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)
 
 /*
  * Repack the raw bits of a native fp value.
  */
 
-#define _FP_PACK_RAW_1(fs, val, X)				\
-  do {								\
-    union _FP_UNION_##fs _flo;					\
-								\
-    _flo.bits.frac = X##_f;					\
-    _flo.bits.exp  = X##_e;					\
-    _flo.bits.sign = X##_s;					\
-								\
-    (val) = _flo.flt;						\
-  } while (0)
-
-#define _FP_PACK_RAW_1_P(fs, val, X)				\
-  do {								\
-    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)
+#define _FP_PACK_RAW_1(fs, val, X)		\
+  do						\
+    {						\
+      union _FP_UNION_##fs _flo;		\
+						\
+      _flo.bits.frac = X##_f;			\
+      _flo.bits.exp  = X##_e;			\
+      _flo.bits.sign = X##_s;			\
+						\
+      (val) = _flo.flt;				\
+    }						\
+  while (0)
+
+#define _FP_PACK_RAW_1_P(fs, val, X)					\
+  do									\
+    {									\
+      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)
 
 
 /*
@@ -138,74 +151,86 @@ do {							\
 /* Basic.  Assuming the host word size is >= 2*FRACBITS, we can do the
    multiplication immediately.  */
 
-#define _FP_MUL_MEAT_DW_1_imm(wfracbits, R, X, Y)			\
-  do {									\
-    R##_f = X##_f * Y##_f;						\
-  } while (0)
+#define _FP_MUL_MEAT_DW_1_imm(wfracbits, R, X, Y)	\
+  do							\
+    {							\
+      R##_f = X##_f * Y##_f;				\
+    }							\
+  while (0)
 
 #define _FP_MUL_MEAT_1_imm(wfracbits, R, X, Y)				\
-  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)
+  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)
 
 /* Given a 1W * 1W => 2W primitive, do the extended multiplication.  */
 
-#define _FP_MUL_MEAT_DW_1_wide(wfracbits, R, X, Y, doit)		\
-  do {									\
-    doit(R##_f1, R##_f0, X##_f, Y##_f);					\
-  } while (0)
+#define _FP_MUL_MEAT_DW_1_wide(wfracbits, R, X, Y, doit)	\
+  do								\
+    {								\
+      doit(R##_f1, R##_f0, X##_f, Y##_f);			\
+    }								\
+  while (0)
 
 #define _FP_MUL_MEAT_1_wide(wfracbits, R, X, Y, doit)			\
-  do {									\
-    _FP_FRAC_DECL_2(_Z);						\
-    _FP_MUL_MEAT_DW_1_wide(wfracbits, _Z, X, Y, doit);			\
-    /* Normalize since we know where the msb of the multiplicands	\
-       were (bit B), we know that the msb of the of the product is	\
-       at either 2B or 2B-1.  */					\
-    _FP_FRAC_SRS_2(_Z, wfracbits-1, 2*wfracbits);			\
-    R##_f = _Z_f0;							\
-  } while (0)
+  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	\
+	 were (bit B), we know that the msb of the of the product is	\
+	 at either 2B or 2B-1.  */					\
+      _FP_FRAC_SRS_2(_Z, wfracbits-1, 2*wfracbits);			\
+      R##_f = _Z_f0;							\
+    }									\
+  while (0)
 
 /* Finally, a simple widening multiply algorithm.  What fun!  */
 
 #define _FP_MUL_MEAT_DW_1_hard(wfracbits, R, X, Y)			\
-  do {									\
-    _FP_W_TYPE _xh, _xl, _yh, _yl;					\
-    _FP_FRAC_DECL_2(_a);						\
-									\
-    /* split the words in half */					\
-    _xh = X##_f >> (_FP_W_TYPE_SIZE/2);					\
-    _xl = X##_f & (((_FP_W_TYPE)1 << (_FP_W_TYPE_SIZE/2)) - 1);		\
-    _yh = Y##_f >> (_FP_W_TYPE_SIZE/2);					\
-    _yl = Y##_f & (((_FP_W_TYPE)1 << (_FP_W_TYPE_SIZE/2)) - 1);		\
+  do									\
+    {									\
+      _FP_W_TYPE _xh, _xl, _yh, _yl;					\
+      _FP_FRAC_DECL_2(_a);						\
 									\
-    /* multiply the pieces */						\
-    R##_f0 = _xl * _yl;							\
-    _a_f0 = _xh * _yl;							\
-    _a_f1 = _xl * _yh;							\
-    R##_f1 = _xh * _yh;							\
+      /* split the words in half */					\
+      _xh = X##_f >> (_FP_W_TYPE_SIZE/2);				\
+      _xl = X##_f & (((_FP_W_TYPE)1 << (_FP_W_TYPE_SIZE/2)) - 1);	\
+      _yh = Y##_f >> (_FP_W_TYPE_SIZE/2);				\
+      _yl = Y##_f & (((_FP_W_TYPE)1 << (_FP_W_TYPE_SIZE/2)) - 1);	\
 									\
-    /* reassemble into two full words */				\
-    if ((_a_f0 += _a_f1) < _a_f1)					\
-      R##_f1 += (_FP_W_TYPE)1 << (_FP_W_TYPE_SIZE/2);			\
-    _a_f1 = _a_f0 >> (_FP_W_TYPE_SIZE/2);				\
-    _a_f0 = _a_f0 << (_FP_W_TYPE_SIZE/2);				\
-    _FP_FRAC_ADD_2(R, R, _a);						\
-  } while (0)
-
-#define _FP_MUL_MEAT_1_hard(wfracbits, R, X, Y)				\
-  do {									\
-    _FP_FRAC_DECL_2(_z);						\
-    _FP_MUL_MEAT_DW_1_hard(wfracbits, _z, X, Y);			\
+      /* multiply the pieces */						\
+      R##_f0 = _xl * _yl;						\
+      _a_f0 = _xh * _yl;						\
+      _a_f1 = _xl * _yh;						\
+      R##_f1 = _xh * _yh;						\
 									\
-    /* normalize */							\
-    _FP_FRAC_SRS_2(_z, wfracbits - 1, 2*wfracbits);			\
-    R##_f = _z_f0;							\
-  } while (0)
+      /* reassemble into two full words */				\
+      if ((_a_f0 += _a_f1) < _a_f1)					\
+	R##_f1 += (_FP_W_TYPE)1 << (_FP_W_TYPE_SIZE/2);			\
+      _a_f1 = _a_f0 >> (_FP_W_TYPE_SIZE/2);				\
+      _a_f0 = _a_f0 << (_FP_W_TYPE_SIZE/2);				\
+      _FP_FRAC_ADD_2(R, R, _a);						\
+    }									\
+  while (0)
+
+#define _FP_MUL_MEAT_1_hard(wfracbits, R, X, Y)		\
+  do							\
+    {							\
+      _FP_FRAC_DECL_2(_z);				\
+      _FP_MUL_MEAT_DW_1_hard(wfracbits, _z, X, Y);	\
+							\
+      /* normalize */					\
+      _FP_FRAC_SRS_2(_z, wfracbits - 1, 2*wfracbits);	\
+      R##_f = _z_f0;					\
+    }							\
+  while (0)
 
 
 /*
@@ -217,15 +242,17 @@ do {							\
    C primitives or _FP_DIV_HELP_ldiv for the ISO function.  Which you
    choose will depend on what the compiler does with divrem4.  */
 
-#define _FP_DIV_MEAT_1_imm(fs, R, X, Y, doit)		\
-  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)
+#define _FP_DIV_MEAT_1_imm(fs, R, X, Y, doit)	\
+  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)
 
 /* 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,46 +260,50 @@ do {							\
    for UDIV_NEEDS_NORMALIZATION to tell which your machine needs.  */
 
 #define _FP_DIV_MEAT_1_udiv_norm(fs, R, X, Y)				\
-  do {									\
-    _FP_W_TYPE _nh, _nl, _q, _r, _y;					\
+  do									\
+    {									\
+      _FP_W_TYPE _nh, _nl, _q, _r, _y;					\
 									\
-    /* Normalize Y -- i.e. make the most significant bit set.  */	\
-    _y = Y##_f << _FP_WFRACXBITS_##fs;					\
+      /* Normalize Y -- i.e. make the most significant bit set.  */	\
+      _y = Y##_f << _FP_WFRACXBITS_##fs;				\
 									\
-    /* Shift X op correspondingly high, that is, up one full word.  */	\
-    if (X##_f < Y##_f)							\
-      {									\
-	R##_e--;							\
-	_nl = 0;							\
-	_nh = X##_f;							\
-      }									\
-    else								\
-      {									\
-	_nl = X##_f << (_FP_W_TYPE_SIZE - 1);				\
-	_nh = X##_f >> 1;						\
-      }									\
+      /* Shift X op correspondingly high, that is, up one full word.  */ \
+      if (X##_f < Y##_f)						\
+	{								\
+	  R##_e--;							\
+	  _nl = 0;							\
+	  _nh = X##_f;							\
+	}								\
+      else								\
+	{								\
+	  _nl = X##_f << (_FP_W_TYPE_SIZE - 1);				\
+	  _nh = X##_f >> 1;						\
+	}								\
 									\
-    udiv_qrnnd(_q, _r, _nh, _nl, _y);					\
-    R##_f = _q | (_r != 0);						\
-  } while (0)
+      udiv_qrnnd(_q, _r, _nh, _nl, _y);					\
+      R##_f = _q | (_r != 0);						\
+    }									\
+  while (0)
 
 #define _FP_DIV_MEAT_1_udiv(fs, R, X, Y)		\
-  do {							\
-    _FP_W_TYPE _nh, _nl, _q, _r;			\
-    if (X##_f < Y##_f)					\
-      {							\
-	R##_e--;					\
-	_nl = X##_f << _FP_WFRACBITS_##fs;		\
-	_nh = X##_f >> _FP_WFRACXBITS_##fs;		\
-      }							\
-    else						\
-      {							\
-	_nl = X##_f << (_FP_WFRACBITS_##fs - 1);	\
-	_nh = X##_f >> (_FP_WFRACXBITS_##fs + 1);	\
-      }							\
-    udiv_qrnnd(_q, _r, _nh, _nl, Y##_f);		\
-    R##_f = _q | (_r != 0);				\
-  } while (0)
+  do							\
+    {							\
+      _FP_W_TYPE _nh, _nl, _q, _r;			\
+      if (X##_f < Y##_f)				\
+	{						\
+	  R##_e--;					\
+	  _nl = X##_f << _FP_WFRACBITS_##fs;		\
+	  _nh = X##_f >> _FP_WFRACXBITS_##fs;		\
+	}						\
+      else						\
+	{						\
+	  _nl = X##_f << (_FP_WFRACBITS_##fs - 1);	\
+	  _nh = X##_f >> (_FP_WFRACXBITS_##fs + 1);	\
+	}						\
+      udiv_qrnnd(_q, _r, _nh, _nl, Y##_f);		\
+      R##_f = _q | (_r != 0);				\
+    }							\
+  while (0)
 
 
 /*
@@ -281,27 +312,29 @@ do {							\
  * should be added for those machines where division is fast.
  */
 
-#define _FP_SQRT_MEAT_1(R, S, T, X, q)			\
-  do {							\
-    while (q != _FP_WORK_ROUND)				\
-      {							\
-        T##_f = S##_f + q;				\
-        if (T##_f <= X##_f)				\
-          {						\
-            S##_f = T##_f + q;				\
-            X##_f -= T##_f;				\
-            R##_f += q;					\
-          }						\
-        _FP_FRAC_SLL_1(X, 1);				\
-        q >>= 1;					\
-      }							\
-    if (X##_f)						\
-      {							\
-	if (S##_f < X##_f)				\
-	  R##_f |= _FP_WORK_ROUND;			\
-	R##_f |= _FP_WORK_STICKY;			\
-      }							\
-  } while (0)
+#define _FP_SQRT_MEAT_1(R, S, T, X, q)		\
+  do						\
+    {						\
+      while (q != _FP_WORK_ROUND)		\
+	{					\
+	  T##_f = S##_f + q;			\
+	  if (T##_f <= X##_f)			\
+	    {					\
+	      S##_f = T##_f + q;		\
+	      X##_f -= T##_f;			\
+	      R##_f += q;			\
+	    }					\
+	  _FP_FRAC_SLL_1(X, 1);			\
+	  q >>= 1;				\
+	}					\
+      if (X##_f)				\
+	{					\
+	  if (S##_f < X##_f)			\
+	    R##_f |= _FP_WORK_ROUND;		\
+	  R##_f |= _FP_WORK_STICKY;		\
+	}					\
+    }						\
+  while (0)
 
 /*
  * Assembly/disassembly for converting to/from integral types.