Lab 8: (nasm) Assembly

Ao final desse lab você deve ser capaz de:

1. Usar o simulador gráfico
2. Fazer pequenas modificações em um código assembly
3. Depurar a execução do assembly

Simulador

Nosso código assembly pode ser executado em hardware de verdade (FPGA) porém nesse primeiro momento iremos trabalhar em um ambiente simulado que nos dará maior facilidade de programação e depuração.

Um pouco de contexto: O livro texto (The Elements Of Computer System) disponibiliza um simulador da CPU original todo escrito em java, esse código é fechado e não permite nenhuma customização. Em 2017 o Prof. Luciano Pereira iniciou a criação de um simulador Z0 (versão anterior) também em Java, onde teríamos controle total do software.

Percebemos alguns pontos negativos de utilizar um simulador em Java sendo o principal: Qualquer alteração no Hardware iria demandar uma alteração no simulador, sendo necessário mantermos dois projetos independentes e sincronizados.

Nesta versão do curso iremos utilizar um simulador que utiliza uma implementacão em MyHDL como descrição da CPU (e de tudo envolvido), uma alteração no hardware irá automaticamente alterar o simulador e o comportamento do computador.

O simulador possui como entradas (para cada simulação): a arquitetura do computador (hardware); o conteúdo da memória RAM o conteúdo da memória ROM e um tempo de execução.

Após o término da simulação é exportado diversos sinais internos da CPU, o estado final da memória RAM e ROM. Esses sinais são então lidos pela interface gráfica e exibida de uma forma amigável, ou usados nos testes.

Testando

Temos um pytest para testar a execucao do programa, para executar pasta usar o mesmo padrão dos anteriores:

pytest -s -k MODULO

Esse script:

1. Inicializa a memória RAM com valores pré estabelecidos
2. Converte o nasm para hack e inicializa a memória ROM
3. Executa o Hardware por um tempo
4. Compara a memória RAM após a simulação com um padrão de testes.

Exemplo de teste:

def test_exe1():
    ram = {0: 0}
    tst = {10: 5}
    assert nasm_test("exe1.nasm", ram, tst)

Onde:

• ram: É a memória RAM inicial da aplicação
• tst: É o teste que será executado na memória RAM ao final do processamento

leaw $5, %A
movw %A, %D
leaw $10, %A
movw %D, %A

pytest -s -k exe1

Entendendo o problema

O código anterior falha, e agora precisamos entender o que está acontecendo com ele, para isso vamos depurar a execução do código assembly, para isso utilize o comando a seguir:

bits debug nasm exe1

Note que toda teste gera um arquivo com extensão .lst, este arquivo possui a execucao passo a passo do código na nossa CPU.

Você deve obter algo assim:

┏━━━━━━━━┳━━━━━━━━━━━━━━┳━━━━┳━━━━┳━━━━━┓
┃ pcount ┃ OP           ┃ %A ┃ %D ┃ RAM ┃
┡━━━━━━━━╇━━━━━━━━━━━━━━╇━━━━╇━━━━╇━━━━━┩
│ 1      │ leaw $5, %A  │ 0  │ 0  │     │
│ 2      │ movw %A, %D  │ 5  │ 0  │     │
│ 3      │ leaw $10, %A │ 5  │ 5  │     │
│ 4      │ movw %D, %A  │ 10 │ 5  │     │
└────────┴──────────────┴────┴────┴─────┘
RAM FINAL (APENAS ENDERECOS ALTERADOS)
┏━━━━━━━━━┳━━━━━━━┓
┃ Address ┃ Value ┃
┡━━━━━━━━━╇━━━━━━━┩
└─────────┴───────┘

- movw %D, %A
+ movw %D, (%A)

💰 Praticando

Vamos praticar um pouco agora programar em assembly, no começo parece bem difícil, mas com a prática as coisas vão ficando mais fáceis.

Vamos implementar alguns códigos assembly, a descrição do que eles devem fazer estão no próprio arquivo .nasm.