Re: test-fprintf-posix3.c:

[Bruce Korb]

On 11/12/10 07:57, Bruce Korb wrote:
> On 11/11/10 18:51, Bruno Haible wrote:
>>> Breakpoint 2, main (argc=2, argv=0x7fffffffdd38)
>>>     at ../../tests/test-fprintf-posix3.c:97
>>> 97              return 1;
>>> (gdb) p repeat
>>> $1 = 0
>>> (gdb) p errno
>>> $2 = 12
>>> $ egrep ENOMEM $(find /usr/include -type f -name 'err*.h')
>>> /usr/include/asm-generic/errno-base.h:#define ENOMEM 12
>>>
>>> It returned ENOMEM on the first try.
> 
> 92        d->dir = (DIRECTIVE *) malloc (d_allocated * sizeof (DIRECTIVE));
> (gdb) p d_allocated
> $3 = 1
> (gdb) n
> 93        if (d->dir == NULL)
> (gdb) p *d
> $4 = {count = 0, dir = 0x0, max_width_length = 140737488343584,
>   max_precision_length = 140737349717056}
> (gdb) n
> 95          goto out_of_memory_1;
> 
> A "DIRECTIVE" is not very big:

Never mind.  I misinterpreted what was going on.
The problem lives in printf-parse.c.  I modified the source thus:


int
PRINTF_PARSE (const CHAR_T *format, DIRECTIVES *d, arguments *a)
{
  const CHAR_T *cp = format;            /* pointer into format */
  size_t arg_posn = 0;          /* number of regular arguments consumed */
  size_t d_allocated;                   /* allocated elements of d->dir */
  size_t a_allocated;                   /* allocated elements of a->arg */
  size_t max_width_length = 0;
  size_t max_precision_length = 0;

  d->count = 0;
  d_allocated = 1;
  a_allocated = d_allocated * sizeof (DIRECTIVE);
  d->dir = (DIRECTIVE *) malloc (a_allocated);

and:

(gdb) s
printf_parse (format=0x405ac4 "%011000d\n", d=0x7fffffffd090, a=0x7fffffffd080)
    at ../../lib/printf-parse.c:83
83        const CHAR_T *cp = format;            /* pointer into format */
(gdb) n
84        size_t arg_posn = 0;          /* number of regular arguments consumed 
*/
(gdb)
87        size_t max_width_length = 0;
(gdb)
88        size_t max_precision_length = 0;
(gdb)
90        d->count = 0;
(gdb)
91        d_allocated = 1;
(gdb)
92        a_allocated = d_allocated * sizeof (DIRECTIVE);
(gdb)
93        d->dir = (DIRECTIVE *) malloc (a_allocated);
(gdb) p a_allocated
$1 = 0
(gdb) p d_allocated
$2 = 1

Woops.  We're allocating zero bytes.

Preprocessed text:
# 44 "../../lib/printf-parse.h"
typedef struct
{
  const char* dir_start;
  const char* dir_end;
  int flags;
  const char* width_start;
  const char* width_end;
  size_t width_arg_index;
  const char* precision_start;
  const char* precision_end;
  size_t precision_arg_index;
  char conversion;
  size_t arg_index;
}
char_directive;
[...]
# 80 "../../lib/printf-parse.c"
int
printf_parse (const char *format, char_directives *d, arguments *a)
{
  const char *cp = format;
  size_t arg_posn = 0;
  size_t d_allocated;
  size_t a_allocated;
  size_t max_width_length = 0;
  size_t max_precision_length = 0;

  d->count = 0;
  d_allocated = 1;
  a_allocated = d_allocated * sizeof (char_directive);
  d->dir = (char_directive *) malloc (a_allocated);



(gdb) x/24i printf_parse
   0x4046b1 <printf_parse>:     push   %rbp
   0x4046b2 <printf_parse+1>:   mov    %rsp,%rbp
   0x4046b5 <printf_parse+4>:   push   %rbx
   0x4046b6 <printf_parse+5>:   sub    $0x118,%rsp
   0x4046bd <printf_parse+12>:  mov    %rdi,-0x108(%rbp)
   0x4046c4 <printf_parse+19>:  mov    %rsi,-0x110(%rbp)
   0x4046cb <printf_parse+26>:  mov    %rdx,-0x118(%rbp)
   0x4046d2 <printf_parse+33>:  mov    -0x108(%rbp),%rax
   0x4046d9 <printf_parse+40>:  mov    %rax,-0x18(%rbp)
   0x4046dd <printf_parse+44>:  movq   $0x0,-0x20(%rbp)
   0x4046e5 <printf_parse+52>:  movq   $0x0,-0x38(%rbp)
   0x4046ed <printf_parse+60>:  movq   $0x0,-0x40(%rbp)
   0x4046f5 <printf_parse+68>:  mov    -0x110(%rbp),%rax
   0x4046fc <printf_parse+75>:  movq   $0x0,(%rax)
   0x404703 <printf_parse+82>:  movq   $0x1,-0x28(%rbp)
   0x40470b <printf_parse+90>:  mov    -0x28(%rbp),%rdx
   0x40470f <printf_parse+94>:  mov    %rdx,%rax
   0x404712 <printf_parse+97>:  shl    $0x2,%rax
   0x404716 <printf_parse+101>: add    %rdx,%rax
   0x404719 <printf_parse+104>: add    %rax,%rax
   0x40471c <printf_parse+107>: add    %rdx,%rax
   0x40471f <printf_parse+110>: shl    $0x3,%rax
   0x404723 <printf_parse+114>: mov    %rax,%rdi
   0x404726 <printf_parse+117>: callq  0x400780 <address@hidden>

Breakpoint 1, printf_parse (format=0x405ac4 "%011000d\n", d=0x7fffffffd090,
    a=0x7fffffffd080) at ../../lib/printf-parse.c:83
83        const CHAR_T *cp = format;            /* pointer into format */
(gdb) n
84        size_t arg_posn = 0;          /* number of regular arguments consumed 
*/
(gdb)
87        size_t max_width_length = 0;
(gdb)
88        size_t max_precision_length = 0;
(gdb)
90        d->count = 0;
(gdb)
91        d_allocated = 1;
(gdb)
92        a_allocated = d_allocated * sizeof (DIRECTIVE);
(gdb)
93        d->dir = (DIRECTIVE *) malloc (a_allocated);
(gdb) info registers
rax            0x7fffffffd090   140737488343184
rbx            0x7fffffffd348   140737488343880
rcx            0x7ffff7979ed8   140737347296984
rdx            0x0      0
rsi            0x58     88
rdi            0x0      0
rbp            0x7fffffffcd70   0x7fffffffcd70
rsp            0x7fffffffcc50   0x7fffffffcc50
r8             0xffffffff       4294967295
r9             0x0      0
r10            0x22     34
r11            0x246    582
r12            0x400800 4196352
r13            0x7fffffffdd20   140737488346400
r14            0x0      0
r15            0x0      0
rip            0x404739 0x404739 <printf_parse+136>
eflags         0x246    [ PF ZF IF ]
cs             0x33     51
ss             0x2b     43
ds             0x0      0
es             0x0      0
fs             0x0      0
gs             0x0      0
(gdb) p a_allocated
$6 = 0

I set "-O0", how much optimization happens?  "rsi" is 88.
I wonder why "rip" is at +133 when the call is at +117.

$ gcc --version
gcc (SUSE Linux) 4.5.0 20100604 [gcc-4_5-branch revision 160292]
Copyright (C) 2010 Free Software Foundation, Inc.
This is free software; see the source for copying conditions.  There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.