libstdc++: Use __extension__ instead of diagnostic pragmas

This reverts c1676651b6c417e8f2b276a28199d76943834277 and uses the
__extension__ keyword to prevent pedantic warnings instead of diagnostic
pragmas.

This also adds the __extension__ keyword in <limits> and <bits/random.h>
where there are some more warnings that I missed in the previous commit.

Signed-off-by: Jonathan Wakely <jwakely@redhat.com>

libstdc++-v3/ChangeLog:

	* include/bits/cpp_type_traits.h (__INT_N): Use __extension__
	instead of diagnostic pragmas.
	* include/bits/functional_hash.h: Likewise.
	* include/bits/iterator_concepts.h (__is_signed_int128)
	(__is_unsigned_int128): Likewise.
	* include/bits/max_size_type.h (__max_size_type): Likewise.
	(numeric_limits<__max_size_type>): Likewise.
	* include/bits/std_abs.h (abs): Likewise.
	* include/bits/stl_algobase.h (__size_to_integer): Likewise.
	* include/bits/uniform_int_dist.h (uniform_int_distribution):
	Likewise.
	* include/ext/numeric_traits.h (_GLIBCXX_INT_N_TRAITS):
	Likewise.
	* include/std/type_traits (__is_integral_helper<INT_N>)
	(__is_signed_integer, __is_unsigned_integer)
	(__make_unsigned<INT_N>, __make_signed<INT_N>): Likewise.
	* include/std/limits (__INT_N): Add __extension__ keyword.
	* include/bits/random.h (_Select_uint_least_t)
	(random_device): Likewise.

11 files changed, 54 insertions, 73 deletions

diff --git a/libstdc++-v3/include/bits/cpp_type_traits.h b/libstdc++-v3/include/bits/cpp_type_traits.h
index 8f8dd81..d946220 100644
--- a/libstdc++-v3/include/bits/cpp_type_traits.h
+++ b/libstdc++-v3/include/bits/cpp_type_traits.h
@@ -253,12 +253,14 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     };
 
 #define __INT_N(TYPE) 			\
+  __extension__				\
   template<>				\
     struct __is_integer<TYPE>		\
     {					\
       enum { __value = 1 };		\
       typedef __true_type __type;	\
     };					\
+  __extension__				\
   template<>				\
     struct __is_integer<unsigned TYPE>	\
     {					\
@@ -266,9 +268,6 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       typedef __true_type __type;	\
     };
 
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wpedantic"
-
 #ifdef __GLIBCXX_TYPE_INT_N_0
 __INT_N(__GLIBCXX_TYPE_INT_N_0)
 #endif
@@ -282,8 +281,6 @@ __INT_N(__GLIBCXX_TYPE_INT_N_2)
 __INT_N(__GLIBCXX_TYPE_INT_N_3)
 #endif
 
-#pragma GCC diagnostic pop
-
 #undef __INT_N
 
   //
diff --git a/libstdc++-v3/include/bits/functional_hash.h b/libstdc++-v3/include/bits/functional_hash.h
index 78e3644..919faba 100644
--- a/libstdc++-v3/include/bits/functional_hash.h
+++ b/libstdc++-v3/include/bits/functional_hash.h
@@ -171,28 +171,31 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
   /// Explicit specialization for unsigned long long.
   _Cxx_hashtable_define_trivial_hash(unsigned long long)
 
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wpedantic"
-
 #ifdef __GLIBCXX_TYPE_INT_N_0
+  __extension__
   _Cxx_hashtable_define_trivial_hash(__GLIBCXX_TYPE_INT_N_0)
+  __extension__
   _Cxx_hashtable_define_trivial_hash(__GLIBCXX_TYPE_INT_N_0 unsigned)
 #endif
 #ifdef __GLIBCXX_TYPE_INT_N_1
+  __extension__
   _Cxx_hashtable_define_trivial_hash(__GLIBCXX_TYPE_INT_N_1)
