diff mbox

Rename soft-fp op-[1248].h variables to avoid risk of shadowing

Message ID Pine.LNX.4.64.1406192017130.32738@digraph.polyomino.org.uk
State Committed
Headers show

Commit Message

Joseph Myers June 19, 2014, 8:18 p.m. UTC
Continuing the soft-fp variable renaming from
<https://sourceware.org/ml/libc-alpha/2014-06/msg00434.html> to avoid
shadowing if two macros happen to use the same variable name and that
variable is involved in an argument one of those macros passes to
another, this patch renames variables in op-[1248].h.  (The two
patches are to different files and are independent of each other.)

Tested for powerpc32 (soft-float) and mips64 that this makes no change
to the disassembly of installed shared libraries.

2014-06-19  Joseph Myers  <joseph@codesourcery.com>

	* soft-fp/op-1.h (_FP_UNPACK_RAW_1): Rename local variables to
	include macro name.
	(_FP_UNPACK_RAW_1_P): Likewise.
	(_FP_PACK_RAW_1): Likewise.
	(_FP_PACK_RAW_1_P): Likewise.
	(_FP_MUL_MEAT_1_wide): Likewise.
	(_FP_MUL_MEAT_DW_1_hard): Likewise.
	(_FP_MUL_MEAT_1_hard): Likewise.
	(_FP_DIV_MEAT_1_imm): Likewise.
	(_FP_DIV_MEAT_1_udiv_norm): Likewise.
	(_FP_DIV_MEAT_1_udiv): Likewise.
	* soft-fp/op-2.h (__FP_FRAC_DEC_2): Likewise.
	(_FP_UNPACK_RAW_2): Likewise.
	(_FP_UNPACK_RAW_2_P): Likewise.
	(_FP_PACK_RAW_2): Likewise.
	(_FP_PACK_RAW_2_P): Likewise.
	(_FP_MUL_MEAT_DW_2_wide): Likewise.
	(_FP_MUL_MEAT_2_wide): Likewise.
	(_FP_MUL_MEAT_DW_2_wide_3mul): Likewise.
	(_FP_MUL_MEAT_2_wide_3mul): Likewise.
	(_FP_MUL_MEAT_DW_2_gmp): Likewise.
	(_FP_MUL_MEAT_2_gmp): Likewise.
	(_FP_DIV_MEAT_2_udiv): Likewise.
	* soft-fp/op-4.h (_FP_FRAC_SLL_4): Likewise.
	(_FP_FRAC_SRL_4): Likewise.
	(_FP_FRAC_SRST_4): Likewise.
	(_FP_FRAC_SRS_4): Likewise.
	(_FP_UNPACK_RAW_4): Likewise.
	(_FP_UNPACK_RAW_4_P): Likewise.
	(_FP_PACK_RAW_4): Likewise.
	(_FP_PACK_RAW_4_P): Likewise.
	(_FP_MUL_MEAT_DW_4_wide): Likewise.
	(_FP_MUL_MEAT_4_wide): Likewise.
	(_FP_MUL_MEAT_4_gmp): Likewise.
	(umul_ppppmnnn): Likewise.
	(_FP_DIV_MEAT_4_udiv): Likewise.
	(__FP_FRAC_ADD_4): Likewise.
	(__FP_FRAC_SUB_3): Likewise.
	(__FP_FRAC_SUB_4): Likewise.
	(__FP_FRAC_DEC_3): Likewise.
	(__FP_FRAC_DEC_4): Likewise.
	(__FP_FRAC_ADDI_4): Likewise.
	* soft-fp/op-8.h (_FP_FRAC_SLL_8): Likewise.
	(_FP_FRAC_SRL_8): Likewise.
	(_FP_FRAC_SRS_8): Likewise.

Comments

Joseph Myers June 25, 2014, 11:09 a.m. UTC | #1
Ping.  This patch 
<https://sourceware.org/ml/libc-alpha/2014-06/msg00470.html> is pending 
review.
Joseph Myers June 30, 2014, 3:18 p.m. UTC | #2
Ping^2 (last ping for this patch for 2.20).  This patch 
<https://sourceware.org/ml/libc-alpha/2014-06/msg00470.html> is still 
pending review.
Will Newton June 30, 2014, 4:05 p.m. UTC | #3
On 19 June 2014 21:18, Joseph S. Myers <joseph@codesourcery.com> wrote:
> Continuing the soft-fp variable renaming from
> <https://sourceware.org/ml/libc-alpha/2014-06/msg00434.html> to avoid
> shadowing if two macros happen to use the same variable name and that
> variable is involved in an argument one of those macros passes to
> another, this patch renames variables in op-[1248].h.  (The two
> patches are to different files and are independent of each other.)
>
> Tested for powerpc32 (soft-float) and mips64 that this makes no change
> to the disassembly of installed shared libraries.
>
> 2014-06-19  Joseph Myers  <joseph@codesourcery.com>
>
>         * soft-fp/op-1.h (_FP_UNPACK_RAW_1): Rename local variables to
>         include macro name.
>         (_FP_UNPACK_RAW_1_P): Likewise.
>         (_FP_PACK_RAW_1): Likewise.
>         (_FP_PACK_RAW_1_P): Likewise.
>         (_FP_MUL_MEAT_1_wide): Likewise.
>         (_FP_MUL_MEAT_DW_1_hard): Likewise.
>         (_FP_MUL_MEAT_1_hard): Likewise.
>         (_FP_DIV_MEAT_1_imm): Likewise.
>         (_FP_DIV_MEAT_1_udiv_norm): Likewise.
>         (_FP_DIV_MEAT_1_udiv): Likewise.
>         * soft-fp/op-2.h (__FP_FRAC_DEC_2): Likewise.
>         (_FP_UNPACK_RAW_2): Likewise.
>         (_FP_UNPACK_RAW_2_P): Likewise.
>         (_FP_PACK_RAW_2): Likewise.
>         (_FP_PACK_RAW_2_P): Likewise.
>         (_FP_MUL_MEAT_DW_2_wide): Likewise.
>         (_FP_MUL_MEAT_2_wide): Likewise.
>         (_FP_MUL_MEAT_DW_2_wide_3mul): Likewise.
>         (_FP_MUL_MEAT_2_wide_3mul): Likewise.
>         (_FP_MUL_MEAT_DW_2_gmp): Likewise.
>         (_FP_MUL_MEAT_2_gmp): Likewise.
>         (_FP_DIV_MEAT_2_udiv): Likewise.
>         * soft-fp/op-4.h (_FP_FRAC_SLL_4): Likewise.
>         (_FP_FRAC_SRL_4): Likewise.
>         (_FP_FRAC_SRST_4): Likewise.
>         (_FP_FRAC_SRS_4): Likewise.
>         (_FP_UNPACK_RAW_4): Likewise.
>         (_FP_UNPACK_RAW_4_P): Likewise.
>         (_FP_PACK_RAW_4): Likewise.
>         (_FP_PACK_RAW_4_P): Likewise.
>         (_FP_MUL_MEAT_DW_4_wide): Likewise.
>         (_FP_MUL_MEAT_4_wide): Likewise.
>         (_FP_MUL_MEAT_4_gmp): Likewise.
>         (umul_ppppmnnn): Likewise.
>         (_FP_DIV_MEAT_4_udiv): Likewise.
>         (__FP_FRAC_ADD_4): Likewise.
>         (__FP_FRAC_SUB_3): Likewise.
>         (__FP_FRAC_SUB_4): Likewise.
>         (__FP_FRAC_DEC_3): Likewise.
>         (__FP_FRAC_DEC_4): Likewise.
>         (__FP_FRAC_ADDI_4): Likewise.
>         * soft-fp/op-8.h (_FP_FRAC_SLL_8): Likewise.
>         (_FP_FRAC_SRL_8): Likewise.
>         (_FP_FRAC_SRS_8): Likewise.

This looks ok too.

