2011-09-21 Paolo Carlini <paolo.carlini@oracle.com>

	* src/limits.cc: Replace everywhere __int128_t -> __int128, and
	__uint128_t -> unsigned __int128.
	* include/std/type_traits: Likewise.
	* include/std/limits: Likewise.
	* testsuite/18_support/numeric_limits/dr559.cc: Likewise.
	* testsuite/18_support/numeric_limits/lowest.cc: Likewise.
	* testsuite/18_support/numeric_limits/40856.cc: Likewise.
	* testsuite/18_support/numeric_limits/max_digits10.cc: Likewise.
	* testsuite/util/testsuite_common_types.h: Likewise.
	* testsuite/20_util/make_signed/requirements/typedefs-1.cc: Likewise.
	* testsuite/20_util/make_signed/requirements/typedefs-2.cc: Likewise.
	* testsuite/20_util/is_floating_point/value.cc: Likewise.
	* testsuite/20_util/make_unsigned/requirements/typedefs-1.cc: Likewise.
	* testsuite/20_util/make_unsigned/requirements/typedefs-2.cc: Likewise.
	* testsuite/20_util/is_signed/value.cc: Likewise.
	* testsuite/20_util/is_unsigned/value.cc: Likewise.
	* testsuite/20_util/is_integral/value.cc: Likewise.
	* config/abi/pre/gnu.ver: Likewise.
	* acinclude.m4: Likewise.
	* configure: Regenerate.
	* config.h.in: Likewise.

git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@179044 138bc75d-0d04-0410-961f-82ee72b054a4

diff --git a/libstdc++-v3/ChangeLog b/libstdc++-v3/ChangeLog
index 98f8b81a482cec85217be2021ab30d4718a9c350..16f7d052135f07f640f37a50ae696efbfa3c7130 100644 (file)
--- a/libstdc++-v3/ChangeLog
+++ b/libstdc++-v3/ChangeLog
@@ -1,3 +1,27 @@
+2011-09-21  Paolo Carlini  <paolo.carlini@oracle.com>
+
+       * src/limits.cc: Replace everywhere __int128_t -> __int128, and
+       __uint128_t -> unsigned __int128.
+       * include/std/type_traits: Likewise.
+       * include/std/limits: Likewise.
+       * testsuite/18_support/numeric_limits/dr559.cc: Likewise.
+       * testsuite/18_support/numeric_limits/lowest.cc: Likewise.
+       * testsuite/18_support/numeric_limits/40856.cc: Likewise.
+       * testsuite/18_support/numeric_limits/max_digits10.cc: Likewise.
+       * testsuite/util/testsuite_common_types.h: Likewise.
+       * testsuite/20_util/make_signed/requirements/typedefs-1.cc: Likewise.
+       * testsuite/20_util/make_signed/requirements/typedefs-2.cc: Likewise.
+       * testsuite/20_util/is_floating_point/value.cc: Likewise.
+       * testsuite/20_util/make_unsigned/requirements/typedefs-1.cc: Likewise.
+       * testsuite/20_util/make_unsigned/requirements/typedefs-2.cc: Likewise.
+       * testsuite/20_util/is_signed/value.cc: Likewise.
+       * testsuite/20_util/is_unsigned/value.cc: Likewise.
+       * testsuite/20_util/is_integral/value.cc: Likewise.
+       * config/abi/pre/gnu.ver: Likewise.
+       * acinclude.m4: Likewise.
+       * configure: Regenerate.
+       * config.h.in: Likewise.
+
 2011-09-19  Paolo Carlini  <paolo.carlini@oracle.com>
 
        PR libstdc++/40856

diff --git a/libstdc++-v3/acinclude.m4 b/libstdc++-v3/acinclude.m4
index 543f684f458d1f597e5f1db71d1f6f377ea62e59..ccfb2ce5e30a376cb9f5627f4356df43f956669d 100644 (file)
--- a/libstdc++-v3/acinclude.m4
+++ b/libstdc++-v3/acinclude.m4
@@ -2446,17 +2446,15 @@ template<typename T>
 
 int main()
 {
-  typename same<long, __int128_t>::type                i1;
-  typename same<unsigned long, __uint128_t>::type      u1;
-  typename same<long long, __int128_t>::type           i2;
-  typename same<unsigned long long, __uint128_t>::type u2;
+  typename same<long, __int128>::type                i1;
+  typename same<long long, __int128>::type           i2;
 }
 EOF
 
-    AC_MSG_CHECKING([for __int128_t and __uint128_t])
+    AC_MSG_CHECKING([for __int128])
     if AC_TRY_EVAL(ac_compile); then
       AC_DEFINE(_GLIBCXX_USE_INT128, 1,
-      [Define if __int128_t and __uint128_t types are supported on this host.])
+      [Define if __int128 is supported on this host.])
       enable_int128=yes
     else
       enable_int128=no

