BubbleSort (Código em linguagem Assembly)

Esta é uma pré-visualização de arquivo. Entre para ver o arquivo original

.data 
 Inicial: .asciiz "Bubble Sort Recursivo.\n\nInsira o numero de elementos do vetor: "
 Elemento: .asciiz "Insira o elemento do vetor: "
 Ordenado: .asciiz "\nArray ordenado: "
 Space: .asciiz " "
.text
 
 li $v0, 4	 #prepara o syscall para impressão de string
 la $a0, Inicial 
 syscall #Imprime a string Inicio
 
 li $v0, 5 #prepara o syscall para leitura de inteiro
 syscall #Recebe a dimensão do vetor em $v0
 
 move $t1, $v0 #Armazena a dimensão do vetor (n) em $t1 liberando o uso de $v0
 
 lui $s0, 0x1000 #Cria o vetor com endereço base em $s0 = 0x10000000
 ori $s0, 0x7200 #Cria o vetor com endereço base em $s0 = 0x10007200
 
 addi $s1, $0, 0 #$s1 é incializada, variável de auxilio (i) no loop for
 
for1:
 slt $t2, $s1, $t1 # $t2 = i < n ? 1 : 0 
 beq $t2, $0, done1 #Se i>=n, fim do loop
 
 
 li $v0, 4 #prepara o syscall para impressão de string
 la $a0, Elemento
 syscall #Imprime a string Elemento
 
 li $v0, 5 #prepara o syscall para leitura de inteiro
 syscall #Recebe o valor do elemento em $v0
 
 sll $t2, $s1, 2 # $t2 = 4*i (offset)
 add $t2, $t2, $s0 # $t2 = endereco de vetor[i]
 sw $v0, 0 ($t2) # endereço do vetor[i]= elemento inserido (em $v0)
 addi $s1, $s1, 1 # i++
 j for1 #loop
 
done1:
 move $a1, $t1 #passando parametro relativo a dimensão do vetor
 move $a0, $s0 #passando parametro relativo ao vetor em si
 j bubble #pula a funcao bubblesort abaixo
 
Bubblesort:
 addi $sp, $sp, -12 # Cria espaço na pilha para 3 registradores
 sw $a1,8($sp) # Salva $a1 na pilha
 
 sw $ra,0($sp) # Salva $ra na pilha
 addi $t3,$0,1 # Gera um 1 para comparação
 beq $a1,$t3,end # Compara n com 1 se for verdade vai para end
 addi $t1,$0,0 # j = 0 
loop:
 addi $t3, $0,1 # Gera -1 para comparação
 sub $t4,$a1,$t3 # Bota n-1 em $t4
 slt $t3,$t1,$t4 # if(j<n-1) se verdade $t3=1 se falso $t3=0
 beq $t3,$0,done # se $t3 = 0 saia do for
 sll $t5,$t1,2 # $t5 = j*4 (offset de bytes)
 addi $t0,$t1,1 # $t0 = j+1
 sll $t6,$t0,2 # $t6 = (j+1)*4 (offset de bytes)
 add $t5,$t5,$a0 # Endereço do vetor arr[j] em $t5
 add $t6,$t6,$a0 # Endereço do vetor arr[j+1] em $t6
 lw $t3,0($t5) # $t3 = arr[j]
 lw $t4,0($t6) # $t4 = arr[j+1]
 slt $t7,$t4,$t3 # se $t4<$t3 ou seja arr[j+1]<arr[j], $t7=1 se não $t7=0
 beq $t7,$0,else # se $t7 - 0 vá para o else:
 move $t2,$t3 # temp = arr[j]
 sw $t4,0($t5) # joga conteúdo de $t4 no endereço de posição $t5
 sw $t2,0($t6) # joga conteúdo de $t4 no endereço de posição $t6
 addi $t1,$t1,1 # j= j+1
 j loop
 
else:
 addi $t1,$t1,1 # j= j+1
 j loop
done:
 addi $a1,$a1,-1 # n = n-1
 jal Bubblesort # chamada recursiva
 lw $ra, 0($sp) # restaura $ra
 lw $a1, 8($sp) # restaura n
 addi $sp,$sp,12 # desaloca espaço de pilha
 jr $ra # return
end:
 lw $a1, 8($sp) # restaura n
 addi $sp,$sp,12 # desaloca espaço de pilha
 jr $ra # return
 
 #////////////////////////////////////////////////////////////////////////////// 
 
bubble: 
 jal Bubblesort #Chama função bubblesort 
 
 li $v0, 4 #prepara o syscall para impressão de string
 la $a0, Ordenado
 syscall #Imprime a string ordenado
 addi $s1, $0, 0 # i=0
 
for2:
 slt $t2, $s1, $t1 # $t2 = i < n ? 1 : 0 
 beq $t2, $0, done2 #Se i>=n, fim do loop
 
 #Carregando o elemento vetor[i]
 sll $t2, $s1, 2 # $t2 = 4*i (offset)
 add $t2, $t2, $s0 # $t2 = endereco de vetor[i]
 lw $t0, 0 ($t2)
 
 li $v0, 1 #prepara o syscall para impressao de inteiro
 move $a0, $t0
 syscall #Imprimindo o elemento vetor[i]
 
 li $v0, 4 #prepara o syscall para impressão de string
 la $a0, Space
 syscall #Imprime a string ordenado
 
 addi $s1, $s1, 1 # i++
 j for2 #loop
 
done2:
 li $v0, 10 #exit
 syscall #fim do algoritmo