+  __extension__
   _Cxx_hashtable_define_trivial_hash(__GLIBCXX_TYPE_INT_N_1 unsigned)
 #endif
 #ifdef __GLIBCXX_TYPE_INT_N_2
+  __extension__
   _Cxx_hashtable_define_trivial_hash(__GLIBCXX_TYPE_INT_N_2)
+  __extension__
   _Cxx_hashtable_define_trivial_hash(__GLIBCXX_TYPE_INT_N_2 unsigned)
 #endif
 #ifdef __GLIBCXX_TYPE_INT_N_3
+  __extension__
   _Cxx_hashtable_define_trivial_hash(__GLIBCXX_TYPE_INT_N_3)
+  __extension__
   _Cxx_hashtable_define_trivial_hash(__GLIBCXX_TYPE_INT_N_3 unsigned)
 #endif
 
-#pragma GCC diagnostic pop
-
 #undef _Cxx_hashtable_define_trivial_hash
 
   struct _Hash_impl
diff --git a/libstdc++-v3/include/bits/iterator_concepts.h b/libstdc++-v3/include/bits/iterator_concepts.h
index 97c0b80..9c28ebf 100644
--- a/libstdc++-v3/include/bits/iterator_concepts.h
+++ b/libstdc++-v3/include/bits/iterator_concepts.h
@@ -553,9 +553,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     class __max_diff_type;
     class __max_size_type;
 
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wpedantic"
-
+    __extension__
     template<typename _Tp>
       concept __is_signed_int128
 #if __SIZEOF_INT128__
@@ -564,6 +562,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	= false;
 #endif
 
+    __extension__
     template<typename _Tp>
       concept __is_unsigned_int128
 #if __SIZEOF_INT128__
@@ -572,8 +571,6 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	= false;
 #endif
 
-#pragma GCC diagnostic pop
-
     template<typename _Tp>
       concept __cv_bool = same_as<const volatile _Tp, const volatile bool>;
 
diff --git a/libstdc++-v3/include/bits/max_size_type.h b/libstdc++-v3/include/bits/max_size_type.h
index 24237cc..298a929 100644
--- a/libstdc++-v3/include/bits/max_size_type.h
+++ b/libstdc++-v3/include/bits/max_size_type.h
@@ -417,10 +417,8 @@ namespace ranges
 #endif
 
 #if __SIZEOF_INT128__
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wpedantic"
+      __extension__
       using __rep = unsigned __int128;
-#pragma GCC diagnostic pop
 #else
       using __rep = unsigned long long;
 #endif
@@ -774,10 +772,7 @@ namespace ranges
       static constexpr bool is_integer = true;
       static constexpr bool is_exact = true;
 #if __SIZEOF_INT128__
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wpedantic"
-      static_assert(same_as<_Sp::__rep, unsigned __int128>);
-#pragma GCC diagnostic pop
+      static_assert(__extension__ same_as<_Sp::__rep, __uint128_t>);
       static constexpr int digits = 129;
 #else
       static_assert(same_as<_Sp::__rep, unsigned long long>);
diff --git a/libstdc++-v3/include/bits/random.h b/libstdc++-v3/include/bits/random.h
index 9e0359b..6d0e154 100644
--- a/libstdc++-v3/include/bits/random.h
+++ b/libstdc++-v3/include/bits/random.h
@@ -101,7 +101,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 #if __SIZEOF_INT128__ > __SIZEOF_LONG_LONG__
     template<int __s>
       struct _Select_uint_least_t<__s, 1>
-      { typedef unsigned __int128 type; };
+      { __extension__ typedef unsigned __int128 type; };
 #endif
 
     // Assume a != 0, a < m, c < m, x < m.
@@ -1663,7 +1663,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
     void _M_init(const char*, size_t); // not exported from the shared library
 
