"__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
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);
}
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
#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
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]));
_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();
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);
__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();
#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
#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)
# 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
#undef _GLIBCXX_HAS_BUILTIN
-
// PSTL configuration
#if __cplusplus >= 201703L
#include <bits/postypes.h> // For streampos
#include <cwchar> // For WEOF, wmemmove, wmemset, etc.
+#if __cplusplus >= 201103L
+# include <type_traits>
+#endif
#if __cplusplus >= 202002L
# include <compare>
# include <bits/stl_construct.h>
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
{
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;
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]);
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);
#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
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
{
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]))
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<char_type>::length(__s);
#endif
return __builtin_strlen(__s);
{
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<char_type>::find(__s, __n, __a);
#endif
return static_cast<const char_type*>(__builtin_memchr(__s, __a, __n));
{
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<char_type>::move(__s1, __s2, __n);
#endif
return static_cast<char_type*>(__builtin_memmove(__s1, __s2, __n));
{
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<char_type>::copy(__s1, __s2, __n);
#endif
return static_cast<char_type*>(__builtin_memcpy(__s1, __s2, __n));
{
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<char_type>::assign(__s, __n, __a);
#endif
return static_cast<char_type*>(__builtin_memset(__s, __a, __n));
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
{
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<char_type>::compare(__s1, __s2, __n);
#endif
return wmemcmp(__s1, __s2, __n);
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<char_type>::length(__s);
#endif
return wcslen(__s);
{
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<char_type>::find(__s, __n, __a);
#endif
return wmemchr(__s, __a, __n);
{
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<char_type>::move(__s1, __s2, __n);
#endif
return wmemmove(__s1, __s2, __n);
{
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<char_type>::copy(__s1, __s2, __n);
#endif
return wmemcpy(__s1, __s2, __n);
{
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<char_type>::assign(__s, __n, __a);
#endif
return wmemset(__s, __a, __n);
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
{
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<char_type>::compare(__s1, __s2, __n);
#endif
return __builtin_memcmp(__s1, __s2, __n);
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<char_type>::length(__s);
#endif
size_t __i = 0;
{
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<char_type>::find(__s, __n, __a);
#endif
return static_cast<const char_type*>(__builtin_memchr(__s, __a, __n));
{
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<char_type>::move(__s1, __s2, __n);
#endif
return static_cast<char_type*>(__builtin_memmove(__s1, __s2, __n));
{
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<char_type>::copy(__s1, __s2, __n);
#endif
return static_cast<char_type*>(__builtin_memcpy(__s1, __s2, __n));
{
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<char_type>::assign(__s, __n, __a);
#endif
return static_cast<char_type*>(__builtin_memset(__s, __a, __n));
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
{
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<char_type>::move(__s1, __s2, __n);
#endif
return (static_cast<char_type*>
{
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<char_type>::copy(__s1, __s2, __n);
#endif
return (static_cast<char_type*>
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
{
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<char_type>::move(__s1, __s2, __n);
#endif
return (static_cast<char_type*>
{
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<char_type>::copy(__s1, __s2, __n);
#endif
return (static_cast<char_type*>
#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
}
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)
{
}
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)
{
&& __is_byte<remove_pointer_t<_Out>>::__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<unsigned char>(__value),
{
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<const volatile void*>(std::forward<_Tp>(__t)));
auto __y = reinterpret_cast<__UINTPTR_TYPE__>(
__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<common_comparison_category_t<_Cat>, _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>)
}
return __lencmp;
}
-#endif // is_constant_evaluated
+
while (__first1 != __last1)
{
if (__first2 == __last2)
_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)
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;
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)...);
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<false>::__destroy(__first, __last);
#endif
std::_Destroy_aux<__has_trivial_destructor(_Value_type)>::
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<false>::__destroy_n(__first, __count);
#endif
return std::_Destroy_n_aux<__has_trivial_destructor(_Value_type)>::
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;
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;
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;
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;
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);
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. */
_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
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)
{
// 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)
{
#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
#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
#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
{
auto __pt = static_cast<const volatile void*>(__t);
auto __pu = static_cast<const volatile void*>(__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);
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 }