You might be able to do something truly arcane using GCC extensions and maybe the __attribute((error))__ thing but realistically it either won't compile or you won't notice unless it's too slow.

The compiler constant folds fairly effectively anyway.

There is __builtin_constant_p (a GCC extension): https://gcc.gnu.org/onlinedocs/gcc-11.3.0/gcc/Other-Builtins...

It's not exactly the same thing, but it's probably what you were thinking of.

This is what qemu uses:

  #define QEMU_BUILD_BUG_ON(x) \
    typedef char qemu_build_bug_on[(x)?-1:1] __attribute__((unused));

So you can write stuff like:

  QEMU_BUILD_BUG_ON(sizeof (struct foo) == 128);

(for example if the struct is used for some network protocol and so it must be 128 bytes long).

I assume you're asking about a check for constness, like __is_constexpr() in Linux kernel.

Starting with C11, it's possible to implement it without any non-standard extensions: https://stackoverflow.com/a/49480926

There is no compilation-time evaluation of functions and statements in C. You have constants, which can be expressions, but that's about it. Oh, and macros of course.

compile-time evaluation was introduced in C++11 and expanded in subsequent versions of the language standard.

This one? https://lore.kernel.org/lkml/1521584015.31174.3.camel@med.un...

What do you want to use it for? C++ uses it for the compile-time programming together with templates. Essentially C++ evolves into a language where you write a program that gets interpreted at compile-time to produce some code that then gets compiled. But I am not sure this is a good idea. It adds a lot of complexity, places many responsibilities that belongs into a compiler onto library writers, increases compilation time a lot, and - with all template expansion - causes a lot of bloat that hurts performance. It also makes debugging interesting. But it looks really good in microbenchmarks because you can create optimal code for special cases easily, I just do not see how this translates into real world performance.