This is the mail archive of the
mailing list for the GCC project.
Re: [PATCH] handle expressions in __builtin_has_attribute (PR 88383)
On 12/13/18 4:39 PM, Jakub Jelinek wrote:
On Thu, Dec 13, 2018 at 02:05:29PM -0700, Martin Sebor wrote:
So how is the builtin defined then? Is the argument always an expression
and you only return whether its type has the attribute, or do something
different if the expression is of certain kind?
For a DECL the built-in looks at both the DECL_ATTRIBUTES and
the DECL's type's TYPE_ATTRIBUTES. For expressions, it just
looks at TYPE_ATTRIBUTES of the expression's type. I'm not
sure that this is necessarily the cleanest design but it's
meant to follow how attributes are applied to DECLs. Sometimes
they get applied to the DECL itself and other times to its type.
This has been causing confusion to both users and GCC devs such
as myself so at some point I'd like to make this clearer somehow.
Not sure exactly how yet.
But some users of the attribute look for the attribute on TYPE_ATTRIBUTES,
other on DECL_ATTRIBUTES, and the attributes have bools which say to what
they apply. So, I think the API need to be very clear whether the attribute
is on a decl or on a type.
If it is similar to say sizeof/__alignof__ etc., where it accepts either
a type (for which one can use __typeof/decltype etc.), in which case it
would check the type attributes, or an expression and in that case require
it to be a decl and use decl attributes, one API is fine, but supporting
arbitrary expressions and sometimes looking at type, other times at decl
or both is not a good design.
It's as good as the design of GCC attributes allows. Based on
the manual a function declaration like
__attribute__ ((alloc_size (1), malloc))
void* allocate (unsigned);
should have those two attributes applied to it. Yet, alloc_size
is actually applied to its type (but not to its decl) while malloc
to the function's decl but not its type (bug 88397).
I'm pretty sure most users still expect the following to pass:
_Static_assert (__builtin_has_attribute (allocate, alloc_size));
_Static_assert (__builtin_has_attribute (allocate, malloc));
It wouldn't if the built-in differentiated between decls and types.
Even if/when we make these function attributes (and others like it)
apply to types as I think we should so it's possible to apply them
to function pointers as users expect, there still will be others
that will apply only to the function decls. The distinction
between when GCC chooses to apply an attribute to a function decl
vs to its type is not intuitive and cannot very well be, and neither
would be an API that queried just a decl attribute or just a type
attribute. The most common use case is to query whether a function
has been declared with an attribute -- it doesn't matter whether
it's on its unique type or on its decl. (The others might perhaps
be useful too, but a lot less often.)