Can I tell my compiler that a floating-point value is not NaN nor +/-infinity?

Question

I'm writing a C function float foo(float x) which manipulates a floating-point value. It so happens, that I can guarantee the function will only ever be called with finite values - neither NaN's, nor +inf, nor -inf. Is it possible to "tell" this to the compiler (without actually doing runtime work which ensures it, like comparing, or zeroing bits and such)? For it to be able to optimize the code based on that assumption?

Notes:

I'm assuming this answer would be compiler-specific, so let's focus on GCC, clang and MSVC.
I might also be able to guarantee the values are not denormals.
It would help if your answer could regard other floating-point types: _Float16/float16_t, double, long double.

Effectively it does compile on the basis that the number is valid FP IEE754. It is really the denorms arising from borderline underflow that you should be worried about - they can cripple performance code if they arise in significant numbers. See for example this on MS erfc implementation slowness. Enabling fastmath effectively makes the assumption that Nans and Infs can be safely ignored although if they do occur the hardware still deals with them. — Martin Brown
– Martin Brown, Commented Jul 20 at 15:35
@MartinBrown: Ah, but I don't want to enable "fast math" - I want maximum precision for mathematical functions; but I also want to benefit from my specific knowledge. Also, I'm asking for a local hint, not something global. — einpoklum
– einpoklum, Commented Jul 20 at 15:45
@einpoklum "... without actually doing runtime work" --> does you function really behave noticeable slower without that check? Losing 5%, .5%, ? — chux
– chux, Commented Jul 21 at 5:05
@chux : If my function runs once, then no. If it is applied for every element in a large array or matrix, then yes. Of course, depends on what's the 100%. I'm experiemnting on one aspect of a computation which involves several kernels, so even if I reduce execution time of one of them to 0, I still only save a few percentage points of my overall processing time. Anyway, the question is about the principle. — einpoklum
– einpoklum, Commented Jul 21 at 9:03

0___________ · Accepted Answer · 2025-07-20 16:49:46Z

5

Compiler	Compile-time Assumption	In-Code Hint	Denormal Control
GCC ≥13	`-ffinite-math-only`	stop excution using `__builtin_unreachable()`	Use FTZ/DAZ or `-ffast-math`
Clang	`-ffinite-math-only`	`__builtin_assume()`, `__attribute__((assume))`	Same as GCC
MSVC	`/fp:fast`	`__assume(_finite(x))`	Flush-to-zero set via flags or code

Examples:

#include <math.h>

float foo(float x) {
    __builtin_assume(isfinite(x));
    // or: __builtin_assume(!isnan(x) && x != INFINITY && x != -INFINITY);

    // Now x is assumed finite
    return x * 2.0f;
}

__attribute__((assume("finite-arg"))) float foo(float x);

clang -O2 -ffinite-math-only -fno-trapping-math foo.c -o foo
gcc  -O2 -ffinite-math-only -fno-trapping-math foo.c -o foo

float foo(float x) {
    __assume(_finite(x));
    return x * 2.0f;
}

answered Jul 20 at 16:49

0___________

71.6k4 gold badges41 silver badges94 bronze badges

Sign up to request clarification or add additional context in comments.

Comments

Eric Postpischil · Accepted Answer · 2025-07-20 16:45:59Z

4

You can tell GCC and Clang any condition you can express in code is impossible by using their __builtin_unreachable feature:

#include <math.h>

float foo(float x)
{
    if (!isfinite(x))
        __builtin_unreachable();
    // The compiler may conclude x is not infinite or NaN when foo is called.
    …
}

Using __builtin_unreachable tells the compiler code will never reach that point. Therefore, the compiler may assume the conditions needed to reach that point are false.

answered Jul 20 at 16:45

Eric Postpischil

233k15 gold badges199 silver badges379 bronze badges

1 Comment

einpoklum Jul 21 at 9:04

Upvoted as well, since if a compiler (not the big-3) has an unreachable hint, but not an assume hint, you've given us a way to "implement" the latter using the former.

Collectives™ on Stack Overflow

Can I tell my compiler that a floating-point value is not NaN nor +/-infinity?

2 Answers 2

Comments

1 Comment

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

Comments

1 Comment

Your Answer

Sign up or log in

Post as a guest

Linked

Related