Checking for NaN bit patterns in C++

First of all, the compiler is not hostile; by using -ffast-math you are asking for an optimization that the compiler dutifully performs. Perhaps it is not what you desired the compiler would do in this particular case, but please don't attribute that to maliciousness from the compiler or the compiler developers.

Compilers routinely are able to look at code patterns and see that a piece of code does the same as some built-in function, and replace one with the other, and then perform more optimizations on it. So in theory, the compiler might decide that what you are doing is the same as std::isnan(). Luckily, current versions of GCC and Clang don't optimize your safe_isnan() away.

Also be aware that as part of -ffast-math optimizations, an operation that would have resulted in a NaN might now return a finite value. safe_isnan() is not going to protect you against that. So it might work for values you read directly from disk or network, but be aware of this when using it on the results of arithmetic operations.

You have missed the namespace qualifier of std::uint64_t. It seems that std::uint_fast64_t should be sufficient, to make the code more portable. The exact-width type is probably appropriate, but we should confirm that using static_assert(sizeof (double) == sizeof (std::uint64_t).

We probably want to ensure that the types have the same endianness - probably the easiest way to do that is follow the definition with a compile-time test like

static_assert(safe_isnan(std::numeric_limits<double>::quiet_NaN()));

It looks like the test could be simplified. Instead of those >= and <= comparisons, just check the relevant bits are set:

auto constexpr ones_mask = 0x7ff0000000000000;
auto constexpr zero_mask = 0x000fffffffffffff;

return (x & ones_mask) == ones_mask  &&  (x & zero_mask) != 0;

We should probably conditionalise on std::numeric_limits<double>::is_iec559 since we depend on the floating-point layout.

The whole thing should be unnecessary - but if you've you've selected -ffast-math, then your compiler can assume that these bit patterns are impossible. You probably need to compile this function separately without that option for it to work reliably. But in that case, you might as well just compile a tiny (non-fastmath) wrapper that ensures the standard isnan() is called:

bool safe_isnan(double val) noexcept { return std::isnan(val); }

(Note: not constexpr, and take steps to avoid inlining - or link-time optimisation)

Another alternative is to use (or reimplement) std::fpclassify() and use that to implement your versions of isnan(), isfinite(), etc.

Minor: ll serves no purpose here

DRYer code
ll is useful to force a minimum width type. Unnecessary with all same sign type compares.

const auto x = std::bit_cast<uint64_t>(val);

// return (x >= 0x7FF0000000000001ull && x <= 0x7FFFFFFFFFFFFFFFull)
//     || (x >= 0xFFF0000000000001ull);
return (x >= 0x7FF0000000000001u && x <= 0x7FFFFFFFFFFFFFFFu)
    || (x >= 0xFFF0000000000001u);

... or re-formed as

return (x & 7FFFFFFFFFFFFFFFu) >= 0x7FF0000000000001u;