2

所以我有一个程序需要使用给定的 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
4

0 回答 0