factorial.s

 #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)