understanding output of c code on gcc compiler

Question

I understand from several post like this What are all the common undefined behaviours that a C++ programmer should know about?, that the behaviour is undefined and left to compiler.

But for given code, the output is 2 1 3 (ALWAYS, CONSISTENTLY)

#include<stdio.h>
int main(){
    int i = 1;
    printf("%d %d %d\n", i++, i++, i);
    return 0;
}

So, I would like to know, what order is gcc following, doesn't look like left-to-right or right-to-left? The output is same always, and this question is pertaining to just gcc 4.9.1 compiler.

Answer 1

you specified gcc so i will state something very gcc specific.

this is undefined but if you consider how gcc implements call stack, you will know why it's consistent. basically, stack grows from high address to low address, and function like printf which has ... in its argument list will dump the arguments into the stack. given the direction of stack, there aren't too many choices:

func(a1, a2, a3, a4);

push from left to right:

high| ... |
    | a1  |
    | a2  |
    | a3  |
low | a4  |

or right to left:

high| ... |
    | a4  |
    | a3  |
    | a2  |
low | a1  |

the truth is, gcc takes the second approach. it may sound counter-intuitive, but given such stack construct, this is very nicely designed. if you have to access the arguments in sequence, you naturally form an array in this way, so each of arr[0], arr[1], etc will correspond to a correct argument in position.

so after knowing this, the evaluation order isn't very hard to comprehend any more, since gcc handles arguments from right to left any ways. if i need to implement a compiler handles function calls, why would i choose to handle arguments from left to right in this case and right to left in that case? that's more than confusing.

gcc is a very comprehensive compiler if you know some of its implementation. a technical decision often will drive to a very obvious consequence.

this is very gcc specific so things could change easily if somebody changes the growth direction of stack or just feel like creating special case. for instance, clang seems to behave the other way around.

Answer 2

Undefined behavior means that one compiler may compile it differently than another compiler. This is because there is no standard.

In regards to the gcc 4.9.1 compiler, it's evaluating the middle one, then the left one, then the right one. It's hopping like a bunny. Maybe it goes from the middle to the left to the right in the general case.

Answer 3

GCC doesn't appear to have an extensive and comprehensive database or documentation concerning undefined behavior--if anything, it seems to be generally understood not to venture off into undefined territory. It does, however, have notes on implementation-defined behavior.

To be clear, I don't think that the i = i++ problem can be optimally standardized across platforms and implementations of the same compiler because of differing semantics of calling and computation across architectures: this article may be related or help clarify how an architecture can have a peculiar calling convention.

Also, even the C++ Standard allows for some "compiler room" to allow them to make optimizations in such a way by imposing restrictions on the programmer, though they are often quite small and esoteric, can matter, such as strict aliasing.

Execution order of individual expressions that inherently collide no matter how you fit them into an expression would probably fit under "compiler-space" where the compiler is generally assumed to have full control over this.

Also, due to the age and large volume of the GCC codebase, I'd doubt that this sort of documentation will exist if it doesn't already.

**Edit: User HuStmpHrrr seems to have a handle on how GCC is implemented. Looks like it'll take some digging!

Answer 4

You can ask GCC to generate assembly code with:

gcc -S -o my_asm_output.s main.c

I got this :

call    ___main
movl    $1, 28(%esp)
movl    28(%esp), %edx
leal    1(%edx), %eax
movl    %eax, 28(%esp)
movl    28(%esp), %eax
leal    1(%eax), %ecx
movl    %ecx, 28(%esp)
movl    28(%esp), %ecx
movl    %ecx, 12(%esp)
movl    %edx, 8(%esp)
movl    %eax, 4(%esp)
movl    $LC0, (%esp)
call    _printf

where LC0:

LC0:
    .ascii "%d %d %d\12\0"
    .text
    .globl  _main
    .def    _main;  .scl    2;  .type   32; .endef

I'm not an expert of assembly but, it look like the print order will be printf("eax edx ecx\n"); with the correspondence increment:

movl    $1, 28(%esp)
movl    28(%esp), %edx
leal    1(%edx), %eax
leal    1(%eax), %ecx

But it is just a fast speculation, maybe I skip something important.