Implementing Quick Sort Algorithm in Visual2 with armv7

23 Views Asked by At

I'm an engineering student. I have developed this recursive quick sort algorithm in Visual2 that works, but I still can't finish it because I should pop at the end of the subroutine all the registers I've stored at the start of the same one. Can anyone help me? Furthermore I should find a way to stop the subroutine early if the length of the list is <=1. You can find the code I've developed attached

          ;       INIZIO PROGRAMMA
          MOV     R0, #LIST ; Carico l'indirizzo di memoria di LEN
          STR     R0, [R13]

          MOV     R0, #LEN ; Carico l'indirizzo di memoria di LEN
          LDR     R0, [R0] ; Carico il valore dell'indirizzo di memoria
          STR     R0, [R13, #-4]!

          BL      QUICKSORT ; muovo il contenuto di PC in LR e salto a QUICKSORT
          END


          ;       SOTTOPROGRAMMA "QUICKSORT"
          ;       R0 = Registro che punta alla posizione assoluta del primo elemento della lista
          ;       R1 = Registro che indica la lunghezza della lista alla destra del pivot
          ;       R8 = Registro che indica la lunghezza della lista alla sinistra del pivot
          ;       R2 = Registro che serve per scorrere gli elementi della lista
          ;       R3 = Registro che indica la posizione relativa in cui andrà inserito il pivot una volta ordinata la lista
          ;       R4 = Registro che contiene il valore del pivot
          ;       R5 = Registro che contiene progressivamente i valori da confrontare con il pivot
          ;       R7 = Registro d'appoggio

QUICKSORT STR     R0, [R13, #-4]!
          STR     R1, [R13, #-4]!
          STR     R8, [R13, #-4]!
          STR     R2, [R13, #-4]!
          STR     R3, [R13, #-4]!
          STR     R4, [R13, #-4]!
          STR     R5, [R13, #-4]!
          STR     R7, [R13, #-4]!

          LDR     R0, [R13, #32]

          ;       Viene azzerato il contenuto dei registri che non vengono inizialmente sovrascritti
          MOV     R1, #0
          MOV     R2, #0
          MOV     R3, #0
          MOV     R8, #0

          ;       Converto la lunghezza della lista come multiplo di 4
CONV      ADD     R1, R1, #4
          SUB     R0, R0, #1
          CMP     R0, #1
          BGT     CONV

          LDR     R0, [R13, #36]

Q_SORT    STR     LR, [R13, #-4]!

          CMP     R8, R1
          BGE     SORTED

          MOV     R7, R1
LENGTH    ADD     R2, R2, #4
          SUB     R7, R7, #4
          CMP     R8, R7
          BLT     LENGTH

          ADD     R3, R2, #4

          LDR     R4, [R0, R8]

          ;       Ciclo sulla lista
CYCLESRT  LDR     R5, [R0, R2] ; Carico in R5 il valore dell'array all'indirizzo R0+[R2]

          CMP     R2, R8 ; Quando si è raggiunta la posizione del pivot si termina il ciclo e si passa in "SW_PIV"
          BLE     SW_PIV

          CMP     R5, R4 ; Se il valore contenuto in R5 > R4 salta in SWITCH
          BGT     SWITCH

          ADD     R2, R2, #-4 ; Si aggiorna lo spiazzamento
          B       CYCLESRT

          ;       Blocco in cui si effettua lo scambio di due valori
SWITCH    SUB     R3, R3, #4 ; Si aggiorna la posizione del pivot al valore precedente

          ;       Blocco in cui viene effettuato lo scambio dei due valori
          LDR     R7, [R0, R3] ; Si inserisce il valore che si trova all'indirizzo R0+[R3] in R7
          STR     R5, [R0, R3] ; Si inserisce il valore di R5 all'indirizzo R0+[R3]
          STR     R7, [R0, R2] ; Si inserisce il valore di R7 all'indirizzo R0+[R2]

          SUB     R2, R2, #4 ; Si aggiorna lo spiazzamento
          B       CYCLESRT


          ;       Blocco in cui ci si entra una volta aver ordinato tutta la lista tranne che il pivot. Viene switchato il pivot con il primo elemento
          ;       minore o uguale in modo tale che il pivot prenda la sua posizione finale all'interno dell'array.
SW_PIV    SUB     R3, R3, #4

          LDR     R7, [R0, R3]
          STR     R4, [R0, R3]
          STR     R7, [R0, R8]

          STR     R3, [R13, #-4]!
          STR     R1, [R13, #-4]!

LEFT      SUB     R1, R3, #4
          BL      Q_SORT

RIGHT     LDR     R1, [R13], #4
          LDR     R3, [R13], #4

          ADD     R2, R3, #4

          MOV     R8, R2

          BL      Q_SORT

SORTED    LDR     PC, [R13], #4


          ;       AREA DATI
LIST      DCD     4, -23, 3, 4, 12, 54
LEN       DCD     6

The correct code should finish with the final pop inside the subroutine "Quick sort" of the registers that I've used

0

There are 0 best solutions below