soft-fp: fix vertical whitespace and indentation.

1 files changed, 1448 insertions, 1389 deletions

diff --git a/soft-fp/op-common.h b/soft-fp/op-common.h
index d87ffaf131..89fec5d878 100644
--- a/soft-fp/op-common.h
+++ b/soft-fp/op-common.h
@@ -50,46 +50,48 @@
  * of fp value and normalizing both the exponent and the fraction.
  */
 
-#define _FP_UNPACK_CANONICAL(fs, wc, X)					\
-do {									\
-  switch (X##_e)							\
-  {									\
-  default:								\
-    _FP_FRAC_HIGH_RAW_##fs(X) |= _FP_IMPLBIT_##fs;			\
-    _FP_FRAC_SLL_##wc(X, _FP_WORKBITS);					\
-    X##_e -= _FP_EXPBIAS_##fs;						\
-    X##_c = FP_CLS_NORMAL;						\
-    break;								\
-									\
-  case 0:								\
-    if (_FP_FRAC_ZEROP_##wc(X))						\
-      X##_c = FP_CLS_ZERO;						\
-    else								\
-      {									\
-	/* a denormalized number */					\
-	_FP_I_TYPE _shift;						\
-	_FP_FRAC_CLZ_##wc(_shift, X);					\
-	_shift -= _FP_FRACXBITS_##fs;					\
-	_FP_FRAC_SLL_##wc(X, (_shift+_FP_WORKBITS));			\
-	X##_e -= _FP_EXPBIAS_##fs - 1 + _shift;				\
-	X##_c = FP_CLS_NORMAL;						\
-	FP_SET_EXCEPTION(FP_EX_DENORM);					\
-      }									\
-    break;								\
-									\
-  case _FP_EXPMAX_##fs:							\
-    if (_FP_FRAC_ZEROP_##wc(X))						\
-      X##_c = FP_CLS_INF;						\
-    else								\
-      {									\
-	X##_c = FP_CLS_NAN;						\
-	/* Check for signaling NaN */					\
-	if (_FP_FRAC_SNANP(fs, X))					\
-	  FP_SET_EXCEPTION(FP_EX_INVALID);				\
-      }									\
-    break;								\
-  }									\
-} while (0)
+#define _FP_UNPACK_CANONICAL(fs, wc, X)				\
+  do								\
+    {								\
+      switch (X##_e)						\
+	{							\
+	default:						\
+	  _FP_FRAC_HIGH_RAW_##fs(X) |= _FP_IMPLBIT_##fs;	\
+	  _FP_FRAC_SLL_##wc(X, _FP_WORKBITS);			\
+	  X##_e -= _FP_EXPBIAS_##fs;				\
+	  X##_c = FP_CLS_NORMAL;				\
+	  break;						\
+								\
+	case 0:							\
+	  if (_FP_FRAC_ZEROP_##wc(X))				\
+	    X##_c = FP_CLS_ZERO;				\
+	  else							\
+	    {							\
+	      /* a denormalized number */			\
+	      _FP_I_TYPE _shift;				\
+	      _FP_FRAC_CLZ_##wc(_shift, X);			\
+	      _shift -= _FP_FRACXBITS_##fs;			\
+	      _FP_FRAC_SLL_##wc(X, (_shift+_FP_WORKBITS));	\
+	      X##_e -= _FP_EXPBIAS_##fs - 1 + _shift;		\
+	      X##_c = FP_CLS_NORMAL;				\
+	      FP_SET_EXCEPTION(FP_EX_DENORM);			\
+	    }							\
+	  break;						\
+								\
+	case _FP_EXPMAX_##fs:					\
+	  if (_FP_FRAC_ZEROP_##wc(X))				\
+	    X##_c = FP_CLS_INF;					\
+	  else							\
+	    {							\
+	      X##_c = FP_CLS_NAN;				\
+	      /* Check for signaling NaN */			\
+	      if (_FP_FRAC_SNANP(fs, X))			\
+		FP_SET_EXCEPTION(FP_EX_INVALID);		\
+	    }							\
+	  break;						\
+	}							\
+    }								\
+  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,76 +101,86 @@ do {									\
 /* A semi-raw value has overflowed to infinity.  Adjust the mantissa
    and exponent appropriately.  */
 #define _FP_OVERFLOW_SEMIRAW(fs, wc, X)			\
-do {							\
-  if (FP_ROUNDMODE == FP_RND_NEAREST			\
-      || (FP_ROUNDMODE == FP_RND_PINF && !X##_s)	\
-      || (FP_ROUNDMODE == FP_RND_MINF && X##_s))	\
-    {							\
-      X##_e = _FP_EXPMAX_##fs;				\
-      _FP_FRAC_SET_##wc(X, _FP_ZEROFRAC_##wc);		\
-    }							\
-  else							\
+  do							\
     {							\
-      X##_e = _FP_EXPMAX_##fs - 1;			\
-      _FP_FRAC_SET_##wc(X, _FP_MAXFRAC_##wc);		\
+      if (FP_ROUNDMODE == FP_RND_NEAREST		\
+	  || (FP_ROUNDMODE == FP_RND_PINF && !X##_s)	\
+	  || (FP_ROUNDMODE == FP_RND_MINF && X##_s))	\
+	{						\
+	  X##_e = _FP_EXPMAX_##fs;			\
+	  _FP_FRAC_SET_##wc(X, _FP_ZEROFRAC_##wc);	\
+	}						\
+      else						\
+	{						\
+	  X##_e = _FP_EXPMAX_##fs - 1;			\
+	  _FP_FRAC_SET_##wc(X, _FP_MAXFRAC_##wc);	\
+	}						\
+      FP_SET_EXCEPTION(FP_EX_INEXACT);			\
+      FP_SET_EXCEPTION(FP_EX_OVERFLOW);			\
     }							\
-    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 {								\
-  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)
+#define _FP_CHECK_SIGNAN_SEMIRAW(fs, wc, X)	\
+  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)
 
 /* Choose a NaN result from an operation on two semi-raw NaN
    values.  */
 #define _FP_CHOOSENAN_SEMIRAW(fs, wc, R, X, Y, OP)			\
-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)
+  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)
 
 /* 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 {									\
-  if (_FP_QNANNEGATEDP)							\
-    {									\
-      _FP_FRAC_HIGH_RAW_##fs(X) &= _FP_QNANBIT_##fs - 1;		\
-      if (_FP_FRAC_ZEROP_##wc(X))					\
-	{								\
-	  X##_s = _FP_NANSIGN_##fs;					\
-	  _FP_FRAC_SET_##wc(X, _FP_NANFRAC_##fs);			\
-	}								\
-    }									\
-  else									\
-    _FP_FRAC_HIGH_RAW_##fs(X) |= _FP_QNANBIT_##fs;			\
-} while (0)
-#define _FP_SETQNAN_SEMIRAW(fs, wc, X)					\
-do {									\
-  if (_FP_QNANNEGATEDP)							\
-    {									\
-      _FP_FRAC_HIGH_##fs(X) &= _FP_QNANBIT_SH_##fs - 1;			\
-      if (_FP_FRAC_ZEROP_##wc(X))					\
-	{								\
-	  X##_s = _FP_NANSIGN_##fs;					\
-	  _FP_FRAC_SET_##wc(X, _FP_NANFRAC_##fs);			\
-	  _FP_FRAC_SLL_##wc(X, _FP_WORKBITS);				\
-	}								\
-    }									\
-  else									\
-    _FP_FRAC_HIGH_##fs(X) |= _FP_QNANBIT_SH_##fs;			\
-} while (0)
+#define _FP_SETQNAN(fs, wc, X)					\
+  do								\
+    {								\
+      if (_FP_QNANNEGATEDP)					\
+	{							\
+	  _FP_FRAC_HIGH_RAW_##fs(X) &= _FP_QNANBIT_##fs - 1;	\
+	  if (_FP_FRAC_ZEROP_##wc(X))				\
+	    {							\
+	      X##_s = _FP_NANSIGN_##fs;				\
+	      _FP_FRAC_SET_##wc(X, _FP_NANFRAC_##fs);		\
+	    }							\
+	}							\
+      else							\
+	_FP_FRAC_HIGH_RAW_##fs(X) |= _FP_QNANBIT_##fs;		\
+    }								\
+  while (0)
+#define _FP_SETQNAN_SEMIRAW(fs, wc, X)				\
+  do								\
+    {								\
+      if (_FP_QNANNEGATEDP)					\
+	{							\
+	  _FP_FRAC_HIGH_##fs(X) &= _FP_QNANBIT_SH_##fs - 1;	\
+	  if (_FP_FRAC_ZEROP_##wc(X))				\
+	    {							\
+	      X##_s = _FP_NANSIGN_##fs;				\
+	      _FP_FRAC_SET_##wc(X, _FP_NANFRAC_##fs);		\
+	      _FP_FRAC_SLL_##wc(X, _FP_WORKBITS);		\
+	    }							\
+	}							\
+      else							\
+	_FP_FRAC_HIGH_##fs(X) |= _FP_QNANBIT_SH_##fs;		\
+    }								\
+  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,34 +189,36 @@ 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 {								\
-  _FP_ROUND(wc, X);						\
-  if (X##_e == 0 && !_FP_FRAC_ZEROP_##wc(X))			\
-	{ \
+  do								\
+    {								\
+      _FP_ROUND(wc, X);						\
+      if (X##_e == 0 && !_FP_FRAC_ZEROP_##wc(X))		\
+	{							\
 	  if ((FP_CUR_EXCEPTIONS & FP_EX_INEXACT)		\
 	      || (FP_TRAPPING_EXCEPTIONS & FP_EX_UNDERFLOW))	\
 	    FP_SET_EXCEPTION(FP_EX_UNDERFLOW);			\
-	} \
-  if (_FP_FRAC_HIGH_##fs(X)					\
-      & (_FP_OVERFLOW_##fs >> 1))				\
-    {								\
-      _FP_FRAC_HIGH_##fs(X) &= ~(_FP_OVERFLOW_##fs >> 1);	\
-      X##_e++;							\
-      if (X##_e == _FP_EXPMAX_##fs)				\
-	_FP_OVERFLOW_SEMIRAW(fs, wc, X);			\
-    }								\
-  _FP_FRAC_SRL_##wc(X, _FP_WORKBITS);				\
-  if (X##_e == _FP_EXPMAX_##fs && !_FP_FRAC_ZEROP_##wc(X))	\
-    {								\
-      if (!_FP_KEEPNANFRACP)					\
+	}							\
+      if (_FP_FRAC_HIGH_##fs(X)					\
+	  & (_FP_OVERFLOW_##fs >> 1))				\
 	{							\
-	  _FP_FRAC_SET_##wc(X, _FP_NANFRAC_##fs);		\
-	  X##_s = _FP_NANSIGN_##fs;				\
+	  _FP_FRAC_HIGH_##fs(X) &= ~(_FP_OVERFLOW_##fs >> 1);	\
+	  X##_e++;						\
+	  if (X##_e == _FP_EXPMAX_##fs)				\
+	    _FP_OVERFLOW_SEMIRAW(fs, wc, X);			\
+	}							\
+      _FP_FRAC_SRL_##wc(X, _FP_WORKBITS);			\
+      if (X##_e == _FP_EXPMAX_##fs && !_FP_FRAC_ZEROP_##wc(X))	\
+	{							\
+	  if (!_FP_KEEPNANFRACP)				\
+	    {							\
+	      _FP_FRAC_SET_##wc(X, _FP_NANFRAC_##fs);		\
+	      X##_s = _FP_NANSIGN_##fs;				\
+	    }							\
+	  else							\
+	    _FP_SETQNAN(fs, wc, X);				\
 	}							\
-      else							\
-	_FP_SETQNAN(fs, wc, X);					\
     }								\
-} while (0)
+  while (0)
 
 /*
  * Before packing the bits back into the native fp result, take care
@@ -213,910 +227,927 @@ do {								\
  * extracted -- but that is ok, we can regenerate them now.
  */
 
-#define _FP_PACK_CANONICAL(fs, wc, X)				\
-do {								\
-  switch (X##_c)						\
-  {								\
-  case FP_CLS_NORMAL:						\
-    X##_e += _FP_EXPBIAS_##fs;					\
-    if (X##_e > 0)						\
-      {								\
-	_FP_ROUND(wc, X);					\
-	if (_FP_FRAC_OVERP_##wc(fs, X))				\
-	  {							\
-	    _FP_FRAC_CLEAR_OVERP_##wc(fs, X);			\
-	    X##_e++;						\
-	  }							\
-	_FP_FRAC_SRL_##wc(X, _FP_WORKBITS);			\
-	if (X##_e >= _FP_EXPMAX_##fs)				\
-	  {							\
-	    /* overflow */					\
-	    switch (FP_ROUNDMODE)				\
-	      {							\
-	      case FP_RND_NEAREST:				\
-		X##_c = FP_CLS_INF;				\
-		break;						\
-	      case FP_RND_PINF:					\
-		if (!X##_s) X##_c = FP_CLS_INF;			\
-		break;						\
-	      case FP_RND_MINF:					\
-		if (X##_s) X##_c = FP_CLS_INF;			\
-		break;						\
-	      }							\
-	    if (X##_c == FP_CLS_INF)				\
-	      {							\
-		/* Overflow to infinity */			\
-		X##_e = _FP_EXPMAX_##fs;			\
-		_FP_FRAC_SET_##wc(X, _FP_ZEROFRAC_##wc);	\
-	      }							\
-	    else						\
-	      {							\
-		/* Overflow to maximum normal */		\
-		X##_e = _FP_EXPMAX_##fs - 1;			\
-		_FP_FRAC_SET_##wc(X, _FP_MAXFRAC_##wc);		\
-	      }							\
-	    FP_SET_EXCEPTION(FP_EX_OVERFLOW);			\
-            FP_SET_EXCEPTION(FP_EX_INEXACT);			\
-	  }							\
-      }								\
-    else							\
-      {								\
-	/* we've got a denormalized number */			\
-	X##_e = -X##_e + 1;					\
-	if (X##_e <= _FP_WFRACBITS_##fs)			\
-	  {							\
-	    _FP_FRAC_SRS_##wc(X, X##_e, _FP_WFRACBITS_##fs);	\
-	    _FP_ROUND(wc, X);					\
-	    if (_FP_FRAC_HIGH_##fs(X)				\
-		& (_FP_OVERFLOW_##fs >> 1))			\
-	      {							\
-	        X##_e = 1;					\
-	        _FP_FRAC_SET_##wc(X, _FP_ZEROFRAC_##wc);	\
-		FP_SET_EXCEPTION(FP_EX_INEXACT);		\
-	      }							\
-	    else						\
-	      {							\
-		X##_e = 0;					\
-		_FP_FRAC_SRL_##wc(X, _FP_WORKBITS);		\
-	      }							\
-	    if ((FP_CUR_EXCEPTIONS & FP_EX_INEXACT)		\
-		|| (FP_TRAPPING_EXCEPTIONS & FP_EX_UNDERFLOW))	\
-	      FP_SET_EXCEPTION(FP_EX_UNDERFLOW);		\
-	  }							\
-	else							\
-	  {							\
-	    /* underflow to zero */				\
-	    X##_e = 0;						\
-	    if (!_FP_FRAC_ZEROP_##wc(X))			\
-	      {							\
-	        _FP_FRAC_SET_##wc(X, _FP_MINFRAC_##wc);		\
-	        _FP_ROUND(wc, X);				\
-	        _FP_FRAC_LOW_##wc(X) >>= (_FP_WORKBITS);	\
-	      }							\
-	    FP_SET_EXCEPTION(FP_EX_UNDERFLOW);			\
-	  }							\
-      }								\
-    break;							\
-								\
-  case FP_CLS_ZERO:						\
-    X##_e = 0;							\
-    _FP_FRAC_SET_##wc(X, _FP_ZEROFRAC_##wc);			\
-    break;							\
-								\
-  case FP_CLS_INF:						\
-    X##_e = _FP_EXPMAX_##fs;					\
-    _FP_FRAC_SET_##wc(X, _FP_ZEROFRAC_##wc);			\
-    break;							\
-								\
-  case FP_CLS_NAN:						\
-    X##_e = _FP_EXPMAX_##fs;					\
-    if (!_FP_KEEPNANFRACP)					\
-      {								\
-	_FP_FRAC_SET_##wc(X, _FP_NANFRAC_##fs);			\
-	X##_s = _FP_NANSIGN_##fs;				\
-      }								\
-    else							\
-      _FP_SETQNAN(fs, wc, X);					\
-    break;							\
-  }								\
-} while (0)
+#define _FP_PACK_CANONICAL(fs, wc, X)					\
+  do									\
+    {									\
+      switch (X##_c)							\
+	{								\
+	case FP_CLS_NORMAL:						\
+	  X##_e += _FP_EXPBIAS_##fs;					\
+	  if (X##_e > 0)						\
+	    {								\
+	      _FP_ROUND(wc, X);						\
+	      if (_FP_FRAC_OVERP_##wc(fs, X))				\
+		{							\
+		  _FP_FRAC_CLEAR_OVERP_##wc(fs, X);			\
+		  X##_e++;						\
+		}							\
+	      _FP_FRAC_SRL_##wc(X, _FP_WORKBITS);			\
+	      if (X##_e >= _FP_EXPMAX_##fs)				\
+		{							\
+		  /* overflow */					\
+		  switch (FP_ROUNDMODE)					\
+		    {							\
+		    case FP_RND_NEAREST:				\
+		      X##_c = FP_CLS_INF;				\
+		      break;						\
+		    case FP_RND_PINF:					\
+		      if (!X##_s)					\
+			X##_c = FP_CLS_INF;				\
+		      break;						\
+		    case FP_RND_MINF:					\
+		      if (X##_s)					\
+			X##_c = FP_CLS_INF;				\
+		      break;						\
+		    }							\
+		  if (X##_c == FP_CLS_INF)				\
+		    {							\
+		      /* Overflow to infinity */			\
+		      X##_e = _FP_EXPMAX_##fs;				\
+		      _FP_FRAC_SET_##wc(X, _FP_ZEROFRAC_##wc);		\
+		    }							\
+		  else							\
+		    {							\
+		      /* Overflow to maximum normal */			\
+		      X##_e = _FP_EXPMAX_##fs - 1;			\
+		      _FP_FRAC_SET_##wc(X, _FP_MAXFRAC_##wc);		\
+		    }							\
+		  FP_SET_EXCEPTION(FP_EX_OVERFLOW);			\
+		  FP_SET_EXCEPTION(FP_EX_INEXACT);			\
+		}							\
+	    }								\
+	  else								\
+	    {								\
+	      /* we've got a denormalized number */			\
+	      X##_e = -X##_e + 1;					\
+	      if (X##_e <= _FP_WFRACBITS_##fs)				\
+		{							\
+		  _FP_FRAC_SRS_##wc(X, X##_e, _FP_WFRACBITS_##fs);	\
+		  _FP_ROUND(wc, X);					\
+		  if (_FP_FRAC_HIGH_##fs(X)				\
+		      & (_FP_OVERFLOW_##fs >> 1))			\
+		    {							\
+		      X##_e = 1;					\
+		      _FP_FRAC_SET_##wc(X, _FP_ZEROFRAC_##wc);		\
+		      FP_SET_EXCEPTION(FP_EX_INEXACT);			\
+		    }							\
+		  else							\
+		    {							\
+		      X##_e = 0;					\
+		      _FP_FRAC_SRL_##wc(X, _FP_WORKBITS);		\
+		    }							\
+		  if ((FP_CUR_EXCEPTIONS & FP_EX_INEXACT)		\
+		      || (FP_TRAPPING_EXCEPTIONS & FP_EX_UNDERFLOW))	\
+		    FP_SET_EXCEPTION(FP_EX_UNDERFLOW);			\
+		}							\
+	      else							\
+		{							\
+		  /* underflow to zero */				\
+		  X##_e = 0;						\
+		  if (!_FP_FRAC_ZEROP_##wc(X))				\
+		    {							\
+		      _FP_FRAC_SET_##wc(X, _FP_MINFRAC_##wc);		\
+		      _FP_ROUND(wc, X);					\
+		      _FP_FRAC_LOW_##wc(X) >>= (_FP_WORKBITS);		\
+		    }							\
+		  FP_SET_EXCEPTION(FP_EX_UNDERFLOW);			\
+		}							\
+	    }								\
+	  break;							\
+									\
+	case FP_CLS_ZERO:						\
+	  X##_e = 0;							\
+	  _FP_FRAC_SET_##wc(X, _FP_ZEROFRAC_##wc);			\
+	  break;							\
+									\
+	case FP_CLS_INF:						\
+	  X##_e = _FP_EXPMAX_##fs;					\
+	  _FP_FRAC_SET_##wc(X, _FP_ZEROFRAC_##wc);			\
+	  break;							\
+									\
+	case FP_CLS_NAN:						\
+	  X##_e = _FP_EXPMAX_##fs;					\
+	  if (!_FP_KEEPNANFRACP)					\
+	    {								\
+	      _FP_FRAC_SET_##wc(X, _FP_NANFRAC_##fs);			\
+	      X##_s = _FP_NANSIGN_##fs;					\
+	    }								\
+	  else								\
+	    _FP_SETQNAN(fs, wc, X);					\
+	  break;							\
+	}								\
+    }									\
+  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)					\
-    {								\
-      if (!_FP_FRAC_ZEROP_##wc(X)				\
-	  && _FP_FRAC_SNANP(fs, X))				\
-	__ret = 1;						\
-    }								\
-  __ret;							\
-})
+#define _FP_ISSIGNAN(fs, wc, X)			\
+  ({						\
+    int __ret = 0;				\
+    if (X##_e == _FP_EXPMAX_##fs)		\
+      {						\
+	if (!_FP_FRAC_ZEROP_##wc(X)		\
+	    && _FP_FRAC_SNANP(fs, X))		\
+	  __ret = 1;				\
+      }						\
+    __ret;					\
+  })
 
 
 
 
 
 /* Addition on semi-raw values.  */
-#define _FP_ADD_INTERNAL(fs, wc, R, X, Y, OP)				 \
-do {									 \
-  if (X##_s == Y##_s)							 \
-    {									 \
-      /* Addition.  */							 \
-      R##_s = X##_s;							 \
-      int ediff = X##_e - Y##_e;					 \
-      if (ediff > 0)							 \
-	{								 \
-	  R##_e = X##_e;						 \
-	  if (Y##_e == 0)						 \
-	    {								 \
-	      /* Y is zero or denormalized.  */				 \
-	      if (_FP_FRAC_ZEROP_##wc(Y))				 \
-		{							 \
-		  _FP_CHECK_SIGNAN_SEMIRAW(fs, wc, X);			 \
-		  _FP_FRAC_COPY_##wc(R, X);				 \
-		  goto add_done;					 \
-		}							 \
-	      else							 \
-		{							 \
-		  FP_SET_EXCEPTION(FP_EX_DENORM);			 \
-		  ediff--;						 \
-		  if (ediff == 0)					 \
-		    {							 \
-		      _FP_FRAC_ADD_##wc(R, X, Y);			 \
-		      goto add3;					 \
-		    }							 \
-		  if (X##_e == _FP_EXPMAX_##fs)				 \
-		    {							 \
-		      _FP_CHECK_SIGNAN_SEMIRAW(fs, wc, X);		 \
-		      _FP_FRAC_COPY_##wc(R, X);				 \
-		      goto add_done;					 \
-		    }							 \
-		  goto add1;						 \
-		}							 \
-	    }								 \
-	  else if (X##_e == _FP_EXPMAX_##fs)				 \
-	    {								 \
-	      /* X is NaN or Inf, Y is normal.  */			 \
-	      _FP_CHECK_SIGNAN_SEMIRAW(fs, wc, X);			 \
-	      _FP_FRAC_COPY_##wc(R, X);					 \
-	      goto add_done;						 \
-	    }								 \
-									 \
-	  /* Insert implicit MSB of Y.  */				 \
-	  _FP_FRAC_HIGH_##fs(Y) |= _FP_IMPLBIT_SH_##fs;			 \
-									 \
-	add1:								 \
-	  /* Shift the mantissa of Y to the right EDIFF steps;		 \
-	     remember to account later for the implicit MSB of X.  */	 \
-	  if (ediff <= _FP_WFRACBITS_##fs)				 \
-	    _FP_FRAC_SRS_##wc(Y, ediff, _FP_WFRACBITS_##fs);		 \
-	  else if (!_FP_FRAC_ZEROP_##wc(Y))				 \
-	    _FP_FRAC_SET_##wc(Y, _FP_MINFRAC_##wc);			 \
-	  _FP_FRAC_ADD_##wc(R, X, Y);					 \
-	}								 \
-      else if (ediff < 0)						 \
-	{								 \
-	  ediff = -ediff;						 \
-	  R##_e = Y##_e;						 \
-	  if (X##_e == 0)						 \
-	    {								 \
-	      /* X is zero or denormalized.  */				 \
-	      if (_FP_FRAC_ZEROP_##wc(X))				 \
-		{							 \
-		  _FP_CHECK_SIGNAN_SEMIRAW(fs, wc, Y);			 \
-		  _FP_FRAC_COPY_##wc(R, Y);				 \
-		  goto add_done;					 \
-		}							 \
-	      else							 \
-		{							 \
-		  FP_SET_EXCEPTION(FP_EX_DENORM);			 \
-		  ediff--;						 \
-		  if (ediff == 0)					 \
-		    {							 \
-		      _FP_FRAC_ADD_##wc(R, Y, X);			 \
-		      goto add3;					 \
-		    }							 \
-		  if (Y##_e == _FP_EXPMAX_##fs)				 \
-		    {							 \
-		      _FP_CHECK_SIGNAN_SEMIRAW(fs, wc, Y);		 \
-		      _FP_FRAC_COPY_##wc(R, Y);				 \
-		      goto add_done;					 \
-		    }							 \
-		  goto add2;						 \
-		}							 \
-	    }								 \
-	  else if (Y##_e == _FP_EXPMAX_##fs)				 \
-	    {								 \
-	      /* Y is NaN or Inf, X is normal.  */			 \
-	      _FP_CHECK_SIGNAN_SEMIRAW(fs, wc, Y);			 \
-	      _FP_FRAC_COPY_##wc(R, Y);					 \
-	      goto add_done;						 \
-	    }								 \
-									 \
-	  /* Insert implicit MSB of X.  */				 \
-	  _FP_FRAC_HIGH_##fs(X) |= _FP_IMPLBIT_SH_##fs;			 \
-									 \
-	add2:								 \
-	  /* Shift the mantissa of X to the right EDIFF steps;		 \
-	     remember to account later for the implicit MSB of Y.  */	 \
-	  if (ediff <= _FP_WFRACBITS_##fs)				 \
-	    _FP_FRAC_SRS_##wc(X, ediff, _FP_WFRACBITS_##fs);		 \
-	  else if (!_FP_FRAC_ZEROP_##wc(X))				 \
-	    _FP_FRAC_SET_##wc(X, _FP_MINFRAC_##wc);			 \
-	  _FP_FRAC_ADD_##wc(R, Y, X);					 \
-	}								 \
-      else								 \
-	{								 \
-	  /* ediff == 0.  */						 \
-	  if (!_FP_EXP_NORMAL(fs, wc, X))				 \
-	    {								 \
-	      if (X##_e == 0)						 \
-		{							 \
-		  /* X and Y are zero or denormalized.  */		 \
-		  R##_e = 0;						 \
-		  if (_FP_FRAC_ZEROP_##wc(X))				 \
-		    {							 \
-		      if (!_FP_FRAC_ZEROP_##wc(Y))			 \
-			FP_SET_EXCEPTION(FP_EX_DENORM);			 \
-		      _FP_FRAC_COPY_##wc(R, Y);				 \
-		      goto add_done;					 \
-		    }							 \
-		  else if (_FP_FRAC_ZEROP_##wc(Y))			 \
-		    {							 \
-		      FP_SET_EXCEPTION(FP_EX_DENORM);			 \
-		      _FP_FRAC_COPY_##wc(R, X);				 \
-		      goto add_done;					 \
-		    }							 \
-		  else							 \
-		    {							 \
-		      FP_SET_EXCEPTION(FP_EX_DENORM);			 \
-		      _FP_FRAC_ADD_##wc(R, X, Y);			 \
-		      if (_FP_FRAC_HIGH_##fs(R) & _FP_IMPLBIT_SH_##fs)	 \
-			{						 \
-			  /* Normalized result.  */			 \
-			  _FP_FRAC_HIGH_##fs(R)				 \
-			    &= ~(_FP_W_TYPE)_FP_IMPLBIT_SH_##fs;	 \
-			  R##_e = 1;					 \
-			}						 \
-		      goto add_done;					 \
-		    }							 \
-		}							 \
-	      else							 \
-		{							 \
-		  /* X and Y are NaN or Inf.  */			 \
-		  _FP_CHECK_SIGNAN_SEMIRAW(fs, wc, X);			 \
-		  _FP_CHECK_SIGNAN_SEMIRAW(fs, wc, Y);			 \
-		  R##_e = _FP_EXPMAX_##fs;				 \
-		  if (_FP_FRAC_ZEROP_##wc(X))				 \
-		    _FP_FRAC_COPY_##wc(R, Y);				 \
-		  else if (_FP_FRAC_ZEROP_##wc(Y))			 \
-		    _FP_FRAC_COPY_##wc(R, X);				 \
-		  else							 \
-		    _FP_CHOOSENAN_SEMIRAW(fs, wc, R, X, Y, OP);		 \
-		  goto add_done;					 \
-		}							 \
-	    }								 \
-	  /* The exponents of X and Y, both normal, are equal.  The	 \
-	     implicit MSBs will always add to increase the		 \
-	     exponent.  */						 \
-	  _FP_FRAC_ADD_##wc(R, X, Y);					 \
-	  R##_e = X##_e + 1;						 \
-	  _FP_FRAC_SRS_##wc(R, 1, _FP_WFRACBITS_##fs);			 \
-	  if (R##_e == _FP_EXPMAX_##fs)					 \
-	    /* Overflow to infinity (depending on rounding mode).  */	 \
-	    _FP_OVERFLOW_SEMIRAW(fs, wc, R);				 \
-	  goto add_done;						 \
-	}								 \
-    add3:								 \
-      if (_FP_FRAC_HIGH_##fs(R) & _FP_IMPLBIT_SH_##fs)			 \
-	{								 \
-	  /* Overflow.  */						 \
-	  _FP_FRAC_HIGH_##fs(R) &= ~(_FP_W_TYPE)_FP_IMPLBIT_SH_##fs;	 \
-	  R##_e++;							 \
-	  _FP_FRAC_SRS_##wc(R, 1, _FP_WFRACBITS_##fs);			 \
-	  if (R##_e == _FP_EXPMAX_##fs)					 \
-	    /* Overflow to infinity (depending on rounding mode).  */	 \
-	    _FP_OVERFLOW_SEMIRAW(fs, wc, R);				 \
-	}								 \
-    add_done: ;								 \
-    }