从C到MIPS汇编对数组进行排序

如何解决从C到MIPS汇编对数组进行排序

我将C代码转换为MIPS程序集以对给定的数组进行排序，但是该代码并不是真正的排序。这是C代码：

    int partition(int v[],int a,int b) {
        int pivot,lower,upper,temp;
        pivot = v[a];
        lower = a + 1;
        upper = b;
        do {
            while (v[lower] <= pivot && lower <= upper) lower = lower + 1;
            while (v[upper] > pivot && lower <= upper) upper = upper - 1;
            if (lower <= upper) {
                temp = v[lower];
                v[lower] = v[upper];
                v[upper] = temp;
                lower = lower + 1;
                upper = upper - 1;
            }
        } while (lower <= upper);
        temp = v[upper];
        v[upper] = v[a];
        v[a] = temp;
        return upper;
   }

编辑： 这是我编写的整个MIPS代码，包括调用分区的quicksort函数，“ skriv”函数只是一个带for循环的功能，用于遍历数组并打印出数字。我的数组存储在堆栈中。运行代码时，堆栈保持不变

.data
 vek:   .word 4,5,2,1,6,7,9,10
 size:  .word 10
 NL:    .asciiz "\n"
 str:   .asciiz "nummer: "


    .text
    .globl main 

main:
    
    subu $sp,$sp,16
    la $a0,vek
    jal skriv  #goto skriv
    move $t1,$v0
    
    #move $a0,$t1
    #syscall 
    
    subu $sp,32
    la $a0,vek
    move $a1,$zero
    addi $a2,$zero,10
    jal quicksort  #goto quicksort
    
    
    
    
    addu $sp,16
    addi $v0,10  #exit
    syscall
    
    .globl partition

partition:

    subu $sp,48
    sw $ra,36($sp)
    sw $s0,32($sp)
    sw $s1,28($sp)
    sw $s2,24($sp)
    sw $s3,20($sp)
    sw $s4,16($sp)
    sw $s5,12($sp)
    sw $s6,8($sp)
    sw $s7,4($sp)
    
    move $s0,$a0  #basadresser till array
    move $s1,$a1  #spara a i s1
    move $s2,$a2  #spara b i a2
    
    sll $t0,$s1,2  #t0 = a*4
    lw $s3,vek($t0)  #s3 = vek[a] = pivot
    addi $s4,1  #lower = a + 1

    
    
do: 
    
while1:
    
    sll $t0,$s4,2  #t0 = lower * 4
    lw $s6,vek($t0)  #t1 = vek[lower]
    
    ble $s6,$s3,n1  #if (vek[low] <= pivot) goto n1
    j while2

n1:

    ble $s4,$s2,n2  #if(lower <= upper) goto n2
    j while2
n2:

    addi $s4,1  #low=low+1
    j while1

while2:

    sll $t2,2  #t2 = upper * 4
    lw $s7,vek($t2)  #t3 = vek[upper]

    bgt $s7,n3  #if (vek[upp] > pivot ) goto n3
    j if

n3:

    ble $s4,n4  #if (lower <= pper) goto n4
    j if
n4: 

    addi $s2,-1  #upp = upp - 1
    j while2
if: 

    bgt $s4,while  #if (lower <= upper) goto while
    addi $t4,0
    
    move $t4,$s6    #s6 = vek[low]
    move $s6,$s7    #s7 = vek[up]
    move $s7,$t4  
    
    sll $t5,2   #t5 = low * 4
    sw $s6,vek($t5)   #t6 = vek[low]
    
    sll $t6,2  #t7 = upp * 4
    sw $s7,vek($t6)   #t8 = vek[upp]
    
    addi $sp,1   #low = low + 1
    addi $s2,-1   #upp = upp -1
    
while:

    ble $s4,finish  #if( lower <= upper ) goto finish
    
finish:

    move $t7,$s7
    move $s7,$s3
    move $s3,$t7
    
    sll $t8,2    #t8 = a * 4
    sw $s3,vek($t8)  #t8 = vek[a]
    
    
    
    
    sll $t9,2  #t9 = upp * 4
    sw $s7,vek($t9)  #s7 = vek[upp]
    
    add $v0,$s2  #save return value for upper
    lw $ra,36($sp)
    lw $s0,32($sp)
    lw $s1,28($sp)
    lw $s2,24($sp)
    lw $s3,20($sp)
    lw $s4,16($sp)
    lw $s5,12($sp)
    lw $s6,8($sp)
    lw $s7,4($sp)
    
    
    addu $sp,48
    
    li $v0,1
    move $a0,$t8
    syscall
    
    li $v0,$s2
    syscall
    
    
    #to exit
    move $v0,$t1
    jr $ra
    
    #quicksort

quicksort:

    subu $sp,32
    
    
    sw $ra,28($sp)
    sw $s1,12($sp)
    sw $s2,8($sp)
    sw $a0,24($sp)
    sw $a1,20($sp)
    sw $a2,16($sp)
    lw $s1,20($sp)
    lw $s2,16($sp)
    
    
    bge $s1,q1
    
    lw $a0,24($sp)  #a0 = v
    lw $a1,20($sp)  #a1 = a
    lw $a2,16($sp)  #s2 = b
    
    jal partition
    move $s0,$v0  
    lw $a0,20($sp)  #a1 = 0
    subu $a2,$s0,1 #a2 = k - 1
    
    jal quicksort
    lw $a0,24($sp)  #a0 = v
    addu $a1,1  #a1 = k + 1
    
    lw $a2,16($sp)  #a2 = b
    jal quicksort
    
    
 q1:

    lw $ra,28($sp)
    lw $s1,12($sp)
    lw $s2,8($sp)
    lw $a0,24($sp)
    lw $a1,20($sp)
    lw $a2,16($sp)
    
    
    lw $ra,28($sp)
    addu $sp,32  #delete the stack 
     
    jr $ra