-    union
+    __extension__ union
     {
       struct
       {
diff --git a/libstdc++-v3/include/bits/std_abs.h b/libstdc++-v3/include/bits/std_abs.h
index c65ebb6..908d6bc 100644
--- a/libstdc++-v3/include/bits/std_abs.h
+++ b/libstdc++-v3/include/bits/std_abs.h
@@ -80,35 +80,30 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
   { return __builtin_fabsl(__x); }
 #endif
 
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wpedantic"
-
 #if defined(__GLIBCXX_TYPE_INT_N_0)
-  inline _GLIBCXX_CONSTEXPR __GLIBCXX_TYPE_INT_N_0
+  __extension__ inline _GLIBCXX_CONSTEXPR __GLIBCXX_TYPE_INT_N_0
   abs(__GLIBCXX_TYPE_INT_N_0 __x) { return __x >= 0 ? __x : -__x; }
 #endif
 #if defined(__GLIBCXX_TYPE_INT_N_1)
-  inline _GLIBCXX_CONSTEXPR __GLIBCXX_TYPE_INT_N_1
+  __extension__ inline _GLIBCXX_CONSTEXPR __GLIBCXX_TYPE_INT_N_1
   abs(__GLIBCXX_TYPE_INT_N_1 __x) { return __x >= 0 ? __x : -__x; }
 #endif
 #if defined(__GLIBCXX_TYPE_INT_N_2)
-  inline _GLIBCXX_CONSTEXPR __GLIBCXX_TYPE_INT_N_2
+  __extension__ inline _GLIBCXX_CONSTEXPR __GLIBCXX_TYPE_INT_N_2
   abs(__GLIBCXX_TYPE_INT_N_2 __x) { return __x >= 0 ? __x : -__x; }
 #endif
 #if defined(__GLIBCXX_TYPE_INT_N_3)
-  inline _GLIBCXX_CONSTEXPR __GLIBCXX_TYPE_INT_N_3
+  __extension__ inline _GLIBCXX_CONSTEXPR __GLIBCXX_TYPE_INT_N_3
   abs(__GLIBCXX_TYPE_INT_N_3 __x) { return __x >= 0 ? __x : -__x; }
 #endif
 
 #if !defined(__STRICT_ANSI__) && defined(_GLIBCXX_USE_FLOAT128)
-  inline _GLIBCXX_CONSTEXPR
+  __extension__ inline _GLIBCXX_CONSTEXPR
   __float128
   abs(__float128 __x)
   { return __x < 0 ? -__x : __x; }
 #endif
 
-#pragma GCC diagnostic pop
-
 _GLIBCXX_END_NAMESPACE_VERSION
 } // namespace
 } // extern "C"++"
diff --git a/libstdc++-v3/include/bits/stl_algobase.h b/libstdc++-v3/include/bits/stl_algobase.h
index 7f920db..d0c4962 100644
--- a/libstdc++-v3/include/bits/stl_algobase.h
+++ b/libstdc++-v3/include/bits/stl_algobase.h
@@ -1013,36 +1013,31 @@ _GLIBCXX_END_NAMESPACE_CONTAINER
   inline _GLIBCXX_CONSTEXPR unsigned long long
   __size_to_integer(unsigned long long __n) { return __n; }
 
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wpedantic"
-
 #if defined(__GLIBCXX_TYPE_INT_N_0)
-  inline _GLIBCXX_CONSTEXPR __GLIBCXX_TYPE_INT_N_0
+  __extension__ inline _GLIBCXX_CONSTEXPR __GLIBCXX_TYPE_INT_N_0
   __size_to_integer(__GLIBCXX_TYPE_INT_N_0 __n) { return __n; }
-  inline _GLIBCXX_CONSTEXPR unsigned __GLIBCXX_TYPE_INT_N_0
+  __extension__ inline _GLIBCXX_CONSTEXPR unsigned __GLIBCXX_TYPE_INT_N_0
   __size_to_integer(unsigned __GLIBCXX_TYPE_INT_N_0 __n) { return __n; }
 #endif
 #if defined(__GLIBCXX_TYPE_INT_N_1)
-  inline _GLIBCXX_CONSTEXPR __GLIBCXX_TYPE_INT_N_1
+  __extension__ inline _GLIBCXX_CONSTEXPR __GLIBCXX_TYPE_INT_N_1
   __size_to_integer(__GLIBCXX_TYPE_INT_N_1 __n) { return __n; }
