##################################################################################
#CS2710 Homework 4
# Put your name here.
#
# Read these instructions carefully and fully.
#
# This assignment builds upon your solution to the previous (Homework 3) assignment.
# For this assignment, write an MIPS assembly-language procedure that is equivalent
# to the following Java method:
#
# // This method sums the first n values in myArray and returns the result.
# // myArray - reference to an integer array of arbitrary length.
# // n - the number of elements of myArray to use to compute the sum.
# // returns: the sum of the first n elements of myArray.
# public int addValues( int[] myArray, int n ) {
#	int sum = 0;
#	for( int i=0; i<n; i++ ) {
#		sum += myArray[i];
#	}
#	return sum;
# }
# BE SURE TO THOROUGHLY COMMENT YOUR CODE!!!
# 
##################################################################################
.text		# Optional, but .text tells the assembler that following this are program instructions

# Your solution to last week's problem goes here.
start:
	# i=0;
	addi	$t0, $zero, 0		#t0=0; (init loop counter)
	lw	$t1, n			#t1=value at address n (number of elements to copy from A to B
	
loop:	# while(i<n) {
	beq	$t0, $t1, end		#if(i==n) jump to end
	sll	$t3, $t0, 2		#compute array offset in bytes (t3=t0*4)
#   B[i] = A[i];
	lw	$t4, A($t3)		#load from A+offset
	sw	$t4, B($t3)		#store to B+offset
#   i++;
	addi	$t0, $t0, 1		#t0++ (increment counter)
	j	loop			#and repeat loop 

# Just before the unconditional jump back to the start of your main program, 
# insert two calls to the addValues procedure (below). The first call should compute the sum
# of the first 3 values of the array of integer words represented by A, while the second call
# should compute the sum of the first 5 values of the array of integer works represented 
# by the label B. 
# Represent the arguments to addValues by the registers $a0 and $a1, where $a0 contains the
# address of the array in data memory containing the values to be added together, and $a1 contains
# the number of values to add.
end:
# Note: if we were concerned about the possibility of addValues or printResult modifying the
# $t registers used in this main "routine", we should save those registers' values here (as shown)
# and restore them after the procedure calls. However, since we reinitialize those registers
# whenever the program jumps back to start, we can effectively ignore that possibility.
#	sw	$t0, ($sp)		#save t0, t1, t3, t4 to stack (t2 not used)
#	sw	$t1, -4($sp)		
#	sw	$t3, -8($sp)		
#	sw	$t4, -12($sp)		
#	addi	$sp, $sp, -16		#decrement stack pointer to point to next available slots

	addi	$a1, $zero, 3		#a1=3
	la	$a0, A			#a0=address of A
	jal	addValues		#call the procedure

	la	$a0, msg1		#load address of message 1
	addi	$a1, $v0, 0		#move return value from addValues into a1
	jal	printResult		#print the result
	
	addi	$a1, $zero, 5		#a1=5
	la	$a0, B			#a0=address of B
	jal	addValues		#call the procedure
	
	la	$a0, msg2		#load address of message 2
	addi	$a1, $v0, 0		#move return value from addValues to a1
	jal	printResult		#print the result
	
#	addi	$sp, $sp, 16		#increment stack pointer to point back to where we found it
#	lw	$t0, ($sp)		#restore t0, t1, t3, t4 from the stack (t2 not used)
#	lw	$t1, -4($sp)		
#	lw	$t3, -8($sp)		
#	lw	$t4, -12($sp)		

	j	start			#repeat from start
##################################################################################

##################################################################################################
# This is procedure addValues. It sums the first n values (where n is the value in register $a1) 
# of a data array whose address is contained in $a0. The sum is returned in $v0.
# Note: This procedure modfifies $t0 through $t4 - the caller must worry about saving/restoring these.
addValues:
	sw	$ra, ($sp)		# push the return address onto the stack
	addi	$sp, $sp, -4		# decrement $sp (by 4 bytes) to point at the next available stack location
	
	addi	$t0, $zero, 0		# init counter t0=0
	addi	$v0, $zero, 0		# init sum v0=0
addValues_loop:
	beq	$t0, $a1, addValues_end	# if(t0==n) terminate loop
	sll	$t1, $t0, 2		# compute byte offset
	add	$t2, $a0, $t1		# t2: address of array element
	lw	$t3, ($t2)		# load value at array index
	add	$v0, $v0, $t3		# add to sum
	addi	$t0, $t0, 1		# increment counter t0++
	j	addValues_loop
	
addValues_end:
	addi	$sp, $sp, 4		# increment $sp (by 4 bytes) to point to the return address
	lw	$ra, ($sp)		# pop the return address from the stack
	jr	$ra			# return to the instruction referenced by $ra (return address register)		
# end procedure addValues
##################################################################################################

##################################################################################################
# This is procedure printResult, which encapsulates printing a string and an int value
# via syscalls. The address of the string to be printed is contained in $a0 and the value of the 
# int to be printed is contained in $a1. No value is returned.
# Note: since $a0 and $v0 are modified within this procedure, their initial values must be restored upon exit.
printResult:
	sw	$ra, ($sp)		# push the return address onto the stack
	sw	$v0, -4($sp)		# push initial value of $v0 to stack
	sw	$a0, -8($sp)		# push inital value of $a0 to stack
#	addi	$sp, $sp, -12		# decrement $sp by 3 words(can omit IFF you're SURE the stack won't be used within this procedure)
	
	addi	$v0, $zero, 4		# function code for string printing
	syscall				# print the string whose address is $a0
	
	addi	$v0, $zero, 1		# function code for int printing
	addi	$a0, $a1, 0		# int argument to syscall must be in $a0
	syscall				# print the int

#	addi	$sp, $sp, 12		# increment $sp (can conditionally be omitted along with decrement as described above)
	lw	$a0, -8($sp)		# pop initial value of $a0 from stack
	lw	$v0, -4($sp)		# pop initial value of $v0 from stack
	lw	$ra, ($sp)		# pop the return address from the stack
	jr	$ra			# return to the instruction referenced by $ra (return address register)		
# end procedure printResult
##################################################################################################

.data 		# Tells the assembler that the following directives affect the .data section of memory	
A:		# A represents an array of 9 32-bit words containing the values below
.word 1,2,3,4,5,6,7,8,9
B:		# B represents a second array of 5 32-bit words, all initialized to 0.
.word 0,0,0,0,0
n:		# n specifies the number of values to copy from A to B
.word 4
msg1:		# a null-terminated string containing the text of the message, including a newline at the start
.asciiz "\nThe sum of the first 3 values in A is: "
msg2:
.asciiz "\nThe sum of the first 5 values in B is: "