standards/130067: Wrong numeric limits in system headers?

[Bruce Evans]

On Fri, 9 Jan 2009, David Schultz wrote:

> On Fri, Jan 09, 2009, John Hein wrote:
>> FWIW, when you compile the OP's sample code on i386 with -pedantic
>> (with 6.x's base gcc 3.4.6 or 7.x's base gcc 4.2.1), you get:
>>
>> x.cc:11: error: floating constant exceeds range of 'long double'
>>
>> (the LDBL_MAX line)
>>
>> That seems to tip the scale more to the 'float.h is wrong' side.

No, it is strictly a bug in gcc (gcc is supposed to support FreeBSD's
idea of a long double, since the special support is only used by
FreeBSD, but it doesn't).  The FreeBSD value of LDBL_MAX doesn't exceed
the range of a long double with FreeBSD's idea of a long double.
However, almost any operation on FreeBSD's LDBL_MAX would overflow.
E.g., (LDBL_MAX + 0) and (LDBL_MAX * 1) both overflow to give a result
of Inf.  There may be optimization bugs related to this -- IIRC,
evaluating x+0 as x at compile time is an invalid optimization, because
x+0 should differ from x iff x is -0, but evaluating x*1 as x at compile
time is a valid optimization because there should be no special cases;
however LDBL_MAX*1 gives a special case.

> gcc doesn't do quite the right thing with long double constants in
> FreeBSD, and it causes no end of trouble when writing long double
> routines that are intended to work when the FPU is switched to
> extended precision mode.

I think it does do the right thing from its viewpoint.  In its viewpoint,
long doubles have only 53 bits of precision.  Since it refuses to
construct long doubles with the full 64 bits of precision that are
possible and expected by FreeBSD, this is a valid viewpoint -- there
is no way to construct a long double with more than 53 bits of precision
in C without invoking undefined behaviour, so the extra bits might as
well not be there.  This viewpoint also avoids surprises like
LDBL_MAX*1 = Inf.

> Older versions of gcc would evaluate long double constant
> expressions at compile time using extended precision, which was
> wrong because it didn't reflect what the FPU would have done at
> runtime. More recent versions of gcc were "fixed" to evaluate all
> long double constants using double precision, which matches what
> the FPU does by default. However, now it's not even possible to
> write a program that uses long double constants, even if the
> program changes the FPU precision at runtime, because gcc
> truncates all the constants at compile time (and generates
> spurious complaints such as the one you mention). C99 defines some
> pragmas that would improve the situation, but gcc doesn't
> implement them.

This is true.

Bruce