`const`/`constexpr` INFINITY can cause clang to make a different result from `inf/inf` or `inf-inf`

[wind0204]

Title.

The usual result from inf/inf or inf-inf is a negative NaN, but when I use a const infinity clang calculates it in compile-time and saves a positive NaN for runtime use

Ubuntu GCC 13.3.0(gcc -std=gnu2x minimal.c -lm) didn't have the issue but Ubuntu clang 18 and Ubuntu clang 20 showed the symptom.

The CPU I use is Haswell.

I think you can reproduce the symptom with the code below ( clang minimal.c -std=gnu23 -lm )

#include <stdio.h>
#include <stdint.h>
#include <math.h>

/*
 * \brief for little endian systems
 */
union ieee754_binary32 {
  struct {
    uint32_t fraction: 23;
    uint16_t exponent: 8;
    uint8_t sign: 1;
  };
  float whole;
};

int main(int argc, char * argv[])
{
  float inf = INFINITY;
  float nan = NAN;

#if __clang_major__ <= 18
  const float cinf = INFINITY;
  const float cnan = NAN;
#else
  constexpr float cinf = INFINITY;
  constexpr float cnan = NAN;
#endif

  fprintf( stdout, "inf - inf = %f\n", (inf - inf) );
  fprintf( stdout, "const_inf - const_inf = %f\n", (cinf - cinf) );
  union ieee754_binary32 inspector = {.whole=(cinf - cinf)};
  fprintf( stdout, "inspector = {.whole=(const_inf - const_inf)}; inspector.sign = %u\n", inspector.sign );

  fprintf( stdout, "inf / inf = %f\n", (inf / inf) );
  inspector.whole = (inf / inf);
  fprintf( stdout, "inspector = {.whole=(inf / inf)}; inspector.sign = %u\n", inspector.sign );
  fprintf( stdout, "const_inf / const_inf = %f\n", (cinf / cinf) );

  inspector.whole = (cinf / cinf);
  fprintf( stdout, "inspector = {.whole=(const_inf / const_inf)}; inspector.sign = %u\n", inspector.sign );

  return 0;
}

The output from clang-built binaries:

inf - inf = -nan
const_inf - const_inf = nan
inspector = {.whole=(const_inf - const_inf)}; inspector.sign = 0
inf / inf = -nan
inspector = {.whole=(inf / inf)}; inspector.sign = 1
const_inf / const_inf = nan
inspector = {.whole=(const_inf / const_inf)}; inspector.sign = 0

The output from a GCC-built binary:

inf - inf = -nan
const_inf - const_inf = -nan
inspector = {.whole=(const_inf - const_inf)}; inspector.sign = 1
inf / inf = -nan
inspector = {.whole=(inf / inf)}; inspector.sign = 1
const_inf / const_inf = -nan
inspector = {.whole=(const_inf / const_inf)}; inspector.sign = 1

Thank you so much!

[llvmbot]

@llvm/issue-subscribers-clang-frontend

Author: Gunwoo Gim (wind0204)

_Title_.

The usual result from inf/inf or inf-inf is a negative NaN, but when I use a const infinity clang calculates it in compile-time and saves a positive NaN for runtime use

Ubuntu GCC 13.3.0(gcc -std=gnu2x minimal.c -lm) didn't have the issue but Ubuntu clang 18 and Ubuntu clang 20 showed the symptom.

The CPU I use is Haswell.

I think you can reproduce the symptom with the code below ( clang minimal.c -std=gnu23 -lm )

#include <stdio.h>
#include <stdint.h>
#include <math.h>

/*
 * \brief for little endian systems
 */
union ieee754_binary32 {
  struct {
    uint32_t fraction: 23;
    uint16_t exponent: 8;
    uint8_t sign: 1;
  };
  float whole;
};

int main(int argc, char * argv[])
{
  float inf = INFINITY;
  float nan = NAN;

#if __clang_major__ <= 18
  const float cinf = INFINITY;
  const float cnan = NAN;
#else
  constexpr float cinf = INFINITY;
  constexpr float cnan = NAN;
#endif

  fprintf( stdout, "inf - inf = %f\n", (inf - inf) );
  fprintf( stdout, "const_inf - const_inf = %f\n", (cinf - cinf) );
  union ieee754_binary32 inspector = {.whole=(cinf - cinf)};
  fprintf( stdout, "inspector = {.whole=(const_inf - const_inf)}; inspector.sign = %u\n", inspector.sign );

  fprintf( stdout, "inf / inf = %f\n", (inf / inf) );
  inspector.whole = (inf / inf);
  fprintf( stdout, "inspector = {.whole=(inf / inf)}; inspector.sign = %u\n", inspector.sign );
  fprintf( stdout, "const_inf / const_inf = %f\n", (cinf / cinf) );

  inspector.whole = (cinf / cinf);
  fprintf( stdout, "inspector = {.whole=(const_inf / const_inf)}; inspector.sign = %u\n", inspector.sign );

  return 0;
}

The output from clang-built binaries:

inf - inf = -nan
const_inf - const_inf = nan
inspector = {.whole=(const_inf - const_inf)}; inspector.sign = 0
inf / inf = -nan
inspector = {.whole=(inf / inf)}; inspector.sign = 1
const_inf / const_inf = nan
inspector = {.whole=(const_inf / const_inf)}; inspector.sign = 0

The output from a GCC-built binary:

inf - inf = -nan
const_inf - const_inf = -nan
inspector = {.whole=(const_inf - const_inf)}; inspector.sign = 1
inf / inf = -nan
inspector = {.whole=(inf / inf)}; inspector.sign = 1
const_inf / const_inf = -nan
inspector = {.whole=(const_inf / const_inf)}; inspector.sign = 1

Thank you so much!

[camc]

I don't think there is anything wrong here. The sign bit after invalid operations is unspecified according to IEEE 754, it varies between architectures and on ARM it can change depending on the runtime state or specific instructions. Note GCC is also inconsistent with the behaviour on Intel/AMD in some cases, e.g. 0 * (-inf) is positive in consteval but negative at runtime.

[wind0204]

I don't think there is anything wrong here. The sign bit after invalid operations is unspecified according to IEEE 754, it varies between architectures and on ARM it can change depending on the runtime state or specific instructions. Note GCC is also inconsistent with the behaviour on Intel/AMD in some cases, e.g. 0 * (-inf) is positive in consteval but negative at runtime.

Aha! Thank you for the information. camc

[wind0204]

Note GCC is also inconsistent with the behaviour on Intel/AMD in some cases, e.g. 0 * (-inf) is positive in consteval but negative at runtime.

For anyone who is interested in testing themself: I could see the consteval changing the output by giving -O2 to GCC ( gcc -std=gnu2x -lm minimal.c -O2)

GCC-built binary would print

0 * -inf = nan
0 * -const_inf = nan

or

0 * -inf = -nan
0 * -const_inf = -nan

according to the optimization level.

code added:

  fprintf( stdout, "0 * -inf = %f\n", 0.0f * -inf );
  fprintf( stdout, "0 * -const_inf = %f\n", 0.0f * -cinf );

[zygoloid]

See also #61973, which is the corresponding issue for the optimizer rather than the frontend. (Note that compiling with Clang -O1 produces positive NaNs regardless of const / constexpr, that's #61973.)