TUTORIAL DO MARS
(MIPS Assembler and Runtime Simulator)
Autor: Pablo Pereira Pires
Revisão: Prof. Dr. Cesar Albenes Zeferino
Introdução
MARS é um montador MIPS e um simulador. Com ele você pode escrever
programas em linguagem de montagem (assembly) do MIPS e simular sua execução. O
requisito do sistema para o MARS é um Ambiente Java em Tempo de Execução, JRE,
que suporte JDK 1.1 ou posterior. Assim, é possível programar para o MIPS mesmo
sem ter um processador disponível.
1. Execute o MARS e ajuste o ambiente.
Antes de simular um programa, é bom verificar se as janelas de interesse estão
sendo apresentadas na guia “Execute”. Dê um duplo clique no ícone “MARS” para
começar a sua execução.
1.1 Selecione o menu “Settings”, as configurações devem estar conforme mostra a
figura abaixo.
1.2 Na guia “Execute” do MARS é importante visualizar:
“Text Segment”, que mostra o código em assembly e em binário,
“Data Segment”, que mostra as variáveis definidas e
1.3 No lado direito da tela, deve se observa a guia “Registers” que exibe o conteúdo dos
registradores do MIPS simulado.
2. Escrevendo seu programa em Linguagem de Montagem
Para executar um programa no MARS, você pode escrever no editor de texto
embutido da ferramenta ou em outro editor de texto como “Bloco de Notas” (notepad)
ou Wordpad. Para escrever seu programa, no menu “File”, selecione a opção “New” ou
pressione Ctrl+N. Lembre-se de manter a guia “Edit” em primeiro plano.
Qualquer dúvida sobre como montar um programa assembly para o MARS,
consulte o Help da ferramenta (selecionando a opção Help no menu “Help” ou
pressionando F1 dentro do MARS), ou então o Apêndice A do livro-texto que mostra
todo o conjunto de instruções reconhecido (leitura recomendada).
Como exemplo inicial, escreva (no editor do MARS) o programa a seguir, que
simplesmente escreve o famoso "Hello world!" na tela (Run I/O). Você pode copiar e
salvá-lo no MARS como "[Link]".
################################################################################
# PRORGRAMA EXEMPLO "HELLO WORLD"
################################################################################
# Isto é apenas um comentário.
# Tudo depois de "#" é ignorado pelo montador.
################################################################################
# SEGMENTO DE DADOS
################################################################################
.data # Informa o início do segmento de dados, onde
# declaramos todas as variáveis envolvidas.
msg:.asciiz "Hello World!" # Esta é a mensagem que vai aparecer.
# Seu endereço começa em "mensagem:"
# e é uma string terminada em zero
################################################################################
# SEGMENTO DE CÓDIGO
################################################################################
.text # Informa o início do segmento de código,
# onde fica o programa.
main: # O início do programa deve ser marcado
# com o label "main:"
addi $v0, $zero, 4 # $v0 = 4 (4 é a chamada PRINT_STRING)
# Veja na página 470 do livro-texto uma
# relação das chamadas ao S.O. disponíveis
la $a0, msg # Carrega o endereço da mensagem em $a0
# "la" é uma pseudo-instrução
syscall # Chama o S.O. que escreve no vídeo
addi $v0, $zero, 10 # $v0 = 0 (0 é a chamada EXIT)
syscall # Termina o programa
3. Execute seu programa no MARS
Para executar um programa no MARS, primeiramente, você deve abrir um
arquivo “.asm” (menu “File”, selecione a opção “Open...” ou pressionando Ctrl+O) ou
salvar o arquivo que está sendo editado (menu “File”, selecione a opção “Save as...”).
Depois de aberto o programa, execute-o pelo menu “Run”. Selecione a opção
“Assemble” ou pressione F3.
Na janela “Text Segment” da guia “Execute”, está o código do programa que foi
aberto. O programa salta para a instrução de endereço (0x00400000), que é “addi”.
Na janela “Data Segment” da guia “Excute”, estão os bytes (em hexadecimal)
que correspondem ao código ASCII da mensagem “Hello World!”.
À direita, na guia “Registers”, informações sobre os registradores do MIPS são
apresentadas. Na figura abaixo, todos os registradores têm conteúdo igual à zero, com
exceção de $sp que marca o início da pilha; $gp, que aponta para a área global e pc,
que aponta para a primeira instrução que será executada (endereço 0x00400000). Essa
instrução aparece destacada na janela “Text Segment”.
4. Entendendo as janelas do MARS
Para usuários não familiarizados com montadores as janelas do MARS podem
parecer estranhas, mas na realidade não são complexas. Veja a figura abaixo.
A janela “Text Segment” apresenta o código assembly. A primeira coluna
apresenta a opção de inserção de breakpoints no código. A coluna “Address” apresenta
o endereço de cada instrução (uma por linha). A coluna “Code” exibe o código
hexadecimal de cada instrução, que corresponde a 32 bits, seguindo o formato R, I e J.
A coluna “Basic” apresenta a instrução correspondente em assembly. Nem sempre
essa instrução, que é realmente executada, corresponde ao código escrito pelo
programador. Isso porque o montador pode substituir algumas instruções ou pseudo-
instruções por outras instruções reais. A coluna “Source” contém o número da linha lida
do arquivo e o conteúdo do arquivo propriamente dito. Esse é o código digitado pelo
programador. Note, por exemplo, que a pseudo-instrução “la” (linha 23 do arquivo) foi
substituída pelo montador pela instrução real “lui” (load upper imediate), equivalente.
A janela “Data Segment”, sempre apresenta as variáveis e outros dados
definidos na seção “.data” do programa assembly. Os valores são apresentados por
words (32 bits) em hexadecimal (0x).
A guia “MARS Messages” apresenta mensagens ao usuário do MARS, como
sucesso ao carregar um arquivo ou então o erro ocorrido ao tentar executar o arquivo
(geralmente erro de sintaxe).
A guia “Registers” mostra o conteúdo hexadecimal de todos os registradores do
processador. Veja o Capítulo 3 e o Apêndice A para conhecer esses registradores.
5. Execute o programa através do MARS
Uma vez aberto o programa assembly no MARS e entendidas suas telas, é só
simular a sua execução. O MARS permite rodar o programa até o fim (Go = F5), passo
a passo (Step = F7), definir breakpoints (coluna “Bkpt” de “Text Segment”) e várias
outras opções.
A figura abaixo mostra a tela do MARS após a execução completa do
“[Link]”.
Note que a guia “Run I/O” (entradas e saídas simuladas) apresenta a mensagem
“Hello World!” e em seguida a mensagem “-- program is finished running --”, ou seja, o
programa funcionou e terminou. Na guia “Registers” o registrador “PC” aponta para uma
possível nova instrução (endereço 0x00400018).
6. Crie você mesmo seus programas
Tendo entendido o funcionamento básico do MARS, crie você mesmo seus
próprios programas e teste-os usando essa poderosa ferramenta. Use os
conhecimentos adquiridos no Capítulo 3 do livro e também todo o conjunto de
instruções disponível (apresentado no Apêndice A) para praticar a programação de uma
máquina RISC moderna.