assembly - function

function, enable program broken into pieces, so that for reuse & easy to maintain,
 
------
define function
 
function is the same as normal assembly instructions,
it has a label, and use ".type label_name, @function"to tell that this is a function,
 
.type label_name, @function
      label_name is a label,
      this line says that label_name is the start of a function,
      and the function will be called via this label,
 
ret
      this line is end of function,
 
------
step to use function
 
steps:
* before call:
      * push params of function into stack in reverse order
      * call function
            call do 2 things:
            * push %eip into top of stack, this will be the return address,
            * set %eip to start address of called function, so that program will jump to function,
* inside function:
      * save %ebp to stack
      * move %esp to %ebp, so that easy to read param & make use of stack as storage,
      * read params from stack,
            the first param is at "8(%ebp)"now, because we push %ebp which take 4byte, and "call"push %eip which take 4byte,
      * 
      * do logics
      * 
      * put return value into %eax
      * restore %esp from %ebp
      * restore %ebp from stack
      * ret
            ret instruction return control to where it's called from, by pop top of stack to %eip,
            remember that before call, the return address is at the top of stack, so before ret, should restore stack to before call, this is done by restore %esp,
* after return:
      * adjust %esp to the position before push params of function,
      * get return value from %eax,
* 
 
------
recursive function
 
each function call has it's own stack,
first push stack for all recursive function call, then release all function call & stack & do calculation,
use pushed %ebp to keep track of %esp of previous call,
 
------
calling convention
 
means the basic rule to:
* pass param
* make use of registers
 
usually:
      use stack to pass params, push in reverse order,
      use %ebp to keep track of current %esp,
      use pushed %ebp to keep track of previous %esp,
 
------
code
 
fun_sumofsquare.s

# function - sum of square

.section .data
nums:
	.long 1,2,3,4,-5
num_count:
	.long 5
.section .text
.globl _start

_start:
pushl num_count	# second param, number count
pushl $nums	# first param, start address of numbers
call square_sum # call function
addl $8, %esp	# restore stack to status before push params of function
movl %eax, %ebx	# status value for exit
jmp exit	# exit

exit:
movl $1, %eax
int $0x80

# a function to caculate sum of square
# param:
#	first param:
#		start address of numbers
#	second param:
#		count of numbers
# storage:
#	%edi:
#		count of number remain
#	%ecx:
#		address of current number
#	%ebx:
#		value & square of current number
#	%eax:
#		sum of squares
.type square_sum, @function	# function start
square_sum:
pushl %ebp	# save %ebp to stack
movl %esp, %ebp	# save %esp to %ebp, also use %esp as base address to get value from stack
movl 8(%ebp), %ecx	# read first param, start address of numbers
movl 12(%ebp), %edi	# read second param, count of numbers
movl $0, %eax

square:	# one square
cmpl $0, %edi
jle square_sum_end
movl (%ecx), %ebx
imull %ebx, %ebx
addl %ebx, %eax
decl %edi
addl $4, %ecx
jmp square

square_sum_end:	# end square function
movl %ebp, %esp		# restore %esp, for ret
popl %ebp		# restore %ebp
ret	# function end

 
fun_factorial.s

# function - factorial
.section .data
num:
	.long 5
.section .text
.globl _start

_start:
pushl num
call factorial
addl $4, %esp
movl %eax, %ebx
jmp exit

exit:
movl $1, %eax
int $0x80

.type factorial, @function
factorial:
pushl %ebp
movl %esp, %ebp
movl 8(%ebp), %edi	# read num
movl $1, %eax
jmp factorial_one

factorial_one:
cmpl $1, %edi
jle factorial_end
imull %edi, %eax
decl %edi
jmp factorial_one

factorial_end:
movl %ebp, %esp
popl %ebp
ret

 
fun_factorial_recusive.s

# function - factorial recursive
.section .data
num:
	.long 5
.section .text
.globl _start

_start:
pushl num
call factorial
addl $4, %esp
movl %eax, %ebx
jmp exit

exit:
movl $1, %eax
int $0x80

# function for factorial - recursive, numbers are all pushed to stack, then do multiplication
# param:
#	first param: number
# storage:
# 	when push stack:
#		%eax -> number
#	when pop stack:
#		%ebx -> number
#		%eax -> tmp result
#	%ebx:
#		current %esp
#	pushed %ebx:
#		store last %esp
.type factorial, @function
factorial:
pushl %ebp
movl %esp, %ebp
movl 8(%ebp), %eax
cmpl $1, %eax
jle factorial_end
decl %eax
pushl %eax
call factorial
movl 8(%ebp), %ebx
imull %ebx, %eax
jmp factorial_end

factorial_end:
movl %ebp, %esp
popl %ebp
ret

 
how to execute:
    as xxx.s -o a.o; ld a.o -o a.out;./a.out;echo $?
------