Notices by Ken Shirriff (kenshirriff@oldbytes.space)

The ancestor of the 8086 processor is the Datapoint 2200, a desktop minicomputer used as an intelligent terminal. Made before the microprocessor, the Datapoint built a processor from a board of chips. The Intel 8008 cloned the Datapoint, first step to the x86 architecture. 🧵

@b0rk
Intel processors are little-endian because they copied the Datapoint 2200, which was a serial computer so it needed to be little endian.

In more detail, the Datapoint 2200 (1971) was built with TTL chips and used shift registers for memory, so it operated on one bit at a time. This forced it to be little endian, since arithmetic needs to start with the lowest bit.

Datapoint asked Intel and Texas Instruments about replacing the board of TTL chips with a single chip. Texas Instruments built the TMX 1795 and Intel slightly later built the Intel 8008. As copies of the Datapoint 2200, they were little endian. Intel improved the 8008 creating the 8080, 8086, x86, keeping the little endian architecture and many other Datapoint features.

I can give you lots of references. See my IEEE Spectrum article https://spectrum.ieee.org/the-surprising-story-of-the-first-microprocessors
Also see the book "Datapoint: The Lost Story of the Texans who Invented the Personal Computer."

How did Russian cosmonauts know where they were? The Globus INK (1967) showed the position of their Soyuz spacecraft on a rotating globe. It is an analog computer built from tiny gears. I reverse-engineered the wiring (which inconveniently had been cut) and we powered it up. 🧵

For lots more details and a microcode walkthrough, see my latest blog post: https://www.righto.com/2023/02/8086-interrupt.html

The INTR pin triggers a complicated interrupt that runs INTA two bus cycles to acknowledge the interrupt (for historical reasons from the 8008 and 8080 processors). The interrupt bus cycle is similar to a memory read but gets an interrupt type value from the external device.

From there, external interrupts go to some logic that prioritizes the interrupts, decides when the system can handle them (usually at the end of an instruction), and signals the microcode to execute the appropriate interrupt code.

The external interrupt pins each have a circuit to clean up the interrupt signal and synchronize it to the 8086's clock. An input protection diode, inverters, and a two-stage latch. "Superbuffers" built from two transistors provide more current than regular NMOS buffers.

For a software interrupt, this INTR microcode pushes the flags and gets the interrupt handler address from the vector table. Two adds multiply the interrupt number by 4 to get the table address. The FARCALL2 and NEARCALL routines do a subroutine call to the handler.

The 8086 chip supports 256 different interrupts. Each one has an entry in a "vector table" pointing to the code that handles that interrupt. The microcode gets the right address from the vector table and does a subroutine call to that handler routine.

The interrupt circuitry is implemented both in microcode and hardware. Microcode is a layer between machine instructions and the hardware, executing low-level 21-bit micro-instructions. These perform moves, combined with several types of actions: ALU, memory, jumps, etc.

The iconic Intel 8086 processor (1978) set the path for modern computers. Like most CPUs, it supports interrupts, a mechanism to interrupt the regular flow of processing. I've been reverse-engineering it from the silicon die, and I can explain how its interrupt circuitry works.

Processor flags indicate if values are zero, negative, overflowed, and so forth. Flags are critical for loops and conditional statements. But how are they implemented? I took a close look at the silicon of the Intel 8086 processor (1978) to find out.

A closeup of the 8086's microcode ROM shows transistors (T) and empty sites (X). This region has 13 real transistors but would be counted as 18 transistor sites. The complete microcode ROM has 7694 empty sites that bump up the published count.

Looking at all the ROMs and PLAs on the 8086 die finds 9659 vacant transistor sites. This boosts the transistor count from 19,618 "real" transistors to 29,277 "potential" transistors. So the published 29,000 number is right if you count "missing" transistors too.

But there are more complications. Output pins are driven by high-current driver transistors, built from multiple transistors in parallel. Do you count that as 12 transistors or 1 transistor?

Other ROMs, such as this constant ROM, are not exactly a grid but are slightly optimized: the transistors are somewhat distorted and the grid is squished a bit to take advantage of empty space.
It's not clear if these potential transistors should be counted since there might not be room to fill in all of them. Also, some transistors act as diodes and many act as pull-up resistors.

So does the 8086 have 19,618 transistors or 29,277? It all depends on what you count.
For more, see my blog post: https://www.righto.com/2023/01/counting-transistors-in-8086-processor.html

Everyone says the Intel 8086 processor has 29,000 tiny transistors. But I counted and found 19,618. Why the difference? It turns out that most counts include "potential" transistors as well as real ones. Let's take a look and find out why.🧵

A ROM (read-only memory) typically stores 1's and 0's by the presence or absence of a transistor for each bit. So the more 1's you have, the more transistors. It's inconvenient for the transistor count to change with the data, so "transistor sites" are usually counted.
This image shows a closeup of the 8086's microcode ROM. It is arranged as a uniform grid. The regions of doped silicon form transistors (or not).

The Intel 8086 microprocessor (1978) revolutionized the computer industry and led to the popular x86 architecture. It uses microcode, breaking machine instructions down into simpler micro-instructions. By studying the chip under a microscope, I can explain it. 🧵