Under certain conditions GCC is able to perform compile-time folding of floating point expressions. This is great. Sometimes, however, the resulting (or indeed intermediate) expressions may evaluate to a non-finite value (e.g. NaN, Inf) -- at compile-time. During a traditional run-time execution of floating point arithmetic there are various ways to detect the case of values going into something like an overflow (individual guarding of each possibly-violating expression via 'isfinite()'; or via reading the FPU status register, which hardware itself may flag appropriately; or via the 'fetestexcept' et al wrappers). I was wondering if there was a way to ask GCC to optionally emit some kind of a diagnostic (e.g. a warning of some kind) when it does floating point calculations at compile-time and when such compile-time calculations yield in a non-finite number. For example in an oversimplified case like this: float const x(::std::numeric_limits<float>::max()); float const y(x * 2); It would be nice for GCC to emit a warning if it ended up setting 'y' to 'Inf'... or similar. Testing for such compile-time results during runtime would always be less efficient (and at times, when not using individual expression-guarding but rather FPU register reading, not possible...) Forcing to always individually-guard may also be extremely defficient (e.g. if 99% of cases are not overflowing then, statistically, it may not be the best way of doing this). Expecting for the compile-time 'Inf', or similar, to be propagated eventually to some runtime-detectable result is also not a solution as comparative (e.g. x < y) math will not work either and not be detected (as 'trigger' for y to overflow had happened at compile-time). Best regards Leon.
