Introduction

Welcome to the SLP-8080 emulator, a faithful implementation of the Intel 8080 microprocessor for the Emulator.ca modem network. If the 8008 was the spark, the 8080 was the fire. This was the processor that turned microcomputers from engineering curiosities into a genuine industry.

The 8080 Legacy

In April 1974, Intel released the 8080---a processor that was everything the 8008 should have been, and more. Where the 8008 had a cramped 14-bit address space, the 8080 offered a full 64 kilobytes. Where the 8008 had an internal stack limited to eight levels, the 8080 had a stack pointer addressing external RAM---unlimited in depth. The clock speed more than tripled, from 0.5 MHz to 2 MHz. The instruction set was dramatically expanded, with PUSH, POP, CALL, and RET instructions that made structured programming practical.

The 8080 did not merely improve upon the 8008---it created an ecosystem:

MITS Altair 8800 (1975) - The machine that started it all, featured on the cover of Popular Electronics
IMSAI 8080 (1975) - The Altair's commercial rival, immortalised in the film WarGames
CP/M (1974) - Gary Kildall's operating system that became the standard for business computing
Microsoft - Bill Gates and Paul Allen wrote their first product, Altair BASIC, for the 8080
Cromemco, North Star, Vector Graphic - An entire industry of S-100 bus systems

The 8080's register architecture---A, B, C, D, E, H, L, flags, stack pointer, program counter---became the template for the Zilog Z80 and, through it, the Intel 8086 and the entire x86 family. The registers you see in a modern x86 processor (AX, BX, CX, DX) are direct descendants of the 8080's register pairs.

This 8080 emulator implements the complete documented instruction set with accurate flag behaviour. It provides 64KB of memory, BIOS support, UART I/O, and interrupt handling. The emulator faithfully replicates the 8080's flag register conventions, including the fixed bits at positions 1, 3, and 5.

Quick Start

Dial 555-8080 to see the Intel 8080 in action. The system loads a pre-compiled "Hello World" programme, executes it on the emulated 8080, and displays the output through the simulated UART. No interaction is required---simply connect and watch.

Getting Connected

To access the SLP-8080 system, configure your modem and dial:

ATDT555-8080

Upon successful connection, you will see the system banner followed by programme output:

CODE_FENCE_0

The demonstration loads the BIOS at address 0x0000, then loads the hello.bin test programme at 0x0100. The BIOS initialises the system and transfers control to the test programme. After displaying its message, the CPU executes a HLT instruction and the session ends.

Terminal Settings

Configure your terminal software as follows:

Terminal emulation: VT100 or ANSI
Data bits: 8
Parity: None
Stop bits: 1
Flow control: Hardware (RTS/CTS)

This service runs a pre-compiled hello world programme to demonstrate 8080 emulation. The programme executes automatically upon connection. The line disconnects after completion. For interactive 8080 programming through CP/M, see the DOS backend (555-8188).

Architecture Overview

The Intel 8080 is an 8-bit microprocessor with a 16-bit address bus, providing access to 64 kilobytes of memory. It introduced the register architecture and instruction conventions that would define the next fifty years of x86 computing.

Registers

The 8080 contains seven 8-bit general-purpose registers that can be used individually or as 16-bit pairs:

    8-bit       16-bit pair
    +---+---+
    | A | F |   AF - Accumulator and Flags (PSW)
    +---+---+
    | B | C |   BC - General purpose
    +---+---+
    | D | E |   DE - General purpose
    +---+---+
    | H | L |   HL - Memory pointer
    +---+---+

    +-------+
    |   SP  |   Stack Pointer (16-bit)
    +-------+
    |   PC  |   Program Counter (16-bit)
    +-------+

A (Accumulator): The primary register for all arithmetic and logical operations. Nearly every ALU instruction uses A as one operand.

H and L: The primary memory pointer pair. Instructions like MOV A, M use HL as an address to access memory. This convention carried forward to the Z80 and, conceptually, to x86.

B, C, D, E: General-purpose registers. BC and DE can serve as additional memory pointers for certain instructions (LDAX, STAX).

SP (Stack Pointer): Points to the top of the stack in RAM. Unlike the 8008's internal stack, the 8080's stack resides in main memory, allowing unlimited depth.

Flags

The 8080 maintains five status flags in the F register:

    Bit:  7   6   5   4   3   2   1   0
        +---+---+---+---+---+---+---+---+
        | S | Z | 0 | AC| 0 | P | 1 | C |
        +---+---+---+---+---+---+---+---+

Flag	Bit	Description
S	7	Sign - set if result bit 7 is 1
Z	6	Zero - set if result is zero
AC	4	Auxiliary Carry - carry from bit 3 to bit 4 (BCD)
P	2	Parity - set if result has even parity
C	0	Carry - set on arithmetic carry or borrow

Bits 5 and 3 are always 0; bit 1 is always 1. These fixed bits distinguish a real 8080 from clones and successors.

Memory Map

    +------------------+ 0xFFFF (65535)
    |                  |
    |       RAM        |
    |    (64 KB)       |
    |                  |
    +------------------+ 0x0100 (256)
    |     BIOS/ROM     |
    |    (256 bytes)    |
    +------------------+ 0x0000 (0)

The full 64KB address space is available. The BIOS occupies the low addresses, and user programmes load at 0x0100---the same convention used by CP/M, which places its Transient Program Area at this address.

I/O Space

The 8080 provides a separate 256-port I/O address space, accessed via the IN and OUT instructions. In this implementation, the UART peripheral occupies I/O ports for serial communication over the modem link.

Interrupts

The 8080 supports a single maskable interrupt line, enabled with EI and disabled with DI. When an interrupt occurs, the interrupting device places an RST instruction on the data bus, vectoring execution to one of eight fixed addresses (0x00, 0x08, 0x10, 0x18, 0x20, 0x28, 0x30, 0x38).

What the Demo Does

The hello world demonstration exercises several key aspects of the 8080 emulator:

BIOS Boot - Execution begins at address 0x0000 where the BIOS performs hardware initialisation, then transfers control to the programme at 0x0100.
String Output - The test programme walks through a null-terminated string in memory, outputting each character through the UART peripheral using OUT instructions.
UART Communication - Each character written to the UART travels through the modem simulation to your terminal, demonstrating the complete serial data path.
Run Cycles - The emulator uses an efficient run_cycles method that executes batches of instructions per tick, providing smooth output at the simulated clock rate.
HLT Instruction - The programme terminates with HLT, which the emulator detects and uses to cleanly close the session.

The 8080 runs roughly four times faster than the 8008 at 2 MHz, but you will observe the output at modem speed---a reminder that in 1975, serial terminals were the primary interface and 300 baud was considered perfectly adequate.

Intel 8080 CPU DEMO