Oi Galera! Continuando a série sobre a Arquitetura do Conjunto de Instruções MIPS 32 bits, hoje mostrarei a vocês as instruções LW e SW em conjunto. Nos dois últimos artigos desta série eu apresentei para vocês essas instruções separadamente. Essas duas instruções têm a função de transferir dados, ou da memória para um registrador (LW), ou de um registrador para a memória (SW).
Relembrando
Formato Tipo R
| opcode | rs | rt | rd | shamt | funct |
| 6 bits | 5 bits | 5 bits | 5 bits | 5 bits | 6 bits |
| código da operação | registrador fonte | registrador fonte | registrador destino | deslocamento | sub código da operação |
Formato Tipo I
| opcode | rs | rt | endereço |
| 6 bits | 5 bits | 5 bits | 16 bits |
| código da operação | registrador | registrador | endereço de memória |
Instruções
Tipo R:
| Instrução | Exemplo | |
| ADD registrador destino, registrador fonte, registrador fonte | ADD $t0, $s0, $s1 | $t0 = $s0 + $s1 |
| SUB registrador destino, registrador fonte, registrador fonte | SUB $t1, $s3, $s4 | $t1 = $s3 – $s4 |
Tipo I:
| Instrução | Exemplo | |
| LW registrador destino, valor ( registrador fonte) | LW $t0, 20 ( $s0 ) | $t0 = memória [ 20 + $s0 ] |
| SW registrador fonte, valor ( registrador destino) | SW $t0, 20 ( $s0 ) | memória [ 20 + $s0 ] = $t0 |
Compilando instruções com LW e SW
Vamos converter a instrução a seguir:
a[22] = b[1] – c
Agora temos uma instrução diferente das que vimos até o momento. No artigo sobre LW vimos a instrução a = b + c[10], e no artigo sobre SW a instrução a[15] = b + c. Observe que na instrução de LW o array está no final e, na instrução que apresento hoje, o array está no início. A ordem em que o array é apresentado ao longo da instrução também deve ser respeitada, não se esqueça disso. A ordem de leitura da esquerda para a direita tem de ser mantida na instrução original e na instrução resultante em MIPS.
Não nos esqueçamos de que o processo de conversão envolve quatro passos:
- Linguagem de Montagem
- Linguagem de Máquina
- Representação da Linguagem de Máquina
- Código de Máquina
Bom, como fica então essa instrução em MIPS? Primeiro resolvemos b[1] – c e o resultado disso armazenamos em a[22]. Consideremos a = $s0, b = $s1 e c = $s2. O primeiro passo é carregar o valor de b[1] em um registrador temporário usando a instrução de LW (load word):
LW $t0, 1 ( $s1) # $t0 = memória [ 1 + $s1 ]
Agora vamos fazer a subtração usando um registrador temporário, $t1, para armazenar o resultado:
SUB $t1, $t0, $s2 # $t1 = $t0 – $s2
O último passo é transferir o resultado que está em $t1 para o array:
SW $t1, 22 ( $s0 ) # memória [ 22 + $s0 ] = $t1
Assim, a Linguagem de Montagem completa, para essa instrução é:
LW $t0, 1 ( $s1)
SUB $t1, $t0, $s2
SW $t1, 22 ( $s0 )
E a Linguagem de Máquina:
LW $8, 1 ( $17)
SUB $9, $8, $18
SW $9, 22 ( $16 )
Representação da Linguagem de Máquina
A representação da linguagem de máquina para a[22] = b[1] – c ficará da seguinte forma. RS e RT são os registradores fonte e RD o registrador destino, para as instruções do tipo R. Para as instruções STORE WORD, RS é o registrador fonte e RT é o registrador destino. Finalizando, para as instruções LOAD WORD, RS é o registrador destino e RT é o registrador fonte. Não se esqueça de consultar as tabelas para fazer a Representação.
| opcode | rs | rt | rd | shamt | funct |
| 35 | 8 | 17 | 1 | ||
| 0 | 8 | 18 | 9 | 0 | 34 |
| 43 | 9 | 16 | 22 |
Código de Máquina
O código de máquina para a[22] = b[1] – c ficará da seguinte forma:
| opcode | rs | rt | rd | shamt | funct |
| 100 011 | 01000 | 01111 | 0000 0000 0000 0001 | ||
| 000 000 | 01000 | 10010 | 01001 | 00000 | 100 010 |
| 101 011 | 01001 | 10000 | 0000 0000 0001 0110 |
10001101000011110000000000000001
00000001000100100100100000100010
10101101001100000000000000010110
Conclusão
Hoje aprendemos a compilar mais um tipo de instrução. No próximo artigo veremos mais uma instrução do MIPS, um pouco mais complexa, porém muito útil para desvios condicionais.
Exercícios
Converta as seguintes instruções considerando a = $s0, b = $s1, c = $s2, d = $s4. Tente reutilizar os registradores temporários.
a) a [ 34 ] = b [ 3 ] + c – d
b) a [ 45 ] = b – c + d [ 67 ]
c) a [ 79 ] = b – c [18 ] + d
d) a [ 82 ] = b [ 2 ] – c [ 4 ]










Onde fica os gabaritos? kkk…queria saber se eu acertei. a) a [ 34 ] = b [ 3 ] + c – d lw $t0, 3($s1) add $t1, $t0,$s2 sub $t0, $t1, $s4 sw $t0, 34($s0) b) a [ 45 ] = b – c + d [ 67 ] lw $t0, 67($s4) sub $t1, $s1, $s2 add $t2, $t1, $t0 sw $t0, 45($s0) c) a [ 79 ] = b – c [18 ] + d lw $t0, 18($s2) sub $t1, $s1, $t0 add $t0, $t1, $s4 sw $t0, 79($s0) d) a [ 82 ] = b [ 2… Leia mais »
Olá, ainda não tem artigo mostrando as soluções! Estou trabalhando nisto. Grata
Muito, muito bom !
Não me dou bem em estudar sem ser por video aula, mas estou me saindo muito bem com esse material.
Muito Obrigado,
Oie!!!!! Que bom, fico muito feliz =) Estou preparando um curso desse em vídeo aulas, assim que estiver pronto aviso a todos! Até lá, aproveite o conteúdo por aqui e fique a vontade para tirar dúvidas. Bons estudos
Ótimo artigo Elaine, estou com uma duvida quando o índice do array é uma variável por exemplo A[i], encontrei esse trecho de código na internet para a expressão:
g = h + A[i];
onde i é associado a $s4, g a $s1, h a $s2 e o endereço base de A a $s3.
Mas confesso que não entendi porque funciona assim.
Obrigado desde já.
add $t1,$s4,$s4
add $t1,$t1,$t1
add $t1,$t1,$s3
lw $t0,0($t1)
add $s1,$s2,$t0
Oi Neto!!! Sua pergunta é muito boa mesmo! Pra falar a verdade, eu acabei me esquecendo de falar sobre isso nos artigos, completamente (ahahah, desculpem leitores, my bad!). Que bom que você perguntou, vou escrever já um artigo que esclarece essa questão. Porém vou te explicar mais ou menos por aqui! i é um índice que contem um valor o qual não sabemos qual é, mas com certeza sabemos como é feito o cálculo do seu endereço. Quanto a isto, você deve consultar o artigo que escrevi sobre SLT, lá eu explico sobre o cálculo correto de endereços no MIPS.… Leia mais »