On Tue, Dec 05, 2023 at 11:01:20AM -0500, Jason Merrill wrote:
> > And there is another thing I wonder about: with -Wno-attributes= we are
> > supposed to ignore the attributes altogether, but we are actually still
> > warning about them when we emit these generic warnings about ignoring
> > all attributes which appertain to this and that (perhaps with some
> > exceptions we first remove from the attribute chain), like:
> > void foo () { [[foo::bar]]; }
> > with -Wattributes -Wno-attributes=foo::bar
> > Shouldn't we call some helper function in cases like this and warn
> > not when std_attrs (or how the attribute chain var is called) is non-NULL,
> > but if it is non-NULL and contains at least one non-attribute_ignored_p
> > attribute?
>
> Sounds good.
The following patch implements it.
I've kept warnings for cases where the C++ standard says explicitly any
attributes aren't ok -
"If an attribute-specifier-seq appertains to a friend declaration, that
declaration shall be a definition."
For some changes I haven't figured out how could I cover it in the
testsuite.
So far tested with
GXX_TESTSUITE_STDS=98,11,14,17,20,23,26 make check-g++
RUNTESTFLAGS="dg.exp=Wno-attributes* ubsan.exp=Wno-attributes*"
(which is all tests that use -Wno-attributes=), ok for trunk if it passes
full bootstrap/regtest?
Note, C uses a different strategy, it has c_warn_unused_attributes
function which warns about all the attributes one by one unless they
are ignored (or allowed in certain position).
Though that is just a single diagnostic wording, while C++ FE just warns
that there are some ignored attributes and doesn't name them individually
(except for namespace and using namespace) and uses different wordings in
different spots.
2023-12-06 Jakub Jelinek <ja...@redhat.com>
gcc/
* attribs.h (any_nonignored_attribute_p): Declare.
* attribs.cc (any_nonignored_attribute_p): New function.
gcc/cp/
* parser.cc (cp_parser_statement, cp_parser_expression_statement,
cp_parser_declaration, cp_parser_elaborated_type_specifier,
cp_parser_asm_definition): Don't diagnose ignored attributes
if !any_nonignored_attribute_p.
* decl.cc (grokdeclarator): Likewise.
* name-lookup.cc (handle_namespace_attrs, finish_using_directive):
Don't diagnose ignoring of attr_ignored_p attributes.
gcc/testsuite/
* g++.dg/warn/Wno-attributes-1.C: New test.
--- gcc/attribs.h.jj 2023-12-06 12:03:27.421176109 +0100
+++ gcc/attribs.h 2023-12-06 12:36:55.704884514 +0100
@@ -48,6 +48,7 @@ extern void apply_tm_attr (tree, tree);
extern tree make_attribute (const char *, const char *, tree);
extern bool attribute_ignored_p (tree);
extern bool attribute_ignored_p (const attribute_spec *const);
+extern bool any_nonignored_attribute_p (tree);
extern struct scoped_attributes *
register_scoped_attributes (const scoped_attribute_specs &, bool = false);
--- gcc/attribs.cc.jj 2023-12-06 12:03:27.386176602 +0100
+++ gcc/attribs.cc 2023-12-06 12:36:55.704884514 +0100
@@ -584,6 +584,19 @@ attribute_ignored_p (const attribute_spe
return as->max_length == -2;
}
+/* Return true if the ATTRS chain contains at least one attribute which
+ is not ignored. */
+
+bool
+any_nonignored_attribute_p (tree attrs)
+{
+ for (tree attr = attrs; attr; attr = TREE_CHAIN (attr))
+ if (!attribute_ignored_p (attr))
+ return true;
+
+ return false;
+}
+
/* See whether LIST contains at least one instance of attribute ATTR
(possibly with different arguments). Return the first such attribute
if so, otherwise return null. */
--- gcc/cp/parser.cc.jj 2023-12-06 12:03:27.502174967 +0100
+++ gcc/cp/parser.cc 2023-12-06 12:36:55.704884514 +0100
@@ -12778,9 +12778,8 @@ cp_parser_statement (cp_parser* parser,
SET_EXPR_LOCATION (statement, statement_location);
/* Allow "[[fallthrough]];" or "[[assume(cond)]];", but warn otherwise. */
- if (std_attrs != NULL_TREE)
- warning_at (attrs_loc,
- OPT_Wattributes,
+ if (std_attrs != NULL_TREE && any_nonignored_attribute_p (std_attrs))
+ warning_at (attrs_loc, OPT_Wattributes,
"attributes at the beginning of statement are ignored");
}
@@ -12986,7 +12985,7 @@ cp_parser_expression_statement (cp_parse
}
/* Allow "[[fallthrough]];", but warn otherwise. */
- if (attr != NULL_TREE)
+ if (attr != NULL_TREE && any_nonignored_attribute_p (attr))
warning_at (loc, OPT_Wattributes,
"attributes at the beginning of statement are ignored");
@@ -15191,7 +15190,7 @@ cp_parser_declaration (cp_parser* parser
}
}
- if (std_attrs != NULL_TREE && !attribute_ignored_p (std_attrs))
+ if (std_attrs != NULL_TREE && any_nonignored_attribute_p (std_attrs))
warning_at (make_location (attrs_loc, attrs_loc, parser->lexer),
OPT_Wattributes, "attribute ignored");
if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
@@ -21095,14 +21094,20 @@ cp_parser_elaborated_type_specifier (cp_
if (attributes)
{
if (TREE_CODE (type) == TYPENAME_TYPE)
- warning (OPT_Wattributes,
- "attributes ignored on uninstantiated type");
+ {
+ if (any_nonignored_attribute_p (attributes))
+ warning (OPT_Wattributes,
+ "attributes ignored on uninstantiated type");
+ }
else if (tag_type != enum_type
&& TREE_CODE (type) != BOUND_TEMPLATE_TEMPLATE_PARM
&& CLASSTYPE_TEMPLATE_INSTANTIATION (type)
&& ! processing_explicit_instantiation)
- warning (OPT_Wattributes,
- "attributes ignored on template instantiation");
+ {
+ if (any_nonignored_attribute_p (attributes))
+ warning (OPT_Wattributes,
+ "attributes ignored on template instantiation");
+ }
else if (is_friend && cxx11_attribute_p (attributes))
{
if (warning (OPT_Wattributes, "attribute ignored"))
@@ -21111,7 +21116,7 @@ cp_parser_elaborated_type_specifier (cp_
}
else if (is_declaration && cp_parser_declares_only_class_p (parser))
cplus_decl_attributes (&type, attributes, (int)
ATTR_FLAG_TYPE_IN_PLACE);
- else
+ else if (any_nonignored_attribute_p (attributes))
warning (OPT_Wattributes,
"attributes ignored on elaborated-type-specifier that is "
"not a forward declaration");
@@ -22672,7 +22677,7 @@ cp_parser_asm_definition (cp_parser* par
symtab->finalize_toplevel_asm (string);
}
- if (std_attrs)
+ if (std_attrs && any_nonignored_attribute_p (std_attrs))
warning_at (asm_loc, OPT_Wattributes,
"attributes ignored on %<asm%> declaration");
}
--- gcc/cp/decl.cc.jj 2023-12-06 12:03:27.483175235 +0100
+++ gcc/cp/decl.cc 2023-12-06 12:36:55.698884598 +0100
@@ -13058,7 +13058,8 @@ grokdeclarator (const cp_declarator *dec
&& !diagnose_misapplied_contracts (declspecs->std_attributes))
{
location_t attr_loc = declspecs->locations[ds_std_attribute];
- if (warning_at (attr_loc, OPT_Wattributes, "attribute ignored"))
+ if (any_nonignored_attribute_p (declspecs->std_attributes)
+ && warning_at (attr_loc, OPT_Wattributes, "attribute ignored"))
inform (attr_loc, "an attribute that appertains to a type-specifier "
"is ignored");
}
--- gcc/cp/name-lookup.cc.jj 2023-12-06 12:03:27.495175066 +0100
+++ gcc/cp/name-lookup.cc 2023-12-06 12:36:55.695884641 +0100
@@ -6356,7 +6356,7 @@ handle_namespace_attrs (tree ns, tree at
DECL_ATTRIBUTES (ns) = tree_cons (name, args,
DECL_ATTRIBUTES (ns));
}
- else
+ else if (!attribute_ignored_p (d))
{
warning (OPT_Wattributes, "%qD attribute directive ignored",
name);
@@ -8703,7 +8703,7 @@ finish_using_directive (tree target, tre
diagnosed = true;
}
}
- else
+ else if (!attribute_ignored_p (a))
warning (OPT_Wattributes, "%qD attribute directive ignored", name);
}
}
--- gcc/testsuite/g++.dg/warn/Wno-attributes-1.C.jj 2023-12-06
14:27:29.006249075 +0100
+++ gcc/testsuite/g++.dg/warn/Wno-attributes-1.C 2023-12-06
14:45:32.475056797 +0100
@@ -0,0 +1,46 @@
+// { dg-do compile { target c++11 } }
+// { dg-options "-Wno-attributes=bar:: -Wno-attributes=baz::qux" }
+
+[[foo::bar]]; // { dg-warning "attribute ignored" }
+[[bar::foo, foo::bar, baz::qux]]; // { dg-warning "attribute ignored" }
+[[bar::foo, bar::bar, baz::qux]]; // { dg-bogus "attribute ignored" }
+
+namespace [[foo::bar]] N { // { dg-warning "'bar' attribute
directive ignored" }
+ int n;
+}
+namespace [[bar::foo, foo::bar, baz::qux]] O { // { dg-warning "'bar'
attribute directive ignored" }
+ int o;
+}
+namespace [[bar::foo, bar::bar, baz::qux]] P { // { dg-bogus "attribute
directive ignored" }
+ int p;
+}
+
+void
+foo ()
+{
+ int i = 0;
+ [[foo::bar]]; // { dg-warning "attributes at
the beginning of statement are ignored" }
+ [[bar::foo, foo::bar, baz::qux]]; // { dg-warning "attributes at the
beginning of statement are ignored" }
+ [[bar::foo, bar::bar, baz::qux]]; // { dg-bogus "attributes at the
beginning of statement are ignored" }
+ [[foo::bar]] ++i; // { dg-warning "attributes at the
beginning of statement are ignored" }
+ [[bar::foo, foo::bar, baz::qux]] ++i; // { dg-warning "attributes at
the beginning of statement are ignored" }
+ [[bar::foo, bar::bar, baz::qux]] ++i; // { dg-bogus "attributes at
the beginning of statement are ignored" }
+ [[foo::bar]] asm (""); // { dg-warning "attributes ignored on
'asm' declaration" }
+ [[bar::foo, foo::bar, baz::qux]] asm (""); // { dg-warning "attributes
ignored on 'asm' declaration" }
+ [[bar::foo, bar::bar, baz::qux]] asm (""); // { dg-bogus "attributes ignored
on 'asm' declaration" }
+ [[foo::bar]] using namespace N; // { dg-warning "'bar' attribute
directive ignored" }
+ [[bar::foo, foo::bar, baz::qux]] using namespace O; // { dg-warning "'bar'
attribute directive ignored" }
+ [[bar::foo, bar::bar, baz::qux]] using namespace P; // { dg-bogus "attribute
directive ignored" }
+}
+
+class S
+{
+ [[foo::bar]] friend int bar (S &); // { dg-warning "attribute ignored" }
+ // { dsg-message "an attribute that
appertains to a friend declaration that is not a definition is ignored" "" {
target *-*-* } .-1 }
+ [[bar::foo, foo::bar, baz::qux]] friend int baz (S &); // { dg-warning
"attribute ignored" }
+ // { dsg-message "an attribute that
appertains to a friend declaration that is not a definition is ignored" "" {
target *-*-* } .-1 }
+ [[bar::foo, bar::bar, baz::qux]] friend int qux (S &); // { dg-warning
"attribute ignored" }
+ // { dsg-message "an attribute that
appertains to a friend declaration that is not a definition is ignored" "" {
target *-*-* } .-1 }
+public:
+ int s;
+};
Jakub
