SAN FRANCISCO, CA — In a deep dive that blends reverse engineering with careful documentation, Ken Shirriff walks through how the Intel 8086’s arithmetic logic unit is steered by microcode and two lookup tables—an approach that set it apart from contemporaries like the 6502 (with more fixed-function paths) and Intel’s 8085 (with reconfigurable gate blocks). His analysis shows how a single decoded instruction can fan out into microcode steps and control signals, the textbook CISC behavior that defined early x86 even as modern cores turned more RISC-like inside.
What Shirriff Examined
- Functional and die-level behavior of the 8086 ALU
- How two LUTs feed control bits to reconfigure ALU operations
- Microcode reuse across multiple instructions to reduce duplicated hardware
How the 8086 ALU Is Organized
- Microcode sequences select ALU modes and data paths.
- Two lookup tables provide fast, compact control patterns for operations.
- The result: a flexible, complex control scheme that trades simplicity for capability.
Trade-offs and Evolution
- Powerful decoding and control flow enable rich instructions but add complexity.
- As processes and tools improved, many early penalties (speed, area, design effort) softened.
- The architectural lesson endures: reuse control and datapath where you can.
Parallels to Modern FPGAs
- LUT-driven control in the 8086 rhymes with FPGA fabrics that map functions into LUTs.
- Both favor reconfigurable logic over sprawling fixed-function circuitry.
- For builders, it’s a historical blueprint for compact, configurable designs.
Why It Matters for Makers
- Retro CPU replicas: Inform your microcode and control-ROM designs.
- FPGA cores: Borrow LUT-centric control to keep logic lean and testable.
- Education: Tie instruction decoding to tangible die structures for clearer mental models.
The Editor’s Take
Shirriff’s write-up is more than retro nostalgia—it’s a practical map for anyone building small CPUs, crafting FPGA cores, or teaching control logic. Seeing how the 8086 reuses microcode with LUT-fed control is the kind of transferable pattern that reduces complexity in DIY designs and open cores alike.
Read More
Credit and Source: Hackaday
