diff --git gcc/c-family/c.opt gcc/c-family/c.opt
index 087eabd..4848399 100644
--- gcc/c-family/c.opt
+++ gcc/c-family/c.opt
@@ -295,6 +295,10 @@ Wc90-c99-compat
 C ObjC Var(warn_c90_c99_compat) Init(-1) Warning
 Warn about features not present in ISO C90, but present in ISO C99
 
+Wc99-c11-compat
+C ObjC Var(warn_c99_c11_compat) Init(-1) Warning
+Warn about features not present in ISO C99, but present in ISO C11
+
 Wc++-compat
 C ObjC Var(warn_cxx_compat) Warning
 Warn about C constructs that are not in the common subset of C and C++
diff --git gcc/c/c-decl.c gcc/c/c-decl.c
index 138b014..39852d5 100644
--- gcc/c/c-decl.c
+++ gcc/c/c-decl.c
@@ -538,6 +538,8 @@ static tree grokdeclarator (const struct c_declarator *,
 			    bool *, enum deprecated_states);
 static tree grokparms (struct c_arg_info *, bool);
 static void layout_array_type (tree);
+static void warn_defaults_to (location_t, int, const char *, ...)
+    ATTRIBUTE_GCC_DIAG(3,4);
 
 /* T is a statement.  Add it to the statement-tree.  This is the
    C/ObjC version--C++ has a slightly different version of this
@@ -1844,12 +1846,9 @@ diagnose_mismatched_decls (tree newdecl, tree olddecl,
 		 newdecl);
 	  locate_old_decl (olddecl);
 	}
-      else if (pedantic && !flag_isoc11)
-	{
-	  pedwarn (input_location, OPT_Wpedantic,
-		   "redefinition of typedef %q+D", newdecl);
-	  locate_old_decl (olddecl);
-	}
+      else if (pedwarn_c99 (input_location, OPT_Wpedantic,
+			    "redefinition of typedef %q+D", newdecl))
+	locate_old_decl (olddecl);
 
       return true;
     }
@@ -4941,6 +4940,22 @@ warn_variable_length_array (tree name, tree size)
     }
 }
 
+/* Print warning about defaulting to int if necessary.  */
+
+static void
+warn_defaults_to (location_t location, int opt, const char *gmsgid, ...)
+{
+  diagnostic_info diagnostic;
+  va_list ap;
+
+  va_start (ap, gmsgid);
+  diagnostic_set_info (&diagnostic, gmsgid, &ap, location,
+                       flag_isoc99 ? DK_PEDWARN : DK_WARNING);
+  diagnostic.option_index = opt;
+  report_diagnostic (&diagnostic);
+  va_end (ap);
+}
+
 /* Given declspecs and a declarator,
    determine the name and type of the object declared
    and construct a ..._DECL node for it.
@@ -5117,12 +5132,12 @@ grokdeclarator (const struct c_declarator *declarator,
       else
 	{
 	  if (name)
-	    pedwarn_c99 (loc, flag_isoc99 ? 0 : OPT_Wimplicit_int,
-			 "type defaults to %<int%> in declaration of %qE",
-			 name);
+	    warn_defaults_to (loc, flag_isoc99 ? 0 : OPT_Wimplicit_int,
+			      "type defaults to %<int%> in declaration "
+			      "of %qE", name);
 	  else
-	    pedwarn_c99 (input_location, flag_isoc99 ? 0 : OPT_Wimplicit_int,
-			 "type defaults to %<int%> in type name");
+	    warn_defaults_to (loc, flag_isoc99 ? 0 : OPT_Wimplicit_int,
+			      "type defaults to %<int%> in type name");
 	}
     }
 
@@ -6249,15 +6264,12 @@ grokdeclarator (const struct c_declarator *declarator,
 	      DECL_DECLARED_INLINE_P (decl) = 1;
 	    if (declspecs->noreturn_p)
 	      {
-		if (!flag_isoc11)
-		  {
-		    if (flag_isoc99)
-		      pedwarn (loc, OPT_Wpedantic,
+		if (flag_isoc99)
+		  pedwarn_c99 (loc, OPT_Wpedantic,
 			       "ISO C99 does not support %<_Noreturn%>");
-		    else
-		      pedwarn (loc, OPT_Wpedantic,
+		else
+		  pedwarn_c99 (loc, OPT_Wpedantic,
 			       "ISO C90 does not support %<_Noreturn%>");
-		  }
 		TREE_THIS_VOLATILE (decl) = 1;
 	      }
 	  }
@@ -6964,15 +6976,12 @@ grokfield (location_t loc,
 	  pedwarn (loc, 0, "declaration does not declare anything");
 	  return NULL_TREE;
 	}
-      if (!flag_isoc11)
-	{
-	  if (flag_isoc99)
-	    pedwarn (loc, OPT_Wpedantic,
+      if (flag_isoc99)
+	pedwarn_c99 (loc, OPT_Wpedantic,
 		     "ISO C99 doesn%'t support unnamed structs/unions");
-	  else
-	    pedwarn (loc, OPT_Wpedantic,
+      else
+	pedwarn_c99 (loc, OPT_Wpedantic,
 		     "ISO C90 doesn%'t support unnamed structs/unions");
-	}
     }
 
   value = grokdeclarator (declarator, declspecs, FIELD, false,
@@ -7913,9 +7922,10 @@ start_function (struct c_declspecs *declspecs, struct c_declarator *declarator,
     }
 
   if (warn_about_return_type)
-    pedwarn_c99 (loc, flag_isoc99 ? 0
-		 : (warn_return_type ? OPT_Wreturn_type : OPT_Wimplicit_int),
-		 "return type defaults to %<int%>");
+    warn_defaults_to (loc, flag_isoc99 ? 0
+			   : (warn_return_type ? OPT_Wreturn_type
+			      : OPT_Wimplicit_int),
+		      "return type defaults to %<int%>");
 
   /* Make the init_value nonzero so pushdecl knows this is not tentative.
      error_mark_node is replaced below (in pop_scope) with the BLOCK.  */
