在C中，将struct作为参数传递给printf的预期行为是什么？

Question

Second try

Ok, maybe my first attempt to ask the question was too confuse. So, here we go again...

In a function that takes a variable number of arguments, like printf , when you pass a struct what is the kind of code generated you should expected?

I'm asking this, based on this code:

#include <stdio.h>

struct edge{
    int v1, v2;
};

int main(void){
    struct edge edges;

    edges.v1=5;
    edges.v2=20;

    printf("'%d'\n",  edges);

return 0;
}

When compiling this on my windows box, it pass 2 integer arguments:

    .file   "simple_test_case2.c"
    .def    ___main;    .scl    2;  .type   32; .endef
    .section .rdata,"dr"
LC0:
    .ascii "'%d'\12\0"
    .text
.globl _main
    .def    _main;  .scl    2;  .type   32; .endef
_main:
    pushl   %ebp
    movl    %esp, %ebp
    andl    $-16, %esp
    subl    $32, %esp
    call    ___main
    movl    $5, 24(%esp)
    movl    $20, 28(%esp)
    movl    24(%esp), %eax
    movl    28(%esp), %edx
    movl    %eax, 4(%esp)
    movl    %edx, 8(%esp)
    movl    $LC0, (%esp)
    call    _printf
    movl    $0, %eax
    leave
    ret
    .def    _printf;    .scl    2;  .type   32; .endef

But the code generated by my linux box, just pass one memory address to it:

    .file   "simple_test_case2.c"
    .section    .rodata
.LC0:
    .string "'%d'\n"
    .text
    .align 2
.globl main
    .type   main, @function
main:
.LFB2:
    pushq   %rbp
.LCFI0:
    movq    %rsp, %rbp
.LCFI1:
    subq    $16, %rsp
.LCFI2:
    movl    $5, -16(%rbp)
    movl    $20, -12(%rbp)
    movq    -16(%rbp), %rsi
    movl    $.LC0, %edi
    movl    $0, %eax
    call    printf
    movl    $0, %eax
    leave
    ret
.LFE2:
    .size   main, .-main
.globl __gxx_personality_v0
    .section    .eh_frame,"a",@progbits
.Lframe1:
    .long   .LECIE1-.LSCIE1
.LSCIE1:
    .long   0x0
    .byte   0x1
    .string "zPR"
    .uleb128 0x1
    .sleb128 -8
    .byte   0x10
    .uleb128 0x6
    .byte   0x3
    .long   __gxx_personality_v0
    .byte   0x3
    .byte   0xc
    .uleb128 0x7
    .uleb128 0x8
    .byte   0x90
    .uleb128 0x1
    .align 8
.LECIE1:
.LSFDE1:
    .long   .LEFDE1-.LASFDE1
.LASFDE1:
    .long   .LASFDE1-.Lframe1
    .long   .LFB2
    .long   .LFE2-.LFB2
    .uleb128 0x0
    .byte   0x4
    .long   .LCFI0-.LFB2
    .byte   0xe
    .uleb128 0x10
    .byte   0x86
    .uleb128 0x2
    .byte   0x4
    .long   .LCFI1-.LCFI0
    .byte   0xd
    .uleb128 0x6
    .align 8
.LEFDE1:
    .ident  "GCC: (GNU) 4.1.2 20080704 (Red Hat 4.1.2-48)"
    .section    .note.GNU-stack,"",@progbits

So this is my question, when you pass only one struct to a function like printf , the code generated should pass just one argument or push all struct members to it?

First try

A friend of mine was having some problems with a program that wasn't working as expected on Windows. So I took a look at the source code and trimmed down the test case to this:

#include <stdio.h>

struct edge{
    int v1, v2;
};

int main(void){
    struct edge edges;

    edges.v1=5;
    edges.v2=20;

    //This is the expected behavior for me:
    printf("'%d' '%d' '%d' '%d'\n",  edges.v1,  edges.v1,  edges.v1,  edges.v1);

    //This is supposed to work like this? It should pass the whole struct to printf?
    printf("'%d' '%d' '%d' '%d'\n",  edges,  edges,  edges,  edges);
    printf("'%d' '%d' '%d' '%d'\n",  edges,  edges);

    return 0;
}

So tested on a Windows 7 box with

gcc (tdm-1) 4.5.0
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.

And the output is this:

'5' '5' '5' '5'
'5' '20' '5' '20'
'5' '20' '5' '20'

On a linux box with

gcc (GCC) 4.1.2 20080704 (Red Hat 4.1.2-48)
Copyright (C) 2006 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.

I got this output:

'5' '5' '5' '5'
'5' '5' '5' '5'
'5' '5' '229971840' '-641776368'

The output from linux box one, is the one that i expected...

Then, I took a look at the assembly code generated by each compiler and saw that on my Windows box, the code was passing the whole struct to printf, both v1 and v2 members (and this justifies the results). But on the Linux box, the code generated passed just the first member of the struct, as I expected.

So what should be the behavior in this case?

For me, the expected one is the Linux one, but maybe I'm wrong and this is a case of undefined behavior.

Answer 1

The expected behavior is undefined behavior . The C language requires that you pass arguments of the correct type (matching the format string) to printf , and there is no format string which can match struct types.

You may be able to get the C implementation you're using to print meaningful data by passing structures this way, but it's non-portable, dependent upon calling convention, and unreliable. Don't do it. Just pass the individual members you want to print.

Answer 2

Look, printf is just a simple function. It evaluates its arguments from right-to-left and just pushes them on the stack. It does no type checking.

Then the format string expects to see certain things, namely ints, doubles, or character pointers. Nothing else.

So just pass it what it expects.

Answer 3

If the compiler doesn't have specific information about how the argument should be passed, such as when there's no prototype or for arguments that are passed where the protoype have an ellipsis ( '...' ), the compiler follows certain rules for passing the arguments:

• the integer promotions are applied (note this doesn't apply to structures)
• if the argument has float type it's promoted to double

After these default argument promotions are applied, the argument is simply copied to wherever the compiler normally copies arguments (generally, the stack). So a struct argument would be copied to the stack.

Try examining the assembly output for the following code, and you'll see that GCC will copy the structures passed to foo() to the stack:

#include <stdarg.h>

void foo( size_t siz, ...);

struct x
{
    int x;
    int y;
};

struct y
{
    char a;
};

struct z
{
    double x;
    double y;
    int z;
};

int main()
{
    struct x x1;
    struct y y1;
    struct z z1;

    foo( sizeof(x1), x1);
    foo( sizeof(y1), y1);
    foo( sizeof(z1), z1);

    return 0;
}

GCC might not be applying this rule to your printf() test because it has special knowledge of printf() and knows that only certain types are supported by the format string. If an argument type doesn't match what's expected by a format specifier then undefined behavior occurs (so the compiler doesn't have to do what you might expect otherwise). I'm surprised you don't get some sort of warning. If you leave out the #include <stddio.h> , you'll probably see a warning something like, "warning: incompatible implicit declaration of built-in function 'printf'", which hints at GCC's special treatment of printf() .