main(), registers and gdb

[Greg Watson <g dot watson at computer dot org>]

I have an issue (I hesitate to say a problem) related to register  
saving and debugging on the linux/x86 platform using gdb 4.1.0.

If the following code is compiled with 'gcc -g -O0 -o test test.c',  
the address of argc is passed into func() in the ecx register. Since  
ecx is not preserved after the call to printf(), the address of argc  
is corrupted on return from func(). Normally this would not be a  
problem, since argc is never used in the code.

    #include <stdio.h>
    #include <stdlib.h>

    int func(int *x)
    {
        printf("in func\n");
        return 0;
    }

    int main(int argc, char *argv[])
    {
        func(&argc);
        //func(&argc);;
        printf("hello\n");
        return 0;
    }

However, when run under gdb, commands that view the stack frame  
produce strange results, and some commands (e.g. -var-update)  
actually crash the debugger.

    Breakpoint 1, main (argc=1, argv=0xbffcef14) at test.c:14
    12              func(&argc);
    (gdb) n
    in func
    14              printf("hello\n");
    (gdb) where
    #0  main (argc=Cannot access memory at address 0x4
    ) at test.c:16
    (gdb)

If line 13 is uncommented the problem goes away, apparently because  
the compiler recognizes that argc is used and so must be preserved.  
Also, this problem is not apparent on other x86 platforms (at least  
Darwin), because eax is used instead of ecx.

This problem is of concern when debugging programs because it  
introduces unexpected behavior, even with optimization disabled.

I would appreciate any comments from the gcc and gdb communities on  
this issue, and would be interested to know if there are any compiler  
options and/or other means of disabling this behavior.

Thanks,

Greg