[P2283R1] Implement constexpr specialized memory algorithms

Author: miscco

stl/inc/memory

@@ -1575,20 +1575,25 @@ namespace ranges {
     template <input_iterator _It, sentinel_for<_It> _Se, _No_throw_forward_iterator _Out,
         _No_throw_sentinel_for<_Out> _OSe>
         requires constructible_from<iter_value_t<_Out>, iter_rvalue_reference_t<_It>>
-    uninitialized_move_result<_It, _Out> _Uninitialized_move_unchecked(
+    _CONSTEXPR23_DYNALLOC uninitialized_move_result<_It, _Out> _Uninitialized_move_unchecked(
             _It _IFirst, const _Se _ILast, _Out _OFirst, const _OSe _OLast) {
         // clang-format on
         if constexpr (is_same_v<_Se, _It> && is_same_v<_OSe, _Out> && _Ptr_move_cat<_It, _Out>::_Really_trivial) {
-            return _Copy_memcpy_common(_IFirst, _ILast, _OFirst, _OLast);
-        } else {
-            _Uninitialized_backout _Backout{_STD move(_OFirst)};
-
-            for (; _IFirst != _ILast && _Backout._Last != _OLast; ++_IFirst) {
-                _Backout._Emplace_back(_RANGES iter_move(_IFirst));
+#ifdef __cpp_lib_constexpr_dynamic_alloc
+            if (!_STD is_constant_evaluated())
+#endif // __cpp_lib_constexpr_dynamic_alloc
+            {
+                return _Copy_memcpy_common(_IFirst, _ILast, _OFirst, _OLast);
             }
+        }
+
+        _Uninitialized_backout _Backout{_STD move(_OFirst)};
 
-            return {_STD move(_IFirst), _Backout._Release()};
+        for (; _IFirst != _ILast && _Backout._Last != _OLast; ++_IFirst) {
+            _Backout._Emplace_back(_RANGES iter_move(_IFirst));
         }
+
+        return {_STD move(_IFirst), _Backout._Release()};
     }
 } // namespace ranges
 #endif // __cpp_lib_concepts
@@ -1680,8 +1685,9 @@ _CONSTEXPR20_DYNALLOC _NoThrowFwdIt _Uninitialized_copy_unchecked(
     return _Backout._Release();
 }
 
+
 template <class _InIt, class _NoThrowFwdIt>
-_NoThrowFwdIt uninitialized_copy(const _InIt _First, const _InIt _Last, _NoThrowFwdIt _Dest) {
+_CONSTEXPR20_DYNALLOC _NoThrowFwdIt uninitialized_copy(const _InIt _First, const _InIt _Last, _NoThrowFwdIt _Dest) {
     // copy [_First, _Last) to raw [_Dest, ...)
     _Adl_verify_range(_First, _Last);
     auto _UFirst      = _Get_unwrapped(_First);
@@ -1755,28 +1761,39 @@ _CONSTEXPR20_DYNALLOC _Alloc_ptr_t<_Alloc> _Uninitialized_fill_n(
 
 // FUNCTION TEMPLATE uninitialized_fill
 template <class _NoThrowFwdIt, class _Tval>
-void uninitialized_fill(const _NoThrowFwdIt _First, const _NoThrowFwdIt _Last, const _Tval& _Val) {
+_CONSTEXPR20_DYNALLOC void uninitialized_fill(
+    const _NoThrowFwdIt _First, const _NoThrowFwdIt _Last, const _Tval& _Val) {
     // copy _Val throughout raw [_First, _Last)
     _Adl_verify_range(_First, _Last);
     auto _UFirst      = _Get_unwrapped(_First);
     const auto _ULast = _Get_unwrapped(_Last);
     if constexpr (_Fill_memset_is_safe<_Unwrapped_t<const _NoThrowFwdIt&>, _Tval>) {
-        _Fill_memset(_UFirst, _Val, static_cast<size_t>(_ULast - _UFirst));
-    } else {
-        if constexpr (_Fill_zero_memset_is_safe<_Unwrapped_t<const _NoThrowFwdIt&>, _Tval>) {
+#ifdef __cpp_lib_constexpr_dynamic_alloc
+        if (!_STD is_constant_evaluated())
+#endif // __cpp_lib_constexpr_dynamic_alloc
+        {
+            _Fill_memset(_UFirst, _Val, static_cast<size_t>(_ULast - _UFirst));
+            return;
+        }
+    }
+    if constexpr (_Fill_zero_memset_is_safe<_Unwrapped_t<const _NoThrowFwdIt&>, _Tval>) {
+#ifdef __cpp_lib_constexpr_dynamic_alloc
+        if (!_STD is_constant_evaluated())
+#endif // __cpp_lib_constexpr_dynamic_alloc
+        {
             if (_Is_all_bits_zero(_Val)) {
                 _Fill_zero_memset(_UFirst, static_cast<size_t>(_ULast - _UFirst));
                 return;
             }
         }
+    }
 
-        _Uninitialized_backout<_Unwrapped_t<const _NoThrowFwdIt&>> _Backout{_UFirst};
-        while (_Backout._Last != _ULast) {
-            _Backout._Emplace_back(_Val);
-        }
-
-        _Backout._Release();
+    _Uninitialized_backout<_Unwrapped_t<const _NoThrowFwdIt&>> _Backout{_UFirst};
+    while (_Backout._Last != _ULast) {
+        _Backout._Emplace_back(_Val);
     }
+
+    _Backout._Release();
 }
 
 // FUNCTION TEMPLATE _Uninitialized_value_construct_n WITH ALLOCATOR
@@ -1819,19 +1836,23 @@ _CONSTEXPR20_DYNALLOC _Alloc_ptr_t<_Alloc> _Uninitialized_value_construct_n(
 }
 
 template <class _NoThrowFwdIt, class _Diff>
-_NoThrowFwdIt _Uninitialized_value_construct_n_unchecked1(_NoThrowFwdIt _UFirst, _Diff _Count) {
+_CONSTEXPR20_DYNALLOC _NoThrowFwdIt _Uninitialized_value_construct_n_unchecked1(_NoThrowFwdIt _UFirst, _Diff _Count) {
     // value-initialize all elements in [_UFirst, _UFirst + _Count_raw)
     _STL_INTERNAL_CHECK(_Count >= 0);
     if constexpr (_Use_memset_value_construct_v<_NoThrowFwdIt>) {
-        return _Zero_range(_UFirst, _UFirst + _Count);
-    } else {
-        _Uninitialized_backout<_NoThrowFwdIt> _Backout{_UFirst};
-        for (; 0 < _Count; --_Count) {
-            _Backout._Emplace_back();
+#ifdef __cpp_lib_constexpr_dynamic_alloc
+        if (!_STD is_constant_evaluated())
+#endif // __cpp_lib_constexpr_dynamic_alloc
+        {
+            return _Zero_range(_UFirst, _UFirst + _Count);
         }
-
-        return _Backout._Release();
     }
+    _Uninitialized_backout<_NoThrowFwdIt> _Backout{_UFirst};
+    for (; 0 < _Count; --_Count) {
+        _Backout._Emplace_back();
+    }
+
+    return _Backout._Release();
 }
 
 #if _HAS_DEPRECATED_TEMPORARY_BUFFER

stl/inc/xmemory

@@ -135,6 +135,18 @@ _NODISCARD constexpr void* _Voidify_iter(_Iter _It) noexcept {
     }
 }
 
+// FUNCTION TEMPLATE default_construct_at
+#if _HAS_CXX20 // TRANSITION, _HAS_CXX23
+template <class _Ty, class = void_t<decltype(::new (_STD declval<void*>()) _Ty)>>
+#if 0 // TRANSITION, compiler suport
+_CONSTEXPR20_DYNALLOC
+#endif // compiler support
+_Ty* default_construct_at(_Ty* const _Location) noexcept(
+    noexcept(::new (_Voidify_iter(_Location)) _Ty)) /* strengthened */ {
+    return ::new (_Voidify_iter(_Location)) _Ty;
+}
+#endif // _HAS_CXX20
+
 // FUNCTION TEMPLATE construct_at
 #if _HAS_CXX20
 template <class _Ty, class... _Types,
@@ -4454,7 +4466,7 @@ void _Fill_zero_memset(_CtgIt _Dest, const size_t _Count) {
 }
 
 template <class _Ty>
-_NODISCARD bool _Is_all_bits_zero(const _Ty& _Val) {
+_NODISCARD _CONSTEXPR23_DYNALLOC bool _Is_all_bits_zero(const _Ty& _Val) {
     // checks if scalar type has all bits set to zero
     _STL_INTERNAL_STATIC_ASSERT(is_scalar_v<_Ty> && !is_member_pointer_v<_Ty>);
     constexpr _Ty _Zero{};

stl/inc/xutility

@@ -1162,13 +1162,19 @@
 #ifndef _M_CEE
 #define __cpp_lib_parallel_algorithm 201603L
 #endif // _M_CEE
-#define __cpp_lib_raw_memory_algorithms 201606L
-#define __cpp_lib_sample                201603L
-#define __cpp_lib_scoped_lock           201703L
-#define __cpp_lib_shared_ptr_weak_type  201606L
-#define __cpp_lib_string_view           201803L
-#define __cpp_lib_to_chars              201611L
-#define __cpp_lib_variant               201606L
+
+#if _HAS_CXX20 && defined(__cpp_lib_constexpr_dynamic_alloc) // TRANSITION, enable only in C++23 when available
+#define __cpp_lib_raw_memory_algorithms 202106L
+#else
+#define __cpp_lib_raw_memory_algorithms 202106L
+#endif
+
+#define __cpp_lib_sample               201603L
+#define __cpp_lib_scoped_lock          201703L
+#define __cpp_lib_shared_ptr_weak_type 201606L
+#define __cpp_lib_string_view          201803L
+#define __cpp_lib_to_chars             201611L
+#define __cpp_lib_variant              201606L
 #endif // _HAS_CXX17
 
 #if _HAS_CXX17
@@ -1325,6 +1331,13 @@
 #define _CONSTEXPR20_CONTAINER inline
 #endif
 
+// Functions that became constexpr in C++23 via P2283
+#ifdef __cpp_lib_constexpr_dynamic_alloc // TRANSITION, enable only in C++23 when available
+#define _CONSTEXPR23_DYNALLOC constexpr
+#else
+#define _CONSTEXPR23_DYNALLOC inline
+#endif
+
 #ifdef _RTC_CONVERSION_CHECKS_ENABLED
 #ifndef _ALLOW_RTCc_IN_STL
 #error /RTCc rejects conformant code, so it is not supported by the C++ Standard Library. Either remove this \

stl/inc/yvals_core.h

@@ -215,8 +215,8 @@ struct memcpy_test {
         }
 
         { // Validate input shorter
-            int input[]  = {13, 55, 12345};
-            int output[] = {-1, -1, -1, -1};
+            int input[] = {13, 55, 12345};
+            int output[4];
 
             auto result = ranges::uninitialized_copy(input, output);
             assert(result.in == end(input));
@@ -226,8 +226,8 @@ struct memcpy_test {
         }
 
         { // Validate output shorter
-            int input[]  = {13, 55, 12345, 42};
-            int output[] = {-1, -1, -1};
+            int input[] = {13, 55, 12345, 42};
+            int output[3];
 
             auto result = ranges::uninitialized_copy(input, output);
             assert(++result.in == end(input));

tests/std/tests/P0896R4_ranges_alg_uninitialized_copy/test.cpp

@@ -216,8 +216,8 @@ struct memcpy_test {
         }
 
         { // Validate input shorter
-            int input[]  = {13, 55, 12345};
-            int output[] = {-1, -1, -1, -1};
+            int input[] = {13, 55, 12345};
+            int output[4];
 
             auto result = ranges::uninitialized_move(input, output);
             assert(result.in == end(input));
@@ -227,8 +227,8 @@ struct memcpy_test {
         }
 
         { // Validate output shorter
-            int input[]  = {13, 55, 12345, 42};
-            int output[] = {-1, -1, -1};
+            int input[] = {13, 55, 12345, 42};
+            int output[3];
 
             auto result = ranges::uninitialized_move(input, output);
             assert(++result.in == end(input));

tests/std/tests/P0896R4_ranges_alg_uninitialized_move/test.cpp

@@ -0,0 +1,4 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+RUNALL_INCLUDE ..\concepts_matrix.lst