Instruções LW e SW com Array no MIPS

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 

 

opcodersrtrdshamtfunct
6 bits5 bits5 bits5 bits5 bits6 bits
código da operaçãoregistrador fonteregistrador fonteregistrador destinodeslocamentosub código da operação

 

 

Formato Tipo I 

 

opcodersrtendereço
6 bits5 bits5 bits16 bits
código da operaçãoregistradorregistradorendereço de memória

 

 

Instruções

 

Tipo R:

InstruçãoExemplo 
ADD registrador destino, registrador fonte, registrador fonteADD $t0, $s0, $s1$t0 = $s0 + $s1
SUB registrador destino, registrador fonte, registrador fonteSUB $t1, $s3, $s4$t1 = $s3 - $s4

 

 

Tipo I:

InstruçãoExemplo 
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.

 

opcodersrtrdshamtfunct
358171
08189034
4391622  

 

Código de Máquina

 

O código de máquina para a[22] = b[1] - c ficará da seguinte forma:

 

opcodersrtrdshamtfunct
100 01101000011110000 0000 0000 0001
000 00001000100100100100000100 010
101 0110100110000‭0000 0000 0001 0110‬

 

 

10001101000011110000000000000001
00000001000100100100100000100010
1010110100110000‭0000000000010110‬

 

 

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 ]

Outros artigos da série

<< Armazenando um valor em Array no MIPSInstrução IF Simples no MIPS >>