Write a MIPS assembly language program that Prompts tor a 5 digits number (e.g.

ID: 3674364 • Letter: W

Question

Write a MIPS assembly language program that Prompts tor a 5 digits number (e.g. 75080) Calls a function named iter-zip that calculates the sum of the digits (7+5+0+8+0) iteratively and then prints out the sum. Calls a function named rec-zip that calculates the sum of the digits recursively and then prints out the sum. When the program is executing the code of function rec-zip observe the visual stack (in the Tools menu of the modified MARS on eLearning) and capture the state of the stack when it starts to pop words out. Answer the questions: 1) which version is faster, and 2) why it is faster.

Explanation / Answer

MIPS

Data Types and Literals

Data types:

Literals:

Registers

This is from Figure 9.9 in the Goodman&Miller text

Alternative
Name

Description

zero

the value 0

$at

(assembler temporary) reserved by the assembler

2-3

$v0 - $v1

(values) from expression evaluation and function results

4-7

$a0 - $a3

(arguments) First four parameters for subroutine.
Not preserved across procedure calls

8-15

$t0 - $t7

(temporaries) Caller saved if needed. Subroutines can use w/out saving.
Not preserved across procedure calls

16-23

$s0 - $s7

(saved values) - Callee saved.
A subroutine using one of these must save original and restore it before exiting.
Preserved across procedure calls

24-25

$t8 - $t9

(temporaries) Caller saved if needed. Subroutines can use w/out saving.
These are in addition to $t0 - $t7 above.
Not preserved across procedure calls.

26-27

$k0 - $k1

reserved for use by the interrupt/trap handler

$gp

global pointer.
Points to the middle of the 64K block of memory in the static data segment.

$sp

stack pointer
Points to last location on the stack.

$s8/$fp

saved value / frame pointer
Preserved across procedure calls

$ra

return address

See also Britton section 1.9, Sweetman section 2.21, Larus Appendix section A.6

Program Structure

Data Declarations

Code

Comments

Data Declarations

format for declarations:

name: storage_type value(s)

Note: labels always followed by colon ( : )

example

var1: .word 3 # create a single integer variable with initial value 3

array1: .byte 'a','b' # create a 2-element character array with elements initialized

# to a and b

array2: .space 40 # allocate 40 consecutive bytes, with storage uninitialized

# could be used as a 40-element character array, or a

# 10-element integer array; a comment should indicate which!

Load / Store Instructions

load:

lw register_destination, RAM_source

#copy word (4 bytes) at source RAM location to destination register.

lb register_destination, RAM_source

#copy byte at source RAM location to low-order byte of destination register,
# and sign-e.g.tend to higher-order bytes

store word:

sw register_source, RAM_destination

#store word in source register into RAM destination

sb register_source, RAM_destination

#store byte (low-order) in source register into RAM destination

load immediate:

li register_destination, value

#load immediate value into destination register

example:

.data

var1: .word 23 # declare storage for var1; initial value is 23

.text

__start:

lw $t0, var1 # load contents of RAM location into register $t0: $t0 = var1

li $t1, 5 # $t1 = 5 ("load immediate")

sw $t1, var1 # store contents of register $t1 into RAM: var1 = $t1

done

Indirect and Based Addressing

load address:

la $t0, var1

indirect addressing:

lw $t2, ($t0)

sw $t2, ($t0)

based or indexed addressing:

lw $t2, 4($t0)

sw $t2, -12($t0)

Note: based addressing is especially useful for:

example

.data

array1: .space 12 # declare 12 bytes of storage to hold array of 3 integers

.text

__start: la $t0, array1 # load base address of array into register $t0

li $t1, 5 # $t1 = 5 ("load immediate")

sw $t1, ($t0) # first array element set to 5; indirect addressing

li $t1, 13 # $t1 = 13

sw $t1, 4($t0) # second array element set to 13

li $t1, -7 # $t1 = -7

