Inside a float: IEEE 754

Fractions in binary

Digits after a binary point work like digits after a decimal point, except that each place is worth half of the one to its left: 1/2, 1/4, 1/8, 1/16, and so on. So 110.11 in binary is 4 + 2 + 1/2 + 1/4 = 6.75.

To turn a decimal fraction into binary, keep doubling it. Each doubling pushes one bit across the point: the whole-number part (0 or 1) is the next bit, and only what is left after the point carries on to the next row.

The bits of 0.1 never end, in the same way that 1/3 = 0.333... never ends in decimal. A float has room for only so many bits, so 0.1 is stored as the nearest value that fits, not as 0.1 itself. The programs below show exactly how near.

Fixed point, and why floats move the point

One simple way to store fractions is fixed point: agree that the binary point sits at a set place, say 8 bits from the right, and store the number times 2^8 as an ordinary integer. 6.75 becomes 6.75 x 256 = 1728. Integer instructions can add and compare these directly, which is why small devices with no floating-point hardware still use them. The catch is range: with the point fixed, the same 32 bits cannot hold both 0.0001 and ten billion.

Floating point lets the point move. Any number other than zero can be written in binary scientific notation, as 1.something times a power of two:

Moving the point until exactly one 1 sits to its left is called normalizing. After normalizing, that leading digit is always 1, so the format does not spend a bit storing it; it is called the hidden bit. What is left to store is the sign, the power of two (the exponent), and the bits after the point (the fraction).

The single-precision layout

A single-precision float, the 32-bit kind that sits in an s register and that .float places in memory, splits its bits three ways:

• s, the sign bit, is 0 for positive and 1 for negative. Flipping it negates the number and changes nothing else, which is all fnegFd = -Fn (flips the sign bit; S or D form). does.
• e, the exponent, is stored with a bias: the true power of two plus 127. The bias keeps the field between 0 and 255, so it needs no sign of its own. An e of 127 means 2^0, 130 means 2^3, and 124 means 2^-3.
• f, the fraction, is the 23 bits after the point of the normalized number, padded with zeros on the right. The hidden 1 goes in front of them.

Encoding -6.75:

Decoding a word

Decoding runs the same steps backwards: split the bits 1, 8 and 23; subtract 127 from e; put the hidden 1 in front of f; and move the point by the true exponent. The IEEE 754 view of the base converter shows the three fields of any word you type, which makes it a quick check for a hand decoding. For 0x42a50000:

Range and precision

e values from 1 to 254 give ordinary numbers, so the true exponent runs from -126 to 127. The largest single is just under 2^128, about 3.4 x 10^38, and the smallest ordinary one is 2^-126, about 1.2 x 10^-38. The two leftover e values, 0 and 255, are kept for special cases, covered further down.

Precision is set by the fraction: 23 stored bits plus the hidden bit give 24 significant bits, about 7 decimal digits. Past that, even whole numbers go missing: 16,777,217 (2^24 + 1) has no single-precision form, and converting it with scvtfSigned-int -> float (SCVTF Dd, Xn / Dd, Wn / Sd, Wn). gives 16,777,216.

Taking floats apart in a program

The program below prints four single-precision values beside their bits and fields. Its helper, show_float, works in three steps:

• fmov bits_r, s0 (with bits_r standing for w9caller-saved temporary (x9-x15): a called routine may overwrite it.) copies the 32 bits of s0 into a general register unchanged. It copies the pattern and does not convert the value: for 1.0 the integer it leaves is 1,065,353,216 (0x3f800000), not 1.
• ubfxUnsigned bitfield extract: Rd = (Rn >> lsb) & ((1 << width) - 1). pulls out s (bit 31), e (bits 30 to 23) and f (bits 22 to 0), and subRd = Rn - Rm/imm. No flags. takes the bias off e.
• fcvt d0, s0 widens the value to a double before the call, because printf always receives a floating-point argument as a double.

Running it prints:

Reading the output:

