static float f = 0.f / 0.f; cannot be compiled

[tydeman]

This program will not compile.

int main(void){
  if(1){
    static float f = 0.f / 0.f;/* cannot compile this constant l-value expression yet */
  }
  return 0;
}

I believe that C99 introduced this feature along with IEEE-754 floating-point.
It is one way to create a NAN.

[keinflue]

Occurs only if -std=c23 or -std=gnu23 is specified, works against older C revisions: https://godbolt.org/z/qaev14ars

[llvmbot]

@llvm/issue-subscribers-clang-frontend

Author: Fred Tydeman (tydeman)

This program will not compile.

int main(void){
if(1){
static float f = 0.f / 0.f;/* cannot compile this constant l-value expression yet */
}
return 0;
}

I believe that C99 introduced this feature along with IEEE-754 floating-point.
It is one way to create a NAN.

[shafik]

C has NAN

[fuhsnn]

The case is explicitly listed in C standard Annex F:

F.8.5 Constant expressions

1. An arithmetic constant expression of floating type, other than one in an initializer for an object
   that has static or thread storage duration or that is declared with storage-class specifier constexpr,
   is evaluated (as if) during execution ...
2. EXAMPLE

#include <fenv.h>
#pragma STDC FENV_ACCESS ON
void f(void)
{
  constexpr double v = 0.0/0.0; // does not raise an exception
  float w[] = { 0.0/0.0 }; // raises an exception
  static float x = 0.0/0.0; // does not raise an exception
  float y = 0.0/0.0; // raises an exception
  double z = 0.0/0.0; // raises an exception
}

3. For the static and constexpr initializations, the division is done at translation time, raising no (execution-
   time) floating-point exceptions.

The example code can be compiled with gcc -std=c23 -pedantic but clang-21 fails with the same error.

[AaronBallman]

https://godbolt.org/z/Y56W1ao17

NaN is in the range of representable values (we conform to as much of Annex F as we can), so this should be accepted IMO. CC @zahiraam who has done some work in this area. Curiously enough, at file scope it works fine, seems to only be an issue at local scope.

[zahiraam]

This is my understanding of it.
When static is used, the initializer must be a constant expression evaluated at compile time. In C, 0.0f/0.0f is not a valid constant expression because division by 0 is UB in constant expression.
Without the static, the initializer is evaluated at run time; 0.0f/0.0f produces NaN and this compiles according the IEEE754.

[AaronBallman]

because division by 0 is UB in constant expression.

It is and it isn't, which is the crux of the issue.

According to the base C language, it's UB (6.5.6p6). According to Annex F, it's a bit less clear but I think it's maybe still UB in this specific case.

F.2.2p1: As negative and positive infinity are representable in ISO/IEC 60559 formats, all real numbers lie within the range of representable values (5.3.5.3.3).

So 1.0 / 0.0 is not UB under Annex F, and that behaves as expected in Clang: https://godbolt.org/z/4jP4v9T45

But there's no mention of a difference for NaN.

I think Clang's behavior is inconsistent. I would expect constexpr to behave the same way, but it does not: https://godbolt.org/z/4nn1Tbr6j and I would expect global vs local to behave the same way, but it does not: https://godbolt.org/z/a6TTorhno

@tydeman has the CFP study group talked about this at all by any chance?