Podstawy programowania jednostki x87 FPU

The x87 Floating-Point Unit (FPU) is a specialized part of the CPU designed to handle mathematical operations on real numbers, also known as floating-point numbers.

Unlike integer arithmetic, floating-point math requires different internal representations and calculations, which the FPU excels at with high precision.

The x87 FPU uses a unique register stack, not general-purpose registers. This stack consists of eight 80-bit registers, denoted as ST(0) through ST(7).

• ST(0) is always the top of the stack.
• Operations push new values onto the stack or pop values from it, shifting existing values.
• It behaves like a Last-In, First-Out (LIFO) stack.

To work with floating-point numbers, you first need to load them onto the FPU stack. The FLD instruction pushes a floating-point value from memory onto the top of the FPU stack, making it ST(0).

In assembly, we often define floating-point constants in the data section. Common types are single-precision (32-bit, DD) and double-precision (64-bit, DQ).

Try loading a value onto the stack:

After calculations, you'll want to store the result from the FPU stack back into memory. The FST and FSTP instructions are used for this.

• FST: Copies the value from ST(0) to a memory location or another FPU register, leaving ST(0) unchanged.
• FSTP: Copies the value from ST(0) to memory/register, then pops it from the stack, decreasing the stack pointer. The previous ST(1) becomes ST(0).

Let's store a value:

The FPU provides instructions for common arithmetic operations. These typically operate on ST(0) and another operand (either another stack register or a memory operand).

• FADD: Add (e.g., FADD ST(1), ST(0) adds ST(0) to ST(1)).
• FMUL: Multiply
• FSUB: Subtract
• FDIV: Divide

Using FADDP ST(1), ST(0) adds ST(0) to ST(1), stores in ST(1), and pops ST(0). This leaves the sum on top of the stack.

Here's an addition example:

The FPU can load commonly used constants directly onto its stack, saving you from defining them in memory. This improves efficiency and precision.

• FLD1: Pushes 1.0 onto the stack.
• FLDZ: Pushes 0.0 onto the stack.
• FLDPI: Pushes the value of Pi (π) onto the stack.

Let's load Pi:

Sometimes you need to convert between integer and floating-point types. The FPU provides instructions for this:

• FILD (Float Integer Load): Loads a signed integer from memory, converts it to a floating-point format, and pushes it onto the FPU stack.
• FISTP (Float Integer Store and Pop): Stores ST(0) as an integer to memory and then pops it from the stack. The value is truncated towards zero during conversion.

Let's convert an integer to a float, add, then convert back:

Comparing floating-point numbers requires special FPU instructions. You can't directly use integer comparison instructions like CMP.

• FCOM: Compares ST(0) with an operand (another FPU register or memory) and sets FPU status flags.
• FCOMP: Same as FCOM, but pops ST(0) after comparison.

To use these flags for conditional jumps (like JE, JB), you must transfer them from the FPU status word to the CPU's EFLAGS register:

1. FSTSW AX: Stores the FPU Status Word into the AX register.
2. SAHF: Transfers the AH register (which now contains the relevant FPU flags) into the CPU's EFLAGS register, specifically the ZF, PF, and CF flags.

Let's combine what we've learned to perform a simple calculation: (A + B) * C. We'll load three values, add two, multiply by the third, and store the final integer result.

This example demonstrates stack manipulation and arithmetic operations.

You've taken your first steps into x87 FPU programming! We covered:

• The FPU's 8-register stack (ST(0) to ST(7)).
• Loading values with FLD and storing with FST/FSTP.
• Basic arithmetic: FADD, FSUB, FMUL, FDIV.
• Using built-in constants like FLD1, FLDZ, FLDPI.
• Converting between integers and floats with FILD and FISTP.
• How to prepare FPU comparison results for conditional jumps.

The x87 FPU is powerful for precise calculations, though modern systems often use SIMD extensions like SSE/AVX for speed, which you'll explore next!