[SOLVED] Understanding pointers in assembler from machine's view

Issue

Here is a basic program I written on the godbolt compiler, and it's as simple as:

#include<stdio.h>

void main()
{
    int a = 10;
    int *p = &a;
    printf("%d", *p);
}

The results after compilation I get:

.LC0:
        .string "%d"
main:
        push    rbp
        mov     rbp, rsp
        sub     rsp, 16
        mov     DWORD PTR [rbp-12], 10
        lea     rax, [rbp-12]
        mov     QWORD PTR [rbp-8], rax
        mov     rax, QWORD PTR [rbp-8]
        mov     eax, DWORD PTR [rax]
        mov     esi, eax
        mov     edi, OFFSET FLAT:.LC0
        mov     eax, 0
        call    printf
        nop
        leave
        ret

Question: Pushing the rbp, making the stack frame by making a 16 byte block, how from a register, a value is moved to a stack location and vice versa, how the job of LEA is to figure out the address, I got this part.

Problem:

            lea     rax, [rbp-12]
            mov     QWORD PTR [rbp-8], rax
            mov     rax, QWORD PTR [rbp-8]
            mov     eax, DWORD PTR [rax]

Lea -> getting address of rbp-12 into rax, then moving the value which is the address of rbp-12 into rax, but next line again says, move to rax, the value of rbp-8. This seems ambiguous. Then again moving the value of rax to eax. I don't understand the amount of work here. Why couldn't I have done

        lea     rax, [rbp-12]
        mov     QWORD PTR [rbp-8], rax
        mov     eax, QWORD PTR [rbp-8]

and be done with it? coz on the original line, rbp-12's address is stored onto rax, then rax stored to rbp-8. then rbp-8 stored again into rax, and then again rax is stored into eax? couldn't we have just copied the rbp-8 directly to eax? i guess not. But my question is why?

I know there is de-referencing in pointers, so How LEA helps grabbing the address of rbp-12, I understand, but on the next parts, when did it went from grabbing values from addresses I completely lost. And also, after that, I didn't understand any of the asm lines.

Solution

You're seeing very un-optimized code. Here's my line-by-line interpretation:

.LC0:
        .string "%d"                     ; Format string for printf
main:
        push    rbp                      ; Save original base pointer
        mov     rbp, rsp                 ; Set base pointer to beginning of stack frame
        sub     rsp, 16                  ; Allocate space for stack frame
        mov     DWORD PTR [rbp-12], 10   ; Initialize variable 'a'
        lea     rax, [rbp-12]            ; Load effective address of 'a'
        mov     QWORD PTR [rbp-8], rax   ; Store address of 'a' in 'p'
        mov     rax, QWORD PTR [rbp-8]   ; Load 'p' into rax (even though it's already there - heh!)
        mov     eax, DWORD PTR [rax]     ; Load 32-bit value of '*p' into eax
        mov     esi, eax                 ; Load value to print into esi
        mov     edi, OFFSET FLAT:.LC0    ; Load format string address into edi
        mov     eax, 0                   ; Zero out eax (not sure why -- likely printf call protocol)
        call    printf                   ; Make the printf call
        nop                              ; No-op (not sure why)
        leave                            ; Remove the stack frame
        ret                              ; Return

Compilers, when not optimizing, generate code like this as they parse the code you gave them. It's doing a lot of unnecessary stuff, but it is quicker to generate and makes using a debugger easier.

Compare this with the optimized code (-O2):

.LC0:
        .string "%d"                   ; Format string for printf
main:
        mov     esi, 10                ; Don't need those variables -- just a 10 to pass to printf!
        mov     edi, OFFSET FLAT:.LC0  ; Load format string address into edi
        xor     eax, eax               ; It's a few cycles faster to xor a register with itself than to load an immediate 0
        jmp     printf                 ; Just jmp to printf -- it will handle the return

The optimizer found that the variables weren't necessary, so no stack frame is created. Nothing is left but the printf call! And that's done as a jmp since nothing else need be done here when the printf is complete.

Answered By - Fred Larson