#esame  21-07-2017 esercizio 1 MIPS
.data
count: .word 0
vals: .word 12, 56, 45, 78, 2, 6, 5, 8, 0, 0, 0, 0
spc2: .asciiz "  "
nl1: .asciiz "\n"
ii:  .word 0
jj:  .word 0
kk:  .word 0

.text
.globl main

#-------------------------------------------------------	
multiply:
	addi $sp,$sp,-36 # allocate frame,...
	sw  $a3,32($sp)
	sw  $a2,28($sp)
	sw  $a1,24($sp)
	sw  $a0,20($sp)
	sw  $fp,16($sp)  # save old-fp
	sw  $ra,12($sp)  # save old-ra
	sw  $s6,8($sp)   # used for 7th parm
	sw  $s5,4($sp)   # used for 6th parm
	sw  $s4,0($sp)   # used for 5th parm
	
	lw  $s4,36($sp)  # load 5th parm
	lw  $s5,40($sp)  # load 6th parm
	lw  $s6,44($sp)  # load 7th parm

    # if1	
	la  $t0,ii       # &i
	lw  $t6,0($t0)   # i
	slt $t9,$t6,$a0  # i<?m1: else1
    bne $t9,$0,else1
	j endif1
else1:
    slt $t9,$t6,$a0  # i<?m1: if not endif1
    beq $t9,$0,endif1
	
	# if2
	la  $t0,jj       # &j
	lw  $t7,0($t0)   # j
	slt $t9,$t7,$s4  # j<?n2: if not endif2
	beq $t9,$0,endif2
	
	# if3
	la  $t0,kk       # &k
	lw  $t8,0($t0)   # k
	slt $t9,$t8,$a1  # k<?n1: if not endif3
	beq $t9,$0,endif3
	
	# a[i][k] ...
	add  $t0,$t6,$t6 # 2*i
	add  $t0,$t0,$t8 # 2*i+k
	sll  $t0,$t0,2	 # 4*(2*i+k)
	add  $t0,$t0,$a2 # &a+4*(2*i+k)
	lw   $t1,0($t0)
	
	# b[k][j] ...
	add  $t0,$t8,$t8 # 2*k
	add  $t0,$t0,$t7 # 2*k+j
	sll  $t0,$t0,2	 # 4*(2*k+j)
	add  $t0,$t0,$s5 # &b+4*(2*k+j)
	lw   $t2,0($t0)
	
	# c[i][j] ...
	add  $t0,$t6,$t6 # 2*i
	add  $t0,$t0,$t7 # 2*i+j
	sll  $t0,$t0,2	 # 4*(2*i+j)
	add  $t0,$t0,$s6 # &c+4*(2*i+j)
	lw   $t3,0($t0)  # load c

	# 
	mult $t1,$t2     # a[][]*b[][]
	mflo $t1
	add  $t3,$t3,$t1 # a[][]*b[][]+c[][]
	sw   $t3,0($t0)  # store c[][]
	
	addi $t8,$t8,1   # k++
    la   $t0,kk      # &k
	sw   $t8,0($t0)  # store k
	
	addi $sp,$sp,-12 # push extra params
	sw   $s6,8($sp)
	sw   $s5,4($sp)
	sw   $s4,0($sp)
	jal multiply
	addi $sp,$sp,12
	
endif3:
    la   $t0,kk      # &k
	sw   $0,0($t0)   # k=0
	la   $t0,jj      # &j
	lw   $t1,0($t0)  # load j
	addi $t1,$t1,1   # j++
	sw   $t1,0($t0)  # store j
	
	addi $sp,$sp,-12 # push extra params
	sw   $s6,8($sp)
	sw   $s5,4($sp)
	sw   $s4,0($sp)
	jal multiply
	addi $sp,$sp,12
 	
endif2:
	la   $t0,jj      # &j
	sw   $0,0($t0)   # store j=0
	la   $t0,ii      # &i
	lw   $t1,0($t0)  # load i
	addi $t1,$t1,1   # i++
	sw   $t1,0($t0)  # store i
	
	addi $sp,$sp,-12 # push extra params
	sw   $s6,8($sp)
	sw   $s5,4($sp)
	sw   $s4,0($sp)
	jal multiply
	addi $sp,$sp,12
	
