Assembly Function Integer Local Variable

Question

I'm trying to learn basic assembly. I wrote a simple program in C to translate to assembly:

void myFunc(int x, int y) {
    int z;
}

int main() {
    myFunc(20, 10);
    return 0;
}

This is what I thought the correct translation of the function would be:

.text
.globl _start
.type myFunc, @function

myFunc:
    pushl %ebp        #Push old ebp register on to stack
    movl %esp, %ebp   #Move esp into ebp so we can reference vars
    sub $4, %esp      #Subtract 4 bytes from esp to make room for 'z' var
    movl $2, -4(%ebp) #Move value 2 into 'z'
    movl %ebp, %esp   #Restore esp
    popl %ebp         #Set ebp to 0?
    ret               #Restore eip and jump to next instruction

_start:
    pushl $10        #Push 10 onto stack for 'y' var
    pushl $20        #Push 20 onto stack for 'x' var
    call myFunc      #Jump to myFunc (this pushes ret onto stack)
    add $8, %esp     #Restore esp to where it was before

    movl $1, %eax    #Exit syscall
    movl $0, %ebx    #Return 0
    int $0x80        #Interrupt

Just to double check it I ran it in gdb and was confused by the results:

(gdb) disas myFunc
Dump of assembler code for function myFunc:
0x08048374 <myFunc+0>:  push   ebp
0x08048375 <myFunc+1>:  mov    ebp,esp
0x08048377 <myFunc+3>:  sub    esp,0x10
0x0804837a <myFunc+6>:  leave
0x0804837b <myFunc+7>:  ret    
End of assembler dump.

Why at 0x08048377 did gcc subtract 0x10 (16 bytes) from the stack when an integer is 4 bytes in length?

Also, is the leave instruction equivalent to the following?

    movl %ebp, %esp   #Restore esp
    popl %ebp         #Set ebp to 0?

Using:

gcc version 4.3.2 (Debian 4.3.2-1.1)
GNU gdb 6.8-debian

in your C example, is your myFunc(int,int) supposed to not do anything with its parameters and declare but never use z? or is there a purpose for this function — Nick Rolando
– Nick Rolando, Commented Jan 13, 2011 at 19:46
The myFunc() function's only purpose is to declare the int z so I could compare it with to gdb's disas of myFunc() to see if I wrote my function correctly in assembly — masterwok
– masterwok, Commented Jan 13, 2011 at 20:03

ephemient · Accepted Answer · 2011-01-13 20:07:48Z

7

Depending on the platform, GCC may choose different stack alignments; this can be overridden, but doing so can make the program slower or crash. The default -mpreferred-stack-boundary=4 keeps the stack aligned to 16-byte addresses. Assuming the stack pointer already suitably aligned at the start of the function, it will remain so aligned after sub %esp, $10.

leave is an x86 macro-instruction which is equivalent to mov %ebp, %esp; pop %ebp.

answered Jan 13, 2011 at 20:07

ephemient

207k39 gold badges292 silver badges403 bronze badges

Sign up to request clarification or add additional context in comments.

Comments

zwol · Accepted Answer · 2011-01-13 20:12:50Z

4

Your GDB is configured to print out Intel instead of AT&T assembly syntax - turn that off before it confuses you more than it already has.

The stack pointer (%esp) is required to always be aligned to a 16-byte boundary. That's probably where the sub esp,0x10 is coming from. (It's unnecessary, but GCC has historically been bad at noticing that stack adjustments are unnecessary.) Also, your function doesn't do anything interesting, so the body has been optimized out. You should have compiled this code:

int myFunc(int x, int y)
{
    return x + y;
}

int main(void)
{
    return myFunc(20, 30);
}

That'll produce assembly language that's easier to map back to the original C. GCC would still be allowed to produce

main:
    movl $50,%eax
    ret

and nothing else, but it probably won't unless you use -O3 -fwhole-program ;-)

answered Jan 13, 2011 at 20:12

zwol

143k39 gold badges272 silver badges388 bronze badges

2 Comments

ephemient Over a year ago

@jtsan: The comments aren't completely right (popl %ebp # Set ebp to 0? actually restores %ebp to the value it had prior to your function call) and changing the stack to 4-byte alignment can cause problems if you call other functions that assume 16-byte alignment (especially if they use MMX/SSE), but otherwise it looks reasonable.

zwol Over a year ago

The only other thing I would say about your original code is: don't write _start, write main, and return from main or call exit, don't do the system call by hand. You want to let the C library initialize itself (or things like printf won't work) and hand-coding system calls is asking for weird compatibility problems.

Collectives™ on Stack Overflow

Assembly Function Integer Local Variable

2 Answers 2

Comments

2 Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

Comments

2 Comments

Your Answer

Sign up or log in

Post as a guest

Related