diff --git a/libstdc++-v3/config.h.in b/libstdc++-v3/config.h.in
index 19a40b8aed41b88f615e4fa6f8ba1a069ebf4790..82470c8cec9ef792014bb9a6d3944b829eea1b6f 100644 (file)
--- a/libstdc++-v3/config.h.in
+++ b/libstdc++-v3/config.h.in
@@ -816,7 +816,7 @@
 /* Define if get_nprocs is available in <sys/sysinfo.h>. */
 #undef _GLIBCXX_USE_GET_NPROCS
 
-/* Define if __int128_t and __uint128_t types are supported on this host. */
+/* Define if __int128 is supported on this host. */
 #undef _GLIBCXX_USE_INT128
 
 /* Define if LFS support is available. */

diff --git a/libstdc++-v3/config/abi/pre/gnu.ver b/libstdc++-v3/config/abi/pre/gnu.ver
index 7409e64f9d5c4fda153709ebad4fc36d95905cb6..5e5aa6a581011d7b439762dcd3f07cf46ce940e6 100644 (file)
--- a/libstdc++-v3/config/abi/pre/gnu.ver
+++ b/libstdc++-v3/config/abi/pre/gnu.ver
@@ -1298,7 +1298,7 @@ GLIBCXX_3.4.17 {
     # std::chrono::steady_clock::now()
     _ZNSt6chrono12steady_clock3nowEv;
 
-    # std::numeric_limits<__int128_t> and <__uint128_t>
+    # std::numeric_limits<__int128> and <unsigned __int128>
     _ZNSt14numeric_limitsInE*;
     _ZNSt14numeric_limitsIoE*;
 

diff --git a/libstdc++-v3/configure b/libstdc++-v3/configure
index 5eb278ac758da084ab42c8d5d4e8d5ed3ac4c3a2..423d447040914208328ae76176d9031938847377 100755 (executable)
--- a/libstdc++-v3/configure
+++ b/libstdc++-v3/configure
@@ -15561,15 +15561,13 @@ template<typename T>
 
 int main()
 {
-  typename same<long, __int128_t>::type                i1;
-  typename same<unsigned long, __uint128_t>::type      u1;
-  typename same<long long, __int128_t>::type           i2;
-  typename same<unsigned long long, __uint128_t>::type u2;
+  typename same<long, __int128>::type                i1;
+  typename same<long long, __int128>::type           i2;
 }
 EOF
 
-    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for __int128_t and __uint128_t" >&5
-$as_echo_n "checking for __int128_t and __uint128_t... " >&6; }
+    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for __int128" >&5
+$as_echo_n "checking for __int128... " >&6; }
     if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5
   (eval $ac_compile) 2>&5
   ac_status=$?
@@ -15587,7 +15585,7 @@ $as_echo "$enable_int128" >&6; }
     rm -f conftest*
 
     cat > conftest.$ac_ext << EOF
-#line 15590 "configure"
+#line 15588 "configure"
 template<typename T1, typename T2>
   struct same
   { typedef T2 type; };

diff --git a/libstdc++-v3/include/std/limits b/libstdc++-v3/include/std/limits
index fe6ee3da6eef6da51d2129d9e01a2819e68fbef1..67a5af4d804a81a601e8f338252a05e9f1f91199 100644 (file)
--- a/libstdc++-v3/include/std/limits
+++ b/libstdc++-v3/include/std/limits
@@ -1400,27 +1400,27 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     };
 
 #if !defined(__STRICT_ANSI__) && defined(_GLIBCXX_USE_INT128)
-  /// numeric_limits<__int128_t> specialization.
+  /// numeric_limits<__int128> specialization.
   template<>
-    struct numeric_limits<__int128_t>
+    struct numeric_limits<__int128>
     {
       static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
 
-      static _GLIBCXX_CONSTEXPR __int128_t
-      min() _GLIBCXX_USE_NOEXCEPT { return __glibcxx_min (__int128_t); }
+      static _GLIBCXX_CONSTEXPR __int128
+      min() _GLIBCXX_USE_NOEXCEPT { return __glibcxx_min (__int128); }
 
-      static _GLIBCXX_CONSTEXPR __int128_t
-      max() _GLIBCXX_USE_NOEXCEPT { return __glibcxx_max (__int128_t); }
+      static _GLIBCXX_CONSTEXPR __int128
+      max() _GLIBCXX_USE_NOEXCEPT { return __glibcxx_max (__int128); }
 
 #ifdef __GXX_EXPERIMENTAL_CXX0X__
-      static constexpr __int128_t
+      static constexpr __int128
       lowest() noexcept { return min(); }
 #endif
 
       static _GLIBCXX_USE_CONSTEXPR int digits
-       = __glibcxx_digits (__int128_t);
+       = __glibcxx_digits (__int128);
       static _GLIBCXX_USE_CONSTEXPR int digits10
-       = __glibcxx_digits10 (__int128_t);
+       = __glibcxx_digits10 (__int128);
 #ifdef __GXX_EXPERIMENTAL_CXX0X__
       static constexpr int max_digits10 = 0;
 #endif
@@ -1429,10 +1429,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
       static _GLIBCXX_USE_CONSTEXPR int radix = 2;
 
-      static _GLIBCXX_CONSTEXPR __int128_t
+      static _GLIBCXX_CONSTEXPR __int128
       epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; }
 