-  inline _GLIBCXX_CONSTEXPR unsigned __GLIBCXX_TYPE_INT_N_1
+  __extension__ inline _GLIBCXX_CONSTEXPR unsigned __GLIBCXX_TYPE_INT_N_1
   __size_to_integer(unsigned __GLIBCXX_TYPE_INT_N_1 __n) { return __n; }
 #endif
 #if defined(__GLIBCXX_TYPE_INT_N_2)
-  inline _GLIBCXX_CONSTEXPR __GLIBCXX_TYPE_INT_N_2
+  __extension__ inline _GLIBCXX_CONSTEXPR __GLIBCXX_TYPE_INT_N_2
   __size_to_integer(__GLIBCXX_TYPE_INT_N_2 __n) { return __n; }
-  inline _GLIBCXX_CONSTEXPR unsigned __GLIBCXX_TYPE_INT_N_2
+  __extension__ inline _GLIBCXX_CONSTEXPR unsigned __GLIBCXX_TYPE_INT_N_2
   __size_to_integer(unsigned __GLIBCXX_TYPE_INT_N_2 __n) { return __n; }
 #endif
 #if defined(__GLIBCXX_TYPE_INT_N_3)
-  inline _GLIBCXX_CONSTEXPR unsigned __GLIBCXX_TYPE_INT_N_3
+  __extension__ inline _GLIBCXX_CONSTEXPR unsigned __GLIBCXX_TYPE_INT_N_3
   __size_to_integer(__GLIBCXX_TYPE_INT_N_3 __n) { return __n; }
-  inline _GLIBCXX_CONSTEXPR __GLIBCXX_TYPE_INT_N_3
+  __extension__ inline _GLIBCXX_CONSTEXPR __GLIBCXX_TYPE_INT_N_3
   __size_to_integer(unsigned __GLIBCXX_TYPE_INT_N_3 __n) { return __n; }
 #endif
 
-#pragma GCC diagnostic pop
-
   inline _GLIBCXX_CONSTEXPR long long
   __size_to_integer(float __n) { return (long long)__n; }
   inline _GLIBCXX_CONSTEXPR long long
@@ -1050,7 +1045,7 @@ _GLIBCXX_END_NAMESPACE_CONTAINER
   inline _GLIBCXX_CONSTEXPR long long
   __size_to_integer(long double __n) { return (long long)__n; }
 #if !defined(__STRICT_ANSI__) && defined(_GLIBCXX_USE_FLOAT128)
-  inline _GLIBCXX_CONSTEXPR long long
+  __extension__ inline _GLIBCXX_CONSTEXPR long long
   __size_to_integer(__float128 __n) { return (long long)__n; }
 #endif
 
diff --git a/libstdc++-v3/include/bits/uniform_int_dist.h b/libstdc++-v3/include/bits/uniform_int_dist.h
index 8ee3345..622b1fe 100644
--- a/libstdc++-v3/include/bits/uniform_int_dist.h
+++ b/libstdc++-v3/include/bits/uniform_int_dist.h
@@ -299,17 +299,15 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
 #if defined __UINT64_TYPE__ && defined __UINT32_TYPE__
 #if __SIZEOF_INT128__
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wpedantic"
 	    if _GLIBCXX17_CONSTEXPR (__urngrange == __UINT64_MAX__)
 	      {
 		// __urng produces values that use exactly 64-bits,
 		// so use 128-bit integers to downscale to desired range.
 		__UINT64_TYPE__ __u64erange = __uerange;
-		__ret = _S_nd<unsigned __int128>(__urng, __u64erange);
+		__ret = __extension__ _S_nd<unsigned __int128>(__urng,
+							       __u64erange);
 	      }
 	    else
