rankK.asm

.data
list1:	.word 4,6,3,7,9,34,9,1,2,2,3,4,4,4,6
buf1:	.space 60
list2:	.word 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15
buf2:	.space 60
list3:	.word -1,43,5,6,-7,2,3,4,-3,4,5,3,3,2,3
buf3:	.space 60
test1:	.asciiz "\nTesting for list1 - random list\n------------------------------\n"
test2:	.asciiz "\nTesting for list2 - sorted list\n------------------------------\n"
test3:	.asciiz "\nTesting for list3 - negative numbers\n------------------------------\n"

#;	DON'T TOUCH
__regsav:		.space 20
__exc0_msg:	.asciiz "[Interrupt] "
__exc1_msg:	.asciiz "[TLB]"
__exc2_msg:     .asciiz "[TLB]"
__exc3_msg:	.asciiz "[TLB]"
__exc4_msg:	.asciiz "[Address error in inst/data fetch] "
__exc5_msg:	.asciiz "[Address error in store] "
__exc6_msg:	.asciiz "[Bad instruction address] "
__exc7_msg:	.asciiz "[Bad data address] "
__exc8_msg:	.asciiz "[Error in syscall] "
__exc9_msg:	.asciiz "[Breakpoint] "
__exc10_msg:	.asciiz "[Reserved instruction] "
__exc11_msg:	.asciiz ""
__exc12_msg:	.asciiz "[Arithmetic overflow] "
__exc13_msg:	.asciiz "[Trap] "
__exc14_msg:	.asciiz ""
__exc15_msg:	.asciiz "[Floating point] "
__exc_msg_table:
		.word   __exc0_msg, __exc1_msg, __exc2_msg, __exc3_msg, __exc4_msg
		.word   __exc5_msg, __exc6_msg, __exc7_msg, __exc8_msg, __exc9_msg
		.word   __exc10_msg, __exc11_msg, __exc12_msg, __exc13_msg, __exc14_msg
		.word   __exc15_msg
__ex:		.asciiz "Expected: "
__actual:		.asciiz " Actual: "
__pass:		.asciiz "\t\t\t\tTest passed!\n"
__fail:		.asciiz "\t\t\t\tTest failed!***\n"
__exc:		.asciiz "Exception - "
__endmsg:		.asciiz " tests ran in "
__ms:		.asciiz " ms\n------------------------\n"
__failmsg:	.asciiz " failures"
__startT:	.word 0
__fails:	.word 0
__total:	.word 0

.ktext	0x80000180 #; might be different, check your settings for exception handler address
	la	$k1, __regsav
	sw	$v0, 0($k1)
	sw	$a0, 4($k1)
	li      $v0, 4
	la	$a0, __exc
	syscall
	mfc0	$k0, $13
	andi	$k0, $k0, 0x7c
	lw	$a0, __exc_msg_table($k0)
	li	$v0, 4
	syscall
	lw	$v0, 0($k1)
	lw	$a0, 4($k1)
	la	$k0, __exception
	mtc0	$k0, $14
	eret

.text
main:
	jal	__setup
	
	
	la	$a0, test1
	li	$v0, 4
	syscall
	
	#; USAGE:
	#; load a0-a3 with the args your function takes
	#; use 'la $t8, your_function' to load your function
	#; use 'li $t9, EXPECTED_VALUE' to load $t9 with the expect return value of your function
	#; example below:
	
	#; copy over the list
	la	$a0, list1
	li	$a1, 60
	jal	memcpy
	
	li	$a0, 0
	#; load the address of the copied list
	addi	$a1, $v0, 0
	li	$a2, 15
	li	$t9, 1
	la	$t8, findRankK
	jal	test
	
	#; don't need to load findRankK any more since $t8 is preserved
	la	$a0, list1
	li	$a1, 120
	jal	memcpy
	addi	$a1, $v0, 0
	li	$a0, 14
	li	$a2, 15
	li	$t9, 34
	jal	test
	
	la	$a0, list1
	li	$a1, 120
	jal	memcpy
	addi	$a1, $v0, 0
	li	$a0, 13
	li	$a2, 15
	li	$t9, 9
	jal	test
	
	la	$a0, list1
	li	$a1, 120
	jal	memcpy
	addi	$a1, $v0, 0
	li	$a0, 12
	li	$a2, 15
	li	$t9, 9
	jal	test
	
	la	$a0, list1
	li	$a1, 120
	jal	memcpy
	addi	$a1, $v0, 0
	li	$a0, 3
	li	$a2, 15
	li	$t9, 3
	jal	test
	
	la	$a0, list1
	li	$a1, 120
	jal	memcpy
	addi	$a1, $v0, 0
	li	$a0, 9
	li	$a2, 15
	li	$t9, 6
	jal	test
	
	la	$a0, test2
	li	$v0, 4
	syscall
	
	la	$a0, list2
	li	$a1, 120
	jal	memcpy
	addi	$a1, $v0, 0
	li	$a0, 0
	li	$a2, 15
	li	$t9, 1
	jal	test
	
	la	$a0, list2
	li	$a1, 120
	jal	memcpy
	addi	$a1, $v0, 0
	li	$a0, 14
	li	$a2, 15
	li	$t9, 15
	jal	test
	
	la	$a0, list2
	li	$a1, 120
	jal	memcpy
	addi	$a1, $v0, 0
	li	$a0, 10
	li	$a2, 15
	li	$t9, 11
	jal	test
	
	la	$a0, list2
	li	$a1, 120
	jal	memcpy
	addi	$a1, $v0, 0
	li	$a0, 9
	li	$a2, 15
	li	$t9, 10
	jal	test
	
	la	$a0, test3
	li	$v0, 4
	syscall
	
	la	$a0, list3
	li	$a1, 120
	jal	memcpy
	addi	$a1, $v0, 0
	li	$a0, 0
	li	$a2, 15
	li	$t9, -7
	jal	test
	
	la	$a0, list3
	li	$a1, 120
	jal	memcpy
	addi	$a1, $v0, 0
	li	$a0, 1
	li	$a2, 15
	li	$t9, -3
	jal	test
	
	la	$a0, list3
	li	$a1, 120
	jal	memcpy
	addi	$a1, $v0, 0
	li	$a0, 14
	li	$a2, 15
	li	$t9, 43
	jal	test
	
	la	$a0, list3
	li	$a1, 120
	jal	memcpy
	addi	$a1, $v0, 0
	li	$a0, 3
	li	$a2, 15
	li	$t9, 2
	jal	test
	
	la	$a0, list3
	li	$a1, 120
	jal	memcpy
	addi	$a1, $v0, 0
	li	$a0, 10
	li	$a2, 15
	li	$t9, 4
	jal	test
	
	
	j	__teardown
	


