Recursive Faculty Function

This shows a recursive faculty implementation in both C and thenafter in ASM. The C example is pretty easy, but doing the same in ASM gets a bit tricky, so it took me some time to figure out a simple way to represent that C function.

C-Implementation

The whole program can be easily implemented with a recursion as in following in C:

faculty.c

#include "stdio.h"

int fac(unsigned int a){
    int b = a;
    if (a <= 1) 
        return b;
    return b * fac(--a);
}

int main(){
    unsigned int a;
    int res;
    a = 5;
    res = fac(a);
    printf("%d\n", res);
}

C-Driver

facultydriver

#include "cdecl.h"
#include "stdio.h"

int PRE_CDECL asm_main( size_t ) POST_CDECL;
// The param must be size_t to ensure a 32-bit unsigned integer. Negative faculty not allowed

int main() {
    size_t a;
    int result;
    a = 5;
    result = asm_main(a);
    printf("%d! = %d\n", a, result);
    return 0;
}

ASM Code

segment .data
buffer: times 1 dd 0    ; define a 32-bit buffer

segment .text
global asm_main

fac: ; fac: int -> int, fac(a) = a!, REQ: a in EAX, Ret EAX
    CMP eax, 1  ; for EAX <= 1, return EAX
    JLE return
    mov ebx, eax
    DEC ebx ; EBX--
    mul ebx     ; EDX:EAX = EAX * EBX
rec_fac:    ; The main (recursive) faculty function. Never call standalone without fac
    CMP ebx, 1
    JLE return
    DEC ebx
    mul ebx
    call rec_fac        ; recursion
return:
    ret

asm_main:
    enter 0, 0
    push ebp
    mov ebp, esp    ; save the stack pointer on ebp
    pusha

    mov eax, [ebp + 12]    ; move first int argument to eax

    call fac                ; result is saved in eax now

    mov ecx, buffer        ; get buffer's address into the register
    mov [ecx], eax           ; save the modulo result into the buffer

    popa
    pop ebp

    mov eax, [buffer]        ; move the saved result back into eax
    leave
    ret

Compilation

$ nasm -f elf faculty.asm
$ gcc -m32 -c facultydriver.c
$ gcc -m32 -o faculty facultydriver.o faculty.o

Execution

$ ./faculty
5! = 120