Questions re: assembly generated from my C++ by gcc

Question

Compiling this code:

int main ()
{
    return 0;
}

using:

gcc -S filename.cpp

...generates this assembly:

        .file   "heloworld.cpp"
    .text
.globl main
    .type   main, @function
main:
.LFB0:
    .cfi_startproc
    .cfi_personality 0x0,__gxx_personality_v0
    pushl   %ebp
    .cfi_def_cfa_offset 8
    movl    %esp, %ebp
    .cfi_offset 5, -8
    .cfi_def_cfa_register 5
    movl    $0, %eax
    popl    %ebp
    ret
    .cfi_endproc
.LFE0:
    .size   main, .-main
    .ident  "GCC: (Ubuntu 4.4.3-4ubuntu5) 4.4.3"
    .section    .note.GNU-stack,"",@progbits

My questions:

Is everything after "." a comment?
What is .LFB0:?
What is .LFE0:?
Why is it so big code only for "int main ()" and "return 0;"?

P.S. I read alot of assembly net books, a lot (at least 30) of tutorials and all I can do is copy code and paste it or rewrite it. Now I'm trying a different approach to try to learn it somehow. The problem is I do understand what are movl, pop, etc, but don't understand how to combine these things to make code "flow". I don't know where or how to correctly start writing a program in asm is. I'm still static not dynamic as in C++ but I want to learn assembly.

You can find some video here that should help you understand assembly language : http://www.securitytube.net/groups?operation=view&groupId=5 The guy has a strong east european accent. — Sylvain Defresne, Mar 03 '11 at 17:44

score 7 · Accepted Answer · answered Mar 02 '11 at 14:50

As other have said, .file, .text, ... are assembler directives and .LFB0, .LFE0 are local labels. The only instruction in the generated code are:

pushl   %ebp
movl    %esp, %ebp
movl    $0, %eax
popl    %ebp
ret

The first two instruction are the function prologue. The frame pointer is stored on the stack and updated. The next intruction store 0 in eax register (i386 ABI states that integer return value are returned via the eax register). The two last instructions are function epilogue. The frame pointer is restored, and then the function return to its caller via the ret instruction.

If you compile your code with -O3 -fomit-frame-pointer, the code will be compiled to just two instructions:

xorl    %eax,%eax
ret

The first set eax to 0 (it only takes two bytes to encode, while movl 0,%eax take 5 bytes), and the second is the ret instruction. The frame pointer manipulation is there to ease debugging (it is possible to get backtrace without it, but it is more difficult).

gcc -O3 -fomit-frame-pointer heloworld.cpp /tmp/ccVdrv9G.o:(.eh_frame+0x12): undefined reference to `__gxx_personality_v0' collect2: ld returned 1 exit status — psihokiller4, Mar 02 '11 at 15:01
You should use `g++` to compile `.cpp` file. I don't think it is the issue in your case, but it is generally a good idea. I do not have a problem when trying to compile `heloworld.cpp` on my side with `gcc -O3 -fomit-frame-pointer heloworld.cpp` ... — Sylvain Defresne, Mar 02 '11 at 15:32

Paul R · Answer 2 · 2011-03-02T14:27:00.927

3

.file, .text, etc are assembler directives.

.LFB0, .LFE0 are local labels, which are normally used as branch destinations within a function.

As for the size, there are really only a few actual instructions - most of the above listing consists of directives, etc. For future reference you might also want to turn up the optimisation level to remove otherwise redudant instructions, i.e. gcc -Wall -O3 -S ....

edited Mar 02 '11 at 14:27

answered Mar 02 '11 at 14:21

Paul R

208,748
37
389
560

score 2 · Answer 3 · answered Mar 02 '11 at 14:21

2

It's just that there's a lot going on behind your simple program.

If you intend to read assembler outputs, by no means compile C++. Use plain C, the output is far clearer for a number of reasons.

answered Mar 02 '11 at 14:21

salezica

74,081
25
105
166

Questions re: assembly generated from my C++ by gcc

3 Answers3

Linked