Here we are calculating factorial of n no [1,2,3,4 ……..,n] using MIPS Assembly language

MIPS assembly language is a very good language to learn because many embedded systems in the world run on the MIPS processor only.

.globl main

.data

msgprompt: .word msgprompt_data

msgres1: .word msgres1_data

msgres2: .word msgres2_data

msgprompt_data: .asciiz "Enter Positive integer only: "

msgres1_data: .asciiz "The value of factorial("msgres2_data: .asciiz ") is "

# every function call has a Stack segment of 12 bytes, or 3 words.

# the space is guarded as follows:

# 0($sp) is reserved for the initial value given to this call

# 4($sp) is the space reserved for a return value

# 8($sp) is the space reserved for the return address.

# calls may change their parent's data, but parents may not

# change their child's data.

# i.e., if we have a call A who has a child call B:

# B may run:

# sw $t0, 16($sp)

# which will store data from $t0 to the parent's return value register

# however A should not(and, in all cases I can think of, cannot) manipulate

# any data that belongs to a child call.

.text

main:

# printing the prompt

#printf("Positive integer Only: ");

la $t0, msgprompt # load address of msg prompt into $t0

lw $a0, 0($t0) # load data from address in $t0 into $a0

li $v0, 4 # system call code for print string

syscall # run the print string syscall

# reading the input int

# scanf("%d", &number);

li $v0, 5 # call code for read_int i.e., reading user input from console

syscall # run the read_int syscall

move $t0, $v0 # store input into temporary storage for further usage $t0

move $a0, $t0 # move input to the argument register $a0

addi $sp, $sp, -12 # move Stackpointer up 3 words

sw $t0, 0($sp) # store input on the top of Stack

sw $ra, 8($sp) # store counter at the bottom of Stack

jal factorial # call factorial to calculate the factorial of number

# as we have reached here now we have the final return value in 4($sp)

lw $s0, 4($sp) # load final return value into $s0

# below command works like printf("The value of 'factorial(%d)' is: %dn"), in C language

la $t1, msgres1 # load msgres1 address into $t1

lw $a0, 0($t1) # load msgres1_data value into $a0

li $v0, 4 # system call for print_string

syscall # print value of msgres1_data to screen

lw $a0, 0($sp) # load the original value in the $a0

li $v0, 1 # system call for print_int code = 1

syscall #call the syscall print original value to screen

la $t2, msgres2 #load msgres2 address into $t1

lw $a0, 0($t2) # load msgres_data value into $a0

li $v0, 4 # system call for print_string code =4

syscall # call the syscall print original value to screen

move $a0, $s0 # move final returned value from $s0 to $a0 for return

li $v0, 1 # system call for print_int code =1

syscall # call the syscall print original value to screen

addi $sp, $sp, 12 # move the Stack pointer back down where we started

# return 0;

li $v0, 10 # system call for exit code = 10

syscall # call exit system call exit!

.text

factorial:

# base case - still in parent's Stack segment

lw $t0, 0($sp) # load input from the top of the Stack into register $t0

#if (x == 0)

beq $t0, 0, returnOne # if $t0 is equal to 0, branch to return One

addi $t0, $t0, -1 # subtract 1 from $t0 if $t0 not equals to the 0

# recursive case - move to this call's Stack segment

addi $sp, $sp, -12 # move the Stack pointer up 3 words

sw $t0, 0($sp) # store the current working number into the top of the Stack segment

sw $ra, 8($sp) # store the Counter at bottom of the Stack segment

jal factorial # recursive call for factorial

# as we bring here, then we have the child return value in 4($sp)

lw $ra, 8($sp) # load this call's $ra once again (we just got back from a jump)

lw $t1, 4($sp) # load the child's return value into $t1

lw $t2, 12($sp) # load the parent start value into $t2

# return x * factorial(x-1); (this is not a return statement, but a multiplication statement)

mul $t3, $t1, $t2 # multiply child's return value by parent's working value, store in $t3.

sw $t3, 16($sp) # take result(in $t3), store in parent's return value.

addi $sp, $sp, 12 # move Stackpointer back down for the parent call

jr $ra # jump to parent’s call

.text

#return 1;

returnOne:

li $t0, 1 # load 1 into register $t0

sw $t0, 4($sp) # store 1 into the parent's return value register

jr $ra # jump to parent call

Public Answer