> diff --git a/soft-fp/op-1.h b/soft-fp/op-1.h
> index 33682cf..3547e74 100644
> --- a/soft-fp/op-1.h
> +++ b/soft-fp/op-1.h
> @@ -92,27 +92,28 @@
>   * 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;                  \
> -    }                                          \
> +#define _FP_UNPACK_RAW_1(fs, X, val)                   \
> +  do                                                   \
> +    {                                                  \
> +      union _FP_UNION_##fs _FP_UNPACK_RAW_1_flo;       \
> +      _FP_UNPACK_RAW_1_flo.flt = (val);                        \
> +                                                       \
> +      X##_f = _FP_UNPACK_RAW_1_flo.bits.frac;          \
> +      X##_e = _FP_UNPACK_RAW_1_flo.bits.exp;           \
> +      X##_s = _FP_UNPACK_RAW_1_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;                                         \
> -    }                                                                  \
> +#define _FP_UNPACK_RAW_1_P(fs, X, val)                 \
> +  do                                                   \
> +    {                                                  \
> +      union _FP_UNION_##fs *_FP_UNPACK_RAW_1_P_flo     \
> +       = (union _FP_UNION_##fs *) (val);               \
> +                                                       \
> +      X##_f = _FP_UNPACK_RAW_1_P_flo->bits.frac;       \
> +      X##_e = _FP_UNPACK_RAW_1_P_flo->bits.exp;                \
> +      X##_s = _FP_UNPACK_RAW_1_P_flo->bits.sign;       \
> +    }                                                  \
>    while (0)
>
>  /*
> @@ -122,25 +123,26 @@
>  #define _FP_PACK_RAW_1(fs, val, X)             \
>    do                                           \
>      {                                          \
> -      union _FP_UNION_##fs _flo;               \
> +      union _FP_UNION_##fs _FP_PACK_RAW_1_flo; \
>                                                 \
> -      _flo.bits.frac = X##_f;                  \
> -      _flo.bits.exp  = X##_e;                  \
> -      _flo.bits.sign = X##_s;                  \
> +      _FP_PACK_RAW_1_flo.bits.frac = X##_f;    \
> +      _FP_PACK_RAW_1_flo.bits.exp  = X##_e;    \
> +      _FP_PACK_RAW_1_flo.bits.sign = X##_s;    \
>                                                 \
> -      (val) = _flo.flt;                                \
> +      (val) = _FP_PACK_RAW_1_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;                                         \
> -    }                                                                  \
> +#define _FP_PACK_RAW_1_P(fs, val, X)                   \
> +  do                                                   \
> +    {                                                  \
> +      union _FP_UNION_##fs *_FP_PACK_RAW_1_P_flo       \
> +       = (union _FP_UNION_##fs *) (val);               \
> +                                                       \
> +      _FP_PACK_RAW_1_P_flo->bits.frac = X##_f;         \
> +      _FP_PACK_RAW_1_P_flo->bits.exp  = X##_e;         \
> +      _FP_PACK_RAW_1_P_flo->bits.sign = X##_s;         \
> +    }                                                  \
>    while (0)
>
>
> @@ -181,13 +183,14 @@
>  #define _FP_MUL_MEAT_1_wide(wfracbits, R, X, Y, doit)                  \
>    do                                                                   \
>      {                                                                  \
> -      _FP_FRAC_DECL_2 (_Z);                                            \
> -      _FP_MUL_MEAT_DW_1_wide (wfracbits, _Z, X, Y, doit);              \
> +      _FP_FRAC_DECL_2 (_FP_MUL_MEAT_1_wide_Z);                         \
> +      _FP_MUL_MEAT_DW_1_wide (wfracbits, _FP_MUL_MEAT_1_wide_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;                                                   \
> +      _FP_FRAC_SRS_2 (_FP_MUL_MEAT_1_wide_Z, wfracbits-1, 2*wfracbits);        \
> +      R##_f = _FP_MUL_MEAT_1_wide_Z_f0;                                        \
>      }                                                                  \
>    while (0)
>
> @@ -196,40 +199,49 @@
>  #define _FP_MUL_MEAT_DW_1_hard(wfracbits, R, X, Y)                     \
>    do                                                                   \
>      {                                                                  \
> -      _FP_W_TYPE _xh, _xl, _yh, _yl;                                   \
> -      _FP_FRAC_DECL_2 (_a);                                            \
> +      _FP_W_TYPE _FP_MUL_MEAT_DW_1_hard_xh, _FP_MUL_MEAT_DW_1_hard_xl; \
> +      _FP_W_TYPE _FP_MUL_MEAT_DW_1_hard_yh, _FP_MUL_MEAT_DW_1_hard_yl; \
> +      _FP_FRAC_DECL_2 (_FP_MUL_MEAT_DW_1_hard_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);     \
> +      _FP_MUL_MEAT_DW_1_hard_xh = X##_f >> (_FP_W_TYPE_SIZE/2);                \
> +      _FP_MUL_MEAT_DW_1_hard_xl                                                \
> +       = X##_f & (((_FP_W_TYPE) 1 << (_FP_W_TYPE_SIZE/2)) - 1);        \
> +      _FP_MUL_MEAT_DW_1_hard_yh = Y##_f >> (_FP_W_TYPE_SIZE/2);                \
> +      _FP_MUL_MEAT_DW_1_hard_yl                                                \
> +       = Y##_f & (((_FP_W_TYPE) 1 << (_FP_W_TYPE_SIZE/2)) - 1);        \
>                                                                         \
>        /* multiply the pieces */                                                \
> -      R##_f0 = _xl * _yl;                                              \
> -      _a_f0 = _xh * _yl;                                               \
> -      _a_f1 = _xl * _yh;                                               \
> -      R##_f1 = _xh * _yh;                                              \
> +      R##_f0 = _FP_MUL_MEAT_DW_1_hard_xl * _FP_MUL_MEAT_DW_1_hard_yl;  \
> +      _FP_MUL_MEAT_DW_1_hard_a_f0                                      \
> +       = _FP_MUL_MEAT_DW_1_hard_xh * _FP_MUL_MEAT_DW_1_hard_yl;        \
> +      _FP_MUL_MEAT_DW_1_hard_a_f1                                      \
> +       = _FP_MUL_MEAT_DW_1_hard_xl * _FP_MUL_MEAT_DW_1_hard_yh;        \
> +      R##_f1 = _FP_MUL_MEAT_DW_1_hard_xh * _FP_MUL_MEAT_DW_1_hard_yh;  \
>                                                                         \
>        /* reassemble into two full words */                             \
> -      if ((_a_f0 += _a_f1) < _a_f1)                                    \
> +      if ((_FP_MUL_MEAT_DW_1_hard_a_f0 += _FP_MUL_MEAT_DW_1_hard_a_f1) \
> +         < _FP_MUL_MEAT_DW_1_hard_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);                                       \
> +      _FP_MUL_MEAT_DW_1_hard_a_f1                                      \
> +       = _FP_MUL_MEAT_DW_1_hard_a_f0 >> (_FP_W_TYPE_SIZE/2);           \
> +      _FP_MUL_MEAT_DW_1_hard_a_f0                                      \
> +       = _FP_MUL_MEAT_DW_1_hard_a_f0 << (_FP_W_TYPE_SIZE/2);           \
> +      _FP_FRAC_ADD_2 (R, R, _FP_MUL_MEAT_DW_1_hard_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;                                   \
> -    }                                                  \
> +#define _FP_MUL_MEAT_1_hard(wfracbits, R, X, Y)                                \
> +  do                                                                   \
> +    {                                                                  \
> +      _FP_FRAC_DECL_2 (_FP_MUL_MEAT_1_hard_z);                         \
> +      _FP_MUL_MEAT_DW_1_hard (wfracbits, _FP_MUL_MEAT_1_hard_z, X, Y); \
> +                                                                       \
> +      /* normalize */                                                  \
> +      _FP_FRAC_SRS_2 (_FP_MUL_MEAT_1_hard_z,                           \
> +                     wfracbits - 1, 2*wfracbits);                      \
> +      R##_f = _FP_MUL_MEAT_1_hard_z_f0;                                        \
> +    }                                                                  \
>    while (0)
>
>
> @@ -242,16 +254,16 @@
>     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);                  \
> -    }                                          \
> +#define _FP_DIV_MEAT_1_imm(fs, R, X, Y, doit)                          \
> +  do                                                                   \
> +    {                                                                  \
> +      _FP_W_TYPE _FP_DIV_MEAT_1_imm_q, _FP_DIV_MEAT_1_imm_r;           \
> +      X##_f <<= (X##_f < Y##_f                                         \
> +                ? R##_e--, _FP_WFRACBITS_##fs                          \
> +                : _FP_WFRACBITS_##fs - 1);                             \
> +      doit (_FP_DIV_MEAT_1_imm_q, _FP_DIV_MEAT_1_imm_r, X##_f, Y##_f); \
> +      R##_f = _FP_DIV_MEAT_1_imm_q | (_FP_DIV_MEAT_1_imm_r != 0);      \
> +    }                                                                  \
>    while (0)
>
>  /* GCC's longlong.h defines a 2W / 1W => (1W,1W) primitive udiv_qrnnd
> @@ -262,47 +274,59 @@
>  #define _FP_DIV_MEAT_1_udiv_norm(fs, R, X, Y)                          \
>    do                                                                   \
>      {                                                                  \
> -      _FP_W_TYPE _nh, _nl, _q, _r, _y;                                 \
> +      _FP_W_TYPE _FP_DIV_MEAT_1_udiv_norm_nh;                          \
> +      _FP_W_TYPE _FP_DIV_MEAT_1_udiv_norm_nl;                          \
> +      _FP_W_TYPE _FP_DIV_MEAT_1_udiv_norm_q;                           \
> +      _FP_W_TYPE _FP_DIV_MEAT_1_udiv_norm_r;                           \
> +      _FP_W_TYPE _FP_DIV_MEAT_1_udiv_norm_y;                           \
>                                                                         \
>        /* Normalize Y -- i.e. make the most significant bit set.  */    \
> -      _y = Y##_f << _FP_WFRACXBITS_##fs;                               \
> +      _FP_DIV_MEAT_1_udiv_norm_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;                                                  \
> +         _FP_DIV_MEAT_1_udiv_norm_nl = 0;                              \
> +         _FP_DIV_MEAT_1_udiv_norm_nh = X##_f;                          \
>         }                                                               \
>        else                                                             \
>         {                                                               \
> -         _nl = X##_f << (_FP_W_TYPE_SIZE - 1);                         \
> -         _nh = X##_f >> 1;                                             \
> +         _FP_DIV_MEAT_1_udiv_norm_nl = X##_f << (_FP_W_TYPE_SIZE - 1); \
> +         _FP_DIV_MEAT_1_udiv_norm_nh = X##_f >> 1;                     \
>         }                                                               \
>                                                                         \
> -      udiv_qrnnd (_q, _r, _nh, _nl, _y);                               \
> -      R##_f = _q | (_r != 0);                                          \
> +      udiv_qrnnd (_FP_DIV_MEAT_1_udiv_norm_q,                          \
> +                 _FP_DIV_MEAT_1_udiv_norm_r,                           \
> +                 _FP_DIV_MEAT_1_udiv_norm_nh,                          \
> +                 _FP_DIV_MEAT_1_udiv_norm_nl,                          \
> +                 _FP_DIV_MEAT_1_udiv_norm_y);                          \
> +      R##_f = (_FP_DIV_MEAT_1_udiv_norm_q                              \
> +              | (_FP_DIV_MEAT_1_udiv_norm_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);                          \
> -    }                                                  \
> +#define _FP_DIV_MEAT_1_udiv(fs, R, X, Y)                               \
> +  do                                                                   \
> +    {                                                                  \
> +      _FP_W_TYPE _FP_DIV_MEAT_1_udiv_nh, _FP_DIV_MEAT_1_udiv_nl;       \
> +      _FP_W_TYPE _FP_DIV_MEAT_1_udiv_q, _FP_DIV_MEAT_1_udiv_r;         \
> +      if (X##_f < Y##_f)                                               \
> +       {                                                               \
> +         R##_e--;                                                      \
> +         _FP_DIV_MEAT_1_udiv_nl = X##_f << _FP_WFRACBITS_##fs;         \
> +         _FP_DIV_MEAT_1_udiv_nh = X##_f >> _FP_WFRACXBITS_##fs;        \
> +       }                                                               \
> +      else                                                             \
> +       {                                                               \
> +         _FP_DIV_MEAT_1_udiv_nl = X##_f << (_FP_WFRACBITS_##fs - 1);   \
> +         _FP_DIV_MEAT_1_udiv_nh = X##_f >> (_FP_WFRACXBITS_##fs + 1);  \
> +       }                                                               \
> +      udiv_qrnnd (_FP_DIV_MEAT_1_udiv_q, _FP_DIV_MEAT_1_udiv_r,                \
> +                 _FP_DIV_MEAT_1_udiv_nh, _FP_DIV_MEAT_1_udiv_nl,       \
> +                 Y##_f);                                               \
> +      R##_f = _FP_DIV_MEAT_1_udiv_q | (_FP_DIV_MEAT_1_udiv_r != 0);    \
> +    }                                                                  \
>    while (0)
>
>
> diff --git a/soft-fp/op-2.h b/soft-fp/op-2.h
> index 160990f..4ea2a00 100644
> --- a/soft-fp/op-2.h
> +++ b/soft-fp/op-2.h
> @@ -182,12 +182,12 @@
>    (rh = xh - yh - ((rl = xl - yl) > xl))
>  # endif
>  # ifndef __FP_FRAC_DEC_2
> -#  define __FP_FRAC_DEC_2(xh, xl, yh, yl)      \
> -  do                                           \
> -    {                                          \
> -      UWtype _t = xl;                          \
> -      xh -= yh + ((xl -= yl) > _t);            \
> -    }                                          \
> +#  define __FP_FRAC_DEC_2(xh, xl, yh, yl)              \
> +  do                                                   \
> +    {                                                  \
> +      UWtype __FP_FRAC_DEC_2_t = xl;                   \
> +      xh -= yh + ((xl -= yl) > __FP_FRAC_DEC_2_t);     \
> +    }                                                  \
>    while (0)
>  # endif
>
> @@ -210,29 +210,30 @@
>   * normalize the data.
>   */
>
> -#define _FP_UNPACK_RAW_2(fs, X, val)           \
> -  do                                           \
> -    {                                          \
> -      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;                 \
> -    }                                          \
> +#define _FP_UNPACK_RAW_2(fs, X, val)                   \
> +  do                                                   \
> +    {                                                  \
> +      union _FP_UNION_##fs _FP_UNPACK_RAW_2_flo;       \
> +      _FP_UNPACK_RAW_2_flo.flt = (val);                        \
> +                                                       \
> +      X##_f0 = _FP_UNPACK_RAW_2_flo.bits.frac0;                \
> +      X##_f1 = _FP_UNPACK_RAW_2_flo.bits.frac1;                \
> +      X##_e  = _FP_UNPACK_RAW_2_flo.bits.exp;          \
> +      X##_s  = _FP_UNPACK_RAW_2_flo.bits.sign;         \
> +    }                                                  \
>    while (0)
>
> -#define _FP_UNPACK_RAW_2_P(fs, X, val)                                 \
> -  do                                                                   \
> -    {                                                                  \
> -      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;                                                \
> -    }                                                                  \
> +#define _FP_UNPACK_RAW_2_P(fs, X, val)                 \
> +  do                                                   \
> +    {                                                  \
> +      union _FP_UNION_##fs *_FP_UNPACK_RAW_2_P_flo     \
> +       = (union _FP_UNION_##fs *) (val);               \
> +                                                       \
> +      X##_f0 = _FP_UNPACK_RAW_2_P_flo->bits.frac0;     \
> +      X##_f1 = _FP_UNPACK_RAW_2_P_flo->bits.frac1;     \
> +      X##_e  = _FP_UNPACK_RAW_2_P_flo->bits.exp;       \
> +      X##_s  = _FP_UNPACK_RAW_2_P_flo->bits.sign;      \
> +    }                                                  \
>    while (0)
>
>
> @@ -243,27 +244,28 @@
>  #define _FP_PACK_RAW_2(fs, val, X)             \
>    do                                           \
>      {                                          \
> -      union _FP_UNION_##fs _flo;               \
> +      union _FP_UNION_##fs _FP_PACK_RAW_2_flo; \
>                                                 \
> -      _flo.bits.frac0 = X##_f0;                        \
> -      _flo.bits.frac1 = X##_f1;                        \
> -      _flo.bits.exp   = X##_e;                 \
> -      _flo.bits.sign  = X##_s;                 \
> +      _FP_PACK_RAW_2_flo.bits.frac0 = X##_f0;  \
> +      _FP_PACK_RAW_2_flo.bits.frac1 = X##_f1;  \
> +      _FP_PACK_RAW_2_flo.bits.exp   = X##_e;   \
> +      _FP_PACK_RAW_2_flo.bits.sign  = X##_s;   \
>                                                 \
> -      (val) = _flo.flt;                                \
> +      (val) = _FP_PACK_RAW_2_flo.flt;          \
>      }                                          \
>    while (0)
>
> -#define _FP_PACK_RAW_2_P(fs, val, X)                                   \
> -  do                                                                   \
> -    {                                                                  \
> -      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;                                                \
> -    }                                                                  \
> +#define _FP_PACK_RAW_2_P(fs, val, X)                   \
> +  do                                                   \
> +    {                                                  \
> +      union _FP_UNION_##fs *_FP_PACK_RAW_2_P_flo       \
> +       = (union _FP_UNION_##fs *) (val);               \
> +                                                       \
> +      _FP_PACK_RAW_2_P_flo->bits.frac0 = X##_f0;       \
> +      _FP_PACK_RAW_2_P_flo->bits.frac1 = X##_f1;       \
> +      _FP_PACK_RAW_2_P_flo->bits.exp   = X##_e;                \
> +      _FP_PACK_RAW_2_P_flo->bits.sign  = X##_s;                \
> +    }                                                  \
>    while (0)
>
>
> @@ -276,20 +278,28 @@
>  #define _FP_MUL_MEAT_DW_2_wide(wfracbits, R, X, Y, doit)               \
>    do                                                                   \
>      {                                                                  \
> -      _FP_FRAC_DECL_2 (_b);                                            \
> -      _FP_FRAC_DECL_2 (_c);                                            \
> +      _FP_FRAC_DECL_2 (_FP_MUL_MEAT_DW_2_wide_b);                      \
> +      _FP_FRAC_DECL_2 (_FP_MUL_MEAT_DW_2_wide_c);                      \
>                                                                         \
> -      doit (_FP_FRAC_WORD_4 (R, 1), _FP_FRAC_WORD_4 (R, 0), X##_f0, Y##_f0); \
> -      doit (_b_f1, _b_f0, X##_f0, Y##_f1);                             \
> -      doit (_c_f1, _c_f0, X##_f1, Y##_f0);                             \
> -      doit (_FP_FRAC_WORD_4 (R, 3), _FP_FRAC_WORD_4 (R, 2), X##_f1, Y##_f1); \
> +      doit (_FP_FRAC_WORD_4 (R, 1), _FP_FRAC_WORD_4 (R, 0),            \
> +           X##_f0, Y##_f0);                                            \
> +      doit (_FP_MUL_MEAT_DW_2_wide_b_f1, _FP_MUL_MEAT_DW_2_wide_b_f0,  \
> +           X##_f0, Y##_f1);                                            \
> +      doit (_FP_MUL_MEAT_DW_2_wide_c_f1, _FP_MUL_MEAT_DW_2_wide_c_f0,  \
> +           X##_f1, Y##_f0);                                            \
> +      doit (_FP_FRAC_WORD_4 (R, 3), _FP_FRAC_WORD_4 (R, 2),            \
> +           X##_f1, Y##_f1);                                            \
>                                                                         \
>        __FP_FRAC_ADD_3 (_FP_FRAC_WORD_4 (R, 3), _FP_FRAC_WORD_4 (R, 2), \
> -                      _FP_FRAC_WORD_4 (R, 1), 0, _b_f1, _b_f0,         \
> +                      _FP_FRAC_WORD_4 (R, 1), 0,                       \
> +                      _FP_MUL_MEAT_DW_2_wide_b_f1,                     \
> +                      _FP_MUL_MEAT_DW_2_wide_b_f0,                     \
>                        _FP_FRAC_WORD_4 (R, 3), _FP_FRAC_WORD_4 (R, 2),  \
>                        _FP_FRAC_WORD_4 (R, 1));                         \
>        __FP_FRAC_ADD_3 (_FP_FRAC_WORD_4 (R, 3), _FP_FRAC_WORD_4 (R, 2), \
> -                      _FP_FRAC_WORD_4 (R, 1), 0, _c_f1, _c_f0,         \
> +                      _FP_FRAC_WORD_4 (R, 1), 0,                       \
> +                      _FP_MUL_MEAT_DW_2_wide_c_f1,                     \
> +                      _FP_MUL_MEAT_DW_2_wide_c_f0,                     \
>                        _FP_FRAC_WORD_4 (R, 3), _FP_FRAC_WORD_4 (R, 2),  \
>                        _FP_FRAC_WORD_4 (R, 1));                         \
>      }                                                                  \
> @@ -298,16 +308,17 @@
>  #define _FP_MUL_MEAT_2_wide(wfracbits, R, X, Y, doit)                  \
>    do                                                                   \
>      {                                                                  \
> -      _FP_FRAC_DECL_4 (_z);                                            \
> +      _FP_FRAC_DECL_4 (_FP_MUL_MEAT_2_wide_z);                         \
>                                                                         \
> -      _FP_MUL_MEAT_DW_2_wide (wfracbits, _z, X, Y, doit);              \
> +      _FP_MUL_MEAT_DW_2_wide (wfracbits, _FP_MUL_MEAT_2_wide_z,                \
> +                             X, Y, doit);                              \
>                                                                         \
>        /* Normalize since we know where the msb of the multiplicands    \
>          were (bit B), we know that the msb of the of the product is    \
>          at either 2B or 2B-1.  */                                      \
> -      _FP_FRAC_SRS_4 (_z, wfracbits-1, 2*wfracbits);                   \
> -      R##_f0 = _FP_FRAC_WORD_4 (_z, 0);                                        \
> -      R##_f1 = _FP_FRAC_WORD_4 (_z, 1);                                        \
> +      _FP_FRAC_SRS_4 (_FP_MUL_MEAT_2_wide_z, wfracbits-1, 2*wfracbits);        \
> +      R##_f0 = _FP_FRAC_WORD_4 (_FP_MUL_MEAT_2_wide_z, 0);             \
> +      R##_f1 = _FP_FRAC_WORD_4 (_FP_MUL_MEAT_2_wide_z, 1);             \
>      }                                                                  \
>    while (0)
>
> @@ -318,35 +329,51 @@
>  #define _FP_MUL_MEAT_DW_2_wide_3mul(wfracbits, R, X, Y, doit)          \
>    do                                                                   \
>      {                                                                  \
> -      _FP_FRAC_DECL_2 (_b);                                            \
> -      _FP_FRAC_DECL_2 (_c);                                            \
> -      _FP_W_TYPE _d;                                                   \
> -      int _c1, _c2;                                                    \
> +      _FP_FRAC_DECL_2 (_FP_MUL_MEAT_DW_2_wide_3mul_b);                 \
> +      _FP_FRAC_DECL_2 (_FP_MUL_MEAT_DW_2_wide_3mul_c);                 \
> +      _FP_W_TYPE _FP_MUL_MEAT_DW_2_wide_3mul_d;                                \
> +      int _FP_MUL_MEAT_DW_2_wide_3mul_c1;                              \
> +      int _FP_MUL_MEAT_DW_2_wide_3mul_c2;                              \
>                                                                         \
> -      _b_f0 = X##_f0 + X##_f1;                                         \
> -      _c1 = _b_f0 < X##_f0;                                            \
> -      _b_f1 = Y##_f0 + Y##_f1;                                         \
> -      _c2 = _b_f1 < Y##_f0;                                            \
> -      doit (_d, _FP_FRAC_WORD_4 (R, 0), X##_f0, Y##_f0);               \
> -      doit (_FP_FRAC_WORD_4 (R, 2), _FP_FRAC_WORD_4 (R, 1), _b_f0, _b_f1); \
> -      doit (_c_f1, _c_f0, X##_f1, Y##_f1);                             \
> +      _FP_MUL_MEAT_DW_2_wide_3mul_b_f0 = X##_f0 + X##_f1;              \
> +      _FP_MUL_MEAT_DW_2_wide_3mul_c1                                   \
> +       = _FP_MUL_MEAT_DW_2_wide_3mul_b_f0 < X##_f0;                    \
> +      _FP_MUL_MEAT_DW_2_wide_3mul_b_f1 = Y##_f0 + Y##_f1;              \
> +      _FP_MUL_MEAT_DW_2_wide_3mul_c2                                   \
> +       = _FP_MUL_MEAT_DW_2_wide_3mul_b_f1 < Y##_f0;                    \
> +      doit (_FP_MUL_MEAT_DW_2_wide_3mul_d, _FP_FRAC_WORD_4 (R, 0),     \
> +           X##_f0, Y##_f0);                                            \
> +      doit (_FP_FRAC_WORD_4 (R, 2), _FP_FRAC_WORD_4 (R, 1),            \
> +           _FP_MUL_MEAT_DW_2_wide_3mul_b_f0,                           \
> +           _FP_MUL_MEAT_DW_2_wide_3mul_b_f1);                          \
> +      doit (_FP_MUL_MEAT_DW_2_wide_3mul_c_f1,                          \
> +           _FP_MUL_MEAT_DW_2_wide_3mul_c_f0, X##_f1, Y##_f1);          \
>                                                                         \
> -      _b_f0 &= -_c2;                                                   \
> -      _b_f1 &= -_c1;                                                   \
> +      _FP_MUL_MEAT_DW_2_wide_3mul_b_f0                                 \
> +       &= -_FP_MUL_MEAT_DW_2_wide_3mul_c2;                             \
> +      _FP_MUL_MEAT_DW_2_wide_3mul_b_f1                                 \
> +       &= -_FP_MUL_MEAT_DW_2_wide_3mul_c1;                             \
>        __FP_FRAC_ADD_3 (_FP_FRAC_WORD_4 (R, 3), _FP_FRAC_WORD_4 (R, 2), \
> -                      _FP_FRAC_WORD_4 (R, 1), (_c1 & _c2), 0, _d,      \
> +                      _FP_FRAC_WORD_4 (R, 1),                          \
> +                      (_FP_MUL_MEAT_DW_2_wide_3mul_c1                  \
> +                       & _FP_MUL_MEAT_DW_2_wide_3mul_c2), 0,           \
> +                      _FP_MUL_MEAT_DW_2_wide_3mul_d,                   \
>                        0, _FP_FRAC_WORD_4 (R, 2), _FP_FRAC_WORD_4 (R, 1)); \
>        __FP_FRAC_ADDI_2 (_FP_FRAC_WORD_4 (R, 3), _FP_FRAC_WORD_4 (R, 2),        \
> -                       _b_f0);                                         \
> +                       _FP_MUL_MEAT_DW_2_wide_3mul_b_f0);              \
>        __FP_FRAC_ADDI_2 (_FP_FRAC_WORD_4 (R, 3), _FP_FRAC_WORD_4 (R, 2),        \
> -                       _b_f1);                                         \
> +                       _FP_MUL_MEAT_DW_2_wide_3mul_b_f1);              \
>        __FP_FRAC_DEC_3 (_FP_FRAC_WORD_4 (R, 3), _FP_FRAC_WORD_4 (R, 2), \
>                        _FP_FRAC_WORD_4 (R, 1),                          \
> -                      0, _d, _FP_FRAC_WORD_4 (R, 0));                  \
> +                      0, _FP_MUL_MEAT_DW_2_wide_3mul_d,                \
> +                      _FP_FRAC_WORD_4 (R, 0));                         \
>        __FP_FRAC_DEC_3 (_FP_FRAC_WORD_4 (R, 3), _FP_FRAC_WORD_4 (R, 2), \
> -                      _FP_FRAC_WORD_4 (R, 1), 0, _c_f1, _c_f0);        \
> +                      _FP_FRAC_WORD_4 (R, 1), 0,                       \
> +                      _FP_MUL_MEAT_DW_2_wide_3mul_c_f1,                \
> +                      _FP_MUL_MEAT_DW_2_wide_3mul_c_f0);               \
>        __FP_FRAC_ADD_2 (_FP_FRAC_WORD_4 (R, 3), _FP_FRAC_WORD_4 (R, 2), \
> -                      _c_f1, _c_f0,                                    \
> +                      _FP_MUL_MEAT_DW_2_wide_3mul_c_f1,                \
> +                      _FP_MUL_MEAT_DW_2_wide_3mul_c_f0,                \
>                        _FP_FRAC_WORD_4 (R, 3), _FP_FRAC_WORD_4 (R, 2)); \
>      }                                                                  \
>    while (0)
> @@ -354,45 +381,50 @@
>  #define _FP_MUL_MEAT_2_wide_3mul(wfracbits, R, X, Y, doit)             \
>    do                                                                   \
>      {                                                                  \
> -      _FP_FRAC_DECL_4 (_z);                                            \
> +      _FP_FRAC_DECL_4 (_FP_MUL_MEAT_2_wide_3mul_z);                    \
>                                                                         \
> -      _FP_MUL_MEAT_DW_2_wide_3mul (wfracbits, _z, X, Y, doit);         \
> +      _FP_MUL_MEAT_DW_2_wide_3mul (wfracbits,                          \
> +                                  _FP_MUL_MEAT_2_wide_3mul_z,          \
> +                                  X, Y, doit);                         \
>                                                                         \
>        /* Normalize since we know where the msb of the multiplicands    \
>          were (bit B), we know that the msb of the of the product is    \
>          at either 2B or 2B-1.  */                                      \
> -      _FP_FRAC_SRS_4 (_z, wfracbits-1, 2*wfracbits);                   \
> -      R##_f0 = _FP_FRAC_WORD_4 (_z, 0);                                        \
> -      R##_f1 = _FP_FRAC_WORD_4 (_z, 1);                                        \
> +      _FP_FRAC_SRS_4 (_FP_MUL_MEAT_2_wide_3mul_z,                      \
> +                     wfracbits-1, 2*wfracbits);                        \
> +      R##_f0 = _FP_FRAC_WORD_4 (_FP_MUL_MEAT_2_wide_3mul_z, 0);                \
> +      R##_f1 = _FP_FRAC_WORD_4 (_FP_MUL_MEAT_2_wide_3mul_z, 1);                \
>      }                                                                  \
>    while (0)
>
>  #define _FP_MUL_MEAT_DW_2_gmp(wfracbits, R, X, Y)      \
>    do                                                   \
>      {                                                  \
> -      _FP_W_TYPE _x[2], _y[2];                         \
> -      _x[0] = X##_f0;                                  \
> -      _x[1] = X##_f1;                                  \
> -      _y[0] = Y##_f0;                                  \
> -      _y[1] = Y##_f1;                                  \
> +      _FP_W_TYPE _FP_MUL_MEAT_DW_2_gmp_x[2];           \
> +      _FP_W_TYPE _FP_MUL_MEAT_DW_2_gmp_y[2];           \
> +      _FP_MUL_MEAT_DW_2_gmp_x[0] = X##_f0;             \
> +      _FP_MUL_MEAT_DW_2_gmp_x[1] = X##_f1;             \
> +      _FP_MUL_MEAT_DW_2_gmp_y[0] = Y##_f0;             \
> +      _FP_MUL_MEAT_DW_2_gmp_y[1] = Y##_f1;             \
>                                                         \
> -      mpn_mul_n (R##_f, _x, _y, 2);                    \
> +      mpn_mul_n (R##_f, _FP_MUL_MEAT_DW_2_gmp_x,       \
> +                _FP_MUL_MEAT_DW_2_gmp_y, 2);           \
>      }                                                  \
>    while (0)
>
>  #define _FP_MUL_MEAT_2_gmp(wfracbits, R, X, Y)                         \
>    do                                                                   \
>      {                                                                  \
> -      _FP_FRAC_DECL_4 (_z);                                            \
> +      _FP_FRAC_DECL_4 (_FP_MUL_MEAT_2_gmp_z);                          \
>                                                                         \
> -      _FP_MUL_MEAT_DW_2_gmp (wfracbits, _z, X, Y);                     \
> +      _FP_MUL_MEAT_DW_2_gmp (wfracbits, _FP_MUL_MEAT_2_gmp_z, 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_4 (_z, wfracbits-1, 2*wfracbits);                   \
> -      R##_f0 = _z_f[0];                                                        \
> -      R##_f1 = _z_f[1];                                                        \
> +      _FP_FRAC_SRS_4 (_FP_MUL_MEAT_2_gmp_z, wfracbits-1, 2*wfracbits); \
> +      R##_f0 = _FP_MUL_MEAT_2_gmp_z_f[0];                              \
> +      R##_f1 = _FP_MUL_MEAT_2_gmp_z_f[1];                              \
>      }                                                                  \
>    while (0)
>
> @@ -507,67 +539,91 @@
>  #define _FP_DIV_MEAT_2_udiv(fs, R, X, Y)                               \
>    do                                                                   \
>      {                                                                  \
> -      _FP_W_TYPE _n_f2, _n_f1, _n_f0, _r_f1, _r_f0, _m_f1, _m_f0;      \
> +      _FP_W_TYPE _FP_DIV_MEAT_2_udiv_n_f2;                             \
> +      _FP_W_TYPE _FP_DIV_MEAT_2_udiv_n_f1;                             \
> +      _FP_W_TYPE _FP_DIV_MEAT_2_udiv_n_f0;                             \
> +      _FP_W_TYPE _FP_DIV_MEAT_2_udiv_r_f1;                             \
> +      _FP_W_TYPE _FP_DIV_MEAT_2_udiv_r_f0;                             \
> +      _FP_W_TYPE _FP_DIV_MEAT_2_udiv_m_f1;                             \
> +      _FP_W_TYPE _FP_DIV_MEAT_2_udiv_m_f0;                             \
>        if (_FP_FRAC_GE_2 (X, Y))                                                \
>         {                                                               \
> -         _n_f2 = X##_f1 >> 1;                                          \
> -         _n_f1 = X##_f1 << (_FP_W_TYPE_SIZE - 1) | X##_f0 >> 1;        \
> -         _n_f0 = X##_f0 << (_FP_W_TYPE_SIZE - 1);                      \
> +         _FP_DIV_MEAT_2_udiv_n_f2 = X##_f1 >> 1;                       \
> +         _FP_DIV_MEAT_2_udiv_n_f1                                      \
> +           = X##_f1 << (_FP_W_TYPE_SIZE - 1) | X##_f0 >> 1;            \
> +         _FP_DIV_MEAT_2_udiv_n_f0                                      \
> +           = X##_f0 << (_FP_W_TYPE_SIZE - 1);                          \
>         }                                                               \
>        else                                                             \
>         {                                                               \
>           R##_e--;                                                      \
> -         _n_f2 = X##_f1;                                               \
> -         _n_f1 = X##_f0;                                               \
> -         _n_f0 = 0;                                                    \
> +         _FP_DIV_MEAT_2_udiv_n_f2 = X##_f1;                            \
> +         _FP_DIV_MEAT_2_udiv_n_f1 = X##_f0;                            \
> +         _FP_DIV_MEAT_2_udiv_n_f0 = 0;                                 \
>         }                                                               \
>                                                                         \
>        /* Normalize, i.e. make the most significant bit of the          \
>          denominator set. */                                            \
>        _FP_FRAC_SLL_2 (Y, _FP_WFRACXBITS_##fs);                         \
>                                                                         \
> -      udiv_qrnnd (R##_f1, _r_f1, _n_f2, _n_f1, Y##_f1);                        \
> -      umul_ppmm (_m_f1, _m_f0, R##_f1, Y##_f0);                                \
> -      _r_f0 = _n_f0;                                                   \
> -      if (_FP_FRAC_GT_2 (_m, _r))                                      \
> +      udiv_qrnnd (R##_f1, _FP_DIV_MEAT_2_udiv_r_f1,                    \
> +                 _FP_DIV_MEAT_2_udiv_n_f2, _FP_DIV_MEAT_2_udiv_n_f1,   \
> +                 Y##_f1);                                              \
> +      umul_ppmm (_FP_DIV_MEAT_2_udiv_m_f1, _FP_DIV_MEAT_2_udiv_m_f0,   \
> +                R##_f1, Y##_f0);                                       \
> +      _FP_DIV_MEAT_2_udiv_r_f0 = _FP_DIV_MEAT_2_udiv_n_f0;             \
> +      if (_FP_FRAC_GT_2 (_FP_DIV_MEAT_2_udiv_m, _FP_DIV_MEAT_2_udiv_r))        \
>         {                                                               \
>           R##_f1--;                                                     \
> -         _FP_FRAC_ADD_2 (_r, Y, _r);                                   \
> -         if (_FP_FRAC_GE_2 (_r, Y) && _FP_FRAC_GT_2 (_m, _r))          \
> +         _FP_FRAC_ADD_2 (_FP_DIV_MEAT_2_udiv_r, Y,                     \
> +                         _FP_DIV_MEAT_2_udiv_r);                       \
> +         if (_FP_FRAC_GE_2 (_FP_DIV_MEAT_2_udiv_r, Y)                  \
> +             && _FP_FRAC_GT_2 (_FP_DIV_MEAT_2_udiv_m,                  \
> +                               _FP_DIV_MEAT_2_udiv_r))                 \
>             {                                                           \
>               R##_f1--;                                                 \
> -             _FP_FRAC_ADD_2 (_r, Y, _r);                               \
> +             _FP_FRAC_ADD_2 (_FP_DIV_MEAT_2_udiv_r, Y,                 \
> +                             _FP_DIV_MEAT_2_udiv_r);                   \
>             }                                                           \
>         }                                                               \
> -      _FP_FRAC_DEC_2 (_r, _m);                                         \
> +      _FP_FRAC_DEC_2 (_FP_DIV_MEAT_2_udiv_r, _FP_DIV_MEAT_2_udiv_m);   \
>                                                                         \
> -      if (_r_f1 == Y##_f1)                                             \
> +      if (_FP_DIV_MEAT_2_udiv_r_f1 == Y##_f1)                          \
>         {                                                               \
>           /* This is a special case, not an optimization                \
> -            (_r/Y##_f1 would not fit into UWtype).                     \
> -            As _r is guaranteed to be < Y,  R##_f0 can be either       \
> -            (UWtype)-1 or (UWtype)-2.  But as we know what kind        \
> -            of bits it is (sticky, guard, round),  we don't care.      \
> -            We also don't care what the reminder is,  because the      \
> -            guard bit will be set anyway.  -jj */                      \
> +            (_FP_DIV_MEAT_2_udiv_r/Y##_f1 would not fit into UWtype).  \
> +            As _FP_DIV_MEAT_2_udiv_r is guaranteed to be < Y,          \
> +            R##_f0 can be either (UWtype)-1 or (UWtype)-2.  But as we  \
> +            know what kind of bits it is (sticky, guard, round),       \
> +            we don't care.  We also don't care what the reminder is,   \
> +            because the guard bit will be set anyway.  -jj */          \
>           R##_f0 = -1;                                                  \
>         }                                                               \
>        else                                                             \
>         {                                                               \
> -         udiv_qrnnd (R##_f0, _r_f1, _r_f1, _r_f0, Y##_f1);             \
> -         umul_ppmm (_m_f1, _m_f0, R##_f0, Y##_f0);                     \
> -         _r_f0 = 0;                                                    \
> -         if (_FP_FRAC_GT_2 (_m, _r))                                   \
> +         udiv_qrnnd (R##_f0, _FP_DIV_MEAT_2_udiv_r_f1,                 \
> +                     _FP_DIV_MEAT_2_udiv_r_f1,                         \
> +                     _FP_DIV_MEAT_2_udiv_r_f0, Y##_f1);                \
> +         umul_ppmm (_FP_DIV_MEAT_2_udiv_m_f1,                          \
> +                    _FP_DIV_MEAT_2_udiv_m_f0, R##_f0, Y##_f0);         \
> +         _FP_DIV_MEAT_2_udiv_r_f0 = 0;                                 \
> +         if (_FP_FRAC_GT_2 (_FP_DIV_MEAT_2_udiv_m,                     \
> +                            _FP_DIV_MEAT_2_udiv_r))                    \
>             {                                                           \
>               R##_f0--;                                                 \
> -             _FP_FRAC_ADD_2 (_r, Y, _r);                               \
> -             if (_FP_FRAC_GE_2 (_r, Y) && _FP_FRAC_GT_2 (_m, _r))      \
> +             _FP_FRAC_ADD_2 (_FP_DIV_MEAT_2_udiv_r, Y,                 \
> +                             _FP_DIV_MEAT_2_udiv_r);                   \
> +             if (_FP_FRAC_GE_2 (_FP_DIV_MEAT_2_udiv_r, Y)              \
> +                 && _FP_FRAC_GT_2 (_FP_DIV_MEAT_2_udiv_m,              \
> +                                   _FP_DIV_MEAT_2_udiv_r))             \
>                 {                                                       \
>                   R##_f0--;                                             \
> -                 _FP_FRAC_ADD_2 (_r, Y, _r);                           \
> +                 _FP_FRAC_ADD_2 (_FP_DIV_MEAT_2_udiv_r, Y,             \
> +                                 _FP_DIV_MEAT_2_udiv_r);               \
>                 }                                                       \
>             }                                                           \
> -         if (!_FP_FRAC_EQ_2 (_r, _m))                                  \
> +         if (!_FP_FRAC_EQ_2 (_FP_DIV_MEAT_2_udiv_r,                    \
> +                             _FP_DIV_MEAT_2_udiv_m))                   \
>             R##_f0 |= _FP_WORK_STICKY;                                  \
>         }                                                               \
>      }                                                                  \
> diff --git a/soft-fp/op-4.h b/soft-fp/op-4.h
> index a80bdb2..3acf96c 100644
> --- a/soft-fp/op-4.h
> +++ b/soft-fp/op-4.h
> @@ -39,49 +39,67 @@
>  #define _FP_FRAC_LOW_4(X)      (X##_f[0])
>  #define _FP_FRAC_WORD_4(X, w)  (X##_f[w])
>
> -#define _FP_FRAC_SLL_4(X, N)                           \
> -  do                                                   \
> -    {                                                  \
> -      _FP_I_TYPE _up, _down, _skip, _i;                        \
> -      _skip = (N) / _FP_W_TYPE_SIZE;                   \
> -      _up = (N) % _FP_W_TYPE_SIZE;                     \
> -      _down = _FP_W_TYPE_SIZE - _up;                   \
> -      if (!_up)                                                \
> -       for (_i = 3; _i >= _skip; --_i)                 \
> -         X##_f[_i] = X##_f[_i-_skip];                  \
> -      else                                             \
> -       {                                               \
> -         for (_i = 3; _i > _skip; --_i)                \
> -           X##_f[_i] = (X##_f[_i-_skip] << _up         \
> -                        | X##_f[_i-_skip-1] >> _down); \
> -         X##_f[_i--] = X##_f[0] << _up;                \
> -       }                                               \
> -      for (; _i >= 0; --_i)                            \
> -       X##_f[_i] = 0;                                  \
> -    }                                                  \
> +#define _FP_FRAC_SLL_4(X, N)                                           \
> +  do                                                                   \
> +    {                                                                  \
> +      _FP_I_TYPE _FP_FRAC_SLL_4_up, _FP_FRAC_SLL_4_down;               \
> +      _FP_I_TYPE _FP_FRAC_SLL_4_skip, _FP_FRAC_SLL_4_i;                        \
> +      _FP_FRAC_SLL_4_skip = (N) / _FP_W_TYPE_SIZE;                     \
> +      _FP_FRAC_SLL_4_up = (N) % _FP_W_TYPE_SIZE;                       \
> +      _FP_FRAC_SLL_4_down = _FP_W_TYPE_SIZE - _FP_FRAC_SLL_4_up;       \
> +      if (!_FP_FRAC_SLL_4_up)                                          \
> +       for (_FP_FRAC_SLL_4_i = 3;                                      \
> +            _FP_FRAC_SLL_4_i >= _FP_FRAC_SLL_4_skip;                   \
> +            --_FP_FRAC_SLL_4_i)                                        \
> +         X##_f[_FP_FRAC_SLL_4_i]                                       \
> +           = X##_f[_FP_FRAC_SLL_4_i-_FP_FRAC_SLL_4_skip];              \
> +      else                                                             \
> +       {                                                               \
> +         for (_FP_FRAC_SLL_4_i = 3;                                    \
> +              _FP_FRAC_SLL_4_i > _FP_FRAC_SLL_4_skip;                  \
> +              --_FP_FRAC_SLL_4_i)                                      \
> +           X##_f[_FP_FRAC_SLL_4_i]                                     \
> +             = ((X##_f[_FP_FRAC_SLL_4_i-_FP_FRAC_SLL_4_skip]           \
> +                 << _FP_FRAC_SLL_4_up)                                 \
> +                | (X##_f[_FP_FRAC_SLL_4_i-_FP_FRAC_SLL_4_skip-1]       \
> +                   >> _FP_FRAC_SLL_4_down));                           \
> +         X##_f[_FP_FRAC_SLL_4_i--] = X##_f[0] << _FP_FRAC_SLL_4_up;    \
> +       }                                                               \
> +      for (; _FP_FRAC_SLL_4_i >= 0; --_FP_FRAC_SLL_4_i)                        \
> +       X##_f[_FP_FRAC_SLL_4_i] = 0;                                    \
> +    }                                                                  \
>    while (0)
>
>  /* This one was broken too */
> -#define _FP_FRAC_SRL_4(X, N)                           \
> -  do                                                   \
> -    {                                                  \
> -      _FP_I_TYPE _up, _down, _skip, _i;                        \
> -      _skip = (N) / _FP_W_TYPE_SIZE;                   \
> -      _down = (N) % _FP_W_TYPE_SIZE;                   \
> -      _up = _FP_W_TYPE_SIZE - _down;                   \
> -      if (!_down)                                      \
> -       for (_i = 0; _i <= 3-_skip; ++_i)               \
> -         X##_f[_i] = X##_f[_i+_skip];                  \
> -      else                                             \
> -       {                                               \
> -         for (_i = 0; _i < 3-_skip; ++_i)              \
> -           X##_f[_i] = (X##_f[_i+_skip] >> _down       \
> -                        | X##_f[_i+_skip+1] << _up);   \
> -         X##_f[_i++] = X##_f[3] >> _down;              \
> -       }                                               \
> -      for (; _i < 4; ++_i)                             \
> -       X##_f[_i] = 0;                                  \
> -    }                                                  \
> +#define _FP_FRAC_SRL_4(X, N)                                           \
> +  do                                                                   \
> +    {                                                                  \
> +      _FP_I_TYPE _FP_FRAC_SRL_4_up, _FP_FRAC_SRL_4_down;               \
> +      _FP_I_TYPE _FP_FRAC_SRL_4_skip, _FP_FRAC_SRL_4_i;                        \
> +      _FP_FRAC_SRL_4_skip = (N) / _FP_W_TYPE_SIZE;                     \
> +      _FP_FRAC_SRL_4_down = (N) % _FP_W_TYPE_SIZE;                     \
> +      _FP_FRAC_SRL_4_up = _FP_W_TYPE_SIZE - _FP_FRAC_SRL_4_down;       \
> +      if (!_FP_FRAC_SRL_4_down)                                                \
> +       for (_FP_FRAC_SRL_4_i = 0;                                      \
> +            _FP_FRAC_SRL_4_i <= 3-_FP_FRAC_SRL_4_skip;                 \
> +            ++_FP_FRAC_SRL_4_i)                                        \
> +         X##_f[_FP_FRAC_SRL_4_i]                                       \
> +           = X##_f[_FP_FRAC_SRL_4_i+_FP_FRAC_SRL_4_skip];              \
> +      else                                                             \
> +       {                                                               \
> +         for (_FP_FRAC_SRL_4_i = 0;                                    \
> +              _FP_FRAC_SRL_4_i < 3-_FP_FRAC_SRL_4_skip;                \
> +              ++_FP_FRAC_SRL_4_i)                                      \
> +           X##_f[_FP_FRAC_SRL_4_i]                                     \
> +             = ((X##_f[_FP_FRAC_SRL_4_i+_FP_FRAC_SRL_4_skip]           \
> +                 >> _FP_FRAC_SRL_4_down)                               \
> +                | (X##_f[_FP_FRAC_SRL_4_i+_FP_FRAC_SRL_4_skip+1]       \
> +                   << _FP_FRAC_SRL_4_up));                             \
> +         X##_f[_FP_FRAC_SRL_4_i++] = X##_f[3] >> _FP_FRAC_SRL_4_down;  \
> +       }                                                               \
> +      for (; _FP_FRAC_SRL_4_i < 4; ++_FP_FRAC_SRL_4_i)                 \
> +       X##_f[_FP_FRAC_SRL_4_i] = 0;                                    \
> +    }                                                                  \
>    while (0)
>
>
> @@ -90,40 +108,53 @@
>   * but that if any of the bits that fall off the right hand side
>   * were one then we always set the LSbit.
>   */
> -#define _FP_FRAC_SRST_4(X, S, N, size)                 \
> -  do                                                   \
> -    {                                                  \
> -      _FP_I_TYPE _up, _down, _skip, _i;                        \
> -      _FP_W_TYPE _s;                                   \
> -      _skip = (N) / _FP_W_TYPE_SIZE;                   \
> -      _down = (N) % _FP_W_TYPE_SIZE;                   \
> -      _up = _FP_W_TYPE_SIZE - _down;                   \
> -      for (_s = _i = 0; _i < _skip; ++_i)              \
> -       _s |= X##_f[_i];                                \
> -      if (!_down)                                      \
> -       for (_i = 0; _i <= 3-_skip; ++_i)               \
> -         X##_f[_i] = X##_f[_i+_skip];                  \
> -      else                                             \
> -       {                                               \
> -         _s |= X##_f[_i] << _up;                       \
> -         for (_i = 0; _i < 3-_skip; ++_i)              \
> -           X##_f[_i] = (X##_f[_i+_skip] >> _down       \
> -                        | X##_f[_i+_skip+1] << _up);   \
> -         X##_f[_i++] = X##_f[3] >> _down;              \
> -       }                                               \
> -      for (; _i < 4; ++_i)                             \
> -       X##_f[_i] = 0;                                  \
> -      S = (_s != 0);                                   \
> -    }                                                  \
> +#define _FP_FRAC_SRST_4(X, S, N, size)                                 \
> +  do                                                                   \
> +    {                                                                  \
> +      _FP_I_TYPE _FP_FRAC_SRST_4_up, _FP_FRAC_SRST_4_down;             \
> +      _FP_I_TYPE _FP_FRAC_SRST_4_skip, _FP_FRAC_SRST_4_i;              \
> +      _FP_W_TYPE _FP_FRAC_SRST_4_s;                                    \
> +      _FP_FRAC_SRST_4_skip = (N) / _FP_W_TYPE_SIZE;                    \
> +      _FP_FRAC_SRST_4_down = (N) % _FP_W_TYPE_SIZE;                    \
> +      _FP_FRAC_SRST_4_up = _FP_W_TYPE_SIZE - _FP_FRAC_SRST_4_down;     \
> +      for (_FP_FRAC_SRST_4_s = _FP_FRAC_SRST_4_i = 0;                  \
> +          _FP_FRAC_SRST_4_i < _FP_FRAC_SRST_4_skip;                    \
> +          ++_FP_FRAC_SRST_4_i)                                         \
> +       _FP_FRAC_SRST_4_s |= X##_f[_FP_FRAC_SRST_4_i];                  \
> +      if (!_FP_FRAC_SRST_4_down)                                       \
> +       for (_FP_FRAC_SRST_4_i = 0;                                     \
> +            _FP_FRAC_SRST_4_i <= 3-_FP_FRAC_SRST_4_skip;               \
> +            ++_FP_FRAC_SRST_4_i)                                       \
> +         X##_f[_FP_FRAC_SRST_4_i]                                      \
> +           = X##_f[_FP_FRAC_SRST_4_i+_FP_FRAC_SRST_4_skip];            \
> +      else                                                             \
> +       {                                                               \
> +         _FP_FRAC_SRST_4_s                                             \
> +           |= X##_f[_FP_FRAC_SRST_4_i] << _FP_FRAC_SRST_4_up;          \
> +         for (_FP_FRAC_SRST_4_i = 0;                                   \
> +              _FP_FRAC_SRST_4_i < 3-_FP_FRAC_SRST_4_skip;              \
> +              ++_FP_FRAC_SRST_4_i)                                     \
> +           X##_f[_FP_FRAC_SRST_4_i]                                    \
> +             = ((X##_f[_FP_FRAC_SRST_4_i+_FP_FRAC_SRST_4_skip]         \
> +                 >> _FP_FRAC_SRST_4_down)                              \
> +                | (X##_f[_FP_FRAC_SRST_4_i+_FP_FRAC_SRST_4_skip+1]     \
> +                   << _FP_FRAC_SRST_4_up));                            \
> +         X##_f[_FP_FRAC_SRST_4_i++]                                    \
> +           = X##_f[3] >> _FP_FRAC_SRST_4_down;                         \
> +       }                                                               \
> +      for (; _FP_FRAC_SRST_4_i < 4; ++_FP_FRAC_SRST_4_i)               \
> +       X##_f[_FP_FRAC_SRST_4_i] = 0;                                   \
> +      S = (_FP_FRAC_SRST_4_s != 0);                                    \
> +    }                                                                  \
>    while (0)
>
> -#define _FP_FRAC_SRS_4(X, N, size)             \
> -  do                                           \
> -    {                                          \
> -      int _sticky;                             \
> -      _FP_FRAC_SRST_4 (X, _sticky, N, size);   \
> -      X##_f[0] |= _sticky;                     \
> -    }                                          \
> +#define _FP_FRAC_SRS_4(X, N, size)                             \
> +  do                                                           \
> +    {                                                          \
> +      int _FP_FRAC_SRS_4_sticky;                               \
> +      _FP_FRAC_SRST_4 (X, _FP_FRAC_SRS_4_sticky, N, size);     \
> +      X##_f[0] |= _FP_FRAC_SRS_4_sticky;                       \
> +    }                                                          \
>    while (0)
>
>  #define _FP_FRAC_ADD_4(R, X, Y)                                        \
> @@ -201,60 +232,62 @@
>    while (0)
>
>
> -#define _FP_UNPACK_RAW_4(fs, X, val)           \
> -  do                                           \
> -    {                                          \
> -      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;                 \
> -    }                                          \
> +#define _FP_UNPACK_RAW_4(fs, X, val)                   \
> +  do                                                   \
> +    {                                                  \
> +      union _FP_UNION_##fs _FP_UNPACK_RAW_4_flo;       \
> +      _FP_UNPACK_RAW_4_flo.flt = (val);                        \
> +      X##_f[0] = _FP_UNPACK_RAW_4_flo.bits.frac0;      \
> +      X##_f[1] = _FP_UNPACK_RAW_4_flo.bits.frac1;      \
> +      X##_f[2] = _FP_UNPACK_RAW_4_flo.bits.frac2;      \
> +      X##_f[3] = _FP_UNPACK_RAW_4_flo.bits.frac3;      \
> +      X##_e  = _FP_UNPACK_RAW_4_flo.bits.exp;          \
> +      X##_s  = _FP_UNPACK_RAW_4_flo.bits.sign;         \
> +    }                                                  \
>    while (0)
>
> -#define _FP_UNPACK_RAW_4_P(fs, X, val)                                 \
> -  do                                                                   \
> -    {                                                                  \
> -      union _FP_UNION_##fs *_flo = (union _FP_UNION_##fs *) (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;                                                \
> -    }                                                                  \
> +#define _FP_UNPACK_RAW_4_P(fs, X, val)                 \
> +  do                                                   \
> +    {                                                  \
> +      union _FP_UNION_##fs *_FP_UNPACK_RAW_4_P_flo     \
> +       = (union _FP_UNION_##fs *) (val);               \
> +                                                       \
> +      X##_f[0] = _FP_UNPACK_RAW_4_P_flo->bits.frac0;   \
> +      X##_f[1] = _FP_UNPACK_RAW_4_P_flo->bits.frac1;   \
> +      X##_f[2] = _FP_UNPACK_RAW_4_P_flo->bits.frac2;   \
> +      X##_f[3] = _FP_UNPACK_RAW_4_P_flo->bits.frac3;   \
> +      X##_e  = _FP_UNPACK_RAW_4_P_flo->bits.exp;       \
> +      X##_s  = _FP_UNPACK_RAW_4_P_flo->bits.sign;      \
> +    }                                                  \
>    while (0)
>
>  #define _FP_PACK_RAW_4(fs, val, X)             \
>    do                                           \
>      {                                          \
> -      union _FP_UNION_##fs _flo;               \
> -      _flo.bits.frac0 = X##_f[0];              \
> -      _flo.bits.frac1 = X##_f[1];              \
> -      _flo.bits.frac2 = X##_f[2];              \
> -      _flo.bits.frac3 = X##_f[3];              \
> -      _flo.bits.exp   = X##_e;                 \
> -      _flo.bits.sign  = X##_s;                 \
> -      (val) = _flo.flt;                                \
> +      union _FP_UNION_##fs _FP_PACK_RAW_4_flo; \
> +      _FP_PACK_RAW_4_flo.bits.frac0 = X##_f[0];        \
> +      _FP_PACK_RAW_4_flo.bits.frac1 = X##_f[1];        \
> +      _FP_PACK_RAW_4_flo.bits.frac2 = X##_f[2];        \
> +      _FP_PACK_RAW_4_flo.bits.frac3 = X##_f[3];        \
> +      _FP_PACK_RAW_4_flo.bits.exp   = X##_e;   \
> +      _FP_PACK_RAW_4_flo.bits.sign  = X##_s;   \
> +      (val) = _FP_PACK_RAW_4_flo.flt;          \
>      }                                          \
>    while (0)
>
> -#define _FP_PACK_RAW_4_P(fs, val, X)                                   \
> -  do                                                                   \
> -    {                                                                  \
> -      union _FP_UNION_##fs *_flo = (union _FP_UNION_##fs *) (val);     \
> -                                                                       \
> -      _flo->bits.frac0 = X##_f[0];                                     \
> -      _flo->bits.frac1 = X##_f[1];                                     \
> -      _flo->bits.frac2 = X##_f[2];                                     \
> -      _flo->bits.frac3 = X##_f[3];                                     \
> -      _flo->bits.exp   = X##_e;                                                \
> -      _flo->bits.sign  = X##_s;                                                \
> -    }                                                                  \
> +#define _FP_PACK_RAW_4_P(fs, val, X)                   \
> +  do                                                   \
> +    {                                                  \
> +      union _FP_UNION_##fs *_FP_PACK_RAW_4_P_flo       \
> +       = (union _FP_UNION_##fs *) (val);               \
> +                                                       \
> +      _FP_PACK_RAW_4_P_flo->bits.frac0 = X##_f[0];     \
> +      _FP_PACK_RAW_4_P_flo->bits.frac1 = X##_f[1];     \
> +      _FP_PACK_RAW_4_P_flo->bits.frac2 = X##_f[2];     \
> +      _FP_PACK_RAW_4_P_flo->bits.frac3 = X##_f[3];     \
> +      _FP_PACK_RAW_4_P_flo->bits.exp   = X##_e;                \
> +      _FP_PACK_RAW_4_P_flo->bits.sign  = X##_s;                \
> +    }                                                  \
>    while (0)
>
>  /*
> @@ -266,81 +299,126 @@
>  #define _FP_MUL_MEAT_DW_4_wide(wfracbits, R, X, Y, doit)               \
>    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 (_FP_MUL_MEAT_DW_4_wide_b);                      \
> +      _FP_FRAC_DECL_2 (_FP_MUL_MEAT_DW_4_wide_c);                      \
> +      _FP_FRAC_DECL_2 (_FP_MUL_MEAT_DW_4_wide_d);                      \
> +      _FP_FRAC_DECL_2 (_FP_MUL_MEAT_DW_4_wide_e);                      \
> +      _FP_FRAC_DECL_2 (_FP_MUL_MEAT_DW_4_wide_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]);                         \
> -      doit (_c_f1, _c_f0, X##_f[1], Y##_f[0]);                         \
> -      doit (_d_f1, _d_f0, X##_f[1], Y##_f[1]);                         \
> -      doit (_e_f1, _e_f0, X##_f[0], Y##_f[2]);                         \
> -      doit (_f_f1, _f_f0, X##_f[2], Y##_f[0]);                         \
> +      doit (_FP_FRAC_WORD_8 (R, 1), _FP_FRAC_WORD_8 (R, 0),            \
> +           X##_f[0], Y##_f[0]);                                        \
> +      doit (_FP_MUL_MEAT_DW_4_wide_b_f1, _FP_MUL_MEAT_DW_4_wide_b_f0,  \
> +           X##_f[0], Y##_f[1]);                                        \
> +      doit (_FP_MUL_MEAT_DW_4_wide_c_f1, _FP_MUL_MEAT_DW_4_wide_c_f0,  \
> +           X##_f[1], Y##_f[0]);                                        \
> +      doit (_FP_MUL_MEAT_DW_4_wide_d_f1, _FP_MUL_MEAT_DW_4_wide_d_f0,  \
> +           X##_f[1], Y##_f[1]);                                        \
> +      doit (_FP_MUL_MEAT_DW_4_wide_e_f1, _FP_MUL_MEAT_DW_4_wide_e_f0,  \
> +           X##_f[0], Y##_f[2]);                                        \
> +      doit (_FP_MUL_MEAT_DW_4_wide_f_f1, _FP_MUL_MEAT_DW_4_wide_f_f0,  \
> +           X##_f[2], Y##_f[0]);                                        \
>        __FP_FRAC_ADD_3 (_FP_FRAC_WORD_8 (R, 3), _FP_FRAC_WORD_8 (R, 2), \
> -                      _FP_FRAC_WORD_8 (R, 1), 0, _b_f1, _b_f0,         \
> +                      _FP_FRAC_WORD_8 (R, 1), 0,                       \
> +                      _FP_MUL_MEAT_DW_4_wide_b_f1,                     \
> +                      _FP_MUL_MEAT_DW_4_wide_b_f0,                     \
>                        0, 0, _FP_FRAC_WORD_8 (R, 1));                   \
>        __FP_FRAC_ADD_3 (_FP_FRAC_WORD_8 (R, 3), _FP_FRAC_WORD_8 (R, 2), \
> -                      _FP_FRAC_WORD_8 (R, 1), 0, _c_f1, _c_f0,         \
> +                      _FP_FRAC_WORD_8 (R, 1), 0,                       \
> +                      _FP_MUL_MEAT_DW_4_wide_c_f1,                     \
> +                      _FP_MUL_MEAT_DW_4_wide_c_f0,                     \
>                        _FP_FRAC_WORD_8 (R, 3), _FP_FRAC_WORD_8 (R, 2),  \
>                        _FP_FRAC_WORD_8 (R, 1));                         \
>        __FP_FRAC_ADD_3 (_FP_FRAC_WORD_8 (R, 4), _FP_FRAC_WORD_8 (R, 3), \
> -                      _FP_FRAC_WORD_8 (R, 2), 0, _d_f1, _d_f0,         \
> +                      _FP_FRAC_WORD_8 (R, 2), 0,                       \
> +                      _FP_MUL_MEAT_DW_4_wide_d_f1,                     \
> +                      _FP_MUL_MEAT_DW_4_wide_d_f0,                     \
>                        0, _FP_FRAC_WORD_8 (R, 3), _FP_FRAC_WORD_8 (R, 2)); \
>        __FP_FRAC_ADD_3 (_FP_FRAC_WORD_8 (R, 4), _FP_FRAC_WORD_8 (R, 3), \
> -                      _FP_FRAC_WORD_8 (R, 2), 0, _e_f1, _e_f0,         \
> +                      _FP_FRAC_WORD_8 (R, 2), 0,                       \
> +                      _FP_MUL_MEAT_DW_4_wide_e_f1,                     \
> +                      _FP_MUL_MEAT_DW_4_wide_e_f0,                     \
>                        _FP_FRAC_WORD_8 (R, 4), _FP_FRAC_WORD_8 (R, 3),  \
>                        _FP_FRAC_WORD_8 (R, 2));                         \
>        __FP_FRAC_ADD_3 (_FP_FRAC_WORD_8 (R, 4), _FP_FRAC_WORD_8 (R, 3), \
> -                      _FP_FRAC_WORD_8 (R, 2), 0, _f_f1, _f_f0,         \
> +                      _FP_FRAC_WORD_8 (R, 2), 0,                       \
> +                      _FP_MUL_MEAT_DW_4_wide_f_f1,                     \
> +                      _FP_MUL_MEAT_DW_4_wide_f_f0,                     \
>                        _FP_FRAC_WORD_8 (R, 4), _FP_FRAC_WORD_8 (R, 3),  \
>                        _FP_FRAC_WORD_8 (R, 2));                         \
> -      doit (_b_f1, _b_f0, X##_f[0], Y##_f[3]);                         \
> -      doit (_c_f1, _c_f0, X##_f[3], Y##_f[0]);                         \
> -      doit (_d_f1, _d_f0, X##_f[1], Y##_f[2]);                         \
> -      doit (_e_f1, _e_f0, X##_f[2], Y##_f[1]);                         \
> +      doit (_FP_MUL_MEAT_DW_4_wide_b_f1,                               \
> +           _FP_MUL_MEAT_DW_4_wide_b_f0, X##_f[0], Y##_f[3]);           \
> +      doit (_FP_MUL_MEAT_DW_4_wide_c_f1,                               \
> +           _FP_MUL_MEAT_DW_4_wide_c_f0, X##_f[3], Y##_f[0]);           \
> +      doit (_FP_MUL_MEAT_DW_4_wide_d_f1, _FP_MUL_MEAT_DW_4_wide_d_f0,  \
> +           X##_f[1], Y##_f[2]);                                        \
> +      doit (_FP_MUL_MEAT_DW_4_wide_e_f1, _FP_MUL_MEAT_DW_4_wide_e_f0,  \
> +           X##_f[2], Y##_f[1]);                                        \
>        __FP_FRAC_ADD_3 (_FP_FRAC_WORD_8 (R, 5), _FP_FRAC_WORD_8 (R, 4), \
> -                      _FP_FRAC_WORD_8 (R, 3), 0, _b_f1, _b_f0,         \
> +                      _FP_FRAC_WORD_8 (R, 3), 0,                       \
> +                      _FP_MUL_MEAT_DW_4_wide_b_f1,                     \
> +                      _FP_MUL_MEAT_DW_4_wide_b_f0,                     \
>                        0, _FP_FRAC_WORD_8 (R, 4), _FP_FRAC_WORD_8 (R, 3)); \
>        __FP_FRAC_ADD_3 (_FP_FRAC_WORD_8 (R, 5), _FP_FRAC_WORD_8 (R, 4), \
> -                      _FP_FRAC_WORD_8 (R, 3), 0, _c_f1, _c_f0,         \
> +                      _FP_FRAC_WORD_8 (R, 3), 0,                       \
> +                      _FP_MUL_MEAT_DW_4_wide_c_f1,                     \
> +                      _FP_MUL_MEAT_DW_4_wide_c_f0,                     \
>                        _FP_FRAC_WORD_8 (R, 5), _FP_FRAC_WORD_8 (R, 4),  \
>                        _FP_FRAC_WORD_8 (R, 3));                         \
>        __FP_FRAC_ADD_3 (_FP_FRAC_WORD_8 (R, 5), _FP_FRAC_WORD_8 (R, 4), \
> -                      _FP_FRAC_WORD_8 (R, 3), 0, _d_f1, _d_f0,         \
> +                      _FP_FRAC_WORD_8 (R, 3), 0,                       \
> +                      _FP_MUL_MEAT_DW_4_wide_d_f1,                     \
> +                      _FP_MUL_MEAT_DW_4_wide_d_f0,                     \
>                        _FP_FRAC_WORD_8 (R, 5), _FP_FRAC_WORD_8 (R, 4),  \
>                        _FP_FRAC_WORD_8 (R, 3));                         \
>        __FP_FRAC_ADD_3 (_FP_FRAC_WORD_8 (R, 5), _FP_FRAC_WORD_8 (R, 4), \
> -                      _FP_FRAC_WORD_8 (R, 3), 0, _e_f1, _e_f0,         \
> +                      _FP_FRAC_WORD_8 (R, 3), 0,                       \
> +                      _FP_MUL_MEAT_DW_4_wide_e_f1,                     \
> +                      _FP_MUL_MEAT_DW_4_wide_e_f0,                     \
>                        _FP_FRAC_WORD_8 (R, 5), _FP_FRAC_WORD_8 (R, 4),  \
>                        _FP_FRAC_WORD_8 (R, 3));                         \
> -      doit (_b_f1, _b_f0, X##_f[2], Y##_f[2]);                         \
> -      doit (_c_f1, _c_f0, X##_f[1], Y##_f[3]);                         \
> -      doit (_d_f1, _d_f0, X##_f[3], Y##_f[1]);                         \
> -      doit (_e_f1, _e_f0, X##_f[2], Y##_f[3]);                         \
> -      doit (_f_f1, _f_f0, X##_f[3], Y##_f[2]);                         \
> +      doit (_FP_MUL_MEAT_DW_4_wide_b_f1, _FP_MUL_MEAT_DW_4_wide_b_f0,  \
> +           X##_f[2], Y##_f[2]);                                        \
> +      doit (_FP_MUL_MEAT_DW_4_wide_c_f1, _FP_MUL_MEAT_DW_4_wide_c_f0,  \
> +           X##_f[1], Y##_f[3]);                                        \
> +      doit (_FP_MUL_MEAT_DW_4_wide_d_f1, _FP_MUL_MEAT_DW_4_wide_d_f0,  \
> +           X##_f[3], Y##_f[1]);                                        \
> +      doit (_FP_MUL_MEAT_DW_4_wide_e_f1, _FP_MUL_MEAT_DW_4_wide_e_f0,  \
> +           X##_f[2], Y##_f[3]);                                        \
> +      doit (_FP_MUL_MEAT_DW_4_wide_f_f1, _FP_MUL_MEAT_DW_4_wide_f_f0,  \
> +           X##_f[3], Y##_f[2]);                                        \
>        __FP_FRAC_ADD_3 (_FP_FRAC_WORD_8 (R, 6), _FP_FRAC_WORD_8 (R, 5), \
> -                      _FP_FRAC_WORD_8 (R, 4), 0, _b_f1, _b_f0,         \
> +                      _FP_FRAC_WORD_8 (R, 4), 0,                       \
> +                      _FP_MUL_MEAT_DW_4_wide_b_f1,                     \
> +                      _FP_MUL_MEAT_DW_4_wide_b_f0,                     \
>                        0, _FP_FRAC_WORD_8 (R, 5), _FP_FRAC_WORD_8 (R, 4)); \
>        __FP_FRAC_ADD_3 (_FP_FRAC_WORD_8 (R, 6), _FP_FRAC_WORD_8 (R, 5), \
> -                      _FP_FRAC_WORD_8 (R, 4), 0, _c_f1, _c_f0,         \
> +                      _FP_FRAC_WORD_8 (R, 4), 0,                       \
> +                      _FP_MUL_MEAT_DW_4_wide_c_f1,                     \
> +                      _FP_MUL_MEAT_DW_4_wide_c_f0,                     \
>                        _FP_FRAC_WORD_8 (R, 6), _FP_FRAC_WORD_8 (R, 5),  \
>                        _FP_FRAC_WORD_8 (R, 4));                         \
>        __FP_FRAC_ADD_3 (_FP_FRAC_WORD_8 (R, 6), _FP_FRAC_WORD_8 (R, 5), \
> -                      _FP_FRAC_WORD_8 (R, 4), 0, _d_f1, _d_f0,         \
> +                      _FP_FRAC_WORD_8 (R, 4), 0,                       \
> +                      _FP_MUL_MEAT_DW_4_wide_d_f1,                     \
> +                      _FP_MUL_MEAT_DW_4_wide_d_f0,                     \
>                        _FP_FRAC_WORD_8 (R, 6), _FP_FRAC_WORD_8 (R, 5),  \
>                        _FP_FRAC_WORD_8 (R, 4));                         \
>        __FP_FRAC_ADD_3 (_FP_FRAC_WORD_8 (R, 7), _FP_FRAC_WORD_8 (R, 6), \
> -                      _FP_FRAC_WORD_8 (R, 5), 0, _e_f1, _e_f0,         \
> +                      _FP_FRAC_WORD_8 (R, 5), 0,                       \
> +                      _FP_MUL_MEAT_DW_4_wide_e_f1,                     \
> +                      _FP_MUL_MEAT_DW_4_wide_e_f0,                     \
>                        0, _FP_FRAC_WORD_8 (R, 6), _FP_FRAC_WORD_8 (R, 5)); \
>        __FP_FRAC_ADD_3 (_FP_FRAC_WORD_8 (R, 7), _FP_FRAC_WORD_8 (R, 6), \
> -                      _FP_FRAC_WORD_8 (R, 5), 0, _f_f1, _f_f0,         \
> +                      _FP_FRAC_WORD_8 (R, 5), 0,                       \
> +                      _FP_MUL_MEAT_DW_4_wide_f_f1,                     \
> +                      _FP_MUL_MEAT_DW_4_wide_f_f0,                     \
>                        _FP_FRAC_WORD_8 (R, 7), _FP_FRAC_WORD_8 (R, 6),  \
>                        _FP_FRAC_WORD_8 (R, 5));                         \
> -      doit (_b_f1, _b_f0, X##_f[3], Y##_f[3]);                         \
> +      doit (_FP_MUL_MEAT_DW_4_wide_b_f1, _FP_MUL_MEAT_DW_4_wide_b_f0,  \
> +           X##_f[3], Y##_f[3]);                                        \
>        __FP_FRAC_ADD_2 (_FP_FRAC_WORD_8 (R, 7), _FP_FRAC_WORD_8 (R, 6), \
> -                      _b_f1, _b_f0,                                    \
> +                      _FP_MUL_MEAT_DW_4_wide_b_f1,                     \
> +                      _FP_MUL_MEAT_DW_4_wide_b_f0,                     \
>                        _FP_FRAC_WORD_8 (R, 7), _FP_FRAC_WORD_8 (R, 6)); \
>      }                                                                  \
>    while (0)
> @@ -348,16 +426,19 @@
>  #define _FP_MUL_MEAT_4_wide(wfracbits, R, X, Y, doit)                  \
>    do                                                                   \
>      {                                                                  \
> -      _FP_FRAC_DECL_8 (_z);                                            \
> +      _FP_FRAC_DECL_8 (_FP_MUL_MEAT_4_wide_z);                         \
>                                                                         \
> -      _FP_MUL_MEAT_DW_4_wide (wfracbits, _z, X, Y, doit);              \
> +      _FP_MUL_MEAT_DW_4_wide (wfracbits, _FP_MUL_MEAT_4_wide_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_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)); \
> +      _FP_FRAC_SRS_8 (_FP_MUL_MEAT_4_wide_z, wfracbits-1, 2*wfracbits);        \
> +      __FP_FRAC_SET_4 (R, _FP_FRAC_WORD_8 (_FP_MUL_MEAT_4_wide_z, 3),  \
> +                      _FP_FRAC_WORD_8 (_FP_MUL_MEAT_4_wide_z, 2),      \
> +                      _FP_FRAC_WORD_8 (_FP_MUL_MEAT_4_wide_z, 1),      \
> +                      _FP_FRAC_WORD_8 (_FP_MUL_MEAT_4_wide_z, 0));     \
>      }                                                                  \
>    while (0)
>
> @@ -371,16 +452,18 @@
>  #define _FP_MUL_MEAT_4_gmp(wfracbits, R, X, Y)                         \
>    do                                                                   \
>      {                                                                  \
> -      _FP_FRAC_DECL_8 (_z);                                            \
> +      _FP_FRAC_DECL_8 (_FP_MUL_MEAT_4_gmp_z);                          \
>                                                                         \
> -      _FP_MUL_MEAT_DW_4_gmp (wfracbits, _z, X, Y);                     \
> +      _FP_MUL_MEAT_DW_4_gmp (wfracbits, _FP_MUL_MEAT_4_gmp_z, 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_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)); \
> +      _FP_FRAC_SRS_8 (_FP_MUL_MEAT_4_gmp_z, wfracbits-1, 2*wfracbits); \
> +      __FP_FRAC_SET_4 (R, _FP_FRAC_WORD_8 (_FP_MUL_MEAT_4_gmp_z, 3),   \
> +                      _FP_FRAC_WORD_8 (_FP_MUL_MEAT_4_gmp_z, 2),       \
> +                      _FP_FRAC_WORD_8 (_FP_MUL_MEAT_4_gmp_z, 1),       \
> +                      _FP_FRAC_WORD_8 (_FP_MUL_MEAT_4_gmp_z, 0));      \
>      }                                                                  \
>    while (0)
>
> @@ -391,12 +474,12 @@
>  #define umul_ppppmnnn(p3, p2, p1, p0, m, n2, n1, n0)   \
>    do                                                   \
>      {                                                  \
> -      UWtype _t;                                       \
> +      UWtype umul_ppppmnnn_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);                   \
> +      umul_ppmm (p2, umul_ppppmnnn_t, m, n1);          \
> +      __FP_FRAC_ADDI_2 (p2, p1, umul_ppppmnnn_t);      \
> +      umul_ppmm (p3, umul_ppppmnnn_t, m, n2);          \
> +      __FP_FRAC_ADDI_2 (p3, p2, umul_ppppmnnn_t);      \
>      }                                                  \
>    while (0)
>
> @@ -407,13 +490,14 @@
>  #define _FP_DIV_MEAT_4_udiv(fs, R, X, Y)                               \
>    do                                                                   \
>      {                                                                  \
> -      int _i;                                                          \
> -      _FP_FRAC_DECL_4 (_n);                                            \
> -      _FP_FRAC_DECL_4 (_m);                                            \
> -      _FP_FRAC_SET_4 (_n, _FP_ZEROFRAC_4);                             \
> +      int _FP_DIV_MEAT_4_udiv_i;                                       \
> +      _FP_FRAC_DECL_4 (_FP_DIV_MEAT_4_udiv_n);                         \
> +      _FP_FRAC_DECL_4 (_FP_DIV_MEAT_4_udiv_m);                         \
> +      _FP_FRAC_SET_4 (_FP_DIV_MEAT_4_udiv_n, _FP_ZEROFRAC_4);          \
>        if (_FP_FRAC_GE_4 (X, Y))                                                \
>         {                                                               \
> -         _n_f[3] = X##_f[0] << (_FP_W_TYPE_SIZE - 1);                  \
> +         _FP_DIV_MEAT_4_udiv_n_f[3]                                    \
> +           = X##_f[0] << (_FP_W_TYPE_SIZE - 1);                        \
>           _FP_FRAC_SRL_4 (X, 1);                                        \
>         }                                                               \
>        else                                                             \
> @@ -423,49 +507,58 @@
>          denominator set. */                                            \
>        _FP_FRAC_SLL_4 (Y, _FP_WFRACXBITS_##fs);                         \
>                                                                         \
> -      for (_i = 3; ; _i--)                                             \
> +      for (_FP_DIV_MEAT_4_udiv_i = 3; ; _FP_DIV_MEAT_4_udiv_i--)       \
>         {                                                               \
>           if (X##_f[3] == Y##_f[3])                                     \
>             {                                                           \
>               /* This is a special case, not an optimization            \
>                  (X##_f[3]/Y##_f[3] would not fit into UWtype).         \
> -                As X## is guaranteed to be < Y,  R##_f[_i] can be either \
> +                As X## is guaranteed to be < Y,                        \
> +                R##_f[_FP_DIV_MEAT_4_udiv_i] can be either             \
>                  (UWtype)-1 or (UWtype)-2.  */                          \
> -             R##_f[_i] = -1;                                           \
> -             if (!_i)                                                  \
> +             R##_f[_FP_DIV_MEAT_4_udiv_i] = -1;                        \
> +             if (!_FP_DIV_MEAT_4_udiv_i)                               \
>                 break;                                                  \
>               __FP_FRAC_SUB_4 (X##_f[3], X##_f[2], X##_f[1], X##_f[0],  \
>                                Y##_f[2], Y##_f[1], Y##_f[0], 0,         \
> -                              X##_f[2], X##_f[1], X##_f[0], _n_f[_i]); \
> +                              X##_f[2], X##_f[1], X##_f[0],            \
> +                              _FP_DIV_MEAT_4_udiv_n_f[_FP_DIV_MEAT_4_udiv_i]); \
>               _FP_FRAC_SUB_4 (X, Y, X);                                 \
>               if (X##_f[3] > Y##_f[3])                                  \
>                 {                                                       \
> -                 R##_f[_i] = -2;                                       \
> +                 R##_f[_FP_DIV_MEAT_4_udiv_i] = -2;                    \
>                   _FP_FRAC_ADD_4 (X, Y, X);                             \
>                 }                                                       \
>             }                                                           \
>           else                                                          \
>             {                                                           \
> -             udiv_qrnnd (R##_f[_i], X##_f[3], X##_f[3], X##_f[2], Y##_f[3]); \
> -             umul_ppppmnnn (_m_f[3], _m_f[2], _m_f[1], _m_f[0],        \
> -                            R##_f[_i], Y##_f[2], Y##_f[1], Y##_f[0]);  \
> +             udiv_qrnnd (R##_f[_FP_DIV_MEAT_4_udiv_i],                 \
> +                         X##_f[3], X##_f[3], X##_f[2], Y##_f[3]);      \
> +             umul_ppppmnnn (_FP_DIV_MEAT_4_udiv_m_f[3],                \
> +                            _FP_DIV_MEAT_4_udiv_m_f[2],                \
> +                            _FP_DIV_MEAT_4_udiv_m_f[1],                \
> +                            _FP_DIV_MEAT_4_udiv_m_f[0],                \
> +                            R##_f[_FP_DIV_MEAT_4_udiv_i],              \
> +                            Y##_f[2], Y##_f[1], Y##_f[0]);             \
>               X##_f[2] = X##_f[1];                                      \
>               X##_f[1] = X##_f[0];                                      \
> -             X##_f[0] = _n_f[_i];                                      \
> -             if (_FP_FRAC_GT_4 (_m, X))                                \
> +             X##_f[0]                                                  \
> +               = _FP_DIV_MEAT_4_udiv_n_f[_FP_DIV_MEAT_4_udiv_i];       \
> +             if (_FP_FRAC_GT_4 (_FP_DIV_MEAT_4_udiv_m, X))             \
>                 {                                                       \
> -                 R##_f[_i]--;                                          \
> +                 R##_f[_FP_DIV_MEAT_4_udiv_i]--;                       \
>                   _FP_FRAC_ADD_4 (X, Y, X);                             \
> -                 if (_FP_FRAC_GE_4 (X, Y) && _FP_FRAC_GT_4 (_m, X))    \
> +                 if (_FP_FRAC_GE_4 (X, Y)                              \
> +                     && _FP_FRAC_GT_4 (_FP_DIV_MEAT_4_udiv_m, X))      \
>                     {                                                   \
> -                     R##_f[_i]--;                                      \
> +                     R##_f[_FP_DIV_MEAT_4_udiv_i]--;                   \
>                       _FP_FRAC_ADD_4 (X, Y, X);                         \
>                     }                                                   \
>                 }                                                       \
> -             _FP_FRAC_DEC_4 (X, _m);                                   \
> -             if (!_i)                                                  \
> +             _FP_FRAC_DEC_4 (X, _FP_DIV_MEAT_4_udiv_m);                \
> +             if (!_FP_DIV_MEAT_4_udiv_i)                               \
>                 {                                                       \
> -                 if (!_FP_FRAC_EQ_4 (X, _m))                           \
> +                 if (!_FP_FRAC_EQ_4 (X, _FP_DIV_MEAT_4_udiv_m))        \
>                     R##_f[0] |= _FP_WORK_STICKY;                        \
>                   break;                                                \
>                 }                                                       \
> @@ -591,18 +684,19 @@
>  # define __FP_FRAC_ADD_4(r3, r2, r1, r0, x3, x2, x1, x0, y3, y2, y1, y0) \
>    do                                                                   \
>      {                                                                  \
> -      _FP_W_TYPE _c1, _c2, _c3;                                                \
> +      _FP_W_TYPE __FP_FRAC_ADD_4_c1, __FP_FRAC_ADD_4_c2;               \
> +      _FP_W_TYPE __FP_FRAC_ADD_4_c3;                                   \
>        r0 = x0 + y0;                                                    \
> -      _c1 = r0 < x0;                                                   \
> +      __FP_FRAC_ADD_4_c1 = r0 < x0;                                    \
>        r1 = x1 + y1;                                                    \
> -      _c2 = r1 < x1;                                                   \
> -      r1 += _c1;                                                       \
> -      _c2 |= r1 < _c1;                                                 \
> +      __FP_FRAC_ADD_4_c2 = r1 < x1;                                    \
> +      r1 += __FP_FRAC_ADD_4_c1;                                                \
> +      __FP_FRAC_ADD_4_c2 |= r1 < __FP_FRAC_ADD_4_c1;                   \
>        r2 = x2 + y2;                                                    \
> -      _c3 = r2 < x2;                                                   \
> -      r2 += _c2;                                                       \
> -      _c3 |= r2 < _c2;                                                 \
> -      r3 = x3 + y3 + _c3;                                              \
> +      __FP_FRAC_ADD_4_c3 = r2 < x2;                                    \
> +      r2 += __FP_FRAC_ADD_4_c2;                                                \
> +      __FP_FRAC_ADD_4_c3 |= r2 < __FP_FRAC_ADD_4_c2;                   \
> +      r3 = x3 + y3 + __FP_FRAC_ADD_4_c3;                               \
>      }                                                                  \
>    while (0)
>  #endif
> @@ -611,14 +705,14 @@
>  # define __FP_FRAC_SUB_3(r2, r1, r0, x2, x1, x0, y2, y1, y0)   \
>    do                                                           \
>      {                                                          \
> -      _FP_W_TYPE _c1, _c2;                                     \
> +      _FP_W_TYPE __FP_FRAC_SUB_3_c1, __FP_FRAC_SUB_3_c2;       \
>        r0 = x0 - y0;                                            \
> -      _c1 = r0 > x0;                                           \
> +      __FP_FRAC_SUB_3_c1 = r0 > x0;                            \
>        r1 = x1 - y1;                                            \
> -      _c2 = r1 > x1;                                           \
> -      r1 -= _c1;                                               \
> -      _c2 |= _c1 && (y1 == x1);                                        \
> -      r2 = x2 - y2 - _c2;                                      \
> +      __FP_FRAC_SUB_3_c2 = r1 > x1;                            \
> +      r1 -= __FP_FRAC_SUB_3_c1;                                        \
> +      __FP_FRAC_SUB_3_c2 |= __FP_FRAC_SUB_3_c1 && (y1 == x1);  \
> +      r2 = x2 - y2 - __FP_FRAC_SUB_3_c2;                       \
>      }                                                          \
>    while (0)
>  #endif
> @@ -627,18 +721,19 @@
>  # define __FP_FRAC_SUB_4(r3, r2, r1, r0, x3, x2, x1, x0, y3, y2, y1, y0) \
>    do                                                                   \
>      {                                                                  \
> -      _FP_W_TYPE _c1, _c2, _c3;                                                \
> +      _FP_W_TYPE __FP_FRAC_SUB_4_c1, __FP_FRAC_SUB_4_c2;               \
> +      _FP_W_TYPE __FP_FRAC_SUB_4_c3;                                   \
>        r0 = x0 - y0;                                                    \
> -      _c1 = r0 > x0;                                                   \
> +      __FP_FRAC_SUB_4_c1 = r0 > x0;                                    \
>        r1 = x1 - y1;                                                    \
> -      _c2 = r1 > x1;                                                   \
> -      r1 -= _c1;                                                       \
> -      _c2 |= _c1 && (y1 == x1);                                                \
> +      __FP_FRAC_SUB_4_c2 = r1 > x1;                                    \
> +      r1 -= __FP_FRAC_SUB_4_c1;                                                \
> +      __FP_FRAC_SUB_4_c2 |= __FP_FRAC_SUB_4_c1 && (y1 == x1);          \
>        r2 = x2 - y2;                                                    \
> -      _c3 = r2 > x2;                                                   \
> -      r2 -= _c2;                                                       \
> -      _c3 |= _c2 && (y2 == x2);                                                \
> -      r3 = x3 - y3 - _c3;                                              \
> +      __FP_FRAC_SUB_4_c3 = r2 > x2;                                    \
> +      r2 -= __FP_FRAC_SUB_4_c2;                                                \
> +      __FP_FRAC_SUB_4_c3 |= __FP_FRAC_SUB_4_c2 && (y2 == x2);          \
> +      r3 = x3 - y3 - __FP_FRAC_SUB_4_c3;                               \
>      }                                                                  \
>    while (0)
>  #endif
> @@ -647,36 +742,47 @@
>  # define __FP_FRAC_DEC_3(x2, x1, x0, y2, y1, y0)               \
>    do                                                           \
>      {                                                          \
> -      UWtype _t0, _t1, _t2;                                    \
> -      _t0 = x0, _t1 = x1, _t2 = x2;                            \
> -      __FP_FRAC_SUB_3 (x2, x1, x0, _t2, _t1, _t0, y2, y1, y0); \
> +      UWtype __FP_FRAC_DEC_3_t0, __FP_FRAC_DEC_3_t1;           \
> +      UWtype __FP_FRAC_DEC_3_t2;                               \
> +      __FP_FRAC_DEC_3_t0 = x0;                                 \
> +      __FP_FRAC_DEC_3_t1 = x1;                                 \
> +      __FP_FRAC_DEC_3_t2 = x2;                                 \
> +      __FP_FRAC_SUB_3 (x2, x1, x0, __FP_FRAC_DEC_3_t2,         \
> +                      __FP_FRAC_DEC_3_t1, __FP_FRAC_DEC_3_t0,  \
> +                      y2, y1, y0);                             \
>      }                                                          \
>    while (0)
>  #endif
>
>  #ifndef __FP_FRAC_DEC_4
> -# define __FP_FRAC_DEC_4(x3, x2, x1, x0, y3, y2, y1, y0)               \
> -  do                                                                   \
> -    {                                                                  \
> -      UWtype _t0, _t1, _t2, _t3;                                       \
> -      _t0 = x0, _t1 = x1, _t2 = x2, _t3 = x3;                          \
> -      __FP_FRAC_SUB_4 (x3, x2, x1, x0, _t3, _t2, _t1, _t0, y3, y2, y1, y0); \
> -    }                                                                  \
> +# define __FP_FRAC_DEC_4(x3, x2, x1, x0, y3, y2, y1, y0)       \
> +  do                                                           \
> +    {                                                          \
> +      UWtype __FP_FRAC_DEC_4_t0, __FP_FRAC_DEC_4_t1;           \
> +      UWtype __FP_FRAC_DEC_4_t2, __FP_FRAC_DEC_4_t3;           \
> +      __FP_FRAC_DEC_4_t0 = x0;                                 \
> +      __FP_FRAC_DEC_4_t1 = x1;                                 \
> +      __FP_FRAC_DEC_4_t2 = x2;                                 \
> +      __FP_FRAC_DEC_4_t3 = x3;                                 \
> +      __FP_FRAC_SUB_4 (x3, x2, x1, x0, __FP_FRAC_DEC_4_t3,     \
> +                      __FP_FRAC_DEC_4_t2, __FP_FRAC_DEC_4_t1,  \
> +                      __FP_FRAC_DEC_4_t0, y3, y2, y1, y0);     \
> +    }                                                          \
>    while (0)
>  #endif
>
>  #ifndef __FP_FRAC_ADDI_4
> -# define __FP_FRAC_ADDI_4(x3, x2, x1, x0, i)   \
> -  do                                           \
> -    {                                          \
> -      UWtype _t;                               \
> -      _t = ((x0 += i) < i);                    \
> -      x1 += _t;                                        \
> -      _t = (x1 < _t);                          \
> -      x2 += _t;                                        \
> -      _t = (x2 < _t);                          \
> -      x3 += _t;                                        \
> -    }                                          \
> +# define __FP_FRAC_ADDI_4(x3, x2, x1, x0, i)           \
> +  do                                                   \
> +    {                                                  \
> +      UWtype __FP_FRAC_ADDI_4_t;                       \
> +      __FP_FRAC_ADDI_4_t = ((x0 += i) < i);            \
> +      x1 += __FP_FRAC_ADDI_4_t;                                \
> +      __FP_FRAC_ADDI_4_t = (x1 < __FP_FRAC_ADDI_4_t);  \
> +      x2 += __FP_FRAC_ADDI_4_t;                                \
> +      __FP_FRAC_ADDI_4_t = (x2 < __FP_FRAC_ADDI_4_t);  \
> +      x3 += __FP_FRAC_ADDI_4_t;                                \
> +    }                                                  \
>    while (0)
>  #endif
>
> diff --git a/soft-fp/op-8.h b/soft-fp/op-8.h
> index a50cd7b..c966ee2 100644
> --- a/soft-fp/op-8.h
> +++ b/soft-fp/op-8.h
> @@ -36,48 +36,66 @@
>  #define _FP_FRAC_LOW_8(X)      (X##_f[0])
>  #define _FP_FRAC_WORD_8(X, w)  (X##_f[w])
>
> -#define _FP_FRAC_SLL_8(X, N)                           \
> -  do                                                   \
> -    {                                                  \
> -      _FP_I_TYPE _up, _down, _skip, _i;                        \
> -      _skip = (N) / _FP_W_TYPE_SIZE;                   \
> -      _up = (N) % _FP_W_TYPE_SIZE;                     \
> -      _down = _FP_W_TYPE_SIZE - _up;                   \
> -      if (!_up)                                                \
> -       for (_i = 7; _i >= _skip; --_i)                 \
> -         X##_f[_i] = X##_f[_i-_skip];                  \
> -      else                                             \
> -       {                                               \
> -         for (_i = 7; _i > _skip; --_i)                \
> -           X##_f[_i] = (X##_f[_i-_skip] << _up         \
> -                        | X##_f[_i-_skip-1] >> _down); \
> -         X##_f[_i--] = X##_f[0] << _up;                \
> -       }                                               \
> -      for (; _i >= 0; --_i)                            \
> -       X##_f[_i] = 0;                                  \
> -    }                                                  \
> +#define _FP_FRAC_SLL_8(X, N)                                           \
> +  do                                                                   \
> +    {                                                                  \
> +      _FP_I_TYPE _FP_FRAC_SLL_8_up, _FP_FRAC_SLL_8_down;               \
> +      _FP_I_TYPE _FP_FRAC_SLL_8_skip, _FP_FRAC_SLL_8_i;                        \
> +      _FP_FRAC_SLL_8_skip = (N) / _FP_W_TYPE_SIZE;                     \
> +      _FP_FRAC_SLL_8_up = (N) % _FP_W_TYPE_SIZE;                       \
> +      _FP_FRAC_SLL_8_down = _FP_W_TYPE_SIZE - _FP_FRAC_SLL_8_up;       \
> +      if (!_FP_FRAC_SLL_8_up)                                          \
> +       for (_FP_FRAC_SLL_8_i = 7;                                      \
> +            _FP_FRAC_SLL_8_i >= _FP_FRAC_SLL_8_skip;                   \
> +            --_FP_FRAC_SLL_8_i)                                        \
> +         X##_f[_FP_FRAC_SLL_8_i]                                       \
> +           = X##_f[_FP_FRAC_SLL_8_i-_FP_FRAC_SLL_8_skip];              \
> +      else                                                             \
> +       {                                                               \
> +         for (_FP_FRAC_SLL_8_i = 7;                                    \
> +              _FP_FRAC_SLL_8_i > _FP_FRAC_SLL_8_skip;                  \
> +              --_FP_FRAC_SLL_8_i)                                      \
> +           X##_f[_FP_FRAC_SLL_8_i]                                     \
> +             = ((X##_f[_FP_FRAC_SLL_8_i-_FP_FRAC_SLL_8_skip]           \
> +                 << _FP_FRAC_SLL_8_up)                                 \
> +                | (X##_f[_FP_FRAC_SLL_8_i-_FP_FRAC_SLL_8_skip-1]       \
> +                   >> _FP_FRAC_SLL_8_down));                           \
> +         X##_f[_FP_FRAC_SLL_8_i--] = X##_f[0] << _FP_FRAC_SLL_8_up;    \
> +       }                                                               \
> +      for (; _FP_FRAC_SLL_8_i >= 0; --_FP_FRAC_SLL_8_i)                        \
> +       X##_f[_FP_FRAC_SLL_8_i] = 0;                                    \
> +    }                                                                  \
>    while (0)
>
> -#define _FP_FRAC_SRL_8(X, N)                           \
> -  do                                                   \
> -    {                                                  \
> -      _FP_I_TYPE _up, _down, _skip, _i;                        \
> -      _skip = (N) / _FP_W_TYPE_SIZE;                   \
> -      _down = (N) % _FP_W_TYPE_SIZE;                   \
> -      _up = _FP_W_TYPE_SIZE - _down;                   \
> -      if (!_down)                                      \
> -       for (_i = 0; _i <= 7-_skip; ++_i)               \
> -         X##_f[_i] = X##_f[_i+_skip];                  \
> -      else                                             \
> -       {                                               \
> -         for (_i = 0; _i < 7-_skip; ++_i)              \
> -           X##_f[_i] = (X##_f[_i+_skip] >> _down       \
> -                        | X##_f[_i+_skip+1] << _up);   \
> -         X##_f[_i++] = X##_f[7] >> _down;              \
> -       }                                               \
> -      for (; _i < 8; ++_i)                             \
> -       X##_f[_i] = 0;                                  \
> -    }                                                  \
> +#define _FP_FRAC_SRL_8(X, N)                                           \
> +  do                                                                   \
> +    {                                                                  \
> +      _FP_I_TYPE _FP_FRAC_SRL_8_up, _FP_FRAC_SRL_8_down;               \
> +      _FP_I_TYPE _FP_FRAC_SRL_8_skip, _FP_FRAC_SRL_8_i;                        \
> +      _FP_FRAC_SRL_8_skip = (N) / _FP_W_TYPE_SIZE;                     \
> +      _FP_FRAC_SRL_8_down = (N) % _FP_W_TYPE_SIZE;                     \
> +      _FP_FRAC_SRL_8_up = _FP_W_TYPE_SIZE - _FP_FRAC_SRL_8_down;       \
> +      if (!_FP_FRAC_SRL_8_down)                                                \
> +       for (_FP_FRAC_SRL_8_i = 0;                                      \
> +            _FP_FRAC_SRL_8_i <= 7-_FP_FRAC_SRL_8_skip;                 \
> +            ++_FP_FRAC_SRL_8_i)                                        \
> +         X##_f[_FP_FRAC_SRL_8_i]                                       \
> +           = X##_f[_FP_FRAC_SRL_8_i+_FP_FRAC_SRL_8_skip];              \
> +      else                                                             \
> +       {                                                               \
> +         for (_FP_FRAC_SRL_8_i = 0;                                    \
> +              _FP_FRAC_SRL_8_i < 7-_FP_FRAC_SRL_8_skip;                \
> +              ++_FP_FRAC_SRL_8_i)                                      \
> +           X##_f[_FP_FRAC_SRL_8_i]                                     \
> +             = ((X##_f[_FP_FRAC_SRL_8_i+_FP_FRAC_SRL_8_skip]           \
> +                 >> _FP_FRAC_SRL_8_down)                               \
> +                | (X##_f[_FP_FRAC_SRL_8_i+_FP_FRAC_SRL_8_skip+1]       \
> +                   << _FP_FRAC_SRL_8_up));                             \
> +         X##_f[_FP_FRAC_SRL_8_i++] = X##_f[7] >> _FP_FRAC_SRL_8_down;  \
> +       }                                                               \
> +      for (; _FP_FRAC_SRL_8_i < 8; ++_FP_FRAC_SRL_8_i)                 \
> +       X##_f[_FP_FRAC_SRL_8_i] = 0;                                    \
> +    }                                                                  \
>    while (0)
>
>
> @@ -89,28 +107,40 @@
>  #define _FP_FRAC_SRS_8(X, N, size)                                     \
>    do                                                                   \
>      {                                                                  \
> -      _FP_I_TYPE _up, _down, _skip, _i;                                        \
> -      _FP_W_TYPE _s;                                                   \
> -      _skip = (N) / _FP_W_TYPE_SIZE;                                   \
> -      _down = (N) % _FP_W_TYPE_SIZE;                                   \
> -      _up = _FP_W_TYPE_SIZE - _down;                                   \
> -      for (_s = _i = 0; _i < _skip; ++_i)                              \
> -       _s |= X##_f[_i];                                                \
> -      if (!_down)                                                      \
> -       for (_i = 0; _i <= 7-_skip; ++_i)                               \
> -         X##_f[_i] = X##_f[_i+_skip];                                  \
> +      _FP_I_TYPE _FP_FRAC_SRS_8_up, _FP_FRAC_SRS_8_down;               \
> +      _FP_I_TYPE _FP_FRAC_SRS_8_skip, _FP_FRAC_SRS_8_i;                        \
> +      _FP_W_TYPE _FP_FRAC_SRS_8_s;                                     \
> +      _FP_FRAC_SRS_8_skip = (N) / _FP_W_TYPE_SIZE;                     \
> +      _FP_FRAC_SRS_8_down = (N) % _FP_W_TYPE_SIZE;                     \
> +      _FP_FRAC_SRS_8_up = _FP_W_TYPE_SIZE - _FP_FRAC_SRS_8_down;       \
> +      for (_FP_FRAC_SRS_8_s = _FP_FRAC_SRS_8_i = 0;                    \
> +          _FP_FRAC_SRS_8_i < _FP_FRAC_SRS_8_skip;                      \
> +          ++_FP_FRAC_SRS_8_i)                                          \
> +       _FP_FRAC_SRS_8_s |= X##_f[_FP_FRAC_SRS_8_i];                    \
> +      if (!_FP_FRAC_SRS_8_down)                                                \
> +       for (_FP_FRAC_SRS_8_i = 0;                                      \
> +            _FP_FRAC_SRS_8_i <= 7-_FP_FRAC_SRS_8_skip;                 \
> +            ++_FP_FRAC_SRS_8_i)                                        \
> +         X##_f[_FP_FRAC_SRS_8_i]                                       \
> +           = X##_f[_FP_FRAC_SRS_8_i+_FP_FRAC_SRS_8_skip];              \
>        else                                                             \
>         {                                                               \
> -         _s |= X##_f[_i] << _up;                                       \
> -         for (_i = 0; _i < 7-_skip; ++_i)                              \
> -           X##_f[_i] = (X##_f[_i+_skip] >> _down                       \
> -                        | X##_f[_i+_skip+1] << _up);                   \
> -         X##_f[_i++] = X##_f[7] >> _down;                              \
> +         _FP_FRAC_SRS_8_s                                              \
> +           |= X##_f[_FP_FRAC_SRS_8_i] << _FP_FRAC_SRS_8_up;            \
> +         for (_FP_FRAC_SRS_8_i = 0;                                    \
> +              _FP_FRAC_SRS_8_i < 7-_FP_FRAC_SRS_8_skip;                \
> +              ++_FP_FRAC_SRS_8_i)                                      \
> +           X##_f[_FP_FRAC_SRS_8_i]                                     \
> +             = ((X##_f[_FP_FRAC_SRS_8_i+_FP_FRAC_SRS_8_skip]           \
> +                 >> _FP_FRAC_SRS_8_down)                               \
> +                | (X##_f[_FP_FRAC_SRS_8_i+_FP_FRAC_SRS_8_skip+1]       \
> +                   << _FP_FRAC_SRS_8_up));                             \
> +         X##_f[_FP_FRAC_SRS_8_i++] = X##_f[7] >> _FP_FRAC_SRS_8_down;  \
>         }                                                               \
> -      for (; _i < 8; ++_i)                                             \
> -       X##_f[_i] = 0;                                                  \
> +      for (; _FP_FRAC_SRS_8_i < 8; ++_FP_FRAC_SRS_8_i)                 \
> +       X##_f[_FP_FRAC_SRS_8_i] = 0;                                    \
>        /* don't fix the LSB until the very end when we're sure f[0] is  \
>          stable */                                                      \
> -      X##_f[0] |= (_s != 0);                                           \
> +      X##_f[0] |= (_FP_FRAC_SRS_8_s != 0);                             \
>      }                                                                  \
>    while (0)
>
> --
> Joseph S. Myers
> joseph@codesourcery.com
diff mbox

Patch

diff --git a/soft-fp/op-1.h b/soft-fp/op-1.h
index 33682cf..3547e74 100644
--- a/soft-fp/op-1.h
+++ b/soft-fp/op-1.h
@@ -92,27 +92,28 @@ 
  * 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;			\
-    }						\
+#define _FP_UNPACK_RAW_1(fs, X, val)			\
+  do							\
+    {							\
+      union _FP_UNION_##fs _FP_UNPACK_RAW_1_flo;	\
+      _FP_UNPACK_RAW_1_flo.flt = (val);			\
+							\
+      X##_f = _FP_UNPACK_RAW_1_flo.bits.frac;		\
+      X##_e = _FP_UNPACK_RAW_1_flo.bits.exp;		\
+      X##_s = _FP_UNPACK_RAW_1_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;						\
-    }									\
+#define _FP_UNPACK_RAW_1_P(fs, X, val)			\
+  do							\
+    {							\
+      union _FP_UNION_##fs *_FP_UNPACK_RAW_1_P_flo	\
+	= (union _FP_UNION_##fs *) (val);		\
+							\
+      X##_f = _FP_UNPACK_RAW_1_P_flo->bits.frac;	\
+      X##_e = _FP_UNPACK_RAW_1_P_flo->bits.exp;		\
+      X##_s = _FP_UNPACK_RAW_1_P_flo->bits.sign;	\
+    }							\
   while (0)
 
 /*
@@ -122,25 +123,26 @@ 
 #define _FP_PACK_RAW_1(fs, val, X)		\
   do						\
     {						\
-      union _FP_UNION_##fs _flo;		\
+      union _FP_UNION_##fs _FP_PACK_RAW_1_flo;	\
 						\
-      _flo.bits.frac = X##_f;			\
-      _flo.bits.exp  = X##_e;			\
-      _flo.bits.sign = X##_s;			\
+      _FP_PACK_RAW_1_flo.bits.frac = X##_f;	\
+      _FP_PACK_RAW_1_flo.bits.exp  = X##_e;	\
+      _FP_PACK_RAW_1_flo.bits.sign = X##_s;	\
 						\
-      (val) = _flo.flt;				\
+      (val) = _FP_PACK_RAW_1_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;						\
-    }									\
+#define _FP_PACK_RAW_1_P(fs, val, X)			\
+  do							\
+    {							\
+      union _FP_UNION_##fs *_FP_PACK_RAW_1_P_flo	\
+	= (union _FP_UNION_##fs *) (val);		\
+							\
+      _FP_PACK_RAW_1_P_flo->bits.frac = X##_f;		\
+      _FP_PACK_RAW_1_P_flo->bits.exp  = X##_e;		\
+      _FP_PACK_RAW_1_P_flo->bits.sign = X##_s;		\
+    }							\
   while (0)
 
 
@@ -181,13 +183,14 @@ 
 #define _FP_MUL_MEAT_1_wide(wfracbits, R, X, Y, doit)			\
   do									\
     {									\
-      _FP_FRAC_DECL_2 (_Z);						\
-      _FP_MUL_MEAT_DW_1_wide (wfracbits, _Z, X, Y, doit);		\
+      _FP_FRAC_DECL_2 (_FP_MUL_MEAT_1_wide_Z);				\
+      _FP_MUL_MEAT_DW_1_wide (wfracbits, _FP_MUL_MEAT_1_wide_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;							\
+      _FP_FRAC_SRS_2 (_FP_MUL_MEAT_1_wide_Z, wfracbits-1, 2*wfracbits);	\
+      R##_f = _FP_MUL_MEAT_1_wide_Z_f0;					\
     }									\
   while (0)
 
@@ -196,40 +199,49 @@ 
 #define _FP_MUL_MEAT_DW_1_hard(wfracbits, R, X, Y)			\
   do									\
     {									\
-      _FP_W_TYPE _xh, _xl, _yh, _yl;					\
-      _FP_FRAC_DECL_2 (_a);						\
+      _FP_W_TYPE _FP_MUL_MEAT_DW_1_hard_xh, _FP_MUL_MEAT_DW_1_hard_xl;	\
+      _FP_W_TYPE _FP_MUL_MEAT_DW_1_hard_yh, _FP_MUL_MEAT_DW_1_hard_yl;	\
+      _FP_FRAC_DECL_2 (_FP_MUL_MEAT_DW_1_hard_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);	\
+      _FP_MUL_MEAT_DW_1_hard_xh = X##_f >> (_FP_W_TYPE_SIZE/2);		\
+      _FP_MUL_MEAT_DW_1_hard_xl						\
+	= X##_f & (((_FP_W_TYPE) 1 << (_FP_W_TYPE_SIZE/2)) - 1);	\
+      _FP_MUL_MEAT_DW_1_hard_yh = Y##_f >> (_FP_W_TYPE_SIZE/2);		\
+      _FP_MUL_MEAT_DW_1_hard_yl						\
+	= Y##_f & (((_FP_W_TYPE) 1 << (_FP_W_TYPE_SIZE/2)) - 1);	\
 									\
       /* multiply the pieces */						\
-      R##_f0 = _xl * _yl;						\
-      _a_f0 = _xh * _yl;						\
-      _a_f1 = _xl * _yh;						\
-      R##_f1 = _xh * _yh;						\
+      R##_f0 = _FP_MUL_MEAT_DW_1_hard_xl * _FP_MUL_MEAT_DW_1_hard_yl;	\
+      _FP_MUL_MEAT_DW_1_hard_a_f0					\
+	= _FP_MUL_MEAT_DW_1_hard_xh * _FP_MUL_MEAT_DW_1_hard_yl;	\
+      _FP_MUL_MEAT_DW_1_hard_a_f1					\
+	= _FP_MUL_MEAT_DW_1_hard_xl * _FP_MUL_MEAT_DW_1_hard_yh;	\
+      R##_f1 = _FP_MUL_MEAT_DW_1_hard_xh * _FP_MUL_MEAT_DW_1_hard_yh;	\
 									\
       /* reassemble into two full words */				\
-      if ((_a_f0 += _a_f1) < _a_f1)					\
+      if ((_FP_MUL_MEAT_DW_1_hard_a_f0 += _FP_MUL_MEAT_DW_1_hard_a_f1)	\
+	  < _FP_MUL_MEAT_DW_1_hard_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);					\
+      _FP_MUL_MEAT_DW_1_hard_a_f1					\
+	= _FP_MUL_MEAT_DW_1_hard_a_f0 >> (_FP_W_TYPE_SIZE/2);		\
+      _FP_MUL_MEAT_DW_1_hard_a_f0					\
+	= _FP_MUL_MEAT_DW_1_hard_a_f0 << (_FP_W_TYPE_SIZE/2);		\
+      _FP_FRAC_ADD_2 (R, R, _FP_MUL_MEAT_DW_1_hard_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;					\
-    }							\
+#define _FP_MUL_MEAT_1_hard(wfracbits, R, X, Y)				\
+  do									\
+    {									\
+      _FP_FRAC_DECL_2 (_FP_MUL_MEAT_1_hard_z);				\
+      _FP_MUL_MEAT_DW_1_hard (wfracbits, _FP_MUL_MEAT_1_hard_z, X, Y);	\
+									\
+      /* normalize */							\
+      _FP_FRAC_SRS_2 (_FP_MUL_MEAT_1_hard_z,				\
+		      wfracbits - 1, 2*wfracbits);			\
+      R##_f = _FP_MUL_MEAT_1_hard_z_f0;					\
+    }									\
   while (0)
 
 
@@ -242,16 +254,16 @@ 
    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);			\
-    }						\
+#define _FP_DIV_MEAT_1_imm(fs, R, X, Y, doit)				\
+  do									\
+    {									\
+      _FP_W_TYPE _FP_DIV_MEAT_1_imm_q, _FP_DIV_MEAT_1_imm_r;		\
+      X##_f <<= (X##_f < Y##_f						\
+		 ? R##_e--, _FP_WFRACBITS_##fs				\
+		 : _FP_WFRACBITS_##fs - 1);				\
+      doit (_FP_DIV_MEAT_1_imm_q, _FP_DIV_MEAT_1_imm_r, X##_f, Y##_f);	\
+      R##_f = _FP_DIV_MEAT_1_imm_q | (_FP_DIV_MEAT_1_imm_r != 0);	\
+    }									\
   while (0)
 
 /* GCC's longlong.h defines a 2W / 1W => (1W,1W) primitive udiv_qrnnd
@@ -262,47 +274,59 @@ 
 #define _FP_DIV_MEAT_1_udiv_norm(fs, R, X, Y)				\
   do									\
     {									\
-      _FP_W_TYPE _nh, _nl, _q, _r, _y;					\
+      _FP_W_TYPE _FP_DIV_MEAT_1_udiv_norm_nh;				\
+      _FP_W_TYPE _FP_DIV_MEAT_1_udiv_norm_nl;				\
+      _FP_W_TYPE _FP_DIV_MEAT_1_udiv_norm_q;				\
+      _FP_W_TYPE _FP_DIV_MEAT_1_udiv_norm_r;				\
+      _FP_W_TYPE _FP_DIV_MEAT_1_udiv_norm_y;				\
 									\
       /* Normalize Y -- i.e. make the most significant bit set.  */	\
-      _y = Y##_f << _FP_WFRACXBITS_##fs;				\
+      _FP_DIV_MEAT_1_udiv_norm_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;							\
+	  _FP_DIV_MEAT_1_udiv_norm_nl = 0;				\
+	  _FP_DIV_MEAT_1_udiv_norm_nh = X##_f;				\
 	}								\
       else								\
 	{								\
-	  _nl = X##_f << (_FP_W_TYPE_SIZE - 1);				\
-	  _nh = X##_f >> 1;						\
+	  _FP_DIV_MEAT_1_udiv_norm_nl = X##_f << (_FP_W_TYPE_SIZE - 1);	\
+	  _FP_DIV_MEAT_1_udiv_norm_nh = X##_f >> 1;			\
 	}								\
 									\
-      udiv_qrnnd (_q, _r, _nh, _nl, _y);				\
-      R##_f = _q | (_r != 0);						\
+      udiv_qrnnd (_FP_DIV_MEAT_1_udiv_norm_q,				\
+		  _FP_DIV_MEAT_1_udiv_norm_r,				\
+		  _FP_DIV_MEAT_1_udiv_norm_nh,				\
+		  _FP_DIV_MEAT_1_udiv_norm_nl,				\
+		  _FP_DIV_MEAT_1_udiv_norm_y);				\
+      R##_f = (_FP_DIV_MEAT_1_udiv_norm_q				\
+	       | (_FP_DIV_MEAT_1_udiv_norm_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);				\
-    }							\
+#define _FP_DIV_MEAT_1_udiv(fs, R, X, Y)				\
+  do									\
+    {									\
+      _FP_W_TYPE _FP_DIV_MEAT_1_udiv_nh, _FP_DIV_MEAT_1_udiv_nl;	\
+      _FP_W_TYPE _FP_DIV_MEAT_1_udiv_q, _FP_DIV_MEAT_1_udiv_r;		\
+      if (X##_f < Y##_f)						\
+	{								\
+	  R##_e--;							\
+	  _FP_DIV_MEAT_1_udiv_nl = X##_f << _FP_WFRACBITS_##fs;		\
+	  _FP_DIV_MEAT_1_udiv_nh = X##_f >> _FP_WFRACXBITS_##fs;	\
+	}								\
+      else								\
+	{								\
+	  _FP_DIV_MEAT_1_udiv_nl = X##_f << (_FP_WFRACBITS_##fs - 1);	\
+	  _FP_DIV_MEAT_1_udiv_nh = X##_f >> (_FP_WFRACXBITS_##fs + 1);	\
+	}								\
+      udiv_qrnnd (_FP_DIV_MEAT_1_udiv_q, _FP_DIV_MEAT_1_udiv_r,		\
+		  _FP_DIV_MEAT_1_udiv_nh, _FP_DIV_MEAT_1_udiv_nl,	\
+		  Y##_f);						\
+      R##_f = _FP_DIV_MEAT_1_udiv_q | (_FP_DIV_MEAT_1_udiv_r != 0);	\
+    }									\
   while (0)
 
 
diff --git a/soft-fp/op-2.h b/soft-fp/op-2.h
index 160990f..4ea2a00 100644
--- a/soft-fp/op-2.h
+++ b/soft-fp/op-2.h
@@ -182,12 +182,12 @@ 
   (rh = xh - yh - ((rl = xl - yl) > xl))
 # endif
 # ifndef __FP_FRAC_DEC_2
-#  define __FP_FRAC_DEC_2(xh, xl, yh, yl)	\
-  do						\
-    {						\
-      UWtype _t = xl;				\
-      xh -= yh + ((xl -= yl) > _t);		\
-    }						\
+#  define __FP_FRAC_DEC_2(xh, xl, yh, yl)		\
+  do							\
+    {							\
+      UWtype __FP_FRAC_DEC_2_t = xl;			\
+      xh -= yh + ((xl -= yl) > __FP_FRAC_DEC_2_t);	\
+    }							\
   while (0)
 # endif
 
@@ -210,29 +210,30 @@ 
  * normalize the data.
  */
 
-#define _FP_UNPACK_RAW_2(fs, X, val)		\
-  do						\
-    {						\
-      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;			\
-    }						\
+#define _FP_UNPACK_RAW_2(fs, X, val)			\
+  do							\
+    {							\
+      union _FP_UNION_##fs _FP_UNPACK_RAW_2_flo;	\
+      _FP_UNPACK_RAW_2_flo.flt = (val);			\
+							\
+      X##_f0 = _FP_UNPACK_RAW_2_flo.bits.frac0;		\
+      X##_f1 = _FP_UNPACK_RAW_2_flo.bits.frac1;		\
+      X##_e  = _FP_UNPACK_RAW_2_flo.bits.exp;		\
+      X##_s  = _FP_UNPACK_RAW_2_flo.bits.sign;		\
+    }							\
   while (0)
 
-#define _FP_UNPACK_RAW_2_P(fs, X, val)					\
-  do									\
-    {									\
-      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;						\
-    }									\
+#define _FP_UNPACK_RAW_2_P(fs, X, val)			\
+  do							\
+    {							\
+      union _FP_UNION_##fs *_FP_UNPACK_RAW_2_P_flo	\
+	= (union _FP_UNION_##fs *) (val);		\
+							\
+      X##_f0 = _FP_UNPACK_RAW_2_P_flo->bits.frac0;	\
+      X##_f1 = _FP_UNPACK_RAW_2_P_flo->bits.frac1;	\
+      X##_e  = _FP_UNPACK_RAW_2_P_flo->bits.exp;	\
+      X##_s  = _FP_UNPACK_RAW_2_P_flo->bits.sign;	\
+    }							\
   while (0)
 
 
@@ -243,27 +244,28 @@ 
 #define _FP_PACK_RAW_2(fs, val, X)		\
   do						\
     {						\
-      union _FP_UNION_##fs _flo;		\
+      union _FP_UNION_##fs _FP_PACK_RAW_2_flo;	\
 						\
-      _flo.bits.frac0 = X##_f0;			\
-      _flo.bits.frac1 = X##_f1;			\
-      _flo.bits.exp   = X##_e;			\
-      _flo.bits.sign  = X##_s;			\
+      _FP_PACK_RAW_2_flo.bits.frac0 = X##_f0;	\
+      _FP_PACK_RAW_2_flo.bits.frac1 = X##_f1;	\
+      _FP_PACK_RAW_2_flo.bits.exp   = X##_e;	\
+      _FP_PACK_RAW_2_flo.bits.sign  = X##_s;	\
 						\
-      (val) = _flo.flt;				\
+      (val) = _FP_PACK_RAW_2_flo.flt;		\
     }						\
   while (0)
 
-#define _FP_PACK_RAW_2_P(fs, val, X)					\
-  do									\
-    {									\
-      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;						\
-    }									\
+#define _FP_PACK_RAW_2_P(fs, val, X)			\
+  do							\
+    {							\
+      union _FP_UNION_##fs *_FP_PACK_RAW_2_P_flo	\
+	= (union _FP_UNION_##fs *) (val);		\
+							\
+      _FP_PACK_RAW_2_P_flo->bits.frac0 = X##_f0;	\
+      _FP_PACK_RAW_2_P_flo->bits.frac1 = X##_f1;	\
+      _FP_PACK_RAW_2_P_flo->bits.exp   = X##_e;		\
+      _FP_PACK_RAW_2_P_flo->bits.sign  = X##_s;		\
+    }							\
   while (0)
 
 
@@ -276,20 +278,28 @@ 
 #define _FP_MUL_MEAT_DW_2_wide(wfracbits, R, X, Y, doit)		\
   do									\
     {									\
-      _FP_FRAC_DECL_2 (_b);						\
-      _FP_FRAC_DECL_2 (_c);						\
+      _FP_FRAC_DECL_2 (_FP_MUL_MEAT_DW_2_wide_b);			\
+      _FP_FRAC_DECL_2 (_FP_MUL_MEAT_DW_2_wide_c);			\
 									\
-      doit (_FP_FRAC_WORD_4 (R, 1), _FP_FRAC_WORD_4 (R, 0), X##_f0, Y##_f0); \
-      doit (_b_f1, _b_f0, X##_f0, Y##_f1);				\
-      doit (_c_f1, _c_f0, X##_f1, Y##_f0);				\
-      doit (_FP_FRAC_WORD_4 (R, 3), _FP_FRAC_WORD_4 (R, 2), X##_f1, Y##_f1); \
+      doit (_FP_FRAC_WORD_4 (R, 1), _FP_FRAC_WORD_4 (R, 0),		\
+	    X##_f0, Y##_f0);						\
+      doit (_FP_MUL_MEAT_DW_2_wide_b_f1, _FP_MUL_MEAT_DW_2_wide_b_f0,	\
+	    X##_f0, Y##_f1);						\
+      doit (_FP_MUL_MEAT_DW_2_wide_c_f1, _FP_MUL_MEAT_DW_2_wide_c_f0,	\
+	    X##_f1, Y##_f0);						\
+      doit (_FP_FRAC_WORD_4 (R, 3), _FP_FRAC_WORD_4 (R, 2),		\
+	    X##_f1, Y##_f1);						\
 									\
       __FP_FRAC_ADD_3 (_FP_FRAC_WORD_4 (R, 3), _FP_FRAC_WORD_4 (R, 2),	\
-		       _FP_FRAC_WORD_4 (R, 1), 0, _b_f1, _b_f0,		\
+		       _FP_FRAC_WORD_4 (R, 1), 0,			\
+		       _FP_MUL_MEAT_DW_2_wide_b_f1,			\
+		       _FP_MUL_MEAT_DW_2_wide_b_f0,			\
 		       _FP_FRAC_WORD_4 (R, 3), _FP_FRAC_WORD_4 (R, 2),	\
 		       _FP_FRAC_WORD_4 (R, 1));				\
       __FP_FRAC_ADD_3 (_FP_FRAC_WORD_4 (R, 3), _FP_FRAC_WORD_4 (R, 2),	\
-		       _FP_FRAC_WORD_4 (R, 1), 0, _c_f1, _c_f0,		\
+		       _FP_FRAC_WORD_4 (R, 1), 0,			\
+		       _FP_MUL_MEAT_DW_2_wide_c_f1,			\
+		       _FP_MUL_MEAT_DW_2_wide_c_f0,			\
 		       _FP_FRAC_WORD_4 (R, 3), _FP_FRAC_WORD_4 (R, 2),	\
 		       _FP_FRAC_WORD_4 (R, 1));				\
     }									\
@@ -298,16 +308,17 @@ 
 #define _FP_MUL_MEAT_2_wide(wfracbits, R, X, Y, doit)			\
   do									\
     {									\
-      _FP_FRAC_DECL_4 (_z);						\
+      _FP_FRAC_DECL_4 (_FP_MUL_MEAT_2_wide_z);				\
 									\
-      _FP_MUL_MEAT_DW_2_wide (wfracbits, _z, X, Y, doit);		\
+      _FP_MUL_MEAT_DW_2_wide (wfracbits, _FP_MUL_MEAT_2_wide_z,		\
+			      X, Y, doit);				\
 									\
       /* Normalize since we know where the msb of the multiplicands	\
 	 were (bit B), we know that the msb of the of the product is	\
 	 at either 2B or 2B-1.  */					\
-      _FP_FRAC_SRS_4 (_z, wfracbits-1, 2*wfracbits);			\
-      R##_f0 = _FP_FRAC_WORD_4 (_z, 0);					\
-      R##_f1 = _FP_FRAC_WORD_4 (_z, 1);					\
+      _FP_FRAC_SRS_4 (_FP_MUL_MEAT_2_wide_z, wfracbits-1, 2*wfracbits);	\
+      R##_f0 = _FP_FRAC_WORD_4 (_FP_MUL_MEAT_2_wide_z, 0);		\
+      R##_f1 = _FP_FRAC_WORD_4 (_FP_MUL_MEAT_2_wide_z, 1);		\
     }									\
   while (0)
 
@@ -318,35 +329,51 @@ 
 #define _FP_MUL_MEAT_DW_2_wide_3mul(wfracbits, R, X, Y, doit)		\
   do									\
     {									\
-      _FP_FRAC_DECL_2 (_b);						\
-      _FP_FRAC_DECL_2 (_c);						\
-      _FP_W_TYPE _d;							\
-      int _c1, _c2;							\
+      _FP_FRAC_DECL_2 (_FP_MUL_MEAT_DW_2_wide_3mul_b);			\
+      _FP_FRAC_DECL_2 (_FP_MUL_MEAT_DW_2_wide_3mul_c);			\
+      _FP_W_TYPE _FP_MUL_MEAT_DW_2_wide_3mul_d;				\
+      int _FP_MUL_MEAT_DW_2_wide_3mul_c1;				\
+      int _FP_MUL_MEAT_DW_2_wide_3mul_c2;				\
 									\
-      _b_f0 = X##_f0 + X##_f1;						\
-      _c1 = _b_f0 < X##_f0;						\
-      _b_f1 = Y##_f0 + Y##_f1;						\
-      _c2 = _b_f1 < Y##_f0;						\
-      doit (_d, _FP_FRAC_WORD_4 (R, 0), X##_f0, Y##_f0);		\
-      doit (_FP_FRAC_WORD_4 (R, 2), _FP_FRAC_WORD_4 (R, 1), _b_f0, _b_f1); \
-      doit (_c_f1, _c_f0, X##_f1, Y##_f1);				\
+      _FP_MUL_MEAT_DW_2_wide_3mul_b_f0 = X##_f0 + X##_f1;		\
+      _FP_MUL_MEAT_DW_2_wide_3mul_c1					\
+	= _FP_MUL_MEAT_DW_2_wide_3mul_b_f0 < X##_f0;			\
+      _FP_MUL_MEAT_DW_2_wide_3mul_b_f1 = Y##_f0 + Y##_f1;		\
+      _FP_MUL_MEAT_DW_2_wide_3mul_c2					\
+	= _FP_MUL_MEAT_DW_2_wide_3mul_b_f1 < Y##_f0;			\
+      doit (_FP_MUL_MEAT_DW_2_wide_3mul_d, _FP_FRAC_WORD_4 (R, 0),	\
+	    X##_f0, Y##_f0);						\
+      doit (_FP_FRAC_WORD_4 (R, 2), _FP_FRAC_WORD_4 (R, 1),		\
+	    _FP_MUL_MEAT_DW_2_wide_3mul_b_f0,				\
+	    _FP_MUL_MEAT_DW_2_wide_3mul_b_f1);				\
+      doit (_FP_MUL_MEAT_DW_2_wide_3mul_c_f1,				\
+	    _FP_MUL_MEAT_DW_2_wide_3mul_c_f0, X##_f1, Y##_f1);		\
 									\
-      _b_f0 &= -_c2;							\
-      _b_f1 &= -_c1;							\
+      _FP_MUL_MEAT_DW_2_wide_3mul_b_f0					\
+	&= -_FP_MUL_MEAT_DW_2_wide_3mul_c2;				\
+      _FP_MUL_MEAT_DW_2_wide_3mul_b_f1					\
+	&= -_FP_MUL_MEAT_DW_2_wide_3mul_c1;				\
       __FP_FRAC_ADD_3 (_FP_FRAC_WORD_4 (R, 3), _FP_FRAC_WORD_4 (R, 2),	\
-		       _FP_FRAC_WORD_4 (R, 1), (_c1 & _c2), 0, _d,	\
+		       _FP_FRAC_WORD_4 (R, 1),				\
+		       (_FP_MUL_MEAT_DW_2_wide_3mul_c1			\
+			& _FP_MUL_MEAT_DW_2_wide_3mul_c2), 0,		\
+		       _FP_MUL_MEAT_DW_2_wide_3mul_d,			\
 		       0, _FP_FRAC_WORD_4 (R, 2), _FP_FRAC_WORD_4 (R, 1)); \
       __FP_FRAC_ADDI_2 (_FP_FRAC_WORD_4 (R, 3), _FP_FRAC_WORD_4 (R, 2),	\
-			_b_f0);						\
+			_FP_MUL_MEAT_DW_2_wide_3mul_b_f0);		\
       __FP_FRAC_ADDI_2 (_FP_FRAC_WORD_4 (R, 3), _FP_FRAC_WORD_4 (R, 2),	\
-			_b_f1);						\
+			_FP_MUL_MEAT_DW_2_wide_3mul_b_f1);		\
       __FP_FRAC_DEC_3 (_FP_FRAC_WORD_4 (R, 3), _FP_FRAC_WORD_4 (R, 2),	\
 		       _FP_FRAC_WORD_4 (R, 1),				\
-		       0, _d, _FP_FRAC_WORD_4 (R, 0));			\
+		       0, _FP_MUL_MEAT_DW_2_wide_3mul_d,		\
+		       _FP_FRAC_WORD_4 (R, 0));				\
       __FP_FRAC_DEC_3 (_FP_FRAC_WORD_4 (R, 3), _FP_FRAC_WORD_4 (R, 2),	\
-		       _FP_FRAC_WORD_4 (R, 1), 0, _c_f1, _c_f0);	\
+		       _FP_FRAC_WORD_4 (R, 1), 0,			\
+		       _FP_MUL_MEAT_DW_2_wide_3mul_c_f1,		\
+		       _FP_MUL_MEAT_DW_2_wide_3mul_c_f0);		\
       __FP_FRAC_ADD_2 (_FP_FRAC_WORD_4 (R, 3), _FP_FRAC_WORD_4 (R, 2),	\
-		       _c_f1, _c_f0,					\
+		       _FP_MUL_MEAT_DW_2_wide_3mul_c_f1,		\
+		       _FP_MUL_MEAT_DW_2_wide_3mul_c_f0,		\
 		       _FP_FRAC_WORD_4 (R, 3), _FP_FRAC_WORD_4 (R, 2));	\
     }									\
   while (0)
@@ -354,45 +381,50 @@ 
 #define _FP_MUL_MEAT_2_wide_3mul(wfracbits, R, X, Y, doit)		\
   do									\
     {									\
-      _FP_FRAC_DECL_4 (_z);						\
+      _FP_FRAC_DECL_4 (_FP_MUL_MEAT_2_wide_3mul_z);			\
 									\
-      _FP_MUL_MEAT_DW_2_wide_3mul (wfracbits, _z, X, Y, doit);		\
+      _FP_MUL_MEAT_DW_2_wide_3mul (wfracbits,				\
+				   _FP_MUL_MEAT_2_wide_3mul_z,		\
+				   X, Y, doit);				\
 									\
       /* Normalize since we know where the msb of the multiplicands	\
 	 were (bit B), we know that the msb of the of the product is	\
 	 at either 2B or 2B-1.  */					\
-      _FP_FRAC_SRS_4 (_z, wfracbits-1, 2*wfracbits);			\
-      R##_f0 = _FP_FRAC_WORD_4 (_z, 0);					\
-      R##_f1 = _FP_FRAC_WORD_4 (_z, 1);					\
+      _FP_FRAC_SRS_4 (_FP_MUL_MEAT_2_wide_3mul_z,			\
+		      wfracbits-1, 2*wfracbits);			\
+      R##_f0 = _FP_FRAC_WORD_4 (_FP_MUL_MEAT_2_wide_3mul_z, 0);		\
+      R##_f1 = _FP_FRAC_WORD_4 (_FP_MUL_MEAT_2_wide_3mul_z, 1);		\
     }									\
   while (0)
 
 #define _FP_MUL_MEAT_DW_2_gmp(wfracbits, R, X, Y)	\
   do							\
     {							\
-      _FP_W_TYPE _x[2], _y[2];				\
-      _x[0] = X##_f0;					\
-      _x[1] = X##_f1;					\
-      _y[0] = Y##_f0;					\
-      _y[1] = Y##_f1;					\
+      _FP_W_TYPE _FP_MUL_MEAT_DW_2_gmp_x[2];		\
+      _FP_W_TYPE _FP_MUL_MEAT_DW_2_gmp_y[2];		\
+      _FP_MUL_MEAT_DW_2_gmp_x[0] = X##_f0;		\
+      _FP_MUL_MEAT_DW_2_gmp_x[1] = X##_f1;		\
+      _FP_MUL_MEAT_DW_2_gmp_y[0] = Y##_f0;		\
+      _FP_MUL_MEAT_DW_2_gmp_y[1] = Y##_f1;		\
 							\
-      mpn_mul_n (R##_f, _x, _y, 2);			\
+      mpn_mul_n (R##_f, _FP_MUL_MEAT_DW_2_gmp_x,	\
+		 _FP_MUL_MEAT_DW_2_gmp_y, 2);		\
     }							\
   while (0)
 
 #define _FP_MUL_MEAT_2_gmp(wfracbits, R, X, Y)				\
   do									\
     {									\
-      _FP_FRAC_DECL_4 (_z);						\
+      _FP_FRAC_DECL_4 (_FP_MUL_MEAT_2_gmp_z);				\
 									\
-      _FP_MUL_MEAT_DW_2_gmp (wfracbits, _z, X, Y);			\
+      _FP_MUL_MEAT_DW_2_gmp (wfracbits, _FP_MUL_MEAT_2_gmp_z, 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_4 (_z, wfracbits-1, 2*wfracbits);			\
-      R##_f0 = _z_f[0];							\
-      R##_f1 = _z_f[1];							\
+      _FP_FRAC_SRS_4 (_FP_MUL_MEAT_2_gmp_z, wfracbits-1, 2*wfracbits);	\
+      R##_f0 = _FP_MUL_MEAT_2_gmp_z_f[0];				\
+      R##_f1 = _FP_MUL_MEAT_2_gmp_z_f[1];				\
     }									\
   while (0)
 
@@ -507,67 +539,91 @@ 
 #define _FP_DIV_MEAT_2_udiv(fs, R, X, Y)				\
   do									\
     {									\
-      _FP_W_TYPE _n_f2, _n_f1, _n_f0, _r_f1, _r_f0, _m_f1, _m_f0;	\
+      _FP_W_TYPE _FP_DIV_MEAT_2_udiv_n_f2;				\
+      _FP_W_TYPE _FP_DIV_MEAT_2_udiv_n_f1;				\
+      _FP_W_TYPE _FP_DIV_MEAT_2_udiv_n_f0;				\
+      _FP_W_TYPE _FP_DIV_MEAT_2_udiv_r_f1;				\
+      _FP_W_TYPE _FP_DIV_MEAT_2_udiv_r_f0;				\
+      _FP_W_TYPE _FP_DIV_MEAT_2_udiv_m_f1;				\
+      _FP_W_TYPE _FP_DIV_MEAT_2_udiv_m_f0;				\
       if (_FP_FRAC_GE_2 (X, Y))						\
 	{								\
-	  _n_f2 = X##_f1 >> 1;						\
-	  _n_f1 = X##_f1 << (_FP_W_TYPE_SIZE - 1) | X##_f0 >> 1;	\
-	  _n_f0 = X##_f0 << (_FP_W_TYPE_SIZE - 1);			\
+	  _FP_DIV_MEAT_2_udiv_n_f2 = X##_f1 >> 1;			\
+	  _FP_DIV_MEAT_2_udiv_n_f1					\
+	    = X##_f1 << (_FP_W_TYPE_SIZE - 1) | X##_f0 >> 1;		\
+	  _FP_DIV_MEAT_2_udiv_n_f0					\
+	    = X##_f0 << (_FP_W_TYPE_SIZE - 1);				\
 	}								\
       else								\
 	{								\
 	  R##_e--;							\
-	  _n_f2 = X##_f1;						\
-	  _n_f1 = X##_f0;						\
-	  _n_f0 = 0;							\
+	  _FP_DIV_MEAT_2_udiv_n_f2 = X##_f1;				\
+	  _FP_DIV_MEAT_2_udiv_n_f1 = X##_f0;				\
+	  _FP_DIV_MEAT_2_udiv_n_f0 = 0;					\
 	}								\
 									\
       /* Normalize, i.e. make the most significant bit of the		\
 	 denominator set. */						\
       _FP_FRAC_SLL_2 (Y, _FP_WFRACXBITS_##fs);				\
 									\
-      udiv_qrnnd (R##_f1, _r_f1, _n_f2, _n_f1, Y##_f1);			\
-      umul_ppmm (_m_f1, _m_f0, R##_f1, Y##_f0);				\
-      _r_f0 = _n_f0;							\
-      if (_FP_FRAC_GT_2 (_m, _r))					\
+      udiv_qrnnd (R##_f1, _FP_DIV_MEAT_2_udiv_r_f1,			\
+		  _FP_DIV_MEAT_2_udiv_n_f2, _FP_DIV_MEAT_2_udiv_n_f1,	\
+		  Y##_f1);						\
+      umul_ppmm (_FP_DIV_MEAT_2_udiv_m_f1, _FP_DIV_MEAT_2_udiv_m_f0,	\
+		 R##_f1, Y##_f0);					\
+      _FP_DIV_MEAT_2_udiv_r_f0 = _FP_DIV_MEAT_2_udiv_n_f0;		\
+      if (_FP_FRAC_GT_2 (_FP_DIV_MEAT_2_udiv_m, _FP_DIV_MEAT_2_udiv_r))	\
 	{								\
 	  R##_f1--;							\
-	  _FP_FRAC_ADD_2 (_r, Y, _r);					\
-	  if (_FP_FRAC_GE_2 (_r, Y) && _FP_FRAC_GT_2 (_m, _r))		\
+	  _FP_FRAC_ADD_2 (_FP_DIV_MEAT_2_udiv_r, Y,			\
+			  _FP_DIV_MEAT_2_udiv_r);			\
+	  if (_FP_FRAC_GE_2 (_FP_DIV_MEAT_2_udiv_r, Y)			\
+	      && _FP_FRAC_GT_2 (_FP_DIV_MEAT_2_udiv_m,			\
+				_FP_DIV_MEAT_2_udiv_r))			\
 	    {								\
 	      R##_f1--;							\
-	      _FP_FRAC_ADD_2 (_r, Y, _r);				\
+	      _FP_FRAC_ADD_2 (_FP_DIV_MEAT_2_udiv_r, Y,			\
+			      _FP_DIV_MEAT_2_udiv_r);			\
 	    }								\
 	}								\
-      _FP_FRAC_DEC_2 (_r, _m);						\
+      _FP_FRAC_DEC_2 (_FP_DIV_MEAT_2_udiv_r, _FP_DIV_MEAT_2_udiv_m);	\
 									\
-      if (_r_f1 == Y##_f1)						\
+      if (_FP_DIV_MEAT_2_udiv_r_f1 == Y##_f1)				\
 	{								\
 	  /* This is a special case, not an optimization		\
-	     (_r/Y##_f1 would not fit into UWtype).			\
-	     As _r is guaranteed to be < Y,  R##_f0 can be either	\
-	     (UWtype)-1 or (UWtype)-2.  But as we know what kind	\
-	     of bits it is (sticky, guard, round),  we don't care.	\
-	     We also don't care what the reminder is,  because the	\
-	     guard bit will be set anyway.  -jj */			\
+	     (_FP_DIV_MEAT_2_udiv_r/Y##_f1 would not fit into UWtype).	\
+	     As _FP_DIV_MEAT_2_udiv_r is guaranteed to be < Y,		\
+	     R##_f0 can be either (UWtype)-1 or (UWtype)-2.  But as we	\
+	     know what kind of bits it is (sticky, guard, round),	\
+	     we don't care.  We also don't care what the reminder is,	\
+	     because the guard bit will be set anyway.  -jj */		\
 	  R##_f0 = -1;							\
 	}								\
       else								\
 	{								\
-	  udiv_qrnnd (R##_f0, _r_f1, _r_f1, _r_f0, Y##_f1);		\
-	  umul_ppmm (_m_f1, _m_f0, R##_f0, Y##_f0);			\
-	  _r_f0 = 0;							\
-	  if (_FP_FRAC_GT_2 (_m, _r))					\
+	  udiv_qrnnd (R##_f0, _FP_DIV_MEAT_2_udiv_r_f1,			\
+		      _FP_DIV_MEAT_2_udiv_r_f1,				\
+		      _FP_DIV_MEAT_2_udiv_r_f0, Y##_f1);		\
+	  umul_ppmm (_FP_DIV_MEAT_2_udiv_m_f1,				\
+		     _FP_DIV_MEAT_2_udiv_m_f0, R##_f0, Y##_f0);		\
+	  _FP_DIV_MEAT_2_udiv_r_f0 = 0;					\
+	  if (_FP_FRAC_GT_2 (_FP_DIV_MEAT_2_udiv_m,			\
+			     _FP_DIV_MEAT_2_udiv_r))			\
 	    {								\
 	      R##_f0--;							\
-	      _FP_FRAC_ADD_2 (_r, Y, _r);				\
-	      if (_FP_FRAC_GE_2 (_r, Y) && _FP_FRAC_GT_2 (_m, _r))	\
+	      _FP_FRAC_ADD_2 (_FP_DIV_MEAT_2_udiv_r, Y,			\
+			      _FP_DIV_MEAT_2_udiv_r);			\
+	      if (_FP_FRAC_GE_2 (_FP_DIV_MEAT_2_udiv_r, Y)		\
+		  && _FP_FRAC_GT_2 (_FP_DIV_MEAT_2_udiv_m,		\
+				    _FP_DIV_MEAT_2_udiv_r))		\
 		{							\
 		  R##_f0--;						\
-		  _FP_FRAC_ADD_2 (_r, Y, _r);				\
+		  _FP_FRAC_ADD_2 (_FP_DIV_MEAT_2_udiv_r, Y,		\
+				  _FP_DIV_MEAT_2_udiv_r);		\
 		}							\
 	    }								\
-	  if (!_FP_FRAC_EQ_2 (_r, _m))					\
+	  if (!_FP_FRAC_EQ_2 (_FP_DIV_MEAT_2_udiv_r,			\
+			      _FP_DIV_MEAT_2_udiv_m))			\
 	    R##_f0 |= _FP_WORK_STICKY;					\
 	}								\
     }									\
diff --git a/soft-fp/op-4.h b/soft-fp/op-4.h
index a80bdb2..3acf96c 100644
--- a/soft-fp/op-4.h
+++ b/soft-fp/op-4.h
@@ -39,49 +39,67 @@ 
 #define _FP_FRAC_LOW_4(X)	(X##_f[0])
 #define _FP_FRAC_WORD_4(X, w)	(X##_f[w])
 
-#define _FP_FRAC_SLL_4(X, N)				\
-  do							\
-    {							\
-      _FP_I_TYPE _up, _down, _skip, _i;			\
-      _skip = (N) / _FP_W_TYPE_SIZE;			\
-      _up = (N) % _FP_W_TYPE_SIZE;			\
-      _down = _FP_W_TYPE_SIZE - _up;			\
-      if (!_up)						\
-	for (_i = 3; _i >= _skip; --_i)			\
-	  X##_f[_i] = X##_f[_i-_skip];			\
-      else						\
-	{						\
-	  for (_i = 3; _i > _skip; --_i)		\
-	    X##_f[_i] = (X##_f[_i-_skip] << _up		\
-			 | X##_f[_i-_skip-1] >> _down);	\
-	  X##_f[_i--] = X##_f[0] << _up;		\
-	}						\
-      for (; _i >= 0; --_i)				\
-	X##_f[_i] = 0;					\
-    }							\
+#define _FP_FRAC_SLL_4(X, N)						\
+  do									\
+    {									\
+      _FP_I_TYPE _FP_FRAC_SLL_4_up, _FP_FRAC_SLL_4_down;		\
+      _FP_I_TYPE _FP_FRAC_SLL_4_skip, _FP_FRAC_SLL_4_i;			\
+      _FP_FRAC_SLL_4_skip = (N) / _FP_W_TYPE_SIZE;			\
+      _FP_FRAC_SLL_4_up = (N) % _FP_W_TYPE_SIZE;			\
+      _FP_FRAC_SLL_4_down = _FP_W_TYPE_SIZE - _FP_FRAC_SLL_4_up;	\
+      if (!_FP_FRAC_SLL_4_up)						\
+	for (_FP_FRAC_SLL_4_i = 3;					\
+	     _FP_FRAC_SLL_4_i >= _FP_FRAC_SLL_4_skip;			\
+	     --_FP_FRAC_SLL_4_i)					\
+	  X##_f[_FP_FRAC_SLL_4_i]					\
+	    = X##_f[_FP_FRAC_SLL_4_i-_FP_FRAC_SLL_4_skip];		\
+      else								\
+	{								\
+	  for (_FP_FRAC_SLL_4_i = 3;					\
+	       _FP_FRAC_SLL_4_i > _FP_FRAC_SLL_4_skip;			\
+	       --_FP_FRAC_SLL_4_i)					\
+	    X##_f[_FP_FRAC_SLL_4_i]					\
+	      = ((X##_f[_FP_FRAC_SLL_4_i-_FP_FRAC_SLL_4_skip]		\
+		  << _FP_FRAC_SLL_4_up)					\
+		 | (X##_f[_FP_FRAC_SLL_4_i-_FP_FRAC_SLL_4_skip-1]	\
+		    >> _FP_FRAC_SLL_4_down));				\
+	  X##_f[_FP_FRAC_SLL_4_i--] = X##_f[0] << _FP_FRAC_SLL_4_up;	\
+	}								\
+      for (; _FP_FRAC_SLL_4_i >= 0; --_FP_FRAC_SLL_4_i)			\
+	X##_f[_FP_FRAC_SLL_4_i] = 0;					\
+    }									\
   while (0)
 
 /* This one was broken too */
-#define _FP_FRAC_SRL_4(X, N)				\
-  do							\
-    {							\
-      _FP_I_TYPE _up, _down, _skip, _i;			\
-      _skip = (N) / _FP_W_TYPE_SIZE;			\
-      _down = (N) % _FP_W_TYPE_SIZE;			\
-      _up = _FP_W_TYPE_SIZE - _down;			\
-      if (!_down)					\
-	for (_i = 0; _i <= 3-_skip; ++_i)		\
-	  X##_f[_i] = X##_f[_i+_skip];			\
-      else						\
-	{						\
-	  for (_i = 0; _i < 3-_skip; ++_i)		\
-	    X##_f[_i] = (X##_f[_i+_skip] >> _down	\
-			 | X##_f[_i+_skip+1] << _up);	\
-	  X##_f[_i++] = X##_f[3] >> _down;		\
-	}						\
-      for (; _i < 4; ++_i)				\
-	X##_f[_i] = 0;					\
-    }							\
+#define _FP_FRAC_SRL_4(X, N)						\
+  do									\
+    {									\
+      _FP_I_TYPE _FP_FRAC_SRL_4_up, _FP_FRAC_SRL_4_down;		\
+      _FP_I_TYPE _FP_FRAC_SRL_4_skip, _FP_FRAC_SRL_4_i;			\
+      _FP_FRAC_SRL_4_skip = (N) / _FP_W_TYPE_SIZE;			\
+      _FP_FRAC_SRL_4_down = (N) % _FP_W_TYPE_SIZE;			\
+      _FP_FRAC_SRL_4_up = _FP_W_TYPE_SIZE - _FP_FRAC_SRL_4_down;	\
+      if (!_FP_FRAC_SRL_4_down)						\
+	for (_FP_FRAC_SRL_4_i = 0;					\
+	     _FP_FRAC_SRL_4_i <= 3-_FP_FRAC_SRL_4_skip;			\
+	     ++_FP_FRAC_SRL_4_i)					\
+	  X##_f[_FP_FRAC_SRL_4_i]					\
+	    = X##_f[_FP_FRAC_SRL_4_i+_FP_FRAC_SRL_4_skip];		\
+      else								\
+	{								\
+	  for (_FP_FRAC_SRL_4_i = 0;					\
+	       _FP_FRAC_SRL_4_i < 3-_FP_FRAC_SRL_4_skip;		\
+	       ++_FP_FRAC_SRL_4_i)					\
+	    X##_f[_FP_FRAC_SRL_4_i]					\
+	      = ((X##_f[_FP_FRAC_SRL_4_i+_FP_FRAC_SRL_4_skip]		\
+		  >> _FP_FRAC_SRL_4_down)				\
+		 | (X##_f[_FP_FRAC_SRL_4_i+_FP_FRAC_SRL_4_skip+1]	\
+		    << _FP_FRAC_SRL_4_up));				\
+	  X##_f[_FP_FRAC_SRL_4_i++] = X##_f[3] >> _FP_FRAC_SRL_4_down;	\
+	}								\
+      for (; _FP_FRAC_SRL_4_i < 4; ++_FP_FRAC_SRL_4_i)			\
+	X##_f[_FP_FRAC_SRL_4_i] = 0;					\
+    }									\
   while (0)
 
 
@@ -90,40 +108,53 @@ 
  * but that if any of the bits that fall off the right hand side
  * were one then we always set the LSbit.
  */
-#define _FP_FRAC_SRST_4(X, S, N, size)			\
-  do							\
-    {							\
-      _FP_I_TYPE _up, _down, _skip, _i;			\
-      _FP_W_TYPE _s;					\
-      _skip = (N) / _FP_W_TYPE_SIZE;			\
-      _down = (N) % _FP_W_TYPE_SIZE;			\
-      _up = _FP_W_TYPE_SIZE - _down;			\
-      for (_s = _i = 0; _i < _skip; ++_i)		\
-	_s |= X##_f[_i];				\
-      if (!_down)					\
-	for (_i = 0; _i <= 3-_skip; ++_i)		\
-	  X##_f[_i] = X##_f[_i+_skip];			\
-      else						\
-	{						\
-	  _s |= X##_f[_i] << _up;			\
-	  for (_i = 0; _i < 3-_skip; ++_i)		\
-	    X##_f[_i] = (X##_f[_i+_skip] >> _down	\
-			 | X##_f[_i+_skip+1] << _up);	\
-	  X##_f[_i++] = X##_f[3] >> _down;		\
-	}						\
-      for (; _i < 4; ++_i)				\
-	X##_f[_i] = 0;					\
-      S = (_s != 0);					\
-    }							\
+#define _FP_FRAC_SRST_4(X, S, N, size)					\
+  do									\
+    {									\
+      _FP_I_TYPE _FP_FRAC_SRST_4_up, _FP_FRAC_SRST_4_down;		\
+      _FP_I_TYPE _FP_FRAC_SRST_4_skip, _FP_FRAC_SRST_4_i;		\
+      _FP_W_TYPE _FP_FRAC_SRST_4_s;					\
+      _FP_FRAC_SRST_4_skip = (N) / _FP_W_TYPE_SIZE;			\
+      _FP_FRAC_SRST_4_down = (N) % _FP_W_TYPE_SIZE;			\
+      _FP_FRAC_SRST_4_up = _FP_W_TYPE_SIZE - _FP_FRAC_SRST_4_down;	\
+      for (_FP_FRAC_SRST_4_s = _FP_FRAC_SRST_4_i = 0;			\
+	   _FP_FRAC_SRST_4_i < _FP_FRAC_SRST_4_skip;			\
+	   ++_FP_FRAC_SRST_4_i)						\
+	_FP_FRAC_SRST_4_s |= X##_f[_FP_FRAC_SRST_4_i];			\
+      if (!_FP_FRAC_SRST_4_down)					\
+	for (_FP_FRAC_SRST_4_i = 0;					\
+	     _FP_FRAC_SRST_4_i <= 3-_FP_FRAC_SRST_4_skip;		\
+	     ++_FP_FRAC_SRST_4_i)					\
+	  X##_f[_FP_FRAC_SRST_4_i]					\
+	    = X##_f[_FP_FRAC_SRST_4_i+_FP_FRAC_SRST_4_skip];		\
+      else								\
+	{								\
+	  _FP_FRAC_SRST_4_s						\
+	    |= X##_f[_FP_FRAC_SRST_4_i] << _FP_FRAC_SRST_4_up;		\
+	  for (_FP_FRAC_SRST_4_i = 0;					\
+	       _FP_FRAC_SRST_4_i < 3-_FP_FRAC_SRST_4_skip;		\
+	       ++_FP_FRAC_SRST_4_i)					\
+	    X##_f[_FP_FRAC_SRST_4_i]					\
+	      = ((X##_f[_FP_FRAC_SRST_4_i+_FP_FRAC_SRST_4_skip]		\
+		  >> _FP_FRAC_SRST_4_down)				\
+		 | (X##_f[_FP_FRAC_SRST_4_i+_FP_FRAC_SRST_4_skip+1]	\
+		    << _FP_FRAC_SRST_4_up));				\
+	  X##_f[_FP_FRAC_SRST_4_i++]					\
+	    = X##_f[3] >> _FP_FRAC_SRST_4_down;				\
+	}								\
+      for (; _FP_FRAC_SRST_4_i < 4; ++_FP_FRAC_SRST_4_i)		\
+	X##_f[_FP_FRAC_SRST_4_i] = 0;					\
+      S = (_FP_FRAC_SRST_4_s != 0);					\
+    }									\
   while (0)
 
-#define _FP_FRAC_SRS_4(X, N, size)		\
-  do						\
-    {						\
-      int _sticky;				\
-      _FP_FRAC_SRST_4 (X, _sticky, N, size);	\
-      X##_f[0] |= _sticky;			\
-    }						\
+#define _FP_FRAC_SRS_4(X, N, size)				\
+  do								\
+    {								\
+      int _FP_FRAC_SRS_4_sticky;				\
+      _FP_FRAC_SRST_4 (X, _FP_FRAC_SRS_4_sticky, N, size);	\
+      X##_f[0] |= _FP_FRAC_SRS_4_sticky;			\
+    }								\
   while (0)
 
 #define _FP_FRAC_ADD_4(R, X, Y)					\
@@ -201,60 +232,62 @@ 
   while (0)
 
 
-#define _FP_UNPACK_RAW_4(fs, X, val)		\
-  do						\
-    {						\
-      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;			\
-    }						\
+#define _FP_UNPACK_RAW_4(fs, X, val)			\
+  do							\
+    {							\
+      union _FP_UNION_##fs _FP_UNPACK_RAW_4_flo;	\
+      _FP_UNPACK_RAW_4_flo.flt = (val);			\
+      X##_f[0] = _FP_UNPACK_RAW_4_flo.bits.frac0;	\
+      X##_f[1] = _FP_UNPACK_RAW_4_flo.bits.frac1;	\
+      X##_f[2] = _FP_UNPACK_RAW_4_flo.bits.frac2;	\
+      X##_f[3] = _FP_UNPACK_RAW_4_flo.bits.frac3;	\
+      X##_e  = _FP_UNPACK_RAW_4_flo.bits.exp;		\
+      X##_s  = _FP_UNPACK_RAW_4_flo.bits.sign;		\
+    }							\
   while (0)
 
-#define _FP_UNPACK_RAW_4_P(fs, X, val)					\
-  do									\
-    {									\
-      union _FP_UNION_##fs *_flo = (union _FP_UNION_##fs *) (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;						\
-    }									\
+#define _FP_UNPACK_RAW_4_P(fs, X, val)			\
+  do							\
+    {							\
+      union _FP_UNION_##fs *_FP_UNPACK_RAW_4_P_flo	\
+	= (union _FP_UNION_##fs *) (val);		\
+							\
+      X##_f[0] = _FP_UNPACK_RAW_4_P_flo->bits.frac0;	\
+      X##_f[1] = _FP_UNPACK_RAW_4_P_flo->bits.frac1;	\
+      X##_f[2] = _FP_UNPACK_RAW_4_P_flo->bits.frac2;	\
+      X##_f[3] = _FP_UNPACK_RAW_4_P_flo->bits.frac3;	\
+      X##_e  = _FP_UNPACK_RAW_4_P_flo->bits.exp;	\
+      X##_s  = _FP_UNPACK_RAW_4_P_flo->bits.sign;	\
+    }							\
   while (0)
 
 #define _FP_PACK_RAW_4(fs, val, X)		\
   do						\
     {						\
-      union _FP_UNION_##fs _flo;		\
-      _flo.bits.frac0 = X##_f[0];		\
-      _flo.bits.frac1 = X##_f[1];		\
-      _flo.bits.frac2 = X##_f[2];		\
-      _flo.bits.frac3 = X##_f[3];		\
-      _flo.bits.exp   = X##_e;			\
-      _flo.bits.sign  = X##_s;			\
-      (val) = _flo.flt;				\
+      union _FP_UNION_##fs _FP_PACK_RAW_4_flo;	\
+      _FP_PACK_RAW_4_flo.bits.frac0 = X##_f[0];	\
+      _FP_PACK_RAW_4_flo.bits.frac1 = X##_f[1];	\
+      _FP_PACK_RAW_4_flo.bits.frac2 = X##_f[2];	\
+      _FP_PACK_RAW_4_flo.bits.frac3 = X##_f[3];	\
+      _FP_PACK_RAW_4_flo.bits.exp   = X##_e;	\
+      _FP_PACK_RAW_4_flo.bits.sign  = X##_s;	\
+      (val) = _FP_PACK_RAW_4_flo.flt;		\
     }						\
   while (0)
 
-#define _FP_PACK_RAW_4_P(fs, val, X)					\
-  do									\
-    {									\
-      union _FP_UNION_##fs *_flo = (union _FP_UNION_##fs *) (val);	\
-									\
-      _flo->bits.frac0 = X##_f[0];					\
-      _flo->bits.frac1 = X##_f[1];					\
-      _flo->bits.frac2 = X##_f[2];					\
-      _flo->bits.frac3 = X##_f[3];					\
-      _flo->bits.exp   = X##_e;						\
-      _flo->bits.sign  = X##_s;						\
-    }									\
+#define _FP_PACK_RAW_4_P(fs, val, X)			\
+  do							\
+    {							\
+      union _FP_UNION_##fs *_FP_PACK_RAW_4_P_flo	\
+	= (union _FP_UNION_##fs *) (val);		\
+							\
+      _FP_PACK_RAW_4_P_flo->bits.frac0 = X##_f[0];	\
+      _FP_PACK_RAW_4_P_flo->bits.frac1 = X##_f[1];	\
+      _FP_PACK_RAW_4_P_flo->bits.frac2 = X##_f[2];	\
+      _FP_PACK_RAW_4_P_flo->bits.frac3 = X##_f[3];	\
+      _FP_PACK_RAW_4_P_flo->bits.exp   = X##_e;		\
+      _FP_PACK_RAW_4_P_flo->bits.sign  = X##_s;		\
+    }							\
   while (0)
 
 /*
@@ -266,81 +299,126 @@ 
 #define _FP_MUL_MEAT_DW_4_wide(wfracbits, R, X, Y, doit)		\
   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 (_FP_MUL_MEAT_DW_4_wide_b);			\
+      _FP_FRAC_DECL_2 (_FP_MUL_MEAT_DW_4_wide_c);			\
+      _FP_FRAC_DECL_2 (_FP_MUL_MEAT_DW_4_wide_d);			\
+      _FP_FRAC_DECL_2 (_FP_MUL_MEAT_DW_4_wide_e);			\
+      _FP_FRAC_DECL_2 (_FP_MUL_MEAT_DW_4_wide_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]);				\
-      doit (_c_f1, _c_f0, X##_f[1], Y##_f[0]);				\
-      doit (_d_f1, _d_f0, X##_f[1], Y##_f[1]);				\
-      doit (_e_f1, _e_f0, X##_f[0], Y##_f[2]);				\
-      doit (_f_f1, _f_f0, X##_f[2], Y##_f[0]);				\
+      doit (_FP_FRAC_WORD_8 (R, 1), _FP_FRAC_WORD_8 (R, 0),		\
+	    X##_f[0], Y##_f[0]);					\
+      doit (_FP_MUL_MEAT_DW_4_wide_b_f1, _FP_MUL_MEAT_DW_4_wide_b_f0,	\
+	    X##_f[0], Y##_f[1]);					\
+      doit (_FP_MUL_MEAT_DW_4_wide_c_f1, _FP_MUL_MEAT_DW_4_wide_c_f0,	\
+	    X##_f[1], Y##_f[0]);					\
+      doit (_FP_MUL_MEAT_DW_4_wide_d_f1, _FP_MUL_MEAT_DW_4_wide_d_f0,	\
+	    X##_f[1], Y##_f[1]);					\
+      doit (_FP_MUL_MEAT_DW_4_wide_e_f1, _FP_MUL_MEAT_DW_4_wide_e_f0,	\
+	    X##_f[0], Y##_f[2]);					\
+      doit (_FP_MUL_MEAT_DW_4_wide_f_f1, _FP_MUL_MEAT_DW_4_wide_f_f0,	\
+	    X##_f[2], Y##_f[0]);					\
       __FP_FRAC_ADD_3 (_FP_FRAC_WORD_8 (R, 3), _FP_FRAC_WORD_8 (R, 2),	\
-		       _FP_FRAC_WORD_8 (R, 1), 0, _b_f1, _b_f0,		\
+		       _FP_FRAC_WORD_8 (R, 1), 0,			\
+		       _FP_MUL_MEAT_DW_4_wide_b_f1,			\
+		       _FP_MUL_MEAT_DW_4_wide_b_f0,			\
 		       0, 0, _FP_FRAC_WORD_8 (R, 1));			\
       __FP_FRAC_ADD_3 (_FP_FRAC_WORD_8 (R, 3), _FP_FRAC_WORD_8 (R, 2),	\
-		       _FP_FRAC_WORD_8 (R, 1), 0, _c_f1, _c_f0,		\
+		       _FP_FRAC_WORD_8 (R, 1), 0,			\
+		       _FP_MUL_MEAT_DW_4_wide_c_f1,			\
+		       _FP_MUL_MEAT_DW_4_wide_c_f0,			\
 		       _FP_FRAC_WORD_8 (R, 3), _FP_FRAC_WORD_8 (R, 2),	\
 		       _FP_FRAC_WORD_8 (R, 1));				\
       __FP_FRAC_ADD_3 (_FP_FRAC_WORD_8 (R, 4), _FP_FRAC_WORD_8 (R, 3),	\
-		       _FP_FRAC_WORD_8 (R, 2), 0, _d_f1, _d_f0,		\
+		       _FP_FRAC_WORD_8 (R, 2), 0,			\
+		       _FP_MUL_MEAT_DW_4_wide_d_f1,			\
+		       _FP_MUL_MEAT_DW_4_wide_d_f0,			\
 		       0, _FP_FRAC_WORD_8 (R, 3), _FP_FRAC_WORD_8 (R, 2)); \
       __FP_FRAC_ADD_3 (_FP_FRAC_WORD_8 (R, 4), _FP_FRAC_WORD_8 (R, 3),	\
-		       _FP_FRAC_WORD_8 (R, 2), 0, _e_f1, _e_f0,		\
+		       _FP_FRAC_WORD_8 (R, 2), 0,			\
+		       _FP_MUL_MEAT_DW_4_wide_e_f1,			\
+		       _FP_MUL_MEAT_DW_4_wide_e_f0,			\
 		       _FP_FRAC_WORD_8 (R, 4), _FP_FRAC_WORD_8 (R, 3),	\
 		       _FP_FRAC_WORD_8 (R, 2));				\
       __FP_FRAC_ADD_3 (_FP_FRAC_WORD_8 (R, 4), _FP_FRAC_WORD_8 (R, 3),	\
-		       _FP_FRAC_WORD_8 (R, 2), 0, _f_f1, _f_f0,		\
+		       _FP_FRAC_WORD_8 (R, 2), 0,			\
+		       _FP_MUL_MEAT_DW_4_wide_f_f1,			\
+		       _FP_MUL_MEAT_DW_4_wide_f_f0,			\
 		       _FP_FRAC_WORD_8 (R, 4), _FP_FRAC_WORD_8 (R, 3),	\
 		       _FP_FRAC_WORD_8 (R, 2));				\
-      doit (_b_f1, _b_f0, X##_f[0], Y##_f[3]);				\
-      doit (_c_f1, _c_f0, X##_f[3], Y##_f[0]);				\
-      doit (_d_f1, _d_f0, X##_f[1], Y##_f[2]);				\
-      doit (_e_f1, _e_f0, X##_f[2], Y##_f[1]);				\
+      doit (_FP_MUL_MEAT_DW_4_wide_b_f1,				\
+	    _FP_MUL_MEAT_DW_4_wide_b_f0, X##_f[0], Y##_f[3]);		\
+      doit (_FP_MUL_MEAT_DW_4_wide_c_f1,				\
+	    _FP_MUL_MEAT_DW_4_wide_c_f0, X##_f[3], Y##_f[0]);		\
+      doit (_FP_MUL_MEAT_DW_4_wide_d_f1, _FP_MUL_MEAT_DW_4_wide_d_f0,	\
+	    X##_f[1], Y##_f[2]);					\
+      doit (_FP_MUL_MEAT_DW_4_wide_e_f1, _FP_MUL_MEAT_DW_4_wide_e_f0,	\
+	    X##_f[2], Y##_f[1]);					\
       __FP_FRAC_ADD_3 (_FP_FRAC_WORD_8 (R, 5), _FP_FRAC_WORD_8 (R, 4),	\
-		       _FP_FRAC_WORD_8 (R, 3), 0, _b_f1, _b_f0,		\
+		       _FP_FRAC_WORD_8 (R, 3), 0,			\
+		       _FP_MUL_MEAT_DW_4_wide_b_f1,			\
+		       _FP_MUL_MEAT_DW_4_wide_b_f0,			\
 		       0, _FP_FRAC_WORD_8 (R, 4), _FP_FRAC_WORD_8 (R, 3)); \
       __FP_FRAC_ADD_3 (_FP_FRAC_WORD_8 (R, 5), _FP_FRAC_WORD_8 (R, 4),	\
-		       _FP_FRAC_WORD_8 (R, 3), 0, _c_f1, _c_f0,		\
+		       _FP_FRAC_WORD_8 (R, 3), 0,			\
+		       _FP_MUL_MEAT_DW_4_wide_c_f1,			\
+		       _FP_MUL_MEAT_DW_4_wide_c_f0,			\
 		       _FP_FRAC_WORD_8 (R, 5), _FP_FRAC_WORD_8 (R, 4),	\
 		       _FP_FRAC_WORD_8 (R, 3));				\
       __FP_FRAC_ADD_3 (_FP_FRAC_WORD_8 (R, 5), _FP_FRAC_WORD_8 (R, 4),	\
-		       _FP_FRAC_WORD_8 (R, 3), 0, _d_f1, _d_f0,		\
+		       _FP_FRAC_WORD_8 (R, 3), 0,			\
+		       _FP_MUL_MEAT_DW_4_wide_d_f1,			\
+		       _FP_MUL_MEAT_DW_4_wide_d_f0,			\
 		       _FP_FRAC_WORD_8 (R, 5), _FP_FRAC_WORD_8 (R, 4),	\
 		       _FP_FRAC_WORD_8 (R, 3));				\
       __FP_FRAC_ADD_3 (_FP_FRAC_WORD_8 (R, 5), _FP_FRAC_WORD_8 (R, 4),	\
-		       _FP_FRAC_WORD_8 (R, 3), 0, _e_f1, _e_f0,		\
+		       _FP_FRAC_WORD_8 (R, 3), 0,			\
+		       _FP_MUL_MEAT_DW_4_wide_e_f1,			\
+		       _FP_MUL_MEAT_DW_4_wide_e_f0,			\
 		       _FP_FRAC_WORD_8 (R, 5), _FP_FRAC_WORD_8 (R, 4),	\
 		       _FP_FRAC_WORD_8 (R, 3));				\
-      doit (_b_f1, _b_f0, X##_f[2], Y##_f[2]);				\
-      doit (_c_f1, _c_f0, X##_f[1], Y##_f[3]);				\
-      doit (_d_f1, _d_f0, X##_f[3], Y##_f[1]);				\
-      doit (_e_f1, _e_f0, X##_f[2], Y##_f[3]);				\
-      doit (_f_f1, _f_f0, X##_f[3], Y##_f[2]);				\
+      doit (_FP_MUL_MEAT_DW_4_wide_b_f1, _FP_MUL_MEAT_DW_4_wide_b_f0,	\
+	    X##_f[2], Y##_f[2]);					\
+      doit (_FP_MUL_MEAT_DW_4_wide_c_f1, _FP_MUL_MEAT_DW_4_wide_c_f0,	\
+	    X##_f[1], Y##_f[3]);					\
+      doit (_FP_MUL_MEAT_DW_4_wide_d_f1, _FP_MUL_MEAT_DW_4_wide_d_f0,	\
+	    X##_f[3], Y##_f[1]);					\
+      doit (_FP_MUL_MEAT_DW_4_wide_e_f1, _FP_MUL_MEAT_DW_4_wide_e_f0,	\
+	    X##_f[2], Y##_f[3]);					\
+      doit (_FP_MUL_MEAT_DW_4_wide_f_f1, _FP_MUL_MEAT_DW_4_wide_f_f0,	\
+	    X##_f[3], Y##_f[2]);					\
       __FP_FRAC_ADD_3 (_FP_FRAC_WORD_8 (R, 6), _FP_FRAC_WORD_8 (R, 5),	\
-		       _FP_FRAC_WORD_8 (R, 4), 0, _b_f1, _b_f0,		\
+		       _FP_FRAC_WORD_8 (R, 4), 0,			\
+		       _FP_MUL_MEAT_DW_4_wide_b_f1,			\
+		       _FP_MUL_MEAT_DW_4_wide_b_f0,			\
 		       0, _FP_FRAC_WORD_8 (R, 5), _FP_FRAC_WORD_8 (R, 4)); \
       __FP_FRAC_ADD_3 (_FP_FRAC_WORD_8 (R, 6), _FP_FRAC_WORD_8 (R, 5),	\
-		       _FP_FRAC_WORD_8 (R, 4), 0, _c_f1, _c_f0,		\
+		       _FP_FRAC_WORD_8 (R, 4), 0,			\
+		       _FP_MUL_MEAT_DW_4_wide_c_f1,			\
+		       _FP_MUL_MEAT_DW_4_wide_c_f0,			\
 		       _FP_FRAC_WORD_8 (R, 6), _FP_FRAC_WORD_8 (R, 5),	\
 		       _FP_FRAC_WORD_8 (R, 4));				\
       __FP_FRAC_ADD_3 (_FP_FRAC_WORD_8 (R, 6), _FP_FRAC_WORD_8 (R, 5),	\
-		       _FP_FRAC_WORD_8 (R, 4), 0, _d_f1, _d_f0,		\
+		       _FP_FRAC_WORD_8 (R, 4), 0,			\
+		       _FP_MUL_MEAT_DW_4_wide_d_f1,			\
+		       _FP_MUL_MEAT_DW_4_wide_d_f0,			\
 		       _FP_FRAC_WORD_8 (R, 6), _FP_FRAC_WORD_8 (R, 5),	\
 		       _FP_FRAC_WORD_8 (R, 4));				\
       __FP_FRAC_ADD_3 (_FP_FRAC_WORD_8 (R, 7), _FP_FRAC_WORD_8 (R, 6),	\
-		       _FP_FRAC_WORD_8 (R, 5), 0, _e_f1, _e_f0,		\
+		       _FP_FRAC_WORD_8 (R, 5), 0,			\
+		       _FP_MUL_MEAT_DW_4_wide_e_f1,			\
+		       _FP_MUL_MEAT_DW_4_wide_e_f0,			\
 		       0, _FP_FRAC_WORD_8 (R, 6), _FP_FRAC_WORD_8 (R, 5)); \
       __FP_FRAC_ADD_3 (_FP_FRAC_WORD_8 (R, 7), _FP_FRAC_WORD_8 (R, 6),	\
-		       _FP_FRAC_WORD_8 (R, 5), 0, _f_f1, _f_f0,		\
+		       _FP_FRAC_WORD_8 (R, 5), 0,			\
+		       _FP_MUL_MEAT_DW_4_wide_f_f1,			\
+		       _FP_MUL_MEAT_DW_4_wide_f_f0,			\
 		       _FP_FRAC_WORD_8 (R, 7), _FP_FRAC_WORD_8 (R, 6),	\
 		       _FP_FRAC_WORD_8 (R, 5));				\
-      doit (_b_f1, _b_f0, X##_f[3], Y##_f[3]);				\
+      doit (_FP_MUL_MEAT_DW_4_wide_b_f1, _FP_MUL_MEAT_DW_4_wide_b_f0,	\
+	    X##_f[3], Y##_f[3]);					\
       __FP_FRAC_ADD_2 (_FP_FRAC_WORD_8 (R, 7), _FP_FRAC_WORD_8 (R, 6),	\
-		       _b_f1, _b_f0,					\
+		       _FP_MUL_MEAT_DW_4_wide_b_f1,			\
+		       _FP_MUL_MEAT_DW_4_wide_b_f0,			\
 		       _FP_FRAC_WORD_8 (R, 7), _FP_FRAC_WORD_8 (R, 6));	\
     }									\
   while (0)
@@ -348,16 +426,19 @@ 
 #define _FP_MUL_MEAT_4_wide(wfracbits, R, X, Y, doit)			\
   do									\
     {									\
-      _FP_FRAC_DECL_8 (_z);						\
+      _FP_FRAC_DECL_8 (_FP_MUL_MEAT_4_wide_z);				\
 									\
-      _FP_MUL_MEAT_DW_4_wide (wfracbits, _z, X, Y, doit);		\
+      _FP_MUL_MEAT_DW_4_wide (wfracbits, _FP_MUL_MEAT_4_wide_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_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)); \
+      _FP_FRAC_SRS_8 (_FP_MUL_MEAT_4_wide_z, wfracbits-1, 2*wfracbits);	\
+      __FP_FRAC_SET_4 (R, _FP_FRAC_WORD_8 (_FP_MUL_MEAT_4_wide_z, 3),	\
+		       _FP_FRAC_WORD_8 (_FP_MUL_MEAT_4_wide_z, 2),	\
+		       _FP_FRAC_WORD_8 (_FP_MUL_MEAT_4_wide_z, 1),	\
+		       _FP_FRAC_WORD_8 (_FP_MUL_MEAT_4_wide_z, 0));	\
     }									\
   while (0)
 
@@ -371,16 +452,18 @@ 
 #define _FP_MUL_MEAT_4_gmp(wfracbits, R, X, Y)				\
   do									\
     {									\
-      _FP_FRAC_DECL_8 (_z);						\
+      _FP_FRAC_DECL_8 (_FP_MUL_MEAT_4_gmp_z);				\
 									\
-      _FP_MUL_MEAT_DW_4_gmp (wfracbits, _z, X, Y);			\
+      _FP_MUL_MEAT_DW_4_gmp (wfracbits, _FP_MUL_MEAT_4_gmp_z, 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_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)); \
+      _FP_FRAC_SRS_8 (_FP_MUL_MEAT_4_gmp_z, wfracbits-1, 2*wfracbits);	\
+      __FP_FRAC_SET_4 (R, _FP_FRAC_WORD_8 (_FP_MUL_MEAT_4_gmp_z, 3),	\
+		       _FP_FRAC_WORD_8 (_FP_MUL_MEAT_4_gmp_z, 2),	\
+		       _FP_FRAC_WORD_8 (_FP_MUL_MEAT_4_gmp_z, 1),	\
+		       _FP_FRAC_WORD_8 (_FP_MUL_MEAT_4_gmp_z, 0));	\
     }									\
   while (0)
 
@@ -391,12 +474,12 @@ 
 #define umul_ppppmnnn(p3, p2, p1, p0, m, n2, n1, n0)	\
   do							\
     {							\
-      UWtype _t;					\
+      UWtype umul_ppppmnnn_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);			\
+      umul_ppmm (p2, umul_ppppmnnn_t, m, n1);		\
+      __FP_FRAC_ADDI_2 (p2, p1, umul_ppppmnnn_t);	\
+      umul_ppmm (p3, umul_ppppmnnn_t, m, n2);		\
+      __FP_FRAC_ADDI_2 (p3, p2, umul_ppppmnnn_t);	\
     }							\
   while (0)
 
@@ -407,13 +490,14 @@ 
 #define _FP_DIV_MEAT_4_udiv(fs, R, X, Y)				\
   do									\
     {									\
-      int _i;								\
-      _FP_FRAC_DECL_4 (_n);						\
-      _FP_FRAC_DECL_4 (_m);						\
-      _FP_FRAC_SET_4 (_n, _FP_ZEROFRAC_4);				\
+      int _FP_DIV_MEAT_4_udiv_i;					\
+      _FP_FRAC_DECL_4 (_FP_DIV_MEAT_4_udiv_n);				\
+      _FP_FRAC_DECL_4 (_FP_DIV_MEAT_4_udiv_m);				\
+      _FP_FRAC_SET_4 (_FP_DIV_MEAT_4_udiv_n, _FP_ZEROFRAC_4);		\
       if (_FP_FRAC_GE_4 (X, Y))						\
 	{								\
-	  _n_f[3] = X##_f[0] << (_FP_W_TYPE_SIZE - 1);			\
+	  _FP_DIV_MEAT_4_udiv_n_f[3]					\
+	    = X##_f[0] << (_FP_W_TYPE_SIZE - 1);			\
 	  _FP_FRAC_SRL_4 (X, 1);					\
 	}								\
       else								\
@@ -423,49 +507,58 @@ 
 	 denominator set. */						\
       _FP_FRAC_SLL_4 (Y, _FP_WFRACXBITS_##fs);				\
 									\
-      for (_i = 3; ; _i--)						\
+      for (_FP_DIV_MEAT_4_udiv_i = 3; ; _FP_DIV_MEAT_4_udiv_i--)	\
 	{								\
 	  if (X##_f[3] == Y##_f[3])					\
 	    {								\
 	      /* This is a special case, not an optimization		\
 		 (X##_f[3]/Y##_f[3] would not fit into UWtype).		\
-		 As X## is guaranteed to be < Y,  R##_f[_i] can be either \
+		 As X## is guaranteed to be < Y,			\
+		 R##_f[_FP_DIV_MEAT_4_udiv_i] can be either		\
 		 (UWtype)-1 or (UWtype)-2.  */				\
-	      R##_f[_i] = -1;						\
-	      if (!_i)							\
+	      R##_f[_FP_DIV_MEAT_4_udiv_i] = -1;			\
+	      if (!_FP_DIV_MEAT_4_udiv_i)				\
 		break;							\
 	      __FP_FRAC_SUB_4 (X##_f[3], X##_f[2], X##_f[1], X##_f[0],	\
 			       Y##_f[2], Y##_f[1], Y##_f[0], 0,		\
-			       X##_f[2], X##_f[1], X##_f[0], _n_f[_i]);	\
+			       X##_f[2], X##_f[1], X##_f[0],		\
+			       _FP_DIV_MEAT_4_udiv_n_f[_FP_DIV_MEAT_4_udiv_i]); \
 	      _FP_FRAC_SUB_4 (X, Y, X);					\
 	      if (X##_f[3] > Y##_f[3])					\
 		{							\
-		  R##_f[_i] = -2;					\
+		  R##_f[_FP_DIV_MEAT_4_udiv_i] = -2;			\
 		  _FP_FRAC_ADD_4 (X, Y, X);				\
 		}							\
 	    }								\
 	  else								\
 	    {								\
-	      udiv_qrnnd (R##_f[_i], X##_f[3], X##_f[3], X##_f[2], Y##_f[3]); \
-	      umul_ppppmnnn (_m_f[3], _m_f[2], _m_f[1], _m_f[0],	\
-			     R##_f[_i], Y##_f[2], Y##_f[1], Y##_f[0]);	\
+	      udiv_qrnnd (R##_f[_FP_DIV_MEAT_4_udiv_i],			\
+			  X##_f[3], X##_f[3], X##_f[2], Y##_f[3]);	\
+	      umul_ppppmnnn (_FP_DIV_MEAT_4_udiv_m_f[3],		\
+			     _FP_DIV_MEAT_4_udiv_m_f[2],		\
+			     _FP_DIV_MEAT_4_udiv_m_f[1],		\
+			     _FP_DIV_MEAT_4_udiv_m_f[0],		\
+			     R##_f[_FP_DIV_MEAT_4_udiv_i],		\
+			     Y##_f[2], Y##_f[1], Y##_f[0]);		\
 	      X##_f[2] = X##_f[1];					\
 	      X##_f[1] = X##_f[0];					\
-	      X##_f[0] = _n_f[_i];					\
-	      if (_FP_FRAC_GT_4 (_m, X))				\
+	      X##_f[0]							\
+		= _FP_DIV_MEAT_4_udiv_n_f[_FP_DIV_MEAT_4_udiv_i];	\
+	      if (_FP_FRAC_GT_4 (_FP_DIV_MEAT_4_udiv_m, X))		\
 		{							\
-		  R##_f[_i]--;						\
+		  R##_f[_FP_DIV_MEAT_4_udiv_i]--;			\
 		  _FP_FRAC_ADD_4 (X, Y, X);				\
-		  if (_FP_FRAC_GE_4 (X, Y) && _FP_FRAC_GT_4 (_m, X))	\
+		  if (_FP_FRAC_GE_4 (X, Y)				\
+		      && _FP_FRAC_GT_4 (_FP_DIV_MEAT_4_udiv_m, X))	\
 		    {							\
-		      R##_f[_i]--;					\
+		      R##_f[_FP_DIV_MEAT_4_udiv_i]--;			\
 		      _FP_FRAC_ADD_4 (X, Y, X);				\
 		    }							\
 		}							\
-	      _FP_FRAC_DEC_4 (X, _m);					\
-	      if (!_i)							\
+	      _FP_FRAC_DEC_4 (X, _FP_DIV_MEAT_4_udiv_m);		\
+	      if (!_FP_DIV_MEAT_4_udiv_i)				\
 		{							\
-		  if (!_FP_FRAC_EQ_4 (X, _m))				\
+		  if (!_FP_FRAC_EQ_4 (X, _FP_DIV_MEAT_4_udiv_m))	\
 		    R##_f[0] |= _FP_WORK_STICKY;			\
 		  break;						\
 		}							\
@@ -591,18 +684,19 @@ 
 # define __FP_FRAC_ADD_4(r3, r2, r1, r0, x3, x2, x1, x0, y3, y2, y1, y0) \
   do									\
     {									\
-      _FP_W_TYPE _c1, _c2, _c3;						\
+      _FP_W_TYPE __FP_FRAC_ADD_4_c1, __FP_FRAC_ADD_4_c2;		\
+      _FP_W_TYPE __FP_FRAC_ADD_4_c3;					\
       r0 = x0 + y0;							\
-      _c1 = r0 < x0;							\
+      __FP_FRAC_ADD_4_c1 = r0 < x0;					\
       r1 = x1 + y1;							\
-      _c2 = r1 < x1;							\
-      r1 += _c1;							\
-      _c2 |= r1 < _c1;							\
+      __FP_FRAC_ADD_4_c2 = r1 < x1;					\
+      r1 += __FP_FRAC_ADD_4_c1;						\
+      __FP_FRAC_ADD_4_c2 |= r1 < __FP_FRAC_ADD_4_c1;			\
       r2 = x2 + y2;							\
-      _c3 = r2 < x2;							\
-      r2 += _c2;							\
-      _c3 |= r2 < _c2;							\
-      r3 = x3 + y3 + _c3;						\
+      __FP_FRAC_ADD_4_c3 = r2 < x2;					\
+      r2 += __FP_FRAC_ADD_4_c2;						\
+      __FP_FRAC_ADD_4_c3 |= r2 < __FP_FRAC_ADD_4_c2;			\
+      r3 = x3 + y3 + __FP_FRAC_ADD_4_c3;				\
     }									\
   while (0)
 #endif
@@ -611,14 +705,14 @@ 
 # define __FP_FRAC_SUB_3(r2, r1, r0, x2, x1, x0, y2, y1, y0)	\
   do								\
     {								\
-      _FP_W_TYPE _c1, _c2;					\
+      _FP_W_TYPE __FP_FRAC_SUB_3_c1, __FP_FRAC_SUB_3_c2;	\
       r0 = x0 - y0;						\
-      _c1 = r0 > x0;						\
+      __FP_FRAC_SUB_3_c1 = r0 > x0;				\
       r1 = x1 - y1;						\
-      _c2 = r1 > x1;						\
-      r1 -= _c1;						\
-      _c2 |= _c1 && (y1 == x1);					\
-      r2 = x2 - y2 - _c2;					\
+      __FP_FRAC_SUB_3_c2 = r1 > x1;				\
+      r1 -= __FP_FRAC_SUB_3_c1;					\
+      __FP_FRAC_SUB_3_c2 |= __FP_FRAC_SUB_3_c1 && (y1 == x1);	\
+      r2 = x2 - y2 - __FP_FRAC_SUB_3_c2;			\
     }								\
   while (0)
 #endif
@@ -627,18 +721,19 @@ 
 # define __FP_FRAC_SUB_4(r3, r2, r1, r0, x3, x2, x1, x0, y3, y2, y1, y0) \
   do									\
     {									\
-      _FP_W_TYPE _c1, _c2, _c3;						\
+      _FP_W_TYPE __FP_FRAC_SUB_4_c1, __FP_FRAC_SUB_4_c2;		\
+      _FP_W_TYPE __FP_FRAC_SUB_4_c3;					\
       r0 = x0 - y0;							\
-      _c1 = r0 > x0;							\
+      __FP_FRAC_SUB_4_c1 = r0 > x0;					\
       r1 = x1 - y1;							\
-      _c2 = r1 > x1;							\
-      r1 -= _c1;							\
-      _c2 |= _c1 && (y1 == x1);						\
+      __FP_FRAC_SUB_4_c2 = r1 > x1;					\
+      r1 -= __FP_FRAC_SUB_4_c1;						\
+      __FP_FRAC_SUB_4_c2 |= __FP_FRAC_SUB_4_c1 && (y1 == x1);		\
       r2 = x2 - y2;							\
-      _c3 = r2 > x2;							\
-      r2 -= _c2;							\
-      _c3 |= _c2 && (y2 == x2);						\
-      r3 = x3 - y3 - _c3;						\
+      __FP_FRAC_SUB_4_c3 = r2 > x2;					\
+      r2 -= __FP_FRAC_SUB_4_c2;						\
+      __FP_FRAC_SUB_4_c3 |= __FP_FRAC_SUB_4_c2 && (y2 == x2);		\
+      r3 = x3 - y3 - __FP_FRAC_SUB_4_c3;				\
     }									\
   while (0)
 #endif
@@ -647,36 +742,47 @@ 
 # define __FP_FRAC_DEC_3(x2, x1, x0, y2, y1, y0)		\
   do								\
     {								\
-      UWtype _t0, _t1, _t2;					\
-      _t0 = x0, _t1 = x1, _t2 = x2;				\
-      __FP_FRAC_SUB_3 (x2, x1, x0, _t2, _t1, _t0, y2, y1, y0);	\
+      UWtype __FP_FRAC_DEC_3_t0, __FP_FRAC_DEC_3_t1;		\
+      UWtype __FP_FRAC_DEC_3_t2;				\
+      __FP_FRAC_DEC_3_t0 = x0;					\
+      __FP_FRAC_DEC_3_t1 = x1;					\
+      __FP_FRAC_DEC_3_t2 = x2;					\
+      __FP_FRAC_SUB_3 (x2, x1, x0, __FP_FRAC_DEC_3_t2,		\
+		       __FP_FRAC_DEC_3_t1, __FP_FRAC_DEC_3_t0,	\
+		       y2, y1, y0);				\
     }								\
   while (0)
 #endif
 
 #ifndef __FP_FRAC_DEC_4
-# define __FP_FRAC_DEC_4(x3, x2, x1, x0, y3, y2, y1, y0)		\
-  do									\
-    {									\
-      UWtype _t0, _t1, _t2, _t3;					\
-      _t0 = x0, _t1 = x1, _t2 = x2, _t3 = x3;				\
-      __FP_FRAC_SUB_4 (x3, x2, x1, x0, _t3, _t2, _t1, _t0, y3, y2, y1, y0); \
-    }									\
+# define __FP_FRAC_DEC_4(x3, x2, x1, x0, y3, y2, y1, y0)	\
+  do								\
+    {								\
+      UWtype __FP_FRAC_DEC_4_t0, __FP_FRAC_DEC_4_t1;		\
+      UWtype __FP_FRAC_DEC_4_t2, __FP_FRAC_DEC_4_t3;		\
+      __FP_FRAC_DEC_4_t0 = x0;					\
+      __FP_FRAC_DEC_4_t1 = x1;					\
+      __FP_FRAC_DEC_4_t2 = x2;					\
+      __FP_FRAC_DEC_4_t3 = x3;					\
+      __FP_FRAC_SUB_4 (x3, x2, x1, x0, __FP_FRAC_DEC_4_t3,	\
+		       __FP_FRAC_DEC_4_t2, __FP_FRAC_DEC_4_t1,	\
+		       __FP_FRAC_DEC_4_t0, y3, y2, y1, y0);	\
+    }								\
   while (0)
 #endif
 
 #ifndef __FP_FRAC_ADDI_4
-# define __FP_FRAC_ADDI_4(x3, x2, x1, x0, i)	\
-  do						\
-    {						\
-      UWtype _t;				\
-      _t = ((x0 += i) < i);			\
-      x1 += _t;					\
-      _t = (x1 < _t);				\
-      x2 += _t;					\
-      _t = (x2 < _t);				\
-      x3 += _t;					\
-    }						\
+# define __FP_FRAC_ADDI_4(x3, x2, x1, x0, i)		\
+  do							\
+    {							\
+      UWtype __FP_FRAC_ADDI_4_t;			\
+      __FP_FRAC_ADDI_4_t = ((x0 += i) < i);		\
+      x1 += __FP_FRAC_ADDI_4_t;				\
+      __FP_FRAC_ADDI_4_t = (x1 < __FP_FRAC_ADDI_4_t);	\
+      x2 += __FP_FRAC_ADDI_4_t;				\
+      __FP_FRAC_ADDI_4_t = (x2 < __FP_FRAC_ADDI_4_t);	\
+      x3 += __FP_FRAC_ADDI_4_t;				\
+    }							\
   while (0)
 #endif
 
diff --git a/soft-fp/op-8.h b/soft-fp/op-8.h
index a50cd7b..c966ee2 100644
--- a/soft-fp/op-8.h
+++ b/soft-fp/op-8.h
@@ -36,48 +36,66 @@ 
 #define _FP_FRAC_LOW_8(X)	(X##_f[0])
 #define _FP_FRAC_WORD_8(X, w)	(X##_f[w])
 
-#define _FP_FRAC_SLL_8(X, N)				\
-  do							\
-    {							\
-      _FP_I_TYPE _up, _down, _skip, _i;			\
-      _skip = (N) / _FP_W_TYPE_SIZE;			\
-      _up = (N) % _FP_W_TYPE_SIZE;			\
-      _down = _FP_W_TYPE_SIZE - _up;			\
-      if (!_up)						\
-	for (_i = 7; _i >= _skip; --_i)			\
-	  X##_f[_i] = X##_f[_i-_skip];			\
-      else						\
-	{						\
-	  for (_i = 7; _i > _skip; --_i)		\
-	    X##_f[_i] = (X##_f[_i-_skip] << _up		\
-			 | X##_f[_i-_skip-1] >> _down);	\
-	  X##_f[_i--] = X##_f[0] << _up;		\
-	}						\
-      for (; _i >= 0; --_i)				\
-	X##_f[_i] = 0;					\
-    }							\
+#define _FP_FRAC_SLL_8(X, N)						\
+  do									\
+    {									\
+      _FP_I_TYPE _FP_FRAC_SLL_8_up, _FP_FRAC_SLL_8_down;		\
+      _FP_I_TYPE _FP_FRAC_SLL_8_skip, _FP_FRAC_SLL_8_i;			\
+      _FP_FRAC_SLL_8_skip = (N) / _FP_W_TYPE_SIZE;			\
+      _FP_FRAC_SLL_8_up = (N) % _FP_W_TYPE_SIZE;			\
+      _FP_FRAC_SLL_8_down = _FP_W_TYPE_SIZE - _FP_FRAC_SLL_8_up;	\
+      if (!_FP_FRAC_SLL_8_up)						\
+	for (_FP_FRAC_SLL_8_i = 7;					\
+	     _FP_FRAC_SLL_8_i >= _FP_FRAC_SLL_8_skip;			\
+	     --_FP_FRAC_SLL_8_i)					\
+	  X##_f[_FP_FRAC_SLL_8_i]					\
+	    = X##_f[_FP_FRAC_SLL_8_i-_FP_FRAC_SLL_8_skip];		\
+      else								\
+	{								\
+	  for (_FP_FRAC_SLL_8_i = 7;					\
+	       _FP_FRAC_SLL_8_i > _FP_FRAC_SLL_8_skip;			\
+	       --_FP_FRAC_SLL_8_i)					\
+	    X##_f[_FP_FRAC_SLL_8_i]					\
+	      = ((X##_f[_FP_FRAC_SLL_8_i-_FP_FRAC_SLL_8_skip]		\
+		  << _FP_FRAC_SLL_8_up)					\
+		 | (X##_f[_FP_FRAC_SLL_8_i-_FP_FRAC_SLL_8_skip-1]	\
+		    >> _FP_FRAC_SLL_8_down));				\
+	  X##_f[_FP_FRAC_SLL_8_i--] = X##_f[0] << _FP_FRAC_SLL_8_up;	\
+	}								\
+      for (; _FP_FRAC_SLL_8_i >= 0; --_FP_FRAC_SLL_8_i)			\
+	X##_f[_FP_FRAC_SLL_8_i] = 0;					\
+    }									\
   while (0)
 
-#define _FP_FRAC_SRL_8(X, N)				\
-  do							\
-    {							\
-      _FP_I_TYPE _up, _down, _skip, _i;			\
-      _skip = (N) / _FP_W_TYPE_SIZE;			\
-      _down = (N) % _FP_W_TYPE_SIZE;			\
-      _up = _FP_W_TYPE_SIZE - _down;			\
-      if (!_down)					\
-	for (_i = 0; _i <= 7-_skip; ++_i)		\
-	  X##_f[_i] = X##_f[_i+_skip];			\
-      else						\
-	{						\
-	  for (_i = 0; _i < 7-_skip; ++_i)		\
-	    X##_f[_i] = (X##_f[_i+_skip] >> _down	\
-			 | X##_f[_i+_skip+1] << _up);	\
-	  X##_f[_i++] = X##_f[7] >> _down;		\
-	}						\
-      for (; _i < 8; ++_i)				\
-	X##_f[_i] = 0;					\
-    }							\
+#define _FP_FRAC_SRL_8(X, N)						\
+  do									\
+    {									\
+      _FP_I_TYPE _FP_FRAC_SRL_8_up, _FP_FRAC_SRL_8_down;		\
+      _FP_I_TYPE _FP_FRAC_SRL_8_skip, _FP_FRAC_SRL_8_i;			\
+      _FP_FRAC_SRL_8_skip = (N) / _FP_W_TYPE_SIZE;			\
+      _FP_FRAC_SRL_8_down = (N) % _FP_W_TYPE_SIZE;			\
+      _FP_FRAC_SRL_8_up = _FP_W_TYPE_SIZE - _FP_FRAC_SRL_8_down;	\
+      if (!_FP_FRAC_SRL_8_down)						\
+	for (_FP_FRAC_SRL_8_i = 0;					\
+	     _FP_FRAC_SRL_8_i <= 7-_FP_FRAC_SRL_8_skip;			\
+	     ++_FP_FRAC_SRL_8_i)					\
+	  X##_f[_FP_FRAC_SRL_8_i]					\
+	    = X##_f[_FP_FRAC_SRL_8_i+_FP_FRAC_SRL_8_skip];		\
+      else								\
+	{								\
+	  for (_FP_FRAC_SRL_8_i = 0;					\
+	       _FP_FRAC_SRL_8_i < 7-_FP_FRAC_SRL_8_skip;		\
+	       ++_FP_FRAC_SRL_8_i)					\
+	    X##_f[_FP_FRAC_SRL_8_i]					\
+	      = ((X##_f[_FP_FRAC_SRL_8_i+_FP_FRAC_SRL_8_skip]		\
+		  >> _FP_FRAC_SRL_8_down)				\
+		 | (X##_f[_FP_FRAC_SRL_8_i+_FP_FRAC_SRL_8_skip+1]	\
+		    << _FP_FRAC_SRL_8_up));				\
+	  X##_f[_FP_FRAC_SRL_8_i++] = X##_f[7] >> _FP_FRAC_SRL_8_down;	\
+	}								\
+      for (; _FP_FRAC_SRL_8_i < 8; ++_FP_FRAC_SRL_8_i)			\
+	X##_f[_FP_FRAC_SRL_8_i] = 0;					\
+    }									\
   while (0)
 
 
@@ -89,28 +107,40 @@ 
 #define _FP_FRAC_SRS_8(X, N, size)					\
   do									\
     {									\
-      _FP_I_TYPE _up, _down, _skip, _i;					\
-      _FP_W_TYPE _s;							\
-      _skip = (N) / _FP_W_TYPE_SIZE;					\
-      _down = (N) % _FP_W_TYPE_SIZE;					\
-      _up = _FP_W_TYPE_SIZE - _down;					\
-      for (_s = _i = 0; _i < _skip; ++_i)				\
-	_s |= X##_f[_i];						\
-      if (!_down)							\
-	for (_i = 0; _i <= 7-_skip; ++_i)				\
-	  X##_f[_i] = X##_f[_i+_skip];					\
+      _FP_I_TYPE _FP_FRAC_SRS_8_up, _FP_FRAC_SRS_8_down;		\
+      _FP_I_TYPE _FP_FRAC_SRS_8_skip, _FP_FRAC_SRS_8_i;			\
+      _FP_W_TYPE _FP_FRAC_SRS_8_s;					\
+      _FP_FRAC_SRS_8_skip = (N) / _FP_W_TYPE_SIZE;			\
+      _FP_FRAC_SRS_8_down = (N) % _FP_W_TYPE_SIZE;			\
+      _FP_FRAC_SRS_8_up = _FP_W_TYPE_SIZE - _FP_FRAC_SRS_8_down;	\
+      for (_FP_FRAC_SRS_8_s = _FP_FRAC_SRS_8_i = 0;			\
+	   _FP_FRAC_SRS_8_i < _FP_FRAC_SRS_8_skip;			\
+	   ++_FP_FRAC_SRS_8_i)						\
+	_FP_FRAC_SRS_8_s |= X##_f[_FP_FRAC_SRS_8_i];			\
+      if (!_FP_FRAC_SRS_8_down)						\
+	for (_FP_FRAC_SRS_8_i = 0;					\
+	     _FP_FRAC_SRS_8_i <= 7-_FP_FRAC_SRS_8_skip;			\
+	     ++_FP_FRAC_SRS_8_i)					\
+	  X##_f[_FP_FRAC_SRS_8_i]					\
+	    = X##_f[_FP_FRAC_SRS_8_i+_FP_FRAC_SRS_8_skip];		\
       else								\
 	{								\
-	  _s |= X##_f[_i] << _up;					\
-	  for (_i = 0; _i < 7-_skip; ++_i)				\
-	    X##_f[_i] = (X##_f[_i+_skip] >> _down			\
-			 | X##_f[_i+_skip+1] << _up);			\
-	  X##_f[_i++] = X##_f[7] >> _down;				\
+	  _FP_FRAC_SRS_8_s						\
+	    |= X##_f[_FP_FRAC_SRS_8_i] << _FP_FRAC_SRS_8_up;		\
+	  for (_FP_FRAC_SRS_8_i = 0;					\
+	       _FP_FRAC_SRS_8_i < 7-_FP_FRAC_SRS_8_skip;		\
+	       ++_FP_FRAC_SRS_8_i)					\
+	    X##_f[_FP_FRAC_SRS_8_i]					\
+	      = ((X##_f[_FP_FRAC_SRS_8_i+_FP_FRAC_SRS_8_skip]		\
+		  >> _FP_FRAC_SRS_8_down)				\
+		 | (X##_f[_FP_FRAC_SRS_8_i+_FP_FRAC_SRS_8_skip+1]	\
+		    << _FP_FRAC_SRS_8_up));				\
+	  X##_f[_FP_FRAC_SRS_8_i++] = X##_f[7] >> _FP_FRAC_SRS_8_down;	\
 	}								\
-      for (; _i < 8; ++_i)						\
-	X##_f[_i] = 0;							\
+      for (; _FP_FRAC_SRS_8_i < 8; ++_FP_FRAC_SRS_8_i)			\
+	X##_f[_FP_FRAC_SRS_8_i] = 0;					\
       /* don't fix the LSB until the very end when we're sure f[0] is	\
 	 stable */							\
-      X##_f[0] |= (_s != 0);						\
+      X##_f[0] |= (_FP_FRAC_SRS_8_s != 0);				\
     }									\
   while (0)