How to implement factorial function in RISC-V - factorial

Question

C-code :
int factorial(int n)
{
if (n<1) return 1;
else return n * factorial (n-1);
}
I've tried to implement it but haven't managed to do a lot. So here is my try:
goto:
factorial:
int factorial(int n) {
if (n<1) goto Lthen;
Lelse:
tmp=factorial(n-1);
return n*tmp;
goto Lend;
Lthen: return 1;
Lend;
}
RISC V:
.factorial
addi sp, sp, -16
sw ra, (sp)
sw s0, 4(sp) //n
sw s1, 8(sp) //tmp
mv s0, a0 //a--->s0
addi t1, zero,1
blt s0, t1, Lthen
.Lelse
mv t0, s0 // copy of n to t0
addi s0, s0, -1 // n-1
mv a0, s0; // n-1--->a0
jal factorial // factorial(a0)
mv s1, a0 // s1=factorial(a0) //tmp
mul a0,t0,s1 // n*tmp ----> a0
ret
j LEND
Lthen: li a0,1
ret
LEND jr ra, 0
Can somebody tell me is that okay, because I don't know how to test it.
And I am not sure about for example return 1 /or any other value/expression, can we just put it in a0 and say ret..
Thank you for your time!

Answer 1

You should use $s0 for the preserved value, instead of $t0.
You should be subtracting one from $a0 after copying from $s0 before the recursive call.
The multiply then would go between the $a0 return value and the $s0 preserved value.
The reason $s0 will work but $t0 won't (to preserve the original $a0 input), is that you are making the (correct) effort to save the s registers.
However, you are not restoring the saved values in function epilogue, nor cutting back the stack, nor reloading $ra...

Answer 2

Here's a recursive factorial function in RISC-V from my RV32I assembly programmer's quick reference: (comments welcome!)
.text # recursive implementation of factorial
.globl __start
fact: # arg: n in a0, returns n! in a1
addi sp, sp, -8 # reserve our stack area
sw ra, 0(sp) # save the return address
li t0, 2
blt a0, t0, ret_one # 0! and 1! == 1
sw a0, 4(sp) # save our n
addi a0, a0, -1
jal fact # call fact (n-1)
# a1 <- fact(n-1)
lw t0, 4(sp) # t0 <- n
mul a1, t0, a1 # a1 <- n * fact(n-1)
j done
ret_one:
li a1, 1
done:
lw ra, 0(sp) # restore return address from stack
addi sp, sp, 8 # free our stack frame
jr ra # and return
__start:
li a0, 5 # compute 5!
jal fact
li a0, 1 # print it
ecall
li a0, 17
ecall # and exit
To test it, my favorite lightweight RISC-V simulators are Venus and Jupiter.