[libcxx-commits] [libcxx] 5629d49 - Reapply "[libc++][ranges]Refactor `copy{, _backward}` and `move{, _backward}`"
Konstantin Varlamov via libcxx-commits
libcxx-commits at lists.llvm.org
Fri Jan 13 16:57:37 PST 2023
Author: varconst
Date: 2023-01-13T16:57:13-08:00
New Revision: 5629d492df388bf6b5532a2a5c1ef5fd27d65ab0
URL: https://github.com/llvm/llvm-project/commit/5629d492df388bf6b5532a2a5c1ef5fd27d65ab0
DIFF: https://github.com/llvm/llvm-project/commit/5629d492df388bf6b5532a2a5c1ef5fd27d65ab0.diff
LOG: Reapply "[libc++][ranges]Refactor `copy{,_backward}` and `move{,_backward}`"
This reverts commit a6e1080b87db8fbe0e1afadd96af5a3c0bd5e279.
Fix the conditions when the `memmove` optimization can be applied and refactor them out into a reusable type trait, fix and significantly expand the tests.
Differential Revision: https://reviews.llvm.org/D139235
Added:
libcxx/include/__algorithm/copy_move_common.h
libcxx/include/__type_traits/is_always_bitcastable.h
libcxx/test/libcxx/algorithms/alg.modifying.operations/copy_move_nontrivial.pass.cpp
libcxx/test/libcxx/algorithms/alg.modifying.operations/copy_move_trivial.pass.cpp
libcxx/test/libcxx/algorithms/alg.modifying.operations/copy_move_unwrap_reverse.pass.cpp
libcxx/test/libcxx/type_traits/is_always_bitcastable.compile.pass.cpp
Modified:
libcxx/include/CMakeLists.txt
libcxx/include/__algorithm/copy.h
libcxx/include/__algorithm/copy_backward.h
libcxx/include/__algorithm/move.h
libcxx/include/__algorithm/move_backward.h
libcxx/include/__algorithm/ranges_copy.h
libcxx/include/__algorithm/ranges_copy_backward.h
libcxx/include/__algorithm/ranges_copy_n.h
libcxx/include/__algorithm/ranges_move.h
libcxx/include/__algorithm/ranges_move_backward.h
libcxx/include/__algorithm/ranges_set_difference.h
libcxx/include/__algorithm/ranges_set_symmetric_difference.h
libcxx/include/__algorithm/ranges_set_union.h
libcxx/include/__algorithm/rotate.h
libcxx/include/__algorithm/set_difference.h
libcxx/include/__algorithm/set_symmetric_difference.h
libcxx/include/__algorithm/set_union.h
libcxx/include/__iterator/reverse_iterator.h
libcxx/include/algorithm
libcxx/include/module.modulemap.in
libcxx/include/valarray
libcxx/test/libcxx/private_headers.verify.cpp
libcxx/test/libcxx/transitive_includes/cxx2b.csv
libcxx/test/std/algorithms/alg.modifying.operations/alg.copy/ranges.copy_backward.pass.cpp
libcxx/test/std/algorithms/alg.modifying.operations/alg.move/ranges.move.pass.cpp
libcxx/test/std/algorithms/alg.modifying.operations/alg.move/ranges.move_backward.pass.cpp
libcxx/test/std/time/time.cal/time.cal.day/time.cal.day.nonmembers/ostream.pass.cpp
libcxx/test/std/time/time.duration/time.duration.nonmember/ostream.pass.cpp
libcxx/test/std/time/time.syn/formatter.duration.pass.cpp
libcxx/test/std/utilities/charconv/charconv.to.chars/integral.pass.cpp
libcxx/test/std/utilities/format/format.functions/P2418.pass.cpp
libcxx/test/std/utilities/format/format.tuple/format.functions.vformat.pass.cpp
Removed:
libcxx/test/libcxx/algorithms/alg.modifying.operations/copy.pass.cpp
################################################################################
diff --git a/libcxx/include/CMakeLists.txt b/libcxx/include/CMakeLists.txt
index 7320bdf9acc05..06c5eb16da1c6 100644
--- a/libcxx/include/CMakeLists.txt
+++ b/libcxx/include/CMakeLists.txt
@@ -9,6 +9,7 @@ set(files
__algorithm/copy.h
__algorithm/copy_backward.h
__algorithm/copy_if.h
+ __algorithm/copy_move_common.h
__algorithm/copy_n.h
__algorithm/count.h
__algorithm/count_if.h
@@ -587,6 +588,7 @@ set(files
__type_traits/is_abstract.h
__type_traits/is_aggregate.h
__type_traits/is_allocator.h
+ __type_traits/is_always_bitcastable.h
__type_traits/is_arithmetic.h
__type_traits/is_array.h
__type_traits/is_assignable.h
diff --git a/libcxx/include/__algorithm/copy.h b/libcxx/include/__algorithm/copy.h
index ed3004995741f..f33d7feda067f 100644
--- a/libcxx/include/__algorithm/copy.h
+++ b/libcxx/include/__algorithm/copy.h
@@ -9,20 +9,11 @@
#ifndef _LIBCPP___ALGORITHM_COPY_H
#define _LIBCPP___ALGORITHM_COPY_H
-#include <__algorithm/unwrap_iter.h>
-#include <__algorithm/unwrap_range.h>
+#include <__algorithm/copy_move_common.h>
+#include <__algorithm/iterator_operations.h>
#include <__config>
-#include <__iterator/iterator_traits.h>
-#include <__iterator/reverse_iterator.h>
-#include <__type_traits/enable_if.h>
-#include <__type_traits/is_copy_constructible.h>
-#include <__type_traits/is_same.h>
-#include <__type_traits/is_trivially_copy_assignable.h>
-#include <__type_traits/is_trivially_copyable.h>
-#include <__type_traits/remove_const.h>
#include <__utility/move.h>
#include <__utility/pair.h>
-#include <cstring>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header
@@ -30,82 +21,43 @@
_LIBCPP_BEGIN_NAMESPACE_STD
-// copy
+struct __copy_loop {
+ template <class _InIter, class _Sent, class _OutIter>
+ _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 pair<_InIter, _OutIter>
+ operator()(_InIter __first, _Sent __last, _OutIter __result) const {
+ while (__first != __last) {
+ *__result = *__first;
+ ++__first;
+ ++__result;
+ }
-template <class _InIter, class _Sent, class _OutIter>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
-pair<_InIter, _OutIter> __copy_impl(_InIter __first, _Sent __last, _OutIter __result) {
- while (__first != __last) {
- *__result = *__first;
- ++__first;
- ++__result;
+ return std::make_pair(std::move(__first), std::move(__result));
}
- return pair<_InIter, _OutIter>(std::move(__first), std::move(__result));
-}
+};
-template <class _InValueT,
- class _OutValueT,
- class = __enable_if_t<is_same<__remove_const_t<_InValueT>, _OutValueT>::value
- && is_trivially_copy_assignable<_OutValueT>::value> >
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
-pair<_InValueT*, _OutValueT*> __copy_impl(_InValueT* __first, _InValueT* __last, _OutValueT* __result) {
- if (__libcpp_is_constant_evaluated()
-// TODO: Remove this once GCC supports __builtin_memmove during constant evaluation
-#ifndef _LIBCPP_COMPILER_GCC
- && !is_trivially_copyable<_InValueT>::value
-#endif
- )
- return std::__copy_impl<_InValueT*, _InValueT*, _OutValueT*>(__first, __last, __result);
- const size_t __n = static_cast<size_t>(__last - __first);
- if (__n > 0)
- ::__builtin_memmove(__result, __first, __n * sizeof(_OutValueT));
- return std::make_pair(__first + __n, __result + __n);
-}
+struct __copy_trivial {
+ // At this point, the iterators have been unwrapped so any `contiguous_iterator` has been unwrapped to a pointer.
+ template <class _In, class _Out,
+ __enable_if_t<__can_lower_copy_assignment_to_memmove<_In, _Out>::value, int> = 0>
+ _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 pair<_In*, _Out*>
+ operator()(_In* __first, _In* __last, _Out* __result) const {
+ return std::__copy_trivial_impl(__first, __last, __result);
+ }
+};
-template <class _InIter, class _OutIter,
- __enable_if_t<is_same<__remove_const_t<__iter_value_type<_InIter> >, __iter_value_type<_OutIter> >::value
- && __is_cpp17_contiguous_iterator<typename _InIter::iterator_type>::value
- && __is_cpp17_contiguous_iterator<typename _OutIter::iterator_type>::value
- && is_trivially_copy_assignable<__iter_value_type<_OutIter> >::value
- && __is_reverse_iterator<_InIter>::value
- && __is_reverse_iterator<_OutIter>::value, int> = 0>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
+template <class _AlgPolicy, class _InIter, class _Sent, class _OutIter>
pair<_InIter, _OutIter>
-__copy_impl(_InIter __first, _InIter __last, _OutIter __result) {
- auto __first_base = std::__unwrap_iter(__first.base());
- auto __last_base = std::__unwrap_iter(__last.base());
- auto __result_base = std::__unwrap_iter(__result.base());
- auto __result_first = __result_base - (__first_base - __last_base);
- std::__copy_impl(__last_base, __first_base, __result_first);
- return std::make_pair(__last, _OutIter(std::__rewrap_iter(__result.base(), __result_first)));
-}
-
-template <class _InIter, class _Sent, class _OutIter,
- __enable_if_t<!(is_copy_constructible<_InIter>::value
- && is_copy_constructible<_Sent>::value
- && is_copy_constructible<_OutIter>::value), int> = 0 >
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
-pair<_InIter, _OutIter> __copy(_InIter __first, _Sent __last, _OutIter __result) {
- return std::__copy_impl(std::move(__first), std::move(__last), std::move(__result));
-}
-
-template <class _InIter, class _Sent, class _OutIter,
- __enable_if_t<is_copy_constructible<_InIter>::value
- && is_copy_constructible<_Sent>::value
- && is_copy_constructible<_OutIter>::value, int> = 0>
inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
-pair<_InIter, _OutIter> __copy(_InIter __first, _Sent __last, _OutIter __result) {
- auto __range = std::__unwrap_range(__first, __last);
- auto __ret = std::__copy_impl(std::move(__range.first), std::move(__range.second), std::__unwrap_iter(__result));
- return std::make_pair(
- std::__rewrap_range<_Sent>(__first, __ret.first), std::__rewrap_iter(__result, __ret.second));
+__copy(_InIter __first, _Sent __last, _OutIter __result) {
+ return std::__dispatch_copy_or_move<_AlgPolicy, __copy_loop, __copy_trivial>(
+ std::move(__first), std::move(__last), std::move(__result));
}
template <class _InputIterator, class _OutputIterator>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
_OutputIterator
copy(_InputIterator __first, _InputIterator __last, _OutputIterator __result) {
- return std::__copy(__first, __last, __result).second;
+ return std::__copy<_ClassicAlgPolicy>(__first, __last, __result).second;
}
_LIBCPP_END_NAMESPACE_STD
diff --git a/libcxx/include/__algorithm/copy_backward.h b/libcxx/include/__algorithm/copy_backward.h
index 1db4f1e2d53ed..be8c1ae9a4ba8 100644
--- a/libcxx/include/__algorithm/copy_backward.h
+++ b/libcxx/include/__algorithm/copy_backward.h
@@ -9,19 +9,12 @@
#ifndef _LIBCPP___ALGORITHM_COPY_BACKWARD_H
#define _LIBCPP___ALGORITHM_COPY_BACKWARD_H
-#include <__algorithm/copy.h>
+#include <__algorithm/copy_move_common.h>
#include <__algorithm/iterator_operations.h>
-#include <__algorithm/ranges_copy.h>
-#include <__algorithm/unwrap_iter.h>
-#include <__concepts/same_as.h>
#include <__config>
-#include <__iterator/iterator_traits.h>
-#include <__iterator/reverse_iterator.h>
-#include <__ranges/subrange.h>
+#include <__type_traits/is_copy_constructible.h>
#include <__utility/move.h>
#include <__utility/pair.h>
-#include <cstring>
-#include <type_traits>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header
@@ -29,32 +22,51 @@
_LIBCPP_BEGIN_NAMESPACE_STD
-template <class _AlgPolicy, class _InputIterator, class _OutputIterator,
- __enable_if_t<is_same<_AlgPolicy, _ClassicAlgPolicy>::value, int> = 0>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 pair<_InputIterator, _OutputIterator>
-__copy_backward(_InputIterator __first, _InputIterator __last, _OutputIterator __result) {
- auto __ret = std::__copy(
- __unconstrained_reverse_iterator<_InputIterator>(__last),
- __unconstrained_reverse_iterator<_InputIterator>(__first),
- __unconstrained_reverse_iterator<_OutputIterator>(__result));
- return pair<_InputIterator, _OutputIterator>(__ret.first.base(), __ret.second.base());
-}
+template <class _AlgPolicy>
+struct __copy_backward_loop {
+ template <class _InIter, class _Sent, class _OutIter>
+ _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 pair<_InIter, _OutIter>
+ operator()(_InIter __first, _Sent __last, _OutIter __result) const {
+ auto __last_iter = _IterOps<_AlgPolicy>::next(__first, __last);
+ auto __original_last_iter = __last_iter;
+
+ while (__first != __last_iter) {
+ *--__result = *--__last_iter;
+ }
+
+ return std::make_pair(std::move(__original_last_iter), std::move(__result));
+ }
+};
-#if _LIBCPP_STD_VER > 17
-template <class _AlgPolicy, class _Iter1, class _Sent1, class _Iter2,
- __enable_if_t<is_same<_AlgPolicy, _RangeAlgPolicy>::value, int> = 0>
-_LIBCPP_HIDE_FROM_ABI constexpr pair<_Iter1, _Iter2> __copy_backward(_Iter1 __first, _Sent1 __last, _Iter2 __result) {
- auto __last_iter = _IterOps<_AlgPolicy>::next(__first, std::move(__last));
- auto __reverse_range = std::__reverse_range(std::ranges::subrange(std::move(__first), __last_iter));
- auto __ret = ranges::copy(std::move(__reverse_range), std::make_reverse_iterator(__result));
- return std::make_pair(__last_iter, __ret.out.base());
+struct __copy_backward_trivial {
+ // At this point, the iterators have been unwrapped so any `contiguous_iterator` has been unwrapped to a pointer.
+ template <class _In, class _Out,
+ __enable_if_t<__can_lower_copy_assignment_to_memmove<_In, _Out>::value, int> = 0>
+ _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 pair<_In*, _Out*>
+ operator()(_In* __first, _In* __last, _Out* __result) const {
+ return std::__copy_backward_trivial_impl(__first, __last, __result);
+ }
+};
+
+template <class _AlgPolicy, class _BidirectionalIterator1, class _Sentinel, class _BidirectionalIterator2>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
+pair<_BidirectionalIterator1, _BidirectionalIterator2>
+__copy_backward(_BidirectionalIterator1 __first, _Sentinel __last, _BidirectionalIterator2 __result) {
+ return std::__dispatch_copy_or_move<_AlgPolicy, __copy_backward_loop<_AlgPolicy>, __copy_backward_trivial>(
+ std::move(__first), std::move(__last), std::move(__result));
}
-#endif // _LIBCPP_STD_VER > 17
template <class _BidirectionalIterator1, class _BidirectionalIterator2>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _BidirectionalIterator2
-copy_backward(_BidirectionalIterator1 __first, _BidirectionalIterator1 __last, _BidirectionalIterator2 __result) {
- return std::__copy_backward<_ClassicAlgPolicy>(__first, __last, __result).second;
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
+_BidirectionalIterator2
+copy_backward(_BidirectionalIterator1 __first, _BidirectionalIterator1 __last,
+ _BidirectionalIterator2 __result)
+{
+ static_assert(std::is_copy_constructible<_BidirectionalIterator1>::value &&
+ std::is_copy_constructible<_BidirectionalIterator1>::value, "Iterators must be copy constructible.");
+
+ return std::__copy_backward<_ClassicAlgPolicy>(
+ std::move(__first), std::move(__last), std::move(__result)).second;
}
_LIBCPP_END_NAMESPACE_STD
diff --git a/libcxx/include/__algorithm/copy_move_common.h b/libcxx/include/__algorithm/copy_move_common.h
new file mode 100644
index 0000000000000..b88c14911b9b6
--- /dev/null
+++ b/libcxx/include/__algorithm/copy_move_common.h
@@ -0,0 +1,163 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___ALGORITHM_COPY_MOVE_COMMON_H
+#define _LIBCPP___ALGORITHM_COPY_MOVE_COMMON_H
+
+#include <__algorithm/iterator_operations.h>
+#include <__algorithm/unwrap_iter.h>
+#include <__algorithm/unwrap_range.h>
+#include <__config>
+#include <__iterator/iterator_traits.h>
+#include <__memory/pointer_traits.h>
+#include <__type_traits/enable_if.h>
+#include <__type_traits/is_always_bitcastable.h>
+#include <__type_traits/is_constant_evaluated.h>
+#include <__type_traits/is_copy_constructible.h>
+#include <__type_traits/is_trivially_assignable.h>
+#include <__type_traits/is_trivially_copyable.h>
+#include <__type_traits/is_volatile.h>
+#include <__utility/move.h>
+#include <__utility/pair.h>
+#include <cstddef>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+# pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+// Type traits.
+
+template <class _From, class _To>
+struct __can_lower_copy_assignment_to_memmove {
+ static const bool value =
+ // If the types are always bitcastable, it's valid to do a bitwise copy between them.
+ __is_always_bitcastable<_From, _To>::value &&
+ // Reject conversions that wouldn't be performed by the regular built-in assignment (e.g. between arrays).
+ is_trivially_assignable<_To&, const _From&>::value &&
+ // `memmove` doesn't accept `volatile` pointers, make sure the optimization SFINAEs away in that case.
+ !is_volatile<_From>::value &&
+ !is_volatile<_To>::value;
+};
+
+template <class _From, class _To>
+struct __can_lower_move_assignment_to_memmove {
+ static const bool value =
+ __is_always_bitcastable<_From, _To>::value &&
+ is_trivially_assignable<_To&, _From&&>::value &&
+ !is_volatile<_From>::value &&
+ !is_volatile<_To>::value;
+};
+
+// `memmove` algorithms implementation.
+
+template <class _In, class _Out>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 pair<_In*, _Out*>
+__copy_trivial_impl(_In* __first, _In* __last, _Out* __result) {
+ const size_t __n = static_cast<size_t>(__last - __first);
+ ::__builtin_memmove(__result, __first, __n * sizeof(_Out));
+
+ return std::make_pair(__last, __result + __n);
+}
+
+template <class _In, class _Out>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 pair<_In*, _Out*>
+__copy_backward_trivial_impl(_In* __first, _In* __last, _Out* __result) {
+ const size_t __n = static_cast<size_t>(__last - __first);
+ __result -= __n;
+
+ ::__builtin_memmove(__result, __first, __n * sizeof(_Out));
+
+ return std::make_pair(__last, __result);
+}
+
+// Iterator unwrapping and dispatching to the correct overload.
+
+template <class _F1, class _F2>
+struct __overload : _F1, _F2 {
+ using _F1::operator();
+ using _F2::operator();
+};
+
+template <class _InIter, class _Sent, class _OutIter, class = void>
+struct __can_rewrap : false_type {};
+
+template <class _InIter, class _Sent, class _OutIter>
+struct __can_rewrap<_InIter,
+ _Sent,
+ _OutIter,
+ // Note that sentinels are always copy-constructible.
+ __enable_if_t< is_copy_constructible<_InIter>::value &&
+ is_copy_constructible<_OutIter>::value > > : true_type {};
+
+template <class _Algorithm,
+ class _InIter,
+ class _Sent,
+ class _OutIter,
+ __enable_if_t<__can_rewrap<_InIter, _Sent, _OutIter>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 pair<_InIter, _OutIter>
+__unwrap_and_dispatch(_InIter __first, _Sent __last, _OutIter __out_first) {
+ auto __range = std::__unwrap_range(__first, std::move(__last));
+ auto __result = _Algorithm()(std::move(__range.first), std::move(__range.second), std::__unwrap_iter(__out_first));
+ return std::make_pair(std::__rewrap_range<_Sent>(std::move(__first), std::move(__result.first)),
+ std::__rewrap_iter(std::move(__out_first), std::move(__result.second)));
+}
+
+template <class _Algorithm,
+ class _InIter,
+ class _Sent,
+ class _OutIter,
+ __enable_if_t<!__can_rewrap<_InIter, _Sent, _OutIter>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 pair<_InIter, _OutIter>
+__unwrap_and_dispatch(_InIter __first, _Sent __last, _OutIter __out_first) {
+ return _Algorithm()(std::move(__first), std::move(__last), std::move(__out_first));
+}
+
+template <class _IterOps, class _InValue, class _OutIter, class = void>
+struct __can_copy_without_conversion : false_type {};
+
+template <class _IterOps, class _InValue, class _OutIter>
+struct __can_copy_without_conversion<
+ _IterOps,
+ _InValue,
+ _OutIter,
+ __enable_if_t<is_same<_InValue, typename _IterOps::template __value_type<_OutIter> >::value> > : true_type {};
+
+template <class _AlgPolicy,
+ class _NaiveAlgorithm,
+ class _OptimizedAlgorithm,
+ class _InIter,
+ class _Sent,
+ class _OutIter>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 pair<_InIter, _OutIter>
+__dispatch_copy_or_move(_InIter __first, _Sent __last, _OutIter __out_first) {
+#ifdef _LIBCPP_COMPILER_GCC
+ // GCC doesn't support `__builtin_memmove` during constant evaluation.
+ if (__libcpp_is_constant_evaluated()) {
+ return std::__unwrap_and_dispatch<_NaiveAlgorithm>(std::move(__first), std::move(__last), std::move(__out_first));
+ }
+#else
+ // In Clang, `__builtin_memmove` only supports fully trivially copyable types (just having trivial copy assignment is
+ // insufficient). Also, conversions are not supported.
+ if (__libcpp_is_constant_evaluated()) {
+ using _InValue = typename _IterOps<_AlgPolicy>::template __value_type<_InIter>;
+ if (!is_trivially_copyable<_InValue>::value ||
+ !__can_copy_without_conversion<_IterOps<_AlgPolicy>, _InValue, _OutIter>::value) {
+ return std::__unwrap_and_dispatch<_NaiveAlgorithm>(std::move(__first), std::move(__last), std::move(__out_first));
+ }
+ }
+#endif // _LIBCPP_COMPILER_GCC
+
+ using _Algorithm = __overload<_NaiveAlgorithm, _OptimizedAlgorithm>;
+ return std::__unwrap_and_dispatch<_Algorithm>(std::move(__first), std::move(__last), std::move(__out_first));
+}
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___ALGORITHM_COPY_MOVE_COMMON_H
diff --git a/libcxx/include/__algorithm/move.h b/libcxx/include/__algorithm/move.h
index 2109f9a081c44..2581a417b5581 100644
--- a/libcxx/include/__algorithm/move.h
+++ b/libcxx/include/__algorithm/move.h
@@ -9,19 +9,12 @@
#ifndef _LIBCPP___ALGORITHM_MOVE_H
#define _LIBCPP___ALGORITHM_MOVE_H
+#include <__algorithm/copy_move_common.h>
#include <__algorithm/iterator_operations.h>
-#include <__algorithm/unwrap_iter.h>
#include <__config>
-#include <__iterator/iterator_traits.h>
-#include <__iterator/reverse_iterator.h>
-#include <__type_traits/is_constant_evaluated.h>
#include <__type_traits/is_copy_constructible.h>
-#include <__type_traits/is_trivially_copyable.h>
-#include <__type_traits/is_trivially_move_assignable.h>
-#include <__type_traits/remove_const.h>
#include <__utility/move.h>
#include <__utility/pair.h>
-#include <cstring>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header
@@ -29,93 +22,46 @@
_LIBCPP_BEGIN_NAMESPACE_STD
-// move
-
-template <class _AlgPolicy, class _InIter, class _Sent, class _OutIter>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
-pair<_InIter, _OutIter> __move_impl(_InIter __first, _Sent __last, _OutIter __result) {
- while (__first != __last) {
- *__result = _IterOps<_AlgPolicy>::__iter_move(__first);
- ++__first;
- ++__result;
+template <class _AlgPolicy>
+struct __move_loop {
+ template <class _InIter, class _Sent, class _OutIter>
+ _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 pair<_InIter, _OutIter>
+ operator()(_InIter __first, _Sent __last, _OutIter __result) const {
+ while (__first != __last) {
+ *__result = _IterOps<_AlgPolicy>::__iter_move(__first);
+ ++__first;
+ ++__result;
+ }
+ return std::make_pair(std::move(__first), std::move(__result));
}
- return std::make_pair(std::move(__first), std::move(__result));
-}
-
-template <class _AlgPolicy,
- class _InType,
- class _OutType,
- class = __enable_if_t<is_same<__remove_const_t<_InType>, _OutType>::value
- && is_trivially_move_assignable<_OutType>::value> >
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
-pair<_InType*, _OutType*> __move_impl(_InType* __first, _InType* __last, _OutType* __result) {
- if (__libcpp_is_constant_evaluated()
-// TODO: Remove this once GCC supports __builtin_memmove during constant evaluation
-#ifndef _LIBCPP_COMPILER_GCC
- && !is_trivially_copyable<_InType>::value
-#endif
- )
- return std::__move_impl<_AlgPolicy, _InType*, _InType*, _OutType*>(__first, __last, __result);
- const size_t __n = static_cast<size_t>(__last - __first);
- ::__builtin_memmove(__result, __first, __n * sizeof(_OutType));
- return std::make_pair(__first + __n, __result + __n);
-}
-
-template <class>
-struct __is_trivially_move_assignable_unwrapped_impl : false_type {};
-
-template <class _Type>
-struct __is_trivially_move_assignable_unwrapped_impl<_Type*> : is_trivially_move_assignable<_Type> {};
-
-template <class _Iter>
-struct __is_trivially_move_assignable_unwrapped
- : __is_trivially_move_assignable_unwrapped_impl<decltype(std::__unwrap_iter<_Iter>(std::declval<_Iter>()))> {};
-
-template <class _AlgPolicy,
- class _InIter,
- class _OutIter,
- __enable_if_t<is_same<__remove_const_t<typename iterator_traits<_InIter>::value_type>,
- typename iterator_traits<_OutIter>::value_type>::value
- && __is_cpp17_contiguous_iterator<_InIter>::value
- && __is_cpp17_contiguous_iterator<_OutIter>::value
- && is_trivially_move_assignable<__iter_value_type<_OutIter> >::value, int> = 0>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17
-pair<reverse_iterator<_InIter>, reverse_iterator<_OutIter> >
-__move_impl(reverse_iterator<_InIter> __first,
- reverse_iterator<_InIter> __last,
- reverse_iterator<_OutIter> __result) {
- auto __first_base = std::__unwrap_iter(__first.base());
- auto __last_base = std::__unwrap_iter(__last.base());
- auto __result_base = std::__unwrap_iter(__result.base());
- auto __result_first = __result_base - (__first_base - __last_base);
- std::__move_impl<_AlgPolicy>(__last_base, __first_base, __result_first);
- return std::make_pair(__last, reverse_iterator<_OutIter>(std::__rewrap_iter(__result.base(), __result_first)));
-}
-
-template <class _AlgPolicy, class _InIter, class _Sent, class _OutIter>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
-__enable_if_t<is_copy_constructible<_InIter>::value
- && is_copy_constructible<_Sent>::value
- && is_copy_constructible<_OutIter>::value, pair<_InIter, _OutIter> >
-__move(_InIter __first, _Sent __last, _OutIter __result) {
- auto __ret = std::__move_impl<_AlgPolicy>(
- std::__unwrap_iter(__first), std::__unwrap_iter(__last), std::__unwrap_iter(__result));
- return std::make_pair(std::__rewrap_iter(__first, __ret.first), std::__rewrap_iter(__result, __ret.second));
-}
+};
+
+struct __move_trivial {
+ // At this point, the iterators have been unwrapped so any `contiguous_iterator` has been unwrapped to a pointer.
+ template <class _In, class _Out,
+ __enable_if_t<__can_lower_move_assignment_to_memmove<_In, _Out>::value, int> = 0>
+ _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 pair<_In*, _Out*>
+ operator()(_In* __first, _In* __last, _Out* __result) const {
+ return std::__copy_trivial_impl(__first, __last, __result);
+ }
+};
template <class _AlgPolicy, class _InIter, class _Sent, class _OutIter>
inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
-__enable_if_t<!is_copy_constructible<_InIter>::value
- || !is_copy_constructible<_Sent>::value
- || !is_copy_constructible<_OutIter>::value, pair<_InIter, _OutIter> >
+pair<_InIter, _OutIter>
__move(_InIter __first, _Sent __last, _OutIter __result) {
- return std::__move_impl<_AlgPolicy>(std::move(__first), std::move(__last), std::move(__result));
+ return std::__dispatch_copy_or_move<_AlgPolicy, __move_loop<_AlgPolicy>, __move_trivial>(
+ std::move(__first), std::move(__last), std::move(__result));
}
template <class _InputIterator, class _OutputIterator>
inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
_OutputIterator move(_InputIterator __first, _InputIterator __last, _OutputIterator __result) {
- return std::__move<_ClassicAlgPolicy>(__first, __last, __result).second;
+ static_assert(is_copy_constructible<_InputIterator>::value, "Iterators has to be copy constructible.");
+ static_assert(is_copy_constructible<_OutputIterator>::value, "The output iterator has to be copy constructible.");
+
+ return std::__move<_ClassicAlgPolicy>(
+ std::move(__first), std::move(__last), std::move(__result)).second;
}
_LIBCPP_END_NAMESPACE_STD
diff --git a/libcxx/include/__algorithm/move_backward.h b/libcxx/include/__algorithm/move_backward.h
index 02aae26fc4499..6636ca6667cef 100644
--- a/libcxx/include/__algorithm/move_backward.h
+++ b/libcxx/include/__algorithm/move_backward.h
@@ -9,12 +9,12 @@
#ifndef _LIBCPP___ALGORITHM_MOVE_BACKWARD_H
#define _LIBCPP___ALGORITHM_MOVE_BACKWARD_H
+#include <__algorithm/copy_move_common.h>
#include <__algorithm/iterator_operations.h>
-#include <__algorithm/unwrap_iter.h>
#include <__config>
+#include <__type_traits/is_copy_constructible.h>
#include <__utility/move.h>
-#include <cstring>
-#include <type_traits>
+#include <__utility/pair.h>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header
@@ -22,57 +22,41 @@
_LIBCPP_BEGIN_NAMESPACE_STD
-template <class _AlgPolicy, class _InputIterator, class _OutputIterator>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
-_OutputIterator
-__move_backward_constexpr(_InputIterator __first, _InputIterator __last, _OutputIterator __result)
-{
- while (__first != __last)
- *--__result = _IterOps<_AlgPolicy>::__iter_move(--__last);
- return __result;
-}
+template <class _AlgPolicy>
+struct __move_backward_loop {
+ template <class _InIter, class _Sent, class _OutIter>
+ _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 pair<_InIter, _OutIter>
+ operator()(_InIter __first, _Sent __last, _OutIter __result) const {
+ auto __last_iter = _IterOps<_AlgPolicy>::next(__first, __last);
+ auto __original_last_iter = __last_iter;
-template <class _AlgPolicy, class _InputIterator, class _OutputIterator>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
-_OutputIterator
-__move_backward_impl(_InputIterator __first, _InputIterator __last, _OutputIterator __result)
-{
- return _VSTD::__move_backward_constexpr<_AlgPolicy>(__first, __last, __result);
-}
-
-template <class _AlgPolicy, class _Tp, class _Up>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
-typename enable_if
-<
- is_same<__remove_const_t<_Tp>, _Up>::value &&
- is_trivially_move_assignable<_Up>::value,
- _Up*
->::type
-__move_backward_impl(_Tp* __first, _Tp* __last, _Up* __result)
-{
- const size_t __n = static_cast<size_t>(__last - __first);
- if (__n > 0)
- {
- __result -= __n;
- _VSTD::memmove(__result, __first, __n * sizeof(_Up));
+ while (__first != __last_iter) {
+ *--__result = _IterOps<_AlgPolicy>::__iter_move(--__last_iter);
}
- return __result;
-}
-template <class _AlgPolicy, class _BidirectionalIterator1, class _BidirectionalIterator2>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-_BidirectionalIterator2
-__move_backward(_BidirectionalIterator1 __first, _BidirectionalIterator1 __last,
- _BidirectionalIterator2 __result)
-{
- if (__libcpp_is_constant_evaluated()) {
- return _VSTD::__move_backward_constexpr<_AlgPolicy>(__first, __last, __result);
- } else {
- return _VSTD::__rewrap_iter(__result,
- _VSTD::__move_backward_impl<_AlgPolicy>(_VSTD::__unwrap_iter(__first),
- _VSTD::__unwrap_iter(__last),
- _VSTD::__unwrap_iter(__result)));
- }
+ return std::make_pair(std::move(__original_last_iter), std::move(__result));
+ }
+};
+
+struct __move_backward_trivial {
+ // At this point, the iterators have been unwrapped so any `contiguous_iterator` has been unwrapped to a pointer.
+ template <class _In, class _Out,
+ __enable_if_t<__can_lower_move_assignment_to_memmove<_In, _Out>::value, int> = 0>
+ _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 pair<_In*, _Out*>
+ operator()(_In* __first, _In* __last, _Out* __result) const {
+ return std::__copy_backward_trivial_impl(__first, __last, __result);
+ }
+};
+
+template <class _AlgPolicy, class _BidirectionalIterator1, class _Sentinel, class _BidirectionalIterator2>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
+pair<_BidirectionalIterator1, _BidirectionalIterator2>
+__move_backward(_BidirectionalIterator1 __first, _Sentinel __last, _BidirectionalIterator2 __result) {
+ static_assert(std::is_copy_constructible<_BidirectionalIterator1>::value &&
+ std::is_copy_constructible<_BidirectionalIterator1>::value, "Iterators must be copy constructible.");
+
+ return std::__dispatch_copy_or_move<_AlgPolicy, __move_backward_loop<_AlgPolicy>, __move_backward_trivial>(
+ std::move(__first), std::move(__last), std::move(__result));
}
template <class _BidirectionalIterator1, class _BidirectionalIterator2>
@@ -81,7 +65,8 @@ _BidirectionalIterator2
move_backward(_BidirectionalIterator1 __first, _BidirectionalIterator1 __last,
_BidirectionalIterator2 __result)
{
- return std::__move_backward<_ClassicAlgPolicy>(std::move(__first), std::move(__last), std::move(__result));
+ return std::__move_backward<_ClassicAlgPolicy>(
+ std::move(__first), std::move(__last), std::move(__result)).second;
}
_LIBCPP_END_NAMESPACE_STD
diff --git a/libcxx/include/__algorithm/ranges_copy.h b/libcxx/include/__algorithm/ranges_copy.h
index 87a6a1e1361f1..bb02c84efbdb4 100644
--- a/libcxx/include/__algorithm/ranges_copy.h
+++ b/libcxx/include/__algorithm/ranges_copy.h
@@ -11,6 +11,7 @@
#include <__algorithm/copy.h>
#include <__algorithm/in_out_result.h>
+#include <__algorithm/iterator_operations.h>
#include <__config>
#include <__functional/identity.h>
#include <__iterator/concepts.h>
@@ -40,7 +41,7 @@ struct __fn {
requires indirectly_copyable<_InIter, _OutIter>
_LIBCPP_HIDE_FROM_ABI constexpr
copy_result<_InIter, _OutIter> operator()(_InIter __first, _Sent __last, _OutIter __result) const {
- auto __ret = std::__copy(std::move(__first), std::move(__last), std::move(__result));
+ auto __ret = std::__copy<_RangeAlgPolicy>(std::move(__first), std::move(__last), std::move(__result));
return {std::move(__ret.first), std::move(__ret.second)};
}
@@ -48,7 +49,7 @@ struct __fn {
requires indirectly_copyable<iterator_t<_Range>, _OutIter>
_LIBCPP_HIDE_FROM_ABI constexpr
copy_result<borrowed_iterator_t<_Range>, _OutIter> operator()(_Range&& __r, _OutIter __result) const {
- auto __ret = std::__copy(ranges::begin(__r), ranges::end(__r), std::move(__result));
+ auto __ret = std::__copy<_RangeAlgPolicy>(ranges::begin(__r), ranges::end(__r), std::move(__result));
return {std::move(__ret.first), std::move(__ret.second)};
}
};
diff --git a/libcxx/include/__algorithm/ranges_copy_backward.h b/libcxx/include/__algorithm/ranges_copy_backward.h
index 67977201fa66c..f41af66f39fbd 100644
--- a/libcxx/include/__algorithm/ranges_copy_backward.h
+++ b/libcxx/include/__algorithm/ranges_copy_backward.h
@@ -14,7 +14,6 @@
#include <__algorithm/iterator_operations.h>
#include <__config>
#include <__iterator/concepts.h>
-#include <__iterator/reverse_iterator.h>
#include <__ranges/access.h>
#include <__ranges/concepts.h>
#include <__ranges/dangling.h>
diff --git a/libcxx/include/__algorithm/ranges_copy_n.h b/libcxx/include/__algorithm/ranges_copy_n.h
index 38a0a308d30ac..04bb80b3ba1ae 100644
--- a/libcxx/include/__algorithm/ranges_copy_n.h
+++ b/libcxx/include/__algorithm/ranges_copy_n.h
@@ -11,6 +11,7 @@
#include <__algorithm/copy.h>
#include <__algorithm/in_out_result.h>
+#include <__algorithm/iterator_operations.h>
#include <__algorithm/ranges_copy.h>
#include <__config>
#include <__functional/identity.h>
@@ -51,7 +52,7 @@ struct __fn {
template <random_access_iterator _InIter, class _DiffType, random_access_iterator _OutIter>
_LIBCPP_HIDE_FROM_ABI constexpr static
copy_n_result<_InIter, _OutIter> __go(_InIter __first, _DiffType __n, _OutIter __result) {
- auto __ret = std::__copy(__first, __first + __n, __result);
+ auto __ret = std::__copy<_RangeAlgPolicy>(__first, __first + __n, __result);
return {__ret.first, __ret.second};
}
diff --git a/libcxx/include/__algorithm/ranges_move.h b/libcxx/include/__algorithm/ranges_move.h
index 94f9970ed2089..46a0970f834ad 100644
--- a/libcxx/include/__algorithm/ranges_move.h
+++ b/libcxx/include/__algorithm/ranges_move.h
@@ -14,7 +14,6 @@
#include <__algorithm/move.h>
#include <__config>
#include <__iterator/concepts.h>
-#include <__iterator/iter_move.h>
#include <__ranges/access.h>
#include <__ranges/concepts.h>
#include <__ranges/dangling.h>
diff --git a/libcxx/include/__algorithm/ranges_move_backward.h b/libcxx/include/__algorithm/ranges_move_backward.h
index 134e0877374df..d4e8eb1a50089 100644
--- a/libcxx/include/__algorithm/ranges_move_backward.h
+++ b/libcxx/include/__algorithm/ranges_move_backward.h
@@ -10,12 +10,12 @@
#define _LIBCPP___ALGORITHM_RANGES_MOVE_BACKWARD_H
#include <__algorithm/in_out_result.h>
-#include <__algorithm/ranges_move.h>
+#include <__algorithm/iterator_operations.h>
+#include <__algorithm/move_backward.h>
#include <__config>
#include <__iterator/concepts.h>
#include <__iterator/iter_move.h>
#include <__iterator/next.h>
-#include <__iterator/reverse_iterator.h>
#include <__ranges/access.h>
#include <__ranges/concepts.h>
#include <__ranges/dangling.h>
@@ -40,11 +40,8 @@ struct __fn {
template <class _InIter, class _Sent, class _OutIter>
_LIBCPP_HIDE_FROM_ABI constexpr static
move_backward_result<_InIter, _OutIter> __move_backward_impl(_InIter __first, _Sent __last, _OutIter __result) {
- auto __last_iter = ranges::next(__first, std::move(__last));
- auto __ret = ranges::move(std::make_reverse_iterator(__last_iter),
- std::make_reverse_iterator(__first),
- std::make_reverse_iterator(__result));
- return {std::move(__last_iter), std::move(__ret.out.base())};
+ auto __ret = std::__move_backward<_RangeAlgPolicy>(std::move(__first), std::move(__last), std::move(__result));
+ return {std::move(__ret.first), std::move(__ret.second)};
}
template <bidirectional_iterator _InIter, sentinel_for<_InIter> _Sent, bidirectional_iterator _OutIter>
diff --git a/libcxx/include/__algorithm/ranges_set_
diff erence.h b/libcxx/include/__algorithm/ranges_set_
diff erence.h
index 398ccc975f225..607dd687a5de6 100644
--- a/libcxx/include/__algorithm/ranges_set_
diff erence.h
+++ b/libcxx/include/__algorithm/ranges_set_
diff erence.h
@@ -10,6 +10,7 @@
#define _LIBCPP___ALGORITHM_RANGES_SET_DIFFERENCE_H
#include <__algorithm/in_out_result.h>
+#include <__algorithm/iterator_operations.h>
#include <__algorithm/make_projected.h>
#include <__algorithm/set_
diff erence.h>
#include <__config>
@@ -60,7 +61,7 @@ struct __fn {
_Comp __comp = {},
_Proj1 __proj1 = {},
_Proj2 __proj2 = {}) const {
- auto __ret = std::__set_
diff erence(
+ auto __ret = std::__set_
diff erence<_RangeAlgPolicy>(
__first1, __last1, __first2, __last2, __result, ranges::__make_projected_comp(__comp, __proj1, __proj2));
return {std::move(__ret.first), std::move(__ret.second)};
}
@@ -81,7 +82,7 @@ struct __fn {
_Comp __comp = {},
_Proj1 __proj1 = {},
_Proj2 __proj2 = {}) const {
- auto __ret = std::__set_
diff erence(
+ auto __ret = std::__set_
diff erence<_RangeAlgPolicy>(
ranges::begin(__range1),
ranges::end(__range1),
ranges::begin(__range2),
diff --git a/libcxx/include/__algorithm/ranges_set_symmetric_
diff erence.h b/libcxx/include/__algorithm/ranges_set_symmetric_
diff erence.h
index b0c79537b178e..bc4a9065503b4 100644
--- a/libcxx/include/__algorithm/ranges_set_symmetric_
diff erence.h
+++ b/libcxx/include/__algorithm/ranges_set_symmetric_
diff erence.h
@@ -10,6 +10,7 @@
#define _LIBCPP___ALGORITHM_RANGES_SET_SYMMETRIC_DIFFERENCE_H
#include <__algorithm/in_in_out_result.h>
+#include <__algorithm/iterator_operations.h>
#include <__algorithm/make_projected.h>
#include <__algorithm/set_symmetric_
diff erence.h>
#include <__config>
@@ -58,7 +59,7 @@ struct __fn {
_Comp __comp = {},
_Proj1 __proj1 = {},
_Proj2 __proj2 = {}) const {
- auto __ret = std::__set_symmetric_
diff erence(
+ auto __ret = std::__set_symmetric_
diff erence<_RangeAlgPolicy>(
std::move(__first1),
std::move(__last1),
std::move(__first2),
@@ -92,7 +93,7 @@ struct __fn {
_Comp __comp = {},
_Proj1 __proj1 = {},
_Proj2 __proj2 = {}) const {
- auto __ret = std::__set_symmetric_
diff erence(
+ auto __ret = std::__set_symmetric_
diff erence<_RangeAlgPolicy>(
ranges::begin(__range1),
ranges::end(__range1),
ranges::begin(__range2),
diff --git a/libcxx/include/__algorithm/ranges_set_union.h b/libcxx/include/__algorithm/ranges_set_union.h
index 500c0b2c2d3bc..f8cd45ca0e33b 100644
--- a/libcxx/include/__algorithm/ranges_set_union.h
+++ b/libcxx/include/__algorithm/ranges_set_union.h
@@ -10,6 +10,7 @@
#define _LIBCPP___ALGORITHM_RANGES_SET_UNION_H
#include <__algorithm/in_in_out_result.h>
+#include <__algorithm/iterator_operations.h>
#include <__algorithm/make_projected.h>
#include <__algorithm/set_union.h>
#include <__config>
@@ -61,7 +62,7 @@ struct __fn {
_Comp __comp = {},
_Proj1 __proj1 = {},
_Proj2 __proj2 = {}) const {
- auto __ret = std::__set_union(
+ auto __ret = std::__set_union<_RangeAlgPolicy>(
std::move(__first1),
std::move(__last1),
std::move(__first2),
@@ -95,7 +96,7 @@ struct __fn {
_Comp __comp = {},
_Proj1 __proj1 = {},
_Proj2 __proj2 = {}) const {
- auto __ret = std::__set_union(
+ auto __ret = std::__set_union<_RangeAlgPolicy>(
ranges::begin(__range1),
ranges::end(__range1),
ranges::begin(__range2),
diff --git a/libcxx/include/__algorithm/rotate.h b/libcxx/include/__algorithm/rotate.h
index 32682936e32e7..8934ce095bbc5 100644
--- a/libcxx/include/__algorithm/rotate.h
+++ b/libcxx/include/__algorithm/rotate.h
@@ -48,7 +48,7 @@ __rotate_right(_BidirectionalIterator __first, _BidirectionalIterator __last)
_BidirectionalIterator __lm1 = _Ops::prev(__last);
value_type __tmp = _Ops::__iter_move(__lm1);
- _BidirectionalIterator __fp1 = std::__move_backward<_AlgPolicy>(__first, __lm1, std::move(__last));
+ _BidirectionalIterator __fp1 = std::__move_backward<_AlgPolicy>(__first, __lm1, std::move(__last)).second;
*__first = _VSTD::move(__tmp);
return __fp1;
}
diff --git a/libcxx/include/__algorithm/set_
diff erence.h b/libcxx/include/__algorithm/set_
diff erence.h
index e0385bf822ff9..cffdc8fc4fc00 100644
--- a/libcxx/include/__algorithm/set_
diff erence.h
+++ b/libcxx/include/__algorithm/set_
diff erence.h
@@ -12,6 +12,7 @@
#include <__algorithm/comp.h>
#include <__algorithm/comp_ref_type.h>
#include <__algorithm/copy.h>
+#include <__algorithm/iterator_operations.h>
#include <__config>
#include <__functional/identity.h>
#include <__functional/invoke.h>
@@ -26,7 +27,7 @@
_LIBCPP_BEGIN_NAMESPACE_STD
-template < class _Comp, class _InIter1, class _Sent1, class _InIter2, class _Sent2, class _OutIter>
+template <class _AlgPolicy, class _Comp, class _InIter1, class _Sent1, class _InIter2, class _Sent2, class _OutIter>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 pair<__remove_cvref_t<_InIter1>, __remove_cvref_t<_OutIter> >
__set_
diff erence(
_InIter1&& __first1, _Sent1&& __last1, _InIter2&& __first2, _Sent2&& __last2, _OutIter&& __result, _Comp&& __comp) {
@@ -42,7 +43,7 @@ __set_
diff erence(
++__first2;
}
}
- return std::__copy(std::move(__first1), std::move(__last1), std::move(__result));
+ return std::__copy<_AlgPolicy>(std::move(__first1), std::move(__last1), std::move(__result));
}
template <class _InputIterator1, class _InputIterator2, class _OutputIterator, class _Compare>
@@ -53,7 +54,8 @@ inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _OutputIterator set_d
_InputIterator2 __last2,
_OutputIterator __result,
_Compare __comp) {
- return std::__set_
diff erence<__comp_ref_type<_Compare> >(__first1, __last1, __first2, __last2, __result, __comp)
+ return std::__set_
diff erence<_ClassicAlgPolicy, __comp_ref_type<_Compare> >(
+ __first1, __last1, __first2, __last2, __result, __comp)
.second;
}
@@ -64,7 +66,7 @@ inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _OutputIterator set_d
_InputIterator2 __first2,
_InputIterator2 __last2,
_OutputIterator __result) {
- return std::__set_
diff erence(
+ return std::__set_
diff erence<_ClassicAlgPolicy>(
__first1,
__last1,
__first2,
diff --git a/libcxx/include/__algorithm/set_symmetric_
diff erence.h b/libcxx/include/__algorithm/set_symmetric_
diff erence.h
index 97d3f1da7c249..bcb09587032ba 100644
--- a/libcxx/include/__algorithm/set_symmetric_
diff erence.h
+++ b/libcxx/include/__algorithm/set_symmetric_
diff erence.h
@@ -12,6 +12,7 @@
#include <__algorithm/comp.h>
#include <__algorithm/comp_ref_type.h>
#include <__algorithm/copy.h>
+#include <__algorithm/iterator_operations.h>
#include <__config>
#include <__iterator/iterator_traits.h>
#include <__utility/move.h>
@@ -35,13 +36,13 @@ struct __set_symmetric_
diff erence_result {
: __in1_(std::move(__in_iter1)), __in2_(std::move(__in_iter2)), __out_(std::move(__out_iter)) {}
};
-template <class _Compare, class _InIter1, class _Sent1, class _InIter2, class _Sent2, class _OutIter>
+template <class _AlgPolicy, class _Compare, class _InIter1, class _Sent1, class _InIter2, class _Sent2, class _OutIter>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 __set_symmetric_
diff erence_result<_InIter1, _InIter2, _OutIter>
__set_symmetric_
diff erence(
_InIter1 __first1, _Sent1 __last1, _InIter2 __first2, _Sent2 __last2, _OutIter __result, _Compare&& __comp) {
while (__first1 != __last1) {
if (__first2 == __last2) {
- auto __ret1 = std::__copy_impl(std::move(__first1), std::move(__last1), std::move(__result));
+ auto __ret1 = std::__copy<_AlgPolicy>(std::move(__first1), std::move(__last1), std::move(__result));
return __set_symmetric_
diff erence_result<_InIter1, _InIter2, _OutIter>(
std::move(__ret1.first), std::move(__first2), std::move((__ret1.second)));
}
@@ -59,7 +60,7 @@ __set_symmetric_
diff erence(
++__first2;
}
}
- auto __ret2 = std::__copy_impl(std::move(__first2), std::move(__last2), std::move(__result));
+ auto __ret2 = std::__copy<_AlgPolicy>(std::move(__first2), std::move(__last2), std::move(__result));
return __set_symmetric_
diff erence_result<_InIter1, _InIter2, _OutIter>(
std::move(__first1), std::move(__ret2.first), std::move((__ret2.second)));
}
@@ -72,7 +73,7 @@ _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _OutputIterator set_symmetri
_InputIterator2 __last2,
_OutputIterator __result,
_Compare __comp) {
- return std::__set_symmetric_
diff erence<__comp_ref_type<_Compare> >(
+ return std::__set_symmetric_
diff erence<_ClassicAlgPolicy, __comp_ref_type<_Compare> >(
std::move(__first1),
std::move(__last1),
std::move(__first2),
diff --git a/libcxx/include/__algorithm/set_union.h b/libcxx/include/__algorithm/set_union.h
index addc77b7d8053..4d154b81e0920 100644
--- a/libcxx/include/__algorithm/set_union.h
+++ b/libcxx/include/__algorithm/set_union.h
@@ -12,6 +12,7 @@
#include <__algorithm/comp.h>
#include <__algorithm/comp_ref_type.h>
#include <__algorithm/copy.h>
+#include <__algorithm/iterator_operations.h>
#include <__config>
#include <__iterator/iterator_traits.h>
#include <__utility/move.h>
@@ -35,12 +36,12 @@ struct __set_union_result {
: __in1_(std::move(__in_iter1)), __in2_(std::move(__in_iter2)), __out_(std::move(__out_iter)) {}
};
-template <class _Compare, class _InIter1, class _Sent1, class _InIter2, class _Sent2, class _OutIter>
+template <class _AlgPolicy, class _Compare, class _InIter1, class _Sent1, class _InIter2, class _Sent2, class _OutIter>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 __set_union_result<_InIter1, _InIter2, _OutIter> __set_union(
_InIter1 __first1, _Sent1 __last1, _InIter2 __first2, _Sent2 __last2, _OutIter __result, _Compare&& __comp) {
for (; __first1 != __last1; ++__result) {
if (__first2 == __last2) {
- auto __ret1 = std::__copy_impl(std::move(__first1), std::move(__last1), std::move(__result));
+ auto __ret1 = std::__copy<_AlgPolicy>(std::move(__first1), std::move(__last1), std::move(__result));
return __set_union_result<_InIter1, _InIter2, _OutIter>(
std::move(__ret1.first), std::move(__first2), std::move((__ret1.second)));
}
@@ -55,7 +56,7 @@ _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 __set_union_result<_InIter1,
++__first1;
}
}
- auto __ret2 = std::__copy_impl(std::move(__first2), std::move(__last2), std::move(__result));
+ auto __ret2 = std::__copy<_AlgPolicy>(std::move(__first2), std::move(__last2), std::move(__result));
return __set_union_result<_InIter1, _InIter2, _OutIter>(
std::move(__first1), std::move(__ret2.first), std::move((__ret2.second)));
}
@@ -68,7 +69,7 @@ _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _OutputIterator set_union(
_InputIterator2 __last2,
_OutputIterator __result,
_Compare __comp) {
- return std::__set_union<__comp_ref_type<_Compare> >(
+ return std::__set_union<_ClassicAlgPolicy, __comp_ref_type<_Compare> >(
std::move(__first1),
std::move(__last1),
std::move(__first2),
diff --git a/libcxx/include/__iterator/reverse_iterator.h b/libcxx/include/__iterator/reverse_iterator.h
index 79eb4a3c5e892..942235a580b84 100644
--- a/libcxx/include/__iterator/reverse_iterator.h
+++ b/libcxx/include/__iterator/reverse_iterator.h
@@ -202,12 +202,6 @@ _LIBCPP_SUPPRESS_DEPRECATED_POP
#endif // _LIBCPP_STD_VER > 17
};
-template <class _Iter>
-struct __is_reverse_iterator : false_type {};
-
-template <class _Iter>
-struct __is_reverse_iterator<reverse_iterator<_Iter> > : true_type {};
-
template <class _Iter1, class _Iter2>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
bool
@@ -485,9 +479,6 @@ class __unconstrained_reverse_iterator {
}
};
-template <class _Iter>
-struct __is_reverse_iterator<__unconstrained_reverse_iterator<_Iter>> : true_type {};
-
#endif // _LIBCPP_STD_VER <= 17
template <template <class> class _RevIter1, template <class> class _RevIter2, class _Iter>
diff --git a/libcxx/include/__type_traits/is_always_bitcastable.h b/libcxx/include/__type_traits/is_always_bitcastable.h
new file mode 100644
index 0000000000000..63304eb492b7c
--- /dev/null
+++ b/libcxx/include/__type_traits/is_always_bitcastable.h
@@ -0,0 +1,82 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___TYPE_TRAITS_IS_ALWAYS_BITCASTABLE_H
+#define _LIBCPP___TYPE_TRAITS_IS_ALWAYS_BITCASTABLE_H
+
+#include <__config>
+#include <__type_traits/integral_constant.h>
+#include <__type_traits/is_integral.h>
+#include <__type_traits/is_object.h>
+#include <__type_traits/is_same.h>
+#include <__type_traits/is_trivially_copyable.h>
+#include <__type_traits/remove_cv.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+# pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+// Checks whether an object of type `From` can always be bit-cast to an object of type `To` and represent a valid value
+// of type `To`. In other words, `From` and `To` have the same value representation and the set of values of `From` is
+// a subset of the set of values of `To`.
+//
+// Note that types that cannot be assigned to each other using built-in assignment (e.g. arrays) might still be
+// considered bit-castable.
+template <class _From, class _To>
+struct __is_always_bitcastable {
+ using _UnqualFrom = __remove_cv_t<_From>;
+ using _UnqualTo = __remove_cv_t<_To>;
+
+ static const bool value =
+ // First, the simple case -- `From` and `To` are the same object type.
+ (is_same<_UnqualFrom, _UnqualTo>::value && is_trivially_copyable<_UnqualFrom>::value) ||
+
+ // Beyond the simple case, we say that one type is "always bit-castable" to another if:
+ // - (1) `From` and `To` have the same value representation, and in addition every possible value of `From` has
+ // a corresponding value in the `To` type (in other words, the set of values of `To` is a superset of the set of
+ // values of `From`);
+ // - (2) When the corresponding values are not the same value (as, for example, between an unsigned and a signed
+ // integer, where a large positive value of the unsigned integer corresponds to a negative value in the signed
+ // integer type), the value of `To` that results from a bitwise copy of `From` is the same what would be produced
+ // by the built-in assignment (if it were defined for the two types, to which there are minor exceptions, e.g.
+ // built-in arrays).
+ //
+ // In practice, that means:
+ // - all integral types (except `bool`, see below) -- that is, character types and `int` types, both signed and
+ // unsigned...
+ // - as well as arrays of such types...
+ // - ...that have the same size.
+ //
+ // Other trivially-copyable types can't be validly bit-cast outside of their own type:
+ // - floating-point types normally have
diff erent sizes and thus aren't bit-castable between each other (fails #1);
+ // - integral types and floating-point types use
diff erent representations, so for example bit-casting an integral
+ // `1` to `float` results in a very small less-than-one value, unlike built-in assignment that produces `1.0`
+ // (fails #2);
+ // - booleans normally use only a single bit of their object representation; bit-casting an integer to a boolean
+ // will result in a boolean object with an incorrect representation, which is undefined behavior (fails #2).
+ // Bit-casting from a boolean into an integer, however, is valid;
+ // - enumeration types may have
diff erent ranges of possible values (fails #1);
+ // - for pointers, it is not guaranteed that pointers to
diff erent types use the same set of values to represent
+ // addresses, and the conversion results are explicitly unspecified for types with
diff erent alignments
+ // (fails #1);
+ // - for structs and unions it is impossible to determine whether the set of values of one of them is a subset of
+ // the other (fails #1);
+ // - there is no need to consider `nullptr_t` for practical purposes.
+ (
+ sizeof(_From) == sizeof(_To) &&
+ is_integral<_From>::value &&
+ is_integral<_To>::value &&
+ !is_same<_UnqualTo, bool>::value
+ );
+};
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___TYPE_TRAITS_IS_ALWAYS_BITCASTABLE_H
diff --git a/libcxx/include/algorithm b/libcxx/include/algorithm
index 69cdc144e80ba..cb2d27cbc80c5 100644
--- a/libcxx/include/algorithm
+++ b/libcxx/include/algorithm
@@ -1707,7 +1707,6 @@ template <class BidirectionalIterator, class Compare>
#include <__config>
#include <__debug>
#include <cstddef>
-#include <cstring>
#include <type_traits>
#include <version>
@@ -1917,6 +1916,7 @@ template <class BidirectionalIterator, class Compare>
#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
# include <atomic>
# include <concepts>
+# include <cstring>
# include <iterator>
# include <memory>
# include <stdexcept>
diff --git a/libcxx/include/module.modulemap.in b/libcxx/include/module.modulemap.in
index 73bd8a2b8e686..d0cb522cc89ae 100644
--- a/libcxx/include/module.modulemap.in
+++ b/libcxx/include/module.modulemap.in
@@ -251,6 +251,7 @@ module std [system] {
module copy { private header "__algorithm/copy.h" }
module copy_backward { private header "__algorithm/copy_backward.h" }
module copy_if { private header "__algorithm/copy_if.h" }
+ module copy_move_common { private header "__algorithm/copy_move_common.h" }
module copy_n { private header "__algorithm/copy_n.h" }
module count { private header "__algorithm/count.h" }
module count_if { private header "__algorithm/count_if.h" }
@@ -1405,6 +1406,7 @@ module std [system] {
module is_abstract { private header "__type_traits/is_abstract.h" }
module is_aggregate { private header "__type_traits/is_aggregate.h" }
module is_allocator { private header "__type_traits/is_allocator.h" }
+ module is_always_bitcastable { private header "__type_traits/is_always_bitcastable.h" }
module is_arithmetic {
private header "__type_traits/is_arithmetic.h"
export integral_constant
diff --git a/libcxx/include/valarray b/libcxx/include/valarray
index 5b1f02312dd1f..92521ed3819cf 100644
--- a/libcxx/include/valarray
+++ b/libcxx/include/valarray
@@ -4933,6 +4933,7 @@ _LIBCPP_POP_MACROS
#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
# include <algorithm>
# include <concepts>
+# include <cstring>
# include <functional>
#endif
diff --git a/libcxx/test/libcxx/algorithms/alg.modifying.operations/copy.pass.cpp b/libcxx/test/libcxx/algorithms/alg.modifying.operations/copy.pass.cpp
deleted file mode 100644
index 8fafad9ad7f53..0000000000000
--- a/libcxx/test/libcxx/algorithms/alg.modifying.operations/copy.pass.cpp
+++ /dev/null
@@ -1,179 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-// UNSUPPORTED: c++03, c++11, c++14, c++17
-
-// When the debug mode is enabled, we don't unwrap iterators in std::copy
-// so we don't get this optimization.
-// UNSUPPORTED: libcpp-has-debug-mode
-
-// <algorithm>
-
-// This test checks that std::copy forwards to memmove when appropriate.
-
-#include <algorithm>
-#include <cassert>
-#include <iterator>
-#include <ranges>
-#include <type_traits>
-
-struct S {
- int i;
- constexpr S(int i_) : i(i_) {}
- S(const S&) = default;
- S(S&&) = delete;
- constexpr S& operator=(const S&) = default;
- S& operator=(S&&) = delete;
- constexpr bool operator==(const S&) const = default;
-};
-
-static_assert(std::is_trivially_copyable_v<S>);
-
-template <class T>
-struct NotIncrementableIt {
- T* i;
- using iterator_category = std::contiguous_iterator_tag;
- using iterator_concept = std::contiguous_iterator_tag;
- using value_type = T;
- using
diff erence_type = ptr
diff _t;
- using pointer = T*;
- using reference = T&;
-
- constexpr NotIncrementableIt() = default;
- constexpr NotIncrementableIt(T* i_) : i(i_) {}
-
- friend constexpr bool operator==(const NotIncrementableIt& lhs, const NotIncrementableIt& rhs) {
- return lhs.i == rhs.i;
- }
-
- constexpr T& operator*() { return *i; }
- constexpr T& operator*() const { return *i; }
- constexpr T* operator->() { return i; }
- constexpr T* operator->() const { return i; }
-
- constexpr NotIncrementableIt& operator++() {
- assert(false);
- return *this;
- }
-
- constexpr NotIncrementableIt& operator++(int) {
- assert(false);
- return *this;
- }
-
- constexpr NotIncrementableIt& operator--() {
- assert(false);
- return *this;
- }
-
- friend constexpr NotIncrementableIt operator+(const NotIncrementableIt& it,
diff erence_type size) { return it.i + size; }
- friend constexpr
diff erence_type operator-(const NotIncrementableIt& x, const NotIncrementableIt& y) { return x.i - y.i; }
- friend constexpr NotIncrementableIt operator-(const NotIncrementableIt& x,
diff erence_type size) { return NotIncrementableIt(x.i - size); }
-};
-
-static_assert(std::__is_cpp17_contiguous_iterator<NotIncrementableIt<S>>::value);
-
-template <size_t N, class Iter, std::enable_if_t<N == 0>* = nullptr>
-constexpr auto wrap_n_times(Iter i) {
- return i;
-}
-
-template <size_t N, class Iter, std::enable_if_t<N != 0>* = nullptr>
-constexpr auto wrap_n_times(Iter i) {
- return std::make_reverse_iterator(wrap_n_times<N - 1>(i));
-}
-
-static_assert(std::is_same_v<decltype(wrap_n_times<2>(std::declval<int*>())),
- std::reverse_iterator<std::reverse_iterator<int*>>>);
-
-template <size_t InCount, size_t OutCount, class Iter>
-constexpr void test_normal() {
- {
- S a[] = {1, 2, 3, 4};
- S b[] = {0, 0, 0, 0};
- std::copy(wrap_n_times<InCount>(Iter(a)), wrap_n_times<InCount>(Iter(a + 4)), wrap_n_times<OutCount>(Iter(b)));
- assert(std::equal(a, a + 4, b));
- }
- {
- S a[] = {1, 2, 3, 4};
- S b[] = {0, 0, 0, 0};
- std::ranges::copy(wrap_n_times<InCount>(Iter(a)),
- wrap_n_times<InCount>(Iter(a + 4)),
- wrap_n_times<OutCount>(Iter(b)));
- assert(std::equal(a, a + 4, b));
- }
- {
- S a[] = {1, 2, 3, 4};
- S b[] = {0, 0, 0, 0};
- auto range = std::ranges::subrange(wrap_n_times<InCount>(Iter(a)), wrap_n_times<InCount>(Iter(a + 4)));
- std::ranges::copy(range, Iter(b));
- assert(std::equal(a, a + 4, b));
- }
-}
-
-template <size_t InCount, size_t OutCount, class Iter>
-constexpr void test_reverse() {
- {
- S a[] = {1, 2, 3, 4};
- S b[] = {0, 0, 0, 0};
- std::copy(std::make_reverse_iterator(wrap_n_times<InCount>(Iter(a + 4))),
- std::make_reverse_iterator(wrap_n_times<InCount>(Iter(a))),
- std::make_reverse_iterator(wrap_n_times<OutCount>(Iter(b + 4))));
- assert(std::equal(a, a + 4, b));
- }
- {
- S a[] = {1, 2, 3, 4};
- S b[] = {0, 0, 0, 0};
- std::ranges::copy(std::make_reverse_iterator(wrap_n_times<InCount>(Iter(a + 4))),
- std::make_reverse_iterator(wrap_n_times<InCount>(Iter(a))),
- std::make_reverse_iterator(wrap_n_times<OutCount>(Iter(b + 4))));
- assert(std::equal(a, a + 4, b));
- }
- {
- S a[] = {1, 2, 3, 4};
- S b[] = {0, 0, 0, 0};
- auto range = std::ranges::subrange(wrap_n_times<InCount>(std::make_reverse_iterator(Iter(a + 4))),
- wrap_n_times<InCount>(std::make_reverse_iterator(Iter(a))));
- std::ranges::copy(range, std::make_reverse_iterator(wrap_n_times<OutCount>(Iter(b + 4))));
- assert(std::equal(a, a + 4, b));
- }
-}
-
-template <size_t InCount, size_t OutCount>
-constexpr void test_normal_reverse() {
- test_normal<InCount, OutCount, S*>();
- test_normal<InCount, OutCount, NotIncrementableIt<S>>();
- test_reverse<InCount, OutCount, S*>();
- test_reverse<InCount, OutCount, NotIncrementableIt<S>>();
-}
-
-template <size_t InCount>
-constexpr void test_out_count() {
- test_normal_reverse<InCount, 0>();
- test_normal_reverse<InCount, 2>();
- test_normal_reverse<InCount, 4>();
- test_normal_reverse<InCount, 6>();
- test_normal_reverse<InCount, 8>();
-}
-
-constexpr bool test() {
- test_out_count<0>();
- test_out_count<2>();
- test_out_count<4>();
- test_out_count<6>();
- test_out_count<8>();
-
- return true;
-}
-
-int main(int, char**) {
- test();
- static_assert(test());
-
- return 0;
-}
diff --git a/libcxx/test/libcxx/algorithms/alg.modifying.operations/copy_move_nontrivial.pass.cpp b/libcxx/test/libcxx/algorithms/alg.modifying.operations/copy_move_nontrivial.pass.cpp
new file mode 100644
index 0000000000000..c26f755768d84
--- /dev/null
+++ b/libcxx/test/libcxx/algorithms/alg.modifying.operations/copy_move_nontrivial.pass.cpp
@@ -0,0 +1,334 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// When the debug mode is enabled, we don't unwrap iterators in `std::copy` and similar algorithms so we never get the
+// optimization.
+// UNSUPPORTED: libcpp-has-debug-mode
+// In the modules build, adding another overload of `memmove` doesn't work.
+// UNSUPPORTED: modules-build
+// GCC complains about "ambiguating" `__builtin_memmove`.
+// UNSUPPORTED: gcc
+
+// <algorithm>
+
+#include <cassert>
+#include <cstddef>
+
+// These tests check that `std::copy` and `std::move` (including their variations like `copy_n`) don't forward to
+// `std::memmove` when doing so would be observable.
+
+// This template is a better match than the actual `builtin_memmove` (it can match the pointer type exactly, without an
+// implicit conversion to `void*`), so it should hijack the call inside `std::copy` and similar algorithms if it's made.
+template <class Dst, class Src>
+constexpr void* __builtin_memmove(Dst*, Src*, size_t) {
+ assert(false);
+ return nullptr;
+}
+
+#include <algorithm>
+#include <cassert>
+#include <cstdint>
+#include <iterator>
+#include <ranges>
+#include <type_traits>
+
+#include "test_iterators.h"
+#include "test_macros.h"
+
+// S1 and S2 are simple structs that are convertible to each other and have the same bit representation.
+struct S1 {
+ int x;
+
+ constexpr S1() = default;
+ constexpr S1(int set_x) : x(set_x) {}
+
+ friend constexpr bool operator==(const S1& lhs, const S1& rhs) { return lhs.x == rhs.x; }
+};
+
+struct S2 {
+ int x;
+
+ constexpr S2() = default;
+ constexpr S2(int set_x) : x(set_x) {}
+ constexpr S2(S1 from) : x(from.x) {}
+
+ friend constexpr bool operator==(const S1& lhs, const S2& rhs) { return lhs.x == rhs.x; }
+ friend constexpr bool operator==(const S2& lhs, const S2& rhs) { return lhs.x == rhs.x; }
+};
+
+// U1 and U2 are simple unions that are convertible to each other and have the same bit representation.
+union U1 {
+ int x;
+
+ constexpr U1() = default;
+ constexpr U1(int set_x) : x(set_x) {}
+
+ friend constexpr bool operator==(const U1& lhs, const U1& rhs) { return lhs.x == rhs.x; }
+};
+
+union U2 {
+ int x;
+
+ constexpr U2() = default;
+ constexpr U2(int set_x) : x(set_x) {}
+ constexpr U2(U1 from) : x(from.x) {}
+
+ friend constexpr bool operator==(const U1& lhs, const U2& rhs) { return lhs.x == rhs.x; }
+ friend constexpr bool operator==(const U2& lhs, const U2& rhs) { return lhs.x == rhs.x; }
+};
+
+struct NonTrivialMoveAssignment {
+ int i;
+
+ constexpr NonTrivialMoveAssignment() = default;
+ constexpr NonTrivialMoveAssignment(int set_i) : i(set_i) {}
+
+ constexpr NonTrivialMoveAssignment(NonTrivialMoveAssignment&& rhs) = default;
+ constexpr NonTrivialMoveAssignment& operator=(NonTrivialMoveAssignment&& rhs) noexcept {
+ i = rhs.i;
+ return *this;
+ }
+
+ constexpr friend bool operator==(const NonTrivialMoveAssignment&, const NonTrivialMoveAssignment&) = default;
+};
+
+static_assert(!std::is_trivially_move_assignable_v<NonTrivialMoveAssignment>);
+static_assert(!std::is_trivially_assignable<NonTrivialMoveAssignment&, NonTrivialMoveAssignment&>::value);
+
+struct NonTrivialMoveCtr {
+ int i;
+
+ constexpr NonTrivialMoveCtr() = default;
+ constexpr NonTrivialMoveCtr(int set_i) : i(set_i) {}
+
+ constexpr NonTrivialMoveCtr(NonTrivialMoveCtr&& rhs) noexcept : i(rhs.i) {}
+ constexpr NonTrivialMoveCtr& operator=(NonTrivialMoveCtr&& rhs) = default;
+
+ constexpr friend bool operator==(const NonTrivialMoveCtr&, const NonTrivialMoveCtr&) = default;
+};
+
+static_assert(std::is_trivially_move_assignable_v<NonTrivialMoveCtr>);
+static_assert(!std::is_trivially_copyable_v<NonTrivialMoveCtr>);
+
+struct NonTrivialCopyAssignment {
+ int i;
+
+ constexpr NonTrivialCopyAssignment() = default;
+ constexpr NonTrivialCopyAssignment(int set_i) : i(set_i) {}
+
+ constexpr NonTrivialCopyAssignment(const NonTrivialCopyAssignment& rhs) = default;
+ constexpr NonTrivialCopyAssignment& operator=(const NonTrivialCopyAssignment& rhs) {
+ i = rhs.i;
+ return *this;
+ }
+
+ constexpr friend bool operator==(const NonTrivialCopyAssignment&, const NonTrivialCopyAssignment&) = default;
+};
+
+static_assert(!std::is_trivially_copy_assignable_v<NonTrivialCopyAssignment>);
+
+struct NonTrivialCopyCtr {
+ int i;
+
+ constexpr NonTrivialCopyCtr() = default;
+ constexpr NonTrivialCopyCtr(int set_i) : i(set_i) {}
+
+ constexpr NonTrivialCopyCtr(const NonTrivialCopyCtr& rhs) : i(rhs.i) {}
+ constexpr NonTrivialCopyCtr& operator=(const NonTrivialCopyCtr& rhs) = default;
+
+ constexpr friend bool operator==(const NonTrivialCopyCtr&, const NonTrivialCopyCtr&) = default;
+};
+
+static_assert(std::is_trivially_copy_assignable_v<NonTrivialCopyCtr>);
+static_assert(!std::is_trivially_copyable_v<NonTrivialCopyCtr>);
+
+template <class T>
+constexpr T make(int from) {
+ return T(from);
+}
+
+template <typename PtrT, typename T = std::remove_pointer_t<PtrT>>
+static T make_internal_array[5] = {T(), T(), T(), T(), T()};
+
+template <class T>
+requires std::is_pointer_v<T>
+constexpr T make(int i) {
+ if constexpr (!std::same_as<std::remove_pointer_t<T>, void>) {
+ return make_internal_array<T> + i;
+ } else {
+ return make_internal_array<int> + i;
+ }
+}
+
+template <class InIter, template <class> class SentWrapper, class OutIter, class Func>
+constexpr void test_one(Func func) {
+ using From = typename std::iterator_traits<InIter>::value_type;
+ using To = typename std::iterator_traits<OutIter>::value_type;
+
+ {
+ const size_t N = 5;
+
+ From input[N] = {make<From>(0), make<From>(1), make<From>(2), make<From>(3), make<From>(4)};
+ To output[N];
+
+ auto in = InIter(input);
+ auto in_end = InIter(input + N);
+ auto sent = SentWrapper<decltype(in_end)>(in_end);
+ auto out = OutIter(output);
+
+ func(in, sent, out, N);
+ if constexpr (!std::same_as<To, bool>) {
+ assert(std::equal(input, input + N, output));
+ } else {
+ bool expected[N] = {false, true, true, true, true};
+ assert(std::equal(output, output + N, expected));
+ }
+ }
+
+ {
+ const size_t N = 0;
+
+ From input[1] = {make<From>(1)};
+ To output[1] = {make<To>(2)};
+
+ auto in = InIter(input);
+ auto in_end = InIter(input + N);
+ auto sent = SentWrapper<decltype(in_end)>(in_end);
+ auto out = OutIter(output);
+
+ func(in, sent, out, N);
+ assert(output[0] == make<To>(2));
+ }
+}
+
+template <class InIter, template <class> class SentWrapper, class OutIter>
+constexpr void test_copy() {
+ // Classic.
+ if constexpr (std::same_as<InIter, SentWrapper<InIter>>) {
+ test_one<InIter, SentWrapper, OutIter>([](auto first, auto last, auto out, size_t) {
+ std::copy(first, last, out);
+ });
+ test_one<InIter, SentWrapper, OutIter>([](auto first, auto last, auto out, size_t n) {
+ std::copy_backward(first, last, out + n);
+ });
+ test_one<InIter, SentWrapper, OutIter>([](auto first, auto, auto out, size_t n) {
+ std::copy_n(first, n, out);
+ });
+ }
+
+ // Ranges.
+ test_one<InIter, SentWrapper, OutIter>([](auto first, auto last, auto out, size_t) {
+ std::ranges::copy(first, last, out);
+ });
+ test_one<InIter, SentWrapper, OutIter>([](auto first, auto last, auto out, size_t n) {
+ std::ranges::copy_backward(first, last, out + n);
+ });
+ test_one<InIter, SentWrapper, OutIter>([](auto first, auto, auto out, size_t n) {
+ std::ranges::copy_n(first, n, out);
+ });
+}
+
+template <class InIter, template <class> class SentWrapper, class OutIter>
+constexpr void test_move() {
+ if constexpr (std::same_as<InIter, SentWrapper<InIter>>) {
+ test_one<InIter, SentWrapper, OutIter>([](auto first, auto last, auto out, size_t) {
+ std::move(first, last, out);
+ });
+ test_one<InIter, SentWrapper, OutIter>([](auto first, auto last, auto out, size_t n) {
+ std::move_backward(first, last, out + n);
+ });
+ }
+
+ // Ranges.
+ test_one<InIter, SentWrapper, OutIter>([](auto first, auto last, auto out, size_t) {
+ std::ranges::move(first, last, out);
+ });
+ test_one<InIter, SentWrapper, OutIter>([](auto first, auto last, auto out, size_t n) {
+ std::ranges::move_backward(first, last, out + n);
+ });
+}
+
+template <class From, class To = From>
+constexpr void test_copy_with_type() {
+ using FromIter = contiguous_iterator<From*>;
+ using ToIter = contiguous_iterator<To*>;
+
+ test_copy<FromIter, std::type_identity_t, ToIter>();
+ test_copy<FromIter, sized_sentinel, ToIter>();
+ test_copy<FromIter, std::type_identity_t, To*>();
+ test_copy<From*, std::type_identity_t, To*>();
+ test_copy<From*, std::type_identity_t, ToIter>();
+}
+
+template <class From, class To = From>
+constexpr void test_move_with_type() {
+ using FromIter = contiguous_iterator<From*>;
+ using ToIter = contiguous_iterator<To*>;
+
+ test_move<FromIter, std::type_identity_t, ToIter>();
+ test_move<FromIter, sized_sentinel, ToIter>();
+ test_move<FromIter, std::type_identity_t, To*>();
+ test_move<From*, std::type_identity_t, To*>();
+ test_move<From*, std::type_identity_t, ToIter>();
+}
+
+template <class From, class To>
+constexpr void test_copy_and_move() {
+ test_copy_with_type<From, To>();
+ test_move_with_type<From, To>();
+}
+
+template <class From, class To>
+constexpr void test_both_directions() {
+ test_copy_and_move<From, To>();
+ if (!std::same_as<From, To>) {
+ test_copy_and_move<To, From>();
+ }
+}
+
+constexpr bool test() {
+ test_copy_with_type<NonTrivialCopyAssignment>();
+ test_move_with_type<NonTrivialMoveAssignment>();
+
+ // Copying from a smaller type into a larger type and vice versa.
+ test_both_directions<char, int>();
+ test_both_directions<std::int32_t, std::int64_t>();
+
+ // Copying between types with
diff erent representations.
+ test_both_directions<int, float>();
+ // Copying from `bool` to `char` will invoke the optimization, so only check one direction.
+ test_copy_and_move<char, bool>();
+
+ // Copying between
diff erent structs with the same represenation (there is no way to guarantee the representation is
+ // the same).
+ test_copy_and_move<S1, S2>();
+ // Copying between
diff erent unions with the same represenation.
+ test_copy_and_move<U1, U2>();
+
+ // Copying from a regular pointer to a void pointer (these are not considered trivially copyable).
+ test_copy_and_move<int*, void*>();
+ // Copying from a non-const pointer to a const pointer (these are not considered trivially copyable).
+ test_copy_and_move<int*, const int*>();
+
+ // `memmove` does not support volatile pointers.
+ // (See also https://github.com/llvm/llvm-project/issues/28901).
+ if (!std::is_constant_evaluated()) {
+ test_both_directions<volatile int, int>();
+ test_both_directions<volatile int, volatile int>();
+ }
+
+ return true;
+}
+
+int main(int, char**) {
+ test();
+ static_assert(test());
+
+ return 0;
+}
diff --git a/libcxx/test/libcxx/algorithms/alg.modifying.operations/copy_move_trivial.pass.cpp b/libcxx/test/libcxx/algorithms/alg.modifying.operations/copy_move_trivial.pass.cpp
new file mode 100644
index 0000000000000..7505e5727cd76
--- /dev/null
+++ b/libcxx/test/libcxx/algorithms/alg.modifying.operations/copy_move_trivial.pass.cpp
@@ -0,0 +1,357 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// When the debug mode is enabled, we don't unwrap iterators in `std::copy` and similar algorithms so we don't get this
+// optimization.
+// UNSUPPORTED: libcpp-has-debug-mode
+// In the modules build, adding another overload of `memmove` doesn't work.
+// UNSUPPORTED: modules-build
+// GCC complains about "ambiguating" `__builtin_memmove`.
+// UNSUPPORTED: gcc
+
+// <algorithm>
+
+// These tests check that `std::copy` and `std::move` (including their variations like `copy_n`) forward to
+// `memmove` when possible.
+
+#include <cstddef>
+
+struct Foo {
+ int i = 0;
+
+ Foo() = default;
+ Foo(int set_i) : i(set_i) {}
+
+ friend bool operator==(const Foo&, const Foo&) = default;
+};
+
+static bool memmove_called = false;
+
+// This template is a better match than the actual `builtin_memmove` (it can match the pointer type exactly, without an
+// implicit conversion to `void*`), so it should hijack the call inside `std::copy` and similar algorithms if it's made.
+template <class Dst, class Src>
+constexpr void* __builtin_memmove(Dst* dst, Src* src, size_t count) {
+ memmove_called = true;
+ return __builtin_memmove(static_cast<void*>(dst), static_cast<const void*>(src), count);
+}
+
+#include <algorithm>
+#include <cassert>
+#include <cstdint>
+#include <iterator>
+#include <limits>
+#include <ranges>
+#include <type_traits>
+
+#include "test_iterators.h"
+
+static_assert(std::is_trivially_copyable_v<Foo>);
+
+// To test pointers to functions.
+void Func() {}
+using FuncPtr = decltype(&Func);
+
+// To test pointers to members.
+struct S {
+ int mem_obj = 0;
+ void MemFunc() {}
+};
+using MemObjPtr = decltype(&S::mem_obj);
+using MemFuncPtr = decltype(&S::MemFunc);
+
+// To test bitfields.
+struct BitfieldS {
+ unsigned char b1 : 3;
+ unsigned char : 2;
+ unsigned char b2 : 5;
+ friend bool operator==(const BitfieldS&, const BitfieldS&) = default;
+};
+
+// To test non-default alignment.
+struct AlignedS {
+ alignas(64) int x;
+ alignas(8) int y;
+ friend bool operator==(const AlignedS&, const AlignedS&) = default;
+};
+
+template <class T>
+T make(int from) {
+ return T(from);
+}
+
+template <class T>
+requires (std::is_pointer_v<T> && !std::is_function_v<std::remove_pointer_t<T>>)
+T make(int i) {
+ static std::remove_pointer_t<T> arr[8];
+ return arr + i;
+}
+
+template <class T>
+requires std::same_as<T, FuncPtr>
+FuncPtr make(int) {
+ return &Func;
+}
+
+template <class T>
+requires std::same_as<T, MemObjPtr>
+MemObjPtr make(int) {
+ return &S::mem_obj;
+}
+
+template <class T>
+requires std::same_as<T, MemFuncPtr>
+MemFuncPtr make(int) {
+ return &S::MemFunc;
+}
+
+template <class T>
+requires std::same_as<T, BitfieldS>
+BitfieldS make(int x) {
+ BitfieldS result = {};
+ result.b1 = x;
+ result.b2 = x;
+ return result;
+}
+
+template <class T>
+requires std::same_as<T, AlignedS>
+AlignedS make(int x) {
+ AlignedS result;
+ result.x = x;
+ result.y = x;
+ return result;
+}
+
+template <class InIter, template <class> class SentWrapper, class OutIter, class Func>
+void test_one(Func func) {
+ using From = std::iter_value_t<InIter>;
+ using To = std::iter_value_t<OutIter>;
+
+ // Normal case.
+ {
+ const size_t N = 4;
+
+ From input[N] = {make<From>(1), make<From>(2), make<From>(3), make<From>(4)};
+ To output[N];
+
+ auto in = InIter(input);
+ auto in_end = InIter(input + N);
+ auto sent = SentWrapper<decltype(in_end)>(in_end);
+ auto out = OutIter(output);
+
+ assert(!memmove_called);
+ func(in, sent, out, N);
+ assert(memmove_called);
+ memmove_called = false;
+
+ assert(std::equal(input, input + N, output, [](const From& lhs, const To& rhs) {
+ // Prevents warnings/errors due to mismatched signed-ness.
+ if constexpr (std::convertible_to<From, To>) {
+ return static_cast<To>(lhs) == rhs;
+ } else if constexpr (std::convertible_to<To, From>) {
+ return lhs == static_cast<From>(rhs);
+ }
+ }));
+ }
+
+ // Empty input sequence.
+ {
+ const size_t N = 0;
+
+ From input[1] = {make<From>(1)};
+ To output[1] = {make<To>(2)};
+
+ auto in = InIter(input);
+ auto in_end = InIter(input + N);
+ auto sent = SentWrapper<decltype(in_end)>(in_end);
+ auto out = OutIter(output);
+
+ assert(!memmove_called);
+ func(in, sent, out, N);
+
+ assert(memmove_called);
+ memmove_called = false;
+ assert(output[0] == make<To>(2));
+ }
+}
+
+template <class InIter, template <class> class SentWrapper, class OutIter>
+void test_copy_and_move() {
+ // Classic.
+ if constexpr (std::same_as<InIter, SentWrapper<InIter>>) {
+ test_one<InIter, SentWrapper, OutIter>([](auto first, auto last, auto out, size_t) {
+ std::copy(first, last, out);
+ });
+ test_one<InIter, SentWrapper, OutIter>([](auto first, auto last, auto out, size_t n) {
+ std::copy_backward(first, last, out + n);
+ });
+ test_one<InIter, SentWrapper, OutIter>([](auto first, auto, auto out, size_t n) {
+ std::copy_n(first, n, out);
+ });
+ test_one<InIter, SentWrapper, OutIter>([](auto first, auto last, auto out, size_t) {
+ std::move(first, last, out);
+ });
+ test_one<InIter, SentWrapper, OutIter>([](auto first, auto last, auto out, size_t n) {
+ std::move_backward(first, last, out + n);
+ });
+ }
+
+ // Ranges.
+ test_one<InIter, SentWrapper, OutIter>([](auto first, auto last, auto out, size_t) {
+ std::ranges::copy(first, last, out);
+ });
+ test_one<InIter, SentWrapper, OutIter>([](auto first, auto last, auto out, size_t n) {
+ std::ranges::copy_backward(first, last, out + n);
+ });
+ test_one<InIter, SentWrapper, OutIter>([](auto first, auto, auto out, size_t n) {
+ std::ranges::copy_n(first, n, out);
+ });
+ test_one<InIter, SentWrapper, OutIter>([](auto first, auto last, auto out, size_t) {
+ std::ranges::move(first, last, out);
+ });
+ test_one<InIter, SentWrapper, OutIter>([](auto first, auto last, auto out, size_t n) {
+ std::ranges::move_backward(first, last, out + n);
+ });
+}
+
+template <class From, class To, template <class> class SentWrapper, bool BothDirections = !std::same_as<From, To>>
+void test_all_permutations_from_to_sent() {
+ test_copy_and_move<From*, SentWrapper, To*>();
+ test_copy_and_move<contiguous_iterator<From*>, SentWrapper, To*>();
+ test_copy_and_move<From*, SentWrapper, contiguous_iterator<To*>>();
+ test_copy_and_move<contiguous_iterator<From*>, SentWrapper, contiguous_iterator<To*>>();
+
+ if (BothDirections) {
+ test_copy_and_move<To*, SentWrapper, From*>();
+ test_copy_and_move<contiguous_iterator<To*>, SentWrapper, From*>();
+ test_copy_and_move<To*, SentWrapper, contiguous_iterator<From*>>();
+ test_copy_and_move<contiguous_iterator<To*>, SentWrapper, contiguous_iterator<From*>>();
+ }
+}
+
+void test_
diff erent_signedness() {
+ auto check = [](auto alg) {
+ // Signed -> unsigned.
+ {
+ constexpr int N = 3;
+ constexpr auto min_value = std::numeric_limits<int>::min();
+
+ int in[N] = {-1, min_value / 2, min_value};
+ unsigned int out[N];
+ unsigned int expected[N] = {
+ static_cast<unsigned int>(in[0]),
+ static_cast<unsigned int>(in[1]),
+ static_cast<unsigned int>(in[2]),
+ };
+
+ assert(!memmove_called);
+ alg(in, in + N, out, N);
+ assert(memmove_called);
+ memmove_called = false;
+
+ assert(std::equal(out, out + N, expected));
+ }
+
+ // Unsigned -> signed.
+ {
+ constexpr int N = 3;
+ constexpr auto max_signed = std::numeric_limits<int>::max();
+ constexpr auto max_unsigned = std::numeric_limits<unsigned int>::max();
+
+ unsigned int in[N] = {static_cast<unsigned int>(max_signed) + 1, max_unsigned / 2, max_unsigned};
+ int out[N];
+ int expected[N] = {
+ static_cast<int>(in[0]),
+ static_cast<int>(in[1]),
+ static_cast<int>(in[2]),
+ };
+
+ assert(!memmove_called);
+ alg(in, in + N, out, N);
+ assert(memmove_called);
+ memmove_called = false;
+
+ assert(std::equal(out, out + N, expected));
+ }
+ };
+
+ check([](auto first, auto last, auto out, size_t) {
+ std::copy(first, last, out);
+ });
+ check([](auto first, auto last, auto out, size_t n) {
+ std::copy_backward(first, last, out + n);
+ });
+ check([](auto first, auto, auto out, size_t n) {
+ std::copy_n(first, n, out);
+ });
+ check([](auto first, auto last, auto out, size_t) {
+ std::move(first, last, out);
+ });
+ check([](auto first, auto last, auto out, size_t n) {
+ std::move_backward(first, last, out + n);
+ });
+
+ // Ranges.
+ check([](auto first, auto last, auto out, size_t) {
+ std::ranges::copy(first, last, out);
+ });
+ check([](auto first, auto last, auto out, size_t n) {
+ std::ranges::copy_backward(first, last, out + n);
+ });
+ check([](auto first, auto, auto out, size_t n) {
+ std::ranges::copy_n(first, n, out);
+ });
+ check([](auto first, auto last, auto out, size_t) {
+ std::ranges::move(first, last, out);
+ });
+ check([](auto first, auto last, auto out, size_t n) {
+ std::ranges::move_backward(first, last, out + n);
+ });
+}
+
+void test() {
+ // Built-in.
+ test_all_permutations_from_to_sent<int, int, std::type_identity_t>();
+ // User-defined.
+ test_all_permutations_from_to_sent<Foo, Foo, std::type_identity_t>();
+
+ // Conversions.
+ test_all_permutations_from_to_sent<char32_t, std::int32_t, sized_sentinel>();
+ test_all_permutations_from_to_sent<std::int32_t, std::uint32_t, sized_sentinel>();
+ // Conversion from `bool` to `char` invokes the optimization (the set of values for `char` is a superset of the set of
+ // values for `bool`), but the other way round cannot.
+ test_all_permutations_from_to_sent<bool, char, sized_sentinel, /*BothDirections=*/false>();
+
+ // Copying between regular pointers.
+ test_copy_and_move<int**, std::type_identity_t, int**>();
+
+ // Copying between pointers to functions.
+ test_copy_and_move<FuncPtr*, std::type_identity_t, FuncPtr*>();
+
+ // Copying between pointers to members.
+ test_copy_and_move<MemObjPtr*, std::type_identity_t, MemObjPtr*>();
+ test_copy_and_move<MemFuncPtr*, std::type_identity_t, MemFuncPtr*>();
+
+ // Copying structs with bitfields.
+ test_copy_and_move<BitfieldS*, std::type_identity_t, BitfieldS*>();
+
+ // Copying objects with non-default alignment.
+ test_copy_and_move<AlignedS*, std::type_identity_t, AlignedS*>();
+
+ // Copying integers with
diff erent signedness produces the same results as built-in assignment.
+ test_
diff erent_signedness();
+}
+
+int main(int, char**) {
+ test();
+ // The test relies on a global variable, so it cannot be made `constexpr`; the `memmove` optimization is not used in
+ // `constexpr` mode anyway.
+
+ return 0;
+}
diff --git a/libcxx/test/libcxx/algorithms/alg.modifying.operations/copy_move_unwrap_reverse.pass.cpp b/libcxx/test/libcxx/algorithms/alg.modifying.operations/copy_move_unwrap_reverse.pass.cpp
new file mode 100644
index 0000000000000..bb01cc4e7322e
--- /dev/null
+++ b/libcxx/test/libcxx/algorithms/alg.modifying.operations/copy_move_unwrap_reverse.pass.cpp
@@ -0,0 +1,141 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+
+// <algorithm>
+
+// These tests checks that `std::copy` and `std::move` (including their variations like `copy_n`) can unwrap multiple
+// layers of reverse iterators.
+
+#include <algorithm>
+#include <cassert>
+#include <cstdint>
+#include <iterator>
+#include <ranges>
+#include <type_traits>
+
+#include "test_iterators.h"
+
+template <size_t N, class Iter>
+requires (N == 0)
+constexpr auto wrap_n_times(Iter i) {
+ return i;
+}
+
+template <size_t N, class Iter>
+requires (N != 0)
+constexpr auto wrap_n_times(Iter i) {
+ return std::make_reverse_iterator(wrap_n_times<N - 1>(i));
+}
+
+static_assert(std::is_same_v<decltype(wrap_n_times<2>(std::declval<int*>())),
+ std::reverse_iterator<std::reverse_iterator<int*>>>);
+
+template <class InIter, template <class> class SentWrapper, class OutIter, size_t W1, size_t W2, class Func>
+constexpr void test_one(Func func) {
+ using From = std::iter_value_t<InIter>;
+ using To = std::iter_value_t<OutIter>;
+
+ const size_t N = 4;
+
+ From input[N] = {{1}, {2}, {3}, {4}};
+ To output[N];
+
+ auto in = wrap_n_times<W1>(InIter(input));
+ auto in_end = wrap_n_times<W1>(InIter(input + N));
+ auto sent = SentWrapper<decltype(in_end)>(in_end);
+ auto out = wrap_n_times<W2>(OutIter(output));
+
+ func(in, sent, out, N);
+
+ assert(std::equal(input, input + N, output, [](const From& lhs, const To& rhs) {
+ // Prevents warnings/errors due to mismatched signed-ness.
+ return lhs == static_cast<From>(rhs);
+ }));
+}
+
+template <class InIter, template <class> class SentWrapper, class OutIter, size_t W1, size_t W2>
+constexpr void test_copy_and_move() {
+ // Classic.
+ if constexpr (std::same_as<InIter, SentWrapper<InIter>>) {
+ test_one<InIter, SentWrapper, OutIter, W1, W2>([](auto first, auto last, auto out, size_t) {
+ std::copy(first, last, out);
+ });
+ test_one<InIter, SentWrapper, OutIter, W1, W2>([](auto first, auto last, auto out, size_t n) {
+ std::copy_backward(first, last, out + n);
+ });
+ test_one<InIter, SentWrapper, OutIter, W1, W2>([](auto first, auto, auto out, size_t n) {
+ std::copy_n(first, n, out);
+ });
+ test_one<InIter, SentWrapper, OutIter, W1, W2>([](auto first, auto last, auto out, size_t) {
+ std::move(first, last, out);
+ });
+ test_one<InIter, SentWrapper, OutIter, W1, W2>([](auto first, auto last, auto out, size_t n) {
+ std::move_backward(first, last, out + n);
+ });
+ }
+
+ // Ranges.
+ test_one<InIter, SentWrapper, OutIter, W1, W2>([](auto first, auto last, auto out, size_t) {
+ std::ranges::copy(first, last, out);
+ });
+ test_one<InIter, SentWrapper, OutIter, W1, W2>([](auto first, auto last, auto out, size_t n) {
+ std::ranges::copy_backward(first, last, out + n);
+ });
+ test_one<InIter, SentWrapper, OutIter, W1, W2>([](auto first, auto, auto out, size_t n) {
+ std::ranges::copy_n(first, n, out);
+ });
+ test_one<InIter, SentWrapper, OutIter, W1, W2>([](auto first, auto last, auto out, size_t) {
+ std::ranges::move(first, last, out);
+ });
+ test_one<InIter, SentWrapper, OutIter, W1, W2>([](auto first, auto last, auto out, size_t n) {
+ std::ranges::move_backward(first, last, out + n);
+ });
+}
+
+template <size_t W1, size_t W2, class From, class To, template <class> class SentWrapper>
+constexpr void test_all_permutations_with_counts_from_to_sent() {
+ test_copy_and_move<From*, SentWrapper, To*, W1, W2>();
+ test_copy_and_move<contiguous_iterator<From*>, SentWrapper, To*, W1, W2>();
+ test_copy_and_move<From*, SentWrapper, contiguous_iterator<To*>, W1, W2>();
+ test_copy_and_move<contiguous_iterator<From*>, SentWrapper, contiguous_iterator<To*>, W1, W2>();
+
+ if (!std::same_as<From, To>) {
+ test_copy_and_move<To*, SentWrapper, From*, W1, W2>();
+ test_copy_and_move<contiguous_iterator<To*>, SentWrapper, From*, W1, W2>();
+ test_copy_and_move<To*, SentWrapper, contiguous_iterator<From*>, W1, W2>();
+ test_copy_and_move<contiguous_iterator<To*>, SentWrapper, contiguous_iterator<From*>, W1, W2>();
+ }
+}
+
+template <size_t W1, size_t W2>
+constexpr void test_all_permutations_with_counts() {
+ test_all_permutations_with_counts_from_to_sent<W1, W2, int, int, std::type_identity_t>();
+ test_all_permutations_with_counts_from_to_sent<W1, W2, int, int, sized_sentinel>();
+ test_all_permutations_with_counts_from_to_sent<W1, W2, std::int32_t, std::uint32_t, std::type_identity_t>();
+ test_all_permutations_with_counts_from_to_sent<W1, W2, std::int32_t, std::uint32_t, sized_sentinel>();
+}
+
+constexpr bool test() {
+ test_all_permutations_with_counts<0, 0>();
+ test_all_permutations_with_counts<0, 2>();
+ test_all_permutations_with_counts<2, 0>();
+ test_all_permutations_with_counts<2, 2>();
+ test_all_permutations_with_counts<2, 4>();
+ test_all_permutations_with_counts<4, 4>();
+
+ return true;
+}
+
+int main(int, char**) {
+ test();
+ static_assert(test());
+
+ return 0;
+}
diff --git a/libcxx/test/libcxx/private_headers.verify.cpp b/libcxx/test/libcxx/private_headers.verify.cpp
index 96f55dc075d27..97e945ef8fde8 100644
--- a/libcxx/test/libcxx/private_headers.verify.cpp
+++ b/libcxx/test/libcxx/private_headers.verify.cpp
@@ -46,6 +46,7 @@ END-SCRIPT
#include <__algorithm/copy.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/copy.h'}}
#include <__algorithm/copy_backward.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/copy_backward.h'}}
#include <__algorithm/copy_if.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/copy_if.h'}}
+#include <__algorithm/copy_move_common.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/copy_move_common.h'}}
#include <__algorithm/copy_n.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/copy_n.h'}}
#include <__algorithm/count.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/count.h'}}
#include <__algorithm/count_if.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/count_if.h'}}
@@ -600,6 +601,7 @@ END-SCRIPT
#include <__type_traits/is_abstract.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_abstract.h'}}
#include <__type_traits/is_aggregate.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_aggregate.h'}}
#include <__type_traits/is_allocator.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_allocator.h'}}
+#include <__type_traits/is_always_bitcastable.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_always_bitcastable.h'}}
#include <__type_traits/is_arithmetic.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_arithmetic.h'}}
#include <__type_traits/is_array.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_array.h'}}
#include <__type_traits/is_assignable.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_assignable.h'}}
diff --git a/libcxx/test/libcxx/transitive_includes/cxx2b.csv b/libcxx/test/libcxx/transitive_includes/cxx2b.csv
index 02af75aca7c6e..8599bb7881a63 100644
--- a/libcxx/test/libcxx/transitive_includes/cxx2b.csv
+++ b/libcxx/test/libcxx/transitive_includes/cxx2b.csv
@@ -701,7 +701,6 @@ utility version
valarray cmath
valarray cstddef
valarray cstdlib
-valarray cstring
valarray initializer_list
valarray limits
valarray new
diff --git a/libcxx/test/libcxx/type_traits/is_always_bitcastable.compile.pass.cpp b/libcxx/test/libcxx/type_traits/is_always_bitcastable.compile.pass.cpp
new file mode 100644
index 0000000000000..4e78fa1bf4eff
--- /dev/null
+++ b/libcxx/test/libcxx/type_traits/is_always_bitcastable.compile.pass.cpp
@@ -0,0 +1,219 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// <type_traits>
+//
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+//
+// __is_always_bitcastable<_From, _To>
+
+#include "test_macros.h"
+TEST_CLANG_DIAGNOSTIC_IGNORED("-Wprivate-header")
+#include <__type_traits/is_always_bitcastable.h>
+
+#include <climits>
+#include <cstdint>
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+#include <cwchar>
+#endif
+#include "type_algorithms.h"
+
+// To test pointers to functions.
+void Func1() {}
+using FuncPtr1 = decltype(&Func1);
+int Func2() { return 0; }
+using FuncPtr2 = decltype(&Func2);
+
+template <bool Expected, class T, class U>
+constexpr void check_one() {
+ static_assert(std::__is_always_bitcastable<T, U>::value == Expected);
+}
+
+template <bool Expected, class T, class U>
+constexpr void check_with_volatile() {
+ check_one<Expected, T, U>();
+ check_one<Expected, volatile T, U>();
+ check_one<Expected, T, volatile U>();
+ check_one<Expected, volatile T, volatile U>();
+}
+
+template <bool Expected, class T, class U>
+constexpr void check_with_cv() {
+ check_with_volatile<Expected, T, U>();
+ check_with_volatile<Expected, const T, U>();
+ check_with_volatile<Expected, T, const U>();
+ check_with_volatile<Expected, const T, const U>();
+}
+
+template <bool Expected, class Types1, class Types2 = Types1>
+constexpr void check() {
+ meta::for_each(Types1{}, []<class T>() {
+ meta::for_each(Types2{}, []<class U>() {
+ check_with_cv<Expected, T, U>();
+ });
+ });
+}
+
+template <bool Expected, class Types1, class Types2>
+constexpr void check_both_ways() {
+ check<Expected, Types1, Types2>();
+ check<Expected, Types2, Types1>();
+}
+
+constexpr void test() {
+ // Arithmetic types.
+ {
+ // Bit-castable arithmetic types.
+
+ // 8-bit types.
+ using integral_8 = meta::type_list<char8_t, int8_t, uint8_t>;
+ using chars = meta::type_list<char, unsigned char, signed char>;
+#if CHAR_BIT == 8
+ check<true, meta::concatenate_t<integral_8, chars>>();
+#else
+ check<true, integral_8>();
+ check<true, chars>();
+#endif
+
+ // 16-bit types.
+ using integral_16 = meta::type_list<char16_t, int16_t, uint16_t>;
+#if !defined(TEST_HAS_NO_WIDE_CHARACTERS) && __WCHAR_WIDTH__ == 16
+ check<true, meta::concatenate_t<integral_16, meta::type_list<wchar_t>>>();
+#else
+ check<true, integral_16>();
+#endif
+
+ // 32-bit types.
+ using integral_32 = meta::type_list<char32_t, int32_t, uint32_t>;
+#if !defined(TEST_HAS_NO_WIDE_CHARACTERS) && __WCHAR_WIDTH__ == 32
+ check<true, meta::concatenate_t<integral_32, meta::type_list<wchar_t>>>();
+#else
+ check<true, integral_32>();
+#endif
+
+ // 64-bit types.
+ using integral_64 = meta::type_list<int64_t, uint64_t>;
+ check<true, integral_64>();
+
+ // 128-bit types.
+#ifndef TEST_HAS_NO_INT128
+ check<true, meta::type_list<__int128_t, __uint128_t>>();
+#endif
+
+ // Bool.
+ check<true, meta::type_list<bool>, meta::concatenate_t<meta::type_list<bool>, integral_8>>();
+
+ // Non-bit-castable arithmetic types.
+
+ // Floating-point.
+ check_both_ways<false, meta::floating_point_types, meta::integral_types>();
+ check_both_ways<false, meta::type_list<float>, meta::type_list<double, long double>>();
+ check_both_ways<false, meta::type_list<double>, meta::type_list<float, long double>>();
+ check_both_ways<false, meta::type_list<long double>, meta::type_list<float, double>>();
+
+ // Different sizes.
+ check_both_ways<false, integral_8, meta::concatenate_t<integral_16, integral_32, integral_64>>();
+ check_both_ways<false, integral_16, meta::concatenate_t<integral_8, integral_32, integral_64>>();
+ check_both_ways<false, integral_32, meta::concatenate_t<integral_8, integral_16, integral_64>>();
+ check_both_ways<false, integral_64, meta::concatenate_t<integral_8, integral_16, integral_32>>();
+
+ // Different representations -- can convert from bool to other integral types, but not vice versa.
+ check<true, meta::type_list<bool>, integral_8>();
+ using larger_than_bool = meta::concatenate_t<
+ integral_16,
+ integral_32,
+ integral_64,
+ meta::floating_point_types>;
+ check<false, meta::type_list<bool>, larger_than_bool>();
+ check<false, meta::concatenate_t<integral_8, larger_than_bool>, meta::type_list<bool>>();
+
+ // Different representations -- floating point vs. integral.
+ check_both_ways<false, meta::floating_point_types, meta::integral_types>();
+ }
+
+ // Enumerations.
+ {
+ enum E1 { Value1 };
+ enum E2 { Value2 };
+ check<true, meta::type_list<E1>>();
+ check_both_ways<false, meta::type_list<E1>, meta::type_list<E2>>();
+
+ enum class ScopedE1 { Value1 };
+ enum class ScopedE2 { Value1 };
+ check<true, meta::type_list<ScopedE1>>();
+ check_both_ways<false, meta::type_list<ScopedE1>, meta::type_list<ScopedE2>>();
+ }
+
+ // Pointers.
+ {
+ check<true, meta::type_list<int*>>();
+ check_both_ways<false, meta::type_list<int*>, meta::type_list<const int*, long*, void*>>();
+
+ check<true, meta::type_list<FuncPtr1>>();
+ check_both_ways<false, meta::type_list<FuncPtr1>, meta::type_list<FuncPtr2>>();
+ }
+
+ // Pointers to members.
+ {
+ struct S {
+ int mem_obj1 = 0;
+ long mem_obj2 = 0;
+ void MemFunc1() {}
+ int MemFunc2() { return 0; }
+ };
+ using MemObjPtr1 = decltype(&S::mem_obj1);
+ using MemObjPtr2 = decltype(&S::mem_obj2);
+ using MemFuncPtr1 = decltype(&S::MemFunc1);
+ using MemFuncPtr2 = decltype(&S::MemFunc2);
+
+ check<true, meta::type_list<MemObjPtr1>>();
+ check<true, meta::type_list<MemFuncPtr1>>();
+ check_both_ways<false, meta::type_list<MemObjPtr1>, meta::type_list<MemObjPtr2>>();
+ check_both_ways<false, meta::type_list<MemFuncPtr1>, meta::type_list<MemFuncPtr2>>();
+ }
+
+ // Trivial classes.
+ {
+ struct S1 {};
+ check<true, meta::type_list<S1>>();
+
+ struct S2 {};
+ check_both_ways<false, meta::type_list<S1>, meta::type_list<S2>>();
+
+ // Having a `volatile` member doesn't prevent a class type from being considered trivially copyable. This is
+ // unfortunate behavior but it is consistent with the Standard.
+ struct VolatileMembersS {
+ volatile int x;
+ };
+ check<true, meta::type_list<VolatileMembersS>>();
+ }
+
+ // Trivial unions.
+ {
+ union U1 {};
+ check<true, meta::type_list<U1>>();
+
+ union U2 {};
+ check_both_ways<false, meta::type_list<U1>, meta::type_list<U2>>();
+
+ union VolatileMembersU {
+ volatile int x;
+ };
+ check<true, meta::type_list<VolatileMembersU>>();
+ }
+
+ // References are not objects, and thus are not bit-castable.
+ {
+ check_both_ways<false, meta::type_list<int&>, meta::type_list<int&>>();
+ }
+
+ // Arrays.
+ {
+ check<true, meta::type_list<int[8]>>();
+ }
+}
diff --git a/libcxx/test/std/algorithms/alg.modifying.operations/alg.copy/ranges.copy_backward.pass.cpp b/libcxx/test/std/algorithms/alg.modifying.operations/alg.copy/ranges.copy_backward.pass.cpp
index 766b220a04f40..a18ba9d6c344c 100644
--- a/libcxx/test/std/algorithms/alg.modifying.operations/alg.copy/ranges.copy_backward.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.modifying.operations/alg.copy/ranges.copy_backward.pass.cpp
@@ -111,6 +111,7 @@ constexpr void test_in_iterators() {
test_sentinels<bidirectional_iterator<int*>, Out>();
test_sentinels<random_access_iterator<int*>, Out>();
test_sentinels<contiguous_iterator<int*>, Out>();
+ test_sentinels<int*, Out>();
}
template <class Out>
@@ -124,6 +125,7 @@ constexpr bool test() {
test_in_iterators<bidirectional_iterator<int*>>();
test_in_iterators<random_access_iterator<int*>>();
test_in_iterators<contiguous_iterator<int*>>();
+ test_in_iterators<int*>();
test_proxy_in_iterators<ProxyIterator<bidirectional_iterator<int*>>>();
test_proxy_in_iterators<ProxyIterator<random_access_iterator<int*>>>();
diff --git a/libcxx/test/std/algorithms/alg.modifying.operations/alg.move/ranges.move.pass.cpp b/libcxx/test/std/algorithms/alg.modifying.operations/alg.move/ranges.move.pass.cpp
index d3350206d77e7..29630966e838d 100644
--- a/libcxx/test/std/algorithms/alg.modifying.operations/alg.move/ranges.move.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.modifying.operations/alg.move/ranges.move.pass.cpp
@@ -92,6 +92,7 @@ constexpr void test_in_iterators() {
test_iterators<bidirectional_iterator<int*>, Out>();
test_iterators<random_access_iterator<int*>, Out>();
test_iterators<contiguous_iterator<int*>, Out>();
+ test_iterators<int*, Out>();
}
template <class Out>
@@ -129,6 +130,7 @@ constexpr bool test() {
test_in_iterators<bidirectional_iterator<int*>>();
test_in_iterators<random_access_iterator<int*>>();
test_in_iterators<contiguous_iterator<int*>>();
+ test_in_iterators<int*>();
test_proxy_in_iterators<ProxyIterator<cpp20_input_iterator<int*>>>();
test_proxy_in_iterators<ProxyIterator<forward_iterator<int*>>>();
diff --git a/libcxx/test/std/algorithms/alg.modifying.operations/alg.move/ranges.move_backward.pass.cpp b/libcxx/test/std/algorithms/alg.modifying.operations/alg.move/ranges.move_backward.pass.cpp
index 143848a455200..b77c1ed87398c 100644
--- a/libcxx/test/std/algorithms/alg.modifying.operations/alg.move/ranges.move_backward.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.modifying.operations/alg.move/ranges.move_backward.pass.cpp
@@ -85,12 +85,19 @@ constexpr void test_iterators() {
test<In, Out, Sent, 0>({});
}
+template <class InIter, class OutIter>
+constexpr void test_sentinels() {
+ test_iterators<InIter, OutIter, InIter>();
+ test_iterators<InIter, OutIter, sentinel_wrapper<InIter>>();
+ test_iterators<InIter, OutIter, sized_sentinel<InIter>>();
+}
+
template <class Out>
constexpr void test_in_iterators() {
- test_iterators<bidirectional_iterator<int*>, Out, sentinel_wrapper<bidirectional_iterator<int*>>>();
- test_iterators<bidirectional_iterator<int*>, Out>();
- test_iterators<random_access_iterator<int*>, Out>();
- test_iterators<contiguous_iterator<int*>, Out>();
+ test_sentinels<bidirectional_iterator<int*>, Out>();
+ test_sentinels<random_access_iterator<int*>, Out>();
+ test_sentinels<contiguous_iterator<int*>, Out>();
+ test_sentinels<int*, Out>();
}
template <class Out>
@@ -125,6 +132,7 @@ constexpr bool test() {
test_in_iterators<bidirectional_iterator<int*>>();
test_in_iterators<random_access_iterator<int*>>();
test_in_iterators<contiguous_iterator<int*>>();
+ test_in_iterators<int*>();
test_proxy_in_iterators<ProxyIterator<bidirectional_iterator<int*>>>();
test_proxy_in_iterators<ProxyIterator<random_access_iterator<int*>>>();
diff --git a/libcxx/test/std/time/time.cal/time.cal.day/time.cal.day.nonmembers/ostream.pass.cpp b/libcxx/test/std/time/time.cal/time.cal.day/time.cal.day.nonmembers/ostream.pass.cpp
index d69ec660f1693..0e1730447e76f 100644
--- a/libcxx/test/std/time/time.cal/time.cal.day/time.cal.day.nonmembers/ostream.pass.cpp
+++ b/libcxx/test/std/time/time.cal/time.cal.day/time.cal.day.nonmembers/ostream.pass.cpp
@@ -12,6 +12,8 @@
// TODO FMT Investigate Windows issues.
// UNSUPPORTED msvc, target={{.+}}-windows-gnu
+// TODO FMT Evaluate gcc-12 status
+// UNSUPPORTED: gcc-12
// REQUIRES: locale.fr_FR.UTF-8
// REQUIRES: locale.ja_JP.UTF-8
diff --git a/libcxx/test/std/time/time.duration/time.duration.nonmember/ostream.pass.cpp b/libcxx/test/std/time/time.duration/time.duration.nonmember/ostream.pass.cpp
index 3b80abbbfa08a..0c2f6852ecc27 100644
--- a/libcxx/test/std/time/time.duration/time.duration.nonmember/ostream.pass.cpp
+++ b/libcxx/test/std/time/time.duration/time.duration.nonmember/ostream.pass.cpp
@@ -12,6 +12,8 @@
// TODO FMT Investigate Windows issues.
// UNSUPPORTED: msvc, target={{.+}}-windows-gnu
+// TODO FMT Evaluate gcc-12 status
+// UNSUPPORTED: gcc-12
// REQUIRES: locale.fr_FR.UTF-8
// REQUIRES: locale.ja_JP.UTF-8
diff --git a/libcxx/test/std/time/time.syn/formatter.duration.pass.cpp b/libcxx/test/std/time/time.syn/formatter.duration.pass.cpp
index e461c72c2ba7a..7d4ac7b1e1752 100644
--- a/libcxx/test/std/time/time.syn/formatter.duration.pass.cpp
+++ b/libcxx/test/std/time/time.syn/formatter.duration.pass.cpp
@@ -11,6 +11,8 @@
// TODO FMT Investigate Windows issues.
// UNSUPPORTED: msvc, target={{.+}}-windows-gnu
+// TODO FMT Evaluate gcc-12 status
+// UNSUPPORTED: gcc-12
// REQUIRES: locale.fr_FR.UTF-8
// REQUIRES: locale.ja_JP.UTF-8
diff --git a/libcxx/test/std/utilities/charconv/charconv.to.chars/integral.pass.cpp b/libcxx/test/std/utilities/charconv/charconv.to.chars/integral.pass.cpp
index 98781e53263d4..4bdb8ca084716 100644
--- a/libcxx/test/std/utilities/charconv/charconv.to.chars/integral.pass.cpp
+++ b/libcxx/test/std/utilities/charconv/charconv.to.chars/integral.pass.cpp
@@ -7,6 +7,8 @@
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++03, c++11, c++14
+// TODO FMT Evaluate gcc-12 status
+// UNSUPPORTED: gcc-12
// ADDITIONAL_COMPILE_FLAGS(has-fconstexpr-steps): -fconstexpr-steps=12712420
// ADDITIONAL_COMPILE_FLAGS(has-fconstexpr-ops-limit): -fconstexpr-ops-limit=50000000
diff --git a/libcxx/test/std/utilities/format/format.functions/P2418.pass.cpp b/libcxx/test/std/utilities/format/format.functions/P2418.pass.cpp
index 004e6c6c45946..9a5baecbb5f97 100644
--- a/libcxx/test/std/utilities/format/format.functions/P2418.pass.cpp
+++ b/libcxx/test/std/utilities/format/format.functions/P2418.pass.cpp
@@ -7,6 +7,8 @@
// UNSUPPORTED: c++03, c++11, c++14, c++17
// UNSUPPORTED: libcpp-has-no-incomplete-format
+// TODO FMT Evaluate gcc-12 status
+// UNSUPPORTED: gcc-12
// Tests whether a move only type can be formatted. This is required by
// P2418R2 "Add support for std::generator-like types to std::format"
diff --git a/libcxx/test/std/utilities/format/format.tuple/format.functions.vformat.pass.cpp b/libcxx/test/std/utilities/format/format.tuple/format.functions.vformat.pass.cpp
index ebcf8c4d8d343..7c9540c2db3a8 100644
--- a/libcxx/test/std/utilities/format/format.tuple/format.functions.vformat.pass.cpp
+++ b/libcxx/test/std/utilities/format/format.tuple/format.functions.vformat.pass.cpp
@@ -7,6 +7,8 @@
// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
// UNSUPPORTED: libcpp-has-no-incomplete-format
+// TODO FMT Evaluate gcc-12 status
+// UNSUPPORTED: gcc-12
// This test requires the dylib support introduced in D92214.
// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{.+}}
More information about the libcxx-commits
mailing list