-      static _GLIBCXX_CONSTEXPR __int128_t
+      static _GLIBCXX_CONSTEXPR __int128
       round_error() _GLIBCXX_USE_NOEXCEPT { return 0; }
 
       static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
@@ -1447,21 +1447,21 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
        = denorm_absent;
       static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
 
-      static _GLIBCXX_CONSTEXPR __int128_t
+      static _GLIBCXX_CONSTEXPR __int128
       infinity() _GLIBCXX_USE_NOEXCEPT
-      { return static_cast<__int128_t>(0); }
+      { return static_cast<__int128>(0); }
 
-      static _GLIBCXX_CONSTEXPR __int128_t
+      static _GLIBCXX_CONSTEXPR __int128
       quiet_NaN() _GLIBCXX_USE_NOEXCEPT
-      { return static_cast<__int128_t>(0); }
+      { return static_cast<__int128>(0); }
       
-      static _GLIBCXX_CONSTEXPR __int128_t
+      static _GLIBCXX_CONSTEXPR __int128
       signaling_NaN() _GLIBCXX_USE_NOEXCEPT
-      { return static_cast<__int128_t>(0); }
+      { return static_cast<__int128>(0); }
       
-      static _GLIBCXX_CONSTEXPR __int128_t
+      static _GLIBCXX_CONSTEXPR __int128
       denorm_min() _GLIBCXX_USE_NOEXCEPT
-      { return static_cast<__int128_t>(0); }
+      { return static_cast<__int128>(0); }
 
       static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
       static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
@@ -1474,27 +1474,27 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
        = round_toward_zero;
     };
 
-  /// numeric_limits<__uint128_t> specialization.
+  /// numeric_limits<unsigned __int128> specialization.
   template<>
-    struct numeric_limits<__uint128_t>
+    struct numeric_limits<unsigned __int128>
     {
       static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
 
-      static _GLIBCXX_CONSTEXPR __uint128_t
+      static _GLIBCXX_CONSTEXPR unsigned __int128
       min() _GLIBCXX_USE_NOEXCEPT { return 0; }
 
-      static _GLIBCXX_CONSTEXPR __uint128_t
-      max() _GLIBCXX_USE_NOEXCEPT { return __glibcxx_max (__uint128_t); }
+      static _GLIBCXX_CONSTEXPR unsigned __int128
+      max() _GLIBCXX_USE_NOEXCEPT { return __glibcxx_max (unsigned __int128); }
 
 #ifdef __GXX_EXPERIMENTAL_CXX0X__
-      static constexpr __uint128_t
+      static constexpr unsigned __int128
       lowest() noexcept { return min(); }
 #endif
 
       static _GLIBCXX_USE_CONSTEXPR int digits
-       = __glibcxx_digits (__uint128_t);
+       = __glibcxx_digits (unsigned __int128);
       static _GLIBCXX_USE_CONSTEXPR int digits10
-       = __glibcxx_digits10 (__uint128_t);
+       = __glibcxx_digits10 (unsigned __int128);
 #ifdef __GXX_EXPERIMENTAL_CXX0X__
       static constexpr int max_digits10 = 0;
 #endif
@@ -1503,10 +1503,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
       static _GLIBCXX_USE_CONSTEXPR int radix = 2;
 
-      static _GLIBCXX_CONSTEXPR __uint128_t
+      static _GLIBCXX_CONSTEXPR unsigned __int128
       epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; }
 
-      static _GLIBCXX_CONSTEXPR __uint128_t
+      static _GLIBCXX_CONSTEXPR unsigned __int128
       round_error() _GLIBCXX_USE_NOEXCEPT { return 0; }
 
       static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
@@ -1521,21 +1521,21 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
        = denorm_absent;
       static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
 
-      static _GLIBCXX_CONSTEXPR __uint128_t
+      static _GLIBCXX_CONSTEXPR unsigned __int128
       infinity() _GLIBCXX_USE_NOEXCEPT
-      { return static_cast<__uint128_t>(0); }
+      { return static_cast<unsigned __int128>(0); }
 
-      static _GLIBCXX_CONSTEXPR __uint128_t
+      static _GLIBCXX_CONSTEXPR unsigned __int128
       quiet_NaN() _GLIBCXX_USE_NOEXCEPT
-      { return static_cast<__uint128_t>(0); }
+      { return static_cast<unsigned __int128>(0); }
 