endif1:
	lw   $s4,0($sp)
	lw   $s5,4($sp)
	lw   $s6,8($sp)
	lw   $ra,12($sp)
	lw   $fp,16($sp)
	lw   $a0,20($sp)
	lw   $a1,24($sp)
	lw   $a2,28($sp)
	lw   $a3,32($fp)
	addi $sp,$sp,36
	j $ra
	
#-------------------------------------------------------	
display:
	addi $sp,$sp,-28 # allocate frame,save-s0,save-s1,a2
	sw   $a2,24($sp) # save a2
	sw   $a1,20($sp) # save a1
	sw   $a0,16($sp) # save a0
	sw   $fp,12($sp) # save old-fp
	sw   $ra,8($sp)  # save old-ra
	sw   $s1,4($sp)  # save s1
	sw   $s0,0($sp)  # save s0
	add  $fp,$sp,$0  # fp=sp
	
	addi $s0,$0,0 	 # i=0
fori1:
	slt $t9,$s0,$a0  # i<?m1: if not endfori
	beq $t9,$0,endfori1
	#----- fori1 body start
	addi $s1,$0,0 	 # j=0
forj1:
	slt $t9,$s1,$a1  # j<?n2: if not endforj
	beq $t9,$0,endforj1
	#----- forj1 body start
	sll $t2,$s0,1    # i*2
	add $t2,$t2,$s1	 # i*2+j
	sll $t2,$t2,2    # 4*(i*2+j)
	add $t2,$a2,$t2  # &c+4*(i*2+j)
	lw  $a0,0($t2)   # t3:c[i][j]
	addi $v0,$0,1	 # service-1: print_int
	syscall
	la  $a0,spc2     # pointer to the string
	addi $v0,$0,4    # service-4: print_str
	syscall
    #----- forj1 body end	

nextforj1:
    addi $s1,$s1,1   # ++j
    lw   $a1,20($sp) # restore a1
	j forj1
	
endforj1:
    #----- fori1 body end	
	addi $s0,$s0,1   # i++
	la   $a0,nl1	 # print just 1 newline
	addi $v0,$0,4    # print_str
	syscall 
    lw   $a0,16($sp) # restore a0
	j fori1
endfori1:

	addi $sp,$sp,28
	lw   $s0,0($sp)  # restore s0
	lw   $s1,4($sp)  # restore s1
	lw   $ra,8($fp)  # restore ra
	lw   $fp,12($fp) # restore fp
	j $ra
	
#-------------------------------------------------------	
main:
	addi $sp,$sp,-48 # allocate "int x[2][2], y... z..."
	add  $fp,$sp, $0 # fp=sp
	la   $t0,vals    # initialize x,y,z
	add  $t1,$fp,$0  # pointer to x[0][0]
	add  $t2,$t0,48
loop1:
	lw   $t3,0($t0)  # load val
	sw   $t3,0($t1)  # store val
	add  $t1,$t1,4   # increment pointers
	add  $t0,$t0,4   #
	bne  $t0,$t2,loop1 # for all elements
	
	addi $a0,$0,2 	 # m1
	addi $a1,$0,2	 # n1
	add  $a2,$fp,$0  # &x
	addi $a3,$0,2	 # n1
	addi $sp,$sp,-12  # allocate space for extra parms
	addi $t0,$fp,32	 # &z
	sw   $t0,8($sp)  # store 7th parm
	addi $t0,$fp,16	 # &y
	sw   $t0,4($sp)  # store 6th parm
	sw   $a3,0($sp)  # store the 5th parm
	jal multiply

	addi $sp,$sp,12  # restore stack pointer for parms
	addi $a0,$0,2    # m1
	addi $a1,$0,2    # n2
	addi $a2,$fp,32	 # &z
	jal display
	
	addi $sp,$sp,48  # deallocate "x, y, z"
	addi $v0,$0,10   # service 10: exit
	syscall