-#pragma GCC diagnostic pop
 #endif
 	    if _GLIBCXX17_CONSTEXPR (__urngrange == __UINT32_MAX__)
 	      {
diff --git a/libstdc++-v3/include/ext/numeric_traits.h b/libstdc++-v3/include/ext/numeric_traits.h
index 0dc1bc6..3ef0989 100644
--- a/libstdc++-v3/include/ext/numeric_traits.h
+++ b/libstdc++-v3/include/ext/numeric_traits.h
@@ -93,12 +93,14 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
   // Enable __numeric_traits_integer for types where the __is_integer_nonstrict
   // primary template doesn't give the right answer.
 #define _GLIBCXX_INT_N_TRAITS(T, WIDTH)			\
+  __extension__						\
   template<> struct __is_integer_nonstrict<T>		\
   {							\
     enum { __value = 1 };				\
     typedef std::__true_type __type;			\
     enum { __width = WIDTH };				\
   };							\
+  __extension__						\
   template<> struct __is_integer_nonstrict<unsigned T>	\
   {							\
     enum { __value = 1 };				\
@@ -123,12 +125,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 #endif
 
 #if defined __STRICT_ANSI__ && defined __SIZEOF_INT128__
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wpedantic"
   // In strict modes __is_integer<__int128> is false,
   // but we still want to define __numeric_traits_integer<__int128>.
   _GLIBCXX_INT_N_TRAITS(__int128, 128)
-#pragma GCC diagnostic pop
 #endif
 
 #undef _GLIBCXX_INT_N_TRAITS
diff --git a/libstdc++-v3/include/std/limits b/libstdc++-v3/include/std/limits
index f2c2072..79aff3d 100644
--- a/libstdc++-v3/include/std/limits
+++ b/libstdc++-v3/include/std/limits
@@ -1478,6 +1478,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     };
 
 #define __INT_N(TYPE, BITSIZE, EXT, UEXT)				\
+  __extension__								\
   template<>								\
     struct numeric_limits<TYPE>						\
     {									\
@@ -1546,6 +1547,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	= round_toward_zero; 						\
     }; 									\
 									\
+  __extension__								\
   template<>								\
     struct numeric_limits<unsigned TYPE>				\
     {									\
diff --git a/libstdc++-v3/include/std/type_traits b/libstdc++-v3/include/std/type_traits
index 8d9c639..15ec83a 100644
--- a/libstdc++-v3/include/std/type_traits
+++ b/libstdc++-v3/include/std/type_traits
@@ -347,48 +347,52 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     struct __is_integral_helper<unsigned long long>
     : public true_type { };
 
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wpedantic"
-
   // Conditionalizing on __STRICT_ANSI__ here will break any port that
   // uses one of these types for size_t.
 #if defined(__GLIBCXX_TYPE_INT_N_0)
+  __extension__
   template<>
     struct __is_integral_helper<__GLIBCXX_TYPE_INT_N_0>
     : public true_type { };
 
+  __extension__
   template<>
     struct __is_integral_helper<unsigned __GLIBCXX_TYPE_INT_N_0>
     : public true_type { };
 #endif
 #if defined(__GLIBCXX_TYPE_INT_N_1)
+  __extension__
   template<>
     struct __is_integral_helper<__GLIBCXX_TYPE_INT_N_1>
     : public true_type { };
 
+  __extension__
   template<>
     struct __is_integral_helper<unsigned __GLIBCXX_TYPE_INT_N_1>
     : public true_type { };
 #endif
 #if defined(__GLIBCXX_TYPE_INT_N_2)
+  __extension__
   template<>
     struct __is_integral_helper<__GLIBCXX_TYPE_INT_N_2>
     : public true_type { };
 
+  __extension__
   template<>
     struct __is_integral_helper<unsigned __GLIBCXX_TYPE_INT_N_2>
     : public true_type { };
 #endif
 #if defined(__GLIBCXX_TYPE_INT_N_3)
+  __extension__
   template<>
     struct __is_integral_helper<__GLIBCXX_TYPE_INT_N_3>
     : public true_type { };
 
+  __extension__
   template<>
     struct __is_integral_helper<unsigned __GLIBCXX_TYPE_INT_N_3>
     : public true_type { };
 #endif
-#pragma GCC diagnostic pop
   /// @endcond
 
   /// is_integral
@@ -621,10 +625,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
   template<typename _Tp, typename... _Types>
     using __is_one_of = __or_<is_same<_Tp, _Types>...>;
 
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wpedantic"
-
   // Check if a type is one of the signed integer types.
+  __extension__
   template<typename _Tp>
     using __is_signed_integer = __is_one_of<__remove_cv_t<_Tp>,
 	  signed char, signed short, signed int, signed long,
@@ -644,6 +646,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	  >;
 
   // Check if a type is one of the unsigned integer types.
+  __extension__
   template<typename _Tp>
     using __is_unsigned_integer = __is_one_of<__remove_cv_t<_Tp>,
 	  unsigned char, unsigned short, unsigned int, unsigned long,
@@ -661,7 +664,6 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	  , unsigned __GLIBCXX_TYPE_INT_N_3
 #endif
 	  >;
-#pragma GCC diagnostic pop
 
   // Check if a type is one of the signed or unsigned integer types.
   template<typename _Tp>
@@ -1725,32 +1727,31 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     struct __make_unsigned<long long>
     { typedef unsigned long long __type; };
 
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wpedantic"
-
 #if defined(__GLIBCXX_TYPE_INT_N_0)
+  __extension__
   template<>
     struct __make_unsigned<__GLIBCXX_TYPE_INT_N_0>
     { typedef unsigned __GLIBCXX_TYPE_INT_N_0 __type; };
 #endif
 #if defined(__GLIBCXX_TYPE_INT_N_1)
+  __extension__
   template<>
     struct __make_unsigned<__GLIBCXX_TYPE_INT_N_1>
     { typedef unsigned __GLIBCXX_TYPE_INT_N_1 __type; };
 #endif
 #if defined(__GLIBCXX_TYPE_INT_N_2)
+  __extension__
   template<>
     struct __make_unsigned<__GLIBCXX_TYPE_INT_N_2>
     { typedef unsigned __GLIBCXX_TYPE_INT_N_2 __type; };
 #endif
 #if defined(__GLIBCXX_TYPE_INT_N_3)
+  __extension__
   template<>
     struct __make_unsigned<__GLIBCXX_TYPE_INT_N_3>
     { typedef unsigned __GLIBCXX_TYPE_INT_N_3 __type; };
 #endif
 
-#pragma GCC diagnostic pop
-
   // Select between integral and enum: not possible to be both.
   template<typename _Tp,
 	   bool _IsInt = is_integral<_Tp>::value,
@@ -1886,32 +1887,31 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     struct __make_signed<unsigned long long>
     { typedef signed long long __type; };
 
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wpedantic"
-
 #if defined(__GLIBCXX_TYPE_INT_N_0)
+  __extension__
   template<>
     struct __make_signed<unsigned __GLIBCXX_TYPE_INT_N_0>
     { typedef __GLIBCXX_TYPE_INT_N_0 __type; };
 #endif
 #if defined(__GLIBCXX_TYPE_INT_N_1)
+  __extension__
   template<>
     struct __make_signed<unsigned __GLIBCXX_TYPE_INT_N_1>
     { typedef __GLIBCXX_TYPE_INT_N_1 __type; };
 #endif
 #if defined(__GLIBCXX_TYPE_INT_N_2)
+  __extension__
   template<>
     struct __make_signed<unsigned __GLIBCXX_TYPE_INT_N_2>
     { typedef __GLIBCXX_TYPE_INT_N_2 __type; };
 #endif
 #if defined(__GLIBCXX_TYPE_INT_N_3)
+  __extension__
   template<>
     struct __make_signed<unsigned __GLIBCXX_TYPE_INT_N_3>
     { typedef __GLIBCXX_TYPE_INT_N_3 __type; };
 #endif
 
-#pragma GCC diagnostic pop
-
   // Select between integral and enum: not possible to be both.
   template<typename _Tp,
 	   bool _IsInt = is_integral<_Tp>::value,