remove nested function hack_digit
diff mbox

Message ID CAGQ9bdyOVYamtWG4L4tUp+WiL2AstZpGLRFKsSeLtLPMyv6Cow@mail.gmail.com
State New
Headers show

Commit Message

Konstantin Serebryany Sept. 22, 2014, 10:52 p.m. UTC
On Mon, Sep 22, 2014 at 3:45 PM, Roland McGrath <roland@hack.frob.com> wrote:
>> hack_digit becomes longer too due to longer function prologue epilogue:
>
> Clearly that cannot be the only difference.  Was the function's code itself
> actually all nearly identical, modulo trivial differences like different
> register allocation choices?  Each access to one of the parent's locals
> surely looks different, and how different that code looks is probably where
> the most important differences are.

Another difference is that the compile decided to rearrange the order
of basic blocks, so the calls go in different orders.
I've attached the disassembly for both variants.

>
>> I considered doing such a patch but it turned out a huge textual
>> change that will make the code much less readable.
>> Still, let me do it and send it here anyway, unless you tell me no to.
>
> Of course readability is very subjective, so there really is no substitute
> for each interested person just seeing how things look and giving their
> opinion.  The most trivial mechanical change might harm readability in ways
> that can be improved with a little thought.

Attached is a patch with "trivial mechanical change" (not properly
formatted yet).
To me it looks horrible. Does it make sense to invest more time in it?
000000000004a390 <hack_digit.13608>:
   4a390:	55                   	push   %rbp
   4a391:	53                   	push   %rbx
   4a392:	4c 89 d3             	mov    %r10,%rbx
   4a395:	48 83 ec 08          	sub    $0x8,%rsp
   4a399:	41 8b 42 30          	mov    0x30(%r10),%eax
   4a39d:	85 c0                	test   %eax,%eax
   4a39f:	74 0b                	je     4a3ac <hack_digit.13608+0x1c>
   4a3a1:	41 83 7a 2c 66       	cmpl   $0x66,0x2c(%r10)
   4a3a6:	0f 84 04 01 00 00    	je     4a4b0 <hack_digit.13608+0x120>
   4a3ac:	4c 8b 4b 20          	mov    0x20(%rbx),%r9
   4a3b0:	4d 85 c9             	test   %r9,%r9
   4a3b3:	0f 84 c7 00 00 00    	je     4a480 <hack_digit.13608+0xf0>
   4a3b9:	48 8b 53 18          	mov    0x18(%rbx),%rdx
   4a3bd:	49 39 d1             	cmp    %rdx,%r9
   4a3c0:	7e 3e                	jle    4a400 <hack_digit.13608+0x70>
   4a3c2:	48 8b 7b 10          	mov    0x10(%rbx),%rdi
   4a3c6:	bd 30 00 00 00       	mov    $0x30,%ebp
   4a3cb:	b9 0a 00 00 00       	mov    $0xa,%ecx
   4a3d0:	48 89 fe             	mov    %rdi,%rsi
   4a3d3:	e8 d8 97 ff ff       	callq  43bb0 <__mpn_mul_1>
   4a3d8:	48 85 c0             	test   %rax,%rax
   4a3db:	74 14                	je     4a3f1 <hack_digit.13608+0x61>
   4a3dd:	48 8b 53 18          	mov    0x18(%rbx),%rdx
   4a3e1:	48 8d 4a 01          	lea    0x1(%rdx),%rcx
   4a3e5:	48 89 4b 18          	mov    %rcx,0x18(%rbx)
   4a3e9:	48 8b 4b 10          	mov    0x10(%rbx),%rcx
   4a3ed:	48 89 04 d1          	mov    %rax,(%rcx,%rdx,8)
   4a3f1:	48 83 c4 08          	add    $0x8,%rsp
   4a3f5:	89 e8                	mov    %ebp,%eax
   4a3f7:	5b                   	pop    %rbx
   4a3f8:	5d                   	pop    %rbp
   4a3f9:	c3                   	retq   
   4a3fa:	66 0f 1f 44 00 00    	nopw   0x0(%rax,%rax,1)
   4a400:	48 89 d1             	mov    %rdx,%rcx
   4a403:	48 8b 7b 08          	mov    0x8(%rbx),%rdi
   4a407:	48 8b 53 10          	mov    0x10(%rbx),%rdx
   4a40b:	4c 8b 03             	mov    (%rbx),%r8
   4a40e:	31 f6                	xor    %esi,%esi
   4a410:	e8 2b 8d ff ff       	callq  43140 <__mpn_divrem>
   4a415:	48 8b 53 20          	mov    0x20(%rbx),%rdx
   4a419:	48 8b 4b 18          	mov    0x18(%rbx),%rcx
   4a41d:	48 8b 73 08          	mov    0x8(%rbx),%rsi
   4a421:	48 29 d1             	sub    %rdx,%rcx
   4a424:	48 85 d2             	test   %rdx,%rdx
   4a427:	48 89 04 ce          	mov    %rax,(%rsi,%rcx,8)
   4a42b:	48 8b 2e             	mov    (%rsi),%rbp
   4a42e:	48 89 53 18          	mov    %rdx,0x18(%rbx)
   4a432:	74 2f                	je     4a463 <hack_digit.13608+0xd3>
   4a434:	48 8b 7b 10          	mov    0x10(%rbx),%rdi
   4a438:	48 8d 4a ff          	lea    -0x1(%rdx),%rcx
   4a43c:	48 83 7c d7 f8 00    	cmpq   $0x0,-0x8(%rdi,%rdx,8)
   4a442:	74 17                	je     4a45b <hack_digit.13608+0xcb>
   4a444:	e9 93 00 00 00       	jmpq   4a4dc <hack_digit.13608+0x14c>
   4a449:	0f 1f 80 00 00 00 00 	nopl   0x0(%rax)
   4a450:	48 8d 49 ff          	lea    -0x1(%rcx),%rcx
   4a454:	48 83 3c cf 00       	cmpq   $0x0,(%rdi,%rcx,8)
   4a459:	75 7d                	jne    4a4d8 <hack_digit.13608+0x148>
   4a45b:	48 85 c9             	test   %rcx,%rcx
   4a45e:	48 89 ca             	mov    %rcx,%rdx
   4a461:	75 ed                	jne    4a450 <hack_digit.13608+0xc0>
   4a463:	48 c7 43 18 01 00 00 	movq   $0x1,0x18(%rbx)
   4a46a:	00 
   4a46b:	48 83 c4 08          	add    $0x8,%rsp
   4a46f:	83 c5 30             	add    $0x30,%ebp
   4a472:	5b                   	pop    %rbx
   4a473:	89 e8                	mov    %ebp,%eax
   4a475:	5d                   	pop    %rbp
   4a476:	c3                   	retq   
   4a477:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
   4a47e:	00 00 
   4a480:	48 8b 53 18          	mov    0x18(%rbx),%rdx
   4a484:	48 8b 7b 10          	mov    0x10(%rbx),%rdi
   4a488:	b9 0a 00 00 00       	mov    $0xa,%ecx
   4a48d:	48 8d 5c d7 f8       	lea    -0x8(%rdi,%rdx,8),%rbx
   4a492:	48 89 fe             	mov    %rdi,%rsi
   4a495:	48 83 ea 01          	sub    $0x1,%rdx
   4a499:	48 8b 2b             	mov    (%rbx),%rbp
   4a49c:	e8 0f 97 ff ff       	callq  43bb0 <__mpn_mul_1>
   4a4a1:	48 89 03             	mov    %rax,(%rbx)
   4a4a4:	48 83 c4 08          	add    $0x8,%rsp
   4a4a8:	83 c5 30             	add    $0x30,%ebp
   4a4ab:	5b                   	pop    %rbx
   4a4ac:	89 e8                	mov    %ebp,%eax
   4a4ae:	5d                   	pop    %rbp
   4a4af:	c3                   	retq   
   4a4b0:	41 8b 42 28          	mov    0x28(%r10),%eax
   4a4b4:	bd 30 00 00 00       	mov    $0x30,%ebp
   4a4b9:	8d 50 ff             	lea    -0x1(%rax),%edx
   4a4bc:	85 c0                	test   %eax,%eax
   4a4be:	41 89 52 28          	mov    %edx,0x28(%r10)
   4a4c2:	0f 8e e4 fe ff ff    	jle    4a3ac <hack_digit.13608+0x1c>
   4a4c8:	48 83 c4 08          	add    $0x8,%rsp
   4a4cc:	89 e8                	mov    %ebp,%eax
   4a4ce:	5b                   	pop    %rbx
   4a4cf:	5d                   	pop    %rbp
   4a4d0:	c3                   	retq   
   4a4d1:	0f 1f 80 00 00 00 00 	nopl   0x0(%rax)
   4a4d8:	48 89 53 18          	mov    %rdx,0x18(%rbx)
   4a4dc:	83 c5 30             	add    $0x30,%ebp
   4a4df:	e9 e7 fe ff ff       	jmpq   4a3cb <hack_digit.13608+0x3b>
   4a4e4:	66 66 66 2e 0f 1f 84 	data32 data32 nopw %cs:0x0(%rax,%rax,1)
   4a4eb:	00 00 00 00 00