__setup:
	li	$v0, 30
	syscall
	sw	$a0, __startT
	jr	$ra

__teardown:
	li	$a0, 10
	li	$v0, 11
	syscall
	syscall
	li	$v0, 1
	lw	$a0, __total
	syscall
	li	$v0, 4
	la	$a0, __endmsg
	syscall
	li	$v0, 30
	syscall
	addi	$t0, $a0, 0
	lw	$a0, __startT
	sub	$a0, $t0, $a0
	li	$v0, 1
	syscall
	li	$v0, 4
	la	$a0, __ms
	syscall
	lw	$a0, __fails
	li	$v0, 1
	syscall
	la	$a0, __failmsg
	li	$v0, 4
	syscall
	li	$v0, 10
	syscall

#	a0 - start of memory region
#	a1 - length
#	v0 - start of copied memory region
memcpy:
	addi	$t0, $a0, 0
	addi	$t1, $a1, 0
	li	$v0, 9
	addi	$a0, $a1, 0
	syscall
	addi	$t2, $v0, 0
	add	$t4, $t0, $t1
	__copyword:
	sub	$t5, $t0, $t4
	beq	$t5, $zero, __endcopy
	bgtz	$t5, __copybytes
	lw	$t3, ($t0)
	sw	$t3, ($t2)
	addi	$t0, $t0, 4
	addi	$t2, $t2, 4
	b	__copyword
	__copybytes:
	xor	$t5, $t5, $t5
	addi	$t0, $t0, -4
	addi	$t2, $t2, -4
	__byteloop:
	beq	$t0, $t4, __endcopy
	lb	$t6, ($t0)
	sb	$t6, ($t2)
	addi	$t0, $t0, 1
	addi	$t2, $t2, 1
	b	__byteloop
	
	__endcopy:
	jr	$ra

#;	a0-a3 - args to the function to test
#;	t8 - function to test
#;	t9 - expected value
test:
	lw	$t0, __total
	addi	$t0, $t0, 1
	sw	$t0, __total
	sw	$ra, ($sp)
	addi	$sp, $sp, -4
	sw	$t9, ($sp)
	addi	$sp, $sp, -4
	sw	$t8, ($sp)
	addi	$sp, $sp, -4
	jalr	$t8
	addi	$sp, $sp, 4
	lw	$t8, ($sp)
	addi	$sp, $sp, 4
	lw	$t9, ($sp)
	addi	$t0, $v0, 0
	la	$a0, __ex
	li	$v0, 4
	syscall
	addi	$a0, $t9, 0
	li	$v0, 1
	syscall
	la	$a0, __actual
	li	$v0, 4
	syscall
	addi	$a0, $t0, 0
	li	$v0, 1
	syscall
	beq	$t0, $t9, __success
	b	__failure
__exception:
	addi	$sp, $sp, 4
	lw	$t8, ($sp)
	addi	$sp, $sp, 4
	lw	$t9, ($sp)
	j	__failure
__success:
	la	$a0, __pass
	j	__end
__failure:
	la	$a0, __fail
	lw	$t0, __fails
	addi	$t0, $t0, 1
	sw	$t0, __fails
__end:
	li	$v0, 4
	syscall
	addi	$sp, $sp, 4
	lw	$ra, ($sp)
	jr 	$ra
	
	
#;	IMPLEMENT THIS YOURSELF
#;	$a0 - value k
#;	$a1 - starting address of array
#;	$a2 - length of array
#;	$v0 - the kth smallest element
findRankK:
	jr 	$ra