/* Software floating-point emulation.
Basic four-word fraction declaration and manipulation.
- Copyright (C) 1997-2014 Free Software Foundation, Inc.
+ Copyright (C) 1997-2015 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Contributed by Richard Henderson (rth@cygnus.com),
Jakub Jelinek (jj@ultra.linux.cz),
} \
while (0)
-/* This one was broken too */
+/* This one was broken too. */
#define _FP_FRAC_SRL_4(X, N) \
do \
{ \
/* Right shift with sticky-lsb.
- * What this actually means is that we do a standard right-shift,
- * but that if any of the bits that fall off the right hand side
- * were one then we always set the LSbit.
- */
+ What this actually means is that we do a standard right-shift,
+ 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 \
{ \
do \
{ \
int _FP_FRAC_SRS_4_sticky; \
- _FP_FRAC_SRST_4 (X, _FP_FRAC_SRS_4_sticky, N, size); \
+ _FP_FRAC_SRST_4 (X, _FP_FRAC_SRS_4_sticky, (N), (size)); \
X##_f[0] |= _FP_FRAC_SRS_4_sticky; \
} \
while (0)
do \
{ \
if (X##_f[3]) \
- __FP_CLZ (R, X##_f[3]); \
+ __FP_CLZ ((R), X##_f[3]); \
else if (X##_f[2]) \
{ \
- __FP_CLZ (R, X##_f[2]); \
- R += _FP_W_TYPE_SIZE; \
+ __FP_CLZ ((R), X##_f[2]); \
+ (R) += _FP_W_TYPE_SIZE; \
} \
else if (X##_f[1]) \
{ \
- __FP_CLZ (R, X##_f[1]); \
- R += _FP_W_TYPE_SIZE*2; \
+ __FP_CLZ ((R), X##_f[1]); \
+ (R) += _FP_W_TYPE_SIZE*2; \
} \
else \
{ \
- __FP_CLZ (R, X##_f[0]); \
- R += _FP_W_TYPE_SIZE*3; \
+ __FP_CLZ ((R), X##_f[0]); \
+ (R) += _FP_W_TYPE_SIZE*3; \
} \
} \
while (0)
} \
while (0)
-/*
- * Multiplication algorithms:
- */
+/* Multiplication algorithms: */
/* Given a 1W * 1W => 2W primitive, do the extended multiplication. */
{ \
_FP_FRAC_DECL_8 (_FP_MUL_MEAT_4_wide_z); \
\
- _FP_MUL_MEAT_DW_4_wide (wfracbits, _FP_MUL_MEAT_4_wide_z, \
+ _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 (_FP_MUL_MEAT_4_wide_z, wfracbits-1, 2*wfracbits); \
+ _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_DECL_8 (_FP_MUL_MEAT_4_gmp_z); \
\
- _FP_MUL_MEAT_DW_4_gmp (wfracbits, _FP_MUL_MEAT_4_gmp_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 (_FP_MUL_MEAT_4_gmp_z, wfracbits-1, 2*wfracbits); \
+ _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), \
} \
while (0)
-/*
- * Helper utility for _FP_DIV_MEAT_4_udiv:
- * pppp = m * nnn
- */
+/* Helper utility for _FP_DIV_MEAT_4_udiv:
+ * pppp = m * nnn. */
#define umul_ppppmnnn(p3, p2, p1, p0, m, n2, n1, n0) \
do \
{ \
} \
while (0)
-/*
- * Division algorithms:
- */
+/* Division algorithms: */
#define _FP_DIV_MEAT_4_udiv(fs, R, X, Y) \
do \
R##_e--; \
\
/* Normalize, i.e. make the most significant bit of the \
- denominator set. */ \
+ denominator set. */ \
_FP_FRAC_SLL_4 (Y, _FP_WFRACXBITS_##fs); \
\
for (_FP_DIV_MEAT_4_udiv_i = 3; ; _FP_DIV_MEAT_4_udiv_i--) \
while (0)
-/*
- * Square root algorithms:
- * We have just one right now, maybe Newton approximation
- * should be added for those machines where division is fast.
- */
+/* Square root algorithms:
+ We have just one right now, maybe Newton approximation
+ should be added for those machines where division is fast. */
#define _FP_SQRT_MEAT_4(R, S, T, X, q) \
do \
{ \
while (q) \
{ \
- T##_f[3] = S##_f[3] + q; \
+ T##_f[3] = S##_f[3] + (q); \
if (T##_f[3] <= X##_f[3]) \
{ \
- S##_f[3] = T##_f[3] + q; \
+ S##_f[3] = T##_f[3] + (q); \
X##_f[3] -= T##_f[3]; \
- R##_f[3] += q; \
+ R##_f[3] += (q); \
} \
_FP_FRAC_SLL_4 (X, 1); \
- q >>= 1; \
+ (q) >>= 1; \
} \
- q = (_FP_W_TYPE) 1 << (_FP_W_TYPE_SIZE - 1); \
+ (q) = (_FP_W_TYPE) 1 << (_FP_W_TYPE_SIZE - 1); \
while (q) \
{ \
- T##_f[2] = S##_f[2] + q; \
+ T##_f[2] = S##_f[2] + (q); \
T##_f[3] = S##_f[3]; \
if (T##_f[3] < X##_f[3] \
|| (T##_f[3] == X##_f[3] && T##_f[2] <= X##_f[2])) \
{ \
- S##_f[2] = T##_f[2] + q; \
+ S##_f[2] = T##_f[2] + (q); \
S##_f[3] += (T##_f[2] > S##_f[2]); \
__FP_FRAC_DEC_2 (X##_f[3], X##_f[2], \
T##_f[3], T##_f[2]); \
- R##_f[2] += q; \
+ R##_f[2] += (q); \
} \
_FP_FRAC_SLL_4 (X, 1); \
- q >>= 1; \
+ (q) >>= 1; \
} \
- q = (_FP_W_TYPE) 1 << (_FP_W_TYPE_SIZE - 1); \
+ (q) = (_FP_W_TYPE) 1 << (_FP_W_TYPE_SIZE - 1); \
while (q) \
{ \
- T##_f[1] = S##_f[1] + q; \
+ T##_f[1] = S##_f[1] + (q); \
T##_f[2] = S##_f[2]; \
T##_f[3] = S##_f[3]; \
if (T##_f[3] < X##_f[3] \
|| (T##_f[2] == X##_f[2] \
&& T##_f[1] <= X##_f[1])))) \
{ \
- S##_f[1] = T##_f[1] + q; \
+ S##_f[1] = T##_f[1] + (q); \
S##_f[2] += (T##_f[1] > S##_f[1]); \
S##_f[3] += (T##_f[2] > S##_f[2]); \
__FP_FRAC_DEC_3 (X##_f[3], X##_f[2], X##_f[1], \
T##_f[3], T##_f[2], T##_f[1]); \
- R##_f[1] += q; \
+ R##_f[1] += (q); \
} \
_FP_FRAC_SLL_4 (X, 1); \
- q >>= 1; \
+ (q) >>= 1; \
} \
- q = (_FP_W_TYPE) 1 << (_FP_W_TYPE_SIZE - 1); \
- while (q != _FP_WORK_ROUND) \
+ (q) = (_FP_W_TYPE) 1 << (_FP_W_TYPE_SIZE - 1); \
+ while ((q) != _FP_WORK_ROUND) \
{ \
- T##_f[0] = S##_f[0] + q; \
+ T##_f[0] = S##_f[0] + (q); \
T##_f[1] = S##_f[1]; \
T##_f[2] = S##_f[2]; \
T##_f[3] = S##_f[3]; \
if (_FP_FRAC_GE_4 (X, T)) \
{ \
- S##_f[0] = T##_f[0] + q; \
+ S##_f[0] = T##_f[0] + (q); \
S##_f[1] += (T##_f[0] > S##_f[0]); \
S##_f[2] += (T##_f[1] > S##_f[1]); \
S##_f[3] += (T##_f[2] > S##_f[2]); \
_FP_FRAC_DEC_4 (X, T); \
- R##_f[0] += q; \
+ R##_f[0] += (q); \
} \
_FP_FRAC_SLL_4 (X, 1); \
- q >>= 1; \
+ (q) >>= 1; \
} \
if (!_FP_FRAC_ZEROP_4 (X)) \
{ \
while (0)
-/*
- * Internals
- */
+/* Internals. */
#define __FP_FRAC_SET_4(X, I3, I2, I1, I0) \
(X##_f[3] = I3, X##_f[2] = I2, X##_f[1] = I1, X##_f[0] = I0)
#endif
/* Convert FP values between word sizes. This appears to be more
- * complicated than I'd have expected it to be, so these might be
- * wrong... These macros are in any case somewhat bogus because they
- * use information about what various FRAC_n variables look like
- * internally [eg, that 2 word vars are X_f0 and x_f1]. But so do
- * the ones in op-2.h and op-1.h.
- */
+ complicated than I'd have expected it to be, so these might be
+ wrong... These macros are in any case somewhat bogus because they
+ use information about what various FRAC_n variables look like
+ internally [eg, that 2 word vars are X_f0 and x_f1]. But so do
+ the ones in op-2.h and op-1.h. */
#define _FP_FRAC_COPY_1_4(D, S) (D##_f = S##_f[0])
#define _FP_FRAC_COPY_2_4(D, S) \
while (0)
/* Assembly/disassembly for converting to/from integral types.
- * No shifting or overflow handled here.
- */
-/* Put the FP value X into r, which is an integer of size rsize. */
+ No shifting or overflow handled here. */
+/* Put the FP value X into r, which is an integer of size rsize. */
#define _FP_FRAC_ASSEMBLE_4(r, X, rsize) \
do \
{ \
- if (rsize <= _FP_W_TYPE_SIZE) \
- r = X##_f[0]; \
- else if (rsize <= 2*_FP_W_TYPE_SIZE) \
+ if ((rsize) <= _FP_W_TYPE_SIZE) \
+ (r) = X##_f[0]; \
+ else if ((rsize) <= 2*_FP_W_TYPE_SIZE) \
{ \
- r = X##_f[1]; \
- r = (rsize <= _FP_W_TYPE_SIZE ? 0 : r << _FP_W_TYPE_SIZE); \
- r += X##_f[0]; \
+ (r) = X##_f[1]; \
+ (r) = ((rsize) <= _FP_W_TYPE_SIZE \
+ ? 0 \
+ : (r) << _FP_W_TYPE_SIZE); \
+ (r) += X##_f[0]; \
} \
else \
{ \
- /* I'm feeling lazy so we deal with int == 3words (implausible)*/ \
- /* and int == 4words as a single case. */ \
- r = X##_f[3]; \
- r = (rsize <= _FP_W_TYPE_SIZE ? 0 : r << _FP_W_TYPE_SIZE); \
- r += X##_f[2]; \
- r = (rsize <= _FP_W_TYPE_SIZE ? 0 : r << _FP_W_TYPE_SIZE); \
- r += X##_f[1]; \
- r = (rsize <= _FP_W_TYPE_SIZE ? 0 : r << _FP_W_TYPE_SIZE); \
- r += X##_f[0]; \
+ /* I'm feeling lazy so we deal with int == 3words \
+ (implausible) and int == 4words as a single case. */ \
+ (r) = X##_f[3]; \
+ (r) = ((rsize) <= _FP_W_TYPE_SIZE \
+ ? 0 \
+ : (r) << _FP_W_TYPE_SIZE); \
+ (r) += X##_f[2]; \
+ (r) = ((rsize) <= _FP_W_TYPE_SIZE \
+ ? 0 \
+ : (r) << _FP_W_TYPE_SIZE); \
+ (r) += X##_f[1]; \
+ (r) = ((rsize) <= _FP_W_TYPE_SIZE \
+ ? 0 \
+ : (r) << _FP_W_TYPE_SIZE); \
+ (r) += X##_f[0]; \
} \
} \
while (0)
/* "No disassemble Number Five!" */
-/* move an integer of size rsize into X's fractional part. We rely on
- * the _f[] array consisting of words of size _FP_W_TYPE_SIZE to avoid
- * having to mask the values we store into it.
- */
-#define _FP_FRAC_DISASSEMBLE_4(X, r, rsize) \
- do \
- { \
- X##_f[0] = r; \
- X##_f[1] = (rsize <= _FP_W_TYPE_SIZE ? 0 : r >> _FP_W_TYPE_SIZE); \
- X##_f[2] = (rsize <= 2*_FP_W_TYPE_SIZE ? 0 : r >> 2*_FP_W_TYPE_SIZE); \
- X##_f[3] = (rsize <= 3*_FP_W_TYPE_SIZE ? 0 : r >> 3*_FP_W_TYPE_SIZE); \
- } \
+/* Move an integer of size rsize into X's fractional part. We rely on
+ the _f[] array consisting of words of size _FP_W_TYPE_SIZE to avoid
+ having to mask the values we store into it. */
+#define _FP_FRAC_DISASSEMBLE_4(X, r, rsize) \
+ do \
+ { \
+ X##_f[0] = (r); \
+ X##_f[1] = ((rsize) <= _FP_W_TYPE_SIZE \
+ ? 0 \
+ : (r) >> _FP_W_TYPE_SIZE); \
+ X##_f[2] = ((rsize) <= 2*_FP_W_TYPE_SIZE \
+ ? 0 \
+ : (r) >> 2*_FP_W_TYPE_SIZE); \
+ X##_f[3] = ((rsize) <= 3*_FP_W_TYPE_SIZE \
+ ? 0 \
+ : (r) >> 3*_FP_W_TYPE_SIZE); \
+ } \
while (0)
#define _FP_FRAC_COPY_4_1(D, S) \