@@ -9893,14 +9903,14 @@ declspecs_add_scspec (source_location loc,
 	     identifier in the implementation namespace; only diagnose
 	     it for the C11 spelling because of existing code using
 	     the other spelling.  */
-	  if (!flag_isoc11 && !specs->thread_gnu_p)
+	  if (!specs->thread_gnu_p)
 	    {
 	      if (flag_isoc99)
-		pedwarn (loc, OPT_Wpedantic,
-			 "ISO C99 does not support %qE", scspec);
+		pedwarn_c99 (loc, OPT_Wpedantic,
+			     "ISO C99 does not support %qE", scspec);
 	      else
-		pedwarn (loc, OPT_Wpedantic,
-			 "ISO C90 does not support %qE", scspec);
+		pedwarn_c99 (loc, OPT_Wpedantic,
+			     "ISO C90 does not support %qE", scspec);
 	    }
 	  specs->locations[cdw_thread] = loc;
 	}
diff --git gcc/c/c-errors.c gcc/c/c-errors.c
index 10a6c95..9c592b2 100644
--- gcc/c/c-errors.c
+++ gcc/c/c-errors.c
@@ -29,20 +29,40 @@ along with GCC; see the file COPYING3.  If not see
 #include "diagnostic.h"
 #include "opts.h"
 
-/* Issue an ISO C99 pedantic warning MSGID.  */
+/* Issue an ISO C99 pedantic warning MSGID if -pedantic outside C11 mode,
+   otherwise issue warning MSGID if -Wc99-c11-compat is specified.
+   This function is supposed to be used for matters that are allowed in
+   ISO C11 but not supported in ISO C99, thus we explicitly don't pedwarn
+   when C11 is specified.  */
 
