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 >>
Sou graduada em Engenharia de Computação pelo Centro Universitário de Votuporanga (UNIFEV) e mestre em Ciência da Computação pela Universidade Federal de são Carlos (UFSCar). Desde 2008 sou membro do comitê organizador do evento É DIA DE JAVA, que acontece em São Carlos e, fui membro do Microsoft Technical Audicente Contributor (MTAC) de 2012 à 07/2016. No período de 2012 à 06/2016 coordenei o curso de Pós Graduação Lato Sensu "Especialização em Desenvolvimento de Software para Web, na Universidade Sagrado Coração (USC). Também fui docente nos cursos de Engenharia de Computação e Ciência da Computação na USC no período de 2011 à 06/2016. De 2012 à 2016 fui Diretora Social da Associação Bauruense de Ciência e Tecnologia (ABCT). Sou integrante, autora, membro do conselho gestor, coordenadora geral e co-fundadora da comunidade #GarotasCPBr. Atualmente sou Professora Substituta no Departamento de Computação na Universidade Tecnológica Federal do Paraná (UTFPR) no Campus Cornélio Procópio. Agora também faço parte da equipe do Embarcados como autora e articulista. Áreas de Interesse: Gênero em Computação, Plataforma Java, Desenvolvimento de Software, Internet das Coisas e Sistemas Embarcados