Understanding gcc -S output

1. .LFB0, .LFE0 are nothing but local labels.

2. .cfi_startproc is used at the beginning of each function and end of the function happens by .cfi_endproc.

   • These assembler directives help the assembler to put debugging and stack unwinding information into the executable.

3. the leave instruction is an x86 assembler instruction which does the work of restoring the calling function's stack frame.

And lastly after the ret instruction, the following things happen:

• %rip contains return address
• %rsp points at arguments pushed by caller that didn't fit in the six registers used to pass arguments on amd64 (%rdi, %rsi, %rdx, %rcx, %r8, %r9)
• called function may have trashed arguments
• %rax contains return value (or trash if function is void) (or %rax and %rdx contain the return value if its size is >8 bytes but <=16 bytes¹)
• %r10, %r11 may be trashed
• %rbp, %rbx, %r12, %r13, %r14, %r15 must contain contents from time of call

Additional information can be found here (SO question) and here (standards PDFs).

Or, on 32-bit:

• %eip contains return address
• %esp points at arguments pushed by caller
• called function may have trashed arguments
• %eax contains return value (or trash if function is void)
• %ecx, %edx may be trashed
• %ebp, %ebx, %esi, %edi must contain contents from time of call

Those .cfisomething directives result in generation of additional data by the compiler. This data helps traverse the call stack when an instruction causes an exception, so the exception handler (if any) can be found and correctly executed. The call stack information is useful for debugging. This data most probably goes into a separate section of the executable. It's not inserted between the instructions of your code.

.LFsomething: are just regular labels that are probably referenced by that extra exception-related data.

leave and ret are CPU instructions.

leave is equivalent to:

movq    %rbp, %rsp
popq    %rbp

and it undoes the effect of these two instructions

pushq   %rbp
movq    %rsp, %rbp

and instructions that allocate space on the stack by subtracting something from rsp.

ret returns from the function. It pops the return address from the stack and jumps to that address. If it was __libc_start_main() that called main(), then it returns there.