-void
+bool
 pedwarn_c99 (location_t location, int opt, const char *gmsgid, ...)
 {
   diagnostic_info diagnostic;
   va_list ap;
+  bool warned = false;
 
   va_start (ap, gmsgid);
-  diagnostic_set_info (&diagnostic, gmsgid, &ap, location,
-		       flag_isoc99 ? DK_PEDWARN : DK_WARNING);
-  diagnostic.option_index = opt;
-  report_diagnostic (&diagnostic);
+  /* If desired, issue the C99/C11 compat warning, which is more specific
+     than -pedantic.  */
+  if (warn_c99_c11_compat > 0)
+    {
+      diagnostic_set_info (&diagnostic, gmsgid, &ap, location, DK_WARNING);
+      diagnostic.option_index = OPT_Wc99_c11_compat;
+      warned = report_diagnostic (&diagnostic);
+    }
+  /* -Wno-c99-c11-compat suppresses even the pedwarns.  */
+  else if (warn_c99_c11_compat == 0)
+    ;
+  /* For -pedantic outside C11, issue a pedwarn.  */
+  else if (pedantic && !flag_isoc11)
+    {
+      diagnostic_set_info (&diagnostic, gmsgid, &ap, location, DK_PEDWARN);
+      diagnostic.option_index = opt;
+      warned = report_diagnostic (&diagnostic);
+    }
   va_end (ap);
+  return warned;
 }
 
 /* Issue an ISO C90 pedantic warning MSGID if -pedantic outside C99 mode,
diff --git gcc/c/c-parser.c gcc/c/c-parser.c
index 454f279..0193e7f 100644
--- gcc/c/c-parser.c
+++ gcc/c/c-parser.c
@@ -1076,7 +1076,10 @@ disable_extension_diagnostics (void)
 	     /* warn_c90_c99_compat has three states: -1/0/1, so we must
 		play tricks to properly restore it.  */
 	     | (warn_c90_c99_compat << 7)
-	     | ((warn_c90_c99_compat == -1) << 8));
+	     | ((warn_c90_c99_compat == -1) << 8)
+	     /* Similarly for warn_c99_c11_compat.  */
+	     | (warn_c99_c11_compat << 9)
+	     | ((warn_c99_c11_compat == -1) << 10));
   cpp_opts->cpp_pedantic = pedantic = 0;
   warn_pointer_arith = 0;
   cpp_opts->cpp_warn_traditional = warn_traditional = 0;
@@ -1085,6 +1088,7 @@ disable_extension_diagnostics (void)
   warn_cxx_compat = 0;
   warn_overlength_strings = 0;
   warn_c90_c99_compat = 0;
+  warn_c99_c11_compat = 0;
   return ret;
 }
 
@@ -1103,6 +1107,7 @@ restore_extension_diagnostics (int flags)
   warn_overlength_strings = (flags >> 6) & 1;
   /* See above for why is this needed.  */
   warn_c90_c99_compat = (flags >> 7) & 1 ? ((flags >> 8) & 1 ? -1 : 1) : 0;
+  warn_c99_c11_compat = (flags >> 9) & 1 ? ((flags >> 10) & 1 ? -1 : 1) : 0;
 }
 
 /* Possibly kinds of declarator to parse.  */
@@ -2009,15 +2014,12 @@ c_parser_static_assert_declaration_no_semi (c_parser *parser)
 
   gcc_assert (c_parser_next_token_is_keyword (parser, RID_STATIC_ASSERT));
   assert_loc = c_parser_peek_token (parser)->location;
