es6.s

.data
	A: .word 1 2 3 4 5 6
	B: .word 0 0 0 0 0 0
	M: .word 2
	N: .word 3

.text
.globl main

trasposta:
	add $t0, $zero, $zero	# $t0 = i=0
	add $t1, $zero, $zero	# $t1 = j=0
cicl_i:
	slt $t2, $t0, $a2		# i<M
	beq $t2, $zero, exit_tra
cicl_j:
	slt $t2, $t1, $a3		# j<N
	beq $t2, $zero, incr_i

	mult $a3, $t0
	mflo $t3				# N*i
	add $t3, $t3, $t1		# N*i+j
	sll $t3, $t3, 2			# (N*i+j)*4 = offset elemento di A
	add $t3, $t3, $a0		# &A[i][j]
	lw $t3, 0($t3)			# A[i][j]

	mult $a2, $t1
	mflo $t4				# M*j
	add $t4, $t4, $t0		# M*j+i
	sll $t4, $t4, 2			# (M*j+i)*4 = offset elemento di B
	add $t4, $t4, $a1		# &B[j][i]
	sw $t3, 0($t4)			# B[j][i]=A[i][j]

	addi $t1, $t1, 1
	j cicl_j

incr_i:
	add $t1, $zero, $zero
	addi $t0, $t0, 1
	j cicl_i
exit_tra:
	jr $ra


simmetrica:
	bne $a1, $a2, exit0		# M!=N => 0

	add $t0, $zero, $zero	# $t0 = i=0
	add $t1, $zero, $zero	# $t1 = j=0
ciclo_i:
	slt $t2, $t0, $a1		# i<M
	beq $t2, $zero, exit1
ciclo_j:
	slt $t2, $t1, $t0		# j<i
	beq $t2, $zero, inc_i

	mult $t0, $a2
	mflo $t3				# i*N
	add $t3, $t3, $t1		# i*N+j
	sll $t3, $t3, 2			# (i*N+j)*4
	add $t3, $t3, $a0		# &A[i][j]
	lw $t3, 0($t3) 			# A[i][j]

	mult $t1, $a2
	mflo $t4				# j*N
	add $t4, $t4, $t0 		# j*N+i
	sll $t4, $t4, 2			# (j*N+i)*4
	add $t4, $t4, $a0		# &A[j][i]
	lw $t4, 0($t4)			# A[j][i]

	bne $t3, $t4, exit0

	addi $t1, $t1, 1		# j++
	j ciclo_j

inc_i:
	addi $t0, $t0, 1		# i++
	add $t1, $zero, $zero	# j = 0
	j ciclo_i
exit1:
	add $v0, $zero, 1
	jr $ra
exit0:
	add $v0, $zero, $zero
	jr $ra


main:
	addi $sp, $sp, -4
	sw $ra, 0($sp)

	la $a0, A				# $a0 = &A
	lw $a1, M				# $a1 = M = righe
	lw $a2, N				# $a2 = N = colonne
	jal simmetrica			# verifico se A e' simmetrica

    bne $v0, $zero, exit_1

	la $a0, A				# $a0 = &A
	la $a1, B				# $a1 = &B
	lw $a2, M				# $a2 = M = righe di A
	lw $a3, N				# $a3 = N = colonne di A
	jal trasposta			# creo la matrice trasposta di A

	j exit
exit_1:
	add $a0, $v0, $zero
	add $v0, $zero, 1
	syscall
exit:
	lw $ra, 0($sp)
	addi $sp, $sp, 4
	jr $ra