-      static _GLIBCXX_CONSTEXPR __uint128_t
+      static _GLIBCXX_CONSTEXPR unsigned __int128
       signaling_NaN() _GLIBCXX_USE_NOEXCEPT
-      { return static_cast<__uint128_t>(0); }
+      { return static_cast<unsigned __int128>(0); }
 
-      static _GLIBCXX_CONSTEXPR __uint128_t
+      static _GLIBCXX_CONSTEXPR unsigned __int128
       denorm_min() _GLIBCXX_USE_NOEXCEPT
-      { return static_cast<__uint128_t>(0); }
+      { return static_cast<unsigned __int128>(0); }
 
       static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
       static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;

diff --git a/libstdc++-v3/include/std/type_traits b/libstdc++-v3/include/std/type_traits
index a03fb34e26e48a07571424434ded31cfae8fdea7..a0208590bb56777fff0312fe9899b134e83a0b7c 100644 (file)
--- a/libstdc++-v3/include/std/type_traits
+++ b/libstdc++-v3/include/std/type_traits
@@ -215,11 +215,11 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
 #if !defined(__STRICT_ANSI__) && defined(_GLIBCXX_USE_INT128)
   template<>
-    struct __is_integral_helper<__int128_t>
+    struct __is_integral_helper<__int128>
     : public true_type { };
 
   template<>
-    struct __is_integral_helper<__uint128_t>
+    struct __is_integral_helper<unsigned __int128>
     : public true_type { };
 #endif
 
@@ -1416,8 +1416,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
 #if !defined(__STRICT_ANSI__) && defined(_GLIBCXX_USE_INT128)
   template<>
-    struct __make_unsigned<__int128_t>
-    { typedef __uint128_t __type; };
+    struct __make_unsigned<__int128>
+    { typedef unsigned __int128 __type; };
 #endif
 
   // Select between integral and enum: not possible to be both.
@@ -1498,8 +1498,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
 #if !defined(__STRICT_ANSI__) && defined(_GLIBCXX_USE_INT128)
   template<>
-    struct __make_signed<__uint128_t>
-    { typedef __int128_t __type; };
+    struct __make_signed<unsigned __int128>
+    { typedef __int128 __type; };
 #endif
 
   // Select between integral and enum: not possible to be both.

diff --git a/libstdc++-v3/src/limits.cc b/libstdc++-v3/src/limits.cc
index a2fe468eca9b22e3313ed0db55e0d4cfd8b2f67d..cc6acc21ea7427685054c4a8848045fd02406826 100644 (file)
--- a/libstdc++-v3/src/limits.cc
+++ b/libstdc++-v3/src/limits.cc
@@ -390,53 +390,53 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
   const float_round_style numeric_limits<unsigned long long>::round_style;
 
 #if !defined(__STRICT_ANSI__) && defined(_GLIBCXX_USE_INT128)
