From patchwork Tue May 16 09:11:31 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Jonathan Wakely X-Patchwork-Id: 94573 Return-Path: Delivered-To: ouuuleilei@gmail.com Received: by 2002:a59:b0ea:0:b0:3b6:4342:cba0 with SMTP id b10csp285425vqo; Tue, 16 May 2023 02:15:17 -0700 (PDT) X-Google-Smtp-Source: ACHHUZ6JTaLtMhKbuTYTCY4Io0VO/9hLrFifwzvtyIEGbZiwnXcw0RJo6IkG1crexKdM669743SS X-Received: by 2002:a05:6402:685:b0:50b:f7b2:79d0 with SMTP id f5-20020a056402068500b0050bf7b279d0mr30118103edy.31.1684228516974; Tue, 16 May 2023 02:15:16 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1684228516; cv=none; d=google.com; s=arc-20160816; b=SF3lVhgwzPMtq97/4v2wXHEGx0xgoG+DKm0LNq/ec2NcxHoyI/QV9oMGvNOD+uLQqI pSFgEh/b/3u22Re8uPDgnUuwSHohqB+l4vAHKRabfRn9dtMDt2FpDn6834EZx6Rj2EF5 OR8F6XDF1HtMWdAsvdiln5ZI1zmXL2s1vQzKrjpJ2PHWD8Gw3TBDoFMUrXTi3E4IjQj8 /2JTL2af4y+61gyo1/R+3QDn3uHiVaIgBjIbPWAj9PgL+L1rOs7L9JdbLau0FS37vcYr lXFDSPHLpAE4T1QXiuAv/Rq4uv7csntaKIBZ4ajsCM/3zAbMCkpH850eLA6djUt/iEK0 JxKg== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=sender:errors-to:reply-to:from:list-subscribe:list-help:list-post :list-archive:list-unsubscribe:list-id:precedence :content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:to:dmarc-filter:delivered-to:dkim-signature :dkim-filter; bh=Uvm39XoZ+HcnyXjyEqY0pWX7Ikc0WjN9zpjOriS6738=; b=NUUy5gAwOcDF9eUvckTH+6EgrTCxHV3kmzqIzCSl5lFWyED4b6XPgi7dxoMw3a9fUC +BScsyAiaej0ZGG8IkYCe0F3tPF4uKKDIt3ugaOLiLt/mOhKhuf96H05GTm72F47577U qZyGKyprDrmB7/y8AymuyPiiyvjjqc6iV1c386sXaNg5b+g5oQ6a5vJF3hGk7J9n4fVh cWSmLxO81UYkZTvy4EnYo3uTCVyU1AxsIfTk48+PTmDCxZNvtmG+CMSWjCGNyg4LeYxz HkX9TJpYgO8BVFfCzmj7cjS9axy0/y/hEIjsF9QpJIaI06dCofLbeX4DwqtCglT3EYf7 EIBg== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@gcc.gnu.org header.s=default header.b=Q4OczPg1; spf=pass (google.com: domain of gcc-patches-bounces+ouuuleilei=gmail.com@gcc.gnu.org designates 2620:52:3:1:0:246e:9693:128c as permitted sender) smtp.mailfrom="gcc-patches-bounces+ouuuleilei=gmail.com@gcc.gnu.org"; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=gnu.org Received: from sourceware.org (server2.sourceware.org. [2620:52:3:1:0:246e:9693:128c]) by mx.google.com with ESMTPS id g21-20020aa7d1d5000000b005068469d3a3si14713230edp.254.2023.05.16.02.15.16 for (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 16 May 2023 02:15:16 -0700 (PDT) Received-SPF: pass (google.com: domain of gcc-patches-bounces+ouuuleilei=gmail.com@gcc.gnu.org designates 2620:52:3:1:0:246e:9693:128c as permitted sender) client-ip=2620:52:3:1:0:246e:9693:128c; Authentication-Results: mx.google.com; dkim=pass header.i=@gcc.gnu.org header.s=default header.b=Q4OczPg1; spf=pass (google.com: domain of gcc-patches-bounces+ouuuleilei=gmail.com@gcc.gnu.org designates 2620:52:3:1:0:246e:9693:128c as permitted sender) smtp.mailfrom="gcc-patches-bounces+ouuuleilei=gmail.com@gcc.gnu.org"; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=gnu.org Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id 17543386D626 for ; Tue, 16 May 2023 09:13:18 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org 17543386D626 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gcc.gnu.org; s=default; t=1684228398; bh=Uvm39XoZ+HcnyXjyEqY0pWX7Ikc0WjN9zpjOriS6738=; h=To:Subject:Date:In-Reply-To:References:List-Id:List-Unsubscribe: List-Archive:List-Post:List-Help:List-Subscribe:From:Reply-To: From; b=Q4OczPg1BkU+/858hpIkGba30/6EI6h8Ktiu8epKOgK9m9zu1r5OalazVSg0RsNdN iUHIEuGlYbRz2wrYHf5AkFJyM0vt9hBLYlf/wav9+71yznRClilahGrHyurxveTa78 89gFBf/SJDWTixJ1v3IqWRN9ru3/URbw+rwmxAGk= X-Original-To: gcc-patches@gcc.gnu.org Delivered-To: gcc-patches@gcc.gnu.org Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [170.10.129.124]) by sourceware.org (Postfix) with ESMTPS id 89BAA385773C for ; Tue, 16 May 2023 09:11:39 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org 89BAA385773C Received: from mimecast-mx02.redhat.com (mimecast-mx02.redhat.com [66.187.233.88]) by relay.mimecast.com with ESMTP with STARTTLS (version=TLSv1.2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id us-mta-121-I98e23EFPaa4xBf7mBcXZQ-1; Tue, 16 May 2023 05:11:35 -0400 X-MC-Unique: I98e23EFPaa4xBf7mBcXZQ-1 Received: from smtp.corp.redhat.com (int-mx01.intmail.prod.int.rdu2.redhat.com [10.11.54.1]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mimecast-mx02.redhat.com (Postfix) with ESMTPS id 8D0F6101A554; Tue, 16 May 2023 09:11:35 +0000 (UTC) Received: from localhost (unknown [10.42.28.178]) by smtp.corp.redhat.com (Postfix) with ESMTP id 12B8640C206F; Tue, 16 May 2023 09:11:34 +0000 (UTC) To: libstdc++@gcc.gnu.org, gcc-patches@gcc.gnu.org Subject: [committed 2/3] libstdc++: Stop using _GLIBCXX_USE_C99_STDINT_TR1 in Date: Tue, 16 May 2023 10:11:31 +0100 Message-Id: <20230516091132.1698684-2-jwakely@redhat.com> In-Reply-To: <20230516091132.1698684-1-jwakely@redhat.com> References: <20230516091132.1698684-1-jwakely@redhat.com> MIME-Version: 1.0 X-Scanned-By: MIMEDefang 3.1 on 10.11.54.1 X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com X-Spam-Status: No, score=-11.8 required=5.0 tests=BAYES_00, DKIMWL_WL_HIGH, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, GIT_PATCH_0, RCVD_IN_DNSWL_NONE, SPF_HELO_NONE, SPF_NONE, TXREP, T_SCC_BODY_TEXT_LINE autolearn=unavailable autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on server2.sourceware.org X-BeenThere: gcc-patches@gcc.gnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Gcc-patches mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-Patchwork-Original-From: Jonathan Wakely via Gcc-patches From: Jonathan Wakely Reply-To: Jonathan Wakely Errors-To: gcc-patches-bounces+ouuuleilei=gmail.com@gcc.gnu.org Sender: "Gcc-patches" X-getmail-retrieved-from-mailbox: =?utf-8?q?INBOX?= X-GMAIL-THRID: =?utf-8?q?1766041601500089198?= X-GMAIL-MSGID: =?utf-8?q?1766041601500089198?= Tested powerpc64le-linux. Pushed to trunk. -- >8 -- The _GLIBCXX_USE_C99_STDINT_TR1 macro (and the comments about it in acinclude.m4 and config.h) are misleading when it is also used for , not only . It is also wrong, because the configure checks for TR1 use -std=c++98 and a target might define uint32_t etc. for C++11 but not for C++98. Add a separate configure check for the types using -std=c++11 for the checks. Use the result of that separate check in and most other places that still depend on the macro (many uses of that macro have been removed already). The remaining uses of the STDINT_TR1 macro are really for TR1, or are in the src/c++11/compatibility-*.cc files, where we don't want/need to change the condition they depend on (if those symbols were only exported when types were available for -std=c++98, then that's the condition we should continue to use for whether to export the compat symbols now). Make similar changes for the related _GLIBCXX_USE_C99_INTTYPES_TR1 and _GLIBCXX_USE_C99_INTTYPES_WCHAR_T_TR1 macros, adding new macros for non-TR1 uses. libstdc++-v3/ChangeLog: * acinclude.m4 (GLIBCXX_USE_C99): Check for types in C++11 mode and define _GLIBCXX_USE_C99_STDINT. Check for features in C++11 mode and define _GLIBCXX_USE_C99_INTTYPES and _GLIBCXX_USE_C99_INTTYPES_WCHAR_T. * config.h.in: Regenerate. * configure: Regenerate. * doc/doxygen/user.cfg.in (PREDEFINED): Add new macros. * include/bits/chrono.h: Check _GLIBCXX_USE_C99_STDINT instead of _GLIBCXX_USE_C99_STDINT_TR1. * include/c_compatibility/inttypes.h: Check _GLIBCXX_USE_C99_INTTYPES and _GLIBCXX_USE_C99_INTTYPES_WCHAR_T instead of _GLIBCXX_USE_C99_INTTYPES_TR1 and _GLIBCXX_USE_C99_INTTYPES_WCHAR_T_TR1. * include/c_compatibility/stdatomic.h: Check _GLIBCXX_USE_C99_STDINT instead of _GLIBCXX_USE_C99_STDINT_TR1. * include/c_compatibility/stdint.h: Likewise. * include/c_global/cinttypes: Check _GLIBCXX_USE_C99_INTTYPES and _GLIBCXX_USE_C99_INTTYPES_WCHAR_T instead of _GLIBCXX_USE_C99_INTTYPES_TR1 and _GLIBCXX_USE_C99_INTTYPES_WCHAR_T_TR1. * include/c_global/cstdint: Check _GLIBCXX_USE_C99_STDINT instead of _GLIBCXX_USE_C99_STDINT_TR1. * include/std/atomic: Likewise. * src/c++11/cow-stdexcept.cc: Likewise. * testsuite/29_atomics/headers/stdatomic.h/c_compat.cc: Likewise. * testsuite/lib/libstdc++.exp (check_v3_target_cstdint): Likewise. --- libstdc++-v3/acinclude.m4 | 142 +++++++++++++ libstdc++-v3/config.h.in | 12 ++ libstdc++-v3/configure | 196 ++++++++++++++++++ libstdc++-v3/doc/doxygen/user.cfg.in | 3 + libstdc++-v3/include/bits/chrono.h | 2 +- .../include/c_compatibility/inttypes.h | 6 +- .../include/c_compatibility/stdatomic.h | 4 +- libstdc++-v3/include/c_compatibility/stdint.h | 4 +- libstdc++-v3/include/c_global/cinttypes | 6 +- libstdc++-v3/include/c_global/cstdint | 6 +- libstdc++-v3/include/std/atomic | 2 +- libstdc++-v3/src/c++11/cow-stdexcept.cc | 4 +- .../headers/stdatomic.h/c_compat.cc | 2 +- libstdc++-v3/testsuite/lib/libstdc++.exp | 2 +- 14 files changed, 372 insertions(+), 19 deletions(-) diff --git a/libstdc++-v3/acinclude.m4 b/libstdc++-v3/acinclude.m4 index 84b12adbc24..0c01b526ebf 100644 --- a/libstdc++-v3/acinclude.m4 +++ b/libstdc++-v3/acinclude.m4 @@ -1103,6 +1103,148 @@ AC_DEFUN([GLIBCXX_ENABLE_C99], [ ]) fi + # Check for the existence of types. + AC_CACHE_CHECK([for ISO C99 support in for C++11], + glibcxx_cv_c99_stdint, [ + AC_TRY_COMPILE([#define __STDC_LIMIT_MACROS + #define __STDC_CONSTANT_MACROS + #include ], + [typedef int8_t my_int8_t; + my_int8_t i8 = INT8_MIN; + i8 = INT8_MAX; + typedef int16_t my_int16_t; + my_int16_t i16 = INT16_MIN; + i16 = INT16_MAX; + typedef int32_t my_int32_t; + my_int32_t i32 = INT32_MIN; + i32 = INT32_MAX; + typedef int64_t my_int64_t; + my_int64_t i64 = INT64_MIN; + i64 = INT64_MAX; + typedef int_fast8_t my_int_fast8_t; + my_int_fast8_t if8 = INT_FAST8_MIN; + if8 = INT_FAST8_MAX; + typedef int_fast16_t my_int_fast16_t; + my_int_fast16_t if16 = INT_FAST16_MIN; + if16 = INT_FAST16_MAX; + typedef int_fast32_t my_int_fast32_t; + my_int_fast32_t if32 = INT_FAST32_MIN; + if32 = INT_FAST32_MAX; + typedef int_fast64_t my_int_fast64_t; + my_int_fast64_t if64 = INT_FAST64_MIN; + if64 = INT_FAST64_MAX; + typedef int_least8_t my_int_least8_t; + my_int_least8_t il8 = INT_LEAST8_MIN; + il8 = INT_LEAST8_MAX; + typedef int_least16_t my_int_least16_t; + my_int_least16_t il16 = INT_LEAST16_MIN; + il16 = INT_LEAST16_MAX; + typedef int_least32_t my_int_least32_t; + my_int_least32_t il32 = INT_LEAST32_MIN; + il32 = INT_LEAST32_MAX; + typedef int_least64_t my_int_least64_t; + my_int_least64_t il64 = INT_LEAST64_MIN; + il64 = INT_LEAST64_MAX; + typedef intmax_t my_intmax_t; + my_intmax_t im = INTMAX_MAX; + im = INTMAX_MIN; + typedef intptr_t my_intptr_t; + my_intptr_t ip = INTPTR_MAX; + ip = INTPTR_MIN; + typedef uint8_t my_uint8_t; + my_uint8_t ui8 = UINT8_MAX; + ui8 = UINT8_MAX; + typedef uint16_t my_uint16_t; + my_uint16_t ui16 = UINT16_MAX; + ui16 = UINT16_MAX; + typedef uint32_t my_uint32_t; + my_uint32_t ui32 = UINT32_MAX; + ui32 = UINT32_MAX; + typedef uint64_t my_uint64_t; + my_uint64_t ui64 = UINT64_MAX; + ui64 = UINT64_MAX; + typedef uint_fast8_t my_uint_fast8_t; + my_uint_fast8_t uif8 = UINT_FAST8_MAX; + uif8 = UINT_FAST8_MAX; + typedef uint_fast16_t my_uint_fast16_t; + my_uint_fast16_t uif16 = UINT_FAST16_MAX; + uif16 = UINT_FAST16_MAX; + typedef uint_fast32_t my_uint_fast32_t; + my_uint_fast32_t uif32 = UINT_FAST32_MAX; + uif32 = UINT_FAST32_MAX; + typedef uint_fast64_t my_uint_fast64_t; + my_uint_fast64_t uif64 = UINT_FAST64_MAX; + uif64 = UINT_FAST64_MAX; + typedef uint_least8_t my_uint_least8_t; + my_uint_least8_t uil8 = UINT_LEAST8_MAX; + uil8 = UINT_LEAST8_MAX; + typedef uint_least16_t my_uint_least16_t; + my_uint_least16_t uil16 = UINT_LEAST16_MAX; + uil16 = UINT_LEAST16_MAX; + typedef uint_least32_t my_uint_least32_t; + my_uint_least32_t uil32 = UINT_LEAST32_MAX; + uil32 = UINT_LEAST32_MAX; + typedef uint_least64_t my_uint_least64_t; + my_uint_least64_t uil64 = UINT_LEAST64_MAX; + uil64 = UINT_LEAST64_MAX; + typedef uintmax_t my_uintmax_t; + my_uintmax_t uim = UINTMAX_MAX; + uim = UINTMAX_MAX; + typedef uintptr_t my_uintptr_t; + my_uintptr_t uip = UINTPTR_MAX; + uip = UINTPTR_MAX; + ],[glibcxx_cv_c99_stdint=yes], + [glibcxx_cv_c99_stdint=no]) + ]) + if test x"$glibcxx_cv_c99_stdint" = x"yes"; then + AC_DEFINE(_GLIBCXX_USE_C99_STDINT, 1, + [Define if C99 types in should be imported in + in namespace std for C++11.]) + fi + + # Check for the existence of functions (NB: doesn't make + # sense if the glibcxx_cv_c99_stdint check fails, per C99, 7.8/1). + ac_c99_inttypes=no; + if test x"$glibcxx_cv_c99_stdint" = x"yes"; then + AC_MSG_CHECKING([for ISO C99 support for C++11 in ]) + AC_TRY_COMPILE([#include ], + [intmax_t i, numer, denom, base; + const char* s; + char** endptr; + intmax_t ret = imaxabs(i); + imaxdiv_t dret = imaxdiv(numer, denom); + ret = strtoimax(s, endptr, base); + uintmax_t uret = strtoumax(s, endptr, base); + ],[ac_c99_inttypes=yes], [ac_c99_inttypes=no]) + AC_MSG_RESULT($ac_c99_inttypes) + fi + if test x"$ac_c99_inttypes" = x"yes"; then + AC_DEFINE(_GLIBCXX_USE_C99_INTTYPES, 1, + [Define if C99 functions in should be imported in + in namespace std in C++11.]) + fi + + # Check for the existence of wchar_t functions (NB: doesn't + # make sense if the glibcxx_cv_c99_stdint check fails, per C99, 7.8/1). + ac_c99_inttypes_wchar_t=no; + if test x"$glibcxx_cv_c99_stdint" = x"yes"; then + AC_MSG_CHECKING([for wchar_t ISO C99 support for C++11 in ]) + AC_TRY_COMPILE([#include ], + [intmax_t base; + const wchar_t* s; + wchar_t** endptr; + intmax_t ret = wcstoimax(s, endptr, base); + uintmax_t uret = wcstoumax(s, endptr, base); + ],[ac_c99_inttypes_wchar_t=yes], + [ac_c99_inttypes_wchar_t=no]) + AC_MSG_RESULT($ac_c99_inttypes_wchar_t) + fi + if test x"$ac_c99_inttypes_wchar_t" = x"yes"; then + AC_DEFINE(_GLIBCXX_USE_C99_INTTYPES_WCHAR_T, 1, + [Define if wchar_t C99 functions in should be + imported in in namespace std in C++11.]) + fi + # Check for the existence of functions used if C99 is enabled. AC_CACHE_CHECK([for ISO C99 support in for C++11], glibcxx_cv_c99_math_cxx11, [ diff --git a/libstdc++-v3/doc/doxygen/user.cfg.in b/libstdc++-v3/doc/doxygen/user.cfg.in index 210e13400b9..0905e0f48f2 100644 --- a/libstdc++-v3/doc/doxygen/user.cfg.in +++ b/libstdc++-v3/doc/doxygen/user.cfg.in @@ -2353,6 +2353,9 @@ PREDEFINED = __cplusplus=202002L \ _GLIBCXX_USE_WCHAR_T \ _GLIBCXX_USE_LONG_LONG \ _GLIBCXX_USE_C99_COMPLEX_ARC \ + _GLIBCXX_USE_C99_INTTYPES \ + _GLIBCXX_USE_C99_INTTYPES_WCHAR_T \ + _GLIBCXX_USE_C99_STDINT \ _GLIBCXX_USE_C99_STDINT_TR1 \ _GLIBCXX_USE_SCHED_YIELD \ _GLIBCXX_USE_NANOSLEEP \ diff --git a/libstdc++-v3/include/bits/chrono.h b/libstdc++-v3/include/bits/chrono.h index fb99fe5eed7..81b92d724f7 100644 --- a/libstdc++-v3/include/bits/chrono.h +++ b/libstdc++-v3/include/bits/chrono.h @@ -884,7 +884,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION /// @} /// @cond undocumented -#ifdef _GLIBCXX_USE_C99_STDINT_TR1 +#ifdef _GLIBCXX_USE_C99_STDINT # define _GLIBCXX_CHRONO_INT64_T int64_t #elif defined __INT64_TYPE__ # define _GLIBCXX_CHRONO_INT64_T __INT64_TYPE__ diff --git a/libstdc++-v3/include/c_compatibility/inttypes.h b/libstdc++-v3/include/c_compatibility/inttypes.h index 9c2b7d6c68d..070fcbcc1f2 100644 --- a/libstdc++-v3/include/c_compatibility/inttypes.h +++ b/libstdc++-v3/include/c_compatibility/inttypes.h @@ -48,7 +48,7 @@ # endif # endif -#ifdef _GLIBCXX_USE_C99_INTTYPES_TR1 +#ifdef _GLIBCXX_USE_C99_INTTYPES namespace std { @@ -72,13 +72,13 @@ namespace std using ::strtoimax; using ::strtoumax; -#if defined(_GLIBCXX_USE_WCHAR_T) && _GLIBCXX_USE_C99_INTTYPES_WCHAR_T_TR1 +#if defined(_GLIBCXX_USE_WCHAR_T) && _GLIBCXX_USE_C99_INTTYPES_WCHAR_T using ::wcstoimax; using ::wcstoumax; #endif } // namespace -#endif _GLIBCXX_USE_C99_INTTYPES_TR1 +#endif _GLIBCXX_USE_C99_INTTYPES #else diff --git a/libstdc++-v3/include/c_compatibility/stdatomic.h b/libstdc++-v3/include/c_compatibility/stdatomic.h index b565a1c1ab1..0b633262d08 100644 --- a/libstdc++-v3/include/c_compatibility/stdatomic.h +++ b/libstdc++-v3/include/c_compatibility/stdatomic.h @@ -62,7 +62,7 @@ using std::atomic_char8_t; using std::atomic_char16_t; using std::atomic_char32_t; using std::atomic_wchar_t; -#ifdef _GLIBCXX_USE_C99_STDINT_TR1 +#ifdef _GLIBCXX_USE_C99_STDINT using std::atomic_int8_t; using std::atomic_uint8_t; using std::atomic_int16_t; @@ -92,7 +92,7 @@ using std::atomic_intptr_t; using std::atomic_uintptr_t; using std::atomic_size_t; using std::atomic_ptrdiff_t; -#ifdef _GLIBCXX_USE_C99_STDINT_TR1 +#ifdef _GLIBCXX_USE_C99_STDINT using std::atomic_intmax_t; using std::atomic_uintmax_t; #endif diff --git a/libstdc++-v3/include/c_compatibility/stdint.h b/libstdc++-v3/include/c_compatibility/stdint.h index c264e979a0a..85948a5ada1 100644 --- a/libstdc++-v3/include/c_compatibility/stdint.h +++ b/libstdc++-v3/include/c_compatibility/stdint.h @@ -56,7 +56,7 @@ # endif # endif -#ifdef _GLIBCXX_USE_C99_STDINT_TR1 +#ifdef _GLIBCXX_USE_C99_STDINT namespace std { @@ -97,7 +97,7 @@ namespace std using ::uintptr_t; } // namespace -#endif // _GLIBCXX_USE_C99_STDINT_TR1 +#endif // _GLIBCXX_USE_C99_STDINT #else diff --git a/libstdc++-v3/include/c_global/cinttypes b/libstdc++-v3/include/c_global/cinttypes index 8a9de63af79..06fc34d7d6e 100644 --- a/libstdc++-v3/include/c_global/cinttypes +++ b/libstdc++-v3/include/c_global/cinttypes @@ -50,7 +50,7 @@ # endif #endif -#ifdef _GLIBCXX_USE_C99_INTTYPES_TR1 +#ifdef _GLIBCXX_USE_C99_INTTYPES namespace std { @@ -68,13 +68,13 @@ namespace std using ::strtoimax; using ::strtoumax; -#if defined(_GLIBCXX_USE_WCHAR_T) && _GLIBCXX_USE_C99_INTTYPES_WCHAR_T_TR1 +#if defined(_GLIBCXX_USE_WCHAR_T) && _GLIBCXX_USE_C99_INTTYPES_WCHAR_T using ::wcstoimax; using ::wcstoumax; #endif } // namespace std -#endif // _GLIBCXX_USE_C99_INTTYPES_TR1 +#endif // _GLIBCXX_USE_C99_INTTYPES #endif // C++11 diff --git a/libstdc++-v3/include/c_global/cstdint b/libstdc++-v3/include/c_global/cstdint index 64e8574badc..97a30d5e004 100644 --- a/libstdc++-v3/include/c_global/cstdint +++ b/libstdc++-v3/include/c_global/cstdint @@ -47,7 +47,7 @@ namespace std { -#ifdef _GLIBCXX_USE_C99_STDINT_TR1 +#ifdef _GLIBCXX_USE_C99_STDINT using ::int8_t; using ::int16_t; using ::int32_t; @@ -83,7 +83,7 @@ namespace std using ::uintmax_t; using ::uintptr_t; -#else // !_GLIBCXX_USE_C99_STDINT_TR1 +#else // !_GLIBCXX_USE_C99_STDINT using intmax_t = __INTMAX_TYPE__; using uintmax_t = __UINTMAX_TYPE__; @@ -138,7 +138,7 @@ namespace std using uintptr_t = __UINTPTR_TYPE__; #endif -#endif // _GLIBCXX_USE_C99_STDINT_TR1 +#endif // _GLIBCXX_USE_C99_STDINT } // namespace std #endif // C++11 diff --git a/libstdc++-v3/include/std/atomic b/libstdc++-v3/include/std/atomic index b502027e4a4..111df2a978b 100644 --- a/libstdc++-v3/include/std/atomic +++ b/libstdc++-v3/include/std/atomic @@ -1103,7 +1103,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION /// atomic_char32_t typedef atomic atomic_char32_t; -#ifdef _GLIBCXX_USE_C99_STDINT_TR1 +#ifdef _GLIBCXX_USE_C99_STDINT // _GLIBCXX_RESOLVE_LIB_DEFECTS // 2441. Exact-width atomic typedefs should be provided diff --git a/libstdc++-v3/src/c++11/cow-stdexcept.cc b/libstdc++-v3/src/c++11/cow-stdexcept.cc index 652f248a54e..8d1cc4605d4 100644 --- a/libstdc++-v3/src/c++11/cow-stdexcept.cc +++ b/libstdc++-v3/src/c++11/cow-stdexcept.cc @@ -198,7 +198,7 @@ _GLIBCXX_END_NAMESPACE_VERSION // declared transaction-safe, so we just don't provide transactional clones // in this case. #if _GLIBCXX_USE_WEAK_REF -#ifdef _GLIBCXX_USE_C99_STDINT_TR1 +#ifdef _GLIBCXX_USE_C99_STDINT #include @@ -461,5 +461,5 @@ CTORDTOR(15underflow_error, std::underflow_error, runtime_error) } -#endif // _GLIBCXX_USE_C99_STDINT_TR1 +#endif // _GLIBCXX_USE_C99_STDINT #endif // _GLIBCXX_USE_WEAK_REF diff --git a/libstdc++-v3/testsuite/29_atomics/headers/stdatomic.h/c_compat.cc b/libstdc++-v3/testsuite/29_atomics/headers/stdatomic.h/c_compat.cc index 8dd7054a997..3364c60a225 100644 --- a/libstdc++-v3/testsuite/29_atomics/headers/stdatomic.h/c_compat.cc +++ b/libstdc++-v3/testsuite/29_atomics/headers/stdatomic.h/c_compat.cc @@ -70,7 +70,7 @@ static_assert(is_same); static_assert(is_same); #include -#ifdef _GLIBCXX_USE_C99_STDINT_TR1 +#ifdef _GLIBCXX_USE_C99_STDINT static_assert(is_same); static_assert(is_same); static_assert(is_same); diff --git a/libstdc++-v3/testsuite/lib/libstdc++.exp b/libstdc++-v3/testsuite/lib/libstdc++.exp index 490abd108fa..7d9471a1ded 100644 --- a/libstdc++-v3/testsuite/lib/libstdc++.exp +++ b/libstdc++-v3/testsuite/lib/libstdc++.exp @@ -1063,7 +1063,7 @@ proc check_v3_target_parallel_mode { } { # Return 1 if the C99 stdint facilities are available, 0 otherwise. proc check_v3_target_cstdint { } { return [check_v3_target_prop_cached et_cstdint { - set cond "defined _GLIBCXX_USE_C99_STDINT_TR1" + set cond "defined _GLIBCXX_USE_C99_STDINT" return [v3_check_preprocessor_condition cstdint $cond] }] }