• 1.0 is 1.0 x 2^0, so e equals the bias and f is all zeros.
• -6.75 matches the hand encoding above. f prints as 0x580000 because its 23 bits, 1011 and nineteen zeros, regroup in fours from the right as 101 1000 0000 0000 0000 0000.
• 0.1 is 1.6 x 2^-4. Its fraction is a pattern of bits that repeats without end (it shows as the run of c digits in f), so the last bit is rounded up, and f ends in d where the pattern alone would give c. Printed to nine significant digits, the stored value shows as 0.100000001.
• 1.0 / 0.0 does not stop the program. It gives infinity, which has e = 255 and f = 0.

Change 0r-6.75 to 0r82.5 and run again: the second line shows 0x42a50000, the word decoded by hand above.

Zero, subnormals, infinity, and NaN

The two e values left out of ordinary numbers mark the special cases:

• Zero has no leading 1 to hide, so it gets its own pattern: e and f all zeros. That leaves two zeros, +0 and -0, which fcmpSet NZCV from Fn vs Fm (S or D form). reports as equal.
• A subnormal number is smaller than the smallest normal one. With e = 0 the hidden bit becomes 0, so these values fill the gap between 2^-126 and zero, at the price of fewer significant bits. The smallest, 0x00000001, is 2^-149, about 1.4 x 10^-45.
• Infinity is the result when the true answer is too large to store, or when a nonzero number is divided by zero.
• A NaN marks a result with no sensible value, such as 0.0 / 0.0 or infinity minus infinity; 0x7fc00000 is the NaN that AArch64 produces for these. A NaN compares unequal to everything, itself included: after fcmpSet NZCV from Fn vs Fm (S or D form). with a NaN on either side, b.eqConditional branch (write as B.EQ, B.NE, B.LT, ...). is not taken.

The program below reads each pattern's fields and names its kind. main keeps its pointer and its counter in x19callee-saved register (x19-x28): a routine must restore it before it returns. and x20callee-saved register (x19-x28): a routine must restore it before it returns. because they must survive every printf call, so it saves those two registers on entry and restores them before returning, as the calling conventions lesson requires. Replace any word in the .word lists with a hex word of your own, such as one from a practice question, to classify it.

Running it prints:

Double precision

A double-precision float, the 64-bit kind in a d register and made by .double, follows the same rules with wider fields:

The bias is 1023, the special cases are e = 0 and e = 2047, and 53 significant bits give about 16 decimal digits, over a range out to about 1.8 x 10^308. -6.75 as a double keeps the same sign and the same fraction bits 1011; only the exponent field is wider, holding the true exponent 2 as 2 + 1023 = 1025:

The program below does the same split for doubles, with x registers and wider ubfxUnsigned bitfield extract: Rd = (Rn >> lsb) & ((1 << width) - 1). fields. It prints 17 significant digits, which is enough to tell any two doubles apart.

Running it prints:

The third and fourth values both started as 0.1. The double 0.1 is off by about 5.6 x 10^-18. The fourth line is the single 0.1 widened with fcvtConvert between the float views: FCVT Dd, Sn widens exactly, FCVT Sd, Dn narrows with rounding., and it is off by about 1.5 x 10^-9, the single's own error. Widening only appends zero bits to the fraction (the single's f, 0x4ccccd, moved left 29 places is 0x99999a0000000), so the error comes along unchanged. Converting to a wider type never brings back bits that were already rounded away.

Check yourself

1. Decode 0xc1200000.
2. Encode 0.375 as a single-precision word.
3. Name the kind of value each word holds: 0x80000000, 0x7f800001, 0x00400000.

Practice

• Float anatomy: split a float into its sign, exponent and fraction, and name what kind of value it is.
• Build a float from parts: the same layout, run backwards.
• Advanced quiz: floating point: how fmovCopy bits: FP to FP, between the register files, or an 8-bit float immediate. fits a constant into 8 bits (a sign, 3 exponent bits and 4 fraction bits, this lesson's layout in miniature).
• Fill in the blank: floating point (core): .float and .double.
• Predict: floating point (core): fnegFd = -Fn (flips the sign bit; S or D form). and fabsFd = fabs(Fn) (clears the sign bit; S or D form)., which touch only the sign bit.