所以我有一个程序需要使用给定的 matrix_a。（4x4）然后它需要将第 1 列与 3 和第 2 列与 4 交换并将其存储到交换矩阵（数组）中，然后需要将 matrix_b 和交换矩阵相乘并保存到结果中。然后打印出来。打印功能有效。我用原始矩阵对其进行了测试。交换函数在内部工作，只是不知道如何将变量保存到全局函数。代码如下。我花了几个小时调试这个。
#############################################################################
#############################################################################
## Assignment 3: Your Name here
#############################################################################
#############################################################################
#############################################################################
#############################################################################
## Data segment
#############################################################################
#############################################################################
.data
matrix_a: .word 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16
matrix_b: .word 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16
swap: .word 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
result: .word 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
newline: .asciiz "\n"
tab: .asciiz "\t"
#############################################################################
#############################################################################
## Text segment
#############################################################################
#############################################################################
.text # this is program code
.align 2 # instructions must be on word boundaries
.globl main # main is a global label
.globl matrix_swap
.globl matrix_multiply
.globl matrix_print
#############################################################################
main:
#############################################################################
# alloc stack and store $ra
sub $sp, $sp, 4
sw $ra, 0($sp)
# load matrix A, swap and N into arg regs
la $a0, matrix_a
la $a1, swap
li $a2, 4
jal matrix_swap
# load A, B and C and N into arg regs
la $a0, swap
la $a1, matrix_b
la $a2, result
li $a3, 4
jal matrix_multiply
la $a0, result
jal matrix_print
# restore $ra, free stack and return
lw $ra, 0($sp)
add $sp, $sp, 4
jr $ra
##############################################################################
matrix_swap:
##############################################################################
# does matrix swap for a specific 4x4 matrix like assignment 1.
# This is a leaf function and can be done without any stack allocation.
# It is ok if you use the stack.
sub $s2, $a2, 2 #j < 2
move $s0, $zero #r = 0
L1: move $s1, $zero #c = 0
#compute A[r][c+2] address and load into $t3
L2: mul $t0, $a2, $s0 #r * size
add $t7, $s1, 2 #c+2
add $t1, $t0, $t7 #(r * size) + col
sll $t1, $t1, 2 #4 * ((r* size) + 2)
add $t2, $t1, $a0 #addr + 4 * ((r* size) + 2)
lw $t3, 0($t2) #store address of A[r][c+2]
#compute swap[r][c] address and load into $t4
mul $t0, $a2, $s0 #r * size
add $t1, $t0, $s1 #(r * size) + c
sll $t1, $t1, 2 #4 * ((r* size) + 2)
add $t2, $t1, $a1 #addr + 4 * ((r* size) + 2)
lw $t4, 0($t2) #store address of swap[r][c]
#compute A[r][c] address and load into $t5
mul $t0, $a2, $s0 #r * size
add $t1, $t0, $s1 #(r * size) + c
sll $t1, $t1, 2 #4 * ((r * size) + c)
add $t2, $t1, $a0 #addr + 4 * ((r * size) + c)
lw $t5, 0($t2) #store address of A[r][c]
#compute swap[r][c+2] address and load into $t6
mul $t0, $a2, $s0 #r * size
add $t7, $s1, 2 #c + 2
add $t1, $t0, $s1 #(r * size) + col
sll $t1, $t1, 2 #4 * ((r * size) + c)
add $t2, $t1, $a1 #addr + 4 * ((r * size) + c)
lw $t6, 0($t2) #store address of swap[r][c+2]
#save A[r][c] into swap[r][C+2]
move $t6, $t5
move $s6, $t6
#save A[r][c+2] into swap[r][c]
move $t4, $t3
move $s4, $t4
#increment c and check conditional
addi $s1, $s1, 1
bne $s1, $s2, L2
#increment r and check conditional
addi $s0, $s0, 1
bne $s0, $a2, L1
jr $ra
##############################################################################
matrix_multiply:
##############################################################################
# mult matrices swap and B together of square size N and store in result.
# alloc stack and store regs.
sub $sp, $sp, 24
sw $ra, 0($sp)
sw $a0, 4($sp)
sw $a1, 8($sp)
sw $s0, 12($sp)
sw $s1, 16($sp)
sw $s2, 20($sp)
#setup for i loop
add $s0, $zero, $zero
#setup for j loop
L3: add $s1, $zero, $zero
#setup for k loop
L4: add $s2, $zero, $zero
#compute swap[i][k] address and load into $t3
L5: mul $t0, $s0, $a3 #i * size
add $t1, $t0, $s2 #(i * size) + k
sll $t1, $t1, 2 #4 * (i * size) + k
add $t2, $a0, $t1 #addr + 4 * (i * size) + k
lw $t3, 0($t2) #store address swap[i][k]
#compute B[k][j] address and load into $t4
mul $t0, $s2, $a3 #k * size
add $t1, $t0, $s1 #(k * size) + j
sll $t1, $t1, 2 #4 * (k * size) + j
add $t2, $a1, $t1 #addr + 4 * (k * size) + j
lw $t4, 0($t2) #store address B[k][j]
#compute result[i][j] address and load into $t5
mul $t0, $s0, $a3
add $t1, $t0, $s1
sll $t1, $t1, 2
add $t2, $a1, $t1
lw $t5, 0($t2)
#invoke mul instruction
mul $t6, $t3, $t4
move $t5, $t6
#increment k and jump back
addi $s2, $s2, 1
bne $s2, $a3, L5
#increment j and jump back
addi $s1, $s1, 1
bne $s1, $a3, L4
#increment i and jump back
addi $s0, $s0, 1
bne $s0, $a3, L3
# retore saved regs from stack
lw $s2, 20($sp)
lw $s1, 16($sp)
lw $s0, 12($sp)
lw $a1, 8($sp)
lw $a0, 4($sp)
lw $ra, 0($sp)
# free stack and return
add $sp, $sp, 24
jr $ra
##############################################################################
matrix_print:
##############################################################################
# alloc stack and store regs.
sub $sp, $sp, 16
sw $ra, 0($sp)
sw $s0, 4($sp)
sw $s1, 8($sp)
sw $a0, 12($sp)
li $t0, 4 # size of array
move $s2, $a0
# do you two loop here
move $s0, $zero #r = 0
Loop1: move $s1, $zero #c = 0
Loop2: mul $t1, $s0, $t0 #r * size
add $t2, $t1, $s1 #(r * size) + col
sll $t2, $t2, 2 # 4 * ((r*size) +)
add $t3, $s2, $t2 #addr + 4 * (r * size) + col
lw $t4, 0($t3) #store address of A[r][c]
li $v0, 1 #load print_int into $v0
move $a0, $t4 #move address to arg register
syscall
li $v0, 4
la $a0, tab
syscall
addi $s1, $s1, 1
bne $s1, $t0, Loop2
li $v0, 4
la $a0, newline
syscall
addi $s0, $s0, 1
bne $s0, $t0, Loop1
# setup to jump back and return
lw $ra, 0($sp)
lw $s0, 4($sp)
lw $s1, 8($sp)
lw $a0, 12($sp)
add $sp, $sp, 16
jr $ra