与简单的汇编代码（IA32）混淆

Question

Consider the following C functions :

void f1(int i) 
{ 
    int j=i+a; 
}

int f2(int i) 
{
    return i+a; 
}

and their translation (given by instructor) in assembly language :

#f1 translation :

subl $8, %esp 
movl 12(%esp), %eax 
movl %eax, 4(%esp) 
movl 4(%esp), %eax 
addl a, %eax 
movl %eax, (%esp) 
addl $8, %esp 
ret

#f2 translation :

subl $8, %esp 
movl 12(%esp), %eax 
movl %eax, 4(%esp) 
movl a, %eax 
movl %eax, (%esp) 
movl (%esp), %eax 
addl 4(%esp), %eax 
addl $8, %esp 
ret

I've tried to draw and write down each step of the two assembly code but I simply cannot see how the two lead to different C codes.

By convention, the register %eax contains the returned value of the function. If I'm not mistaken, the register %eax contains the value (i+a) at the end of BOTH assembly code although f1 returns nothing .

1) Why's that? What exactly tells that a function is returning a value?

Also, in both codes, we have two lines like this two :

movl %eax, (%esp) 
movl (%esp), %eax

the last one seems to be redundant, 2) or isn't it?

Answer 1

If the ABI says EAX contains the return value, functions that return something will have the return value there. If a function does not return anything, the register may contain whatever. In this case it might be the same value, I didn't read the code.

If the calling function doesn't read the return value it doesn't matter what that register contains. So it is all about the caller and the called function. They must obay the ABI. If a void function is called, the calling code will never try to use that register as anything.

So nothing in the assembly code says the function returns something. It's all in the C code.

As for 2, the MOV is redundant. It is because you didn't compile with optimizations so the compiler will just output whatever simple things it wants and is very much not optimal.

Answer 2

It's much easier to understand the difference if you look at compiler output with optimizations enabled:

gcc 5.3 with -O3 -m32 on the Godbolt Compiler Explorer :

int a = 1234;  // global, not static or const, so it has to get loaded from memory

void f1(int i) { int j=i+a; }
// 3 : warning: unused variable 'j' [-Wunused-variable]
    ret

int f2(int i) { return i+a; }
    movl    a, %eax         # load a
    addl    4(%esp), %eax   # add i from its arg-passing location on the stack
    ret

f1 is optimized away completely, because it has no externally-visible effects (no return value and no side-effects). Local variables disappear (go out of scope) when a function returns, so there's no need to compute it at all. (Since it's not volatile )

Probably your prof was trying to illustrate how locals are stored on the stack. (What C calls "automatic" storage, as opposed to dynamic (malloc) or static (globals and static ).)

gcc -O0 is too noisy to be a good illustration of that, esp. the way it copies args from above the return address to locals.

gcc -O0 mostly just translates each C statement directly to asm, without considering the rest of the function. And also, variables are stored / reloaded between statements, instead of staying live in registers. (Except sometimes they do stay live as part of a large expression).

gcc -Og is only slightly optimized, and corresponds to the source fairly well. It does still optimize f1 to an empty function. So does -O1 .