From patchwork Wed Dec 1 15:08:21 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Jonathan Wakely X-Patchwork-Id: 1562214 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Authentication-Results: bilbo.ozlabs.org; dkim=pass (1024-bit key; unprotected) header.d=gcc.gnu.org header.i=@gcc.gnu.org header.a=rsa-sha256 header.s=default header.b=aRaxcVdb; dkim-atps=neutral Authentication-Results: ozlabs.org; spf=pass (sender SPF authorized) smtp.mailfrom=gcc.gnu.org (client-ip=2620:52:3:1:0:246e:9693:128c; helo=sourceware.org; envelope-from=gcc-patches-bounces+incoming=patchwork.ozlabs.org@gcc.gnu.org; receiver=) Received: from sourceware.org (server2.sourceware.org [IPv6:2620:52:3:1:0:246e:9693:128c]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (No client certificate requested) by bilbo.ozlabs.org (Postfix) with ESMTPS id 4J42l23Dzwz9sCD for ; Thu, 2 Dec 2021 02:17:32 +1100 (AEDT) Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id 39271385C411 for ; Wed, 1 Dec 2021 15:17:30 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org 39271385C411 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gcc.gnu.org; s=default; t=1638371850; bh=AqfZRs90XPZYGwCVO75sCrOOUdliblDXcPNLB3Fs/IA=; h=To:Subject:Date:List-Id:List-Unsubscribe:List-Archive:List-Post: List-Help:List-Subscribe:From:Reply-To:From; b=aRaxcVdbwKrOw0OBU7CbH4yLaJjIjlD7gceNJExaY8LMD12nJ/SImDmv4k7FJnxW7 OSKC9gK7Gn6U3jOfI+P+HmV9BXLqvzA4uiFS4iG6aFzMh9MDPnV5i0f/zsYv5c5raO H8DFbVgKqSp4NJqSG4Lrv0vvwvR/eZq5ElmX2ZJE= 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 1EA57385801C for ; Wed, 1 Dec 2021 15:08:41 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.1 sourceware.org 1EA57385801C Received: from mimecast-mx01.redhat.com (mimecast-mx01.redhat.com [209.132.183.4]) by relay.mimecast.com with ESMTP with STARTTLS (version=TLSv1.2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id us-mta-413-o9pEj62oOBa_GEfaxucHUQ-1; Wed, 01 Dec 2021 10:08:34 -0500 X-MC-Unique: o9pEj62oOBa_GEfaxucHUQ-1 Received: from smtp.corp.redhat.com (int-mx04.intmail.prod.int.phx2.redhat.com [10.5.11.14]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mimecast-mx01.redhat.com (Postfix) with ESMTPS id BE77D835B92; Wed, 1 Dec 2021 15:08:23 +0000 (UTC) Received: from localhost (unknown [10.33.36.16]) by smtp.corp.redhat.com (Postfix) with ESMTP id A1FE85ED5B; Wed, 1 Dec 2021 15:08:22 +0000 (UTC) To: libstdc++@gcc.gnu.org, gcc-patches@gcc.gnu.org Subject: [committed] libstdc++: Define std::__is_constant_evaluated() for internal use Date: Wed, 1 Dec 2021 15:08:21 +0000 Message-Id: <20211201150821.217546-1-jwakely@redhat.com> MIME-Version: 1.0 X-Scanned-By: MIMEDefang 2.79 on 10.5.11.14 X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com X-Spam-Status: No, score=-14.0 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_LOW, RCVD_IN_MSPIKE_H3, RCVD_IN_MSPIKE_WL, SPF_HELO_NONE, SPF_NONE, TXREP autolearn=unavailable autolearn_force=no version=3.4.4 X-Spam-Checker-Version: SpamAssassin 3.4.4 (2020-01-24) 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+incoming=patchwork.ozlabs.org@gcc.gnu.org Sender: "Gcc-patches" Tested x86_64-linux, pushed to trunk. This adds std::__is_constant_evaluated() as a C++11 wrapper for __builtin_is_constant_evaluated, but just returning false if the built-in isn't supported by the compiler. This allows us to use it throughout the library without checking __has_builtin every time. Some uses in std::vector and std::string can only be constexpr when the std::is_constant_evaluated() function actually works, so we might as well guard them with a relevant macro and call that function directly, rather than the built-in or std::__is_constant_evaluated(). The remaining checks of the __cpp_lib_is_constant_evaluated macro could now be replaced by checking __cplusplus >= 202002 instead, but there's no practical difference. We still need some kind of preprocessor check there anyway. libstdc++-v3/ChangeLog: * doc/doxygen/user.cfg.in (PREDEFINED): Change macro name. * include/bits/allocator.h (allocate, deallocate): Use std::__is_constant_evaluated() unconditionally, instead of checking whether std::is_constant_evaluated() (or the built-in) can be used. * include/bits/basic_string.h: Check new macro. call std::is_constant_evaluated() directly in C++20-only code that is guarded by a suitable macro. * include/bits/basic_string.tcc: Likewise. * include/bits/c++config (__is_constant_evaluated): Define. (_GLIBCXX_HAVE_BUILTIN_IS_CONSTANT_EVALUATED): Replace with ... (_GLIBCXX_HAVE_IS_CONSTANT_EVALUATED): New macro. * include/bits/char_traits.h (char_traits): Replace conditional calls to std::is_constant_evaluated with unconditional calls to std::__is_constant_evaluated. * include/bits/cow_string.h: Use new macro. * include/bits/ranges_algobase.h (__copy_or_move): Replace conditional calls to std::is_constant_evaluated with unconditional calls to std::__is_constant_evaluated. (__copy_or_move_backward, __fill_n_fn): Likewise. * include/bits/ranges_cmp.h (ranges::less): Likewise. * include/bits/stl_algobase.h (lexicographical_compare_three_way): Likewise. * include/bits/stl_bvector.h: Call std::is_constant_evaluated directly in C++20-only code that is guarded by a suitable macro. * include/bits/stl_construct.h (_Construct, _Destroy, _Destroy_n): Replace is_constant_evaluated with __is_constant_evaluated. * include/bits/stl_function.h (greater, less, greater_equal) (less_equal): Replace __builtin_is_constant_evaluated and __builtin_constant_p with __is_constant_evaluated. * include/bits/stl_vector.h: Call std::is_constant_evaluated() in C++20-only code. * include/debug/helper_functions.h (__check_singular): Use __is_constant_evaluated instead of built-in, or remove check entirely. * include/std/array (operator<=>): Use __is_constant_evaluated unconditionally. * include/std/bit (__bit_ceil): Likewise. * include/std/type_traits (is_constant_evaluated): Define using 'if consteval' if possible. * include/std/version: Use new macro. * libsupc++/compare: Use __is_constant_evaluated instead of __builtin_is_constant_evaluated. * testsuite/23_containers/array/tuple_interface/get_neg.cc: Adjust dg-error lines. --- libstdc++-v3/doc/doxygen/user.cfg.in | 2 +- libstdc++-v3/include/bits/allocator.h | 8 +- libstdc++-v3/include/bits/basic_string.h | 6 +- libstdc++-v3/include/bits/basic_string.tcc | 4 +- libstdc++-v3/include/bits/c++config | 30 +++- libstdc++-v3/include/bits/char_traits.h | 129 +++++++++--------- libstdc++-v3/include/bits/cow_string.h | 2 +- libstdc++-v3/include/bits/ranges_algobase.h | 12 +- libstdc++-v3/include/bits/ranges_cmp.h | 5 +- libstdc++-v3/include/bits/stl_algobase.h | 5 +- libstdc++-v3/include/bits/stl_bvector.h | 8 +- libstdc++-v3/include/bits/stl_construct.h | 12 +- libstdc++-v3/include/bits/stl_function.h | 24 +--- libstdc++-v3/include/bits/stl_vector.h | 5 +- libstdc++-v3/include/debug/helper_functions.h | 15 +- libstdc++-v3/include/std/array | 4 +- libstdc++-v3/include/std/bit | 5 +- libstdc++-v3/include/std/type_traits | 11 +- libstdc++-v3/include/std/version | 4 +- libstdc++-v3/libsupc++/compare | 2 +- .../array/tuple_interface/get_neg.cc | 6 +- 21 files changed, 142 insertions(+), 157 deletions(-) diff --git a/libstdc++-v3/doc/doxygen/user.cfg.in b/libstdc++-v3/doc/doxygen/user.cfg.in index 17cd6fc1c0e..2f15f2c1b82 100644 --- a/libstdc++-v3/doc/doxygen/user.cfg.in +++ b/libstdc++-v3/doc/doxygen/user.cfg.in @@ -2399,7 +2399,7 @@ PREDEFINED = __cplusplus=202002L \ "__has_builtin(x)=1" \ _GLIBCXX_HAVE_BUILTIN_HAS_UNIQ_OBJ_REP \ _GLIBCXX_HAVE_BUILTIN_IS_AGGREGATE \ - _GLIBCXX_HAVE_BUILTIN_IS_CONSTANT_EVALUATED \ + _GLIBCXX_HAVE_IS_CONSTANT_EVALUATED \ _GLIBCXX_HAVE_BUILTIN_LAUNDER \ # If the MACRO_EXPANSION and EXPAND_ONLY_PREDEF tags are set to YES then this diff --git a/libstdc++-v3/include/bits/allocator.h b/libstdc++-v3/include/bits/allocator.h index f83e6b87666..1c099514e18 100644 --- a/libstdc++-v3/include/bits/allocator.h +++ b/libstdc++-v3/include/bits/allocator.h @@ -178,10 +178,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION constexpr _Tp* allocate(size_t __n) { -#ifdef __cpp_lib_is_constant_evaluated - if (std::is_constant_evaluated()) + if (std::__is_constant_evaluated()) return static_cast<_Tp*>(::operator new(__n * sizeof(_Tp))); -#endif return __allocator_base<_Tp>::allocate(__n, 0); } @@ -189,13 +187,11 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION constexpr void deallocate(_Tp* __p, size_t __n) { -#ifdef __cpp_lib_is_constant_evaluated - if (std::is_constant_evaluated()) + if (std::__is_constant_evaluated()) { ::operator delete(__p); return; } -#endif __allocator_base<_Tp>::deallocate(__p, __n); } #endif // C++20 diff --git a/libstdc++-v3/include/bits/basic_string.h b/libstdc++-v3/include/bits/basic_string.h index 6e7de738308..4007a8d2d7c 100644 --- a/libstdc++-v3/include/bits/basic_string.h +++ b/libstdc++-v3/include/bits/basic_string.h @@ -59,7 +59,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CXX11 #ifdef __cpp_lib_is_constant_evaluated // Support P0980R1 in C++20. # define __cpp_lib_constexpr_string 201907L -#elif __cplusplus >= 201703L && _GLIBCXX_HAVE_BUILTIN_IS_CONSTANT_EVALUATED +#elif __cplusplus >= 201703L && _GLIBCXX_HAVE_IS_CONSTANT_EVALUATED // Support P0426R1 changes to char_traits in C++17. # define __cpp_lib_constexpr_string 201611L #endif @@ -101,7 +101,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CXX11 allocate(_Char_alloc_type& __a, typename _Base::size_type __n) { pointer __p = _Base::allocate(__a, __n); - if (__builtin_is_constant_evaluated()) + if (std::is_constant_evaluated()) // Begin the lifetime of characters in allocated storage. for (size_type __i = 0; __i < __n; ++__i) std::construct_at(__builtin_addressof(__p[__i])); @@ -352,7 +352,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CXX11 _M_use_local_data() _GLIBCXX_NOEXCEPT { #if __cpp_lib_is_constant_evaluated - if (__builtin_is_constant_evaluated()) + if (std::is_constant_evaluated()) _M_local_buf[0] = _CharT(); #endif return _M_local_data(); diff --git a/libstdc++-v3/include/bits/basic_string.tcc b/libstdc++-v3/include/bits/basic_string.tcc index 6f619a08f70..4a2d48c48e8 100644 --- a/libstdc++-v3/include/bits/basic_string.tcc +++ b/libstdc++-v3/include/bits/basic_string.tcc @@ -488,7 +488,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION const size_type __how_much = __old_size - __pos - __len1; #if __cpp_lib_is_constant_evaluated - if (__builtin_is_constant_evaluated()) + if (std::is_constant_evaluated()) { auto __newp = _Alloc_traits::allocate(_M_get_allocator(), __new_size); @@ -571,7 +571,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION __p = _M_create(__n, __capacity); this->_S_copy(__p, _M_data(), length()); // exclude trailing null #if __cpp_lib_is_constant_evaluated - if (__builtin_is_constant_evaluated()) + if (std::is_constant_evaluated()) traits_type::assign(__p + length(), __n - length(), _CharT()); #endif _M_dispose(); diff --git a/libstdc++-v3/include/bits/c++config b/libstdc++-v3/include/bits/c++config index cbcdedb366f..90513ccae38 100644 --- a/libstdc++-v3/include/bits/c++config +++ b/libstdc++-v3/include/bits/c++config @@ -495,6 +495,27 @@ namespace std #endif // _GLIBCXX_LONG_DOUBLE_ALT128_COMPAT && IEEE128 +namespace std +{ + // Internal version of std::is_constant_evaluated(). + // This can be used without checking if the compiler supports the feature. + // The macro _GLIBCXX_HAVE_IS_CONSTANT_EVALUATED can be used to check if + // the compiler support is present to make this function work as expected. + _GLIBCXX_CONSTEXPR inline bool + __is_constant_evaluated() _GLIBCXX_NOEXCEPT + { +#if __cpp_if_consteval >= 202106L +# define _GLIBCXX_HAVE_IS_CONSTANT_EVALUATED 1 + if consteval { return true; } else { return false; } +#elif __cplusplus >= 201103L && __has_builtin(__builtin_is_constant_evaluated) +# define _GLIBCXX_HAVE_IS_CONSTANT_EVALUATED 1 + return __builtin_is_constant_evaluated(); +#else + return false; +#endif + } +} + // Debug Mode implies checking assertions. #if defined(_GLIBCXX_DEBUG) && !defined(_GLIBCXX_ASSERTIONS) # define _GLIBCXX_ASSERTIONS 1 @@ -507,9 +528,9 @@ namespace std #endif -#if __has_builtin(__builtin_is_constant_evaluated) +#if _GLIBCXX_HAVE_IS_CONSTANT_EVALUATED # define __glibcxx_constexpr_assert(cond) \ - if (__builtin_is_constant_evaluated() && !bool(cond)) \ + if (std::__is_constant_evaluated() && !bool(cond)) \ __builtin_unreachable() /* precondition violation detected! */ #else # define __glibcxx_constexpr_assert(unevaluated) @@ -762,10 +783,6 @@ namespace std # define _GLIBCXX_HAVE_BUILTIN_IS_AGGREGATE 1 #endif -#if _GLIBCXX_HAS_BUILTIN(__builtin_is_constant_evaluated) -# define _GLIBCXX_HAVE_BUILTIN_IS_CONSTANT_EVALUATED 1 -#endif - #if _GLIBCXX_HAS_BUILTIN(__is_same) # define _GLIBCXX_HAVE_BUILTIN_IS_SAME 1 #endif @@ -776,7 +793,6 @@ namespace std #undef _GLIBCXX_HAS_BUILTIN - // PSTL configuration #if __cplusplus >= 201703L diff --git a/libstdc++-v3/include/bits/char_traits.h b/libstdc++-v3/include/bits/char_traits.h index b1cdc55ea61..da3e0ffffaa 100644 --- a/libstdc++-v3/include/bits/char_traits.h +++ b/libstdc++-v3/include/bits/char_traits.h @@ -38,6 +38,9 @@ #include // For streampos #include // For WEOF, wmemmove, wmemset, etc. +#if __cplusplus >= 201103L +# include +#endif #if __cplusplus >= 202002L # include # include @@ -101,8 +104,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION static _GLIBCXX14_CONSTEXPR void assign(char_type& __c1, const char_type& __c2) { -#if __cpp_constexpr_dynamic_alloc && __cpp_lib_is_constant_evaluated - if (std::is_constant_evaluated()) +#if __cpp_constexpr_dynamic_alloc + if (std::__is_constant_evaluated()) std::construct_at(__builtin_addressof(__c1), __c2); else #endif @@ -199,8 +202,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION { if (__n == 0) return __s1; -#if __cpp_lib_is_constant_evaluated - if (std::is_constant_evaluated()) +#if __cplusplus >= 202002L + if (std::__is_constant_evaluated()) { if (__s1 == __s2) // unlikely, but saves a lot of work return __s1; @@ -247,8 +250,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION char_traits<_CharT>:: copy(char_type* __s1, const char_type* __s2, std::size_t __n) { -#if __cpp_lib_is_constant_evaluated - if (std::is_constant_evaluated()) +#if __cplusplus >= 202002L + if (std::__is_constant_evaluated()) { for (std::size_t __i = 0; __i < __n; ++__i) std::construct_at(__s1 + __i, __s2[__i]); @@ -266,8 +269,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION char_traits<_CharT>:: assign(char_type* __s, std::size_t __n, char_type __a) { -#if __cpp_lib_is_constant_evaluated - if (std::is_constant_evaluated()) +#if __cplusplus >= 202002L + if (std::__is_constant_evaluated()) { for (std::size_t __i = 0; __i < __n; ++__i) std::construct_at(__s + __i, __a); @@ -299,7 +302,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION #ifdef __cpp_lib_is_constant_evaluated // Unofficial macro indicating P1032R1 support in C++20 # define __cpp_lib_constexpr_char_traits 201811L -#elif __cplusplus >= 201703L && _GLIBCXX_HAVE_BUILTIN_IS_CONSTANT_EVALUATED +#elif __cplusplus >= 201703L && _GLIBCXX_HAVE_IS_CONSTANT_EVALUATED // Unofficial macro indicating P0426R1 support in C++17 # define __cpp_lib_constexpr_char_traits 201611L #endif @@ -338,8 +341,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION static _GLIBCXX17_CONSTEXPR void assign(char_type& __c1, const char_type& __c2) _GLIBCXX_NOEXCEPT { -#if __cpp_constexpr_dynamic_alloc && __cpp_lib_is_constant_evaluated - if (std::is_constant_evaluated()) +#if __cpp_constexpr_dynamic_alloc + if (std::__is_constant_evaluated()) std::construct_at(__builtin_addressof(__c1), __c2); else #endif @@ -363,8 +366,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION { if (__n == 0) return 0; -#if __cplusplus >= 201703L && _GLIBCXX_HAVE_BUILTIN_IS_CONSTANT_EVALUATED - if (__builtin_is_constant_evaluated()) +#if __cplusplus >= 201703L + if (std::__is_constant_evaluated()) { for (size_t __i = 0; __i < __n; ++__i) if (lt(__s1[__i], __s2[__i])) @@ -380,8 +383,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION static _GLIBCXX17_CONSTEXPR size_t length(const char_type* __s) { -#if __cplusplus >= 201703L && _GLIBCXX_HAVE_BUILTIN_IS_CONSTANT_EVALUATED - if (__builtin_is_constant_evaluated()) +#if __cplusplus >= 201703L + if (std::__is_constant_evaluated()) return __gnu_cxx::char_traits::length(__s); #endif return __builtin_strlen(__s); @@ -392,8 +395,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION { if (__n == 0) return 0; -#if __cplusplus >= 201703L && _GLIBCXX_HAVE_BUILTIN_IS_CONSTANT_EVALUATED - if (__builtin_is_constant_evaluated()) +#if __cplusplus >= 201703L + if (std::__is_constant_evaluated()) return __gnu_cxx::char_traits::find(__s, __n, __a); #endif return static_cast(__builtin_memchr(__s, __a, __n)); @@ -404,8 +407,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION { if (__n == 0) return __s1; -#ifdef __cpp_lib_is_constant_evaluated - if (std::is_constant_evaluated()) +#if __cplusplus >= 202002L + if (std::__is_constant_evaluated()) return __gnu_cxx::char_traits::move(__s1, __s2, __n); #endif return static_cast(__builtin_memmove(__s1, __s2, __n)); @@ -416,8 +419,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION { if (__n == 0) return __s1; -#ifdef __cpp_lib_is_constant_evaluated - if (std::is_constant_evaluated()) +#if __cplusplus >= 202002L + if (std::__is_constant_evaluated()) return __gnu_cxx::char_traits::copy(__s1, __s2, __n); #endif return static_cast(__builtin_memcpy(__s1, __s2, __n)); @@ -428,8 +431,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION { if (__n == 0) return __s; -#ifdef __cpp_lib_is_constant_evaluated - if (std::is_constant_evaluated()) +#if __cplusplus >= 202002L + if (std::__is_constant_evaluated()) return __gnu_cxx::char_traits::assign(__s, __n, __a); #endif return static_cast(__builtin_memset(__s, __a, __n)); @@ -476,8 +479,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION static _GLIBCXX17_CONSTEXPR void assign(char_type& __c1, const char_type& __c2) _GLIBCXX_NOEXCEPT { -#if __cpp_constexpr_dynamic_alloc && __cpp_lib_is_constant_evaluated - if (std::is_constant_evaluated()) +#if __cpp_constexpr_dynamic_alloc + if (std::__is_constant_evaluated()) std::construct_at(__builtin_addressof(__c1), __c2); else #endif @@ -497,8 +500,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION { if (__n == 0) return 0; -#if __cplusplus >= 201703L && _GLIBCXX_HAVE_BUILTIN_IS_CONSTANT_EVALUATED - if (__builtin_is_constant_evaluated()) +#if __cplusplus >= 201703L + if (std::__is_constant_evaluated()) return __gnu_cxx::char_traits::compare(__s1, __s2, __n); #endif return wmemcmp(__s1, __s2, __n); @@ -507,8 +510,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION static _GLIBCXX17_CONSTEXPR size_t length(const char_type* __s) { -#if __cplusplus >= 201703L && _GLIBCXX_HAVE_BUILTIN_IS_CONSTANT_EVALUATED - if (__builtin_is_constant_evaluated()) +#if __cplusplus >= 201703L + if (std::__is_constant_evaluated()) return __gnu_cxx::char_traits::length(__s); #endif return wcslen(__s); @@ -519,8 +522,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION { if (__n == 0) return 0; -#if __cplusplus >= 201703L && _GLIBCXX_HAVE_BUILTIN_IS_CONSTANT_EVALUATED - if (__builtin_is_constant_evaluated()) +#if __cplusplus >= 201703L + if (std::__is_constant_evaluated()) return __gnu_cxx::char_traits::find(__s, __n, __a); #endif return wmemchr(__s, __a, __n); @@ -531,8 +534,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION { if (__n == 0) return __s1; -#ifdef __cpp_lib_is_constant_evaluated - if (std::is_constant_evaluated()) +#if __cplusplus >= 202002L + if (std::__is_constant_evaluated()) return __gnu_cxx::char_traits::move(__s1, __s2, __n); #endif return wmemmove(__s1, __s2, __n); @@ -543,8 +546,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION { if (__n == 0) return __s1; -#ifdef __cpp_lib_is_constant_evaluated - if (std::is_constant_evaluated()) +#if __cplusplus >= 202002L + if (std::__is_constant_evaluated()) return __gnu_cxx::char_traits::copy(__s1, __s2, __n); #endif return wmemcpy(__s1, __s2, __n); @@ -555,8 +558,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION { if (__n == 0) return __s; -#ifdef __cpp_lib_is_constant_evaluated - if (std::is_constant_evaluated()) +#if __cplusplus >= 202002L + if (std::__is_constant_evaluated()) return __gnu_cxx::char_traits::assign(__s, __n, __a); #endif return wmemset(__s, __a, __n); @@ -604,8 +607,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION static _GLIBCXX17_CONSTEXPR void assign(char_type& __c1, const char_type& __c2) _GLIBCXX_NOEXCEPT { -#if __cpp_constexpr_dynamic_alloc && __cpp_lib_is_constant_evaluated - if (std::is_constant_evaluated()) +#if __cpp_constexpr_dynamic_alloc + if (std::__is_constant_evaluated()) std::construct_at(__builtin_addressof(__c1), __c2); else #endif @@ -625,8 +628,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION { if (__n == 0) return 0; -#if __cplusplus >= 201703L && _GLIBCXX_HAVE_BUILTIN_IS_CONSTANT_EVALUATED - if (__builtin_is_constant_evaluated()) +#if __cplusplus >= 201703L + if (std::__is_constant_evaluated()) return __gnu_cxx::char_traits::compare(__s1, __s2, __n); #endif return __builtin_memcmp(__s1, __s2, __n); @@ -635,8 +638,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION static _GLIBCXX17_CONSTEXPR size_t length(const char_type* __s) { -#if __cplusplus >= 201703L && _GLIBCXX_HAVE_BUILTIN_IS_CONSTANT_EVALUATED - if (__builtin_is_constant_evaluated()) +#if __cplusplus >= 201703L + if (std::__is_constant_evaluated()) return __gnu_cxx::char_traits::length(__s); #endif size_t __i = 0; @@ -650,8 +653,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION { if (__n == 0) return 0; -#if __cplusplus >= 201703L && _GLIBCXX_HAVE_BUILTIN_IS_CONSTANT_EVALUATED - if (__builtin_is_constant_evaluated()) +#if __cplusplus >= 201703L + if (std::__is_constant_evaluated()) return __gnu_cxx::char_traits::find(__s, __n, __a); #endif return static_cast(__builtin_memchr(__s, __a, __n)); @@ -662,8 +665,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION { if (__n == 0) return __s1; -#ifdef __cpp_lib_is_constant_evaluated - if (std::is_constant_evaluated()) +#if __cplusplus >= 202002L + if (std::__is_constant_evaluated()) return __gnu_cxx::char_traits::move(__s1, __s2, __n); #endif return static_cast(__builtin_memmove(__s1, __s2, __n)); @@ -674,8 +677,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION { if (__n == 0) return __s1; -#ifdef __cpp_lib_is_constant_evaluated - if (std::is_constant_evaluated()) +#if __cplusplus >= 202002L + if (std::__is_constant_evaluated()) return __gnu_cxx::char_traits::copy(__s1, __s2, __n); #endif return static_cast(__builtin_memcpy(__s1, __s2, __n)); @@ -686,8 +689,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION { if (__n == 0) return __s; -#ifdef __cpp_lib_is_constant_evaluated - if (std::is_constant_evaluated()) +#if __cplusplus >= 202002L + if (std::__is_constant_evaluated()) return __gnu_cxx::char_traits::assign(__s, __n, __a); #endif return static_cast(__builtin_memset(__s, __a, __n)); @@ -747,8 +750,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION static _GLIBCXX17_CONSTEXPR void assign(char_type& __c1, const char_type& __c2) noexcept { -#if __cpp_constexpr_dynamic_alloc && __cpp_lib_is_constant_evaluated - if (std::is_constant_evaluated()) +#if __cpp_constexpr_dynamic_alloc + if (std::__is_constant_evaluated()) std::construct_at(__builtin_addressof(__c1), __c2); else #endif @@ -797,8 +800,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION { if (__n == 0) return __s1; -#ifdef __cpp_lib_is_constant_evaluated - if (std::is_constant_evaluated()) +#if __cplusplus >= 202002L + if (std::__is_constant_evaluated()) return __gnu_cxx::char_traits::move(__s1, __s2, __n); #endif return (static_cast @@ -810,8 +813,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION { if (__n == 0) return __s1; -#ifdef __cpp_lib_is_constant_evaluated - if (std::is_constant_evaluated()) +#if __cplusplus >= 202002L + if (std::__is_constant_evaluated()) return __gnu_cxx::char_traits::copy(__s1, __s2, __n); #endif return (static_cast @@ -868,8 +871,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION static _GLIBCXX17_CONSTEXPR void assign(char_type& __c1, const char_type& __c2) noexcept { -#if __cpp_constexpr_dynamic_alloc && __cpp_lib_is_constant_evaluated - if (std::is_constant_evaluated()) +#if __cpp_constexpr_dynamic_alloc + if (std::__is_constant_evaluated()) std::construct_at(__builtin_addressof(__c1), __c2); else #endif @@ -918,8 +921,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION { if (__n == 0) return __s1; -#ifdef __cpp_lib_is_constant_evaluated - if (std::is_constant_evaluated()) +#if __cplusplus >= 202002L + if (std::__is_constant_evaluated()) return __gnu_cxx::char_traits::move(__s1, __s2, __n); #endif return (static_cast @@ -931,8 +934,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION { if (__n == 0) return __s1; -#ifdef __cpp_lib_is_constant_evaluated - if (std::is_constant_evaluated()) +#if __cplusplus >= 202002L + if (std::__is_constant_evaluated()) return __gnu_cxx::char_traits::copy(__s1, __s2, __n); #endif return (static_cast diff --git a/libstdc++-v3/include/bits/cow_string.h b/libstdc++-v3/include/bits/cow_string.h index 4fae1d02981..d6ddf3489d1 100644 --- a/libstdc++-v3/include/bits/cow_string.h +++ b/libstdc++-v3/include/bits/cow_string.h @@ -37,7 +37,7 @@ #ifdef __cpp_lib_is_constant_evaluated // Support P1032R1 in C++20 (but not P0980R1 for COW strings). # define __cpp_lib_constexpr_string 201811L -#elif __cplusplus >= 201703L && _GLIBCXX_HAVE_BUILTIN_IS_CONSTANT_EVALUATED +#elif __cplusplus >= 201703L && _GLIBCXX_HAVE_IS_CONSTANT_EVALUATED // Support P0426R1 changes to char_traits in C++17. # define __cpp_lib_constexpr_string 201611L #endif diff --git a/libstdc++-v3/include/bits/ranges_algobase.h b/libstdc++-v3/include/bits/ranges_algobase.h index 9929e5e828b..74b8e9c4d59 100644 --- a/libstdc++-v3/include/bits/ranges_algobase.h +++ b/libstdc++-v3/include/bits/ranges_algobase.h @@ -251,9 +251,7 @@ namespace ranges } else if constexpr (sized_sentinel_for<_Sent, _Iter>) { -#ifdef __cpp_lib_is_constant_evaluated - if (!std::is_constant_evaluated()) -#endif + if (!std::__is_constant_evaluated()) { if constexpr (__memcpyable<_Iter, _Out>::__value) { @@ -388,9 +386,7 @@ namespace ranges } else if constexpr (sized_sentinel_for<_Sent, _Iter>) { -#ifdef __cpp_lib_is_constant_evaluated - if (!std::is_constant_evaluated()) -#endif + if (!std::__is_constant_evaluated()) { if constexpr (__memcpyable<_Out, _Iter>::__value) { @@ -535,9 +531,7 @@ namespace ranges && __is_byte>::__value && integral<_Tp>) { -#ifdef __cpp_lib_is_constant_evaluated - if (!std::is_constant_evaluated()) -#endif + if (!std::__is_constant_evaluated()) { __builtin_memset(__first, static_cast(__value), diff --git a/libstdc++-v3/include/bits/ranges_cmp.h b/libstdc++-v3/include/bits/ranges_cmp.h index 1d7da30dddf..098022e63a2 100644 --- a/libstdc++-v3/include/bits/ranges_cmp.h +++ b/libstdc++-v3/include/bits/ranges_cmp.h @@ -119,10 +119,9 @@ namespace ranges { if constexpr (__detail::__less_builtin_ptr_cmp<_Tp, _Up>) { -#ifdef __cpp_lib_is_constant_evaluated - if (std::is_constant_evaluated()) + if (std::__is_constant_evaluated()) return __t < __u; -#endif + auto __x = reinterpret_cast<__UINTPTR_TYPE__>( static_cast(std::forward<_Tp>(__t))); auto __y = reinterpret_cast<__UINTPTR_TYPE__>( diff --git a/libstdc++-v3/include/bits/stl_algobase.h b/libstdc++-v3/include/bits/stl_algobase.h index f441165714b..984a5bf94b9 100644 --- a/libstdc++-v3/include/bits/stl_algobase.h +++ b/libstdc++-v3/include/bits/stl_algobase.h @@ -1826,11 +1826,10 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO __glibcxx_requires_valid_range(__first1, __last1); __glibcxx_requires_valid_range(__first2, __last2); -#if __cpp_lib_is_constant_evaluated using _Cat = decltype(__comp(*__first1, *__first2)); static_assert(same_as, _Cat>); - if (!std::is_constant_evaluated()) + if (!std::__is_constant_evaluated()) if constexpr (same_as<_Comp, __detail::_Synth3way> || same_as<_Comp, compare_three_way>) if constexpr (__is_byte_iter<_InputIter1>) @@ -1847,7 +1846,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO } return __lencmp; } -#endif // is_constant_evaluated + while (__first1 != __last1) { if (__first2 == __last2) diff --git a/libstdc++-v3/include/bits/stl_bvector.h b/libstdc++-v3/include/bits/stl_bvector.h index 68070685baf..7d93084fe37 100644 --- a/libstdc++-v3/include/bits/stl_bvector.h +++ b/libstdc++-v3/include/bits/stl_bvector.h @@ -625,8 +625,8 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER _M_allocate(size_t __n) { _Bit_pointer __p = _Bit_alloc_traits::allocate(_M_impl, _S_nword(__n)); -#if __has_builtin(__builtin_is_constant_evaluated) - if (__builtin_is_constant_evaluated()) +#if __cpp_lib_is_constant_evaluated + if (std::is_constant_evaluated()) { __n = _S_nword(__n); for (size_t __i = 0; __i < __n; ++__i) @@ -1524,8 +1524,8 @@ _GLIBCXX_END_NAMESPACE_CONTAINER inline void __fill_bvector_n(_Bit_type* __p, size_t __n, bool __x) _GLIBCXX_NOEXCEPT { -#if __has_builtin(__builtin_is_constant_evaluated) - if (__builtin_is_constant_evaluated()) +#if __cpp_lib_is_constant_evaluated + if (std::is_constant_evaluated()) { for (size_t __i = 0; __i < __n; ++__i) __p[__i] = __x ? ~0ul : 0ul; diff --git a/libstdc++-v3/include/bits/stl_construct.h b/libstdc++-v3/include/bits/stl_construct.h index e53ed0d9f91..dd621f24bc2 100644 --- a/libstdc++-v3/include/bits/stl_construct.h +++ b/libstdc++-v3/include/bits/stl_construct.h @@ -108,8 +108,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION inline void _Construct(_Tp* __p, _Args&&... __args) { -#if __cplusplus >= 202002L && __has_builtin(__builtin_is_constant_evaluated) - if (__builtin_is_constant_evaluated()) +#if __cplusplus >= 202002L + if (std::__is_constant_evaluated()) { // Allow std::_Construct to be used in constant expressions. std::construct_at(__p, std::forward<_Args>(__args)...); @@ -188,8 +188,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION static_assert(is_destructible<_Value_type>::value, "value type is destructible"); #endif -#if __cplusplus > 201703L && defined __cpp_lib_is_constant_evaluated - if (std::is_constant_evaluated()) +#if __cplusplus >= 202002L + if (std::__is_constant_evaluated()) return _Destroy_aux::__destroy(__first, __last); #endif std::_Destroy_aux<__has_trivial_destructor(_Value_type)>:: @@ -237,8 +237,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION static_assert(is_destructible<_Value_type>::value, "value type is destructible"); #endif -#if __cplusplus > 201703L && defined __cpp_lib_is_constant_evaluated - if (std::is_constant_evaluated()) +#if __cplusplus >= 202002L + if (std::__is_constant_evaluated()) return _Destroy_n_aux::__destroy_n(__first, __count); #endif return std::_Destroy_n_aux<__has_trivial_destructor(_Value_type)>:: diff --git a/libstdc++-v3/include/bits/stl_function.h b/libstdc++-v3/include/bits/stl_function.h index 5de8c3234f7..92e9dc75a80 100644 --- a/libstdc++-v3/include/bits/stl_function.h +++ b/libstdc++-v3/include/bits/stl_function.h @@ -428,11 +428,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION operator()(_Tp* __x, _Tp* __y) const _GLIBCXX_NOTHROW { #if __cplusplus >= 201402L -#ifdef _GLIBCXX_HAVE_BUILTIN_IS_CONSTANT_EVALUATED - if (__builtin_is_constant_evaluated()) -#else - if (__builtin_constant_p(__x > __y)) -#endif + if (std::__is_constant_evaluated()) return __x > __y; #endif return (__UINTPTR_TYPE__)__x > (__UINTPTR_TYPE__)__y; @@ -447,11 +443,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION operator()(_Tp* __x, _Tp* __y) const _GLIBCXX_NOTHROW { #if __cplusplus >= 201402L -#ifdef _GLIBCXX_HAVE_BUILTIN_IS_CONSTANT_EVALUATED - if (__builtin_is_constant_evaluated()) -#else - if (__builtin_constant_p(__x < __y)) -#endif + if (std::__is_constant_evaluated()) return __x < __y; #endif return (__UINTPTR_TYPE__)__x < (__UINTPTR_TYPE__)__y; @@ -466,11 +458,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION operator()(_Tp* __x, _Tp* __y) const _GLIBCXX_NOTHROW { #if __cplusplus >= 201402L -#ifdef _GLIBCXX_HAVE_BUILTIN_IS_CONSTANT_EVALUATED - if (__builtin_is_constant_evaluated()) -#else - if (__builtin_constant_p(__x >= __y)) -#endif + if (std::__is_constant_evaluated()) return __x >= __y; #endif return (__UINTPTR_TYPE__)__x >= (__UINTPTR_TYPE__)__y; @@ -485,11 +473,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION operator()(_Tp* __x, _Tp* __y) const _GLIBCXX_NOTHROW { #if __cplusplus >= 201402L -#ifdef _GLIBCXX_HAVE_BUILTIN_IS_CONSTANT_EVALUATED - if (__builtin_is_constant_evaluated()) -#else - if (__builtin_constant_p(__x <= __y)) -#endif + if (std::__is_constant_evaluated()) return __x <= __y; #endif return (__UINTPTR_TYPE__)__x <= (__UINTPTR_TYPE__)__y; diff --git a/libstdc++-v3/include/bits/stl_vector.h b/libstdc++-v3/include/bits/stl_vector.h index 36b2cff3d78..7c37d85c8fa 100644 --- a/libstdc++-v3/include/bits/stl_vector.h +++ b/libstdc++-v3/include/bits/stl_vector.h @@ -195,8 +195,9 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER static _GLIBCXX20_CONSTEXPR void _S_adjust(_Vector_impl& __impl, pointer __prev, pointer __curr) { -#if __has_builtin(__builtin_is_constant_evaluated) - if (!__builtin_is_constant_evaluated()) +#if __cpp_lib_is_constant_evaluated + if (std::is_constant_evaluated()) + return; #endif __sanitizer_annotate_contiguous_container(__impl._M_start, __impl._M_end_of_storage, __prev, __curr); diff --git a/libstdc++-v3/include/debug/helper_functions.h b/libstdc++-v3/include/debug/helper_functions.h index c0144ced979..1547154bca1 100644 --- a/libstdc++-v3/include/debug/helper_functions.h +++ b/libstdc++-v3/include/debug/helper_functions.h @@ -124,11 +124,8 @@ namespace __gnu_debug inline bool __check_singular(_Iterator const& __x) { - return -#ifdef _GLIBCXX_HAVE_BUILTIN_IS_CONSTANT_EVALUATED - __builtin_is_constant_evaluated() ? false : -#endif - __check_singular_aux(std::__addressof(__x)); + return ! std::__is_constant_evaluated() + && __check_singular_aux(std::__addressof(__x)); } /** Non-NULL pointers are nonsingular. */ @@ -136,13 +133,7 @@ namespace __gnu_debug _GLIBCXX_CONSTEXPR inline bool __check_singular(_Tp* const& __ptr) - { - return -#ifdef _GLIBCXX_HAVE_BUILTIN_IS_CONSTANT_EVALUATED - __builtin_is_constant_evaluated() ? false : -#endif - __ptr == 0; - } + { return __ptr == 0; } /** We say that integral types for a valid range, and defer to other * routines to realize what to do with integral types instead of diff --git a/libstdc++-v3/include/std/array b/libstdc++-v3/include/std/array index 413f8e2be01..e632de15aff 100644 --- a/libstdc++-v3/include/std/array +++ b/libstdc++-v3/include/std/array @@ -310,14 +310,12 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION constexpr __detail::__synth3way_t<_Tp> operator<=>(const array<_Tp, _Nm>& __a, const array<_Tp, _Nm>& __b) { -#ifdef __cpp_lib_is_constant_evaluated if constexpr (_Nm && __is_memcmp_ordered<_Tp>::__value) - if (!std::is_constant_evaluated()) + if (!std::__is_constant_evaluated()) { constexpr size_t __n = _Nm * sizeof(_Tp); return __builtin_memcmp(__a.data(), __b.data(), __n) <=> 0; } -#endif for (size_t __i = 0; __i < _Nm; ++__i) { diff --git a/libstdc++-v3/include/std/bit b/libstdc++-v3/include/std/bit index 4facb615014..454f9fce409 100644 --- a/libstdc++-v3/include/std/bit +++ b/libstdc++-v3/include/std/bit @@ -315,12 +315,11 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION // representable as a value of _Tp, and so the result is undefined. // Want that undefined behaviour to be detected in constant expressions, // by UBSan, and by debug assertions. -#ifdef _GLIBCXX_HAVE_BUILTIN_IS_CONSTANT_EVALUATED - if (!__builtin_is_constant_evaluated()) + if (!std::__is_constant_evaluated()) { __glibcxx_assert( __shift_exponent != __int_traits<_Tp>::__digits ); } -#endif + using __promoted_type = decltype(__x << 1); if _GLIBCXX17_CONSTEXPR (!is_same<__promoted_type, _Tp>::value) { diff --git a/libstdc++-v3/include/std/type_traits b/libstdc++-v3/include/std/type_traits index d3693b1069e..4df7e627edb 100644 --- a/libstdc++-v3/include/std/type_traits +++ b/libstdc++-v3/include/std/type_traits @@ -3510,15 +3510,20 @@ template #endif // C++23 -#ifdef _GLIBCXX_HAVE_BUILTIN_IS_CONSTANT_EVALUATED - +#if _GLIBCXX_HAVE_IS_CONSTANT_EVALUATED #define __cpp_lib_is_constant_evaluated 201811L /// Returns true only when called during constant evaluation. /// @since C++20 constexpr inline bool is_constant_evaluated() noexcept - { return __builtin_is_constant_evaluated(); } + { +#if __cpp_if_consteval >= 202106L + if consteval { return true; } else { return false; } +#else + return __builtin_is_constant_evaluated(); +#endif + } #endif /// @cond undocumented diff --git a/libstdc++-v3/include/std/version b/libstdc++-v3/include/std/version index 2d4e9bf4eee..eb612f57c73 100644 --- a/libstdc++-v3/include/std/version +++ b/libstdc++-v3/include/std/version @@ -130,7 +130,7 @@ #define __cpp_lib_chrono 201611 #define __cpp_lib_clamp 201603 #if __cplusplus == 201703L // N.B. updated value in C++20 -# if _GLIBCXX_HAVE_BUILTIN_IS_CONSTANT_EVALUATED +# if _GLIBCXX_HAVE_IS_CONSTANT_EVALUATED # define __cpp_lib_constexpr_char_traits 201611L # define __cpp_lib_constexpr_string 201611L # endif @@ -195,7 +195,7 @@ #endif #define __cpp_lib_endian 201907L #define __cpp_lib_int_pow2 202002L -#ifdef _GLIBCXX_HAVE_BUILTIN_IS_CONSTANT_EVALUATED +#ifdef _GLIBCXX_HAVE_IS_CONSTANT_EVALUATED # define __cpp_lib_is_constant_evaluated 201811L #endif #define __cpp_lib_is_nothrow_convertible 201806L diff --git a/libstdc++-v3/libsupc++/compare b/libstdc++-v3/libsupc++/compare index 5aee89e3a6e..f095de7935f 100644 --- a/libstdc++-v3/libsupc++/compare +++ b/libstdc++-v3/libsupc++/compare @@ -555,7 +555,7 @@ namespace std { auto __pt = static_cast(__t); auto __pu = static_cast(__u); - if (__builtin_is_constant_evaluated()) + if (std::__is_constant_evaluated()) return __pt <=> __pu; auto __it = reinterpret_cast<__UINTPTR_TYPE__>(__pt); auto __iu = reinterpret_cast<__UINTPTR_TYPE__>(__pu); diff --git a/libstdc++-v3/testsuite/23_containers/array/tuple_interface/get_neg.cc b/libstdc++-v3/testsuite/23_containers/array/tuple_interface/get_neg.cc index 70742c14a7d..776ff5f771f 100644 --- a/libstdc++-v3/testsuite/23_containers/array/tuple_interface/get_neg.cc +++ b/libstdc++-v3/testsuite/23_containers/array/tuple_interface/get_neg.cc @@ -26,6 +26,6 @@ int n1 = std::get<1>(a); int n2 = std::get<1>(std::move(a)); int n3 = std::get<1>(ca); -// { dg-error "static assertion failed" "" { target *-*-* } 398 } -// { dg-error "static assertion failed" "" { target *-*-* } 407 } -// { dg-error "static assertion failed" "" { target *-*-* } 416 } +// { dg-error "static assertion failed" "" { target *-*-* } 396 } +// { dg-error "static assertion failed" "" { target *-*-* } 405 } +// { dg-error "static assertion failed" "" { target *-*-* } 414 }