15.1.5 C Floating Point
Most modern systems handle floating point following the IEEE-695
standard. However, there are still portability issues.
Most processors use 64 bits of precision when computing floating point
values. However, the widely used Intel x86 series of processors compute
temporary values using 80 bits of precision, as do most instances of the
Motorola 68k series. Some other processors, such as the PowerPC,
provide fused multiply-add instructions which perform a multiplication
and an addition using high precision for the intermediate value.
Optimizing compilers will generate such instructions based on sequences
of C operations.
For almost all programs, these differences do not matter. However, for
programs which do intensive floating point operations, the differences
can be significant. It is possible to write floating point loops which
terminate on one sort of processor but not on another.
Unfortunately, there is no rule of thumb that can be used to avoid these
problems. Most compilers provide an option to disable the use of
extended precision (for GNU cc, the option is
`-ffloat-store'). However, on the one hand, this merely shifts the
portability problem elsewhere, and, on the other, the extended precision
is often good rather than bad. Although these portability problems can
not be easily avoided, you should at least be aware of them if you write
programs which require very precise floating point operations.
The IEEE-695 standard specifies certain flags which the floating point
processor should make available (e.g., overflow, underflow, inexact),
and specifies that there should be some control over the floating point
rounding mode. Most processors make these flags and controls available;
however, there is no portable way to access them. A portable program
should not assume that it will have this degree of control over floating