Add two numbers together in asm

Question

I have compiled the following c program to asm to see what instructions it uses. What I have in C is:

int add(int num1, int num2) {
    int num3 = num1 + num2;
    return num3;
}

My thought on what the instructions "should be" (from my very limited knowledge of asm) would be:

1. Load (two 4-byte int variables into memory).
2. Add (two memory locations), and -
3. Store the sum at a third memory location.
4. Return the value and halt execution.

When compiling this, I was surprised at all the mov operations it does:

add:
        push    rbp
        mov     rbp, rsp
        mov     DWORD PTR [rbp-20], edi
        mov     DWORD PTR [rbp-24], esi
        mov     edx, DWORD PTR [rbp-20]
        mov     eax, DWORD PTR [rbp-24]
        add     eax, edx
        mov     DWORD PTR [rbp-4], eax
        mov     eax, DWORD PTR [rbp-4]
        pop     rbp
        ret

Could someone walk me through the asm code here and point out why it's using the mov code so frequently? Here's an example of it: here.

Answer 1

This looks like code that was specifically compiled at the lowest possible optimization setting. What it's doing is storing the arguments (which are in the registers edi and esi) into stack memory (rbp - offset), then reloading them into registers eax and edx to add them, storing the result back into int num3 in stack memory at [rbp - 4], then reloading to return the result in eax.

A lot of this is redundant and it could just as easily be:

add:
    add edi, esi
    mov eax, edi
    ret

Or in practice with gcc -O1 or higher is actually

add:
    lea    eax, [rdi+rsi]
    ret

The gcc/clang default is -O0 which anti-optimizes for consistent debugging, keeping variables in memory between C statements instead of registers. See Why does clang produce inefficient asm with -O0 (for this simple floating point sum)? for details.