Question

Write a program to evaluate the arithmetic expression: (25xy - 10x - 6y + 28)/7

Use symbolic addresses x, y, answer, and remainder. Pick two registers for x and y and load them from memory. At the end of the program, store the answer and remainder to memory. Assume that the values are small enough so that all results fit into 32 bits. Since load delays are turned on in SPIM be careful what instructions are placed in the load delay slot.

Verify that the program works by using several initial values for x and y. Use x=1, y=1 and x=1, y= -1 to start since this will make debugging easy. Then try some other values. Don’t assume that x and y are positive.

Remember that a value loaded from memory can only be used after a one instruction delay slot. Also, be sure to use the basic assembly two-operand instructions for multiply and divide and to retrieve the results of the operation from the lo and hi registers.

Use register $10 as a base register and use register-offset addressing to load and store values. Set up the base register with a lui instruction. The program at the end of the chapter will be useful.

Set MIPS settings to the following:

ON Bare Machine

ON Enable Delayed Loads

ON Enable Delayed Branches

OFF Load Exception Handler

OFF Enable Mapped IO

OFF Accept Pseudo Instructions

Set these options as specified or QtSpim will start up with options you don’t want. You may have to set the options, close QtSpim, and then restart it for the options to have an effect. Use only those instructions that have been discussed in the notes through chapter 15. Include a register use table in the documentation at the top of your source program.

Answer 1

.data
                # declare varaibles
                # memory address are stored as default in spim as follow
                x:       .word -17   # use address 0x10000000 by default
                y:       .word -13   # next address is 0x10000004
                answer:       .word 0       # at 0x10000008
                remainder:   .word 0       # at 0x1000000c
                # stores 9 bytes including null terminator at end
                ans_text:    .asciiz "Answer: "       
                rem_text:    .asciiz "\nRemainder: "
              
.text
####################################################################
# Procedure main
# Description: evaluates (25xy - 10x - 6y + 28)/7
# parameters:
# return value:
# registers to be used: $8, $9, $10, $11
###################################################################
main:
                # load x into $8
                lui, $10, 0x1000
                lw $8, 0($10)       # $8 = value of x
                # load y in $9
                lw $9, 4($10)       # $9 = value of x
                addi $11, $zero, 25   # $11 = 25
                # evaluate first term of numerator
                mult $11, $8  
                mflo $11       # $11 = 25x
                # assuming result fit into 32 bits
                # so allbits are in lo register
                mult $11, $9
                mflo $11       # $11 = 25xy
                # store result in answer
                # address of answer is 3rd word location
                sw $11, 8($10)       # answer = 25xy
                # evaluate second term of numerator
                addi $11, $zero, -10   # $11 = -10
                mult $11, $8  
                # load answer
                lw $9, 8($10)       # $9 = 25xy
                mflo $11       # $11 = -10x
                add $11, $9, $11   # $11 = 25xy - 10x
                # store result in answer
                sw $11, 8($10)       # answer = 25xy - 10x
                # load y in $9
                lw $9, 4($10)       # $9 = y
                addi $11, $zero, -6   # $11 = -6
                mult $9, $11
                mflo $11       # $11 = -6y
                # load answer
                lw $9, 8($10)       # $9 = 25xy - 10x
                addi $8, $zero, 28   # $8 = 28
                add $11, $9, $11   # $11 = 25xy - 10x - 6y
                add $11, $11, $8   # $9 = 25xy -10x -6y +28
                # perform division
                addi $8, $zero, 7   # $8 = 7
                div $11, $8
                # quotient stored in lo
                mflo $9           # $9 = quotient
                # remainder stored in hi
                mfhi $8           # $8 = remainder
                # store values to memory
                sw $9, 8($10)       # answer = quotient
                sw $8, 12($10)       # remainder = remainder value
              
                # print string
                addi $a0, $10, 16
                addi $v0, $zero, 4
                syscall
                # print answer
                lw $a0, 8($10)
                addi $v0, $zero, 1
                syscall
                # print string
                # calculate next string address
                # string is 9 character long each character stores 1 byte
                # 16 + 9 = 25,
                # address at $10 + 25
                addi $a0, $10, 25
                addi $v0, $zero, 4
                syscall
                # print remainder
                lw $a0, 12($10)
                addi $v0, $zero, 1
                syscall
                # end program
                addi $v0, $zero, 10
                syscall

let me know if you have any problem or doubts. thank you.