-  const bool numeric_limits<__int128_t>::is_specialized;
-  const int  numeric_limits<__int128_t>::digits;
-  const int  numeric_limits<__int128_t>::digits10;
-  const int  numeric_limits<__int128_t>::max_digits10;
-  const bool numeric_limits<__int128_t>::is_signed;
-  const bool numeric_limits<__int128_t>::is_integer;
-  const bool numeric_limits<__int128_t>::is_exact;
-  const int  numeric_limits<__int128_t>::radix;
-  const int  numeric_limits<__int128_t>::min_exponent;
-  const int  numeric_limits<__int128_t>::min_exponent10;
-  const int  numeric_limits<__int128_t>::max_exponent;
-  const int  numeric_limits<__int128_t>::max_exponent10;
-  const bool numeric_limits<__int128_t>::has_infinity;
-  const bool numeric_limits<__int128_t>::has_quiet_NaN;
-  const bool numeric_limits<__int128_t>::has_signaling_NaN;
-  const float_denorm_style numeric_limits<__int128_t>::has_denorm;
-  const bool numeric_limits<__int128_t>::has_denorm_loss;
-  const bool numeric_limits<__int128_t>::is_iec559;
-  const bool numeric_limits<__int128_t>::is_bounded;
-  const bool numeric_limits<__int128_t>::is_modulo;
-  const bool numeric_limits<__int128_t>::traps;
-  const bool numeric_limits<__int128_t>::tinyness_before;
-  const float_round_style numeric_limits<__int128_t>::round_style;
-
-  const bool numeric_limits<__uint128_t>::is_specialized;
-  const int  numeric_limits<__uint128_t>::digits;
-  const int  numeric_limits<__uint128_t>::digits10;
-  const int  numeric_limits<__uint128_t>::max_digits10;
-  const bool numeric_limits<__uint128_t>::is_signed;
-  const bool numeric_limits<__uint128_t>::is_integer;
-  const bool numeric_limits<__uint128_t>::is_exact;
-  const int  numeric_limits<__uint128_t>::radix;
-  const int  numeric_limits<__uint128_t>::min_exponent;
-  const int  numeric_limits<__uint128_t>::min_exponent10;
-  const int  numeric_limits<__uint128_t>::max_exponent;
-  const int  numeric_limits<__uint128_t>::max_exponent10;
-  const bool numeric_limits<__uint128_t>::has_infinity;
-  const bool numeric_limits<__uint128_t>::has_quiet_NaN;
-  const bool numeric_limits<__uint128_t>::has_signaling_NaN;
-  const float_denorm_style numeric_limits<__uint128_t>::has_denorm;
-  const bool numeric_limits<__uint128_t>::has_denorm_loss;
-  const bool numeric_limits<__uint128_t>::is_iec559;
-  const bool numeric_limits<__uint128_t>::is_bounded;
-  const bool numeric_limits<__uint128_t>::is_modulo;
-  const bool numeric_limits<__uint128_t>::traps;
-  const bool numeric_limits<__uint128_t>::tinyness_before;
-  const float_round_style numeric_limits<__uint128_t>::round_style;
+  const bool numeric_limits<__int128>::is_specialized;
+  const int  numeric_limits<__int128>::digits;
+  const int  numeric_limits<__int128>::digits10;
+  const int  numeric_limits<__int128>::max_digits10;
+  const bool numeric_limits<__int128>::is_signed;
+  const bool numeric_limits<__int128>::is_integer;
+  const bool numeric_limits<__int128>::is_exact;
+  const int  numeric_limits<__int128>::radix;
+  const int  numeric_limits<__int128>::min_exponent;
+  const int  numeric_limits<__int128>::min_exponent10;
+  const int  numeric_limits<__int128>::max_exponent;
+  const int  numeric_limits<__int128>::max_exponent10;
+  const bool numeric_limits<__int128>::has_infinity;
+  const bool numeric_limits<__int128>::has_quiet_NaN;
+  const bool numeric_limits<__int128>::has_signaling_NaN;
+  const float_denorm_style numeric_limits<__int128>::has_denorm;
+  const bool numeric_limits<__int128>::has_denorm_loss;
+  const bool numeric_limits<__int128>::is_iec559;
+  const bool numeric_limits<__int128>::is_bounded;
+  const bool numeric_limits<__int128>::is_modulo;
+  const bool numeric_limits<__int128>::traps;
+  const bool numeric_limits<__int128>::tinyness_before;
+  const float_round_style numeric_limits<__int128>::round_style;
+
+  const bool numeric_limits<unsigned __int128>::is_specialized;
+  const int  numeric_limits<unsigned __int128>::digits;
+  const int  numeric_limits<unsigned __int128>::digits10;
+  const int  numeric_limits<unsigned __int128>::max_digits10;
+  const bool numeric_limits<unsigned __int128>::is_signed;
+  const bool numeric_limits<unsigned __int128>::is_integer;
+  const bool numeric_limits<unsigned __int128>::is_exact;
+  const int  numeric_limits<unsigned __int128>::radix;
+  const int  numeric_limits<unsigned __int128>::min_exponent;
+  const int  numeric_limits<unsigned __int128>::min_exponent10;
+  const int  numeric_limits<unsigned __int128>::max_exponent;
+  const int  numeric_limits<unsigned __int128>::max_exponent10;
+  const bool numeric_limits<unsigned __int128>::has_infinity;
+  const bool numeric_limits<unsigned __int128>::has_quiet_NaN;
+  const bool numeric_limits<unsigned __int128>::has_signaling_NaN;
+  const float_denorm_style numeric_limits<unsigned __int128>::has_denorm;
+  const bool numeric_limits<unsigned __int128>::has_denorm_loss;
+  const bool numeric_limits<unsigned __int128>::is_iec559;
+  const bool numeric_limits<unsigned __int128>::is_bounded;
+  const bool numeric_limits<unsigned __int128>::is_modulo;
+  const bool numeric_limits<unsigned __int128>::traps;
+  const bool numeric_limits<unsigned __int128>::tinyness_before;
+  const float_round_style numeric_limits<unsigned __int128>::round_style;
 #endif
 
   // float

diff --git a/libstdc++-v3/testsuite/18_support/numeric_limits/40856.cc b/libstdc++-v3/testsuite/18_support/numeric_limits/40856.cc
index b39456bc9e4a0ee1149eb7638de390b9379f724b..d4dff3a14a8a1088d43a597474b358261b2ae383 100644 (file)
--- a/libstdc++-v3/testsuite/18_support/numeric_limits/40856.cc
+++ b/libstdc++-v3/testsuite/18_support/numeric_limits/40856.cc
@@ -22,6 +22,7 @@
 
 // libstdc++/40856 
 #ifdef _GLIBCXX_USE_INT128
