gistfile1.txt

Olá, professora

Segue a resolução do trabalho:

2) a) Ordena o vetor em v

b) É voltar para aonde o procedimento foi chamado, para poder dar continuidade ao programa neste local

3)

.data 0x10000000

.globl v

v:
    .word 2,5,3,7,1,9,4,6,10,8 # Array com dados

.text # Diz que é a seção de código do arquivo
.globl main # Aponta para o início do programa

main:
    subu $sp, $sp, 4 # Subtrai 4 do endereço da pilha
    sw $ra, 0($sp)   # Guarda o Return Address no começo da pilha
    la $a0, v        # carrega o endereço base do array no $a0 (argument 0) ( Array para se ordenar )
    li $a1, 10       # Carrega o valor imediato 10 no $a1 (argument 1), ( quantidade de itens do vetor, para ordenação )
    jal srt          # Pula para o label srt e guarda o return address daqui em $ra ( chamada da função str )
    lw $ra, 0($sp)   # Retira um valor da pilha (pop) e o usa como sendo um valor de Return adress
    addi $sp, $sp, 4 # Adiciona 4 ao $sp para diminuir o espaço da pilha
    jr $ra           # Pula para aonde o $ra aponta, o fim do programa

tro:
    sll $t0, $a1, 2   # Avança 1 posição no array e guarda o valor em $t0
    add $t1, $a0, $t0 # adiciona o offset calculado em $t0 ao endereço do vetor, para retornar a posição com o índice
    lw $t2, 0($t1)    # guarda o valor na posicão de $t1[i] em $t2
    lw $t3, 4($t1)    # guarda o valor na posição de $t1[i + 1] em $t3
    sw $t2, 4($t1)    # Invertendo, guarda o valor de $t2 em $t[i+1]
    sw $t3, 0($t1)    # Guarda o valor de $t3 em $t1[i]
    jr $ra            # Volta para aonde o método foi chamado

srt:
    subu $sp, $sp, 16 # Subtrai 16 do ponteiro da pilha para adicionar valores
    sw $ra, 12($sp)   # Salva o $ra desta função no offset 12 do $sp (1º espaço disponível na pilha)
    sw $a1, 8($sp)    # Salva o arumento 1 no offset 8 do $sp (2º espaço disponível na pilha) (Número de elementos do vetor)
    sw $s0, 4($sp)    # Salva o registrador $s0 no offset 4 de $sp (3º espaço disponível na pilha) (Posição inicial dos dados do vetor)
    sw $s1, 0($sp)    # Salva o valor de $s1 no offset 0 de $sp (4º espaço disponível na pilha)

    #corpo da rotina
    add $s0, $zero, $zero # Reseta o valor de $s0 para 0

for1:
    slt $t0, $s0, $a1      # Verifica se $s0 é menor $a1 para continuar o loop
    beq $t0, $zero, saida1 # Se $t0 for iqual a $zero, realiza a saída1, se não, continua
    addi $s1, $s0, -1      # adiciona -1 à $s0 e salva em $s1

for2:
    slt $t0, $s1, $zero    # Fator de parada o for interno
    bne $t0, $zero, saida2 # Se $t0 for $sero, vai para saída2, se não, continua a execução
    sll $t1, $s1, 2        # multiplica o valor em $s1 por 4
    add $t2, $t1, $a0      # Soma os valores $t1 e $a0 e salva-os em $t2 ( próximos valores a serem comparados pela função )
    lw $t3, 0($t2)         # Retira primeiro valor para a comparação
    lw $t4, 4($t2)         # Segundo valor para a comparação
    slt $t0, $t3, $t4      # se o primeiro valor for maior que o segundo
    beq $t0, $zero, saida2 # se $t0 for iqual a $zero, vai para saída2
    move $a1, $s1          # move o valor no registrador em $s1 para o argumento em $a1 para chamar o procedimento de troca de valores
    jal tro                # Pula para o procedimento de troca
    lw $a1, 8($sp)         # retoran com o valor anterior de $a1
    addi $s1, $s1, -1      # Decrementa o índice do for2
    j for2                 # recomeça o for2

saida2:
    addi $s0, $s0, 1 # Avança o índice do for1
    j for1           # Recomeça o loop do for1

saida1:
    lw $s1, 0($sp)    # Carrega de volta os valores guardados na pilha: valor original de $s1
    lw $s0, 4($sp)    # valor original de $s0
    lw $ra, 12($sp)   # valor do $ra original, para poder voltar onde estava no programa
    addi $sp, $sp, 16 # Retorna a posição do topo da pilha para onde estava antes dos for
    jr $ra            # Volta para o programa original