What does gcc -fno-trapping-math do?

Question

I cannot find any example where the -fno-trapping-math option has an effect.

I would expect -ftrapping-math to disable optimizations that may affect whether traps are generated or not. For example the calculation of an intermediate value with extended precision using x87 instructions or FMA instructions may prevent an overflow exception from occurring. The -ftrapping-math option does not prevent this.

Common subexpression elimination may result in one exception occurring rather than two, for example the optimization 1./x + 1./x = 2./x will generate one trap rather than two when x=0. The -ftrapping-math option does not prevent this.

Please give some examples of optimizations that are prevented by -fno-trapping-math.

Can you recommend any documents that explain the different floating point optimization options better than the gcc manual, perhaps with specific examples of code that is optimized by each option? Possibly for other compilers.

Answer 1

A simple example is as follows:

float foo()
{
    float a = 0;
    float nan = a/a;
    return nan;
}

Compiled with GCC 7.3 for x64, at -O3:

foo():
  pxor xmm0, xmm0
  divss xmm0, xmm0
  ret

...which is pretty self-explanatory. Note that it's actually doing the div (despite knowing that 0/0 is nan), which is not especially cheap! It has to do that, because your code might be trying to deliberately raise a floating point trap.

With -O3 -fno-signaling-nans -fno-trapping-math:

foo():
  movss xmm0, DWORD PTR .LC0[rip]
  ret
.LC0:
  .long 2143289344

That is, "just load in a NaN and return it". Which is identical behavior, as long as you're not relying on there being a trap.