# Lab 3 "Solution" (sort of)

# This is a fairly inefficient program. I deliberately write it
# this way to illustrate the subtleties of the MIPS calling conventions

# Gek Siong Low (cs61c-tb), Spring 1999

__start:

main:	# Variables:	a - s0
	#		b - s1
	#		size - s2

	addi $sp, $sp, -400	# allocate stack for a
	add $s0, $sp, $zero
	addi $sp, $sp, -400	# allocate stack for b
	add $s1, $sp, $zero
	addi $s2, $zero, 20	# size=0

	add $a0, $s0, $zero	# initialize(a,size,0)
	add $a1, $s2, $zero
	add $a2, $zero, $zero
	jal initialize

	add $a0, $s1, $zero	# initialize(b,size,20)
	add $a1, $s2, $zero
	addi $a2, $zero, 20
	jal initialize

	add $a0, $s0, $zero	# sumprod(a,b,size)
	add $a1, $s1, $zero
	add $a2, $s2, $zero
	jal sumprod

	add $t0, $v0, $zero	# cannot use puti $v0
	puti $t0		# because puti clobbers $v0 first
	putc '\n'
	
	addi $sp, $sp, 800	# remember to restore stack!
	done
	
multloop:		# this is Kevin/Wayne's multloop
			# since it works and conforms to conventions
			# I'll just plug it in here
	add $t5, $zero, $zero
	addi $t5, $zero, 255	#t5=255
	slt $t0, $t5, $a1	#if t5<a1, t0=1
	bne $t0, $zero, L1      #if t0
	add $t1, $zero, $zero
	slt $t1, $a1, $zero
	bne $t1, $zero, L1
	add $t5, $zero, $zero
	add $t4, $zero, $zero
	
Loop:	beq $a1, $zero, mloopend
	add $t4, $t4, $a0
	addi $a1, $a1, -1
	j Loop
	
L1:	add $t4, $zero, $zero
	addi $t4, $zero, -1

mloopend:
	add $v0, $t4, $zero
	jr $ra



initialize:	# Variables:	x - a0
		#		size - a1
		#		start - a2
		#		i - t0

	add $t0, $zero, $zero		# i=0
initloop:	
	beq $t0, $a1, initloop_end	# i<size?
	add $t1, $a2, $t0		# start + i
	add $t2, $t0, $t0		# i*4
	add $t2, $t2, $t2
	add $t3, $a0, $t2		# address of x[i]
	sw $t1, 0($t3)			# x[i]=start + i
	addi $t0, $t0, 1		# i++
	j initloop
initloop_end:
	jr $ra


sumprod:	# Variables:	x - a0
		#		y - a1
		#		size - a2
		#		z - t0
		#		i - t1
		#		sum - t2

	# I could have used the $s registers here, but using $t registers
	# allows me to demonstrate certain issues in MIPS register conventions

	addi $sp, $sp, -400	# allocate stack for z
	add $t0, $sp, $zero	# z
	add $t1, $zero, $zero	# i=0
	addi $sp, $sp, -24	# save needed registers (calling multloop)
	sw $ra, 0($sp)		# most important register to save!
	sw $a0, 4($sp)
	sw $a1, 8($sp)
	sw $a2, 12($sp)
	sw $t0, 16($sp)
	sw $t1, 20($sp)

prodloop:
	lw $t1, 20($sp)			# reload i from stack
	lw $a2, 12($sp)			# reload size
	beq $t1, $a2, prodloop_end	# i<size?
	add $t3, $t1, $t1		# i*4
	add $t3, $t3, $t3
	lw $a0, 4($sp)			# reload x
	lw $a1, 8($sp)			# reload y
	add $t4, $a0, $t3		# address of x[i]
	add $t5, $a1, $t3		# address of y[i]
	lw $a0, 0($t4)			# get x[i]
	lw $a1, 0($t5)			# get y[i]
	jal multloop			# call multloop
	lw $t0, 16($sp)			# reload z
	lw $t1, 20($sp)			# reload i
	add $t3, $t1, $t1		# i*4
	add $t3, $t3, $t3
	add $t3, $t3, $t0		# address of z[i]
	sw $v0, 0($t3)			# z[i]=result of multloop

	addi $t1, $t1, 1		# i++
	sw $t1, 20($sp)			# must update i on stack! common bug
	j prodloop
prodloop_end:

	add $t1, $zero, $zero		# i=0
	add $t2, $zero, $zero		# sum=0
sumloop:
	beq $t1, $a2, sumloop_end	# i<size?
					# ($a2 was not clobbered so it's okay)
	add $t3, $t1, $t1		# i*4
	add $t3, $t3, $t3
	lw $t0, 16($sp)			# reload z
	add $t3, $t3, $t0		# address of z[i]
	lw $t4, 0($t3)			# get z[i]

	add $t2, $t2, $t4		# sum=sum+z[i]
	addi $t1, $t1, 1		# i++
	j sumloop
sumloop_end:
	add $v0, $t2, $zero		# move sum into $v0
	lw $ra, 0($sp)			# restore $ra first!
	addi $sp, $sp, 424		# then restore stack pointer
	jr $ra