The Intel 8087 chip: floating-point addition and subtraction

Back in the day, the 8087 and 80287 were supported by quite a bit of software (spreadsheets, statistics, etc...). First dev job I had (was 15 at the time), I had to recalc our accountants 1-2-3 models because I had a 80287 in my AT clone... and that resulted in a "hell yes" a year later when I asked for a 386 + 387. I put on the write up on why I needed it was a) it would compile faster and when needed I b) could recalc financial models faster. That model took maybe 5 minutes with the 287 and maybe 40 sec on the 386+387 setup... I suspect the generous 4mb of RAM was more important... I never really understood why people wouldn't shell out the extra couple hundred bucks on the math coprocessors, they really sped things up provided that software supported them.

"numerics people ignored it"

I dunno Walter but as the first(?) IEEE754 implementation in a PC system it seemed like a pretty damn big deal to us people working in numerical algorithms. It was a big enough deal to me at the time (I was in graduate school) that I've kept my 8087 chip all my life and have it before me now. I see the old boy has lost a pin during the last move, dammit.

Chip has "3716150AA MALAY BEV 22" embossed on the pin side. Search gets me nothing.

I mean, the 8087 was the primary influence on IEEE 754, and hence all of modern floating-point, so in that sense, the numerics people don't ignore it.

The main problem with the x87 floating-point unit is that it only properly works on a weird 80-bit floating-point type that doesn't have the properties you expect of regular IEEE 754 floating-point types, thanks to the explicit integer bit. The design makes it hard to properly emulate the more common 32-bit and 64-bit single and double-precision floating-point arithmetic bit-equivalently, and this is compounded by many compilers' decision to spill floating-point registers incorrectly (they're spilled as 32-bit or 64-bit, not 80-bit), which makes the numerical results of your program effectively random. Also, the size of the 80-bit types isn't really conducive to vectorization, so the floating-point unit gets left behind as SIMD programming starts to become more important.

So what happens is that the x87 is essentially the last of the pre-IEEE 754 floating-point systems that's still hanging around. A lot of the features that would make it interesting in an environment where every vendor has a different floating-point system are now just vestigial weirdness in a world where everybody is following the same floating-point system, and not worth supporting.

That was win64, not win32. My mistake.

Yeah even NASA doesn't need that many bits. Ken said it himself: https://news.ycombinator.com/item?id=40971913

But they can, it's just not accelerated by hardware built specifically for the task

Espressif did finally added back an FPU to the ESP32-S3. (The original ESP32 also has one).

They tried, with the H- and P- lines to effectively make it a paid extra over the regular productions. At least they accepted when the market disagreed.

Minor erratum: "1.1 (binary) × 2^8 is 304" should be 384.

righto.com has been great reading. None of my friends wanted to pay for an 8087, but I can still remember getting out of school (for 2nd time) and saving up for the 486DX after 3 others got them. After that, well, it's been quite a ride.

If your look at {whatever part is next} is this interesting, I don't know if "which one?" really matters much.

Have you already covered how the decoding of instructions is shared with the 8086?

There's a ton of coordination lately on P6 microcode. Would love to see what twists and turns there are supporting the older isa on newer architectures

I am curious about the transcendental instructions, how are they implemented, and used, and if actually used

Sample assembly x86 code for this FPU.