Machine Organization & Assembly Language
CSE 378, Spring Quarter 2000
Assembly Language Programming Exercises - Answers
Exercise 1 - Absolute Value
bltz $t1, neg # If $t0 < 0 then branch to the instruction
# labelled neg
add $t1, $t0, $zero # Set $t1 to $t0
j skip # Jump over the next instruction
neg: sub $t1, $zero, $t0 # Set $t1 to -$t0
skip:
Multiplying by -1 to perform the negation is tricky: the result is held in
special registers and needs to be transferred to the general purpose registers.
Exercise 2 - Swap
lw $t0, 0($a0) # Load the first word into $t0
lw $t1, 0($a1) # Load the second word into $t1
sw $t0, 0($a1) # Store $t0 into the old second word
sw $t1, 0($a0) # Store $t1 into the old first word
Exercise 3 - Linear Search
linSearch: # A procedure to perform linear searching of an integer array
# On entry:
# $a0 - base address of the array
# $a1 - number of elements in the array
# $a2 - the number to search for
# On exit:
# $v0 - 1 if the number was found, 0 otherwise
addi $t0, $a0, 0 # Initialize $t0 to the base address of the
# array
# Set $t1 to the address just beyond the
# last element in the array, which is:
sll $t1, $a1, 2 # the number of elements multiplied by 4
add $t1, $t1, $a0 # and added to the base address of the array
# $t1 has this odd "beyond the end" address
# that an addition instruction can be
# removed
loop: beq $t0, $t1, not # If $t0 == $t1 then exit the loop, the
# value was not found
lw $t2, 0($t0) # Load the current element into $t2
beq $t2, $a2, found # If it is the number we are searching for
# then exit the loop
addi $t0, $t0, 4 # Make $t0 point to the next array element
j loop # Jump to the start of the loop
not: addi $v0, $zero, 0 # Set $v0 to 0
jr $ra # Return from the procedure
found: addi $v0, $zero, 1 # Set $v0 to 1
jr $ra # Return from the procedure
By using a pointer into the array, you can avoid having to multiply the index
by 4 and adding it to the base address of the array. This is to save
instructions so that the code executes quicker.
Exercise 4 - MiniMax
miniMax: # A procedure to find the minimum and maximum elements of an integer
# array
# On entry:
# $a0 - base address of the array
# $a1 - number of elements in the array
# On exit:
# $v0 - the minimum element
# $v1 - the maximum element
addi $t0, $a0, 4 # Initialize $t0 to the base address of the
# array plus 4. This allows for an addition
# instruction to be removed
# Set $t1 to the address just beyond the
# last element in the array, which is:
sll $t1, $a1, 2 # the number of elements multiplied by 4
add $t1, $t1, $a0 # and added to the base address of the array
# $t1 has this odd "beyond the end" value so
# that an addition instruction can be removed
lw $v0, -4($t0) # Initialize $v0 and $v1 to the first element
addi $v1, $v0, 0 # in the array. Notice the use of the offset
# field to "look backwards" - we get a "free"
# subtraction operation
loop: beq $t0, $t1, exit # If $t0 == $t1 then exit the loop
lw $t2, 0($t0) # Load the current element into $t2
slt $t3, $t2, $v0 # If $t2 >= the smallest element so far
beq $t3, $zero, skip1 # then skip the next instruction
addi $v0, $t2, 0 # Set $v0 to the current element
skip1: slt $t3, $v1, $t2 # If the largest element so far >= $t2
beq $t3, $zero, skip2 # then skip the next instruction
addi $v1, $t2, 0 # Set $v1 to the current element
skip2: addi $t0, $t0, 4 # Make $t0 point to the next array element
j loop # Jump to the start of the loop
exit: jr $ra # Return from the procedure
Main Page
Section Notes Page