sw $t1, 8($t0) # third array element set to -7

done

Arithmetic Instructions

add $t0,$t1,$t2 # $t0 = $t1 + $t2; add as signed (2's complement) integers

sub $t2,$t3,$t4 # $t2 = $t3 Ð $t4

addi $t2,$t3, 5 # $t2 = $t3 + 5; "add immediate" (no sub immediate)

addu $t1,$t6,$t7 # $t1 = $t6 + $t7; add as unsigned integers

subu $t1,$t6,$t7 # $t1 = $t6 + $t7; subtract as unsigned integers

mult $t3,$t4 # multiply 32-bit quantities in $t3 and $t4, and store 64-bit

# result in special registers Lo and Hi: (Hi,Lo) = $t3 * $t4

div $t5,$t6 # Lo = $t5 / $t6 (integer quotient)

# Hi = $t5 mod $t6 (remainder)

mfhi $t0 # move quantity in special register Hi to $t0: $t0 = Hi

mflo $t1 # move quantity in special register Lo to $t1: $t1 = Lo

# used to get at result of product or quotient

move $t2,$t3 # $t2 = $t3

Control Structures

Branches

b target # unconditional branch to program label target

beq $t0,$t1,target # branch to target if $t0 = $t1

blt $t0,$t1,target # branch to target if $t0 < $t1

ble $t0,$t1,target # branch to target if $t0 <= $t1

bgt $t0,$t1,target # branch to target if $t0 > $t1

bge $t0,$t1,target # branch to target if $t0 >= $t1

bne $t0,$t1,target # branch to target if $t0 <> $t1

Jumps

j target # unconditional jump to program label target
jr $t3 # jump to address contained in $t3 ("jump register")

Subroutine Calls

subroutine call: "jump and link" instruction

jal sub_label # "jump and link"

subroutine return: "jump register" instruction

jr $ra # "jump register"

Note: return address stored in register $ra; if subroutine will call other subroutines, or is recursive, return address should be copied from $ra onto stack to preserve it, since jal always places return address in this register and hence will overwrite previous value

System Calls and I/O (SPIM Simulator)

The following table lists the possible syscall services.

Service

Code
in $v0

Arguments

Results

print_int

$a0 = integer to be printed

print_float

$f12 = float to be printed

print_double

$f12 = double to be printed

print_string

$a0 = address of string in memory

read_int

integer returned in $v0

read_float

float returned in $v0

read_double

double returned in $v0

read_string

$a0 = memory address of string input buffer
$a1 = length of string buffer (n)

sbrk

$a0 = amount

address in $v0

exit

e.g. Print out integer value contained in register $t2

li $v0, 1 # load appropriate system call code into register $v0;

# code for printing integer is 1

move $a0, $t2 # move integer to be printed into $a0: $a0 = $t2

syscall # call operating system to perform operation

e.g. Read integer value, store in RAM location with label int_value (presumably declared in data section)

li $v0, 5 # load appropriate system call code into register $v0;

# code for reading integer is 5

syscall # call operating system to perform operation

sw $v0, int_value # value read from keyboard returned in register $v0;

# store this in desired location

e.g. Print out string (useful for prompts)

.data

string1 .asciiz "Print this. " # declaration for string variable,

# .asciiz directive makes string null terminated

.text

main: li $v0, 4 # load appropriate system call code into register $v0;

# code for printing string is 4

la $a0, string1 # load address of string to be printed into $a0

syscall # call operating system to perform print operation

e.g. To indicate end of program, use exit system call; thus last lines of program should be:

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

syscall # call operating sys

Navigate

Write a MIPS assembly language procedure, stats, that will find the minimum, med

Write a MIPS assembly language program that a) Prompt the user for an integer in

Integrity-first tutoring: explanations and feedback only — we do not complete graded work. Learn more.

Write a MIPS assembly language program that Prompts tor a 5 digits number (e.g.

Question

Explanation / Answer

Related Questions

Navigate