This is the mail archive of the libc-alpha@sourceware.org mailing list for the glibc project.
| Index Nav: | [Date Index] [Subject Index] [Author Index] [Thread Index] | |
|---|---|---|
| Message Nav: | [Date Prev] [Date Next] | [Thread Prev] [Thread Next] |
| Other format: | [Raw text] | |
On 18 June 2014 11:55, Joseph S. Myers <joseph@codesourcery.com> wrote:
> In <https://sourceware.org/ml/libc-alpha/2013-06/msg00851.html>, I
> fixed a bug caused by multiple soft-fp macros using the same variable
> names, resulting in shadowing when one macro called another that used
> the same variable name, with an argument involving the variable in the
> outer macro. The fix was to rename the local variables so their names
> included the containing macro name, to ensure uniqueness.
>
> I noted then that this would make sense more systematically for all
> variables in any soft-fp macro. Since then, I've used such variable
> names in new soft-fp macros. This patch now converts existing macros
> in extended.h and op-common.h to use this convention. (op-[1248].h
> are intended to be converted separately.)
>
> (Name conflicts could arise for label names as well, but because those
> are function-scope in C any such conflict will give an immediate
> compile error rather than a subtle bug, so there's no need for
> preemptive renaming in that case.)
>
> Tested for powerpc32 (soft-float) and mips64 that this makes no change
> to the disassembly of installed shared libraries.
>
> 2014-06-18 Joseph Myers <joseph@codesourcery.com>
>
> * soft-fp/extended.h (FP_UNPACK_RAW_E): Rename local variables to
> include macro name.
> (FP_UNPACK_RAW_EP): Likewise.
> (FP_PACK_RAW_E): Likewise.
> (FP_PACK_RAW_EP): Likewise.
> * soft-fp/op-common.h (_FP_UNPACK_CANONICAL): Likewise.
> (_FP_ISSIGNAN): Likewise.
> (_FP_ADD_INTERNAL): Likewise.
> (_FP_FMA): Likewise.
> (_FP_CMP): Likewise.
> (_FP_SQRT): Likewise.
> (_FP_TO_INT): Likewise.
> (_FP_FROM_INT): Likewise.
> (FP_EXTEND): Likewise.
> (_FP_DIV_MEAT_N_loop): Likewise.
This looks ok to me.
> diff --git a/soft-fp/extended.h b/soft-fp/extended.h
> index 69a5a06..940bdf1 100644
> --- a/soft-fp/extended.h
> +++ b/soft-fp/extended.h
> @@ -91,70 +91,72 @@ union _FP_UNION_E
>
> # define FP_DECL_E(X) _FP_DECL (4, X)
>
> -# define FP_UNPACK_RAW_E(X, val) \
> - do \
> - { \
> - union _FP_UNION_E _flo; \
> - _flo.flt = (val); \
> - \
> - X##_f[2] = 0; \
> - X##_f[3] = 0; \
> - X##_f[0] = _flo.bits.frac0; \
> - X##_f[1] = _flo.bits.frac1; \
> - X##_e = _flo.bits.exp; \
> - X##_s = _flo.bits.sign; \
> - } \
> +# define FP_UNPACK_RAW_E(X, val) \
> + do \
> + { \
> + union _FP_UNION_E FP_UNPACK_RAW_E_flo; \
> + FP_UNPACK_RAW_E_flo.flt = (val); \
> + \
> + X##_f[2] = 0; \
> + X##_f[3] = 0; \
> + X##_f[0] = FP_UNPACK_RAW_E_flo.bits.frac0; \
> + X##_f[1] = FP_UNPACK_RAW_E_flo.bits.frac1; \
> + X##_e = FP_UNPACK_RAW_E_flo.bits.exp; \
> + X##_s = FP_UNPACK_RAW_E_flo.bits.sign; \
> + } \
> while (0)
>
> -# define FP_UNPACK_RAW_EP(X, val) \
> - do \
> - { \
> - union _FP_UNION_E *_flo = (union _FP_UNION_E *) (val); \
> - \
> - X##_f[2] = 0; \
> - X##_f[3] = 0; \
> - X##_f[0] = _flo->bits.frac0; \
> - X##_f[1] = _flo->bits.frac1; \
> - X##_e = _flo->bits.exp; \
> - X##_s = _flo->bits.sign; \
> - } \
> +# define FP_UNPACK_RAW_EP(X, val) \
> + do \
> + { \
> + union _FP_UNION_E *FP_UNPACK_RAW_EP_flo \
> + = (union _FP_UNION_E *) (val); \
> + \
> + X##_f[2] = 0; \
> + X##_f[3] = 0; \
> + X##_f[0] = FP_UNPACK_RAW_EP_flo->bits.frac0; \
> + X##_f[1] = FP_UNPACK_RAW_EP_flo->bits.frac1; \
> + X##_e = FP_UNPACK_RAW_EP_flo->bits.exp; \
> + X##_s = FP_UNPACK_RAW_EP_flo->bits.sign; \
> + } \
> while (0)
>
> # define FP_PACK_RAW_E(val, X) \
> do \
> { \
> - union _FP_UNION_E _flo; \
> + union _FP_UNION_E FP_PACK_RAW_E_flo; \
> \
> if (X##_e) \
> X##_f[1] |= _FP_IMPLBIT_E; \
> else \
> X##_f[1] &= ~(_FP_IMPLBIT_E); \
> - _flo.bits.frac0 = X##_f[0]; \
> - _flo.bits.frac1 = X##_f[1]; \
> - _flo.bits.exp = X##_e; \
> - _flo.bits.sign = X##_s; \
> + FP_PACK_RAW_E_flo.bits.frac0 = X##_f[0]; \
> + FP_PACK_RAW_E_flo.bits.frac1 = X##_f[1]; \
> + FP_PACK_RAW_E_flo.bits.exp = X##_e; \
> + FP_PACK_RAW_E_flo.bits.sign = X##_s; \
> \
> - (val) = _flo.flt; \
> + (val) = FP_PACK_RAW_E_flo.flt; \
> } \
> while (0)
>
> -# define FP_PACK_RAW_EP(val, X) \
> - do \
> - { \
> - if (!FP_INHIBIT_RESULTS) \
> - { \
> - union _FP_UNION_E *_flo = (union _FP_UNION_E *) (val); \
> - \
> - if (X##_e) \
> - X##_f[1] |= _FP_IMPLBIT_E; \
> - else \
> - X##_f[1] &= ~(_FP_IMPLBIT_E); \
> - _flo->bits.frac0 = X##_f[0]; \
> - _flo->bits.frac1 = X##_f[1]; \
> - _flo->bits.exp = X##_e; \
> - _flo->bits.sign = X##_s; \
> - } \
> - } \
> +# define FP_PACK_RAW_EP(val, X) \
> + do \
> + { \
> + if (!FP_INHIBIT_RESULTS) \
> + { \
> + union _FP_UNION_E *FP_PACK_RAW_EP_flo \
> + = (union _FP_UNION_E *) (val); \
> + \
> + if (X##_e) \
> + X##_f[1] |= _FP_IMPLBIT_E; \
> + else \
> + X##_f[1] &= ~(_FP_IMPLBIT_E); \
> + FP_PACK_RAW_EP_flo->bits.frac0 = X##_f[0]; \
> + FP_PACK_RAW_EP_flo->bits.frac1 = X##_f[1]; \
> + FP_PACK_RAW_EP_flo->bits.exp = X##_e; \
> + FP_PACK_RAW_EP_flo->bits.sign = X##_s; \
> + } \
> + } \
> while (0)
>
> # define FP_UNPACK_E(X, val) \
> @@ -323,61 +325,63 @@ union _FP_UNION_E
> # define FP_UNPACK_RAW_E(X, val) \
> do \
> { \
> - union _FP_UNION_E _flo; \
> - _flo.flt = (val); \
> + union _FP_UNION_E FP_UNPACK_RAW_E_flo; \
> + FP_UNPACK_RAW_E_flo.flt = (val); \
> \
> - X##_f0 = _flo.bits.frac; \
> + X##_f0 = FP_UNPACK_RAW_E_flo.bits.frac; \
> X##_f1 = 0; \
> - X##_e = _flo.bits.exp; \
> - X##_s = _flo.bits.sign; \
> + X##_e = FP_UNPACK_RAW_E_flo.bits.exp; \
> + X##_s = FP_UNPACK_RAW_E_flo.bits.sign; \
> } \
> while (0)
>
> -# define FP_UNPACK_RAW_EP(X, val) \
> - do \
> - { \
> - union _FP_UNION_E *_flo = (union _FP_UNION_E *) (val); \
> - \
> - X##_f0 = _flo->bits.frac; \
> - X##_f1 = 0; \
> - X##_e = _flo->bits.exp; \
> - X##_s = _flo->bits.sign; \
> - } \
> +# define FP_UNPACK_RAW_EP(X, val) \
> + do \
> + { \
> + union _FP_UNION_E *FP_UNPACK_RAW_EP_flo \
> + = (union _FP_UNION_E *) (val); \
> + \
> + X##_f0 = FP_UNPACK_RAW_EP_flo->bits.frac; \
> + X##_f1 = 0; \
> + X##_e = FP_UNPACK_RAW_EP_flo->bits.exp; \
> + X##_s = FP_UNPACK_RAW_EP_flo->bits.sign; \
> + } \
> while (0)
>
> # define FP_PACK_RAW_E(val, X) \
> do \
> { \
> - union _FP_UNION_E _flo; \
> + union _FP_UNION_E FP_PACK_RAW_E_flo; \
> \
> if (X##_e) \
> X##_f0 |= _FP_IMPLBIT_E; \
> else \
> X##_f0 &= ~(_FP_IMPLBIT_E); \
> - _flo.bits.frac = X##_f0; \
> - _flo.bits.exp = X##_e; \
> - _flo.bits.sign = X##_s; \
> + FP_PACK_RAW_E_flo.bits.frac = X##_f0; \
> + FP_PACK_RAW_E_flo.bits.exp = X##_e; \
> + FP_PACK_RAW_E_flo.bits.sign = X##_s; \
> \
> - (val) = _flo.flt; \
> + (val) = FP_PACK_RAW_E_flo.flt; \
> } \
> while (0)
>
> -# define FP_PACK_RAW_EP(fs, val, X) \
> - do \
> - { \
> - if (!FP_INHIBIT_RESULTS) \
> - { \
> - union _FP_UNION_E *_flo = (union _FP_UNION_E *) (val); \
> - \
> - if (X##_e) \
> - X##_f0 |= _FP_IMPLBIT_E; \
> - else \
> - X##_f0 &= ~(_FP_IMPLBIT_E); \
> - _flo->bits.frac = X##_f0; \
> - _flo->bits.exp = X##_e; \
> - _flo->bits.sign = X##_s; \
> - } \
> - } \
> +# define FP_PACK_RAW_EP(fs, val, X) \
> + do \
> + { \
> + if (!FP_INHIBIT_RESULTS) \
> + { \
> + union _FP_UNION_E *FP_PACK_RAW_EP_flo \
> + = (union _FP_UNION_E *) (val); \
> + \
> + if (X##_e) \
> + X##_f0 |= _FP_IMPLBIT_E; \
> + else \
> + X##_f0 &= ~(_FP_IMPLBIT_E); \
> + FP_PACK_RAW_EP_flo->bits.frac = X##_f0; \
> + FP_PACK_RAW_EP_flo->bits.exp = X##_e; \
> + FP_PACK_RAW_EP_flo->bits.sign = X##_s; \
> + } \
> + } \
> while (0)
>
>
> diff --git a/soft-fp/op-common.h b/soft-fp/op-common.h
> index 6f8c1f3..5f37a32 100644
> --- a/soft-fp/op-common.h
> +++ b/soft-fp/op-common.h
> @@ -68,11 +68,14 @@
> else \
> { \
> /* a denormalized number */ \
> - _FP_I_TYPE _shift; \
> - _FP_FRAC_CLZ_##wc (_shift, X); \
> - _shift -= _FP_FRACXBITS_##fs; \
> - _FP_FRAC_SLL_##wc (X, (_shift+_FP_WORKBITS)); \
> - X##_e -= _FP_EXPBIAS_##fs - 1 + _shift; \
> + _FP_I_TYPE _FP_UNPACK_CANONICAL_shift; \
> + _FP_FRAC_CLZ_##wc (_FP_UNPACK_CANONICAL_shift, \
> + X); \
> + _FP_UNPACK_CANONICAL_shift -= _FP_FRACXBITS_##fs; \
> + _FP_FRAC_SLL_##wc (X, (_FP_UNPACK_CANONICAL_shift \
> + + _FP_WORKBITS)); \
> + X##_e -= (_FP_EXPBIAS_##fs - 1 \
> + + _FP_UNPACK_CANONICAL_shift); \
> X##_c = FP_CLS_NORMAL; \
> FP_SET_EXCEPTION (FP_EX_DENORM); \
> } \
> @@ -371,14 +374,14 @@
> */
> #define _FP_ISSIGNAN(fs, wc, X) \
> ({ \
> - int __ret = 0; \
> + int _FP_ISSIGNAN_ret = 0; \
> if (X##_e == _FP_EXPMAX_##fs) \
> { \
> if (!_FP_FRAC_ZEROP_##wc (X) \
> && _FP_FRAC_SNANP (fs, X)) \
> - __ret = 1; \
> + _FP_ISSIGNAN_ret = 1; \
> } \
> - __ret; \
> + _FP_ISSIGNAN_ret; \
> })
>
>
> @@ -393,8 +396,8 @@
> { \
> /* Addition. */ \
> R##_s = X##_s; \
> - int ediff = X##_e - Y##_e; \
> - if (ediff > 0) \
> + int _FP_ADD_INTERNAL_ediff = X##_e - Y##_e; \
> + if (_FP_ADD_INTERNAL_ediff > 0) \
> { \
> R##_e = X##_e; \
> if (Y##_e == 0) \
> @@ -409,8 +412,8 @@
> else \
> { \
> FP_SET_EXCEPTION (FP_EX_DENORM); \
> - ediff--; \
> - if (ediff == 0) \
> + _FP_ADD_INTERNAL_ediff--; \
> + if (_FP_ADD_INTERNAL_ediff == 0) \
> { \
> _FP_FRAC_ADD_##wc (R, X, Y); \
> goto add3; \
> @@ -436,17 +439,19 @@
> _FP_FRAC_HIGH_##fs (Y) |= _FP_IMPLBIT_SH_##fs; \
> \
> add1: \
> - /* Shift the mantissa of Y to the right EDIFF steps; \
> - remember to account later for the implicit MSB of X. */ \
> - if (ediff <= _FP_WFRACBITS_##fs) \
> - _FP_FRAC_SRS_##wc (Y, ediff, _FP_WFRACBITS_##fs); \
> + /* Shift the mantissa of Y to the right \
> + _FP_ADD_INTERNAL_EDIFF steps; remember to account \
> + later for the implicit MSB of X. */ \
> + if (_FP_ADD_INTERNAL_ediff <= _FP_WFRACBITS_##fs) \
> + _FP_FRAC_SRS_##wc (Y, _FP_ADD_INTERNAL_ediff, \
> + _FP_WFRACBITS_##fs); \
> else if (!_FP_FRAC_ZEROP_##wc (Y)) \
> _FP_FRAC_SET_##wc (Y, _FP_MINFRAC_##wc); \
> _FP_FRAC_ADD_##wc (R, X, Y); \
> } \
> - else if (ediff < 0) \
> + else if (_FP_ADD_INTERNAL_ediff < 0) \
> { \
> - ediff = -ediff; \
> + _FP_ADD_INTERNAL_ediff = -_FP_ADD_INTERNAL_ediff; \
> R##_e = Y##_e; \
> if (X##_e == 0) \
> { \
> @@ -460,8 +465,8 @@
> else \
> { \
> FP_SET_EXCEPTION (FP_EX_DENORM); \
> - ediff--; \
> - if (ediff == 0) \
> + _FP_ADD_INTERNAL_ediff--; \
> + if (_FP_ADD_INTERNAL_ediff == 0) \
> { \
> _FP_FRAC_ADD_##wc (R, Y, X); \
> goto add3; \
> @@ -487,17 +492,19 @@
> _FP_FRAC_HIGH_##fs (X) |= _FP_IMPLBIT_SH_##fs; \
> \
> add2: \
> - /* Shift the mantissa of X to the right EDIFF steps; \
> - remember to account later for the implicit MSB of Y. */ \
> - if (ediff <= _FP_WFRACBITS_##fs) \
> - _FP_FRAC_SRS_##wc (X, ediff, _FP_WFRACBITS_##fs); \
> + /* Shift the mantissa of X to the right \
> + _FP_ADD_INTERNAL_EDIFF steps; remember to account \
> + later for the implicit MSB of Y. */ \
> + if (_FP_ADD_INTERNAL_ediff <= _FP_WFRACBITS_##fs) \
> + _FP_FRAC_SRS_##wc (X, _FP_ADD_INTERNAL_ediff, \
> + _FP_WFRACBITS_##fs); \
> else if (!_FP_FRAC_ZEROP_##wc (X)) \
> _FP_FRAC_SET_##wc (X, _FP_MINFRAC_##wc); \
> _FP_FRAC_ADD_##wc (R, Y, X); \
> } \
> else \
> { \
> - /* ediff == 0. */ \
> + /* _FP_ADD_INTERNAL_ediff == 0. */ \
> if (!_FP_EXP_NORMAL (fs, wc, X)) \
> { \
> if (X##_e == 0) \
> @@ -573,8 +580,8 @@
> else \
> { \
> /* Subtraction. */ \
> - int ediff = X##_e - Y##_e; \
> - if (ediff > 0) \
> + int _FP_ADD_INTERNAL_ediff = X##_e - Y##_e; \
> + if (_FP_ADD_INTERNAL_ediff > 0) \
> { \
> R##_e = X##_e; \
> R##_s = X##_s; \
> @@ -590,8 +597,8 @@
> else \
> { \
> FP_SET_EXCEPTION (FP_EX_DENORM); \
> - ediff--; \
> - if (ediff == 0) \
> + _FP_ADD_INTERNAL_ediff--; \
> + if (_FP_ADD_INTERNAL_ediff == 0) \
> { \
> _FP_FRAC_SUB_##wc (R, X, Y); \
> goto sub3; \
> @@ -617,17 +624,19 @@
> _FP_FRAC_HIGH_##fs (Y) |= _FP_IMPLBIT_SH_##fs; \
> \
> sub1: \
> - /* Shift the mantissa of Y to the right EDIFF steps; \
> - remember to account later for the implicit MSB of X. */ \
> - if (ediff <= _FP_WFRACBITS_##fs) \
> - _FP_FRAC_SRS_##wc (Y, ediff, _FP_WFRACBITS_##fs); \
> + /* Shift the mantissa of Y to the right \
> + _FP_ADD_INTERNAL_EDIFF steps; remember to account \
> + later for the implicit MSB of X. */ \
> + if (_FP_ADD_INTERNAL_ediff <= _FP_WFRACBITS_##fs) \
> + _FP_FRAC_SRS_##wc (Y, _FP_ADD_INTERNAL_ediff, \
> + _FP_WFRACBITS_##fs); \
> else if (!_FP_FRAC_ZEROP_##wc (Y)) \
> _FP_FRAC_SET_##wc (Y, _FP_MINFRAC_##wc); \
> _FP_FRAC_SUB_##wc (R, X, Y); \
> } \
> - else if (ediff < 0) \
> + else if (_FP_ADD_INTERNAL_ediff < 0) \
> { \
> - ediff = -ediff; \
> + _FP_ADD_INTERNAL_ediff = -_FP_ADD_INTERNAL_ediff; \
> R##_e = Y##_e; \
> R##_s = Y##_s; \
> if (X##_e == 0) \
> @@ -642,8 +651,8 @@
> else \
> { \
> FP_SET_EXCEPTION (FP_EX_DENORM); \
> - ediff--; \
> - if (ediff == 0) \
> + _FP_ADD_INTERNAL_ediff--; \
> + if (_FP_ADD_INTERNAL_ediff == 0) \
> { \
> _FP_FRAC_SUB_##wc (R, Y, X); \
> goto sub3; \
> @@ -669,10 +678,12 @@
> _FP_FRAC_HIGH_##fs (X) |= _FP_IMPLBIT_SH_##fs; \
> \
> sub2: \
> - /* Shift the mantissa of X to the right EDIFF steps; \
> - remember to account later for the implicit MSB of Y. */ \
> - if (ediff <= _FP_WFRACBITS_##fs) \
> - _FP_FRAC_SRS_##wc (X, ediff, _FP_WFRACBITS_##fs); \
> + /* Shift the mantissa of X to the right \
> + _FP_ADD_INTERNAL_EDIFF steps; remember to account \
> + later for the implicit MSB of Y. */ \
> + if (_FP_ADD_INTERNAL_ediff <= _FP_WFRACBITS_##fs) \
> + _FP_FRAC_SRS_##wc (X, _FP_ADD_INTERNAL_ediff, \
> + _FP_WFRACBITS_##fs); \
> else if (!_FP_FRAC_ZEROP_##wc (X)) \
> _FP_FRAC_SET_##wc (X, _FP_MINFRAC_##wc); \
> _FP_FRAC_SUB_##wc (R, Y, X); \
> @@ -783,24 +794,26 @@
> sub3: \
> if (_FP_FRAC_HIGH_##fs (R) & _FP_IMPLBIT_SH_##fs) \
> { \
> - int diff; \
> + int _FP_ADD_INTERNAL_diff; \
> /* Carry into most significant bit of larger one of X and Y, \
> canceling it; renormalize. */ \
> _FP_FRAC_HIGH_##fs (R) &= _FP_IMPLBIT_SH_##fs - 1; \
> norm: \
> - _FP_FRAC_CLZ_##wc (diff, R); \
> - diff -= _FP_WFRACXBITS_##fs; \
> - _FP_FRAC_SLL_##wc (R, diff); \
> - if (R##_e <= diff) \
> + _FP_FRAC_CLZ_##wc (_FP_ADD_INTERNAL_diff, R); \
> + _FP_ADD_INTERNAL_diff -= _FP_WFRACXBITS_##fs; \
> + _FP_FRAC_SLL_##wc (R, _FP_ADD_INTERNAL_diff); \
> + if (R##_e <= _FP_ADD_INTERNAL_diff) \
> { \
> /* R is denormalized. */ \
> - diff = diff - R##_e + 1; \
> - _FP_FRAC_SRS_##wc (R, diff, _FP_WFRACBITS_##fs); \
> + _FP_ADD_INTERNAL_diff \
> + = _FP_ADD_INTERNAL_diff - R##_e + 1; \
> + _FP_FRAC_SRS_##wc (R, _FP_ADD_INTERNAL_diff, \
> + _FP_WFRACBITS_##fs); \
> R##_e = 0; \
> } \
> else \
> { \
> - R##_e -= diff; \
> + R##_e -= _FP_ADD_INTERNAL_diff; \
> _FP_FRAC_HIGH_##fs (R) &= ~(_FP_W_TYPE) _FP_IMPLBIT_SH_##fs; \
> } \
> } \
> @@ -904,9 +917,9 @@
> #define _FP_FMA(fs, wc, dwc, R, X, Y, Z) \
> do \
> { \
> - FP_DECL_##fs (T); \
> - T##_s = X##_s ^ Y##_s; \
> - T##_e = X##_e + Y##_e + 1; \
> + FP_DECL_##fs (_FP_FMA_T); \
> + _FP_FMA_T##_s = X##_s ^ Y##_s; \
> + _FP_FMA_T##_e = X##_e + Y##_e + 1; \
> switch (_FP_CLS_COMBINE (X##_c, Y##_c)) \
> { \
> case _FP_CLS_COMBINE (FP_CLS_NORMAL, FP_CLS_NORMAL): \
> @@ -921,8 +934,8 @@
> \
> case FP_CLS_ZERO: \
> R##_c = FP_CLS_NORMAL; \
> - R##_s = T##_s; \
> - R##_e = T##_e; \
> + R##_s = _FP_FMA_T##_s; \
> + R##_e = _FP_FMA_T##_e; \
> \
> _FP_MUL_MEAT_##fs (R, X, Y); \
> \
> @@ -933,38 +946,43 @@
> break; \
> \
> case FP_CLS_NORMAL:; \
> - _FP_FRAC_DECL_##dwc (TD); \
> - _FP_FRAC_DECL_##dwc (ZD); \
> - _FP_FRAC_DECL_##dwc (RD); \
> - _FP_MUL_MEAT_DW_##fs (TD, X, Y); \
> - R##_e = T##_e; \
> - int tsh = _FP_FRAC_HIGHBIT_DW_##dwc (fs, TD) == 0; \
> - T##_e -= tsh; \
> - int ediff = T##_e - Z##_e; \
> - if (ediff >= 0) \
> + _FP_FRAC_DECL_##dwc (_FP_FMA_TD); \
> + _FP_FRAC_DECL_##dwc (_FP_FMA_ZD); \
> + _FP_FRAC_DECL_##dwc (_FP_FMA_RD); \
> + _FP_MUL_MEAT_DW_##fs (_FP_FMA_TD, X, Y); \
> + R##_e = _FP_FMA_T##_e; \
> + int _FP_FMA_tsh \
> + = _FP_FRAC_HIGHBIT_DW_##dwc (fs, _FP_FMA_TD) == 0; \
> + _FP_FMA_T##_e -= _FP_FMA_tsh; \
> + int _FP_FMA_ediff = _FP_FMA_T##_e - Z##_e; \
> + if (_FP_FMA_ediff >= 0) \
> { \
> - int shift = _FP_WFRACBITS_##fs - tsh - ediff; \
> - if (shift <= -_FP_WFRACBITS_##fs) \
> - _FP_FRAC_SET_##dwc (ZD, _FP_MINFRAC_##dwc); \
> + int _FP_FMA_shift \
> + = _FP_WFRACBITS_##fs - _FP_FMA_tsh - _FP_FMA_ediff; \
> + if (_FP_FMA_shift <= -_FP_WFRACBITS_##fs) \
> + _FP_FRAC_SET_##dwc (_FP_FMA_ZD, _FP_MINFRAC_##dwc); \
> else \
> { \
> - _FP_FRAC_COPY_##dwc##_##wc (ZD, Z); \
> - if (shift < 0) \
> - _FP_FRAC_SRS_##dwc (ZD, -shift, \
> + _FP_FRAC_COPY_##dwc##_##wc (_FP_FMA_ZD, Z); \
> + if (_FP_FMA_shift < 0) \
> + _FP_FRAC_SRS_##dwc (_FP_FMA_ZD, -_FP_FMA_shift, \
> _FP_WFRACBITS_DW_##fs); \
> - else if (shift > 0) \
> - _FP_FRAC_SLL_##dwc (ZD, shift); \
> + else if (_FP_FMA_shift > 0) \
> + _FP_FRAC_SLL_##dwc (_FP_FMA_ZD, _FP_FMA_shift); \
> } \
> - R##_s = T##_s; \
> - if (T##_s == Z##_s) \
> - _FP_FRAC_ADD_##dwc (RD, TD, ZD); \
> + R##_s = _FP_FMA_T##_s; \
> + if (_FP_FMA_T##_s == Z##_s) \
> + _FP_FRAC_ADD_##dwc (_FP_FMA_RD, _FP_FMA_TD, \
> + _FP_FMA_ZD); \
> else \
> { \
> - _FP_FRAC_SUB_##dwc (RD, TD, ZD); \
> - if (_FP_FRAC_NEGP_##dwc (RD)) \
> + _FP_FRAC_SUB_##dwc (_FP_FMA_RD, _FP_FMA_TD, \
> + _FP_FMA_ZD); \
> + if (_FP_FRAC_NEGP_##dwc (_FP_FMA_RD)) \
> { \
> R##_s = Z##_s; \
> - _FP_FRAC_SUB_##dwc (RD, ZD, TD); \
> + _FP_FRAC_SUB_##dwc (_FP_FMA_RD, _FP_FMA_ZD, \
> + _FP_FMA_TD); \
> } \
> } \
> } \
> @@ -972,22 +990,24 @@
> { \
> R##_e = Z##_e; \
> R##_s = Z##_s; \
> - _FP_FRAC_COPY_##dwc##_##wc (ZD, Z); \
> - _FP_FRAC_SLL_##dwc (ZD, _FP_WFRACBITS_##fs); \
> - int shift = -ediff - tsh; \
> - if (shift >= _FP_WFRACBITS_DW_##fs) \
> - _FP_FRAC_SET_##dwc (TD, _FP_MINFRAC_##dwc); \
> - else if (shift > 0) \
> - _FP_FRAC_SRS_##dwc (TD, shift, \
> + _FP_FRAC_COPY_##dwc##_##wc (_FP_FMA_ZD, Z); \
> + _FP_FRAC_SLL_##dwc (_FP_FMA_ZD, _FP_WFRACBITS_##fs); \
> + int _FP_FMA_shift = -_FP_FMA_ediff - _FP_FMA_tsh; \
> + if (_FP_FMA_shift >= _FP_WFRACBITS_DW_##fs) \
> + _FP_FRAC_SET_##dwc (_FP_FMA_TD, _FP_MINFRAC_##dwc); \
> + else if (_FP_FMA_shift > 0) \
> + _FP_FRAC_SRS_##dwc (_FP_FMA_TD, _FP_FMA_shift, \
> _FP_WFRACBITS_DW_##fs); \
> - if (Z##_s == T##_s) \
> - _FP_FRAC_ADD_##dwc (RD, ZD, TD); \
> + if (Z##_s == _FP_FMA_T##_s) \
> + _FP_FRAC_ADD_##dwc (_FP_FMA_RD, _FP_FMA_ZD, \
> + _FP_FMA_TD); \
> else \
> - _FP_FRAC_SUB_##dwc (RD, ZD, TD); \
> + _FP_FRAC_SUB_##dwc (_FP_FMA_RD, _FP_FMA_ZD, \
> + _FP_FMA_TD); \
> } \
> - if (_FP_FRAC_ZEROP_##dwc (RD)) \
> + if (_FP_FRAC_ZEROP_##dwc (_FP_FMA_RD)) \
> { \
> - if (T##_s == Z##_s) \
> + if (_FP_FMA_T##_s == Z##_s) \
> R##_s = Z##_s; \
> else \
> R##_s = (FP_ROUNDMODE == FP_RND_MINF); \
> @@ -996,17 +1016,17 @@
> } \
> else \
> { \
> - int rlz; \
> - _FP_FRAC_CLZ_##dwc (rlz, RD); \
> - rlz -= _FP_WFRACXBITS_DW_##fs; \
> - R##_e -= rlz; \
> - int shift = _FP_WFRACBITS_##fs - rlz; \
> - if (shift > 0) \
> - _FP_FRAC_SRS_##dwc (RD, shift, \
> + int _FP_FMA_rlz; \
> + _FP_FRAC_CLZ_##dwc (_FP_FMA_rlz, _FP_FMA_RD); \
> + _FP_FMA_rlz -= _FP_WFRACXBITS_DW_##fs; \
> + R##_e -= _FP_FMA_rlz; \
> + int _FP_FMA_shift = _FP_WFRACBITS_##fs - _FP_FMA_rlz; \
> + if (_FP_FMA_shift > 0) \
> + _FP_FRAC_SRS_##dwc (_FP_FMA_RD, _FP_FMA_shift, \
> _FP_WFRACBITS_DW_##fs); \
> - else if (shift < 0) \
> - _FP_FRAC_SLL_##dwc (RD, -shift); \
> - _FP_FRAC_COPY_##wc##_##dwc (R, RD); \
> + else if (_FP_FMA_shift < 0) \
> + _FP_FRAC_SLL_##dwc (_FP_FMA_RD, -_FP_FMA_shift); \
> + _FP_FRAC_COPY_##wc##_##dwc (R, _FP_FMA_RD); \
> R##_c = FP_CLS_NORMAL; \
> } \
> break; \
> @@ -1014,38 +1034,38 @@
> goto done_fma; \
> \
> case _FP_CLS_COMBINE (FP_CLS_NAN, FP_CLS_NAN): \
> - _FP_CHOOSENAN (fs, wc, T, X, Y, '*'); \
> + _FP_CHOOSENAN (fs, wc, _FP_FMA_T, X, Y, '*'); \
> break; \
> \
> case _FP_CLS_COMBINE (FP_CLS_NAN, FP_CLS_NORMAL): \
> case _FP_CLS_COMBINE (FP_CLS_NAN, FP_CLS_INF): \
> case _FP_CLS_COMBINE (FP_CLS_NAN, FP_CLS_ZERO): \
> - T##_s = X##_s; \
> + _FP_FMA_T##_s = X##_s; \
> \
> case _FP_CLS_COMBINE (FP_CLS_INF, FP_CLS_INF): \
> case _FP_CLS_COMBINE (FP_CLS_INF, FP_CLS_NORMAL): \
> case _FP_CLS_COMBINE (FP_CLS_ZERO, FP_CLS_NORMAL): \
> case _FP_CLS_COMBINE (FP_CLS_ZERO, FP_CLS_ZERO): \
> - _FP_FRAC_COPY_##wc (T, X); \
> - T##_c = X##_c; \
> + _FP_FRAC_COPY_##wc (_FP_FMA_T, X); \
> + _FP_FMA_T##_c = X##_c; \
> break; \
> \
> case _FP_CLS_COMBINE (FP_CLS_NORMAL, FP_CLS_NAN): \
> case _FP_CLS_COMBINE (FP_CLS_INF, FP_CLS_NAN): \
> case _FP_CLS_COMBINE (FP_CLS_ZERO, FP_CLS_NAN): \
> - T##_s = Y##_s; \
> + _FP_FMA_T##_s = Y##_s; \
> \
> case _FP_CLS_COMBINE (FP_CLS_NORMAL, FP_CLS_INF): \
> case _FP_CLS_COMBINE (FP_CLS_NORMAL, FP_CLS_ZERO): \
> - _FP_FRAC_COPY_##wc (T, Y); \
> - T##_c = Y##_c; \
> + _FP_FRAC_COPY_##wc (_FP_FMA_T, Y); \
> + _FP_FMA_T##_c = Y##_c; \
> break; \
> \
> case _FP_CLS_COMBINE (FP_CLS_INF, FP_CLS_ZERO): \
> case _FP_CLS_COMBINE (FP_CLS_ZERO, FP_CLS_INF): \
> - T##_s = _FP_NANSIGN_##fs; \
> - T##_c = FP_CLS_NAN; \
> - _FP_FRAC_SET_##wc (T, _FP_NANFRAC_##fs); \
> + _FP_FMA_T##_s = _FP_NANSIGN_##fs; \
> + _FP_FMA_T##_c = FP_CLS_NAN; \
> + _FP_FRAC_SET_##wc (_FP_FMA_T, _FP_NANFRAC_##fs); \
> FP_SET_EXCEPTION (FP_EX_INVALID); \
> break; \
> \
> @@ -1054,10 +1074,10 @@
> } \
> \
> /* T = X * Y is zero, infinity or NaN. */ \
> - switch (_FP_CLS_COMBINE (T##_c, Z##_c)) \
> + switch (_FP_CLS_COMBINE (_FP_FMA_T##_c, Z##_c)) \
> { \
> case _FP_CLS_COMBINE (FP_CLS_NAN, FP_CLS_NAN): \
> - _FP_CHOOSENAN (fs, wc, R, T, Z, '+'); \
> + _FP_CHOOSENAN (fs, wc, R, _FP_FMA_T, Z, '+'); \
> break; \
> \
> case _FP_CLS_COMBINE (FP_CLS_NAN, FP_CLS_NORMAL): \
> @@ -1065,9 +1085,9 @@
> case _FP_CLS_COMBINE (FP_CLS_NAN, FP_CLS_ZERO): \
> case _FP_CLS_COMBINE (FP_CLS_INF, FP_CLS_NORMAL): \
> case _FP_CLS_COMBINE (FP_CLS_INF, FP_CLS_ZERO): \
> - R##_s = T##_s; \
> - _FP_FRAC_COPY_##wc (R, T); \
> - R##_c = T##_c; \
> + R##_s = _FP_FMA_T##_s; \
> + _FP_FRAC_COPY_##wc (R, _FP_FMA_T); \
> + R##_c = _FP_FMA_T##_c; \
> break; \
> \
> case _FP_CLS_COMBINE (FP_CLS_INF, FP_CLS_NAN): \
> @@ -1080,7 +1100,7 @@
> break; \
> \
> case _FP_CLS_COMBINE (FP_CLS_INF, FP_CLS_INF): \
> - if (T##_s == Z##_s) \
> + if (_FP_FMA_T##_s == Z##_s) \
> { \
> R##_s = Z##_s; \
> _FP_FRAC_COPY_##wc (R, Z); \
> @@ -1096,7 +1116,7 @@
> break; \
> \
> case _FP_CLS_COMBINE (FP_CLS_ZERO, FP_CLS_ZERO): \
> - if (T##_s == Z##_s) \
> + if (_FP_FMA_T##_s == Z##_s) \
> R##_s = Z##_s; \
> else \
> R##_s = (FP_ROUNDMODE == FP_RND_MINF); \
> @@ -1193,17 +1213,19 @@
> } \
> else \
> { \
> - int __is_zero_x; \
> - int __is_zero_y; \
> + int _FP_CMP_is_zero_x; \
> + int _FP_CMP_is_zero_y; \
> \
> - __is_zero_x = (!X##_e && _FP_FRAC_ZEROP_##wc (X)) ? 1 : 0; \
> - __is_zero_y = (!Y##_e && _FP_FRAC_ZEROP_##wc (Y)) ? 1 : 0; \
> + _FP_CMP_is_zero_x \
> + = (!X##_e && _FP_FRAC_ZEROP_##wc (X)) ? 1 : 0; \
> + _FP_CMP_is_zero_y \
> + = (!Y##_e && _FP_FRAC_ZEROP_##wc (Y)) ? 1 : 0; \
> \
> - if (__is_zero_x && __is_zero_y) \
> + if (_FP_CMP_is_zero_x && _FP_CMP_is_zero_y) \
> ret = 0; \
> - else if (__is_zero_x) \
> + else if (_FP_CMP_is_zero_x) \
> ret = Y##_s ? 1 : -1; \
> - else if (__is_zero_y) \
> + else if (_FP_CMP_is_zero_y) \
> ret = X##_s ? -1 : 1; \
> else if (X##_s != Y##_s) \
> ret = X##_s ? -1 : 1; \
> @@ -1259,9 +1281,9 @@
> #define _FP_SQRT(fs, wc, R, X) \
> do \
> { \
> - _FP_FRAC_DECL_##wc (T); \
> - _FP_FRAC_DECL_##wc (S); \
> - _FP_W_TYPE q; \
> + _FP_FRAC_DECL_##wc (_FP_SQRT_T); \
> + _FP_FRAC_DECL_##wc (_FP_SQRT_S); \
> + _FP_W_TYPE _FP_SQRT_q; \
> switch (X##_c) \
> { \
> case FP_CLS_NAN: \
> @@ -1301,10 +1323,11 @@
> if (X##_e & 1) \
> _FP_FRAC_SLL_##wc (X, 1); \
> R##_e = X##_e >> 1; \
> - _FP_FRAC_SET_##wc (S, _FP_ZEROFRAC_##wc); \
> + _FP_FRAC_SET_##wc (_FP_SQRT_S, _FP_ZEROFRAC_##wc); \
> _FP_FRAC_SET_##wc (R, _FP_ZEROFRAC_##wc); \
> - q = _FP_OVERFLOW_##fs >> 1; \
> - _FP_SQRT_MEAT_##wc (R, S, T, X, q); \
> + _FP_SQRT_q = _FP_OVERFLOW_##fs >> 1; \
> + _FP_SQRT_MEAT_##wc (R, _FP_SQRT_S, _FP_SQRT_T, X, \
> + _FP_SQRT_q); \
> } \
> } \
> while (0)
> @@ -1360,10 +1383,10 @@
> { \
> /* Possibly converting to most negative integer; check the \
> mantissa. */ \
> - int inexact = 0; \
> + int _FP_TO_INT_inexact = 0; \
> (void) ((_FP_FRACBITS_##fs > rsize) \
> ? ({ \
> - _FP_FRAC_SRST_##wc (X, inexact, \
> + _FP_FRAC_SRST_##wc (X, _FP_TO_INT_inexact, \
> _FP_FRACBITS_##fs - rsize, \
> _FP_FRACBITS_##fs); \
> 0; \
> @@ -1371,7 +1394,7 @@
> : 0); \
> if (!_FP_FRAC_ZEROP_##wc (X)) \
> FP_SET_EXCEPTION (FP_EX_INVALID); \
> - else if (inexact) \
> + else if (_FP_TO_INT_inexact) \
> FP_SET_EXCEPTION (FP_EX_INEXACT); \
> } \
> else \
> @@ -1387,12 +1410,12 @@
> } \
> else \
> { \
> - int inexact; \
> - _FP_FRAC_SRST_##wc (X, inexact, \
> + int _FP_TO_INT_inexact; \
> + _FP_FRAC_SRST_##wc (X, _FP_TO_INT_inexact, \
> (_FP_FRACBITS_##fs + _FP_EXPBIAS_##fs - 1 \
> - X##_e), \
> _FP_FRACBITS_##fs); \
> - if (inexact) \
> + if (_FP_TO_INT_inexact) \
> FP_SET_EXCEPTION (FP_EX_INEXACT); \
> _FP_FRAC_ASSEMBLE_##wc (r, X, rsize); \
> } \
> @@ -1409,26 +1432,29 @@
> { \
> if (r) \
> { \
> - rtype ur_; \
> + rtype _FP_FROM_INT_ur; \
> \
> if ((X##_s = (r < 0))) \
> r = -(rtype) r; \
> \
> - ur_ = (rtype) r; \
> + _FP_FROM_INT_ur = (rtype) r; \
> (void) ((rsize <= _FP_W_TYPE_SIZE) \
> ? ({ \
> - int lz_; \
> - __FP_CLZ (lz_, (_FP_W_TYPE) ur_); \
> - X##_e = _FP_EXPBIAS_##fs + _FP_W_TYPE_SIZE - 1 - lz_; \
> + int _FP_FROM_INT_lz; \
> + __FP_CLZ (_FP_FROM_INT_lz, \
> + (_FP_W_TYPE) _FP_FROM_INT_ur); \
> + X##_e = (_FP_EXPBIAS_##fs + _FP_W_TYPE_SIZE - 1 \
> + - _FP_FROM_INT_lz); \
> }) \
> : ((rsize <= 2 * _FP_W_TYPE_SIZE) \
> ? ({ \
> - int lz_; \
> - __FP_CLZ_2 (lz_, \
> - (_FP_W_TYPE) (ur_ >> _FP_W_TYPE_SIZE), \
> - (_FP_W_TYPE) ur_); \
> + int _FP_FROM_INT_lz; \
> + __FP_CLZ_2 (_FP_FROM_INT_lz, \
> + (_FP_W_TYPE) (_FP_FROM_INT_ur \
> + >> _FP_W_TYPE_SIZE), \
> + (_FP_W_TYPE) _FP_FROM_INT_ur); \
> X##_e = (_FP_EXPBIAS_##fs + 2 * _FP_W_TYPE_SIZE - 1 \
> - - lz_); \
> + - _FP_FROM_INT_lz); \
> }) \
> : (abort (), 0))); \
> \
> @@ -1445,7 +1471,7 @@
> || X##_e < _FP_EXPBIAS_##fs + _FP_FRACBITS_##fs) \
> { \
> /* Exactly representable; shift left. */ \
> - _FP_FRAC_DISASSEMBLE_##wc (X, ur_, rsize); \
> + _FP_FRAC_DISASSEMBLE_##wc (X, _FP_FROM_INT_ur, rsize); \
> if (_FP_EXPBIAS_##fs + _FP_FRACBITS_##fs - 1 - X##_e > 0) \
> _FP_FRAC_SLL_##wc (X, (_FP_EXPBIAS_##fs \
> + _FP_FRACBITS_##fs - 1 - X##_e)); \
> @@ -1455,12 +1481,14 @@
> /* More bits in integer than in floating type; need to \
> round. */ \
> if (_FP_EXPBIAS_##fs + _FP_WFRACBITS_##fs - 1 < X##_e) \
> - ur_ = ((ur_ >> (X##_e - _FP_EXPBIAS_##fs \
> - - _FP_WFRACBITS_##fs + 1)) \
> - | ((ur_ << (rsize - (X##_e - _FP_EXPBIAS_##fs \
> - - _FP_WFRACBITS_##fs + 1))) \
> - != 0)); \
> - _FP_FRAC_DISASSEMBLE_##wc (X, ur_, rsize); \
> + _FP_FROM_INT_ur \
> + = ((_FP_FROM_INT_ur >> (X##_e - _FP_EXPBIAS_##fs \
> + - _FP_WFRACBITS_##fs + 1)) \
> + | ((_FP_FROM_INT_ur \
> + << (rsize - (X##_e - _FP_EXPBIAS_##fs \
> + - _FP_WFRACBITS_##fs + 1))) \
> + != 0)); \
> + _FP_FRAC_DISASSEMBLE_##wc (X, _FP_FROM_INT_ur, rsize); \
> if ((_FP_EXPBIAS_##fs + _FP_WFRACBITS_##fs - 1 - X##_e) > 0) \
> _FP_FRAC_SLL_##wc (X, (_FP_EXPBIAS_##fs \
> + _FP_WFRACBITS_##fs - 1 - X##_e)); \
> @@ -1513,14 +1541,14 @@
> } \
> else \
> { \
> - int _lz; \
> + int FP_EXTEND_lz; \
> FP_SET_EXCEPTION (FP_EX_DENORM); \
> - _FP_FRAC_CLZ_##swc (_lz, S); \
> + _FP_FRAC_CLZ_##swc (FP_EXTEND_lz, S); \
> _FP_FRAC_SLL_##dwc (D, \
> - _lz + _FP_FRACBITS_##dfs \
> + FP_EXTEND_lz + _FP_FRACBITS_##dfs \
> - _FP_FRACTBITS_##sfs); \
> D##_e = (_FP_EXPBIAS_##dfs - _FP_EXPBIAS_##sfs + 1 \
> - + _FP_FRACXBITS_##sfs - _lz); \
> + + _FP_FRACXBITS_##sfs - FP_EXTEND_lz); \
> } \
> } \
> else \
> @@ -1662,42 +1690,51 @@
> #define _FP_DIV_MEAT_N_loop(fs, wc, R, X, Y) \
> do \
> { \
> - int count = _FP_WFRACBITS_##fs; \
> - _FP_FRAC_DECL_##wc (u); \
> - _FP_FRAC_DECL_##wc (v); \
> - _FP_FRAC_COPY_##wc (u, X); \
> - _FP_FRAC_COPY_##wc (v, Y); \
> + int _FP_DIV_MEAT_N_loop_count = _FP_WFRACBITS_##fs; \
> + _FP_FRAC_DECL_##wc (_FP_DIV_MEAT_N_loop_u); \
> + _FP_FRAC_DECL_##wc (_FP_DIV_MEAT_N_loop_v); \
> + _FP_FRAC_COPY_##wc (_FP_DIV_MEAT_N_loop_u, X); \
> + _FP_FRAC_COPY_##wc (_FP_DIV_MEAT_N_loop_v, Y); \
> _FP_FRAC_SET_##wc (R, _FP_ZEROFRAC_##wc); \
> - /* Normalize U and V. */ \
> - _FP_FRAC_SLL_##wc (u, _FP_WFRACXBITS_##fs); \
> - _FP_FRAC_SLL_##wc (v, _FP_WFRACXBITS_##fs); \
> + /* Normalize _FP_DIV_MEAT_N_LOOP_U and _FP_DIV_MEAT_N_LOOP_V. */ \
> + _FP_FRAC_SLL_##wc (_FP_DIV_MEAT_N_loop_u, _FP_WFRACXBITS_##fs); \
> + _FP_FRAC_SLL_##wc (_FP_DIV_MEAT_N_loop_v, _FP_WFRACXBITS_##fs); \
> /* First round. Since the operands are normalized, either the \
> first or second bit will be set in the fraction. Produce a \
> normalized result by checking which and adjusting the loop \
> count and exponent accordingly. */ \
> - if (_FP_FRAC_GE_1 (u, v)) \
> + if (_FP_FRAC_GE_1 (_FP_DIV_MEAT_N_loop_u, _FP_DIV_MEAT_N_loop_v)) \
> { \
> - _FP_FRAC_SUB_##wc (u, u, v); \
> + _FP_FRAC_SUB_##wc (_FP_DIV_MEAT_N_loop_u, \
> + _FP_DIV_MEAT_N_loop_u, \
> + _FP_DIV_MEAT_N_loop_v); \
> _FP_FRAC_LOW_##wc (R) |= 1; \
> - count--; \
> + _FP_DIV_MEAT_N_loop_count--; \
> } \
> else \
> R##_e--; \
> /* Subsequent rounds. */ \
> do \
> { \
> - int msb = (_FP_WS_TYPE) _FP_FRAC_HIGH_##wc (u) < 0; \
> - _FP_FRAC_SLL_##wc (u, 1); \
> + int _FP_DIV_MEAT_N_loop_msb \
> + = (_FP_WS_TYPE) _FP_FRAC_HIGH_##wc (_FP_DIV_MEAT_N_loop_u) < 0; \
> + _FP_FRAC_SLL_##wc (_FP_DIV_MEAT_N_loop_u, 1); \
> _FP_FRAC_SLL_##wc (R, 1); \
> - if (msb || _FP_FRAC_GE_1 (u, v)) \
> + if (_FP_DIV_MEAT_N_loop_msb \
> + || _FP_FRAC_GE_1 (_FP_DIV_MEAT_N_loop_u, \
> + _FP_DIV_MEAT_N_loop_v)) \
> { \
> - _FP_FRAC_SUB_##wc (u, u, v); \
> + _FP_FRAC_SUB_##wc (_FP_DIV_MEAT_N_loop_u, \
> + _FP_DIV_MEAT_N_loop_u, \
> + _FP_DIV_MEAT_N_loop_v); \
> _FP_FRAC_LOW_##wc (R) |= 1; \
> } \
> } \
> - while (--count > 0); \
> - /* If there's anything left in U, the result is inexact. */ \
> - _FP_FRAC_LOW_##wc (R) |= !_FP_FRAC_ZEROP_##wc (u); \
> + while (--_FP_DIV_MEAT_N_loop_count > 0); \
> + /* If there's anything left in _FP_DIV_MEAT_N_LOOP_U, the result \
> + is inexact. */ \
> + _FP_FRAC_LOW_##wc (R) \
> + |= !_FP_FRAC_ZEROP_##wc (_FP_DIV_MEAT_N_loop_u); \
> } \
> while (0)
>
>
> --
> Joseph S. Myers
> joseph@codesourcery.com
--
Will Newton
Toolchain Working Group, Linaro
| Index Nav: | [Date Index] [Subject Index] [Author Index] [Thread Index] | |
|---|---|---|
| Message Nav: | [Date Prev] [Date Next] | [Thread Prev] [Thread Next] |