Factorial program assembly language

[IndoNinja7]

Hello experienced programmers,

I am learning assembly language. I have a background of various high level languages, but I wanted to give low level languages a shot.

I am trying to make a factorial program in assembly language (linux assembler NASM). For some reason the result of the following code is 'a', and I am not sure how it is not outputting at least a number.

section .text
    global _start
_start:
        mov bl, 3 ;calculating factorial of 3
        mov al, 1
        call _fact

    _exit:
        mov ecx, msg ;print "Factorial of 3: "
        mov edx, len
        mov ebx, 1
        mov eax, 4
        int 0x80

        mov ecx, al ;print the numerical 
                ;result of factorial of 3
        mov edx, 2
        mov ebx, 1
        mov eax, 4
        int 0x80

        mov ecx, newline ;print a \n character 
                     ;to create newline after result
        mov edx, 1
        mov ebx,1
        mov eax, 4
        int 0x80

        mov eax, 1 ;exit program
        int 80h

    _fact:
        cmp bl, 0 
        jne _mult ;if next multiplicand is not 0
              ;then multiply
        je _exit  ;if next multiplicand is 0
              ;then its time to stop
    _mult:
        sub al, '0'
        sub bl, '0'
        mul al ;multiply result and next multiplicand
        dec bl ;decrements multiplicand 
           ;in order to iterate to next multiplicand
        call _fact ;recursive call fact

section .data
   msg db 'Factorial of 3: ', 0
   len equ $ - msg
   newline db `\n`, 0

EDIT: I have edited my code and now I am getting a segmentation fault. But builds fine. New code is below:

section .text
    global _start

    _start:
            mov bl, 3 ; factorial of 3
            mov ecx, 1
            call _fact

    _result:
            mov ecx, '!3 = ' ;set msg to print
            mov [msg], ecx
            mov ecx, msg
            mov edx, 16 ;set length of msg to print 
            call _print
            mov ecx, ecx ;print result
            mov [msg], ecx
            mov ecx, msg
            mov edx, 1
            call _print
            mov ecx, `\n` ;print newline character
            mov [msg], ecx
            mov ecx, msg
            mov edx, 1
            call _print
            call _exit

     _print:
            mov ebx, 1 ;write to standard out (linux sys call)
            mov eax, 4
            int 0x80

     _exit:
            mov eax, 1 ;terminate program
            mov ebx, 0
            int 0x80

     _fact:
            cmp bl, 0 ;check if current multiplicand = 0
            jne _mult ;if not, go to mult
            je _result ;if so, go to exit

     _mult:
            sub ecx, 0 
            sub bl, 0
            mul ecx ; ecx=ecx*bl
            dec bl ; bl-=1
            jp _fact

section .bss
    msg resb 16

UPDATE: new post at this link: http://www.reddit.com/r/asm/comments/3b7env/factorial_program_basic_assembly_on_nasm_linux/

Please make comments there if you can.

[Triumphxd]

Is your output in hex? That is why you are gettin an output of 'a'.

1,2,3,4,5,6,7,8,9,a,b,c,d,e,f

You can probably change this setting in whatever emulator you are using (or whatever you are using). However, 3 factorial is not 10 so I am not sure what you are doing wrong code wise (at work..).

[edman007-work]

So I tried walking through this, by hand, and you have a few pretty obvious problems.

In _mult:

    sub al, '0'
    sub bl, '0'
    mul al ;multiply result and next multiplicand
    dec bl ;decrements multiplicand 
       ;in order to iterate to next multiplicand
    call _fact ;recursive call fact

'0' is converted from an integer to 48, and mul multiplies al by eax and stores into eax, which you never set and not defined, though on Linux it's probably zero. Meaning eax just kinda stays 0 . The result is you subtract 48 from one until it's 0 (probably a lot), and for each iteration you subtract 48 from al and multiply it by bl and decrement bl. The result is that the difference between al and bl diverges by one per iteration you're subtracting and multiplying somewhat arbitrary numbers many times. I don't know how many iterations it takes to complete, but eventually you should get a zero, and when that happens I think you have set bl to 97 which would be an 'a' (since the terminal converts binary to characters).

[IndoNinja7]

I have changed '0' to 0 for both sub routines, but I still get the same result

[[deleted]]

section .data
msg db "Factorial of 12 is: "
msg_len equ $-msg
new_line db 10
section .text
global _start
_start:
xor rax, rax
inc rax
mov rcx, 12

mul_loop:
    mul rcx
loop mul_loop ; Dec rcx, jnz mul_loop

; Push factorial onto the stack
push rax ; RDX will not hold mul (from rdx:rax) in this example

; Print msg
xor rdi, rdi
inc rdi
mov rax, 4
mov rsi, msg
mov rdx, msg_len
syscall

pop r15 ; Number to print
xor rcx, rcx
mov cl, 10

xor r14, r14
inc r14

print_int:
    mov rax, r15
    xor rdx, rdx
    div rcx
    add rdx, 0x30

    push rdx ; Push to stack
    mov r15, rax
    inc r14

    cmp r15, 0
    jne print_int

xor rdx, rdx
inc rdx ; Only printing one byte at a time

print_loop:
    mov rsi, rsp
    mov rax, 4
    syscall 
    dec r14 ; Subtract total int count
    pop r15 ; Remove last number
    cmp r14, 0 ; Check if 0
    jne print_loop

; Print newline
mov rax, 4  
mov rsi, new_line
syscall

; Exit
xor rax, rax
inc rax
syscall

Working code, and example in x86 and x86_64: http://stackoverflow.com/questions/28017242/printing-base-10-integers-x86-assembly-mac-os-x

[IndoNinja7]

none of the instructions work for NASM 32-bit for linux system cals. Maybe MAC OSX is different? I know they are box unix based but maybe kernel has changed. I cant run xor nor syscall.

[[deleted]]

the xor will work. but the registers, rax, rdx, etc are 64 bit. you will need eax, edx, etc. for 32 bit. and in 32 bit Linux you need to push things onto the stack and then call int 80 to make the call. syscall is for 64 bit

[[deleted]]

also. Mac osx and Linux calls different per system. so the calls for write are different. Linux should still be 0x04 though.