tiny8 Documentation

Tiny8 is a simplified 8-bit CPU architecture inspired by the AVR (ATmega) family, designed for educational clarity. It uses a Von Neumann architecture where program instructions and data share the same memory space.

Key Specifications:

• Word size: 8 bits
• Registers: 32 general-purpose 8-bit registers (R0-R31)
• Memory: Configurable RAM (default 2KB)
• Stack: Grows downward from high memory
• Instruction set: ~60 AVR-inspired instructions
• Status register: 8-bit SREG with condition flags

Tiny8 is an AVR-inspired 8-bit CPU simulator with the following architectural specifications:

• Registers: 32 general-purpose registers (R0-R31).
• ALU: 8-bit Arithmetic Logic Unit supporting arithmetic, logical, and bit manipulation.
• Status Register (SREG): Contains 8 condition flags.
• Memory: 2KB unified address space for memory and I/O.
• Stack: Dedicated stack pointer for stack operations.
• Instruction Set: 60+ AVR-inspired instructions.

Tiny8 follows a Fetch-Decode-Execute-Update cycle. Instructions are stored in memory as tuples.

Instruction Format (Python representation): (mnemonic, (operand1, operand2, ...))

Operand Types:

• Register: ("reg", N) where N is 0-31
• Immediate: Integer value
• Label: String referring to a program location
• Address: Memory address (integer)

Examples of instruction tuples:

("ldi", (("reg", 16), 42))      # ldi r16, 42
("add", (("reg", 16), ("reg", 17)))  # add r16, r17
("jmp", ("loop",))              # jmp loop

The CPU automatically records traces during execution, which can be used for debugging and animation:

• Register Trace: Records all register changes as (step, register, new_value).
• Memory Trace: Records all memory writes as (step, address, new_value).
• Step Trace: Records full CPU state snapshots for visualization.

When calculating sequences or managing state transitions, you often need to move values between registers. This is typically done using a temporary register to prevent overwriting data before it has been moved.

mov r19, r16        ; Temporary save
mov r16, r17        ; Shift values
mov r17, r19        ; Update with new value

A standard pattern for implementing loops in Tiny8 assembly involves initializing a counter register, performing the loop body, decrementing the counter, and using a conditional branch (brne) to jump back to the start of the loop if the counter is not zero.

ldi r18, N          ; Initialize counter
loop:
    ; ... loop body ...
    dec r18         ; Decrement counter
    brne loop       ; Branch if not equal to zero

Tiny8 is an 8-bit architecture with the following components:

CPU Components

• 32 General-Purpose Registers (R0-R31): 8-bit working registers.
• Program Counter (PC): 16-bit, addresses up to 64KB.
• Stack Pointer (SP): 16-bit, grows downward from high memory.
• Status Register (SREG): 8 condition flags (I, T, H, S, V, N, Z, C).
• 64KB Address Space: Unified memory for RAM and I/O.

Memory Map

• 0x0000 - 0x001F: Memory-mapped I/O (optional).
• 0x0020 - 0xFFFF: Available RAM (stack grows downward from the top).

Labels mark specific locations in your program and are used as targets for jumps, branches, or subroutine calls.

Rules for Labels:

• Must end with a colon (:).
• Names are case-sensitive.
• Valid characters: letters, digits, and underscores.
• Cannot start with a digit.
• Cannot be a reserved instruction mnemonic.

Usage Examples:

; Label on its own line
start:               
    ldi r16, 0

; Label before instruction
loop: dec r16        
    brne loop

; Using labels with control flow
    jmp start
    breq equal_case
    call subroutine

subroutine:
    ; ... code ...
    ret

Tiny8 provides 32 general-purpose 8-bit registers labeled R0 through R31. While all are general-purpose, certain instructions have constraints:

• LDI (Load Immediate): Only works with registers R16-R31.
• Arithmetic/Logic: Most instructions work with any register R0-R31.

Special Registers:

• Program Counter (PC): Points to the current instruction; automatically increments.
• Stack Pointer (SP): Points to the top of the stack in memory. Initialized to the end of RAM (e.g., 0x07FF for 2KB RAM). It decrements on PUSH and increments on POP.
• Status Register (SREG): An 8-bit register containing condition flags updated by arithmetic and logic operations.

To execute an assembly file (.asm) using the interactive terminal debugger, pass the filename as an argument to the tiny8 command. The debugger supports Vim-style navigation, change highlighting for registers and memory, and advanced search capabilities.

tiny8 fibonacci.asm