AuroraMiddleware/glibc
1
0
Fork 0
mirror of https://sourceware.org/git/glibc.git synced 2024-11-09 23:00:07 +00:00
Code Issues Packages Projects Releases Wiki Activity

remove nested function hack_digit

Browse Source
This commit is contained in:
Kostya Serebryany 2014-09-29 10:46:05 -07:00
parent f4a58f0d35
commit 8e257a2959
2 changed files with 246 additions and 230 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
ChangeLog
View File

@ -1,3 +1,12 @@
2014-09-29 Kostya Serebryany <konstantin.s.serebryany@gmail.com>
* stdio-common/printf_fp.c
(hack_digit): New function, broken out of ...
(__printf_fp): ... local function here. Update call sites.
hack_digit now takes an additional parameter that is a pointer
to a struct of the referenced locals. Those locals moved inside
the struct and references updated.
2014-09-29 H.J. Lu <hongjiu.lu@intel.com> 2014-09-29 H.J. Lu <hongjiu.lu@intel.com>
* aclocal.m4: Require autoconf 2.69. * aclocal.m4: Require autoconf 2.69.

467
stdio-common/printf_fp.c
View File

@ -148,6 +148,65 @@ static wchar_t *group_number (wchar_t *buf, wchar_t *bufend,
wchar_t thousands_sep, int ngroups) wchar_t thousands_sep, int ngroups)
internal_function; internal_function;
struct hack_digit_param
{
/* Sign of the exponent. */
int expsign;
/* The type of output format that will be used: 'e'/'E' or 'f'. */
int type;
/* and the exponent. */
int exponent;
/* The fraction of the floting-point value in question */
MPN_VAR(frac);
/* Scaling factor. */
MPN_VAR(scale);
/* Temporary bignum value. */
MPN_VAR(tmp);
};
static wchar_t
hack_digit (struct hack_digit_param *p)
{
mp_limb_t hi;
if (p->expsign != 0 && p->type == 'f' && p->exponent-- > 0)
hi = 0;
else if (p->scalesize == 0)
{
hi = p->frac[p->fracsize - 1];
p->frac[p->fracsize - 1] = __mpn_mul_1 (p->frac, p->frac,
p->fracsize - 1, 10);
}
else
{
if (p->fracsize < p->scalesize)
hi = 0;
else
{
hi = mpn_divmod (p->tmp, p->frac, p->fracsize,
p->scale, p->scalesize);
p->tmp[p->fracsize - p->scalesize] = hi;
hi = p->tmp[0];
p->fracsize = p->scalesize;
while (p->fracsize != 0 && p->frac[p->fracsize - 1] == 0)
--p->fracsize;
if (p->fracsize == 0)
{
/* We're not prepared for an mpn variable with zero
limbs. */
p->fracsize = 1;
return L'0' + hi;
}
}
mp_limb_t _cy = __mpn_mul_1 (p->frac, p->frac, p->fracsize, 10);
if (_cy != 0)
p->frac[p->fracsize++] = _cy;
}
return L'0' + hi;
}
int int
___printf_fp (FILE *fp, ___printf_fp (FILE *fp,
@ -181,24 +240,10 @@ ___printf_fp (FILE *fp,
/* We need to shift the contents of fp_input by this amount of bits. */ /* We need to shift the contents of fp_input by this amount of bits. */
int to_shift = 0; int to_shift = 0;
/* The fraction of the floting-point value in question */ struct hack_digit_param p;
MPN_VAR(frac);
/* and the exponent. */
int exponent;
/* Sign of the exponent. */
int expsign = 0;
/* Sign of float number. */ /* Sign of float number. */
int is_neg = 0; int is_neg = 0;
/* Scaling factor. */
MPN_VAR(scale);
/* Temporary bignum value. */
MPN_VAR(tmp);
/* The type of output format that will be used: 'e'/'E' or 'f'. */
int type;
/* Counter for number of written characters. */ /* Counter for number of written characters. */
int done = 0; int done = 0;
@ -213,49 +258,7 @@ ___printf_fp (FILE *fp,
/* Flag whether wbuffer is malloc'ed or not. */ /* Flag whether wbuffer is malloc'ed or not. */
int buffer_malloced = 0; int buffer_malloced = 0;
auto wchar_t hack_digit (void); p.expsign = 0;
wchar_t hack_digit (void)
{
mp_limb_t hi;
if (expsign != 0 && type == 'f' && exponent-- > 0)
hi = 0;
else if (scalesize == 0)
{
hi = frac[fracsize - 1];
frac[fracsize - 1] = __mpn_mul_1 (frac, frac, fracsize - 1, 10);
}
else
{
if (fracsize < scalesize)
hi = 0;
else
{
hi = mpn_divmod (tmp, frac, fracsize, scale, scalesize);
tmp[fracsize - scalesize] = hi;
hi = tmp[0];
fracsize = scalesize;
while (fracsize != 0 && frac[fracsize - 1] == 0)
--fracsize;
if (fracsize == 0)
{
/* We're not prepared for an mpn variable with zero
limbs. */
fracsize = 1;
return L'0' + hi;
}
}
mp_limb_t _cy = __mpn_mul_1 (frac, frac, fracsize, 10);
if (_cy != 0)
frac[fracsize++] = _cy;
}
return L'0' + hi;
}
/* Figure out the decimal point character. */ /* Figure out the decimal point character. */
if (info->extra == 0) if (info->extra == 0)
@ -360,12 +363,12 @@ ___printf_fp (FILE *fp,
} }
else else
{ {
fracsize = __mpn_extract_long_double (fp_input, p.fracsize = __mpn_extract_long_double (fp_input,
(sizeof (fp_input) / (sizeof (fp_input) /
sizeof (fp_input[0])), sizeof (fp_input[0])),
&exponent, &is_neg, &p.exponent, &is_neg,
fpnum.ldbl); fpnum.ldbl);
to_shift = 1 + fracsize * BITS_PER_MP_LIMB - LDBL_MANT_DIG; to_shift = 1 + p.fracsize * BITS_PER_MP_LIMB - LDBL_MANT_DIG;
} }
} }
else else
@ -406,11 +409,11 @@ ___printf_fp (FILE *fp,
} }
else else
{ {
fracsize = __mpn_extract_double (fp_input, p.fracsize = __mpn_extract_double (fp_input,
(sizeof (fp_input) (sizeof (fp_input)
/ sizeof (fp_input[0])), / sizeof (fp_input[0])),
&exponent, &is_neg, fpnum.dbl); &p.exponent, &is_neg, fpnum.dbl);
to_shift = 1 + fracsize * BITS_PER_MP_LIMB - DBL_MANT_DIG; to_shift = 1 + p.fracsize * BITS_PER_MP_LIMB - DBL_MANT_DIG;
} }
} }
@ -441,25 +444,25 @@ ___printf_fp (FILE *fp,
} }
/* We need three multiprecision variables. Now that we have the exponent /* We need three multiprecision variables. Now that we have the p.exponent
of the number we can allocate the needed memory. It would be more of the number we can allocate the needed memory. It would be more
efficient to use variables of the fixed maximum size but because this efficient to use variables of the fixed maximum size but because this
would be really big it could lead to memory problems. */ would be really big it could lead to memory problems. */
{ {
mp_size_t bignum_size = ((ABS (exponent) + BITS_PER_MP_LIMB - 1) mp_size_t bignum_size = ((ABS (p.exponent) + BITS_PER_MP_LIMB - 1)
/ BITS_PER_MP_LIMB / BITS_PER_MP_LIMB
+ (LDBL_MANT_DIG / BITS_PER_MP_LIMB > 2 ? 8 : 4)) + (LDBL_MANT_DIG / BITS_PER_MP_LIMB > 2 ? 8 : 4))
* sizeof (mp_limb_t); * sizeof (mp_limb_t);
frac = (mp_limb_t *) alloca (bignum_size); p.frac = (mp_limb_t *) alloca (bignum_size);
tmp = (mp_limb_t *) alloca (bignum_size); p.tmp = (mp_limb_t *) alloca (bignum_size);
scale = (mp_limb_t *) alloca (bignum_size); p.scale = (mp_limb_t *) alloca (bignum_size);
} }
/* We now have to distinguish between numbers with positive and negative /* We now have to distinguish between numbers with positive and negative
exponents because the method used for the one is not applicable/efficient exponents because the method used for the one is not applicable/efficient
for the other. */ for the other. */
scalesize = 0; p.scalesize = 0;
if (exponent > 2) if (p.exponent > 2)
{ {
/* |FP| >= 8.0. */ /* |FP| >= 8.0. */
int scaleexpo = 0; int scaleexpo = 0;
@ -468,22 +471,23 @@ ___printf_fp (FILE *fp,
const struct mp_power *powers = &_fpioconst_pow10[explog + 1]; const struct mp_power *powers = &_fpioconst_pow10[explog + 1];
int cnt_h, cnt_l, i; int cnt_h, cnt_l, i;
if ((exponent + to_shift) % BITS_PER_MP_LIMB == 0) if ((p.exponent + to_shift) % BITS_PER_MP_LIMB == 0)
{ {
MPN_COPY_DECR (frac + (exponent + to_shift) / BITS_PER_MP_LIMB, MPN_COPY_DECR (p.frac + (p.exponent + to_shift) / BITS_PER_MP_LIMB,
fp_input, fracsize); fp_input, p.fracsize);
fracsize += (exponent + to_shift) / BITS_PER_MP_LIMB; p.fracsize += (p.exponent + to_shift) / BITS_PER_MP_LIMB;
} }
else else
{ {
cy = __mpn_lshift (frac + (exponent + to_shift) / BITS_PER_MP_LIMB, cy = __mpn_lshift (p.frac +
fp_input, fracsize, (p.exponent + to_shift) / BITS_PER_MP_LIMB,
(exponent + to_shift) % BITS_PER_MP_LIMB); fp_input, p.fracsize,
fracsize += (exponent + to_shift) / BITS_PER_MP_LIMB; (p.exponent + to_shift) % BITS_PER_MP_LIMB);
p.fracsize += (p.exponent + to_shift) / BITS_PER_MP_LIMB;
if (cy) if (cy)
frac[fracsize++] = cy; p.frac[p.fracsize++] = cy;
} }
MPN_ZERO (frac, (exponent + to_shift) / BITS_PER_MP_LIMB); MPN_ZERO (p.frac, (p.exponent + to_shift) / BITS_PER_MP_LIMB);
assert (powers > &_fpioconst_pow10[0]); assert (powers > &_fpioconst_pow10[0]);
do do
@ -492,9 +496,9 @@ ___printf_fp (FILE *fp,
/* The number of the product of two binary numbers with n and m /* The number of the product of two binary numbers with n and m
bits respectively has m+n or m+n-1 bits. */ bits respectively has m+n or m+n-1 bits. */
if (exponent >= scaleexpo + powers->p_expo - 1) if (p.exponent >= scaleexpo + powers->p_expo - 1)
{ {
if (scalesize == 0) if (p.scalesize == 0)
{ {
#ifndef __NO_LONG_DOUBLE_MATH #ifndef __NO_LONG_DOUBLE_MATH
if (LDBL_MANT_DIG > _FPIO_CONST_OFFSET * BITS_PER_MP_LIMB if (LDBL_MANT_DIG > _FPIO_CONST_OFFSET * BITS_PER_MP_LIMB
@ -505,61 +509,62 @@ ___printf_fp (FILE *fp,
- _FPIO_CONST_OFFSET) - _FPIO_CONST_OFFSET)
/* 64bit const offset is not enough for /* 64bit const offset is not enough for
IEEE quad long double. */ IEEE quad long double. */
tmpsize = powers->arraysize + _FPIO_CONST_SHIFT; p.tmpsize = powers->arraysize + _FPIO_CONST_SHIFT;
memcpy (tmp + _FPIO_CONST_SHIFT, memcpy (p.tmp + _FPIO_CONST_SHIFT,
&__tens[powers->arrayoff], &__tens[powers->arrayoff],
tmpsize * sizeof (mp_limb_t)); p.tmpsize * sizeof (mp_limb_t));
MPN_ZERO (tmp, _FPIO_CONST_SHIFT); MPN_ZERO (p.tmp, _FPIO_CONST_SHIFT);
/* Adjust exponent, as scaleexpo will be this much /* Adjust p.exponent, as scaleexpo will be this much
bigger too. */ bigger too. */
exponent += _FPIO_CONST_SHIFT * BITS_PER_MP_LIMB; p.exponent += _FPIO_CONST_SHIFT * BITS_PER_MP_LIMB;
} }
else else
#endif #endif
{ {
tmpsize = powers->arraysize; p.tmpsize = powers->arraysize;
memcpy (tmp, &__tens[powers->arrayoff], memcpy (p.tmp, &__tens[powers->arrayoff],
tmpsize * sizeof (mp_limb_t)); p.tmpsize * sizeof (mp_limb_t));
} }
} }
else else
{ {
cy = __mpn_mul (tmp, scale, scalesize, cy = __mpn_mul (p.tmp, p.scale, p.scalesize,
&__tens[powers->arrayoff &__tens[powers->arrayoff
+ _FPIO_CONST_OFFSET], + _FPIO_CONST_OFFSET],
powers->arraysize - _FPIO_CONST_OFFSET); powers->arraysize - _FPIO_CONST_OFFSET);
tmpsize = scalesize + powers->arraysize - _FPIO_CONST_OFFSET; p.tmpsize = p.scalesize +
powers->arraysize - _FPIO_CONST_OFFSET;
if (cy == 0) if (cy == 0)
--tmpsize; --p.tmpsize;
} }
if (MPN_GE (frac, tmp)) if (MPN_GE (p.frac, p.tmp))
{ {
int cnt; int cnt;
MPN_ASSIGN (scale, tmp); MPN_ASSIGN (p.scale, p.tmp);
count_leading_zeros (cnt, scale[scalesize - 1]); count_leading_zeros (cnt, p.scale[p.scalesize - 1]);
scaleexpo = (scalesize - 2) * BITS_PER_MP_LIMB - cnt - 1; scaleexpo = (p.scalesize - 2) * BITS_PER_MP_LIMB - cnt - 1;
exp10 |= 1 << explog; exp10 |= 1 << explog;
} }
} }
--explog; --explog;
} }
while (powers > &_fpioconst_pow10[0]); while (powers > &_fpioconst_pow10[0]);
exponent = exp10; p.exponent = exp10;
/* Optimize number representations. We want to represent the numbers /* Optimize number representations. We want to represent the numbers
with the lowest number of bytes possible without losing any with the lowest number of bytes possible without losing any
bytes. Also the highest bit in the scaling factor has to be set bytes. Also the highest bit in the scaling factor has to be set
(this is a requirement of the MPN division routines). */ (this is a requirement of the MPN division routines). */
if (scalesize > 0) if (p.scalesize > 0)
{ {
/* Determine minimum number of zero bits at the end of /* Determine minimum number of zero bits at the end of
both numbers. */ both numbers. */
for (i = 0; scale[i] == 0 && frac[i] == 0; i++) for (i = 0; p.scale[i] == 0 && p.frac[i] == 0; i++)
; ;
/* Determine number of bits the scaling factor is misplaced. */ /* Determine number of bits the scaling factor is misplaced. */
count_leading_zeros (cnt_h, scale[scalesize - 1]); count_leading_zeros (cnt_h, p.scale[p.scalesize - 1]);
if (cnt_h == 0) if (cnt_h == 0)
{ {
@ -567,27 +572,27 @@ ___printf_fp (FILE *fp,
we only have to remove the trailing empty limbs. */ we only have to remove the trailing empty limbs. */
if (i > 0) if (i > 0)
{ {
MPN_COPY_INCR (scale, scale + i, scalesize - i); MPN_COPY_INCR (p.scale, p.scale + i, p.scalesize - i);
scalesize -= i; p.scalesize -= i;
MPN_COPY_INCR (frac, frac + i, fracsize - i); MPN_COPY_INCR (p.frac, p.frac + i, p.fracsize - i);
fracsize -= i; p.fracsize -= i;
} }
} }
else else
{ {
if (scale[i] != 0) if (p.scale[i] != 0)
{ {
count_trailing_zeros (cnt_l, scale[i]); count_trailing_zeros (cnt_l, p.scale[i]);
if (frac[i] != 0) if (p.frac[i] != 0)
{ {
int cnt_l2; int cnt_l2;
count_trailing_zeros (cnt_l2, frac[i]); count_trailing_zeros (cnt_l2, p.frac[i]);
if (cnt_l2 < cnt_l) if (cnt_l2 < cnt_l)
cnt_l = cnt_l2; cnt_l = cnt_l2;
} }
} }
else else
count_trailing_zeros (cnt_l, frac[i]); count_trailing_zeros (cnt_l, p.frac[i]);
/* Now shift the numbers to their optimal position. */ /* Now shift the numbers to their optimal position. */
if (i == 0 && BITS_PER_MP_LIMB - cnt_h > cnt_l) if (i == 0 && BITS_PER_MP_LIMB - cnt_h > cnt_l)
@ -595,10 +600,10 @@ ___printf_fp (FILE *fp,
/* We cannot save any memory. So just roll both numbers /* We cannot save any memory. So just roll both numbers
so that the scaling factor has its highest bit set. */ so that the scaling factor has its highest bit set. */
(void) __mpn_lshift (scale, scale, scalesize, cnt_h); (void) __mpn_lshift (p.scale, p.scale, p.scalesize, cnt_h);
cy = __mpn_lshift (frac, frac, fracsize, cnt_h); cy = __mpn_lshift (p.frac, p.frac, p.fracsize, cnt_h);
if (cy != 0) if (cy != 0)
frac[fracsize++] = cy; p.frac[p.fracsize++] = cy;
} }
else if (BITS_PER_MP_LIMB - cnt_h <= cnt_l) else if (BITS_PER_MP_LIMB - cnt_h <= cnt_l)
{ {
@ -606,31 +611,32 @@ ___printf_fp (FILE *fp,
and by packing the non-zero limbs which gain another and by packing the non-zero limbs which gain another
free one. */ free one. */
(void) __mpn_rshift (scale, scale + i, scalesize - i, (void) __mpn_rshift (p.scale, p.scale + i, p.scalesize - i,
BITS_PER_MP_LIMB - cnt_h); BITS_PER_MP_LIMB - cnt_h);
scalesize -= i + 1; p.scalesize -= i + 1;
(void) __mpn_rshift (frac, frac + i, fracsize - i, (void) __mpn_rshift (p.frac, p.frac + i, p.fracsize - i,
BITS_PER_MP_LIMB - cnt_h); BITS_PER_MP_LIMB - cnt_h);
fracsize -= frac[fracsize - i - 1] == 0 ? i + 1 : i; p.fracsize -= p.frac[p.fracsize - i - 1] == 0 ? i + 1 : i;
} }
else else
{ {
/* We can only save the memory of the limbs which are zero. /* We can only save the memory of the limbs which are zero.
The non-zero parts occupy the same number of limbs. */ The non-zero parts occupy the same number of limbs. */
(void) __mpn_rshift (scale, scale + (i - 1), (void) __mpn_rshift (p.scale, p.scale + (i - 1),
scalesize - (i - 1), p.scalesize - (i - 1),
BITS_PER_MP_LIMB - cnt_h); BITS_PER_MP_LIMB - cnt_h);
scalesize -= i; p.scalesize -= i;
(void) __mpn_rshift (frac, frac + (i - 1), (void) __mpn_rshift (p.frac, p.frac + (i - 1),
fracsize - (i - 1), p.fracsize - (i - 1),
BITS_PER_MP_LIMB - cnt_h); BITS_PER_MP_LIMB - cnt_h);
fracsize -= frac[fracsize - (i - 1) - 1] == 0 ? i : i - 1; p.fracsize -=
p.frac[p.fracsize - (i - 1) - 1] == 0 ? i : i - 1;
} }
} }
} }
} }
else if (exponent < 0) else if (p.exponent < 0)
{ {
/* |FP| < 1.0. */ /* |FP| < 1.0. */
int exp10 = 0; int exp10 = 0;
@ -638,48 +644,48 @@ ___printf_fp (FILE *fp,
const struct mp_power *powers = &_fpioconst_pow10[explog + 1]; const struct mp_power *powers = &_fpioconst_pow10[explog + 1];
/* Now shift the input value to its right place. */ /* Now shift the input value to its right place. */
cy = __mpn_lshift (frac, fp_input, fracsize, to_shift); cy = __mpn_lshift (p.frac, fp_input, p.fracsize, to_shift);
frac[fracsize++] = cy; p.frac[p.fracsize++] = cy;
assert (cy == 1 || (frac[fracsize - 2] == 0 && frac[0] == 0)); assert (cy == 1 || (p.frac[p.fracsize - 2] == 0 && p.frac[0] == 0));
expsign = 1; p.expsign = 1;
exponent = -exponent; p.exponent = -p.exponent;
assert (powers != &_fpioconst_pow10[0]); assert (powers != &_fpioconst_pow10[0]);
do do
{ {
--powers; --powers;
if (exponent >= powers->m_expo) if (p.exponent >= powers->m_expo)
{ {
int i, incr, cnt_h, cnt_l; int i, incr, cnt_h, cnt_l;
mp_limb_t topval[2]; mp_limb_t topval[2];
/* The __mpn_mul function expects the first argument to be /* The __mpn_mul function expects the first argument to be
bigger than the second. */ bigger than the second. */
if (fracsize < powers->arraysize - _FPIO_CONST_OFFSET) if (p.fracsize < powers->arraysize - _FPIO_CONST_OFFSET)
cy = __mpn_mul (tmp, &__tens[powers->arrayoff cy = __mpn_mul (p.tmp, &__tens[powers->arrayoff
+ _FPIO_CONST_OFFSET], + _FPIO_CONST_OFFSET],
powers->arraysize - _FPIO_CONST_OFFSET, powers->arraysize - _FPIO_CONST_OFFSET,
frac, fracsize); p.frac, p.fracsize);
else else
cy = __mpn_mul (tmp, frac, fracsize, cy = __mpn_mul (p.tmp, p.frac, p.fracsize,
&__tens[powers->arrayoff + _FPIO_CONST_OFFSET], &__tens[powers->arrayoff + _FPIO_CONST_OFFSET],
powers->arraysize - _FPIO_CONST_OFFSET); powers->arraysize - _FPIO_CONST_OFFSET);
tmpsize = fracsize + powers->arraysize - _FPIO_CONST_OFFSET; p.tmpsize = p.fracsize + powers->arraysize - _FPIO_CONST_OFFSET;
if (cy == 0) if (cy == 0)
--tmpsize; --p.tmpsize;
count_leading_zeros (cnt_h, tmp[tmpsize - 1]); count_leading_zeros (cnt_h, p.tmp[p.tmpsize - 1]);
incr = (tmpsize - fracsize) * BITS_PER_MP_LIMB incr = (p.tmpsize - p.fracsize) * BITS_PER_MP_LIMB
+ BITS_PER_MP_LIMB - 1 - cnt_h; + BITS_PER_MP_LIMB - 1 - cnt_h;
assert (incr <= powers->p_expo); assert (incr <= powers->p_expo);
/* If we increased the exponent by exactly 3 we have to test /* If we increased the p.exponent by exactly 3 we have to test
for overflow. This is done by comparing with 10 shifted for overflow. This is done by comparing with 10 shifted
to the right position. */ to the right position. */
if (incr == exponent + 3) if (incr == p.exponent + 3)
{ {
if (cnt_h <= BITS_PER_MP_LIMB - 4) if (cnt_h <= BITS_PER_MP_LIMB - 4)
{ {
@ -701,32 +707,32 @@ ___printf_fp (FILE *fp,
against 10.0. If it is greater or equal to 10.0 the against 10.0. If it is greater or equal to 10.0 the
multiplication was not valid. This is because we cannot multiplication was not valid. This is because we cannot
determine the number of bits in the result in advance. */ determine the number of bits in the result in advance. */
if (incr < exponent + 3 if (incr < p.exponent + 3
|| (incr == exponent + 3 && || (incr == p.exponent + 3 &&
(tmp[tmpsize - 1] < topval[1] (p.tmp[p.tmpsize - 1] < topval[1]
|| (tmp[tmpsize - 1] == topval[1] || (p.tmp[p.tmpsize - 1] == topval[1]
&& tmp[tmpsize - 2] < topval[0])))) && p.tmp[p.tmpsize - 2] < topval[0]))))
{ {
/* The factor is right. Adapt binary and decimal /* The factor is right. Adapt binary and decimal
exponents. */ exponents. */
exponent -= incr; p.exponent -= incr;
exp10 |= 1 << explog; exp10 |= 1 << explog;
/* If this factor yields a number greater or equal to /* If this factor yields a number greater or equal to
1.0, we must not shift the non-fractional digits down. */ 1.0, we must not shift the non-fractional digits down. */
if (exponent < 0) if (p.exponent < 0)
cnt_h += -exponent; cnt_h += -p.exponent;
/* Now we optimize the number representation. */ /* Now we optimize the number representation. */
for (i = 0; tmp[i] == 0; ++i); for (i = 0; p.tmp[i] == 0; ++i);
if (cnt_h == BITS_PER_MP_LIMB - 1) if (cnt_h == BITS_PER_MP_LIMB - 1)
{ {
MPN_COPY (frac, tmp + i, tmpsize - i); MPN_COPY (p.frac, p.tmp + i, p.tmpsize - i);
fracsize = tmpsize - i; p.fracsize = p.tmpsize - i;
} }
else else
{ {
count_trailing_zeros (cnt_l, tmp[i]); count_trailing_zeros (cnt_l, p.tmp[i]);
/* Now shift the numbers to their optimal position. */ /* Now shift the numbers to their optimal position. */
if (i == 0 && BITS_PER_MP_LIMB - 1 - cnt_h > cnt_l) if (i == 0 && BITS_PER_MP_LIMB - 1 - cnt_h > cnt_l)
@ -735,15 +741,16 @@ ___printf_fp (FILE *fp,
number so that the leading digit is in a number so that the leading digit is in a
separate limb. */ separate limb. */
cy = __mpn_lshift (frac, tmp, tmpsize, cnt_h + 1); cy = __mpn_lshift (p.frac, p.tmp, p.tmpsize,
fracsize = tmpsize + 1; cnt_h + 1);
frac[fracsize - 1] = cy; p.fracsize = p.tmpsize + 1;
p.frac[p.fracsize - 1] = cy;
} }
else if (BITS_PER_MP_LIMB - 1 - cnt_h <= cnt_l) else if (BITS_PER_MP_LIMB - 1 - cnt_h <= cnt_l)
{ {
(void) __mpn_rshift (frac, tmp + i, tmpsize - i, (void) __mpn_rshift (p.frac, p.tmp + i, p.tmpsize - i,
BITS_PER_MP_LIMB - 1 - cnt_h); BITS_PER_MP_LIMB - 1 - cnt_h);
fracsize = tmpsize - i; p.fracsize = p.tmpsize - i;
} }
else else
{ {
@ -751,41 +758,41 @@ ___printf_fp (FILE *fp,
are zero. The non-zero parts occupy the same are zero. The non-zero parts occupy the same
number of limbs. */ number of limbs. */
(void) __mpn_rshift (frac, tmp + (i - 1), (void) __mpn_rshift (p.frac, p.tmp + (i - 1),
tmpsize - (i - 1), p.tmpsize - (i - 1),
BITS_PER_MP_LIMB - 1 - cnt_h); BITS_PER_MP_LIMB - 1 - cnt_h);
fracsize = tmpsize - (i - 1); p.fracsize = p.tmpsize - (i - 1);
} }
} }
} }
} }
--explog; --explog;
} }
while (powers != &_fpioconst_pow10[1] && exponent > 0); while (powers != &_fpioconst_pow10[1] && p.exponent > 0);
/* All factors but 10^-1 are tested now. */ /* All factors but 10^-1 are tested now. */
if (exponent > 0) if (p.exponent > 0)
{ {
int cnt_l; int cnt_l;
cy = __mpn_mul_1 (tmp, frac, fracsize, 10); cy = __mpn_mul_1 (p.tmp, p.frac, p.fracsize, 10);
tmpsize = fracsize; p.tmpsize = p.fracsize;
assert (cy == 0 || tmp[tmpsize - 1] < 20); assert (cy == 0 || p.tmp[p.tmpsize - 1] < 20);
count_trailing_zeros (cnt_l, tmp[0]); count_trailing_zeros (cnt_l, p.tmp[0]);
if (cnt_l < MIN (4, exponent)) if (cnt_l < MIN (4, p.exponent))
{ {
cy = __mpn_lshift (frac, tmp, tmpsize, cy = __mpn_lshift (p.frac, p.tmp, p.tmpsize,
BITS_PER_MP_LIMB - MIN (4, exponent)); BITS_PER_MP_LIMB - MIN (4, p.exponent));
if (cy != 0) if (cy != 0)
frac[tmpsize++] = cy; p.frac[p.tmpsize++] = cy;
} }
else else
(void) __mpn_rshift (frac, tmp, tmpsize, MIN (4, exponent)); (void) __mpn_rshift (p.frac, p.tmp, p.tmpsize, MIN (4, p.exponent));
fracsize = tmpsize; p.fracsize = p.tmpsize;
exp10 |= 1; exp10 |= 1;
assert (frac[fracsize - 1] < 10); assert (p.frac[p.fracsize - 1] < 10);
} }
exponent = exp10; p.exponent = exp10;
} }
else else
{ {
@ -793,13 +800,13 @@ ___printf_fp (FILE *fp,
numbers are in the range of 1.0 <= |fp| < 8.0. We simply numbers are in the range of 1.0 <= |fp| < 8.0. We simply
shift it to the right place and divide it by 1.0 to get the shift it to the right place and divide it by 1.0 to get the
leading digit. (Of course this division is not really made.) */ leading digit. (Of course this division is not really made.) */
assert (0 <= exponent && exponent < 3 && assert (0 <= p.exponent && p.exponent < 3 &&
exponent + to_shift < BITS_PER_MP_LIMB); p.exponent + to_shift < BITS_PER_MP_LIMB);
/* Now shift the input value to its right place. */ /* Now shift the input value to its right place. */
cy = __mpn_lshift (frac, fp_input, fracsize, (exponent + to_shift)); cy = __mpn_lshift (p.frac, fp_input, p.fracsize, (p.exponent + to_shift));
frac[fracsize++] = cy; p.frac[p.fracsize++] = cy;
exponent = 0; p.exponent = 0;
} }
{ {
@ -817,7 +824,7 @@ ___printf_fp (FILE *fp,
if (spec == 'e') if (spec == 'e')
{ {
type = info->spec; p.type = info->spec;
intdig_max = 1; intdig_max = 1;
fracdig_min = fracdig_max = info->prec < 0 ? 6 : info->prec; fracdig_min = fracdig_max = info->prec < 0 ? 6 : info->prec;
chars_needed = 1 + 1 + (size_t) fracdig_max + 1 + 1 + 4; chars_needed = 1 + 1 + (size_t) fracdig_max + 1 + 1 + 4;
@ -827,15 +834,15 @@ ___printf_fp (FILE *fp,
} }
else if (spec == 'f') else if (spec == 'f')
{ {
type = 'f'; p.type = 'f';
fracdig_min = fracdig_max = info->prec < 0 ? 6 : info->prec; fracdig_min = fracdig_max = info->prec < 0 ? 6 : info->prec;
dig_max = INT_MAX; /* Unlimited. */ dig_max = INT_MAX; /* Unlimited. */
significant = 1; /* Does not matter here. */ significant = 1; /* Does not matter here. */
if (expsign == 0) if (p.expsign == 0)
{ {
intdig_max = exponent + 1; intdig_max = p.exponent + 1;
/* This can be really big! */ /* XXX Maybe malloc if too big? */ /* This can be really big! */ /* XXX Maybe malloc if too big? */
chars_needed = (size_t) exponent + 1 + 1 + (size_t) fracdig_max; chars_needed = (size_t) p.exponent + 1 + 1 + (size_t) fracdig_max;
} }
else else
{ {
@ -846,27 +853,27 @@ ___printf_fp (FILE *fp,
else else
{ {
dig_max = info->prec < 0 ? 6 : (info->prec == 0 ? 1 : info->prec); dig_max = info->prec < 0 ? 6 : (info->prec == 0 ? 1 : info->prec);
if ((expsign == 0 && exponent >= dig_max) if ((p.expsign == 0 && p.exponent >= dig_max)
|| (expsign != 0 && exponent > 4)) || (p.expsign != 0 && p.exponent > 4))
{ {
if ('g' - 'G' == 'e' - 'E') if ('g' - 'G' == 'e' - 'E')
type = 'E' + (info->spec - 'G'); p.type = 'E' + (info->spec - 'G');
else else
type = isupper (info->spec) ? 'E' : 'e'; p.type = isupper (info->spec) ? 'E' : 'e';
fracdig_max = dig_max - 1; fracdig_max = dig_max - 1;
intdig_max = 1; intdig_max = 1;
chars_needed = 1 + 1 + (size_t) fracdig_max + 1 + 1 + 4; chars_needed = 1 + 1 + (size_t) fracdig_max + 1 + 1 + 4;
} }
else else
{ {
type = 'f'; p.type = 'f';
intdig_max = expsign == 0 ? exponent + 1 : 0; intdig_max = p.expsign == 0 ? p.exponent + 1 : 0;
fracdig_max = dig_max - intdig_max; fracdig_max = dig_max - intdig_max;
/* We need space for the significant digits and perhaps /* We need space for the significant digits and perhaps
for leading zeros when < 1.0. The number of leading for leading zeros when < 1.0. The number of leading
zeros can be as many as would be required for zeros can be as many as would be required for
exponential notation with a negative two-digit exponential notation with a negative two-digit
exponent, which is 4. */ p.exponent, which is 4. */
chars_needed = (size_t) dig_max + 1 + 4; chars_needed = (size_t) dig_max + 1 + 4;
} }
fracdig_min = info->alt ? fracdig_max : 0; fracdig_min = info->alt ? fracdig_max : 0;
@ -908,26 +915,26 @@ ___printf_fp (FILE *fp,
wcp = wstartp = wbuffer + 2; /* Let room for rounding. */ wcp = wstartp = wbuffer + 2; /* Let room for rounding. */
/* Do the real work: put digits in allocated buffer. */ /* Do the real work: put digits in allocated buffer. */
if (expsign == 0 || type != 'f') if (p.expsign == 0 || p.type != 'f')
{ {
assert (expsign == 0 || intdig_max == 1); assert (p.expsign == 0 || intdig_max == 1);
while (intdig_no < intdig_max) while (intdig_no < intdig_max)
{ {
++intdig_no; ++intdig_no;
*wcp++ = hack_digit (); *wcp++ = hack_digit (&p);
} }
significant = 1; significant = 1;
if (info->alt if (info->alt
|| fracdig_min > 0 || fracdig_min > 0
|| (fracdig_max > 0 && (fracsize > 1 || frac[0] != 0))) || (fracdig_max > 0 && (p.fracsize > 1 || p.frac[0] != 0)))
*wcp++ = decimalwc; *wcp++ = decimalwc;
} }
else else
{ {
/* |fp| < 1.0 and the selected type is 'f', so put "0." /* |fp| < 1.0 and the selected p.type is 'f', so put "0."
in the buffer. */ in the buffer. */
*wcp++ = L'0'; *wcp++ = L'0';
--exponent; --p.exponent;
*wcp++ = decimalwc; *wcp++ = decimalwc;
} }
@ -935,10 +942,10 @@ ___printf_fp (FILE *fp,
int fracdig_no = 0; int fracdig_no = 0;
int added_zeros = 0; int added_zeros = 0;
while (fracdig_no < fracdig_min + added_zeros while (fracdig_no < fracdig_min + added_zeros
|| (fracdig_no < fracdig_max && (fracsize > 1 || frac[0] != 0))) || (fracdig_no < fracdig_max && (p.fracsize > 1 || p.frac[0] != 0)))
{ {
++fracdig_no; ++fracdig_no;
*wcp = hack_digit (); *wcp = hack_digit (&p);
if (*wcp++ != L'0') if (*wcp++ != L'0')
significant = 1; significant = 1;
else if (significant == 0) else if (significant == 0)
@ -951,19 +958,19 @@ ___printf_fp (FILE *fp,
/* Do rounding. */ /* Do rounding. */
wchar_t last_digit = wcp[-1] != decimalwc ? wcp[-1] : wcp[-2]; wchar_t last_digit = wcp[-1] != decimalwc ? wcp[-1] : wcp[-2];
wchar_t next_digit = hack_digit (); wchar_t next_digit = hack_digit (&p);
bool more_bits; bool more_bits;
if (next_digit != L'0' && next_digit != L'5') if (next_digit != L'0' && next_digit != L'5')
more_bits = true; more_bits = true;
else if (fracsize == 1 && frac[0] == 0) else if (p.fracsize == 1 && p.frac[0] == 0)
/* Rest of the number is zero. */ /* Rest of the number is zero. */
more_bits = false; more_bits = false;
else if (scalesize == 0) else if (p.scalesize == 0)
{ {
/* Here we have to see whether all limbs are zero since no /* Here we have to see whether all limbs are zero since no
normalization happened. */ normalization happened. */
size_t lcnt = fracsize; size_t lcnt = p.fracsize;
while (lcnt >= 1 && frac[lcnt - 1] == 0) while (lcnt >= 1 && p.frac[lcnt - 1] == 0)
--lcnt; --lcnt;
more_bits = lcnt > 0; more_bits = lcnt > 0;
} }
@ -990,7 +997,7 @@ ___printf_fp (FILE *fp,
if (*wtp != decimalwc) if (*wtp != decimalwc)
/* Round up. */ /* Round up. */
(*wtp)++; (*wtp)++;
else if (__builtin_expect (spec == 'g' && type == 'f' && info->alt else if (__builtin_expect (spec == 'g' && p.type == 'f' && info->alt
&& wtp == wstartp + 1 && wtp == wstartp + 1
&& wstartp[0] == L'0', && wstartp[0] == L'0',
0)) 0))
@ -1015,20 +1022,20 @@ ___printf_fp (FILE *fp,
else else
/* It is more critical. All digits were 9's. */ /* It is more critical. All digits were 9's. */
{ {
if (type != 'f') if (p.type != 'f')
{ {
*wstartp = '1'; *wstartp = '1';
exponent += expsign == 0 ? 1 : -1; p.exponent += p.expsign == 0 ? 1 : -1;
/* The above exponent adjustment could lead to 1.0e-00, /* The above p.exponent adjustment could lead to 1.0e-00,
e.g. for 0.999999999. Make sure exponent 0 always e.g. for 0.999999999. Make sure p.exponent 0 always
uses + sign. */ uses + sign. */
if (exponent == 0) if (p.exponent == 0)
expsign = 0; p.expsign = 0;
} }
else if (intdig_no == dig_max) else if (intdig_no == dig_max)
{ {
/* This is the case where for type %g the number fits /* This is the case where for p.type %g the number fits
really in the range for %f output but after rounding really in the range for %f output but after rounding
the number of digits is too big. */ the number of digits is too big. */
*--wstartp = decimalwc; *--wstartp = decimalwc;
@ -1044,9 +1051,9 @@ ___printf_fp (FILE *fp,
fracdig_no += intdig_no; fracdig_no += intdig_no;
intdig_no = 1; intdig_no = 1;
fracdig_max = intdig_max - intdig_no; fracdig_max = intdig_max - intdig_no;
++exponent; ++p.exponent;
/* Now we must print the exponent. */ /* Now we must print the p.exponent. */
type = isupper (info->spec) ? 'E' : 'e'; p.type = isupper (info->spec) ? 'E' : 'e';
} }
else else
{ {
@ -1091,14 +1098,14 @@ ___printf_fp (FILE *fp,
ngroups); ngroups);
} }
/* Write the exponent if it is needed. */ /* Write the p.exponent if it is needed. */
if (type != 'f') if (p.type != 'f')
{ {
if (__glibc_unlikely (expsign != 0 && exponent == 4 && spec == 'g')) if (__glibc_unlikely (p.expsign != 0 && p.exponent == 4 && spec == 'g'))
{ {
/* This is another special case. The exponent of the number is /* This is another special case. The p.exponent of the number is
really smaller than -4, which requires the 'e'/'E' format. really smaller than -4, which requires the 'e'/'E' format.
But after rounding the number has an exponent of -4. */ But after rounding the number has an p.exponent of -4. */
assert (wcp >= wstartp + 1); assert (wcp >= wstartp + 1);
assert (wstartp[0] == L'1'); assert (wstartp[0] == L'1');
__wmemcpy (wstartp, L"0.0001", 6); __wmemcpy (wstartp, L"0.0001", 6);
@ -1113,26 +1120,26 @@ ___printf_fp (FILE *fp,
} }
else else
{ {
*wcp++ = (wchar_t) type; *wcp++ = (wchar_t) p.type;
*wcp++ = expsign ? L'-' : L'+'; *wcp++ = p.expsign ? L'-' : L'+';
/* Find the magnitude of the exponent. */ /* Find the magnitude of the p.exponent. */
expscale = 10; expscale = 10;
while (expscale <= exponent) while (expscale <= p.exponent)
expscale *= 10; expscale *= 10;
if (exponent < 10) if (p.exponent < 10)
/* Exponent always has at least two digits. */ /* Exponent always has at least two digits. */
*wcp++ = L'0'; *wcp++ = L'0';
else else
do do
{ {
expscale /= 10; expscale /= 10;
*wcp++ = L'0' + (exponent / expscale); *wcp++ = L'0' + (p.exponent / expscale);
exponent %= expscale; p.exponent %= expscale;
} }
while (expscale > 10); while (expscale > 10);
*wcp++ = L'0' + exponent; *wcp++ = L'0' + p.exponent;
} }
} }