Devlog #02: Emulador NES, emulação da CPU 6502 – parte 1

Dê uma olhada no vídeo de apoio caso queira acompanhar a implementação final, ou implemente os testes abaixo caso queira escrever comigo!

Vídeo de apoio

Testes para o barramento de memória

void test_bus_read(void)
{
    // Given the memory address '0x0600' has the value '0xA9'
    // When I call 'bus_read()' with the address '0x0600'
    // Then I should get the value '0xA9'
}

void test_bus_write(void)
{
     // Given the memory bus contains only zeroes
     // When I call 'bus_write()' with the address '0x0600' and value '0xA9'
     // Then the byte '0x0600' should contain the value '0xA9'
}

Ao fazer o teste acima passar, estamos prontes para a próxima etapa: emular a CPU!

Emulação da CPU 6502

O coração do nosso emulador é a unidade central de processamento, a CPU. Este é o componente que vai nos permitir ler programas presentes no barramento de memória e executar lógica. Na maioria dos casos, os bugs que vamos encontrar no emulador vão morar neste componente também!

Apesar de ser tão fundamental, o processador tem um funcionamento muito simples: ele fica rodando infinitamente (ou até ser encerrado) e a cada iteração (ciclo) o processador tenta identificar qual a próxima instrução que ele deveria executar a partir do barramento de memória.

Características da CPU 6502

O processador 6502 tem 3 registradores chamados de A (acumulador), X e Y – todos eles de apenas 1 byte. Além disso, ele possui um ponteiro de pilha (stack pointer) que também tem 1 byte, um registrador de status da CPU de 1 byte e um ponteiro de instrução (instruction pointer ou program counter) que possui 2 bytes.

A representação disso em uma struct C é mais ou menos a seguinte:

struct Cpu {
 uint8_t a; // acumulador
 uint8_t x;
 uint8_t y;
 uint8_t sp; // stack pointer
 uint8_t st; // status register
 uint16_t pc; // program counter
};

Note que o ponteiro de instrução possui 16 bits, ou 2 bytes, que é justamente o tamanho do nosso barramento. Portanto este é o único ponteiro que consegue armazenar o endereço completo de qualquer parte da memória do barramento.

Cada instrução do processador é descrita com apenas um byte – elas são armazenadas na memória assim. Por exemplo, a instrução LDA #$00 que significa “carregar o valor 0x00 no registrador A” fica descrita assim no barramento de memória: 0xA9 0x00.

Exatamente esta instrução LDA #$00 pode ser representada no nosso barramento de memória assim:

struct Cpu cpu = { 0 };
// aponta para o endereço 0x0600 da memória
cpu.pc = 0x0600;

uint8_t bus[0xFFFF];
bus_write(0x0600, 0xA9); // LDA
bus_write(0x0601, 0x00); // 0x00

De forma que quando a CPU rodar irá encontrar a instrução 0xA9 já que seu ponteiro de instrução (pc) aponta para o endereço 0x0600, onde existe o byte 0xA9. Esta instrução exige que o processador busque um segundo parâmetro gravado em sequência, no endereço 0x0601.

As instruções do processador – também chamadas de OpCode – podem obrigar diferentes números de parâmetros e diferentes formas de acessar a memória. Para você ter uma ideia, veja o exemplo da instrução LDA:

void test_cpu_reset(void)
{
  // Given a CPU in any state
  // When I call 'cpu_reset()'
  // Then the registers A, X and Y should be '0'
  // And the stack pointer should be '0x30'
  // And the program counter should point to '0x0600'
}

void test_cpu_tick_lda(void)
{
  // Given the program '0xA9 0xAA' in the address '0x0600'
  // And the program counter (pc) points to the address '0x0600'
  // When the cpu executes 1 OpCode
  // Then the program counter (pc) should be '0x0602'
  // And the A register should be '0xAA'
  // And the number of elapsed cycles should be '2'
}