000000000004a390 <hack_digit>:
   4a390:	41 55                	push   %r13
   4a392:	41 54                	push   %r12
   4a394:	55                   	push   %rbp
   4a395:	4c 89 c5             	mov    %r8,%rbp
   4a398:	4d 89 c8             	mov    %r9,%r8
   4a39b:	53                   	push   %rbx
   4a39c:	48 89 cb             	mov    %rcx,%rbx
   4a39f:	48 83 ec 08          	sub    $0x8,%rsp
   4a3a3:	85 ff                	test   %edi,%edi
   4a3a5:	4c 8b 64 24 30       	mov    0x30(%rsp),%r12
   4a3aa:	74 24                	je     4a3d0 <hack_digit+0x40>
   4a3ac:	83 fe 66             	cmp    $0x66,%esi
   4a3af:	75 1f                	jne    4a3d0 <hack_digit+0x40>
   4a3b1:	8b 02                	mov    (%rdx),%eax
   4a3b3:	41 bd 30 00 00 00    	mov    $0x30,%r13d
   4a3b9:	8d 48 ff             	lea    -0x1(%rax),%ecx
   4a3bc:	85 c0                	test   %eax,%eax
   4a3be:	89 0a                	mov    %ecx,(%rdx)
   4a3c0:	7e 0e                	jle    4a3d0 <hack_digit+0x40>
   4a3c2:	48 83 c4 08          	add    $0x8,%rsp
   4a3c6:	44 89 e8             	mov    %r13d,%eax
   4a3c9:	5b                   	pop    %rbx
   4a3ca:	5d                   	pop    %rbp
   4a3cb:	41 5c                	pop    %r12
   4a3cd:	41 5d                	pop    %r13
   4a3cf:	c3                   	retq   
   4a3d0:	4d 85 e4             	test   %r12,%r12
   4a3d3:	0f 84 c7 00 00 00    	je     4a4a0 <hack_digit+0x110>
   4a3d9:	48 8b 4d 00          	mov    0x0(%rbp),%rcx
   4a3dd:	49 39 cc             	cmp    %rcx,%r12
   4a3e0:	7f 76                	jg     4a458 <hack_digit+0xc8>
   4a3e2:	48 8b 7c 24 38       	mov    0x38(%rsp),%rdi
   4a3e7:	31 f6                	xor    %esi,%esi
   4a3e9:	48 89 da             	mov    %rbx,%rdx
   4a3ec:	4d 89 e1             	mov    %r12,%r9
   4a3ef:	e8 4c 8d ff ff       	callq  43140 <__mpn_divrem>
   4a3f4:	48 8b 55 00          	mov    0x0(%rbp),%rdx
   4a3f8:	48 8b 74 24 38       	mov    0x38(%rsp),%rsi
   4a3fd:	4d 8d 54 24 ff       	lea    -0x1(%r12),%r10
   4a402:	4c 29 e2             	sub    %r12,%rdx
   4a405:	48 89 04 d6          	mov    %rax,(%rsi,%rdx,8)
   4a409:	4c 8b 2e             	mov    (%rsi),%r13
   4a40c:	4c 89 65 00          	mov    %r12,0x0(%rbp)
   4a410:	4a 83 7c e3 f8 00    	cmpq   $0x0,-0x8(%rbx,%r12,8)
   4a416:	74 17                	je     4a42f <hack_digit+0x9f>
   4a418:	e9 cc 00 00 00       	jmpq   4a4e9 <hack_digit+0x159>
   4a41d:	0f 1f 00             	nopl   (%rax)
   4a420:	49 83 ea 01          	sub    $0x1,%r10
   4a424:	4a 83 3c d3 00       	cmpq   $0x0,(%rbx,%r10,8)
   4a429:	0f 85 b1 00 00 00    	jne    4a4e0 <hack_digit+0x150>
   4a42f:	4d 85 d2             	test   %r10,%r10
   4a432:	4c 89 d2             	mov    %r10,%rdx
   4a435:	4c 89 55 00          	mov    %r10,0x0(%rbp)
   4a439:	75 e5                	jne    4a420 <hack_digit+0x90>
   4a43b:	48 c7 45 00 01 00 00 	movq   $0x1,0x0(%rbp)
   4a442:	00 
   4a443:	48 83 c4 08          	add    $0x8,%rsp
   4a447:	41 83 c5 30          	add    $0x30,%r13d
   4a44b:	5b                   	pop    %rbx
   4a44c:	5d                   	pop    %rbp
   4a44d:	41 5c                	pop    %r12
   4a44f:	44 89 e8             	mov    %r13d,%eax
   4a452:	41 5d                	pop    %r13
   4a454:	c3                   	retq   
   4a455:	0f 1f 00             	nopl   (%rax)
   4a458:	48 89 ca             	mov    %rcx,%rdx
   4a45b:	41 bd 30 00 00 00    	mov    $0x30,%r13d
   4a461:	b9 0a 00 00 00       	mov    $0xa,%ecx
   4a466:	48 89 de             	mov    %rbx,%rsi
   4a469:	48 89 df             	mov    %rbx,%rdi
   4a46c:	e8 3f 97 ff ff       	callq  43bb0 <__mpn_mul_1>
   4a471:	48 85 c0             	test   %rax,%rax
   4a474:	0f 84 48 ff ff ff    	je     4a3c2 <hack_digit+0x32>
   4a47a:	48 8b 55 00          	mov    0x0(%rbp),%rdx
   4a47e:	48 8d 4a 01          	lea    0x1(%rdx),%rcx
   4a482:	48 89 4d 00          	mov    %rcx,0x0(%rbp)
   4a486:	48 89 04 d3          	mov    %rax,(%rbx,%rdx,8)
   4a48a:	48 83 c4 08          	add    $0x8,%rsp
   4a48e:	5b                   	pop    %rbx
   4a48f:	5d                   	pop    %rbp
   4a490:	41 5c                	pop    %r12
   4a492:	44 89 e8             	mov    %r13d,%eax
   4a495:	41 5d                	pop    %r13
   4a497:	c3                   	retq   
   4a498:	0f 1f 84 00 00 00 00 	nopl   0x0(%rax,%rax,1)
   4a49f:	00 
   4a4a0:	48 8b 55 00          	mov    0x0(%rbp),%rdx
   4a4a4:	48 89 de             	mov    %rbx,%rsi
   4a4a7:	48 89 df             	mov    %rbx,%rdi
   4a4aa:	b9 0a 00 00 00       	mov    $0xa,%ecx
   4a4af:	48 8d 6c d3 f8       	lea    -0x8(%rbx,%rdx,8),%rbp
   4a4b4:	48 83 ea 01          	sub    $0x1,%rdx
   4a4b8:	4c 8b 6d 00          	mov    0x0(%rbp),%r13
   4a4bc:	e8 ef 96 ff ff       	callq  43bb0 <__mpn_mul_1>
   4a4c1:	48 89 45 00          	mov    %rax,0x0(%rbp)
   4a4c5:	48 83 c4 08          	add    $0x8,%rsp
   4a4c9:	5b                   	pop    %rbx
   4a4ca:	5d                   	pop    %rbp
   4a4cb:	41 83 c5 30          	add    $0x30,%r13d
   4a4cf:	41 5c                	pop    %r12
   4a4d1:	44 89 e8             	mov    %r13d,%eax
   4a4d4:	41 5d                	pop    %r13
   4a4d6:	c3                   	retq   
   4a4d7:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
   4a4de:	00 00 
   4a4e0:	41 83 c5 30          	add    $0x30,%r13d
   4a4e4:	e9 78 ff ff ff       	jmpq   4a461 <hack_digit+0xd1>
   4a4e9:	41 83 c5 30          	add    $0x30,%r13d
   4a4ed:	4c 89 e2             	mov    %r12,%rdx
   4a4f0:	e9 6c ff ff ff       	jmpq   4a461 <hack_digit+0xd1>
   4a4f5:	66 66 2e 0f 1f 84 00 	data32 nopw %cs:0x0(%rax,%rax,1)
   4a4fc:	00 00 00 00

Patch
diff mbox

--- a/stdio-common/printf_fp.c
+++ b/stdio-common/printf_fp.c
@@ -148,6 +148,63 @@  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 +238,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,50 +256,6 @@  ___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;
-    }
-
-
   /* Figure out the decimal point character.  */
   if (info->extra == 0)
     {
@@ -360,12 +359,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 +405,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 +440,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 +467,22 @@  ___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 +491,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 +504,61 @@  ___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 +566,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 +594,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 +605,31 @@  ___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 +637,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 +700,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 +734,15 @@  ___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 +750,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 +792,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 +816,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 +826,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 +845,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 +907,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 +934,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 +950,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 +989,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 +1014,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 +1043,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 +1090,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 +1112,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;
 	  }
       }