From patchwork Fri Nov 26 23:26:30 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Jonathan Wakely X-Patchwork-Id: 48207 Return-Path: X-Original-To: patchwork@sourceware.org Delivered-To: patchwork@sourceware.org Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id 5BC793857C4C for ; Fri, 26 Nov 2021 23:27:16 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org 5BC793857C4C DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gcc.gnu.org; s=default; t=1637969236; bh=YnTkW36DvNdmMuIq6c02k84u1ZRDpWMsIC/+KoPMKwM=; h=References:In-Reply-To:Date:Subject:To:List-Id:List-Unsubscribe: List-Archive:List-Post:List-Help:List-Subscribe:From:Reply-To:Cc: From; b=SepNjgYyN/qmxwIWbRVzNGszRZFjHaKnITjuRAKZJ9Cz/OTNLR+RAi7Bad5bY9asa E7N0hvHuT55xbZMH42KSq+5cloqXB4M1hK5L6sQkmx7wHDYhMLCmwXNr/qq6Thgd20 3PkJppBVtjENFef+Mbk48ypm1KrkIqnYVQxmmoPA= 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.133.124]) by sourceware.org (Postfix) with ESMTPS id 3450C3858D39 for ; Fri, 26 Nov 2021 23:26:44 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.1 sourceware.org 3450C3858D39 Received: from mail-yb1-f200.google.com (mail-yb1-f200.google.com [209.85.219.200]) by relay.mimecast.com with ESMTP with STARTTLS (version=TLSv1.2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id us-mta-268-drhz1yjOPAeJLO8o62lwcw-1; Fri, 26 Nov 2021 18:26:42 -0500 X-MC-Unique: drhz1yjOPAeJLO8o62lwcw-1 Received: by mail-yb1-f200.google.com with SMTP id d27-20020a25addb000000b005c2355d9052so12556510ybe.3 for ; Fri, 26 Nov 2021 15:26:42 -0800 (PST) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:mime-version:references:in-reply-to:from:date :message-id:subject:to:cc; bh=YnTkW36DvNdmMuIq6c02k84u1ZRDpWMsIC/+KoPMKwM=; b=LqNsMDWFIJClhkmBT/JqZnXeTrVfCqhmZPSZIkCnKHMZcuhHCyesd8o09AWjmwIhHS qbb+dD3KdWo/gWKq6KwdFQH04URHqm6qUpXtk8PtcscEGNTVm3mg8ofbB+Cc0EJO9Ugw KyWYz149Rd6xcH+VFB4FgXyir/OXE6iA/7WoYb0I+db+iCwoPmtnoGRzpT7oWJRHpLTy llewDpeuTkJBYxo2hf27zR5BB5euagRXdHlgCRxhHBP09uTso1Uwwk8+ZGNV/UePFoc3 zeelCLsau5rhC057C5YR3uNQ0CCAXvlmIGFLtbvppnhctQSSeT1QklFIgLqoBJItripz DsEw== X-Gm-Message-State: AOAM532+rckO/NJv2K/GRWeN8ig8WXFgloVPV+44/zPr9Q3ypdef0rzM 1bMxgVnL2WMgRqtxRcj1k3m0zv2XVDCokpuDdY2VOy2xc2xs6jFjhKa8sNMcyu0wESL72w99Oqq vi8lc4+/U+EVciFpJ+xjLxxsJLY7XkOEUng== X-Received: by 2002:a25:238a:: with SMTP id j132mr19367308ybj.530.1637969201761; Fri, 26 Nov 2021 15:26:41 -0800 (PST) X-Google-Smtp-Source: ABdhPJwU8Tq3eQIR6FsWgQOQTQhL79xgujI1URiNmxrvwuaA3MFWR6n4Z+YsSASm98Rff6jwntMsnjuNwnOzcMeWBPg= X-Received: by 2002:a25:238a:: with SMTP id j132mr19367289ybj.530.1637969201539; Fri, 26 Nov 2021 15:26:41 -0800 (PST) MIME-Version: 1.0 References: <20211126122925.1626170-1-jwakely@redhat.com> <20211126123950.GG2646553@tucnak> In-Reply-To: Date: Fri, 26 Nov 2021 23:26:30 +0000 Message-ID: Subject: [PATCH v2] libstdc++: Define std::__is_constant_evaluated() for internal use To: Jakub Jelinek X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com X-Spam-Status: No, score=-13.9 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_H2, SPF_HELO_NONE, SPF_NONE, TXREP autolearn=ham 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 Cc: libstdc++ , gcc Patches Errors-To: gcc-patches-bounces+patchwork=sourceware.org@gcc.gnu.org Sender: "Gcc-patches" On Fri, 26 Nov 2021 at 12:43, Jonathan Wakely wrote: > > On Fri, 26 Nov 2021 at 12:39, Jakub Jelinek wrote: > > > > On Fri, Nov 26, 2021 at 12:29:25PM +0000, Jonathan Wakely via Gcc-patches wrote: > > > + // Internal version of std::is_constant_evaluated() for C++11. > > > + // This can be used without checking if the compiler supports the built-in. > > > + constexpr inline bool > > > + __is_constant_evaluated() noexcept > > > + { > > > > When you have such a nice one spot, shouldn't it: > > #if __cpp_if_consteval >= 202106L > > if consteval > > { > > return true; > > } > > else > > { > > return false; > > } > > #elif __has_builtin(__builtin_is_constant_evaluated) > > ... > > > > Theoretically not all compilers need to support the builtin and in C++23 > > mode if consteval should be slightly more efficient. > > Yes, good idea. We actually still have two spots, because we still > have std::is_constant_evaluated as well, which is only defined if it > actually works. But we can use the same implementation in there (or > make it call std::__is_constant_evaluated()). I'll prepare a new patch > soon. > > > One disadvantage of std::__is_constant_evaluated() is that Marek's > > warning for if constexpr (std::is_constant_evaluated()) will not trigger > > if __is_constant_evaluated() is used instead. But I'd hope testsuite > > coverage would discover it quickly if such bug would appear... > > Yes, and I hope I won't make that mistake anyway, or miss it in reviews. > > It's a good warning for users, but I like to think I don't need it > (and now we start the sweepstake on how many days until I push a patch > making exactly that mistake ;-) Who had -15 days in the sweepstake? r12-5187 did it. Fixed in r12-5552. Here's a new WIP patch for __is_constant_evaluated. commit 3569c5f76ad9fc91b327a97e9cb6d5dd0f38358a Author: Jonathan Wakely Date: Fri Nov 26 23:25:03 2021 libstdc++: Define std::__is_constant_evaluated() for internal use 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. 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..ff23161e8d8 100644 --- a/libstdc++-v3/include/bits/c++config +++ b/libstdc++-v3/include/bits/c++config @@ -495,6 +495,25 @@ 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. + _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 +526,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 +781,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 +791,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 bafca7bb313..3d881a8a683 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 4587757637e..9015ba00dec 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 c5aae8bab03..cc73bcfec6b 100644 --- a/libstdc++-v3/include/std/bit +++ b/libstdc++-v3/include/std/bit @@ -265,12 +265,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..9866bf4cd96 100644 --- a/libstdc++-v3/include/std/type_traits +++ b/libstdc++-v3/include/std/type_traits @@ -32,9 +32,8 @@ #pragma GCC system_header #if __cplusplus < 201103L -# include +#include #else - #include namespace std _GLIBCXX_VISIBILITY(default) @@ -3510,15 +3509,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 fd7e1258543..e7e4d9fda82 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 }