OpenTube

The Missing Instruction That Crippled Early CPUs

The Part That Changed the World

55,525 views

In the 1970s, most microprocessors could add and subtract—but they couldn't multiply.

This video tells the story of one of the most overlooked limitations in early computing: the missing multiply instruction. From the Intel 8080 and MOS 6502 to the rise of VisiCalc, flight simulators, and early CAD software, programmers were forced to perform multiplication through slow software routines that consumed valuable processing time.

Discover why chip designers left multiplication out of early CPUs, how William Kahan and Intel's 8087 coprocessor changed the industry, and how a feature we take for granted today helped make modern spreadsheets, 3D graphics, engineering software, and personal computing possible.

A fascinating story about engineering trade-offs, transistor budgets, and the innovation that quietly transformed computing forever.

#ComputerHistory #Intel8080 #8087 #Microprocessor #RetroComputing #TechHistory #CPU #Engineering #IEEE754 #ComputingHistory

20 Comments

@mutant0407 2 months ago (edited)

There are some very elegant multiply algorithms that work using precalculated tables of squares. This reduces the multiplication of two signed numbers to an addition, three array fetches, two subtracts and a final right shift, using AxB = ((A+B)^2-A^2 - B^2) / 2 . These are vastly quicker than traditional shift and add.
We found this algorithm in the Z80 port of the Elite space flight sim game written by Ricardo Pinto et al in 1985, which had 3d wireframe graphics.

The 8086 hardware integer multiply instruction was actually present on the core processor without an 87, but was actually slower than some of these software algorithms.

@Pihlalorjoone 2 months ago

My very first routine I wrote for the 6502 was a 16x16 bit multiplication. I loved it when I got it to work. And it was soo fast!

@MultiPetercool 1 month ago

I started on 6502. I love it because it is the ultimate learning experience for a programmer.

Compilers are great, but hand assembling instructions and poking them into RAM creates an appreciation for exactly how hardware works.

A good programmer needs to understand the limitations of the hardware.

@HotspotsSoutheast 1 month ago

I started programming in 1979 on circuit board computers. I programmed in 6502, 6809 in hexadecimal, no compiler. My favorite CPU was the MC6809 on the Color Computer. It had things none of the other CPUs had. It had two 8-bit accumulators that could be multiplied and the result was 16-bit. It had true relative branching for the entire memory range. It had optimized branching to reduce the number of bytes required to store the distance. I knew every single operation for the 6809 including the ones that were undocumented. I knew what those undocumented operations did and used them in my code. I even rewrote the disk operating system that Microsoft wrote and served a few hundred bytes, enough to add more BASIC commands.

@tcmxiyw 2 months ago

Back in the day one of my colleagues complained to me that he had installed a coprocessor (80287?) and it disappointed him that he could see no increase in performance. I suggested that he should let his compiler know that the coprocessor was available. The next day he told me that it was like I had given him a supercomputer.

@carlosanvito 1 month ago

I lived through that period and specifically added the 8087 math co-pro to the Compaq 8086 machine were were ordering to perform engineering calculations. That's how it was done then. As a coda, when that machine was sent to pasture, I removed the gold-plated 8087 and kept it as a fond memento.

@mheermance 2 months ago (edited)

This was true for most minicomputers and microprocessors into the early 80s. For example the 74LS181 ALU chip lacked a multiply operation and it was used in minicomputers of that era. Loop unrolling can make it faster if you have the RAM. The hardware multiply instruction is slower than others because there's no free lunch and multiplication is intrinsically more expensive than addition.

@christianpyn 1 month ago

This is an excellent 10 min video that drags on for 30 minutes…

@HarveyIng 1 month ago

In 1970, we designed a hardware 24-bit multiplier for a signal processor. It is housed on a 3x5 modules using then advanced MSI integrated circuits. We did not use the standard shift and add algorithm but a much faster algorithm that add partial sums. It performed a 24-bit multiply in two 5MHz cycles.

@ContagiousRepublic 1 month ago

So THAT is why DOOM used a fast multiplication trick that made lighting "good enough"!!

@markbertenshaw3977 2 months ago

This was confusing. It originally started saying that early microcomputers couldn't do integer multiplication, specifically talking about the Intel 4004. It then jumps to the 8086 (missing out the 8008) and talks about how it needed a 8087 coprocessor to support floating point multiplication. It did not mention that the important new feature of the 8086 was the integer multiplication support!

@NoOneYouKnow2025-m8c 1 month ago

My first computer, the Radio Shack Color Computer, had a hardware multiply instruction as standard equipment.

@cigmorfil4101 1 month ago

The algorithm to calculate square roots works extremely well in binary - more so than when calculating by hand in decimal.

@HCherns 1 month ago

I recall that the CDC 6400, smaller brother to the supercomputer 6600 (what later we would call RISC machines), had no integer multiply op code. But one could convert the two numbers to floating-point, do a floating-point multiply, and turn the product into a normalized integer faster than most 360s could do an integer multiply.

@slvsfr 1 month ago

My first computer was a Rockwell AIM 65, a one MHz 6502. No assembler, but a sort of neumatic entry. Calculation branches was a thing, A great vehicle for learning machine code and hardware interface.

@JodyBruchon 1 month ago

Multiplication is expensive even if you have a dedicated instruction. Claims of modern chips doing it in one cycle are false. They do out of order execution which amortizes the cost by running other instructions on other execution ports. It still takes several cycles on the multiplying execution port to finish the multiply.

@lexxynubbers 2 months ago

I did Zilog Z80 machine code for early computer games. I don't think I ever noticed the lack of multiplication because I 'simulated' laws of motion with cheats and lookups to avoid calculations.

@Pericles_Vicente 1 month ago

AMD 9511 (32 bit arithmetic precision proprietary format, with full set of math functions, but the subsequent 9512 had an "almost IEEE 754" format, 64 bit precision, but just the four basic operations), came actually first, in 1977, and Intel used their architecture as the licensed and rebranded 8231 and 8232 floating point arithmetic processors. And the 8086 could already multiply and divide integers, even without a 8087. Later (1985), Hitachi's HD6309 (an upgraded, but pin-to-pin compatible with Motorola's MC6809) could multiply up to 16X16 bit integers, and divide integers up to a 32 bit divided by a 16 bit, giving a 16 bit quotient and a 16 bit remainder, an original functionality for an 8-bit processor (MC6809 could only multiply).

@rational-being 1 month ago

In the late 1970s, I remember inheriting some flawed Fortran code which gave different results when run on an IBM 370 and another computer, purely because of how they normalised and rounded floating point number results - even addition. The IBM normalised the exponent by nibbles (4-bits) rather than bits, and truncated rather than rounded the mantissa results. The other computer rounded the mantissa (and I think normalised by single bits). Those IBM 370 truncations could be devastating to code relying on lots of additions of numbers with different exponents. I recoded the algorithm to avoid chains of additions.