-static_assert(std::numeric_limits<__int128_t>::is_specialized == true, "");
-static_assert(std::numeric_limits<__uint128_t>::is_specialized == true, "");
+static_assert(std::numeric_limits<__int128>::is_specialized == true, "");
+static_assert(std::numeric_limits<unsigned __int128>::is_specialized == true,
+             "");
 #endif

diff --git a/libstdc++-v3/testsuite/18_support/numeric_limits/dr559.cc b/libstdc++-v3/testsuite/18_support/numeric_limits/dr559.cc
index d6b78d52c90a680205f48710ca8480984c36a27a..05e4e173d1a3ad7abf7ea12c843b282286c55e8e 100644 (file)
--- a/libstdc++-v3/testsuite/18_support/numeric_limits/dr559.cc
+++ b/libstdc++-v3/testsuite/18_support/numeric_limits/dr559.cc
@@ -97,8 +97,8 @@ int main()
   do_test<unsigned long long>();
   // GNU Extensions.
 #ifdef _GLIBCXX_USE_INT128
-  do_test<__int128_t>();
-  do_test<__uint128_t>();
+  do_test<__int128>();
+  do_test<unsigned __int128>();
 #endif
   do_test<float>();
   do_test<double>();

diff --git a/libstdc++-v3/testsuite/18_support/numeric_limits/lowest.cc b/libstdc++-v3/testsuite/18_support/numeric_limits/lowest.cc
index ab964ef98b99a7b9e2c931b6c3ff64e1318c038d..0b410b55fe0e0b8da1ab74a39707a1e8f5c153ea 100644 (file)
--- a/libstdc++-v3/testsuite/18_support/numeric_limits/lowest.cc
+++ b/libstdc++-v3/testsuite/18_support/numeric_limits/lowest.cc
@@ -74,8 +74,8 @@ void test01()
 
   // GNU Extensions.
 #ifdef _GLIBCXX_USE_INT128
-  do_test<__int128_t>();
-  do_test<__uint128_t>();
+  do_test<__int128>();
+  do_test<unsigned __int128>();
 #endif
 
   do_test<float>();

diff --git a/libstdc++-v3/testsuite/18_support/numeric_limits/max_digits10.cc b/libstdc++-v3/testsuite/18_support/numeric_limits/max_digits10.cc
index 571b4032b005920a5ea077a58a773e3ba9e12c81..d4858244ee776fa050d58a5470b09bf2cb82881f 100644 (file)
--- a/libstdc++-v3/testsuite/18_support/numeric_limits/max_digits10.cc
+++ b/libstdc++-v3/testsuite/18_support/numeric_limits/max_digits10.cc
@@ -49,8 +49,8 @@ test01()
 
   // GNU Extensions.
 #ifdef _GLIBCXX_USE_INT128
