Programming languages MIPS不在数组中存储值
所以我有一个程序,需要取一个给定的矩阵。(4x4) 然后它需要用3交换列1,用4交换列2,并将其存储到交换矩阵(数组)中 之后,需要将矩阵_b相乘,并将矩阵交换在一起,然后保存到结果中。 然后打印出来。 打印功能工作正常。我用原始矩阵测试了它。 swap函数在内部工作,只是不知道如何将变量保存到全局函数。 代码如下。我花了几个小时调试这个Programming languages MIPS不在数组中存储值,programming-languages,mips,Programming Languages,Mips,所以我有一个程序,需要取一个给定的矩阵。(4x4) 然后它需要用3交换列1,用4交换列2,并将其存储到交换矩阵(数组)中 之后,需要将矩阵_b相乘,并将矩阵交换在一起,然后保存到结果中。 然后打印出来。 打印功能工作正常。我用原始矩阵测试了它。 swap函数在内部工作,只是不知道如何将变量保存到全局函数。 代码如下。我花了几个小时调试这个 #############################################################################
#############################################################################
#############################################################################
## 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
来自码码码码码码码码码码码码码方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方方本35现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场现场##
#############################################################################
##作业3:这里是你的名字
#############################################################################
#############################################################################
#############################################################################
#############################################################################
##数据段
#############################################################################
#############################################################################
.数据
矩阵a:。单词1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16
矩阵b:。单词1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16
交换:。字0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
结果:。单词0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
换行符:.asciiz“\n”
选项卡:.asciiz“\t”
#############################################################################
#############################################################################
##文本段
#############################################################################
#############################################################################
.text#这是程序代码
.align 2#说明必须位于单词边界上
.globl main#main是一个全局标签
.globl矩阵交换
.globl矩阵
.globl矩阵_打印
#############################################################################
主要内容:
#############################################################################
#alloc堆栈和存储$ra
低于$sp,$sp,4
西南$ra,0($sp)
#将矩阵A、swap和N加载到arg regs中
la$a0,矩阵a
洛杉矶1美元,互换
李$a2,4
日航矩阵交换
#将A、B、C和N加载到arg regs中
la$a0,互换
la$a1,matrix_b
洛杉矶2美元,结果如何
李:3美元,4美元
jal矩阵
la$a0,结果
日航矩阵印刷
#恢复$ra,免费堆叠并返回
lw$ra,0$sp
添加$sp、$sp、4
jr$ra
##############################################################################
矩阵交换:
##############################################################################
#矩阵是否交换为特定的4x4矩阵,如赋值1。
#这是一个叶函数,无需任何堆栈分配即可完成。
#如果您使用堆栈,就可以了。
低于$s2、$a2、2#j<2
移动$s0,$0#r=0
L1:移动$s1,$0#c=0
#计算[r][c+2]地址并加载到$t3
L2:mul$t0,$a2,$s0#r*尺寸
加上$t7、$s1、2#c+2
添加$t1、$t0、$t7#(r*大小)+列
sll$t1,$t1,2#4*((r*尺寸)+2)
添加$t2、$t1、$a0#添加+4*((r*大小)+2)
lw$t3,0($t2)#A[r][c+2]的门店地址
#计算交换[r][c]地址并加载到$t4
mul$t0,$a2,$s0#r*尺寸
加上$t1、$t0、$s1#(r*size)+c
sll$t1,$t1,2#4*((r*尺寸)+2)
添加$t2、$t1、$a1#添加+4*((r*大小)+2)
lw$t4,0($t2)#掉期存储地址[r][c]
#计算[r][c]地址并加载到$t5
mul$t0,$a2,$s0#r*尺寸
加上$t1、$t0、$s1#(r*size)+c
sll$t1,$t1,2#4*((r*尺寸)+c)
添加$t2、$t1、$a0#添加+4*((r*大小)+c)
lw$t5,0($t2)#A[r][c]的门店地址
#计算交换[r][c+2]地址并加载到$t6
mul$t0,$a2,$s0#r*尺寸
加上$t7、$s1、2#c+2
加上$t1、$t0、$s1#(r*size)+col
sll$t1,$t1,2#4*((r*尺寸)+c)
添加$t2、$t1、$a1#添加+4*((r*大小)+c)
lw$t6,0($t2)#掉期存储地址[r][c+2]
#将[r][c]保存到掉期[r][c+2]
移动$t6,$t5
移动$s6,$t6
#将[r][c+2]保存到掉期[r][c]
移动$t4,$t3
移动$s4,$t4
#递增c并检查条件
附加$s1、$s1、1
bne$s1、$s2、L2
#递增r并检查条件
附加$s0,$s0,1
bne$s0、$a2、L1
jr$ra
##############################################################################
矩阵乘法:
##############################################################################
#多个矩阵交换和B的平方大小为N,并存储在结果中。
#alloc堆栈和存储注册表。
低于$sp,$sp,24
西南$ra,0($sp)
sw$a0,4($sp)
sw$a1、8($sp)
sw$s0,12($sp)
sw$s1、16($sp)
sw$s2,20($sp)
#i循环的设置
加上$s0、$0、$0
#j回路的设置
L3:添加$s1、$0、$0
#k循环的设置
L4:添加$s2、$0、$0
#计算交换[i][k]地址并加载到$t3
L5:mul$t0,$s0,$a3#i*尺寸
加上$t1、$t0、$s2#(i*尺寸)+k
sll$t1,$t1,2#4*(i*尺寸)+k
添加$t2、$a0、$t1#添加+4*(i*尺寸)+k
lw$t3,0($t2)#店铺地址交换[i][k]
#计算B[k][j]地址并加载到$t4
mul$t0、$s2、$a3#k*尺寸
加上$t1、$t0、$s1#(k*size)+j
sll$t1,$t1,2#4*(k*尺寸)+j
添加$t2、$a1、$t1#添加+4*(k*大小)+j
lw$t4,0($t2)#门店地址B[k][j]
#计算结果[i][j]地址和