From patchwork Fri Sep 26 20:57:50 2014 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Konstantin Serebryany X-Patchwork-Id: 393978 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Received: from sourceware.org (server1.sourceware.org [209.132.180.131]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by ozlabs.org (Postfix) with ESMTPS id 7CD3014008C for ; Sat, 27 Sep 2014 06:58:23 +1000 (EST) DomainKey-Signature: a=rsa-sha1; c=nofws; d=sourceware.org; h=list-id :list-unsubscribe:list-subscribe:list-archive:list-post :list-help:sender:mime-version:in-reply-to:references:from:date :message-id:subject:to:cc:content-type; q=dns; s=default; b=wkT/ UPThtRclAZQmEMYC6Z11U5ppck2Ah4Gjgf81CdF+zsqFCzLEH+Lq0Kw1r2OhsbML 1rIbdHigZtw32+DeWxvbHsNqt313StePIK+CxUHPvx1bIZ9HkBfVuA/VrXLcW0pK yz7aBx0XqtnJbr0q+LYKzUGeeIF4iSK7zBkPJCI= DKIM-Signature: v=1; a=rsa-sha1; c=relaxed; d=sourceware.org; h=list-id :list-unsubscribe:list-subscribe:list-archive:list-post :list-help:sender:mime-version:in-reply-to:references:from:date :message-id:subject:to:cc:content-type; s=default; bh=zc+TPAfd7o IgGFcvxyiDTMQDKRU=; b=ZfiL8ZKZ5x4keya4EI+ZUCrD/feh1SkxfpmHZ9HiyK DR3QpL+9ocDD3Hxr1avWzWvXB1IyYv7mnQFgGKwBiGF8VrumiabWVVbUCBP4QyEP aBx9kbmFitfK3t6aeE/POC0N1DcfekngxYZJ+MWEimSklIl4d7Gr8ZG8WXLjbzYF s= Received: (qmail 18427 invoked by alias); 26 Sep 2014 20:58:17 -0000 Mailing-List: contact libc-alpha-help@sourceware.org; run by ezmlm Precedence: bulk List-Id: List-Unsubscribe: List-Subscribe: List-Archive: List-Post: List-Help: , Sender: libc-alpha-owner@sourceware.org Delivered-To: mailing list libc-alpha@sourceware.org Received: (qmail 18414 invoked by uid 89); 26 Sep 2014 20:58:16 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-2.4 required=5.0 tests=AWL, BAYES_00, FREEMAIL_FROM, RCVD_IN_DNSWL_LOW, SPF_PASS autolearn=ham version=3.3.2 X-HELO: mail-vc0-f172.google.com X-Received: by 10.52.76.130 with SMTP id k2mr14719910vdw.9.1411765090876; Fri, 26 Sep 2014 13:58:10 -0700 (PDT) MIME-Version: 1.0 In-Reply-To: <20140926193846.BF4482C39D8@topped-with-meat.com> References: <87a960l9ze.fsf@igel.home> <20140922214338.0D30A2C3971@topped-with-meat.com> <20140922224516.EAC342C3971@topped-with-meat.com> <20140926193846.BF4482C39D8@topped-with-meat.com> From: Konstantin Serebryany Date: Fri, 26 Sep 2014 13:57:50 -0700 Message-ID: Subject: Re: [PATCH] remove nested function hack_digit To: Roland McGrath Cc: Andreas Schwab , GNU C Library I've attached a patch that addresses your comments. 2014-09-26 Kostya Serebryany * 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. On Fri, Sep 26, 2014 at 12:38 PM, Roland McGrath wrote: >> Here is a better formatted and tested patch that uses a single parameter. >> The generated code is nearly identical (same instructions, differences >> only in constant offsets). > > This change looks mostly OK to me. It's not clear to me what you're saying > this version's generated code is identical to. If you're just saying it's > identical to the version of the patch that differs only cosmetically, then > that's not interesting. The clear comparison of the trunk code to the > patched code is what we need. The comparison is between the trunk and the current patch. The differences are minimal. hack_digit has the same number of instructions and the diff mostly look like this: 23c24 < 4a39b: 74 14 je 4a3b1 --- > 4a39b: 74 14 je 4a3b1 25,27c26,28 < 4a3a1: 48 8d 4a 01 lea 0x1(%rdx),%rcx < 4a3a5: 48 89 4b 18 mov %rcx,0x18(%rbx) < 4a3a9: 48 8b 4b 10 mov 0x10(%rbx),%rcx --- > 4a3a1: 48 8b 4b 10 mov 0x10(%rbx),%rcx > 4a3a5: 48 8d 72 01 lea 0x1(%rdx),%rsi > 4a3a9: 48 89 73 18 mov %rsi,0x18(%rbx) ... The changes in __printf_fp are also minimal (same number of instructions) > It's not especially helpful to attach the > whole disassembly (we can all compile it for ourselves). What's important > is to do the careful analysis of the code differences and explain their > expected performance impact. I don't see any changes that may impact performance. > >> +2014-09-15 Kostya Serebryany > > In patch submissions, the log entry should not be part of the patch. > >> + * stdio-common/printf_fp.c (hack_digit): New function. >> + (___printf_fp): Remove nested function hack_digit. Call non-nested >> + function hack_digit. > > Two spaces between sentences. I would have written this: > > * 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. > >> +static wchar_t hack_digit (struct hack_digit_param *p) >> +{ > > The parts of the declaration before the function name get their own line, > with the function name starting the next line. > > You didn't report what testing you did on this patch. I've runs "make check". On my system I get same number of failures with and w/o the patch: 107 FAIL 1616 PASS 121 XFAIL 3 XPASS All of the tests in stdio-common pass. The failures I see are in nptl (many) and in these tests FAIL: debug/tst-backtrace2 FAIL: debug/tst-backtrace3 FAIL: debug/tst-backtrace4 FAIL: debug/tst-backtrace5 FAIL: debug/tst-backtrace6 FAIL: dlfcn/bug-atexit3 FAIL: elf/check-abi-libc FAIL: grp/testgrp FAIL: posix/globtest FAIL: rt/tst-cpuclock2 FAIL: rt/tst-mqueue8 FAIL: rt/tst-mqueue8x off-topic -- how do I achieve a clean "make check" run on Ubuntu 14.04? This is what I do: ../glibc/configure --prefix=$HOME/glibc-clang/inst && make -j 40 && make -j 40 check --kcc > > > Thanks, > Roland diff --git a/stdio-common/printf_fp.c b/stdio-common/printf_fp.c index 9cd4b4b..c8061cb 100644 --- a/stdio-common/printf_fp.c +++ b/stdio-common/printf_fp.c @@ -148,6 +148,65 @@ static wchar_t *group_number (wchar_t *buf, wchar_t *bufend, wchar_t thousands_sep, int ngroups) 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 ___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. */ int to_shift = 0; - /* The fraction of the floting-point value in question */ - MPN_VAR(frac); - /* and the exponent. */ - int exponent; - /* Sign of the exponent. */ - int expsign = 0; + struct hack_digit_param p; /* Sign of float number. */ 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. */ int done = 0; @@ -213,49 +258,7 @@ ___printf_fp (FILE *fp, /* Flag whether wbuffer is malloc'ed or not. */ int buffer_malloced = 0; - auto wchar_t hack_digit (void); - - 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; - } - + p.expsign = 0; /* Figure out the decimal point character. */ if (info->extra == 0) @@ -360,12 +363,12 @@ ___printf_fp (FILE *fp, } else { - fracsize = __mpn_extract_long_double (fp_input, + p.fracsize = __mpn_extract_long_double (fp_input, (sizeof (fp_input) / sizeof (fp_input[0])), - &exponent, &is_neg, + &p.exponent, &is_neg, 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 @@ -406,11 +409,11 @@ ___printf_fp (FILE *fp, } else { - fracsize = __mpn_extract_double (fp_input, + p.fracsize = __mpn_extract_double (fp_input, (sizeof (fp_input) / sizeof (fp_input[0])), - &exponent, &is_neg, fpnum.dbl); - to_shift = 1 + fracsize * BITS_PER_MP_LIMB - DBL_MANT_DIG; + &p.exponent, &is_neg, fpnum.dbl); + 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 efficient to use variables of the fixed maximum size but because this 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 + (LDBL_MANT_DIG / BITS_PER_MP_LIMB > 2 ? 8 : 4)) * sizeof (mp_limb_t); - frac = (mp_limb_t *) alloca (bignum_size); - tmp = (mp_limb_t *) alloca (bignum_size); - scale = (mp_limb_t *) alloca (bignum_size); + p.frac = (mp_limb_t *) alloca (bignum_size); + p.tmp = (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 exponents because the method used for the one is not applicable/efficient for the other. */ - scalesize = 0; - if (exponent > 2) + p.scalesize = 0; + if (p.exponent > 2) { /* |FP| >= 8.0. */ int scaleexpo = 0; @@ -468,22 +471,23 @@ ___printf_fp (FILE *fp, const struct mp_power *powers = &_fpioconst_pow10[explog + 1]; 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, - fp_input, fracsize); - fracsize += (exponent + to_shift) / BITS_PER_MP_LIMB; + MPN_COPY_DECR (p.frac + (p.exponent + to_shift) / BITS_PER_MP_LIMB, + fp_input, p.fracsize); + p.fracsize += (p.exponent + to_shift) / BITS_PER_MP_LIMB; } else { - cy = __mpn_lshift (frac + (exponent + to_shift) / BITS_PER_MP_LIMB, - fp_input, fracsize, - (exponent + to_shift) % BITS_PER_MP_LIMB); - fracsize += (exponent + to_shift) / BITS_PER_MP_LIMB; + cy = __mpn_lshift (p.frac + + (p.exponent + to_shift) / BITS_PER_MP_LIMB, + fp_input, p.fracsize, + (p.exponent + to_shift) % BITS_PER_MP_LIMB); + p.fracsize += (p.exponent + to_shift) / BITS_PER_MP_LIMB; 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]); do @@ -492,9 +496,9 @@ ___printf_fp (FILE *fp, /* The number of the product of two binary numbers with n and m 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 if (LDBL_MANT_DIG > _FPIO_CONST_OFFSET * BITS_PER_MP_LIMB @@ -505,61 +509,62 @@ ___printf_fp (FILE *fp, - _FPIO_CONST_OFFSET) /* 64bit const offset is not enough for IEEE quad long double. */ - tmpsize = powers->arraysize + _FPIO_CONST_SHIFT; - memcpy (tmp + _FPIO_CONST_SHIFT, + p.tmpsize = powers->arraysize + _FPIO_CONST_SHIFT; + memcpy (p.tmp + _FPIO_CONST_SHIFT, &__tens[powers->arrayoff], - tmpsize * sizeof (mp_limb_t)); - MPN_ZERO (tmp, _FPIO_CONST_SHIFT); - /* Adjust exponent, as scaleexpo will be this much + p.tmpsize * sizeof (mp_limb_t)); + MPN_ZERO (p.tmp, _FPIO_CONST_SHIFT); + /* Adjust p.exponent, as scaleexpo will be this much bigger too. */ - exponent += _FPIO_CONST_SHIFT * BITS_PER_MP_LIMB; + p.exponent += _FPIO_CONST_SHIFT * BITS_PER_MP_LIMB; } else #endif { - tmpsize = powers->arraysize; - memcpy (tmp, &__tens[powers->arrayoff], - tmpsize * sizeof (mp_limb_t)); + p.tmpsize = powers->arraysize; + memcpy (p.tmp, &__tens[powers->arrayoff], + p.tmpsize * sizeof (mp_limb_t)); } } else { - cy = __mpn_mul (tmp, scale, scalesize, + cy = __mpn_mul (p.tmp, p.scale, p.scalesize, &__tens[powers->arrayoff + _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) - --tmpsize; + --p.tmpsize; } - if (MPN_GE (frac, tmp)) + if (MPN_GE (p.frac, p.tmp)) { int cnt; - MPN_ASSIGN (scale, tmp); - count_leading_zeros (cnt, scale[scalesize - 1]); - scaleexpo = (scalesize - 2) * BITS_PER_MP_LIMB - cnt - 1; + MPN_ASSIGN (p.scale, p.tmp); + count_leading_zeros (cnt, p.scale[p.scalesize - 1]); + scaleexpo = (p.scalesize - 2) * BITS_PER_MP_LIMB - cnt - 1; exp10 |= 1 << explog; } } --explog; } while (powers > &_fpioconst_pow10[0]); - exponent = exp10; + p.exponent = exp10; /* Optimize number representations. We want to represent the numbers with the lowest number of bytes possible without losing any bytes. Also the highest bit in the scaling factor has to be set (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 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. */ - count_leading_zeros (cnt_h, scale[scalesize - 1]); + count_leading_zeros (cnt_h, p.scale[p.scalesize - 1]); if (cnt_h == 0) { @@ -567,27 +572,27 @@ ___printf_fp (FILE *fp, we only have to remove the trailing empty limbs. */ if (i > 0) { - MPN_COPY_INCR (scale, scale + i, scalesize - i); - scalesize -= i; - MPN_COPY_INCR (frac, frac + i, fracsize - i); - fracsize -= i; + MPN_COPY_INCR (p.scale, p.scale + i, p.scalesize - i); + p.scalesize -= i; + MPN_COPY_INCR (p.frac, p.frac + i, p.fracsize - i); + p.fracsize -= i; } } else { - if (scale[i] != 0) + if (p.scale[i] != 0) { - count_trailing_zeros (cnt_l, scale[i]); - if (frac[i] != 0) + count_trailing_zeros (cnt_l, p.scale[i]); + if (p.frac[i] != 0) { int cnt_l2; - count_trailing_zeros (cnt_l2, frac[i]); + count_trailing_zeros (cnt_l2, p.frac[i]); if (cnt_l2 < cnt_l) cnt_l = cnt_l2; } } else - count_trailing_zeros (cnt_l, frac[i]); + count_trailing_zeros (cnt_l, p.frac[i]); /* Now shift the numbers to their optimal position. */ 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 so that the scaling factor has its highest bit set. */ - (void) __mpn_lshift (scale, scale, scalesize, cnt_h); - cy = __mpn_lshift (frac, frac, fracsize, cnt_h); + (void) __mpn_lshift (p.scale, p.scale, p.scalesize, cnt_h); + cy = __mpn_lshift (p.frac, p.frac, p.fracsize, cnt_h); if (cy != 0) - frac[fracsize++] = cy; + p.frac[p.fracsize++] = cy; } 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 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); - scalesize -= i + 1; - (void) __mpn_rshift (frac, frac + i, fracsize - i, + p.scalesize -= i + 1; + (void) __mpn_rshift (p.frac, p.frac + i, p.fracsize - i, 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 { /* We can only save the memory of the limbs which are zero. The non-zero parts occupy the same number of limbs. */ - (void) __mpn_rshift (scale, scale + (i - 1), - scalesize - (i - 1), + (void) __mpn_rshift (p.scale, p.scale + (i - 1), + p.scalesize - (i - 1), BITS_PER_MP_LIMB - cnt_h); - scalesize -= i; - (void) __mpn_rshift (frac, frac + (i - 1), - fracsize - (i - 1), + p.scalesize -= i; + (void) __mpn_rshift (p.frac, p.frac + (i - 1), + p.fracsize - (i - 1), 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. */ int exp10 = 0; @@ -638,48 +644,48 @@ ___printf_fp (FILE *fp, const struct mp_power *powers = &_fpioconst_pow10[explog + 1]; /* Now shift the input value to its right place. */ - cy = __mpn_lshift (frac, fp_input, fracsize, to_shift); - frac[fracsize++] = cy; - assert (cy == 1 || (frac[fracsize - 2] == 0 && frac[0] == 0)); + cy = __mpn_lshift (p.frac, fp_input, p.fracsize, to_shift); + p.frac[p.fracsize++] = cy; + assert (cy == 1 || (p.frac[p.fracsize - 2] == 0 && p.frac[0] == 0)); - expsign = 1; - exponent = -exponent; + p.expsign = 1; + p.exponent = -p.exponent; assert (powers != &_fpioconst_pow10[0]); do { --powers; - if (exponent >= powers->m_expo) + if (p.exponent >= powers->m_expo) { int i, incr, cnt_h, cnt_l; mp_limb_t topval[2]; /* The __mpn_mul function expects the first argument to be bigger than the second. */ - if (fracsize < powers->arraysize - _FPIO_CONST_OFFSET) - cy = __mpn_mul (tmp, &__tens[powers->arrayoff + if (p.fracsize < powers->arraysize - _FPIO_CONST_OFFSET) + cy = __mpn_mul (p.tmp, &__tens[powers->arrayoff + _FPIO_CONST_OFFSET], powers->arraysize - _FPIO_CONST_OFFSET, - frac, fracsize); + p.frac, p.fracsize); else - cy = __mpn_mul (tmp, frac, fracsize, + cy = __mpn_mul (p.tmp, p.frac, p.fracsize, &__tens[powers->arrayoff + _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) - --tmpsize; + --p.tmpsize; - count_leading_zeros (cnt_h, tmp[tmpsize - 1]); - incr = (tmpsize - fracsize) * BITS_PER_MP_LIMB + count_leading_zeros (cnt_h, p.tmp[p.tmpsize - 1]); + incr = (p.tmpsize - p.fracsize) * BITS_PER_MP_LIMB + BITS_PER_MP_LIMB - 1 - cnt_h; 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 to the right position. */ - if (incr == exponent + 3) + if (incr == p.exponent + 3) { 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 multiplication was not valid. This is because we cannot determine the number of bits in the result in advance. */ - if (incr < exponent + 3 - || (incr == exponent + 3 && - (tmp[tmpsize - 1] < topval[1] - || (tmp[tmpsize - 1] == topval[1] - && tmp[tmpsize - 2] < topval[0])))) + if (incr < p.exponent + 3 + || (incr == p.exponent + 3 && + (p.tmp[p.tmpsize - 1] < topval[1] + || (p.tmp[p.tmpsize - 1] == topval[1] + && p.tmp[p.tmpsize - 2] < topval[0])))) { /* The factor is right. Adapt binary and decimal exponents. */ - exponent -= incr; + p.exponent -= incr; exp10 |= 1 << explog; /* If this factor yields a number greater or equal to 1.0, we must not shift the non-fractional digits down. */ - if (exponent < 0) - cnt_h += -exponent; + if (p.exponent < 0) + cnt_h += -p.exponent; /* 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) { - MPN_COPY (frac, tmp + i, tmpsize - i); - fracsize = tmpsize - i; + MPN_COPY (p.frac, p.tmp + i, p.tmpsize - i); + p.fracsize = p.tmpsize - i; } else { - count_trailing_zeros (cnt_l, tmp[i]); + count_trailing_zeros (cnt_l, p.tmp[i]); /* Now shift the numbers to their optimal position. */ 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 separate limb. */ - cy = __mpn_lshift (frac, tmp, tmpsize, cnt_h + 1); - fracsize = tmpsize + 1; - frac[fracsize - 1] = cy; + cy = __mpn_lshift (p.frac, p.tmp, p.tmpsize, + cnt_h + 1); + p.fracsize = p.tmpsize + 1; + p.frac[p.fracsize - 1] = cy; } 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); - fracsize = tmpsize - i; + p.fracsize = p.tmpsize - i; } else { @@ -751,41 +758,41 @@ ___printf_fp (FILE *fp, are zero. The non-zero parts occupy the same number of limbs. */ - (void) __mpn_rshift (frac, tmp + (i - 1), - tmpsize - (i - 1), + (void) __mpn_rshift (p.frac, p.tmp + (i - 1), + p.tmpsize - (i - 1), BITS_PER_MP_LIMB - 1 - cnt_h); - fracsize = tmpsize - (i - 1); + p.fracsize = p.tmpsize - (i - 1); } } } } --explog; } - while (powers != &_fpioconst_pow10[1] && exponent > 0); + while (powers != &_fpioconst_pow10[1] && p.exponent > 0); /* All factors but 10^-1 are tested now. */ - if (exponent > 0) + if (p.exponent > 0) { int cnt_l; - cy = __mpn_mul_1 (tmp, frac, fracsize, 10); - tmpsize = fracsize; - assert (cy == 0 || tmp[tmpsize - 1] < 20); + cy = __mpn_mul_1 (p.tmp, p.frac, p.fracsize, 10); + p.tmpsize = p.fracsize; + assert (cy == 0 || p.tmp[p.tmpsize - 1] < 20); - count_trailing_zeros (cnt_l, tmp[0]); - if (cnt_l < MIN (4, exponent)) + count_trailing_zeros (cnt_l, p.tmp[0]); + if (cnt_l < MIN (4, p.exponent)) { - cy = __mpn_lshift (frac, tmp, tmpsize, - BITS_PER_MP_LIMB - MIN (4, exponent)); + cy = __mpn_lshift (p.frac, p.tmp, p.tmpsize, + BITS_PER_MP_LIMB - MIN (4, p.exponent)); if (cy != 0) - frac[tmpsize++] = cy; + p.frac[p.tmpsize++] = cy; } else - (void) __mpn_rshift (frac, tmp, tmpsize, MIN (4, exponent)); - fracsize = tmpsize; + (void) __mpn_rshift (p.frac, p.tmp, p.tmpsize, MIN (4, p.exponent)); + p.fracsize = p.tmpsize; exp10 |= 1; - assert (frac[fracsize - 1] < 10); + assert (p.frac[p.fracsize - 1] < 10); } - exponent = exp10; + p.exponent = exp10; } else { @@ -793,13 +800,13 @@ ___printf_fp (FILE *fp, 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 leading digit. (Of course this division is not really made.) */ - assert (0 <= exponent && exponent < 3 && - exponent + to_shift < BITS_PER_MP_LIMB); + assert (0 <= p.exponent && p.exponent < 3 && + p.exponent + to_shift < BITS_PER_MP_LIMB); /* Now shift the input value to its right place. */ - cy = __mpn_lshift (frac, fp_input, fracsize, (exponent + to_shift)); - frac[fracsize++] = cy; - exponent = 0; + cy = __mpn_lshift (p.frac, fp_input, p.fracsize, (p.exponent + to_shift)); + p.frac[p.fracsize++] = cy; + p.exponent = 0; } { @@ -817,7 +824,7 @@ ___printf_fp (FILE *fp, if (spec == 'e') { - type = info->spec; + p.type = info->spec; intdig_max = 1; fracdig_min = fracdig_max = info->prec < 0 ? 6 : info->prec; chars_needed = 1 + 1 + (size_t) fracdig_max + 1 + 1 + 4; @@ -827,15 +834,15 @@ ___printf_fp (FILE *fp, } else if (spec == 'f') { - type = 'f'; + p.type = 'f'; fracdig_min = fracdig_max = info->prec < 0 ? 6 : info->prec; dig_max = INT_MAX; /* Unlimited. */ 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? */ - chars_needed = (size_t) exponent + 1 + 1 + (size_t) fracdig_max; + chars_needed = (size_t) p.exponent + 1 + 1 + (size_t) fracdig_max; } else { @@ -846,27 +853,27 @@ ___printf_fp (FILE *fp, else { dig_max = info->prec < 0 ? 6 : (info->prec == 0 ? 1 : info->prec); - if ((expsign == 0 && exponent >= dig_max) - || (expsign != 0 && exponent > 4)) + if ((p.expsign == 0 && p.exponent >= dig_max) + || (p.expsign != 0 && p.exponent > 4)) { if ('g' - 'G' == 'e' - 'E') - type = 'E' + (info->spec - 'G'); + p.type = 'E' + (info->spec - 'G'); else - type = isupper (info->spec) ? 'E' : 'e'; + p.type = isupper (info->spec) ? 'E' : 'e'; fracdig_max = dig_max - 1; intdig_max = 1; chars_needed = 1 + 1 + (size_t) fracdig_max + 1 + 1 + 4; } else { - type = 'f'; - intdig_max = expsign == 0 ? exponent + 1 : 0; + p.type = 'f'; + intdig_max = p.expsign == 0 ? p.exponent + 1 : 0; fracdig_max = dig_max - intdig_max; /* We need space for the significant digits and perhaps for leading zeros when < 1.0. The number of leading zeros can be as many as would be required for exponential notation with a negative two-digit - exponent, which is 4. */ + p.exponent, which is 4. */ chars_needed = (size_t) dig_max + 1 + 4; } fracdig_min = info->alt ? fracdig_max : 0; @@ -908,26 +915,26 @@ ___printf_fp (FILE *fp, wcp = wstartp = wbuffer + 2; /* Let room for rounding. */ /* 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) { ++intdig_no; - *wcp++ = hack_digit (); + *wcp++ = hack_digit (&p); } significant = 1; if (info->alt || fracdig_min > 0 - || (fracdig_max > 0 && (fracsize > 1 || frac[0] != 0))) + || (fracdig_max > 0 && (p.fracsize > 1 || p.frac[0] != 0))) *wcp++ = decimalwc; } 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. */ *wcp++ = L'0'; - --exponent; + --p.exponent; *wcp++ = decimalwc; } @@ -935,10 +942,10 @@ ___printf_fp (FILE *fp, int fracdig_no = 0; int added_zeros = 0; 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; - *wcp = hack_digit (); + *wcp = hack_digit (&p); if (*wcp++ != L'0') significant = 1; else if (significant == 0) @@ -951,19 +958,19 @@ ___printf_fp (FILE *fp, /* Do rounding. */ 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; if (next_digit != L'0' && next_digit != L'5') 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. */ more_bits = false; - else if (scalesize == 0) + else if (p.scalesize == 0) { /* Here we have to see whether all limbs are zero since no normalization happened. */ - size_t lcnt = fracsize; - while (lcnt >= 1 && frac[lcnt - 1] == 0) + size_t lcnt = p.fracsize; + while (lcnt >= 1 && p.frac[lcnt - 1] == 0) --lcnt; more_bits = lcnt > 0; } @@ -990,7 +997,7 @@ ___printf_fp (FILE *fp, if (*wtp != decimalwc) /* Round up. */ (*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 && wstartp[0] == L'0', 0)) @@ -1015,20 +1022,20 @@ ___printf_fp (FILE *fp, else /* It is more critical. All digits were 9's. */ { - if (type != 'f') + if (p.type != 'f') { *wstartp = '1'; - exponent += expsign == 0 ? 1 : -1; + p.exponent += p.expsign == 0 ? 1 : -1; - /* The above exponent adjustment could lead to 1.0e-00, - e.g. for 0.999999999. Make sure exponent 0 always + /* The above p.exponent adjustment could lead to 1.0e-00, + e.g. for 0.999999999. Make sure p.exponent 0 always uses + sign. */ - if (exponent == 0) - expsign = 0; + if (p.exponent == 0) + p.expsign = 0; } 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 the number of digits is too big. */ *--wstartp = decimalwc; @@ -1044,9 +1051,9 @@ ___printf_fp (FILE *fp, fracdig_no += intdig_no; intdig_no = 1; fracdig_max = intdig_max - intdig_no; - ++exponent; - /* Now we must print the exponent. */ - type = isupper (info->spec) ? 'E' : 'e'; + ++p.exponent; + /* Now we must print the p.exponent. */ + p.type = isupper (info->spec) ? 'E' : 'e'; } else { @@ -1091,14 +1098,14 @@ ___printf_fp (FILE *fp, ngroups); } - /* Write the exponent if it is needed. */ - if (type != 'f') + /* Write the p.exponent if it is needed. */ + 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. - 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 (wstartp[0] == L'1'); __wmemcpy (wstartp, L"0.0001", 6); @@ -1113,26 +1120,26 @@ ___printf_fp (FILE *fp, } else { - *wcp++ = (wchar_t) type; - *wcp++ = expsign ? L'-' : L'+'; + *wcp++ = (wchar_t) p.type; + *wcp++ = p.expsign ? L'-' : L'+'; - /* Find the magnitude of the exponent. */ + /* Find the magnitude of the p.exponent. */ expscale = 10; - while (expscale <= exponent) + while (expscale <= p.exponent) expscale *= 10; - if (exponent < 10) + if (p.exponent < 10) /* Exponent always has at least two digits. */ *wcp++ = L'0'; else do { expscale /= 10; - *wcp++ = L'0' + (exponent / expscale); - exponent %= expscale; + *wcp++ = L'0' + (p.exponent / expscale); + p.exponent %= expscale; } while (expscale > 10); - *wcp++ = L'0' + exponent; + *wcp++ = L'0' + p.exponent; } }