(5 pontos) Faça na linguagem de montagem do Mips um código para ler 96 valores inteiros do teclado e armazenar na memória de dados. Para ler um inteiro o valor em $v0 deve ser 5. Em seguida, os valores lidos que forem múltiplos de 4 devem ser atribuídos o valor -1.

Passo 1

O enunciado pede para criar um programa em assembly MIPS que:
1. Leia 96 valores inteiros do teclado (usando syscall de código 5).
2. Armazene esses 96 valores em um vetor na seção de dados.
3. Depois de lidos, percorra o vetor e, para cada elemento múltiplo de 4, substitua seu valor por -1.
Para resolver, vamos criar:
  • Na seção de dados, um espaço para 96 words.
  • Um loop de leitura que usa syscall 5 e armazena cada inteiro.
  • Um segundo loop que testa o bit menos significativo (usando andi com máscara 3) para detectar múltiplos de 4 e, se for caso, faz sw -\(1\).

Passo 2

Definimos na seção de dados um vetor de 96 inteiros inicialmente não inicializados:
        .data
vetor:  .space \(384\)      # \(96\) * \(4\) bytes \(=384\) bytes
Aqui vetor aponta ao primeiro byte do espaço destinado às 96 words.

Passo 3

Na seção de texto, fazemos o loop de leitura:
        .text
        .globl main
main:
        la   \(t\(2\), vetor    #\)t\(2\) será o ponteiro corrente de escrita
        li   $t\(3\), \(96\)       # contador de quantos ler (\(96\))
leitura:
        li   $v\(0\), \(5\)        # syscall \(5= read_int\)
        syscall
        sw   \(v\(0\), \(0\)(\)t\(2\))   # armazena inteiro lido em vetor[i]
        addiu \(t\(2\),\)t\(2\), \(4\)  # avança ponteiro para próxima posição
        addiu \(t\(3\),\)t\(3\), -\(1\) # decrementa contador
        bgtz $t\(3\), leitura  # se ainda não leu \(96\), continua

Passo 4

Agora percorremos o vetor para substituir múltiplos de 4 por -1:
        la   \(t\(2\), vetor    # reseta\)t\(2\) ao início de vetor
        li   $t\(3\), \(96\)       # contador de \(96\) posições
processa:
        lw   \(t\(4\), \(0\)(\)t\(2\))   # carrega vetor[i] em $t\(4\)
        andi \(t\(5\),\)t\(4\), \(3\)   # testa os \(2\) bits menos significativos
        bne  \(t\(5\),\)zero, prox  # se !\(=0\), não é múltiplo de \(4\)
        li   $t\(4\), -\(1\)       # carga valor -\(1\)
        sw   \(t\(4\), \(0\)(\)t\(2\))   # armazena -\(1\) em vetor[i]
prox:
        addiu \(t\(2\),\)t\(2\), \(4\)  # avança ponteiro
        addiu \(t\(3\),\)t\(3\), -\(1\) # decrementa contador
        bgtz $t\(3\), processa # repete até processar \(96\)

Passo 5

Por fim, encerramos o programa:
        li   $v\(0\), \(10\)       # syscall \(10=\) exit
        syscall

Resposta

.data
vetor: .space 384 # espaço para 96 inteiros
    .text  
    .globl main  
main:
# Loop de leitura de 96 inteiros
la $t 2, vetor
li $t 3, 96
leitura:
li $v 0, 5
syscall
sw v\(0, 0()t 2)
addiu t\(2,)t 2, 4
addiu t\(3,)t 3, - 1
bgtz $t 3, leitura
    # Loop de processamento: múltiplos de \(4\) viram -\(1\)  
    la   $t\(2\), vetor  
    li   $t\(3\), \(96\)  
processa:
lw t\(4, 0()t 2)
andi t\(5,)t 4, 3
bne t\(5,)zero, prox
li $t 4, - 1
sw t\(4, 0()t 2)
prox:
addiu t\(2,)t 2, 4
addiu t\(3,)t 3, - 1
bgtz $t 3, processa
    # Exit  
    li   $v\(0\), \(10\)  
    syscall

Exercícios relacionados