Após a execução do programa abaixo, qual o estado do trecho de memória e dos registradores acessados?
lui $t0, 0x1001
addi \(t0,\)t0, 0x0008
addi \(t1,\)0, 0x01
sw \(t1, 0(\)t0)
addi \(t1,\)0, 0x02
sw \(t1, 4(\)t0)
addi \(t1,\)0, 0x0E
sw \(t1, 8(\)t0)
addi \(t1,\)0, 0x10
sw \(t1, 12(\)t0)
addi \(t0,\)t0, 0x0C
lw \(t2, -4(\)t0)
lw \(t3, -8(\)t0)
lw \(t4, -12(\)t0)
lui $t0, 0x1001
addi \(t0,\)t0, 0x0008
addi \(t1,\)0, 0x01
sw \(t1, 0(\)t0)
addi \(t1,\)0, 0x02
sw \(t1, 4(\)t0)
addi \(t1,\)0, 0x0E
sw \(t1, 8(\)t0)
addi \(t1,\)0, 0x10
sw \(t1, 12(\)t0)
addi \(t0,\)t0, 0x0C
lw \(t2, -4(\)t0)
lw \(t3, -8(\)t0)
lw \(t4, -12(\)t0)
| memória | valor | registrador | valor |
|---|---|---|---|
| 0x10010000 | 0x00 | $a2 | 0x00000000 |
| 0x10010004 | 0x00 | $a3 | 0x00000000 |
| 0x10010008 | 0x01 | $t0 | 0x10010014 |
| 0x1001000C | 0x02 | $t1 | 0x00000001 |
| 0x10010010 | 0x0E | $t2 | 0x00000002 |
| 0x10010014 | 0x10 | $t3 | 0x0000000E |
| 0x10010018 | 0x00 | $t4 | 0x00000010 |
| 0x1001001C | 0x00 | $t5 | 0x00000000 |
Passo 1
O enunciado dá o seguinte programa (cada linha é uma instrução MIPS):
O enunciado também apresenta o estado (tabela) com alguns conteúdos de memória e registradores antes/para comparar — as células relevantes da memória mostradas são:
e alguns registradores são mostrados (valores iniciais podem ser zeros). O que o exercício pede é: qual é o estado final do trecho de memória acessado e dos registradores usados após executar todo o programa.
e alguns registradores são mostrados (valores iniciais podem ser zeros). O que o exercício pede é: qual é o estado final do trecho de memória acessado e dos registradores usados após executar todo o programa.
Passo 2
Explicação do funcionamento das instruções que aparecem no programa (conceitos que vamos usar):
-
(load upper immediate) carrega um imediato de 16 bits para os 16 bits mais significativos do registrador, ou seja ele faz . Ex.: . -
soma um imediato (16 bits, com extensão de sinal) ao registrador destino: . Para pequenos imediatos positivos é só soma normal. -
(store word) grava uma palavra de 32 bits em memória no endereço . Em MIPS o offset é em bytes e a palavra ocupa 4 bytes; endereços devem estar alinhados a 4 para armazenamento de palavra. -
(load word) carrega uma palavra de 32 bits de memória do endereço para um registrador.
Passo 3
Executando a primeira instrução:
.
Cálculo: .
Resultado: .
Cálculo:
Resultado:
Passo 4
Segunda instrução:
.
Soma: .
Resultado: .
Soma:
Resultado:
Passo 5
Terceira instrução:
.
Aqui é o registrador zero (sempre zero), então
.
Aqui
Passo 6
Quarta instrução:
.
Endereço calculado: . Armazenamos a palavra
em memória no endereço
. Em termos de palavras, a célula em
passa a conter
.
Endereço calculado:
Comentário didático: cada store word escreve 4 bytes (uma palavra). Como os offsets usados são múltiplos de 4, não há problema de desalinhamento.
Passo 7
Quinta instrução:
.
Resultado: .
Resultado:
Passo 8
Sexta instrução:
.
Endereço: . Gravamos
em
.
Endereço:
Passo 9
Sétima instrução:
.
Imediato é decimal
. Resultado:
.
Imediato
Passo 10
Oitava instrução:
.
Endereço: . Gravamos
em
.
Endereço:
Passo 11
Nona instrução:
.
Imediato é decimal
. Resultado:
.
Imediato
Passo 12
Décima instrução:
.
Endereço: . Gravamos
em
.
Endereço:
Até aqui, os quatro stores produziram as seguintes escritas em memória (em endereços-alvo):
Passo 13
Décima primeira instrução:
.
Soma: .
Resultado: .
Soma:
Resultado:
Passo 14
Décima segunda instrução:
.
Endereço: . Carregamos a palavra que está em
, que gravamos antes como
.
Resultado: .
Endereço:
Resultado:
Passo 15
Décima terceira instrução:
.
Endereço: . Carregamos
.
Resultado: .
Endereço:
Resultado:
Passo 16
Décima quarta instrução:
.
Endereço: . Carregamos
.
Resultado: .
Endereço:
Resultado:
Passo 17
Resumo final (antes de entregar a resposta final): os stores escreveram as palavras esperadas nas quatro posições consecutivas a partir de
. Os loads leram essas palavras em ordem invertida relativa ao deslocamento negativo a partir de
. Os registradores finais relevantes são:
,
(último valor carregado em
),
,
,
. Registradores não mencionados mantêm os valores que tinham (por exemplo
permanecem
se não foram modificados).