{"id":2665,"date":"2018-09-01T14:00:00","date_gmt":"2018-09-01T17:00:00","guid":{"rendered":"https:\/\/www.ufsm.br\/pet\/sistemas-de-informacao\/?p=2665"},"modified":"2025-09-02T13:45:25","modified_gmt":"2025-09-02T16:45:25","slug":"mars-ide-para-programacao-em-assembl","status":"publish","type":"post","link":"https:\/\/www.ufsm.br\/pet\/sistemas-de-informacao\/2018\/09\/01\/mars-ide-para-programacao-em-assembl","title":{"rendered":"MARS: IDE para programa\u00e7\u00e3o em Assembly"},"content":{"rendered":"\n
\n
\n
\n
\n
\n
\n
\n
\n
\n
\n

Nesta edi\u00e7\u00e3o do PET Reda\u00e7\u00e3o, vamos falar um pouquinho sobre programa\u00e7\u00e3o de baixo n\u00edvel. Isso quer dizer que a programa\u00e7\u00e3o \u00e9 ruim? N\u00e3o, nada disso! Programa\u00e7\u00e3o de baixo n\u00edvel se trata de usarmos uma linguagem de programa\u00e7\u00e3o que segue as caracter\u00edsticas de estrutura do computador. Para isso, utilizaremos o software MARS (MIPS Assembler and Runtime Simulator) <\/em>e a arquitetura MIPS32.<\/p>\n

MARS \u00e9 um ambiente de desenvolvimento integrado (IDE) destinado a estudos da arquitetura MIPS monociclo. Em conjunto com o software, nas disciplinas de Organiza\u00e7\u00e3o de Computadores e Arquitetura de Computadores, \u00e9 utilizado o livro do Patterson, Organiza\u00e7\u00e3o e Arquitetura de Computadores.<\/p>\n

A ferramenta MARS \u00e9 um programa desenvolvido em Java e a partir do release 4.0, cont\u00e9m 155 instru\u00e7\u00f5es b\u00e1sicas da arquitetura MIPS, aproximadamente 370 pseudo-instru\u00e7\u00f5es, 17 fun\u00e7\u00f5es syscalls <\/em>para o console e entrada e sa\u00edda de dados, outras 22 fun\u00e7\u00f5es syscalls<\/em> para outros usos como o MIDI output<\/em>, para as sa\u00eddas de m\u00eddia, gera\u00e7\u00e3o de n\u00fameros aleat\u00f3rios, entre outras tantas fun\u00e7\u00f5es que vamos ver ao longo do texto.<\/p>\n

Como podemos ver com essa breve introdu\u00e7\u00e3o, a ferramenta \u00e9 bem completa e proporciona ao usu\u00e1rio uma \u00f3tima no\u00e7\u00e3o do que acontece no processador. Ent\u00e3o, basta fazer o download do software e come\u00e7ar a programar em Assembly.<\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/section>\n

\n
\u00a0<\/div>\n
\n
\n
\n
\n
\n
\n
\n
\n
\n
\"\"<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
\n
\n
\n
\n
\n
\n
\n

Assembly \u00e9 o que, no mundo da computa\u00e7\u00e3o, chamamos de linguagem de montagem. \u00c9, basicamente, uma linguagem intermedi\u00e1ria entre as linguagens de programa\u00e7\u00e3o que n\u00f3s usu\u00e1rios usamos e o que o computador interpreta.<\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n

\n
\n
\n
\n

O compilador (GCC, por exemplo) interpreta o nosso c\u00f3digo em linguagem de alto n\u00edvel (C, C++) e gera um arquivo do programa traduzido para o assembly da arquitetura em que o programa est\u00e1 sendo rodado. N\u00f3s podemos gerar o arquivo do assembly com o GCC mandando a flag -S junto do c\u00f3digo para compilar. Nesse caso, estaremos gerando um assembly da arquitetura x86, que \u00e9 a arquitetura da maioria dos computadores de hoje em dia.<\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/section>\n

\n
\n
\n
\n
\n
\n
\n
\n
\n
\n

A imagem acima mostra exatamente o que acontece com um programa quando ele \u00e9 compilado. O compilador recebe o c\u00f3digo fonte (arquivo.c) e gera um c\u00f3digo assembly (arquivo.s) a partir dele. Depois, o Assembler vai interpretar o c\u00f3digo assembly do c\u00f3digo fonte e, com as bibliotecas, vai gerar um c\u00f3digo objeto (arquivo.o). Esse c\u00f3digo objeto \u00e9 um aglomerado de 0s e 1s referentes ao nosso programa. Depois do c\u00f3digo objeto ser montado, o Linker vai pegar todos os c\u00f3digos objetos que o programa tiver, caso tenha mais do que um, e vai montar um c\u00f3digo execut\u00e1vel (arquivo.exe). \u00c9 basicamente isso o que acontece com um programa ao ser compilado.<\/p>\n

O foco desse texto \u00e9 aprender e entender como funciona um c\u00f3digo Assembly. Por isso vamos nos basear no software MARS e na arquitetura MIPS32 para isso. O software est\u00e1 dispon\u00edvel para download no site dos desenvolvedores logo abaixo.<\/p>\n

Link para download do MARS.<\/a><\/p>\n

Assim que voc\u00ea abrir o MARS, vai se dar de cara com uma interface bem comum, at\u00e9. O software tem uma estrutura bem parecida com outras IDEs. Como a ferramenta \u00e9 feita para fins educativos da arquitetura MIPS32, a IDE tem alguns elementos bem peculiares.<\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/section>\n

\n
\u00a0<\/div>\n
\n
\n
\n
\n
\n
\n
\n
\n
\n
\"\"<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/section>\n
\n
\u00a0<\/div>\n
\n
\n
\n
\n
\n
\n
\n
\n
\n

Em nossa direita \u00e9 poss\u00edvel ver uma lista de elementos estranhos, com os cabe\u00e7alhos \u201cName\u201d, \u201cNumber\u201d e \u201cValor\u201d. Cada elemento dessa lista representa um registrador e, essa lista, est\u00e1 representando o banco de registradores do processador.<\/p>\n

Os campos \u201cName\u201d e \u201cNumber\u201d servir\u00e3o para referenciarmos os nossos registradores no nosso c\u00f3digo, j\u00e1 o campo \u201cValue\u201d, armazenar\u00e1 algum dado que quisermos colocar.<\/p>\n

Abaixo do espa\u00e7o azul h\u00e1 uma caixa em branco com o bot\u00e3o \u201cClear\u201d \u00e0 sua esquerda. Esta caixa \u00e9 o console da IDE. Nela, vamos receber respostas do programa, solicitar entrada de dados pelo console e afins.<\/p>\n

E por \u00faltimo, mas n\u00e3o menos importante, temos esse espa\u00e7o em azul que \u00e9 o editor de texto.<\/p>\n

Para criarmos um novo arquivo, basta clicarmos no primeiro \u00edcone da tabela de acesso r\u00e1pido, ou ir em \u2018File>New\u2019. Ap\u00f3s criarmos um arquivo em branco, o nosso editor vai ficar desse jeito.<\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/section>\n

\n
\u00a0<\/div>\n
\n
\n
\n
\n
\n
\n
\n
\n
\n
\"\"<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/section>\n
\n
\u00a0<\/div>\n
\n
\n
\n
\n
\n
\n
\n
\n
\n
\"\"<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
\n
\n
\n
\n
\n
\n
\n

Com um arquivo criado na IDE, podemos come\u00e7ar a escrever alguns c\u00f3digos. Para ajudarmos-nos, \u00e9 aconselh\u00e1vel usar o Help<\/em>. Apertando F1<\/strong> temos acesso a ele.<\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n

\n
\n
\n
\n

A janela de Help<\/em> \u00e9 essencial no aprendizado da ferramenta pois nele obtemos acesso a todas aquelas instru\u00e7\u00f5es as quais comentei no come\u00e7o do texto. Obtemos acesso \u00e0s syscalls<\/em>, \u00e0s diretivas, \u00e0s pseudo-instru\u00e7\u00f5es e at\u00e9 \u00e0s macros. N\u00e3o veremos tudo isso nesse texto, mas veremos uma boa parte.<\/p>\n

Ent\u00e3o, como come\u00e7amos a escrever um c\u00f3digo Assembly? Para come\u00e7armos com um c\u00f3digo assembly, temos que entender como as instru\u00e7\u00f5es funcionam.<\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/section>\n

\n
\n
\n
\n
\n
\n
\n
\n
\n
\n

Em uma instru\u00e7\u00e3o temos dois elementos principais: O mnem\u00f4nico e os operandos.<\/p>\n

O mnem\u00f4nico \u00e9 o \u201cnome\u201d da instru\u00e7\u00e3o, vamos dizer assim, e os operandos s\u00e3o os nomes ou n\u00fameros dos registradores nos quais estamos operando.<\/p>\n

Um exemplo de instru\u00e7\u00e3o \u00e9 o \u2018add\u2019. Essa instru\u00e7\u00e3o realiza uma soma de dois registradores e armazena em um terceiro registrador. A instru\u00e7\u00e3o fica assim:<\/p>\n

add $t2, $t0, $t1<\/p>\n

Nesse caso, estamos fazendo uma soma do conte\u00fado do registrador $t0 com o conte\u00fado do registrador $t1 e armazenando o resultado em $t2. O registrador que recebe o resultado \u00e9 o primeiro a ser referenciado na express\u00e3o, seguido pelos registradores que far\u00e3o a opera\u00e7\u00e3o.<\/p>\n

J\u00e1 sabemos como funciona uma instru\u00e7\u00e3o de soma, vamos coloc\u00e1-la na ferramenta e testar para ver o que vai dar.<\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/section>\n

\n
\n
\n
\n
\n
\n
\n
\n
\n
\n

Antes da minha opera\u00e7\u00e3o de soma, coloquei duas outras instru\u00e7\u00f5es para carregar valores nos registradores $t0 e $t1. Ap\u00f3s carregar esses dois valores nos meus registradores, eu posso realizar a instru\u00e7\u00e3o add e ver o que vai acontecer.<\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n

\n
\n
\n
\n
\"\"<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
\n
\n
\n
\n

Para compilar o c\u00f3digo que estamos escrevendo, primeiro \u00e9 necess\u00e1rio salvar o arquivo. Ap\u00f3s salvar o arquivo, para compilar basta apertar F3<\/strong> ou ir em \u2018Assemble>Run\u2019.<\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/section>\n

\n
\u00a0<\/div>\n
\n
\n
\n
\n
\n
\n
\n
\n
\n
\"\"<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/section>\n
\n
\u00a0<\/div>\n
\n
\n
\n
\n
\n
\n
\n
\n
\n

Ap\u00f3s compilar o programa, abre uma nova tela com esses elementos mostrados acima. Nesta tela podemos ver que temos outros dois segmentos que n\u00e3o conhec\u00edamos, os segmentos de texto e de dados. O segmento de texto cont\u00e9m todas as nossas instru\u00e7\u00f5es do nosso c\u00f3digo. Cada instru\u00e7\u00e3o ter\u00e1 um endere\u00e7o, um c\u00f3digo e para facilitar a compreens\u00e3o na ferramenta, temos o campo \u2018Source\u2019, que cont\u00e9m exatamente o que est\u00e1 marcado naquela linha. J\u00e1 o segmento de dados, representa a nossa mem\u00f3ria. Mais adiante, nesse texto, veremos instru\u00e7\u00f5es que ir\u00e3o gravar na mem\u00f3ria.<\/p>\n

Podemos ver na imagem acima que nosso segmento de texto cont\u00e9m tr\u00eas instru\u00e7\u00f5es a serem executadas. E s\u00e3o exatamente as instru\u00e7\u00f5es que colocamos no nosso editor de texto, l\u00e1 na outra tela. \u00c9 poss\u00edvel acessar aquela tela apenas clicando no bot\u00e3o \u2018Edit\u2019, bem \u00e0 esquerda , abaixo da barra de acesso r\u00e1pido.<\/p>\n

Mas e agora, como fazemos para ver o programa sendo executado? Bom, h\u00e1 duas formas de executar o programa. Podemos execut\u00e1-lo instru\u00e7\u00e3o a instru\u00e7\u00e3o ou podemos execut\u00e1-lo normal. Se apertarmos a tecla F5<\/strong> ou formos em \u2018Run>Go\u2019, veremos que o programa ir\u00e1 executar at\u00e9 o fim, sem parar, mostrando os resultados no nosso banco de registradores \u00e0 direita do segmento de dados.<\/p>\n

Os valores de $t0, $t1 e $t2 foram alterados para os valores que colocamos em $t0 e $t1, e o valor da soma em $t2.<\/p>\n

Se pressionarmos a tecla F7 <\/strong>ou acessar no menu a op\u00e7\u00e3o Run>Step, executaremos uma instru\u00e7\u00e3o de cada vez. Executar desta maneira \u00e9 muito bom para entender exatamente o que est\u00e1 acontecendo no processador. \u00c9 bastante \u00fatil, tamb\u00e9m, para debugar c\u00f3digo, pois veremos todas as instru\u00e7\u00f5es do programa sendo executadas uma por vez, conseguindo assim detectar o bug para corrigir exatamente onde nos \u00e9 conveniente.<\/p>\n

Agora voltando ao nosso c\u00f3digo, vemos que ele parece estar \u201csolto\u201d ali no editor de texto, n\u00e3o \u00e9? Pois bem, a partir de agora utilizaremos as diretivas para organizar o nosso c\u00f3digo.<\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/section>\n

\n
\u00a0<\/div>\n
\n
\n
\n
\n
\n
\n
\n
\n
\n

As diretivas servir\u00e3o para dizer ao assembler onde ele dever\u00e1 escrever aquele dado.<\/p>\n

As duas principais diretivas s\u00e3o \u2018.text\u2019 e \u2018.data\u2019, e servir\u00e3o para dizer se estamos escrevendo c\u00f3digo para o segmento de texto ou para o segmento de dados, respectivamente. Podemos consultar todas as diretivas do MIPS no Help<\/em> pressionando F1<\/strong> e indo na aba \u2018Directives<\/em>\u2019.<\/p>\n

Para entendermos melhor o que essas duas diretivas fazem, vamos olhar outro c\u00f3digo. Vejamos este c\u00f3digo de Hello World! <\/strong>em Assembly.<\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n

\n
\n
\n
\n
\"\"<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
\n
\n
\n
\n

O que h\u00e1 de novo neste c\u00f3digo? Podemos ver as diretivas, como explicado anteriormente, mas tamb\u00e9m podemos ver novos elementos. Temos a instru\u00e7\u00e3o la, que vai nos servir para armazenar o endere\u00e7o de algum elemento em um registrador espec\u00edfico. Nesse caso, estamos pegando o endere\u00e7o do r\u00f3tulo \u2018printHelloWorld\u2019. Um r\u00f3tulo \u00e9 como se fosse uma marca\u00e7\u00e3o daquele endere\u00e7o espec\u00edfico. E com essa marca\u00e7\u00e3o, podemos acessar esse endere\u00e7o por esse r\u00f3tulo.<\/p>\n

Depois, temos a primeira syscall<\/em>. Uma syscall<\/em> \u00e9 uma chamada do sistema, literalmente falando. Como ela funciona? Essa chamada do sistema tem dois registradores padr\u00e3o de argumentos. O $a0 e o $v0. Para essa syscall<\/em>, que \u00e9 de imprimir uma string no console, enviamos o endere\u00e7o da string que queremos imprimir para $a0 e o c\u00f3digo da opera\u00e7\u00e3o enviamos para $v0. Esse c\u00f3digo da opera\u00e7\u00e3o podemos consultar no Help<\/em> apertando F1<\/strong> e indo na aba Syscalls<\/em>. Ap\u00f3s enviarmos os valores para os registradores de argumento da syscall<\/em>, fazemos uma chamada com o comando syscall no nosso c\u00f3digo.<\/p>\n

Tamb\u00e9m temos uma nova diretiva, o .asciiz, que \u00e9 a diretiva respons\u00e1vel por representar os caracteres da string a seguir em ASCII com a termina\u00e7\u00e3o \u2018\\0\u2019.<\/p>\n

Fora os novos elementos do c\u00f3digo, \u00e9 vis\u00edvel que ele est\u00e1 melhor estruturado, separando o que \u00e9 do segmento de texto e o que \u00e9 do segmento de dados.<\/p>\n

Ap\u00f3s compilar o nosso c\u00f3digo, na nossa tela de execu\u00e7\u00e3o teremos algo diferente. O nosso segmento de dados n\u00e3o est\u00e1 mais vazio. Agora, cont\u00e9m nele a nossa string \u201cHello World!\u201d<\/strong>, que enviamos com a diretiva .asciiz. Podemos executar o programa pressionando o F5<\/strong> ou atrav\u00e9s do F7<\/strong> e ver como o processador faz a execu\u00e7\u00e3o de cada instru\u00e7\u00e3o.<\/p>\n

Se prestar aten\u00e7\u00e3o, veremos que no segmento de dados existem alguns valores bem grandes nos primeiros endere\u00e7os. E se clicarmos no ASCII, abaixo do segmento de dados, veremos estes valores em ASCII. Nos primeiros endere\u00e7os est\u00e3o armazenados todos os caracteres em c\u00f3digo ASCII da nossa string.<\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/section>\n

\n
\u00a0<\/div>\n
\n
\n
\n
\n
\n
\n
\n
\n
\n
\"\"<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/section>\n
\n
\u00a0<\/div>\n
\n
\n
\n
\n
\n
\n
\n
\n
\n

Ap\u00f3s o t\u00e9rmino da execu\u00e7\u00e3o teremos no nosso console a string que mandamos imprimir e tamb\u00e9m poderemos ver dois valores em nossos registradores $a0 e $v0. Em $a0 observamos o valor 0x10010000, que corresponde ao endere\u00e7o de come\u00e7o da nossa string e, em $v0, o valor 0x00000004, que corresponde ao valor 4 que colocamos nele para executar a opera\u00e7\u00e3o de imprimir string.<\/p>\n

At\u00e9 agora vimos como o software MARS funciona, como as instru\u00e7\u00f5es da arquitetura MIPS funcionam e outras fun\u00e7\u00f5es relacionadas a entrada e sa\u00edda de dados. O que veremos agora ser\u00e3o as estruturas b\u00e1sicas de um programa representado em Assembly.<\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/section>\n

\n
\u00a0<\/div>\n
\n
\n
\n
\n
\n
\n
\n
\n
\n

Estruturas sequenciais:<\/strong><\/p>\n

As estruturas sequenciais s\u00e3o representadas da mesma forma que estruturamos essas em uma linguagem do paradigma procedural. Cada instru\u00e7\u00e3o \u00e9 posicionada uma abaixo da outra. Vamos ver um exemplo de uma estrutura sequencial em Assembly.<\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n

\n
\n
\n
\n
\"\"<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
\n
\n
\n
\n

No c\u00f3digo acima, vemos que no c\u00f3digo escrito em C, estamos atribuindo valores para tais vari\u00e1veis, operando estes valores e atribuindo para outras vari\u00e1veis. Como \u00e9 poss\u00edvel ver, no assembly \u00e9 bem parecido. Nesse caso, os nossos registradores $t0, $t1, $t2, $t3, e $t4 representam as vari\u00e1veis \u2018a\u2019, \u2018b\u2019, \u2018c\u2019, \u2018d\u2019, e \u2018e\u2019, respectivamente.<\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/section>\n

\n
\u00a0<\/div>\n
\n
\n
\n
\n
\n
\n
\n
\n
\n

Estruturas condicionais:<\/strong><\/p>\n

Nas estruturas condicionais temos os \u2018if\u2019s\u2019<\/em> , \u2018elses\u2019 <\/em>e o switch<\/em>. Essas estruturas ser\u00e3o constru\u00eddas em assembly com instru\u00e7\u00f5es de desvios, chamadas de branch.<\/em> Tamb\u00e9m devemos estruturar o c\u00f3digo de forma a executar apenas os da condi\u00e7\u00e3o, entretanto, como fazer isto? Bom, h\u00e1 duas formas de fazer isso, podemos estruturar o c\u00f3digo para que verifique se a condi\u00e7\u00e3o \u00e9 satisfeita e salte para as instru\u00e7\u00f5es ou podemos estruturar o c\u00f3digo para a condi\u00e7\u00e3o que n\u00e3o \u00e9 satisfeita e fique executando na sequ\u00eancia das instru\u00e7\u00f5es.<\/p>\n

A primeira forma de fazermos uma estrutura condicional \u00e9 usando a instru\u00e7\u00e3o beq (Branch if equal)<\/em>. A instru\u00e7\u00e3o beq verifica se os registradores possuem a mesma informa\u00e7\u00e3o. Caso seja verdade, a instru\u00e7\u00e3o salta para o r\u00f3tulo relacionado a ela.<\/p>\n

Podemos ver no exemplo abaixo:<\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n

\n
\n
\n
\n
\"\"<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
\n
\n
\n
\n

A outra forma de estruturarmos um if-else <\/em>\u00e9 com a instru\u00e7\u00e3o bne (Branch if not equal)<\/em>. Essa instru\u00e7\u00e3o verifica se os registradores que est\u00e3o operando s\u00e3o diferentes, caso sejam, a instru\u00e7\u00e3o realizar\u00e1 um salto para o r\u00f3tulo relacionado.<\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/section>\n

\n
\u00a0<\/div>\n
\n
\n
\n
\n
\n
\n
\n
\n
\n

A seguir, veja o exemplo na imagem:<\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n

\n
\n
\n
\n
\"\"<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
\n
\n
\n
\n

Nos dois exemplos, vemos a instru\u00e7\u00e3o j, que \u00e9 uma instru\u00e7\u00e3o de salto incondicional. Esta instru\u00e7\u00e3o realiza um salto para o r\u00f3tulo relacionado a ela que cont\u00e9m o endere\u00e7o de salto.<\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/section>\n

\n
\u00a0<\/div>\n
\n
\n
\n
\n
\n
\n
\n
\n
\n

A estrutura\u00e7\u00e3o de um switch<\/em> na linguagem assembly usa v\u00e1rias instru\u00e7\u00f5es branch<\/em> pois essa estrutura pode ter mais de dois resultados poss\u00edveis. Vejamos um exemplo de switch com 3 casos:<\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n

\n
\n
\n
\n
\"\"<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
\n
\n
\n
\n

Como pode ser visto no exemplo, s\u00e3o v\u00e1rias instru\u00e7\u00f5es branch<\/em> em sequ\u00eancia que verificam o valor do case<\/em>. Neste caso, h\u00e1 o valor 2 no nosso switch,<\/em> que far\u00e1 com que realize o c\u00f3digo do case2<\/em>. Caso nenhum dos casos seja satisfeito, o programa realiza as instru\u00e7\u00f5es do default<\/em>, colocado logo abaixo de todos os beq<\/strong>\u2019s.<\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/section>\n

\n
\u00a0<\/div>\n
\n
\n
\n
\n
\n
\n
\n
\n
\n

Estruturas de repeti\u00e7\u00e3o:<\/strong><\/p>\n

As estruturas de repeti\u00e7\u00e3o na linguagem Assembly utilizam-se de elementos que comp\u00f5em as nossas outras estruturas. Como realizar uma opera\u00e7\u00e3o n<\/strong><\/em> vezes? Em todos os casos haver\u00e1 uma condi\u00e7\u00e3o de parada. E para verificarmos uma condi\u00e7\u00e3o, utilizamos as instru\u00e7\u00f5es branch<\/em>.<\/p>\n

\u201cA soma \u00e9 realizada 10 vezes\u2026\u201d<\/p>\n

Nesse caso, o nosso la\u00e7o ir\u00e1 iterar 10 vezes, certo? E como essa repeti\u00e7\u00e3o funciona? Ela precisa executar aqueles passos contidos dentro da estrutura do la\u00e7o e voltar para o come\u00e7o do la\u00e7o, correto?<\/p>\n

Bom, para estruturarmos essa \u201cvolta para o come\u00e7o do la\u00e7o\u201d, usamos a instru\u00e7\u00e3o j e endere\u00e7amos um r\u00f3tulo do come\u00e7o do la\u00e7o. Nos exemplos abaixo d\u00e1 pra ver as tr\u00eas estruturas de repeti\u00e7\u00e3o: do-while, while <\/strong>e for<\/strong>.<\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/section>\n

\n
\u00a0<\/div>\n
\n
\n
\n
\n
\u00a0<\/div>\n<\/div>\n<\/div>\n
\n
\n
\n
\n
\n
\n
\n
\"\"<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
\n
\n
\n
\n
\u00a0<\/div>\n
\n
\n
\n
\u00a0<\/div>\n<\/div>\n<\/div>\nDo-While<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
\n
\n
\n
\n
\"\"<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
\n
\n
\n
\n
\u00a0<\/div>\n
\n
\n
\n
\u00a0<\/div>\n<\/div>\n<\/div>\nWhile<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
\n
\n
\n
\n
\"\"<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
\n
\n
\n
\n
\u00a0<\/div>\n
\n
\n
\n
\u00a0<\/div>\n<\/div>\n<\/div>\nFor<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
\n
\n
\u00a0<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/section>\n
\n
\u00a0<\/div>\n
\n
\n
\n
\n
\n
\n
\n
\n
\n

Apesar das tr\u00eas estruturas serem bem parecidas, elas diferem no posicionamento do incremento da vari\u00e1vel controladora do la\u00e7o. Estes exemplos s\u00e3o b\u00e1sicos, apenas para situar voc\u00ea, leitor, sobre como funcionam la\u00e7os em uma linguagem de montagem.<\/p>\n

O MARS possui v\u00e1rias ferramentas que auxiliam no desenvolvimento de programas mais elaborados. Acessando o menu \u2018Tools\u2019<\/em>, podemos ver essas ferramentas. Algumas delas s\u00e3o bem interessantes como a MIPS X-Ray<\/em>, que mostra a propaga\u00e7\u00e3o da instru\u00e7\u00e3o corrente no processador. O Bitmap Display<\/em> \u00e9 um simulador de uma interface gr\u00e1fica, o interessante nessa ferramenta, implementando um programa para ser executado com essa interface, \u00e9 ver como as GPUs funcionam e ter uma ideia de como funciona uma placa de v\u00eddeo. O Keyboard and Display MMIO Simulator<\/em> simula as entradas do teclado em tempo real do programa. Estas s\u00e3o algumas das ferramentas que o software traz para o usu\u00e1rio estudar e aprender a programa\u00e7\u00e3o de n\u00edvel mais baixo.<\/p>\n

Al\u00e9m das ferramentas e de todas as funcionalidades que vimos no texto, o software tamb\u00e9m oferece as fun\u00e7\u00f5es e registradores de ponto flutuante. Acessando a aba \u2018Coproc 1\u2019<\/em>, obtemos acesso a esses registradores. E as fun\u00e7\u00f5es podem ser consultadas no menu Help<\/em>, pressionando a tecla F1<\/strong>.<\/p>\n

As fun\u00e7\u00f5es de ponto flutuante operam apenas nos registradores $f<\/em>n. Apenas as instru\u00e7\u00f5es de convers\u00e3o utilizam os dois tipos de registradores.<\/p>\n

Caso voc\u00ea tenha curiosidade de conhecer um pouco mais sobre a ferramenta, disponibilizo abaixo o link do meu GitHub, que cont\u00e9m os trabalhos que realizei na disciplina de Organiza\u00e7\u00e3o de Computadores. Nestes trabalhos eu utilizei tanto os simuladores de interface gr\u00e1fica quanto os registradores de ponto flutuante.<\/p>\n