-  if (!flag_isoc11)
-    {
-      if (flag_isoc99)
-	pedwarn (assert_loc, OPT_Wpedantic,
+  if (flag_isoc99)
+    pedwarn_c99 (assert_loc, OPT_Wpedantic,
 		 "ISO C99 does not support %<_Static_assert%>");
-      else
-	pedwarn (assert_loc, OPT_Wpedantic,
+  else
+    pedwarn_c99 (assert_loc, OPT_Wpedantic,
 		 "ISO C90 does not support %<_Static_assert%>");
-    }
   c_parser_consume_token (parser);
   if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
     return;
@@ -2382,15 +2384,12 @@ c_parser_declspecs (c_parser *parser, struct c_declspecs *specs,
 	     correct lvalue-to-rvalue conversions.  */
 	  if (flag_openmp)
 	    sorry ("%<_Atomic%> with OpenMP");
-	  if (!flag_isoc11)
-	    {
-	      if (flag_isoc99)
-		pedwarn (loc, OPT_Wpedantic,
+	  if (flag_isoc99)
+	    pedwarn_c99 (loc, OPT_Wpedantic,
 			 "ISO C99 does not support the %<_Atomic%> qualifier");
-	      else
-		pedwarn (loc, OPT_Wpedantic,
+	  else
+	    pedwarn_c99 (loc, OPT_Wpedantic,
 			 "ISO C90 does not support the %<_Atomic%> qualifier");
-	    }
 	  attrs_ok = true;
 	  tree value;
 	  value = c_parser_peek_token (parser)->value;
@@ -3055,15 +3054,12 @@ c_parser_alignas_specifier (c_parser * parser)
   location_t loc = c_parser_peek_token (parser)->location;
   gcc_assert (c_parser_next_token_is_keyword (parser, RID_ALIGNAS));
   c_parser_consume_token (parser);
-  if (!flag_isoc11)
-    {
-      if (flag_isoc99)
-	pedwarn (loc, OPT_Wpedantic,
+  if (flag_isoc99)
+    pedwarn_c99 (loc, OPT_Wpedantic,
 		 "ISO C99 does not support %<_Alignas%>");
-      else
-	pedwarn (loc, OPT_Wpedantic,
+  else
+    pedwarn_c99 (loc, OPT_Wpedantic,
 		 "ISO C90 does not support %<_Alignas%>");
-    }
   if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
     return ret;
   if (c_parser_next_tokens_start_typename (parser, cla_prefer_id))
@@ -6579,14 +6575,14 @@ c_parser_alignof_expression (c_parser *parser)
   /* A diagnostic is not required for the use of this identifier in
      the implementation namespace; only diagnose it for the C11
      spelling because of existing code using the other spellings.  */
-  if (!flag_isoc11 && is_c11_alignof)
+  if (is_c11_alignof)
     {
       if (flag_isoc99)
-	pedwarn (loc, OPT_Wpedantic, "ISO C99 does not support %qE",
-		 alignof_spelling);
+	pedwarn_c99 (loc, OPT_Wpedantic, "ISO C99 does not support %qE",
+		     alignof_spelling);
       else
-	pedwarn (loc, OPT_Wpedantic, "ISO C90 does not support %qE",
-		 alignof_spelling);
+	pedwarn_c99 (loc, OPT_Wpedantic, "ISO C90 does not support %qE",
+		     alignof_spelling);
     }
   c_parser_consume_token (parser);
   c_inhibit_evaluation_warnings++;
@@ -6745,15 +6741,12 @@ c_parser_generic_selection (c_parser *parser)
   gcc_assert (c_parser_next_token_is_keyword (parser, RID_GENERIC));
   generic_loc = c_parser_peek_token (parser)->location;
   c_parser_consume_token (parser);
-  if (!flag_isoc11)
-    {
-      if (flag_isoc99)
-	pedwarn (generic_loc, OPT_Wpedantic,
+  if (flag_isoc99)
+    pedwarn_c99 (generic_loc, OPT_Wpedantic,
 		 "ISO C99 does not support %<_Generic%>");
-      else
-	pedwarn (generic_loc, OPT_Wpedantic,
+  else
+    pedwarn_c99 (generic_loc, OPT_Wpedantic,
 		 "ISO C90 does not support %<_Generic%>");
-    }
 
   if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
     return error_expr;
diff --git gcc/c/c-tree.h gcc/c/c-tree.h
index 55e71dc..6004d50 100644
--- gcc/c/c-tree.h
+++ gcc/c/c-tree.h
@@ -678,7 +678,7 @@ extern tree c_check_omp_declare_reduction_r (tree *, int *, void *);
 /* In c-errors.c */
 extern void pedwarn_c90 (location_t, int opt, const char *, ...)
     ATTRIBUTE_GCC_DIAG(3,4);
-extern void pedwarn_c99 (location_t, int opt, const char *, ...)
+extern bool pedwarn_c99 (location_t, int opt, const char *, ...)
     ATTRIBUTE_GCC_DIAG(3,4);
 
 #endif /* ! GCC_C_TREE_H */
diff --git gcc/c/c-typeck.c gcc/c/c-typeck.c
index 0ed92c6..b1eac34 100644
--- gcc/c/c-typeck.c
+++ gcc/c/c-typeck.c
@@ -9220,9 +9220,12 @@ c_finish_return (location_t loc, tree retval, tree origtype)
       if ((warn_return_type || flag_isoc99)
 	  && valtype != 0 && TREE_CODE (valtype) != VOID_TYPE)
 	{
-	  pedwarn_c99 (loc, flag_isoc99 ? 0 : OPT_Wreturn_type,
-		       "%<return%> with no value, in "
-		       "function returning non-void");
+	  if (flag_isoc99)
+	    pedwarn (loc, 0, "%<return%> with no value, in "
+		     "function returning non-void");
+	  else
+	    warning_at (loc, OPT_Wreturn_type, "%<return%> with no value, "
+			"in function returning non-void");
 	  no_warning = true;
 	}
     }
diff --git gcc/doc/invoke.texi gcc/doc/invoke.texi
index 91377fa..d0ef1a9 100644
--- gcc/doc/invoke.texi
+++ gcc/doc/invoke.texi
@@ -241,7 +241,7 @@ Objective-C and Objective-C++ Dialects}.
 -w  -Wextra  -Wall  -Waddress  -Waggregate-return  @gol
 -Waggressive-loop-optimizations -Warray-bounds @gol
 -Wno-attributes -Wno-builtin-macro-redefined @gol
--Wc90-c99-compat @gol
+-Wc90-c99-compat -Wc99-c11-compat @gol
 -Wc++-compat -Wc++11-compat -Wcast-align  -Wcast-qual  @gol
 -Wchar-subscripts -Wclobbered  -Wcomment -Wconditionally-supported  @gol
 -Wconversion -Wcoverage-mismatch -Wdate-time -Wdelete-incomplete -Wno-cpp  @gol
@@ -4527,6 +4527,16 @@ type, @code{bool} type, compound literals, designated initializers, and so
 on.  This option is independent of the standards mode.  Warnings are disabled
 in the expression that follows @code{__extension__}.
 
+@item -Wc99-c11-compat @r{(C and Objective-C only)}
+@opindex Wc99-c11-compat
+@opindex Wno-c99-c11-compat
+Warn about features not present in ISO C99, but present in ISO C11.
+For instance, warn about use of anonymous structures and unions,
+@code{_Atomic} type qualifier, @code{_Thread_local} storage-class specifier,
+@code{_Alignas} specifier, @code{Alignof} operator, @code{_Generic} keyword,
+and so on.  This option is independent of the standards mode.  Warnings are
+disabled in the expression that follows @code{__extension__}.
+
 @item -Wc++-compat @r{(C and Objective-C only)}
 Warn about ISO C constructs that are outside of the common subset of
 ISO C and ISO C++, e.g.@: request for implicit conversion from
diff --git gcc/testsuite/gcc.dg/Wc99-c11-compat-1.c gcc/testsuite/gcc.dg/Wc99-c11-compat-1.c
index e69de29..e31bf92 100644
--- gcc/testsuite/gcc.dg/Wc99-c11-compat-1.c
+++ gcc/testsuite/gcc.dg/Wc99-c11-compat-1.c
@@ -0,0 +1,18 @@
+/* { dg-do compile } */
+/* { dg-options "-std=gnu90 -pedantic-errors -Wc99-c11-compat" } */
+
+struct S { int i; struct { int a; }; }; /* { dg-warning "ISO C90 doesn.t support unnamed structs/unions" } */
+_Noreturn void foo (void); /* { dg-warning "ISO C90 does not support ._Noreturn." } */
+typedef int A;
+typedef int A; /* { dg-warning "redefinition of typedef .A." } */
+_Thread_local int i; /* { dg-warning "ISO C90 does not support ._Thread_local." } */
+_Static_assert (1, "foo"); /* { dg-warning "ISO C90 does not support ._Static_assert." } */
+_Atomic int a; /* { dg-warning "ISO C90 does not support the ._Atomic. qualifier" } */
+_Alignas (int) int aa; /* { dg-warning "ISO C90 does not support ._Alignas." } */
+enum e { E = _Alignof (double) }; /* { dg-warning "ISO C90 does not support ._Alignof." } */
+
+void
+fn (int n)
+{
+  _Generic (n, int: 0); /* { dg-warning "ISO C90 does not support ._Generic." } */
+}
diff --git gcc/testsuite/gcc.dg/Wc99-c11-compat-2.c gcc/testsuite/gcc.dg/Wc99-c11-compat-2.c
index e69de29..9ef21e7 100644
--- gcc/testsuite/gcc.dg/Wc99-c11-compat-2.c
+++ gcc/testsuite/gcc.dg/Wc99-c11-compat-2.c
@@ -0,0 +1,18 @@
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99 -pedantic-errors -Wc99-c11-compat" } */
+
+struct S { int i; struct { int a; }; }; /* { dg-warning "ISO C99 doesn.t support unnamed structs/unions" } */
+_Noreturn void foo (void); /* { dg-warning "ISO C99 does not support ._Noreturn." } */
+typedef int A;
+typedef int A; /* { dg-warning "redefinition of typedef .A." } */
+_Thread_local int i; /* { dg-warning "ISO C99 does not support ._Thread_local." } */
+_Static_assert (1, "foo"); /* { dg-warning "ISO C99 does not support ._Static_assert." } */
+_Atomic int a; /* { dg-warning "ISO C99 does not support the ._Atomic. qualifier" } */
+_Alignas (int) int aa; /* { dg-warning "ISO C99 does not support ._Alignas." } */
+enum e { E = _Alignof (double) }; /* { dg-warning "ISO C99 does not support ._Alignof." } */
+
+void
+fn (int n)
+{
+  _Generic (n, int: 0); /* { dg-warning "ISO C99 does not support ._Generic." } */
+}
diff --git gcc/testsuite/gcc.dg/Wc99-c11-compat-3.c gcc/testsuite/gcc.dg/Wc99-c11-compat-3.c
index e69de29..64e24f8 100644
--- gcc/testsuite/gcc.dg/Wc99-c11-compat-3.c
+++ gcc/testsuite/gcc.dg/Wc99-c11-compat-3.c
@@ -0,0 +1,18 @@
+/* { dg-do compile } */
+/* { dg-options "-std=gnu11 -pedantic-errors -Wc99-c11-compat" } */
+
+struct S { int i; struct { int a; }; }; /* { dg-warning "ISO C99 doesn.t support unnamed structs/unions" } */
+_Noreturn void foo (void); /* { dg-warning "ISO C99 does not support ._Noreturn." } */
+typedef int A;
+typedef int A; /* { dg-warning "redefinition of typedef .A." } */
+_Thread_local int i; /* { dg-warning "ISO C99 does not support ._Thread_local." } */
+_Static_assert (1, "foo"); /* { dg-warning "ISO C99 does not support ._Static_assert." } */
+_Atomic int a; /* { dg-warning "ISO C99 does not support the ._Atomic. qualifier" } */
+_Alignas (int) int aa; /* { dg-warning "ISO C99 does not support ._Alignas." } */
+enum e { E = _Alignof (double) }; /* { dg-warning "ISO C99 does not support ._Alignof." } */
+
+void
+fn (int n)
+{
+  _Generic (n, int: 0); /* { dg-warning "ISO C99 does not support ._Generic." } */
+}
diff --git gcc/testsuite/gcc.dg/Wc99-c11-compat-4.c gcc/testsuite/gcc.dg/Wc99-c11-compat-4.c
index e69de29..511ccee 100644
--- gcc/testsuite/gcc.dg/Wc99-c11-compat-4.c
+++ gcc/testsuite/gcc.dg/Wc99-c11-compat-4.c
@@ -0,0 +1,18 @@
+/* { dg-do compile } */
+/* { dg-options "-std=gnu99 -pedantic-errors -Wno-c99-c11-compat" } */
+
+struct S { int i; struct { int a; }; };
+_Noreturn void foo (void);
+typedef int A;
+typedef int A;
+_Thread_local int i;
+_Static_assert (1, "foo");
+_Atomic int a;
+_Alignas (int) int aa;
+enum e { E = _Alignof (double) };
+
+void
+fn (int n)
+{
+  _Generic (n, int: 0);
+}
diff --git gcc/testsuite/gcc.dg/Wc99-c11-compat-5.c gcc/testsuite/gcc.dg/Wc99-c11-compat-5.c
index e69de29..ce9698c 100644
--- gcc/testsuite/gcc.dg/Wc99-c11-compat-5.c
+++ gcc/testsuite/gcc.dg/Wc99-c11-compat-5.c
@@ -0,0 +1,18 @@
+/* { dg-do compile } */
+/* { dg-options "-std=gnu11 -Wc99-c11-compat" } */
+
+__extension__ struct S { int i; struct { int a; }; };
+__extension__ _Noreturn void foo (void);
+typedef int A;
+__extension__ typedef int A;
+__extension__ _Thread_local int i;
+__extension__ _Static_assert (1, "foo");
+__extension__ _Atomic int a;
+__extension__ _Alignas (int) int aa;
+enum e { E = __extension__ _Alignof (double) };
+
+void
+fn (int n)
+{
+  __extension__ _Generic (n, int: 0);
+}
