problem understanding recursion in assembly language

[dynamo]

In the following code eax was decremented before calling the function inside the function(recursion) in calculating the factorial.However my understanding of the code makes me think the function takes its parameter from 8(%ebp) where the parameter 4(the number we are finding the factorial for) was stored.I think the value in 8(%ebp)should be decremented not eax .Can anyone explain?Thanks

#PURPOSE - Given a number, this program computes the
# factorial. For example, the factorial of
# 3 is 3 * 2 * 1, or 6. The factorial of
# 4 is 4 * 3 * 2 * 1, or 24, and so on.
#
#This program shows how to call a function recursively.
.section .data
#This program has no global data
.section .text
.globl _start
.globl factorial #this is unneeded unless we want to share
#this function among other programs
_start:
pushl $4 #The factorial takes one argument - the
#number we want a factorial of. So, it
#gets pushed
call factorial #run the factorial function
addl $4, %esp #Scrubs the parameter that was pushed on
#the stack
movl %eax, %ebx #factorial returns the answer in %eax, but
#we want it in %ebx to send it as our exit
#status
movl $1, %eax #call the kernel’s exit function
int $0x80
#This is the actual function definition
.type factorial,@function
factorial:
pushl %ebp #standard function stuff - we have to
#restore %ebp to its prior state before
#returning, so we have to push it
movl %esp, %ebp #This is because we don’t want to modify
#the stack pointer, so we use %ebp.
movl 8(%ebp), %eax #This moves the first argument to %eax
#4(%ebp) holds the return address, and
#8(%ebp) holds the first parameter
cmpl $1, %eax #If the number is 1, that is our base
#case, and we simply return (1 is
#already in %eax as the return value)
je end_factorial
decl %eax #otherwise, decrease the value
pushl %eax #push it for our call to factorial
call factorial #call factorial
movl 8(%ebp), %ebx #%eax has the return value, so we
#reload our parameter into %ebx
imull %ebx, %eax #multiply that by the result of the
#last call to factorial (in %eax)
#the answer is stored in %eax, which
#is good since that’s where return
#values go.
end_factorial:
movl %ebp, %esp #standard function return stuff - we
popl %ebp #have to restore %ebp and %esp to where
#they were before the function started
ret #return to the function (this pops the
#return value, too)
*****************************************************************
 

[Ganon11]

If you decremented 8(%ebp) instead of %eax, you might still get the same answer...I'm not entirely sure. Why not try it?

i.e. write a short C program containing a main and a factorial(int a) function declaration, compile it into assembler code, insert your factorial assembler code, and see if it works.

[asedt]

I think it's like this:

(%ebp)

Is an indirect references to memory and we move the content of what its pointing on to a register -> %eax befor working with it. Itself it's just a number/adress of were the thing is stored in memory.

The 8(%ebp) adds 8 to the adress.

Readings:

http://www.ibm.com/developerworks/li...rary/l-ia.html


http://209.85.135.104/search?q=cache...lnk&cd=2&gl=se

[dynamo]

thanx for the help guys.