-  VERIFY( std::numeric_limits<__int128_t>::max_digits10 == 0 );
-  VERIFY( std::numeric_limits<__uint128_t>::max_digits10 == 0 );
+  VERIFY( std::numeric_limits<__int128>::max_digits10 == 0 );
+  VERIFY( std::numeric_limits<unsigned __int128>::max_digits10 == 0 );
 #endif
 
   const int f_max_digits10 = (2 + std::numeric_limits<float>::digits

diff --git a/libstdc++-v3/testsuite/20_util/is_floating_point/value.cc b/libstdc++-v3/testsuite/20_util/is_floating_point/value.cc
index 8f11924ae2578e81e28c3845c5f398403775ba05..df9cfcaa5bc97f563e725318976e2f826b53d3e6 100644 (file)
--- a/libstdc++-v3/testsuite/20_util/is_floating_point/value.cc
+++ b/libstdc++-v3/testsuite/20_util/is_floating_point/value.cc
@@ -53,8 +53,8 @@ void test01()
 #endif
 
 #ifdef _GLIBCXX_USE_INT128
-  VERIFY( (test_category<is_floating_point, __int128_t>(false)) );
-  VERIFY( (test_category<is_floating_point, __uint128_t>(false)) );
+  VERIFY( (test_category<is_floating_point, __int128>(false)) );
+  VERIFY( (test_category<is_floating_point, unsigned __int128>(false)) );
 #endif
 
   // Sanity check.

diff --git a/libstdc++-v3/testsuite/20_util/is_integral/value.cc b/libstdc++-v3/testsuite/20_util/is_integral/value.cc
index 04a91091ad09308d7a8c102593d723241a3d1b8c..d085f92358ff17f09499003b5978e09ff97a2a31 100644 (file)
--- a/libstdc++-v3/testsuite/20_util/is_integral/value.cc
+++ b/libstdc++-v3/testsuite/20_util/is_integral/value.cc
@@ -53,8 +53,8 @@ void test01()
 
   // GNU Extensions.
 #ifdef _GLIBCXX_USE_INT128
-  VERIFY( (test_category<is_integral, __int128_t>(true)) );
-  VERIFY( (test_category<is_integral, __uint128_t>(true)) );
+  VERIFY( (test_category<is_integral, __int128>(true)) );
+  VERIFY( (test_category<is_integral, unsigned __int128>(true)) );
 #endif
 
 #ifdef _GLIBCXX_USE_FLOAT128

diff --git a/libstdc++-v3/testsuite/20_util/is_signed/value.cc b/libstdc++-v3/testsuite/20_util/is_signed/value.cc
index f407b42a9a92c3aabe148ffbd33b0c9bef1e6322..d6394ff503734b73a18570660fc6773d98ad54d0 100644 (file)
--- a/libstdc++-v3/testsuite/20_util/is_signed/value.cc
+++ b/libstdc++-v3/testsuite/20_util/is_signed/value.cc
@@ -51,8 +51,8 @@ void test01()
 
   // GNU Extensions.
 #ifdef _GLIBCXX_USE_INT128
-  VERIFY( (test_category<is_signed, __int128_t>(true)) );
-  VERIFY( (test_category<is_signed, __uint128_t>(false)) );
+  VERIFY( (test_category<is_signed, __int128>(true)) );
+  VERIFY( (test_category<is_signed, unsigned __int128>(false)) );
 #endif
 
 #ifdef _GLIBCXX_USE_FLOAT128

diff --git a/libstdc++-v3/testsuite/20_util/is_unsigned/value.cc b/libstdc++-v3/testsuite/20_util/is_unsigned/value.cc
index 7628c99365329a11f7cb8dd93c1275d6c23c6057..41e05871a7b95bb4d0b4f32c5588495825dba128 100644 (file)
--- a/libstdc++-v3/testsuite/20_util/is_unsigned/value.cc
+++ b/libstdc++-v3/testsuite/20_util/is_unsigned/value.cc
@@ -51,8 +51,8 @@ void test01()
 
   // GNU Extensions.
 #ifdef _GLIBCXX_USE_INT128
-  VERIFY( (test_category<is_unsigned, __uint128_t>(true)) );
-  VERIFY( (test_category<is_unsigned, __int128_t>(false)) );
+  VERIFY( (test_category<is_unsigned, unsigned __int128>(true)) );
+  VERIFY( (test_category<is_unsigned, __int128>(false)) );
 #endif
 
 #ifdef _GLIBCXX_USE_FLOAT128

diff --git a/libstdc++-v3/testsuite/20_util/make_signed/requirements/typedefs-1.cc b/libstdc++-v3/testsuite/20_util/make_signed/requirements/typedefs-1.cc
index 28d17af8ad373e44d0899958485b9bf1b94433fb..73cfddccb3c2a5bcbf9efc18a06a78db01f83ae9 100644 (file)
--- a/libstdc++-v3/testsuite/20_util/make_signed/requirements/typedefs-1.cc
+++ b/libstdc++-v3/testsuite/20_util/make_signed/requirements/typedefs-1.cc
@@ -59,11 +59,11 @@ void test01()
 
   // GNU Extensions.
 #ifdef _GLIBCXX_USE_INT128
-  typedef make_signed<__uint128_t>::type       test25_type;
-  VERIFY( (is_same<test25_type, __int128_t>::value) );
+  typedef make_signed<unsigned __int128>::type  test25_type;
+  VERIFY( (is_same<test25_type, __int128>::value) );
 
-  typedef make_signed<__int128_t>::type        test26_type;
-  VERIFY( (is_same<test26_type, __int128_t>::value) );
+  typedef make_signed<__int128>::type                  test26_type;
+  VERIFY( (is_same<test26_type, __int128>::value) );
 #endif
 }
 

diff --git a/libstdc++-v3/testsuite/20_util/make_signed/requirements/typedefs-2.cc b/libstdc++-v3/testsuite/20_util/make_signed/requirements/typedefs-2.cc
index 209ea61013c69b7a7ef8db01d30b6172d1565e32..adf3af4abd8cbbdb1d772b5da5a8cd1e45a282b0 100644 (file)
--- a/libstdc++-v3/testsuite/20_util/make_signed/requirements/typedefs-2.cc
+++ b/libstdc++-v3/testsuite/20_util/make_signed/requirements/typedefs-2.cc
@@ -58,11 +58,11 @@ void test01()
 
   // GNU Extensions.
 #ifdef _GLIBCXX_USE_INT128
-  typedef make_signed<__uint128_t>::type       test25_type;
-  VERIFY( (is_same<test25_type, __int128_t>::value) );
+  typedef make_signed<unsigned __int128>::type  test25_type;
+  VERIFY( (is_same<test25_type, __int128>::value) );
 
-  typedef make_signed<__int128_t>::type        test26_type;
-  VERIFY( (is_same<test26_type, __int128_t>::value) );
+  typedef make_signed<__int128>::type                  test26_type;
+  VERIFY( (is_same<test26_type, __int128>::value) );
 #endif
 }
 

