()() ha
On Thu, Apr 5, 2018 at 10:46 AM, James Y Knight <jykni...@google.com> wrote:
>
> GCC, however, mixes up the concept of a C "constant expression" with the
> results of running optimization passes such as inlining for its
> definition/implementation of __builtin_constant_p. Clang does not, and quite
> likely will not ever, do that.
Nothing has ever said that "__builtin_constant_p(x)" means "is x an
integer constant expression".
So there is no mix-up - or rather, *you* are the one mixing things up.
The gcc documentation says:
"You can use the built-in function __builtin_constant_p to
determine if a value is known to be constant at compile time [...]"
Note that this has *nothing* to do with the concept of C "integer
constant expressions".
Yes, integer constant expressions obviously have values that are known
to be constant at compile time. But *other* things have values that
are known to be constant at compile time too.
In fact, we went through a long and painful thing exactly because we
wanted to get that "is this an ICE" value, and it turns out that the
best way to get that value has nothing to do with any gcc builtin at
all, but looks like this:
/* Glory to Martin Uecker <martin.uec...@med.uni-goettingen.de> *
#define __is_constexpr(x) \
(sizeof(int) == sizeof(*(8 ? ((void *)((long)(x) * 0l)) : (int *)8)))
which is actually impressively subtle, and almost entirely standard C
(the only real dependency is "sizeof(void)", and it not being the same
as "sizeof(int)").
So honestly, if your "__builtin_constant_p(x)" is just "is 'x' just a
C integer constant expression", then your __builtin_constant_p() is
not only not compatible with gcc, it isn't really even all that
useful. We can do it by hand without using a builtin at all.
So if any clang person thinks that it's gcc that is mixing up
concepts, you guys need to re-consider. It is simply not true - and
*should* not be true - that __builtin_constant_ps anything to do with
the "C integer constant expression".
It needs to go inside inline functions. That's how we use it, and we
often have reasons why it practically has to. Macro argument
evaluation rules (and lack of type handling) makes it too painful to
use macros everywhere.
And even when the __builtin_constant_p itself is in a macro, the macro
is then often used by inline functions, so..
Linus
