c: Ignore _Atomic on function return type for C2x

For C2x it was decided that _Atomic would be completely ignored on
function return types (just as was done for qualifiers in C11 DR#423),
to eliminate the potential for an rvalue returned by a function having
_Atomic-qualified type when an rvalue resulting from lvalue-to-rvalue
conversion could not have such a type.  Implement this for GCC.

Bootstrapped with no regressions for x86_64-pc-linux-gnu.

gcc/c/
	* c-decl.cc (grokdeclarator): Ignore _Atomic on function return
	type for C2x.

gcc/testsuite/
	* gcc.dg/qual-return-9.c, gcc.dg/qual-return-10.c: New tests.

diff --git a/gcc/c/c-decl.cc b/gcc/c/c-decl.cc
index 1b53f2d0785af8d169f8606d1fefdd5a76a5d543..90d7cd27cd5ab6ab2356694bba26c21ea492d858 100644 (file)
--- a/gcc/c/c-decl.cc
+++ b/gcc/c/c-decl.cc
@@ -7412,9 +7412,12 @@ grokdeclarator (const struct c_declarator *declarator,
                   them for noreturn functions.  The resolution of C11
                   DR#423 means qualifiers (other than _Atomic) are
                   actually removed from the return type when
-                  determining the function type.  */
+                  determining the function type.  For C2X, _Atomic is
+                  removed as well.  */
                int quals_used = type_quals;
-               if (flag_isoc11)
+               if (flag_isoc2x)
+                 quals_used = 0;
+               else if (flag_isoc11)
                  quals_used &= TYPE_QUAL_ATOMIC;
                if (quals_used && VOID_TYPE_P (type) && really_funcdef)
                  pedwarn (specs_loc, 0,

diff --git a/gcc/testsuite/gcc.dg/qual-return-10.c b/gcc/testsuite/gcc.dg/qual-return-10.c
new file mode 100644 (file)
index 0000000..c7dd6ad
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/qual-return-10.c
@@ -0,0 +1,12 @@
+/* Test qualifiers on function return types in C2X (C2X version of
+   qual-return-6.c): those qualifiers are now ignored for all purposes,
+   including _Atomic, but should still get warnings.  */
+/* { dg-do compile } */
+/* { dg-options "-std=c2x -Wignored-qualifiers" } */
+
+const int f1 (void); /* { dg-warning "qualifiers ignored" } */
+volatile int f2 (void) { return 0; } /* { dg-warning "qualifiers ignored" } */
+const volatile void f3 (void) { } /* { dg-warning "qualifiers ignored" } */
+const void f4 (void); /* { dg-warning "qualifiers ignored" } */
+_Atomic int f5 (void); /* { dg-warning "qualifiers ignored" } */
+_Atomic int f6 (void) { return 0; } /* { dg-warning "qualifiers ignored" } */

diff --git a/gcc/testsuite/gcc.dg/qual-return-9.c b/gcc/testsuite/gcc.dg/qual-return-9.c
new file mode 100644 (file)
index 0000000..7762782
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/qual-return-9.c
@@ -0,0 +1,32 @@
+/* Test qualifiers on function return types in C2X (C2X version of
+   qual-return-5.c): those qualifiers are now ignored for all purposes,
+   including _Atomic.  */
+/* { dg-do compile } */
+/* { dg-options "-std=c2x -pedantic-errors" } */
+
+int f1 (void);
+const int f1 (void);
+volatile int f1 (void) { return 0; }
+
+int *restrict f2 (void) { return 0; }
+int *f2 (void);
+
+const volatile long f3 (void);
+long f3 (void);
+
+const volatile void f4 (void) { }
+void f4 (void);
+
+_Atomic int f5 (void);
+int f5 (void);
+
+int f6 (void);
+_Atomic int f6 (void) { return 0; }
+
+/* The standard seems unclear regarding the case where restrict is
+   applied to a function return type that may not be
+   restrict-qualified; assume here that it is disallowed.  */
+restrict int f7 (void); /* { dg-error "restrict" } */
+
+typedef void FT (void);
+FT *restrict f8 (void); /* { dg-error "restrict" } */