What is the meaning of these assembly lines?

Hi

When I compile my program with -S option of gcc it always produces some meaningless (for me) lines! Below is what i did

Code:

fnoyan@linux:~> cat > trial.c
#include <stdio.h>

int main()
{
        return 0;
}
fnoyan@linux:~> gcc -Wall trial.c -S -o trial.s
fnoyan@linux:~> cat trial.s
        .file   "trial.c"
        .text
.globl main
        .type   main, @function
main:
        pushl   %ebp
        movl    %esp, %ebp
        subl    $8, %esp
        andl    $-16, %esp
        movl    $0, %eax
        addl    $15, %eax
        addl    $15, %eax
        shrl    $4, %eax
        sall    $4, %eax
        subl    %eax, %esp
        movl    $0, %eax
        leave
        ret
        .size   main, .-main
        .ident  "GCC: (GNU) 4.0.2 20050901 (prerelease) (SUSE Linux)"
        .section        .note.GNU-stack,"",@progbits

All the parts are ok except the part below

Code:

        andl    $-16, %esp
        movl    $0, %eax
        addl    $15, %eax
        addl    $15, %eax
        shrl    $4, %eax
        sall    $4, %eax
        subl    %eax, %esp

Even if I delete these lines and compile the corresponding assembly file (with gcc -Wall trial.s -o trial), the program runs fine! Also, after compilation, I chechked the corresponinding assembly code for the file with GDB. The compiler did not add any other line.

What is the aim of these lines? Why does it add 15 two times instead of adding 30?

Thanks...

I would recomend just not using asemble at all. It is just way to much of an ugly language that almost nobody uses anymore.

Actually I am not using language itself. I just wonder the aim of the generated code!

But sometimes it may be required to write the code in assembly and most of the times being familiar with the assembly helps you to understand the underlaying procedures.

> I just wonder the aim of the generated code!
Try the same thing with a function other than main().
main() is different, it does things no other function does (recursive callers of main take note).

One of the things it seems to be doing with esp for example is making sure it's aligned on a 16-byte boundary. This is to ensure optimal access to local variables later on.

> One of the things it seems to be doing with esp for example is making sure it's aligned on a 16-byte boundary. This is to ensure optimal access to local variables later on.

Yeah, but these lines make no sence

Code:

movl    $0,   %eax  ; eax: 00 00 00 00
addl    $15,  %eax  ; eax: 00 00 00 0F
addl    $15,  %eax  ; eax: 00 00 00 1E
shrl    $4,   %eax  ; eax: 00 00 00 01
sall    $4,   %eax  ; eax: 00 00 00 10
subl    %eax, %esp

since it could be simply replaced by

Code:

subl    $16, %esp

and why would anyone even want to do that? andl rounds esp down so there _should_ be no need for it...

BTW. there doesn't seem to be such code on amd64

Compiling with -O2 also removes some of the apparent redundancy.

Originally Posted by tuxinator

I would recomend just not using asemble at all. It is just way to much of an ugly language that almost nobody uses anymore.

funny, you have a lot of software on your system written with assembler.
the kernel is c and assembler, and most device drivers make heavy use of assembler.
the real intention of the language, extremely fine control of hardware.

C is one step above, in that it has a much more human readable syntax, but it is almost as powerful at hardware control as assembler, that almost being why assembler is still used in os / systems development.

I would say definatly learn some assembly... it really shows you how computers do things. It removes one more layer of abstraction and shows you more of the raw "this is how you do it" code.

It'll give you a better understanding of what your code is doing and hints as to how you can write more efficient code.

and lots of people still use ASM. your crazy if you think otherwise.