diff --git a/libstdc++-v3/testsuite/20_util/make_unsigned/requirements/typedefs-1.cc b/libstdc++-v3/testsuite/20_util/make_unsigned/requirements/typedefs-1.cc
index 021ac7e2f4ffc0dbe0821481710b10d7b149c4e7..44399851a19c2e412827ae3688ee3854f7a54906 100644 (file)
--- a/libstdc++-v3/testsuite/20_util/make_unsigned/requirements/typedefs-1.cc
+++ b/libstdc++-v3/testsuite/20_util/make_unsigned/requirements/typedefs-1.cc
@@ -54,17 +54,17 @@ void test01()
 
   // Chapter 48, chapter 20. Smallest rank such that new unsigned type
   // same size.
-  typedef make_unsigned<test_enum>::type       test24_type;
+  typedef make_unsigned<test_enum>::type        test24_type;
   VERIFY( is_unsigned<test24_type>::value );
   VERIFY( sizeof(test24_type) == sizeof(test_enum) );
 
   // GNU Extensions.
 #ifdef _GLIBCXX_USE_INT128
-  typedef make_unsigned<__uint128_t>::type     test25_type;
-  VERIFY( (is_same<test25_type, __uint128_t>::value) );
+  typedef make_unsigned<unsigned __int128>::type test25_type;
+  VERIFY( (is_same<test25_type, unsigned __int128>::value) );
 
-  typedef make_unsigned<__int128_t>::type      test26_type;
-  VERIFY( (is_same<test26_type, __uint128_t>::value) );
+  typedef make_unsigned<__int128>::type         test26_type;
+  VERIFY( (is_same<test26_type, unsigned __int128>::value) );
 #endif
 }
 

diff --git a/libstdc++-v3/testsuite/20_util/make_unsigned/requirements/typedefs-2.cc b/libstdc++-v3/testsuite/20_util/make_unsigned/requirements/typedefs-2.cc
index da572624135b030aca1eb5a41af804eb6a93ab60..a1465d39fb24893bb1abc953452d7845e8d8c505 100644 (file)
--- a/libstdc++-v3/testsuite/20_util/make_unsigned/requirements/typedefs-2.cc
+++ b/libstdc++-v3/testsuite/20_util/make_unsigned/requirements/typedefs-2.cc
@@ -53,16 +53,16 @@ void test01()
   VERIFY( (is_same<test23_type, volatile wchar_t>::value) );
 #endif
 
-  typedef make_unsigned<test_enum>::type       test24_type;
+  typedef make_unsigned<test_enum>::type         test24_type;
   VERIFY( (is_same<test24_type, unsigned short>::value) );
 
   // GNU Extensions.
 #ifdef _GLIBCXX_USE_INT128
-  typedef make_unsigned<__uint128_t>::type     test25_type;
-  VERIFY( (is_same<test25_type, __uint128_t>::value) );
+  typedef make_unsigned<unsigned __int128>::type  test25_type;
+  VERIFY( (is_same<test25_type, unsigned __int128>::value) );
 
-  typedef make_unsigned<__int128_t>::type      test26_type;
-  VERIFY( (is_same<test26_type, __uint128_t>::value) );
+  typedef make_unsigned<__int128>::type          test26_type;
+  VERIFY( (is_same<test26_type, unsigned __int128>::value) );
 #endif
 }
 

diff --git a/libstdc++-v3/testsuite/util/testsuite_common_types.h b/libstdc++-v3/testsuite/util/testsuite_common_types.h
index 68c3252472b5d15e7e9fbd1235dbaba2337e6f46..03be0acac252e0740506ded35df1c12b77f5d470 100644 (file)
--- a/libstdc++-v3/testsuite/util/testsuite_common_types.h
+++ b/libstdc++-v3/testsuite/util/testsuite_common_types.h
@@ -305,8 +305,8 @@ namespace __gnu_test
     typedef char16_t           a14;
     typedef char32_t           a15;
 # if !defined(__STRICT_ANSI__) && defined(_GLIBCXX_USE_INT128)
-    typedef __int128_t          a16;
-    typedef __uint128_t         a17;
+    typedef __int128            a16;
+    typedef unsigned __int128   a17;
 
     typedef node<_GLIBCXX_TYPELIST_CHAIN17(a1, a2, a3, a4, a5, a6, a7, a8, a9, 
                                           a10, a11, a12, a13, a14, a15,
@@ -317,8 +317,8 @@ namespace __gnu_test
 # endif
 #else
 # if !defined(__STRICT_ANSI__) && defined(_GLIBCXX_USE_INT128)
-    typedef __int128_t          a14;
-    typedef __uint128_t         a15;
+    typedef __int128            a14;
+    typedef unsigned __int128   a15;
 
     typedef node<_GLIBCXX_TYPELIST_CHAIN15(a1, a2, a3, a4, a5, a6, a7, a8, a9, 
                                           a10, a11, a12, a13, a14, a15)> type;