Chip-8 Book

Registers are small, named, high-speed storage locations used directly by the CPU during opcode execution.

There are two types of registers in Chip-8:

1. General Purpose Registers (V0-VF): Sixteen 8-bit registers named V0 through VF (or 0 through F in hex). These can be used freely by the programmer for data storage.

   • Example: The opcode 8XY4 performs VX += VY. If the opcode is 8124, it adds the value in V1 to the value in V2 and stores the result in V1.

2. Program Counter (PC): A 16-bit register that holds the memory address (index) of the instruction currently being executed. The PC typically increments by 2 bytes after every instruction to move to the next opcode, but certain instructions can change the PC to jump to a different part of the program.

Subroutines (functions) allow the program to jump to a specific address and later return to the original execution point. This is managed using a stack.

• Call Subroutine (2NNN): Push the current Program Counter (self.pc) onto the stack, then set self.pc to the target address nnn.
• Return from Subroutine (00EE): Pop the return address from the stack and set self.pc to that value.

// CALL NNN
(2, _, _, _) => {
    let nnn = op & 0xFFF;
    self.push(self.pc);
    self.pc = nnn;
}

// RET
(0, 0, 0xE, 0xE) => {
    let ret_addr = self.pop();
    self.pc = ret_addr;
}

The CPU is responsible for performing mathematical operations (addition, subtraction, equality checks) and control flow (jumping to different code sections, fetching/saving numbers).

Key concepts:

• Opcode: A unique number representing a specific mathematical or logical operation.
• Tick/Cycle: The process of the emulator grabbing the next opcode from the ROM and executing the corresponding operation.
• Opcode Layout: Opcodes are two bytes long. They use specific patterns to pack information. In documentation, literal hexadecimal values are represented by:
  • N: Single digit
  • NN: Two digits
  • NNN: Three digits
  • X or Y: Specifies a register index.

Chip-8 uses 'skip' instructions to provide if-else functionality. If the condition is met, the Program Counter (self.pc) is incremented by 2 to skip the next instruction.

• Skip if VX == NN (3XNN): Skip if register VX equals the constant NN.
• Skip if VX != NN (4XNN): Skip if register VX does not equal the constant NN.
• Skip if VX == VY (5XY0): Skip if register VX equals register VY.
• Skip if VX != VY (9XY0): Skip if register VX does not equal register VY.
• Skip if Key Pressed (E9E): Skip if the key indexed by VX is currently pressed.
• Skip if Key Not Pressed (E A1): Skip if the key indexed by VX is not currently pressed.

// SKIP VX == NN
(3, _, _, _) => {
    let x = digit2 as usize;
    let nn = (op & 0xFF) as u8;
    if self.v_reg[x] == nn {
        self.pc += 2;
    }
}

The FX33 instruction converts the 8-bit value in VX into its Binary-Coded Decimal (BCD) representation and stores the three resulting digits in RAM starting at the address in the I register.

Example: If VX is 0x64 (decimal 100), the bytes stored in RAM[I], RAM[I+1], and RAM[I+2] will be 1, 0, and 0 respectively.

Implementation Logic:

• Hundreds digit: (vx / 100.0).floor()
• Tens digit: ((vx / 10.0) % 10.0).floor()
• Ones digit: (vx % 10.0)

// BCD
(0xF, _, 3, 3) => {
    let x = digit2 as usize;
    let vx = self.v_reg[x] as f32;
    let hundreds = (vx / 100.0).floor() as u8;
    let tens = ((vx / 10.0) % 10.0).floor() as u8;
    let ones = (vx % 10.0) as u8;

    self.ram[self.i_reg as usize] = hundreds;
    self.ram[(self.i_reg + 1) as usize] = tens;
    self.ram[(self.i_reg + 2) as usize] = ones;
}

Chip-8 uses RAM (Random Access Memory) as a large array of numbers for the CPU to read and write.

Memory Specifications:

• RAM Size: While not strictly defined by the original hardware, emulators typically implement 4096 bytes (4 KB) of RAM.
• ROM Loading: The CPU cannot read directly from the ROM file. Instead, the entire game ROM must be copied into RAM at startup.
• Memory Offset: ROM data is not loaded at the beginning of RAM. It is offset by 512 bytes (0x200). This means the first byte of the ROM is stored at RAM address 0x200, the second at 0x201, and so on.
• ROM Size Limit: Because the ROM is loaded into RAM, Chip-8 games are effectively limited to a maximum size of 4 KB.

Chip-8 opcodes use a specific shorthand notation to describe operations. When reading the opcode table, understand the following symbols:

• Hexadecimal digits (0-9, A-F): Interpreted literally to determine the specific operation.
• X or Y: Wildcards representing the index of a register (e.g., VX or VY refers to the value stored in that specific register).
• N: A literal hexadecimal value.
• NN: A two-digit hexadecimal value.
• NNN: A three-digit hexadecimal value.

Example: The instruction 0xD123 matches the DXYN opcode pattern, where VX is V1, VY is V2, and N is 3. This instruction tells the system to draw an 8x3 sprite at coordinates (V1, V2).

Jumps change the Program Counter (self.pc) to a new address.

• Jump (1NNN): Set self.pc directly to the 12-bit address nnn extracted from the opcode.
• Jump to V0 + NNN (BNNN): Set self.pc to the sum of the value in register V0 and the 12-bit address nnn provided in the opcode.

// JMP NNN
(1, _, _, _) => {
    let nnn = op & 0xFFF;
    self.pc = nnn;
}

// JMP V0 + NNN
(0xB, _, _, _) => {
    let nnn = op & 0xFFF;
    self.pc = (self.v_reg[0] as u16) + nnn;
}

A Chip-8 ROM (Read-Only Memory) file contains the game logic and graphical assets required to run a game. It is a binary file consisting of a sequence of numbers, where every two bytes represent a single instruction called an opcode.

To inspect the raw contents of a ROM, use a hex editor. In a hex editor:

• The offset (left column) indicates the byte position from the start of the file.
• The data values (right column) are displayed in hexadecimal.
• Instructions are typically grouped in pairs because each opcode is two bytes long.