[libc++] Optimize algorithms on uninitialized memory for trivial types.

[var-const]

Summary

There are five cases (also applying to the *_n versions of the
algorithms):

• destroy is a no-op when the type is trivially destructible;
• uninitialized_default_construct is a no-op when the type is trivially default-constructible and destructible;
• uninitialized_value_construct zeroes out trivially default constructible types using memset;
• uninitialized_fill uses memset if both types are trivial and 1-byte long;
• uninitialized_copy and uninitialized_move use memcpy on trivially copy-constructible types.

[var-const]

Fix tests in C++11 - C++17 modes.

[var-const]

Make construct_at.h compile in C++03 mode.

[• Quuxplusone]

FWIW, libc++'s historical position on this kind of optimization (which I associate particularly with Marshall's tenure) is "libc++ should do the simple thing; file a codegen bug against Clang if it's failing to optimize our simple template code for some trivial type." TBF, I have not looked closely at this PR to know whether that attitude would be unfair here for some reason.
Do you have a Godbolt of the codegen before and after? (You should.)

[ldionne]

In D118329#3277050, @Quuxplusone wrote:

FWIW, libc++'s historical position on this kind of optimization (which I associate particularly with Marshall's tenure) is "libc++ should do the simple thing; file a codegen bug against Clang if it's failing to optimize our simple template code for some trivial type." TBF, I have not looked closely at this PR to know whether that attitude would be unfair here for some reason.
Do you have a Godbolt of the codegen before and after? (You should.)

FWIW, I "sponsored" this patch in that I believe I was the one to request that we do it (or if not, then I immediately thought it was a good idea). I've also gone through several review iterations on it with Costa before it got published, so this is not far from a LGTM from my side.

However, I do agree it should be backed by at least some proof that it improves codegen. If Clang always ends up doing the right thing without us having to lift a finger, then this complexity is not actually worth it since the naive code "just works". I'd be surprised if Clang was clever enough to perform these optimizations in all cases, but I could be surprised.

[var-const]

In D118329#3277050, @Quuxplusone wrote:

FWIW, libc++'s historical position on this kind of optimization (which I associate particularly with Marshall's tenure) is "libc++ should do the simple thing; file a codegen bug against Clang if it's failing to optimize our simple template code for some trivial type." TBF, I have not looked closely at this PR to know whether that attitude would be unfair here for some reason.
Do you have a Godbolt of the codegen before and after? (You should.)

@Quuxplusone This is a very good point. I'd suggest holding off the review for now until I have some data.

[Mordante]

In D118329#3281020, @var-const wrote:

In D118329#3277050, @Quuxplusone wrote:

FWIW, libc++'s historical position on this kind of optimization (which I associate particularly with Marshall's tenure) is "libc++ should do the simple thing; file a codegen bug against Clang if it's failing to optimize our simple template code for some trivial type." TBF, I have not looked closely at this PR to know whether that attitude would be unfair here for some reason.
Do you have a Godbolt of the codegen before and after? (You should.)

@Quuxplusone This is a very good point. I'd suggest holding off the review for now until I have some data.

Thanks, I too like to see this data.

I only skimmed over the patch and didn't do a review.

libcxx/include/__memory/construct_at.h

113

For an if constexpr there needs to be an else branch to guarantee the code below isn't used.

Please search the patch for other occurances of if constexpr.

[huixie90]

libcxx/include/__memory/construct_at.h

80

Why is value_type used?
_VSTD::__destroy_at(_VSTD::addressof(*__first)); does not have any value_type involved

libcxx/include/__memory/uninitialized_algorithms.h

299

why is_trivially_destructible_v is needed? IIUC, we are not destroying anything since the memory [first, last) does not have any objects yet thus no destructors are required

300–308

This looks like the implementation of ranges::next(__first, __last) but I guess it is hard to reuse because this algorithm is c++17?

libcxx/include/__bit/bit_cast.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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___BIT_BIT_CAST_H
 #define _LIBCPP___BIT_BIT_CAST_H
 
 #include <__config>
 #include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
+template<class _ToType, class _FromType, class = __enable_if_t<
+  sizeof(_ToType) == sizeof(_FromType) &&
+  is_trivially_copyable<_ToType>::value &&
+  is_trivially_copyable<_FromType>::value
+> >
+_LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI
+_LIBCPP_CONSTEXPR _ToType __bit_cast(_FromType const& __from) _NOEXCEPT {
+    return __builtin_bit_cast(_ToType, __from);
+}
+
 #if _LIBCPP_STD_VER > 17
 
 template<class _ToType, class _FromType, class = enable_if_t<
   sizeof(_ToType) == sizeof(_FromType) &&
   is_trivially_copyable_v<_ToType> &&
   is_trivially_copyable_v<_FromType>
 >>
 _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI

libcxx/include/__iterator/iterator_traits.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//

 
 
 template <class _Tp>
 struct __is_exactly_cpp17_input_iterator
     : public integral_constant<bool,
          __has_iterator_category_convertible_to<_Tp, input_iterator_tag>::value &&
         !__has_iterator_category_convertible_to<_Tp, forward_iterator_tag>::value> {};
 
-#if _LIBCPP_STD_VER >= 17
 template<class _InputIterator>
 using __iter_value_type = typename iterator_traits<_InputIterator>::value_type;
 
+#if _LIBCPP_STD_VER >= 17
+
 template<class _InputIterator>
 using __iter_key_type = remove_const_t<typename iterator_traits<_InputIterator>::value_type::first_type>;
 
 template<class _InputIterator>
 using __iter_mapped_type = typename iterator_traits<_InputIterator>::value_type::second_type;
 
 template<class _InputIterator>
 using __iter_to_alloc_type = pair<
     add_const_t<typename iterator_traits<_InputIterator>::value_type::first_type>,
     typename iterator_traits<_InputIterator>::value_type::second_type>;
 #endif // _LIBCPP_STD_VER >= 17
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___ITERATOR_ITERATOR_TRAITS_H

libcxx/include/__memory/construct_at.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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___MEMORY_CONSTRUCT_AT_H
 #define _LIBCPP___MEMORY_CONSTRUCT_AT_H
 
 #include <__config>
 #include <__debug>
 #include <__iterator/access.h>
+#include <__iterator/iterator_traits.h>
+#include <__iterator/next.h>
 #include <__memory/addressof.h>
 #include <__memory/voidify.h>
 #include <__utility/forward.h>
 #include <type_traits>
 #include <utility>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header

 void __destroy_at(_Tp* __loc) {
     _LIBCPP_ASSERT(__loc, "null pointer given to destroy_at");
     _VSTD::__destroy(_VSTD::begin(*__loc), _VSTD::end(*__loc));
 }
 #endif
 
 template <class _ForwardIterator>
 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17
-_ForwardIterator __destroy(_ForwardIterator __first, _ForwardIterator __last) {
+_ForwardIterator __destroy(_ForwardIterator __first, _ForwardIterator __last,
+        __enable_if_t<is_trivially_destructible<__iter_value_type<_ForwardIterator> >::value>* = nullptr) {
+  return __last;
+}
+
+template <class _ForwardIterator>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17
+_ForwardIterator __destroy(_ForwardIterator __first, _ForwardIterator __last,
+        __enable_if_t<!is_trivially_destructible<__iter_value_type<_ForwardIterator> >::value>* = nullptr) {
     for (; __first != __last; ++__first)
         _VSTD::__destroy_at(_VSTD::addressof(*__first));
     return __first;
 }
 
 #if _LIBCPP_STD_VER > 14
 
 template <class _Tp, enable_if_t<!is_array_v<_Tp>, int> = 0>

 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17
 void destroy(_ForwardIterator __first, _ForwardIterator __last) {
   (void)_VSTD::__destroy(_VSTD::move(__first), _VSTD::move(__last));
 }
 
 template <class _ForwardIterator, class _Size>
 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17
 _ForwardIterator destroy_n(_ForwardIterator __first, _Size __n) {
+    if constexpr (is_trivially_destructible<__iter_value_type<_ForwardIterator>>::value) {
+      return _VSTD::next(__first, __n);
+    }
+
     for (; __n > 0; (void)++__first, --__n)
         _VSTD::__destroy_at(_VSTD::addressof(*__first));
     return __first;
 }
 
 #endif // _LIBCPP_STD_VER > 14
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___MEMORY_CONSTRUCT_AT_H

libcxx/include/__memory/uninitialized_algorithms.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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___MEMORY_UNINITIALIZED_ALGORITHMS_H
 #define _LIBCPP___MEMORY_UNINITIALIZED_ALGORITHMS_H
 
+#include <__bit/bit_cast.h>
 #include <__config>
 #include <__memory/addressof.h>
 #include <__memory/construct_at.h>
 #include <__memory/voidify.h>
 #include <iterator>
+#include <limits>
 #include <utility>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 // This is a simplified version of C++20 `unreachable_sentinel` that doesn't use concepts and thus can be used in any
 // language mode.
 struct __unreachable_sentinel {
   template <class _Iter>
   _LIBCPP_HIDE_FROM_ABI friend _LIBCPP_CONSTEXPR bool operator!=(const _Iter&, __unreachable_sentinel) _NOEXCEPT {
     return true;
   }
+
+  // When comparing the size of two ranges, having `__unreachable_sentinel` define `operator-` allows comparing the size
+  // of a range denoted by (iterator, __unreachable_sentinel) directly to the size of a range denoted by (iterator,
+  // iterator), with no special handling.
+  template <class _Iter>
+  _LIBCPP_HIDE_FROM_ABI friend _LIBCPP_CONSTEXPR
+  typename iterator_traits<_Iter>::difference_type operator-(__unreachable_sentinel, const _Iter&) _NOEXCEPT {
+    return numeric_limits<typename iterator_traits<_Iter>::difference_type>::max();
+  }
+};
+
+template <class _Iterator>
+struct __iter_cv_value_type {
+  using type = typename remove_reference<typename iterator_traits<_Iterator>::reference>::type;
+};
+
+template <class _Tp>
+struct __is_cv {
+  static const bool value = is_const<_Tp>::value || is_volatile<_Tp>::value;
+};
+
+// TODO(varconst): support contiguous iterators.
+template <class _From, class _OutputIterator, class _SizeOrSentinel,
+          class _To = typename __iter_cv_value_type<_OutputIterator>::type>
+struct __can_use_memset_fill {
+  static const bool value =
+    // The input is not volatile.
+    !is_volatile<_From>::value
+    // The output range is denoted by two pointers or a pointer and a size. Pointer isn't const or volatile.
+    && is_pointer<_OutputIterator>::value
+    && (is_integral<_SizeOrSentinel>::value || is_same<_SizeOrSentinel, _OutputIterator>::value)
+    && !__is_cv<_To>::value
+    // Both the input and the output type are 1 byte (`memset` only operates on single bytes) and constructing `_To`
+    // from `_From` is trivial.
+    && sizeof(_From) == sizeof(unsigned char)
+    && sizeof(_To) == sizeof(unsigned char)
+    && is_trivially_constructible<_To, _From>::value;
+};
+
+// TODO(varconst): support contiguous iterators.
+template <class _ValueType, class _OutputIterator, class _SizeOrSentinel>
+struct __can_use_memset_zero {
+  static const bool value =
+    // The output range is denoted by two pointers or a pointer and a size. Pointer isn't const or volatile.
+    is_pointer<_OutputIterator>::value
+    && !__is_cv<_ValueType>::value
+    && (is_integral<_SizeOrSentinel>::value || is_same<_SizeOrSentinel, _OutputIterator>::value)
+    // Default-constucting the output type is a trivial operation. Zero is special in that setting any trivial type to
+    // all zeroes produces a meaningful value.
+    && is_trivially_default_constructible<_ValueType>::value
+    // Pointers to members don't represent `nullptr` as all zeroes.
+    && !is_member_pointer<_ValueType>::value;
+};
+
+template <class _From, class _To>
+struct __is_bitwise_copyable {
+  static const bool value = (is_same<_From, _To>::value && is_trivially_copyable<_From>::value)
+      || (sizeof(_From) == sizeof(_To) && is_integral<_From>::value && is_integral<_To>::value);
+};
+
+// TODO(varconst): support contiguous iterators.
+template <class _InputIterator, class _SizeOrSentinel, class _OutputIterator, class _Sentinel2,
+          class _From = __iter_value_type<_InputIterator>,
+          class _To = __iter_value_type<_OutputIterator>,
+          class _FromCv = typename __iter_cv_value_type<_InputIterator>::type,
+          class _ToCv = typename __iter_cv_value_type<_OutputIterator>::type>
+struct __can_use_memcpy {
+  static const bool value =
+    // The input range is denoted by two pointers or a pointer and a size; pointers aren't volatile.
+    is_pointer<_InputIterator>::value
+    && (is_integral<_SizeOrSentinel>::value || is_same<_SizeOrSentinel, _InputIterator>::value)
+    && !is_volatile<_FromCv>::value
+    // The output range is denoted by two pointers or a pointer and the internal `unreachable_sentinel`. Pointer isn't
+    // const or volatile.
+    && is_pointer<_OutputIterator>::value
+    && (is_same<_Sentinel2, _OutputIterator>::value || is_same<_Sentinel2, __unreachable_sentinel>::value)
+    && !__is_cv<_ToCv>::value
+    // It is valid to do a bitwise copy between the types.
+    && __is_bitwise_copyable<_From, _To>::value;
 };
 
 // uninitialized_copy
 
-template <class _ValueType, class _InputIterator, class _Sentinel1, class _ForwardIterator, class _Sentinel2>
+template <class _ValueType, class _InputIterator, class _Sentinel1, class _ForwardIterator, class _Sentinel2,
+    __enable_if_t<__can_use_memcpy<_InputIterator, _Sentinel1, _ForwardIterator, _Sentinel2>::value>* = nullptr>
+inline _LIBCPP_HIDE_FROM_ABI pair<_InputIterator, _ForwardIterator>
+__uninitialized_copy(_InputIterator __ifirst, _Sentinel1 __ilast, _ForwardIterator __ofirst, _Sentinel2 __olast) {
+  auto __isize = __ilast - __ifirst;
+  auto __osize = __olast - __ofirst;
+  auto __smaller_size = __isize < __osize ? __isize : __osize;
+  _VSTD::memcpy(__ofirst, __ifirst, __smaller_size * sizeof(_ValueType));
+
+  return _VSTD::make_pair(__ifirst + __smaller_size, __ofirst + __smaller_size);
+}
+
+template <class _ValueType, class _InputIterator, class _Sentinel1, class _ForwardIterator, class _Sentinel2,
+    __enable_if_t<!__can_use_memcpy<_InputIterator, _Sentinel1, _ForwardIterator, _Sentinel2>::value>* = nullptr>
 inline _LIBCPP_HIDE_FROM_ABI pair<_InputIterator, _ForwardIterator>
 __uninitialized_copy(_InputIterator __ifirst, _Sentinel1 __ilast,
                      _ForwardIterator __ofirst, _Sentinel2 __olast) {
   _ForwardIterator __idx = __ofirst;
 #ifndef _LIBCPP_NO_EXCEPTIONS
   try {
 #endif
     for (; __ifirst != __ilast && __idx != __olast; ++__ifirst, (void)++__idx)
       ::new (_VSTD::__voidify(*__idx)) _ValueType(*__ifirst);
 #ifndef _LIBCPP_NO_EXCEPTIONS
   } catch (...) {
     _VSTD::__destroy(__ofirst, __idx);
     throw;
   }
 #endif
 
-  return pair<_InputIterator, _ForwardIterator>(_VSTD::move(__ifirst), _VSTD::move(__idx));
+  return _VSTD::make_pair(_VSTD::move(__ifirst), _VSTD::move(__idx));
 }
 
 template <class _InputIterator, class _ForwardIterator>
 _ForwardIterator uninitialized_copy(_InputIterator __ifirst, _InputIterator __ilast,
                                     _ForwardIterator __ofirst) {
   typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType;
   auto __result = _VSTD::__uninitialized_copy<_ValueType>(_VSTD::move(__ifirst), _VSTD::move(__ilast),
                                                           _VSTD::move(__ofirst), __unreachable_sentinel());
   return _VSTD::move(__result.second);
 }
 
 // uninitialized_copy_n
 
-template <class _ValueType, class _InputIterator, class _Size, class _ForwardIterator, class _Sentinel>
+template <class _ValueType, class _InputIterator, class _Size, class _ForwardIterator, class _Sentinel,
+    __enable_if_t<__can_use_memcpy<_InputIterator, _Size, _ForwardIterator, _Sentinel>::value>* = nullptr>
+inline _LIBCPP_HIDE_FROM_ABI pair<_InputIterator, _ForwardIterator>
+__uninitialized_copy_n(_InputIterator __ifirst, _Size __n,
+                       _ForwardIterator __ofirst, _Sentinel __olast) {
+  auto __isize = __n;
+  auto __osize = __olast - __ofirst;
+  auto __smaller_size = __isize < __osize ? __isize : __osize;
+  _VSTD::memcpy(__ofirst, __ifirst, __smaller_size * sizeof(_ValueType));
+
+  return _VSTD::make_pair(__ifirst + __smaller_size, __ofirst + __smaller_size);
+}
+
+template <class _ValueType, class _InputIterator, class _Size, class _ForwardIterator, class _Sentinel,
+    __enable_if_t<!__can_use_memcpy<_InputIterator, _Size, _ForwardIterator, _Sentinel>::value>* = nullptr>
 inline _LIBCPP_HIDE_FROM_ABI pair<_InputIterator, _ForwardIterator>
 __uninitialized_copy_n(_InputIterator __ifirst, _Size __n,
                        _ForwardIterator __ofirst, _Sentinel __olast) {
   _ForwardIterator __idx = __ofirst;
 #ifndef _LIBCPP_NO_EXCEPTIONS
   try {
 #endif
     for (; __n > 0 && __idx != __olast; ++__ifirst, (void)++__idx, (void)--__n)
       ::new (_VSTD::__voidify(*__idx)) _ValueType(*__ifirst);
 #ifndef _LIBCPP_NO_EXCEPTIONS
   } catch (...) {
     _VSTD::__destroy(__ofirst, __idx);
     throw;
   }
 #endif
 
-  return pair<_InputIterator, _ForwardIterator>(_VSTD::move(__ifirst), _VSTD::move(__idx));
+  return _VSTD::make_pair(_VSTD::move(__ifirst), _VSTD::move(__idx));
 }
 
 template <class _InputIterator, class _Size, class _ForwardIterator>
 inline _LIBCPP_HIDE_FROM_ABI _ForwardIterator uninitialized_copy_n(_InputIterator __ifirst, _Size __n,
                                                                    _ForwardIterator __ofirst) {
   typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType;
   auto __result = _VSTD::__uninitialized_copy_n<_ValueType>(_VSTD::move(__ifirst), __n, _VSTD::move(__ofirst),
                                                             __unreachable_sentinel());
   return _VSTD::move(__result.second);
 }
 
 // uninitialized_fill
 
-template <class _ValueType, class _ForwardIterator, class _Sentinel, class _Tp>
+template <class _ValueType, class _ForwardIterator, class _Sentinel, class _Tp,
+    __enable_if_t<__can_use_memset_fill<_Tp, _ForwardIterator, _Sentinel>::value>* = nullptr>
+inline _LIBCPP_HIDE_FROM_ABI
+_ForwardIterator __uninitialized_fill(_ForwardIterator __first, _Sentinel __last, const _Tp& __x)
+{
+    auto __n = __last - __first;
+    _VSTD::memset(__first, _VSTD::__bit_cast<unsigned char>(__x), sizeof(_ValueType) * __n);
+    return __first + __n;
+}
+
+template <class _ValueType, class _ForwardIterator, class _Sentinel, class _Tp,
+    __enable_if_t<!__can_use_memset_fill<_Tp, _ForwardIterator, _Sentinel>::value>* = nullptr>
 inline _LIBCPP_HIDE_FROM_ABI
 _ForwardIterator __uninitialized_fill(_ForwardIterator __first, _Sentinel __last, const _Tp& __x)
 {
     _ForwardIterator __idx = __first;
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try
     {
 #endif

 void uninitialized_fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __x)
 {
     typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType;
     (void)_VSTD::__uninitialized_fill<_ValueType>(__first, __last, __x);
 }
 
 // uninitialized_fill_n
 
-template <class _ValueType, class _ForwardIterator, class _Size, class _Tp>
+template <class _ValueType, class _ForwardIterator, class _Size, class _Tp,
+    __enable_if_t<__can_use_memset_fill<_Tp, _ForwardIterator, _Size>::value>* = nullptr>
+inline _LIBCPP_HIDE_FROM_ABI
+_ForwardIterator __uninitialized_fill_n(_ForwardIterator __first, _Size __n, const _Tp& __x)
+{
+    _VSTD::memset(__first, _VSTD::__bit_cast<unsigned char>(__x), sizeof(_ValueType) * __n);
+    return __first + __n;
+}
+
+template <class _ValueType, class _ForwardIterator, class _Size, class _Tp,
+    __enable_if_t<!__can_use_memset_fill<_Tp, _ForwardIterator, _Size>::value>* = nullptr>
 inline _LIBCPP_HIDE_FROM_ABI
 _ForwardIterator __uninitialized_fill_n(_ForwardIterator __first, _Size __n, const _Tp& __x)
 {
     _ForwardIterator __idx = __first;
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try
     {
 #endif

 
 #if _LIBCPP_STD_VER > 14
 
 // uninitialized_default_construct
 
 template <class _ValueType, class _ForwardIterator, class _Sentinel>
 inline _LIBCPP_HIDE_FROM_ABI
 _ForwardIterator __uninitialized_default_construct(_ForwardIterator __first, _Sentinel __last) {
+    if constexpr (is_trivially_default_constructible_v<_ValueType> && is_trivially_destructible_v<_ValueType>) {
+        if constexpr (is_assignable<_ForwardIterator, _Sentinel>::value) {
+          return __last;
+
+        } else {
+          while (__first != __last) {
+            ++__first;
+          }
+          return __first;
+        }
+    }
+
     auto __idx = __first;
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try {
 #endif
     for (; __idx != __last; ++__idx)
         ::new (_VSTD::__voidify(*__idx)) _ValueType;
 #ifndef _LIBCPP_NO_EXCEPTIONS
     } catch (...) {
(void)_VSTD::__uninitialized_default_construct<_ValueType>(
         _VSTD::move(__first), _VSTD::move(__last));
 }
 
 // uninitialized_default_construct_n
 
 template <class _ValueType, class _ForwardIterator, class _Size>
 inline _LIBCPP_HIDE_FROM_ABI
 _ForwardIterator __uninitialized_default_construct_n(_ForwardIterator __first, _Size __n) {
+    if constexpr (is_trivially_default_constructible_v<_ValueType> && is_trivially_destructible_v<_ValueType>) {
+        return _VSTD::next(_VSTD::move(__first), __n);
+    }
+
     auto __idx = __first;
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try {
 #endif
     for (; __n > 0; ++__idx, (void) --__n)
         ::new (_VSTD::__voidify(*__idx)) _ValueType;
 #ifndef _LIBCPP_NO_EXCEPTIONS
     } catch (...) {
_ForwardIterator uninitialized_default_construct_n(_ForwardIterator __first, _Size __n) {
     return _VSTD::__uninitialized_default_construct_n<_ValueType>(_VSTD::move(__first), __n);
 }
 
 // uninitialized_value_construct
 
 template <class _ValueType, class _ForwardIterator, class _Sentinel>
 inline _LIBCPP_HIDE_FROM_ABI
 _ForwardIterator __uninitialized_value_construct(_ForwardIterator __first, _Sentinel __last) {
+    if constexpr (__can_use_memset_zero<_ValueType, _ForwardIterator, _Sentinel>::value) {
+        auto __n = __last - __first;
+        _VSTD::memset(__first, 0, sizeof(_ValueType) * __n);
+        return __first + __n;
+    }
+
     auto __idx = __first;
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try {
 #endif
     for (; __idx != __last; ++__idx)
         ::new (_VSTD::__voidify(*__idx)) _ValueType();
 #ifndef _LIBCPP_NO_EXCEPTIONS
     } catch (...) {
(void)_VSTD::__uninitialized_value_construct<_ValueType>(
         _VSTD::move(__first), _VSTD::move(__last));
 }
 
 // uninitialized_value_construct_n
 
 template <class _ValueType, class _ForwardIterator, class _Size>
 inline _LIBCPP_HIDE_FROM_ABI
 _ForwardIterator __uninitialized_value_construct_n(_ForwardIterator __first, _Size __n) {
+    if constexpr (__can_use_memset_zero<_ValueType, _ForwardIterator, _Size>::value) {
+        _VSTD::memset(__first, 0, sizeof(_ValueType) * __n);
+        return __first + __n;
+    }
+
     auto __idx = __first;
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try {
 #endif
     for (; __n > 0; ++__idx, (void) --__n)
         ::new (_VSTD::__voidify(*__idx)) _ValueType();
 #ifndef _LIBCPP_NO_EXCEPTIONS
     } catch (...) {

 
 // uninitialized_move
 
 template <class _ValueType, class _InputIterator, class _Sentinel1, class _ForwardIterator, class _Sentinel2,
           class _IterMove>
 inline _LIBCPP_HIDE_FROM_ABI pair<_InputIterator, _ForwardIterator>
 __uninitialized_move(_InputIterator __ifirst, _Sentinel1 __ilast,
                      _ForwardIterator __ofirst, _Sentinel2 __olast, _IterMove __iter_move) {
+  if constexpr (__can_use_memcpy<_InputIterator, _Sentinel1, _ForwardIterator, _Sentinel2>::value) {
+    auto __isize = __ilast - __ifirst;
+    auto __osize = __olast - __ofirst;
+    auto __smaller_size = __isize < __osize ? __isize : __osize;
+    _VSTD::memcpy(__ofirst, __ifirst, __smaller_size * sizeof(_ValueType));
+
+    return _VSTD::make_pair(__ifirst + __smaller_size, __ofirst + __smaller_size);
+  }
+
   auto __idx = __ofirst;
 #ifndef _LIBCPP_NO_EXCEPTIONS
   try {
 #endif
     for (; __ifirst != __ilast && __idx != __olast; ++__idx, (void)++__ifirst) {
       ::new (_VSTD::__voidify(*__idx)) _ValueType(__iter_move(__ifirst));
     }
 #ifndef _LIBCPP_NO_EXCEPTIONS
inline _LIBCPP_HIDE_FROM_ABI _ForwardIterator uninitialized_move(_InputIterator __ifirst, _InputIterator __ilast,
   return _VSTD::move(__result.second);
 }
 
 // uninitialized_move_n
 
 template <class _ValueType, class _InputIterator, class _Size, class _ForwardIterator, class _Sentinel, class _IterMove>
 inline _LIBCPP_HIDE_FROM_ABI pair<_InputIterator, _ForwardIterator>
 __uninitialized_move_n(_InputIterator __ifirst, _Size __n,
-                       _ForwardIterator __ofirst, _Sentinel __olast, _IterMove __iter_move) {
+  if constexpr (__can_use_memcpy<_InputIterator, _Size, _ForwardIterator, _Sentinel>::value) {
+    auto __isize = __n;
+    auto __osize = __olast - __ofirst;
+    auto __smaller_size = __isize < __osize ? __isize : __osize;
+    _VSTD::memcpy(__ofirst, __ifirst, __smaller_size * sizeof(_ValueType));
+
+    return _VSTD::make_pair(__ifirst + __smaller_size, __ofirst + __smaller_size);
+  }
+
   auto __idx = __ofirst;
 #ifndef _LIBCPP_NO_EXCEPTIONS
   try {
 #endif
     for (; __n > 0 && __idx != __olast; ++__idx, (void)++__ifirst, --__n)
       ::new (_VSTD::__voidify(*__idx)) _ValueType(__iter_move(__ifirst));
 #ifndef _LIBCPP_NO_EXCEPTIONS
   } catch (...) {

libcxx/include/memory

template<nothrow-input-iterator InputIterator>
     constexpr InputIterator destroy_n(InputIterator first, iter_difference_t<InputIterator> n) noexcept; // since C++20
 }
 
 template <class InputIterator, class ForwardIterator>
  ForwardIterator uninitialized_move(InputIterator first, InputIterator last, ForwardIterator result);
 
 namespace ranges {
 
-template<class InputIterator, class OutputIterator>
+template <class InputIterator, class OutputIterator>
 using uninitialized_move_result = in_out_result<InputIterator, OutputIterator>; // since C++20
 
 template <input_iterator InputIterator, sentinel_for<InputIterator> Sentinel1, nothrow-forward-iterator OutputIterator, nothrow-sentinel-for<O> Sentinel2>
   requires constructible_from<iter_value_t<OutputIterator>, iter_rvalue_reference_t<InputIterator>>
 uninitialized_move_result<InputIterator, OutputIterator>
 uninitialized_move(InputIterator ifirst, Sentinel1 ilast, OutputIterator ofirst, Sentinel2 olast); // since C++20
 
-template<input_range InputRange, nothrow-forward-range OutputRange>
+template <input_range InputRange, nothrow-forward-range OutputRange>
   requires constructible_from<range_value_t<OutputRange>, range_rvalue_reference_t<InputRange>>
 uninitialized_move_result<borrowed_iterator_t<InputRange>, borrowed_iterator_t<OutputRange>>
 uninitialized_move(InputRange&& in_range, OutputRange&& out_range); // since C++20
 
 }
 
 template <class InputIterator, class Size, class ForwardIterator>
  pair<InputIterator,ForwardIterator> uninitialized_move_n(InputIterator first, Size n, ForwardIterator result);
 
 namespace ranges {
 
-template<class InputIterator, class OutputIterator>
+template <class InputIterator, class OutputIterator>
 using uninitialized_move_n_result = in_out_result<InputIterator, OutputIterator>; // since C++20
 
-template<input_iterator InputIterator, nothrow-forward-iterator OutputIterator, nothrow-sentinel-for<OutputIterator> Sentinel>
+template <input_iterator InputIterator, nothrow-forward-iterator OutputIterator, nothrow-sentinel-for<OutputIterator> Sentinel>
   requires constructible_from<iter_value_t<OutputIterator>, iter_rvalue_reference_t<InputIterator>>
 uninitialized_move_n_result<InputIterator, OutputIterator>
 uninitialized_move_n(InputIterator ifirst, iter_difference_t<InputIterator> n, OutputIterator ofirst, Sentinel olast); // since C++20
 
 }
 
 template <class ForwardIterator>
  void uninitialized_value_construct(ForwardIterator first, ForwardIterator last);

libcxx/include/type_traits

 template <class _Tp>
 inline constexpr bool is_object_v = is_object<_Tp>::value;
 #endif
 
 #endif // __has_keyword(__is_object)
 
 // is_compound
 
-// >= 11 because in C++03 nullptr isn't actually nullptr
 #if __has_keyword(__is_compound) && !defined(_LIBCPP_CXX03_LANG)
 
 template<class _Tp>
 struct _LIBCPP_TEMPLATE_VIS is_compound : _BoolConstant<__is_compound(_Tp)> { };
 
 #if _LIBCPP_STD_VER > 14
 template <class _Tp>
 inline constexpr bool is_compound_v = __is_compound(_Tp);

libcxx/test/std/utilities/memory/specialized.algorithms/buffer.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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_TEST_STD_UTILITIES_MEMORY_SPECIALIZED_ALGORITHMS_BUFFER_H
 #define LIBCPP_TEST_STD_UTILITIES_MEMORY_SPECIALIZED_ALGORITHMS_BUFFER_H
 
+#include <cassert>
+#include <iterator>
+
+#include "test_iterators.h"
+
 template <typename T, int N>
 struct Buffer {
   alignas(T) char buffer[sizeof(T) * N] = {};
 
   T* begin() { return reinterpret_cast<T*>(buffer); }
   T* end() { return begin() + N; }
   const T* cbegin() const { return reinterpret_cast<const T*>(buffer); }
   const T* cend() const { return cbegin() + N; }
 
   constexpr int size() const { return N; }
 };
 
+template <typename T, int N>
+class NonContiguousBuffer {
+  static constexpr int magic = 12345678;
+
+  struct Cell {
+    alignas(T) char raw_value[sizeof(T)] = {};
+    int padding = magic;
+  };
+
+  Cell buffer[N] = {};
+
+  struct iterator {
+    using value_type = T;
+    using difference_type = ptrdiff_t;
+    using reference = T&;
+    using pointer = T*;
+    using iterator_category = std::random_access_iterator_tag;
+
+    Cell* cur = nullptr;
+
+    iterator() = default;
+    explicit iterator(Cell* ptr) : cur(ptr) {}
+
+    T& operator*() const { return *reinterpret_cast<T*>(cur->raw_value); }
+    T* operator->() const { return reinterpret_cast<T*>(cur->raw_value); }
+
+    iterator& operator++() {
+      ++cur;
+      return *this;
+    }
+
+    iterator operator++(int) {
+      iterator prev = *this;
+      ++cur;
+      return prev;
+    }
+
+    iterator& operator+=(size_t n) {
+      cur += n;
+      return *this;
+    }
+
+    bool operator==(const iterator& rhs) const { return cur == rhs.cur; }
+    bool operator!=(const iterator& rhs) const { return cur != rhs.cur; }
+  };
+
+public:
+  using iterator_t = random_access_iterator<iterator>;
+  using forward_iterator_t = forward_iterator<iterator>;
+
+  iterator_t begin() { return iterator_t(iterator(buffer)); }
+  iterator_t end() { return iterator_t(iterator(buffer + N)); }
+
+  constexpr int size() const { return N; }
+
+  // Checks and asserts that no out-of-bounds writes occurred within the buffer.
+  void validate() const {
+    for (const Cell& e : buffer) {
+      assert(e.padding == magic);
+    }
+  }
+};
+
 #endif // LIBCPP_TEST_STD_UTILITIES_MEMORY_SPECIALIZED_ALGORITHMS_BUFFER_H

libcxx/test/std/utilities/memory/specialized.algorithms/specialized.destroy/destroy.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 
 // <memory>
 
 // template <class ForwardIt>
 // constexpr void destroy(ForwardIt, ForwardIt);
 
 #include <memory>
 #include <cassert>
 #include <type_traits>
 
+#include "../buffer.h"
 #include "test_macros.h"
 #include "test_iterators.h"
 
 struct Counted {
     int* counter_;
     TEST_CONSTEXPR Counted(int* counter) : counter_(counter) { ++*counter_; }
     TEST_CONSTEXPR Counted(Counted const& other) : counter_(other.counter_) { ++*counter_; }
     TEST_CONSTEXPR_CXX20 ~Counted() { --*counter_; }
constexpr bool test_arrays() {
         assert(counter == 5 * 3);
 
         std::destroy(pool, pool + 5);
         ASSERT_SAME_TYPE(decltype(std::destroy(pool, pool + 5)), void);
         assert(counter == 0);
 
         std::allocator_traits<Alloc>::deallocate(alloc, pool, 5);
     }
+
     {
         using Array = Counted[3][2];
         using Alloc = std::allocator<Array>;
         int counter = 0;
         Alloc alloc;
         Array* pool = std::allocator_traits<Alloc>::allocate(alloc, 5);
 
         for (Array* p = pool; p != pool + 5; ++p) {
constexpr bool test_arrays() {
 
         std::allocator_traits<Alloc>::deallocate(alloc, pool, 5);
     }
 
     return true;
 }
 #endif
 
+template <class T, int N>
+TEST_CONSTEXPR_CXX20 void test_trivial() {
+    std::allocator<T> alloc;
+    using Traits = std::allocator_traits<decltype(alloc)>;
+    T* pool = Traits::allocate(alloc, N);
+
+    for (T* p = pool; p != pool + N; ++p) {
+        Traits::construct(alloc, p);
+    }
+
+    std::destroy(pool, pool + N);
+    Traits::deallocate(alloc, pool, N);
+}
+
 template <class It>
 TEST_CONSTEXPR_CXX20 void test() {
     using Alloc = std::allocator<Counted>;
     int counter = 0;
     Alloc alloc;
     Counted* pool = std::allocator_traits<Alloc>::allocate(alloc, 5);
 
     for (Counted* p = pool; p != pool + 5; ++p)
         std::allocator_traits<Alloc>::construct(alloc, p, &counter);
     assert(counter == 5);
 
     std::destroy(It(pool), It(pool + 5));
     ASSERT_SAME_TYPE(decltype(std::destroy(It(pool), It(pool + 5))), void);
     assert(counter == 0);
 
     std::allocator_traits<Alloc>::deallocate(alloc, pool, 5);
 }
 
 TEST_CONSTEXPR_CXX20 bool tests() {
     test<Counted*>();
     test<forward_iterator<Counted*>>();
+
+    // Trivial types.
+    {
+        constexpr int N = 5;
+
+        test_trivial<int, N>();
+        test_trivial<int*, N>();
+
+        struct Trivial {
+            int a;
+            float b;
+        };
+        static_assert(std::is_trivial<Trivial>::value);
+
+        test_trivial<Trivial, N>();
+    }
+
     return true;
 }
 
 int main(int, char**) {
     tests();
 #if TEST_STD_VER > 17
     test_arrays();
     static_assert(tests());
     // TODO: Until std::construct_at has support for arrays, it's impossible to test this
     //       in a constexpr context (see https://reviews.llvm.org/D114903).
     // static_assert(test_arrays());
 #endif
     return 0;
 }

libcxx/test/std/utilities/memory/specialized.algorithms/specialized.destroy/destroy_at.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
TEST_CONSTEXPR_CXX20 bool test() {
         assert(counter == 1);
 
         std::destroy_at(ptr2);
         assert(counter == 0);
 
         std::allocator_traits<Alloc>::deallocate(alloc, ptr1, 1);
         std::allocator_traits<Alloc>::deallocate(alloc, ptr2, 1);
     }
+
     {
         using Alloc = std::allocator<DerivedCounted>;
         Alloc alloc;
         DerivedCounted* ptr1 = std::allocator_traits<Alloc>::allocate(alloc, 1);
         DerivedCounted* ptr2 = std::allocator_traits<Alloc>::allocate(alloc, 1);
 
         int counter = 0;
         std::allocator_traits<Alloc>::construct(alloc, ptr1, &counter);

libcxx/test/std/utilities/memory/specialized.algorithms/specialized.destroy/destroy_n.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
constexpr bool test_arrays()  {
 
         Array* p = std::destroy_n(pool, 5);
         ASSERT_SAME_TYPE(decltype(std::destroy_n(pool, 5)), Array*);
         assert(p == pool + 5);
         assert(counter == 0);
 
         std::allocator_traits<Alloc>::deallocate(alloc, pool, 5);
     }
+
     {
         using Array = Counted[3][2];
         using Alloc = std::allocator<Array>;
         int counter = 0;
         Alloc alloc;
         Array* pool = std::allocator_traits<Alloc>::allocate(alloc, 5);
 
         for (Array* p = pool; p != pool + 5; ++p) {
constexpr bool test_arrays()  {
 
         std::allocator_traits<Alloc>::deallocate(alloc, pool, 5);
     }
 
     return true;
 }
 #endif
 
+template <class T, int N>
+TEST_CONSTEXPR_CXX20 void test_trivial() {
+    std::allocator<T> alloc;
+    using Traits = std::allocator_traits<decltype(alloc)>;
+    T* pool = Traits::allocate(alloc, N);
+
+    for (T* p = pool; p != pool + N; ++p) {
+        Traits::construct(alloc, p);
+    }
+
+    std::destroy_n(pool, N);
+    Traits::deallocate(alloc, pool, N);
+}
+
 template <class It>
 TEST_CONSTEXPR_CXX20 void test() {
     using Alloc = std::allocator<Counted>;
     int counter = 0;
     Alloc alloc;
     Counted* pool = std::allocator_traits<Alloc>::allocate(alloc, 5);
 
     for (Counted* p = pool; p != pool + 5; ++p)
         std::allocator_traits<Alloc>::construct(alloc, p, &counter);
     assert(counter == 5);
 
     It it = std::destroy_n(It(pool), 5);
     ASSERT_SAME_TYPE(decltype(std::destroy_n(It(pool), 5)), It);
     assert(it == It(pool + 5));
     assert(counter == 0);
 
     std::allocator_traits<Alloc>::deallocate(alloc, pool, 5);
 }
 
 TEST_CONSTEXPR_CXX20 bool tests() {
     test<Counted*>();
     test<forward_iterator<Counted*>>();
+
+    // Trivial types.
+    {
+        constexpr int N = 5;
+
+        test_trivial<int, N>();
+        test_trivial<int*, N>();
+
+        struct Trivial {
+            int a;
+            float b;
+        };
+        static_assert(std::is_trivial<Trivial>::value);
+
+        test_trivial<Trivial, N>();
+    }
+
     return true;
 }
 
 int main(int, char**) {
     tests();
 #if TEST_STD_VER > 17
     test_arrays();
     static_assert(tests());
     // TODO: Until std::construct_at has support for arrays, it's impossible to test this
     //       in a constexpr context (see https://reviews.llvm.org/D114903).
     // static_assert(test_arrays());
 #endif
     return 0;
 }

libcxx/test/std/utilities/memory/specialized.algorithms/specialized.destroy/ranges_destroy.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
struct Counted {
 
   constexpr Counted(int& count_ref) : count(count_ref) { ++count; }
   constexpr Counted(const Counted& rhs) : count(rhs.count) { ++count; }
   constexpr ~Counted() { --count; }
 
   friend void operator&(Counted) = delete;
 };
 
+template <class T, int N>
+TEST_CONSTEXPR_CXX20 void test_trivial() {
+  std::allocator<T> alloc;
+  using Traits = std::allocator_traits<decltype(alloc)>;
+
+  {
+    T* pool = Traits::allocate(alloc, N);
+
+    for (T* p = pool; p != pool + N; ++p) {
+      Traits::construct(alloc, p);
+    }
+
+    std::ranges::destroy(pool, pool + N);
+    Traits::deallocate(alloc, pool, N);
+  }
+
+  {
+    T* pool = Traits::allocate(alloc, N);
+
+    for (T* p = pool; p != pool + N; ++p) {
+      Traits::construct(alloc, p);
+    }
+
+    std::ranges::subrange range(pool, pool + N);
+    std::ranges::destroy(range);
+    Traits::deallocate(alloc, pool, N);
+  }
+}
+
 template <class Iterator>
 constexpr void test() {
   // (iterator + sentinel) overload.
   {
     constexpr int N = 5;
     std::allocator<Counted> alloc;
     using Traits = std::allocator_traits<decltype(alloc)>;
     int counter = 0;
// (range) overload.
     Traits::deallocate(alloc, out, N);
   }
 }
 
 constexpr bool tests() {
   test<Counted*>();
   test<forward_iterator<Counted*>>();
 
+  // Trivial types.
+  {
+    constexpr int N = 5;
+
+    test_trivial<int, N>();
+    test_trivial<int*, N>();
+
+    struct Trivial {
+      int a;
+      float b;
+    };
+    static_assert(std::is_trivial<Trivial>::value);
+
+    test_trivial<Trivial, N>();
+  }
+
   return true;
 }
 
 constexpr bool test_arrays() {
   // One-dimensional array, (iterator + sentinel) overload.
   {
     constexpr int N = 5;
     constexpr int M = 3;

libcxx/test/std/utilities/memory/specialized.algorithms/specialized.destroy/ranges_destroy_n.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
struct Counted {
 
   constexpr Counted(int& count_ref) : count(count_ref) { ++count; }
   constexpr Counted(const Counted& rhs) : count(rhs.count) { ++count; }
   constexpr ~Counted() { --count; }
 
   friend void operator&(Counted) = delete;
 };
 
+template <class T, int N>
+TEST_CONSTEXPR_CXX20 void test_trivial() {
+  std::allocator<T> alloc;
+  using Traits = std::allocator_traits<decltype(alloc)>;
+  T* pool = Traits::allocate(alloc, N);
+
+  for (T* p = pool; p != pool + N; ++p) {
+    Traits::construct(alloc, p);
+  }
+
+  std::ranges::destroy_n(pool, N);
+  Traits::deallocate(alloc, pool, N);
+}
+
 template <class Iterator>
 constexpr void test() {
   {
     constexpr int N = 5;
+
     std::allocator<Counted> alloc;
     using Traits = std::allocator_traits<decltype(alloc)>;
     int counter = 0;
 
     Counted* out = Traits::allocate(alloc, N);
     for (int i = 0; i != N; ++i) {
       Traits::construct(alloc, out + i, counter);
     }
     assert(counter == N);
 
     std::ranges::destroy_n(Iterator(out), N);
     assert(counter == 0);
 
     Traits::deallocate(alloc, out, N);
   }
 }
 
 constexpr bool tests() {
   test<Counted*>();
   test<forward_iterator<Counted*>>();
 
+  // Trivial types.
+  {
+    constexpr int N = 5;
+
+    test_trivial<int, N>();
+    test_trivial<int*, N>();
+
+    struct Trivial {
+      int a;
+      float b;
+    };
+    static_assert(std::is_trivial<Trivial>::value);
+
+    test_trivial<Trivial, N>();
+  }
+
   return true;
 }
 
 constexpr bool test_arrays() {
   // One-dimensional array.
   {
     constexpr int N = 5;
     constexpr int M = 3;
// Multidimensional array.
     assert(counter == N * A * B);
 
     std::ranges::destroy_n(buffer, N);
     assert(counter == 0);
 
     Traits::deallocate(alloc, buffer, N);
   }
 
+  // Trivial types.
+  {
+    constexpr int N = 5;
+
+    int x[N] = {};
+    std::ranges::destroy_n(x, N);
+
+    int* y[N] = {};
+    std::ranges::destroy_n(y, N);
+
+    struct Trivial {
+      int a;
+      float b;
+    };
+    static_assert(std::is_trivial<Trivial>::value);
+
+    Trivial z[N] = {};
+    std::ranges::destroy_n(z, N);
+  }
+
   return true;
 }
 
 int main(int, char**) {
   tests();
   test_arrays();
 
   static_assert(tests());
   // TODO: Until std::construct_at has support for arrays, it's impossible to test this
   //       in a constexpr context (see https://reviews.llvm.org/D114903).
   // static_assert(test_arrays());
 
   return 0;
 }

libcxx/test/std/utilities/memory/specialized.algorithms/uninitialized.construct.default/ranges_uninitialized_default_construct.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 // UNSUPPORTED: libcpp-no-concepts, libcpp-has-no-incomplete-ranges
 
+// ADDITIONAL_COMPILE_FLAGS: -Wno-deprecated-volatile
+
 // <memory>
 
 // template <nothrow-forward-iterator ForwardIterator, nothrow-sentinel-for<ForwardIterator> Sentinel>
 //   requires default_initializable<iter_value_t<ForwardIterator>>
 // ForwardIterator ranges::uninitialized_default_construct(ForwardIterator first, Sentinel last);
 //
 // template <nothrow-forward-range ForwardRange>
 //   requires default_initializable<range_value_t<ForwardRange>>

 // implementations are allowed to use a different mechanism to achieve this effect, so this check is
 // libc++-specific.
 LIBCPP_STATIC_ASSERT(std::is_class_v<decltype(std::ranges::uninitialized_default_construct)>);
 
 struct NotDefaultCtrable { NotDefaultCtrable() = delete; };
 static_assert(!std::is_invocable_v<decltype(std::ranges::uninitialized_default_construct),
     NotDefaultCtrable*, NotDefaultCtrable*>);
 
+int dtr_calls = 0;
+
 int main(int, char**) {
   // An empty range -- no default constructors should be invoked.
   {
     Buffer<Counted, 1> buf;
 
     std::ranges::uninitialized_default_construct(buf.begin(), buf.begin());
     assert(Counted::current_objects == 0);
     assert(Counted::total_objects == 0);
 
     std::ranges::uninitialized_default_construct(std::ranges::empty_view<Counted>());
     assert(Counted::current_objects == 0);
     assert(Counted::total_objects == 0);
 
     forward_iterator<Counted*> it(buf.begin());
-    auto range = std::ranges::subrange(it, sentinel_wrapper<forward_iterator<Counted*>>(it));
+    std::ranges::subrange range(it, sentinel_wrapper<forward_iterator<Counted*>>(it));
     std::ranges::uninitialized_default_construct(range.begin(), range.end());
     assert(Counted::current_objects == 0);
     assert(Counted::total_objects == 0);
 
     std::ranges::uninitialized_default_construct(range);
     assert(Counted::current_objects == 0);
     assert(Counted::total_objects == 0);
   }
// A range containing several objects, (iter, sentinel) overload.
     Counted::reset();
   }
 
   // A range containing several objects, (range) overload.
   {
     constexpr int N = 5;
     Buffer<Counted, N> buf;
 
-    auto range = std::ranges::subrange(buf.begin(), buf.end());
+    std::ranges::subrange range(buf.begin(), buf.end());
     std::ranges::uninitialized_default_construct(range);
     assert(Counted::current_objects == N);
     assert(Counted::total_objects == N);
 
     std::destroy(buf.begin(), buf.end());
     Counted::reset();
   }
 
// Using `views::counted`.
     Counted::reset();
   }
 
   // Using `reverse_view`.
   {
     constexpr int N = 3;
     Buffer<Counted, 5> buf;
 
-    auto range = std::ranges::subrange(buf.begin(), buf.begin() + N);
+    std::ranges::subrange range(buf.begin(), buf.begin() + N);
     std::ranges::uninitialized_default_construct(std::ranges::reverse_view(range));
     assert(Counted::current_objects == N);
     assert(Counted::total_objects == N);
 
     std::destroy(buf.begin(), buf.begin() + N);
     Counted::reset();
   }
 
// Works with const iterators, (iter, sentinel) overload.
     std::destroy(buf.begin(), buf.end());
     Counted::reset();
   }
 
   // Works with const iterators, (range) overload.
   {
     constexpr int N = 5;
     Buffer<Counted, N> buf;
-    auto range = std::ranges::subrange(buf.cbegin(), buf.cend());
+    std::ranges::subrange range(buf.cbegin(), buf.cend());
 
     std::ranges::uninitialized_default_construct(range);
     assert(Counted::current_objects == N);
     assert(Counted::total_objects == N);
     std::destroy(buf.begin(), buf.end());
     Counted::reset();
   }
 
+  // Works with trivial types, (iter, sentinel) overload.
+  {
+    constexpr int N = 5;
+
+    {
+      Buffer<char, N> buf;
+      auto result = std::ranges::uninitialized_default_construct(buf.begin(), buf.end());
+      assert(result == buf.end());
+    }
+
+    {
+      Buffer<int*, N> buf;
+      auto result = std::ranges::uninitialized_default_construct(buf.begin(), buf.end());
+      assert(result == buf.end());
+    }
+
+    {
+      struct Trivial {
+        int a;
+        float b;
+      };
+      static_assert(std::is_trivial<Trivial>::value);
+
+      Buffer<Trivial, N> buf;
+      auto result = std::ranges::uninitialized_default_construct(buf.begin(), buf.end());
+      assert(result == buf.end());
+    }
+  }
+
+  // Works with trivial types, (range) overload.
+  {
+    constexpr int N = 5;
+
+    {
+      Buffer<char, N> buf;
+      std::ranges::subrange range(buf.begin(), buf.end());
+
+      auto result = std::ranges::uninitialized_default_construct(range);
+      assert(result == buf.end());
+    }
+
+    {
+      Buffer<int*, N> buf;
+      std::ranges::subrange range(buf);
+
+      auto result = std::ranges::uninitialized_default_construct(range);
+      assert(result == buf.end());
+    }
+
+    {
+      struct Trivial {
+        int a;
+        float b;
+      };
+      static_assert(std::is_trivial<Trivial>::value);
+
+      Buffer<Trivial, N> buf;
+      std::ranges::subrange range(buf.begin(), buf.end());
+
+      auto result = std::ranges::uninitialized_default_construct(range);
+      assert(result == buf.end());
+    }
+
+#ifndef TEST_HAS_NO_EXCEPTIONS
+    // Make sure destructor calls are not optimized away for a type with a trivial default constructor but a non-trivial
+    // destructor.
+    {
+      struct NonTrivialDtr {
+        ~NonTrivialDtr() { ++dtr_calls; }
+      };
+      // Note: `is_trivially_default_constructible` is in practice only true if the type is also trivially
+      // destructible, so a `static_assert` is not possible.
+
+      Buffer<NonTrivialDtr, 5> buf;
+      using IterT = ThrowingIterator<NonTrivialDtr>;
+      IterT begin(buf.begin(), buf.end(), 3, IterT::TAIncrement);
+      IterT end(buf.end(), buf.end());
+
+      try {
+        std::ranges::uninitialized_default_construct(begin, end);
+        assert(false);
+      } catch (...) {
+      }
+
+      assert(dtr_calls == 3);
+    }
+#endif
+  }
+
+  // Works on non-contiguous ranges, (iter, sentinel) overload.
+  {
+    NonContiguousBuffer<double, 5> buf;
+    std::ranges::uninitialized_default_construct(buf.begin(), buf.end());
+    buf.validate();
+  }
+
+  // Works on non-contiguous ranges, (range) overload.
+  {
+    NonContiguousBuffer<double, 5> buf;
+    std::ranges::subrange range(buf);
+
+    std::ranges::uninitialized_default_construct(range);
+    buf.validate();
+  }
+
+  // Note: can't default-construct a const type.
+
+  // Works with volatile outputs.
+  {
+    // (iter, sentinel) overload.
+    {
+      Buffer<volatile char, 5> buf;
+      std::ranges::uninitialized_default_construct(buf.begin(), buf.end());
+    }
+
+    // (range) overload.
+    {
+      Buffer<volatile char, 5> buf;
+      std::ranges::subrange range(buf);
+      std::ranges::uninitialized_default_construct(range);
+    }
+  }
+
   return 0;
 }

libcxx/test/std/utilities/memory/specialized.algorithms/uninitialized.construct.default/ranges_uninitialized_default_construct_n.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 // UNSUPPORTED: libcpp-no-concepts, libcpp-has-no-incomplete-ranges
 
+// ADDITIONAL_COMPILE_FLAGS: -Wno-deprecated-volatile
+
 // <memory>
 
 // template <nothrow-forward-iterator ForwardIterator>
 //   requires default_initializable<iter_value_t<ForwardIterator>>
 // ForwardIterator ranges::uninitialized_default_construct_n(ForwardIterator first,
 //     iter_difference_t<ForwardIterator> n);
 
 #include <cassert>

 // implementations are allowed to use a different mechanism to achieve this effect, so this check is
 // libc++-specific.
 LIBCPP_STATIC_ASSERT(std::is_class_v<decltype(std::ranges::uninitialized_default_construct_n)>);
 
 struct NotDefaultCtrable { NotDefaultCtrable() = delete; };
 static_assert(!std::is_invocable_v<decltype(std::ranges::uninitialized_default_construct_n),
     NotDefaultCtrable*, int>);
 
+int dtr_calls = 0;
+
 int main(int, char**) {
   // An empty range -- no default constructors should be invoked.
   {
     Buffer<Counted, 1> buf;
 
     std::ranges::uninitialized_default_construct_n(buf.begin(), 0);
     assert(Counted::current_objects == 0);
     assert(Counted::total_objects == 0);
// Works with const iterators.
 
     std::ranges::uninitialized_default_construct_n(buf.cbegin(), N);
     assert(Counted::current_objects == N);
     assert(Counted::total_objects == N);
     std::destroy(buf.begin(), buf.end());
     Counted::reset();
   }
 
+  // Works with trivial types.
+  {
+    constexpr int N = 5;
+
+    {
+      Buffer<char, N> buf;
+      auto result = std::ranges::uninitialized_default_construct_n(buf.begin(), N);
+      assert(result == buf.end());
+    }
+
+    {
+      Buffer<int*, N> buf;
+      auto result = std::ranges::uninitialized_default_construct_n(buf.begin(), N);
+      assert(result == buf.end());
+    }
+
+    {
+      struct Trivial {
+        int a;
+        float b;
+      };
+      static_assert(std::is_trivial<Trivial>::value);
+
+      Buffer<Trivial, N> buf;
+      auto result = std::ranges::uninitialized_default_construct_n(buf.begin(), N);
+      assert(result == buf.end());
+    }
+
+#ifndef TEST_HAS_NO_EXCEPTIONS
+    // Make sure destructor calls are not optimized away for a type with a trivial default constructor but a non-trivial
+    // destructor.
+    {
+      struct NonTrivialDtr {
+        ~NonTrivialDtr() { ++dtr_calls; }
+      };
+      // Note: `is_trivially_default_constructible` is in practice only true if the type is also trivially
+      // destructible, so a `static_assert` is not possible.
+
+      Buffer<NonTrivialDtr, N> buf;
+      using IterT = ThrowingIterator<NonTrivialDtr>;
+      IterT begin(buf.begin(), buf.end(), 3, IterT::TAIncrement);
+      IterT end(buf.end(), buf.end());
+
+      try {
+        std::ranges::uninitialized_default_construct_n(begin, N);
+        assert(false);
+      } catch (...) {
+      }
+
+      assert(dtr_calls == 3);
+    }
+#endif
+  }
+
+  // Works on non-contiguous ranges.
+  {
+    NonContiguousBuffer<double, 5> buf;
+    std::ranges::uninitialized_default_construct_n(buf.begin(), 5);
+    buf.validate();
+  }
+
+  // Note: can't default-construct a const type.
+
+  // Works with volatile outputs.
+  {
+    {
+      Buffer<volatile char, 5> buf;
+      std::ranges::uninitialized_default_construct_n(buf.begin(), 5);
+    }
+  }
+
   return 0;
 }

libcxx/test/std/utilities/memory/specialized.algorithms/uninitialized.construct.default/uninitialized_default_construct.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 
 // <memory>
 
 // template <class ForwardIt>
 // void uninitialized_default_construct(ForwardIt, ForwardIt);
 
 #include <memory>
 #include <cstdlib>
 #include <cassert>
 
+#include "../buffer.h"
 #include "test_macros.h"
 #include "test_iterators.h"
 
 struct Counted {
   static int count;
   static int constructed;
   explicit Counted() { ++count; ++constructed; }
   Counted(Counted const&) { assert(false); }
void test_counted()
     assert(Counted::constructed == 1);
     std::uninitialized_default_construct(It(p+1), It(p+N));
     assert(Counted::count == 5);
     assert(Counted::constructed == 5);
     std::destroy(p, p+N);
     assert(Counted::count == 0);
 }
 
+int dtr_calls = 0;
+
+void test_trivial() {
+    constexpr int N = 5;
+
+    {
+        Buffer<char, N> buf;
+        std::uninitialized_default_construct(buf.begin(), buf.end());
+    }
+
+    {
+        Buffer<int*, N> buf;
+        std::uninitialized_default_construct(buf.begin(), buf.end());
+    }
+
+    {
+        struct Trivial {
+          int a;
+          float b;
+        };
+        static_assert(std::is_trivial<Trivial>::value);
+
+        Buffer<Trivial, N> buf;
+        std::uninitialized_default_construct(buf.begin(), buf.end());
+    }
+
+#ifndef TEST_HAS_NO_EXCEPTIONS
+    // Make sure destructor calls are not optimized away for a type with a trivial default constructor but a non-trivial
+    // destructor.
+    {
+        struct NonTrivialDtr {
+            ~NonTrivialDtr() {
+                ++dtr_calls;
+            }
+        };
+        // Note: `is_trivially_default_constructible` is in practice only true if the type is also trivially
+        // destructible, so a `static_assert` is not possible.
+
+        Buffer<NonTrivialDtr, 5> buf;
+        using IterT = ThrowingIterator<NonTrivialDtr>;
+        IterT begin(buf.begin(), buf.end(), 3, IterT::TAIncrement);
+        IterT end(buf.end(), buf.end());
+
+        try {
+          std::uninitialized_default_construct(begin, end);
+          assert(false);
+        } catch (...) {}
+
+        assert(dtr_calls == 3);
+    }
+#endif
+}
+
+void test_non_contiguous() {
+    NonContiguousBuffer<double, 5> buf;
+
+    std::uninitialized_default_construct(buf.begin(), buf.end());
+    buf.validate();
+}
+
+void test_cv() {
+    constexpr int N = 5;
+
+    // Const output.
+    {
+        Buffer<const char, N> buf;
+        std::uninitialized_default_construct(buf.begin(), buf.end());
+    }
+
+    // Volatile output.
+    {
+        Buffer<volatile char, N> buf;
+        std::uninitialized_default_construct(buf.begin(), buf.end());
+    }
+}
+
 int main(int, char**)
 {
     test_counted();
     test_ctor_throws();
+    test_trivial();
+    test_non_contiguous();
+    test_cv();
 
     return 0;
 }

libcxx/test/std/utilities/memory/specialized.algorithms/uninitialized.construct.default/uninitialized_default_construct_n.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 
 // <memory>
 
 // template <class ForwardIt>
 // void uninitialized_default_construct(ForwardIt, ForwardIt);
 
 #include <memory>
-#include <cstdlib>
 #include <cassert>
+#include <cstdlib>
+#include <type_traits>
 
+#include "../buffer.h"
 #include "test_macros.h"
 #include "test_iterators.h"
 
 struct Counted {
   static int count;
   static int constructed;
   static void reset() { count = constructed =  0; }
   explicit Counted() { ++count; ++constructed; }
void test_counted()
     e = std::uninitialized_default_construct_n(It(p+1), 4);
     assert(e == It(p+N));
     assert(Counted::count == 5);
     assert(Counted::constructed == 5);
     std::destroy(p, p+N);
     assert(Counted::count == 0);
 }
 
+int dtr_calls = 0;
+
+void test_trivial() {
+    constexpr int N = 5;
+
+    {
+        Buffer<char, N> buf;
+        std::uninitialized_default_construct_n(buf.begin(), N);
+    }
+
+    {
+        Buffer<int*, N> buf;
+        std::uninitialized_default_construct_n(buf.begin(), N);
+    }
+
+    {
+        struct Trivial {
+            int a;
+            float b;
+        };
+        static_assert(std::is_trivial<Trivial>::value);
+
+        Buffer<Trivial, N> buf;
+        std::uninitialized_default_construct_n(buf.begin(), N);
+    }
+
+#ifndef TEST_HAS_NO_EXCEPTIONS
+    // Make sure destructor calls are not optimized away for a type with a trivial default constructor but a non-trivial
+    // destructor.
+    {
+        struct NonTrivialDtr {
+            ~NonTrivialDtr() {
+                ++dtr_calls;
+            }
+        };
+        // Note: `is_trivially_default_constructible` is in practice only true if the type is also trivially
+        // destructible, so a `static_assert` is not possible.
+
+        Buffer<NonTrivialDtr, 5> buf;
+        using IterT = ThrowingIterator<NonTrivialDtr>;
+        IterT begin(buf.begin(), buf.end(), 3, IterT::TAIncrement);
+        IterT end(buf.end(), buf.end());
+
+        try {
+          std::uninitialized_default_construct(begin, end);
+          assert(false);
+        } catch (...) {}
+
+        assert(dtr_calls == 3);
+    }
+#endif
+}
+
+void test_non_contiguous() {
+    NonContiguousBuffer<double, 5> buf;
+
+    std::uninitialized_default_construct_n(buf.begin(), buf.size());
+    buf.validate();
+}
+
+void test_cv() {
+    constexpr int N = 5;
+
+    // Const output.
+    {
+        Buffer<const char, N> buf;
+        std::uninitialized_default_construct_n(buf.begin(), N);
+    }
+
+    // Volatile output.
+    {
+        Buffer<volatile char, N> buf;
+        std::uninitialized_default_construct_n(buf.begin(), N);
+    }
+}
+
 int main(int, char**)
 {
     test_counted();
     test_ctor_throws();
+    test_trivial();
+    test_non_contiguous();
+    test_cv();
 
     return 0;
 }

libcxx/test/std/utilities/memory/specialized.algorithms/uninitialized.construct.value/ranges_uninitialized_value_construct.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
// An empty range -- no default constructors should be invoked.
     assert(Counted::current_objects == 0);
     assert(Counted::total_objects == 0);
 
     std::ranges::uninitialized_value_construct(std::ranges::empty_view<Counted>());
     assert(Counted::current_objects == 0);
     assert(Counted::total_objects == 0);
 
     forward_iterator<Counted*> it(buf.begin());
-    auto range = std::ranges::subrange(it, sentinel_wrapper<forward_iterator<Counted*>>(it));
+    std::ranges::subrange range(it, sentinel_wrapper<forward_iterator<Counted*>>(it));
     std::ranges::uninitialized_value_construct(range.begin(), range.end());
     assert(Counted::current_objects == 0);
     assert(Counted::total_objects == 0);
 
     std::ranges::uninitialized_value_construct(range);
     assert(Counted::current_objects == 0);
     assert(Counted::total_objects == 0);
   }
// A range containing several objects, (iter, sentinel) overload.
     Counted::reset();
   }
 
   // A range containing several objects, (range) overload.
   {
     constexpr int N = 5;
     Buffer<Counted, N> buf;
 
-    auto range = std::ranges::subrange(buf.begin(), buf.end());
+    std::ranges::subrange range(buf.begin(), buf.end());
     std::ranges::uninitialized_value_construct(range);
     assert(Counted::current_objects == N);
     assert(Counted::total_objects == N);
 
     std::destroy(buf.begin(), buf.end());
     Counted::reset();
   }
 
// Using `views::counted`.
     Counted::reset();
   }
 
   // Using `reverse_view`.
   {
     constexpr int N = 3;
     Buffer<Counted, 5> buf;
 
-    auto range = std::ranges::subrange(buf.begin(), buf.begin() + N);
+    std::ranges::subrange range(buf.begin(), buf.begin() + N);
     std::ranges::uninitialized_value_construct(std::ranges::reverse_view(range));
     assert(Counted::current_objects == N);
     assert(Counted::total_objects == N);
 
     std::destroy(buf.begin(), buf.begin() + N);
     Counted::reset();
   }
 
// Works with const iterators, (iter, sentinel) overload.
     Counted::reset();
   }
 
   // Works with const iterators, (range) overload.
   {
     constexpr int N = 5;
     Buffer<Counted, N> buf;
 
-    auto range = std::ranges::subrange(buf.cbegin(), buf.cend());
+    std::ranges::subrange range(buf.cbegin(), buf.cend());
     std::ranges::uninitialized_value_construct(range);
     assert(Counted::current_objects == N);
     assert(Counted::total_objects == N);
     std::destroy(buf.begin(), buf.end());
     Counted::reset();
   }
 
+  // Works with trivial types, (iter, sentinel) overload.
+  {
+    constexpr int N = 5;
+
+    {
+      Buffer<int, N> x;
+
+      auto result = std::ranges::uninitialized_value_construct(x.begin(), x.end());
+      assert(result == x.end());
+      assert(std::all_of(x.begin(), x.end(), [](auto e) { return e == 0; }));
+    }
+
+    {
+      Buffer<int*, N> y;
+
+      auto result = std::ranges::uninitialized_value_construct(y.begin(), y.end());
+      assert(result == y.end());
+      assert(std::all_of(y.begin(), y.end(), [](auto e) { return e == nullptr; }));
+    }
+
+    {
+      struct Trivial {
+        int a;
+        float b;
+        bool operator==(const Trivial& rhs) const { return a == rhs.a && b == rhs.b; }
+      };
+      static_assert(std::is_trivial<Trivial>::value);
+
+      Buffer<Trivial, N> z;
+
+      auto result = std::ranges::uninitialized_value_construct(z.begin(), z.end());
+      assert(result == z.end());
+      assert(std::all_of(z.begin(), z.end(), [](auto e) { return e == Trivial(); }));
+    }
+
+    // Pointers to members don't represent `nullptr` as all zeroes -- make sure the implementation doesn't try to simply
+    // zero out the object in this case.
+    {
+      struct Foo {};
+      using MemberPtr = int Foo::*;
+
+      Buffer<MemberPtr, 5> buf;
+      std::ranges::uninitialized_value_construct(buf.begin(), buf.end());
+      assert(std::all_of(buf.begin(), buf.end(), [](auto e) { return e == nullptr; }));
+    }
+  }
+
+  // Works with trivial types, (range) overload.
+  {
+    constexpr int N = 5;
+
+    {
+      Buffer<int, N> buf;
+      std::ranges::subrange range(buf.begin(), buf.end());
+
+      auto result = std::ranges::uninitialized_value_construct(range);
+      assert(result == buf.end());
+      assert(std::all_of(buf.begin(), buf.end(), [](auto e) { return e == 0; }));
+    }
+
+    {
+      Buffer<int*, N> buf;
+      std::ranges::subrange range(buf.begin(), buf.end());
+
+      auto result = std::ranges::uninitialized_value_construct(range);
+      assert(result == buf.end());
+      assert(std::all_of(buf.begin(), buf.end(), [](auto e) { return e == nullptr; }));
+    }
+
+    {
+      struct Trivial {
+        int a;
+        float b;
+        bool operator==(const Trivial& rhs) const { return a == rhs.a && b == rhs.b; }
+      };
+      static_assert(std::is_trivial<Trivial>::value);
+
+      Buffer<Trivial, N> buf;
+      std::ranges::subrange range(buf.begin(), buf.end());
+
+      auto result = std::ranges::uninitialized_value_construct(range);
+      assert(result == buf.end());
+      assert(std::all_of(buf.begin(), buf.end(), [](auto e) { return e == Trivial(); }));
+    }
+
+    // Pointers to members don't represent `nullptr` as all zeroes -- make sure the implementation doesn't try to simply
+    // zero out the object in this case.
+    {
+      struct Foo {};
+      using MemberPtr = int Foo::*;
+
+      Buffer<MemberPtr, N> buf;
+      std::ranges::uninitialized_value_construct(buf);
+      assert(std::all_of(buf.begin(), buf.end(), [](auto e) { return e == nullptr; }));
+    }
+  }
+
   return 0;
 }

libcxx/test/std/utilities/memory/specialized.algorithms/uninitialized.construct.value/ranges_uninitialized_value_construct_n.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
// Works with const iterators.
 
     std::ranges::uninitialized_value_construct_n(buf.cbegin(), N);
     assert(Counted::current_objects == N);
     assert(Counted::total_objects == N);
     std::destroy(buf.begin(), buf.end());
     Counted::reset();
   }
 
+  // Works with trivial types.
+  {
+    constexpr int N = 5;
+
+    {
+      Buffer<int, N> x;
+
+      auto result = std::ranges::uninitialized_value_construct_n(x.begin(), N);
+      assert(result == x.end());
+      assert(std::all_of(x.begin(), x.end(), [](auto e) { return e == 0; }));
+    }
+
+    {
+      Buffer<int*, N> y;
+
+      auto result = std::ranges::uninitialized_value_construct_n(y.begin(), N);
+      assert(result == y.end());
+      assert(std::all_of(y.begin(), y.end(), [](auto e) { return e == nullptr; }));
+    }
+
+    {
+      struct Trivial {
+        int a;
+        float b;
+        bool operator==(const Trivial& rhs) const { return a == rhs.a && b == rhs.b; }
+      };
+      static_assert(std::is_trivial<Trivial>::value);
+
+      Buffer<Trivial, N> z;
+
+      auto result = std::ranges::uninitialized_value_construct_n(z.begin(), N);
+      assert(result == z.end());
+      assert(std::all_of(z.begin(), z.end(), [](auto e) { return e == Trivial(); }));
+    }
+
+    // Pointers to members don't represent `nullptr` as all zeroes -- make sure the implementation doesn't try to simply
+    // zero out the object in this case.
+    {
+      struct Foo {};
+      using MemberPtr = int Foo::*;
+
+      Buffer<MemberPtr, N> buf;
+      std::ranges::uninitialized_value_construct_n(buf.begin(), N);
+      assert(std::all_of(buf.begin(), buf.end(), [](auto e) { return e == nullptr; }));
+    }
+  }
+
   return 0;
 }

libcxx/test/std/utilities/memory/specialized.algorithms/uninitialized.construct.value/uninitialized_value_construct.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 
 // <memory>
 
 // template <class ForwardIt>
 // void uninitialized_value_construct(ForwardIt, ForwardIt);
 
 #include <memory>
-#include <cstdlib>
+#include <algorithm>
 #include <cassert>
+#include <cstdlib>
+#include <type_traits>
 
-#include "test_macros.h"
+#include "../buffer.h"
 #include "test_iterators.h"
+#include "test_macros.h"
 
 struct Counted {
   static int count;
   static int constructed;
   static void reset() { count = constructed =  0; }
   explicit Counted() { ++count; ++constructed; }
   Counted(Counted const&) { assert(false); }
   ~Counted() { assert(count > 0); --count; }
#ifndef TEST_HAS_NO_EXCEPTIONS
     alignas(ThrowsCounted) char pool[sizeof(ThrowsCounted)*N] = {};
     ThrowsCounted* p = (ThrowsCounted*)pool;
     try {
         ThrowsCounted::throw_after = 4;
         std::uninitialized_value_construct(It(p), It(p+N));
         assert(false);
     } catch (...) {}
     assert(ThrowsCounted::count == 0);
-    assert(ThrowsCounted::constructed == 4); // forth construction throws
+    assert(ThrowsCounted::constructed == 4); // Fourth construction throws
 #endif
 }
 
 void test_counted()
 {
     using It = forward_iterator<Counted*>;
     const int N = 5;
     alignas(Counted) char pool[sizeof(Counted)*N] = {};
void test_value_initialized()
     assert(pool[1] == -1);
     std::uninitialized_value_construct(It(p+1), It(p+N));
     assert(pool[1] == 0);
     assert(pool[2] == 0);
     assert(pool[3] == 0);
     assert(pool[4] == 0);
 }
 
+void test_trivial() {
+  constexpr int N = 5;
+
+  {
+    Buffer<char, N> buf;
+    std::uninitialized_value_construct(buf.begin(), buf.end());
+    assert(std::all_of(buf.begin(), buf.end(), [](auto e) { return e == 0; }));
+  }
+
+  {
+    Buffer<int*, N> buf;
+    std::uninitialized_value_construct(buf.begin(), buf.end());
+    assert(std::all_of(buf.begin(), buf.end(), [](auto e) { return e == nullptr; }));
+  }
+
+  {
+    struct Trivial {
+      int a;
+      float b;
+      bool operator==(const Trivial& rhs) const { return a == rhs.a && b == rhs.b; }
+    };
+    static_assert(std::is_trivial<Trivial>::value);
+
+    Buffer<Trivial, N> buf;
+    std::uninitialized_value_construct(buf.begin(), buf.end());
+    assert(std::all_of(buf.begin(), buf.end(), [](auto e) { return e == Trivial(); }));
+  }
+
+  // Pointers to members don't represent `nullptr` as all zeroes -- make sure the implementation doesn't try to simply
+  // zero out the object in this case.
+  {
+    struct Foo {};
+    using MemberPtr = int Foo::*;
+
+    Buffer<MemberPtr, 5> buf;
+    std::uninitialized_value_construct(buf.begin(), buf.end());
+    assert(std::all_of(buf.begin(), buf.end(), [](auto e) { return e == nullptr; }));
+  }
+}
+
 int main(int, char**)
 {
     test_counted();
     test_value_initialized();
     test_ctor_throws();
+    test_trivial();
 
     return 0;
 }

libcxx/test/std/utilities/memory/specialized.algorithms/uninitialized.construct.value/uninitialized_value_construct_n.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 
 // <memory>
 
 // template <class ForwardIt>
 // void uninitialized_value_construct(ForwardIt, ForwardIt);
 
 #include <memory>
+#include <algorithm>
 #include <cstdlib>
 #include <cassert>
 
+#include "../buffer.h"
 #include "test_macros.h"
 #include "test_iterators.h"
 
 struct Counted {
   static int count;
   static int constructed;
   static void reset() { count = constructed =  0; }
   explicit Counted() { ++count; ++constructed; }
#ifndef TEST_HAS_NO_EXCEPTIONS
     const int N = 5;
     alignas(ThrowsCounted) char pool[sizeof(ThrowsCounted)*N] = {};
     ThrowsCounted* p = (ThrowsCounted*)pool;
     try {
         ThrowsCounted::throw_after = 4;
         std::uninitialized_value_construct_n(It(p), N);
         assert(false);
     } catch (...) {}
-    assert(ThrowsCounted::count == 3);
-    assert(ThrowsCounted::constructed == 4); // forth construction throws
-    std::destroy(p, p+3);
     assert(ThrowsCounted::count == 0);
+    assert(ThrowsCounted::constructed == 4); // Fourth construction throws
 #endif
 }
 
 void test_counted()
 {
     using It = forward_iterator<Counted*>;
     const int N = 5;
     alignas(Counted) char pool[sizeof(Counted)*N] = {};
void test_value_initialized()
     e = std::uninitialized_value_construct_n(It(p+1), 4);
     assert(e == It(p+N));
     assert(pool[1] == 0);
     assert(pool[2] == 0);
     assert(pool[3] == 0);
     assert(pool[4] == 0);
 }
 
+void test_trivial() {
+  constexpr int N = 5;
+
+  {
+    Buffer<char, N> buf;
+    std::uninitialized_value_construct_n(buf.begin(), N);
+    assert(std::all_of(buf.begin(), buf.end(), [](auto e) { return e == 0; }));
+  }
+
+  {
+    Buffer<int*, N> buf;
+    std::uninitialized_value_construct_n(buf.begin(), N);
+    assert(std::all_of(buf.begin(), buf.end(), [](auto e) { return e == nullptr; }));
+  }
+
+  {
+    struct Trivial {
+      int a;
+      float b;
+      bool operator==(const Trivial& rhs) const { return a == rhs.a && b == rhs.b; }
+    };
+    static_assert(std::is_trivial<Trivial>::value);
+
+    Buffer<Trivial, N> buf;
+    std::uninitialized_value_construct_n(buf.begin(), N);
+    assert(std::all_of(buf.begin(), buf.end(), [](auto e) { return e == Trivial(); }));
+  }
+
+  // Pointers to members don't represent `nullptr` as all zeroes -- make sure the implementation doesn't try to simply
+  // zero out the object in this case.
+  {
+    struct Foo {};
+    using MemberPtr = int Foo::*;
+
+    Buffer<MemberPtr, 5> buf;
+    std::uninitialized_value_construct_n(buf.begin(), N);
+    assert(std::all_of(buf.begin(), buf.end(), [](auto e) { return e == nullptr; }));
+  }
+}
+
 int main(int, char**)
 {
     test_counted();
     test_value_initialized();
+    test_ctor_throws();
+    test_trivial();
 
     return 0;
 }

libcxx/test/std/utilities/memory/specialized.algorithms/uninitialized.copy/ranges_uninitialized_copy.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 // UNSUPPORTED: libcpp-no-concepts, libcpp-has-no-incomplete-ranges
 
+// ADDITIONAL_COMPILE_FLAGS: -Wno-deprecated-volatile -Wno-sign-compare
+
 // <memory>
 //
 // template<input_iterator I, sentinel-for<I> S1, nothrow-forward-iterator O, nothrow-sentinel-for<O> S2>
 //   requires constructible_from<iter_value_t<O>, iter_reference_t<I>>
 // uninitialized_copy_result<I, O> ranges::uninitialized_copy(I ifirst, S1 ilast, O ofirst, S2 olast); // since C++20
 //
 // template<input_range IR, nothrow-forward-range OR>
 //   requires constructible_from<range_value_t<OR>, range_reference_t<IR>>
 // uninitialized_copy_result<borrowed_iterator_t<IR>, borrowed_iterator_t<OR>> ranges::uninitialized_copy(IR&& in_range, OR&& out_range); // since C++20
 
 #include <algorithm>
 #include <cassert>
+#include <initializer_list>
 #include <iterator>
 #include <memory>
 #include <ranges>
 #include <type_traits>
 
 #include "../buffer.h"
 #include "../counted.h"
 #include "test_macros.h"
 #include "test_iterators.h"
 
 // TODO(varconst): consolidate the ADL checks into a single file.
 // Because this is a variable and not a function, it's guaranteed that ADL won't be used. However,
 // implementations are allowed to use a different mechanism to achieve this effect, so this check is
 // libc++-specific.
 LIBCPP_STATIC_ASSERT(std::is_class_v<decltype(std::ranges::uninitialized_copy)>);
 
 static_assert(std::is_invocable_v<decltype(std::ranges::uninitialized_copy), int*, int*, long*, long*>);
 struct NotConvertibleFromInt {};
 static_assert(!std::is_invocable_v<decltype(std::ranges::uninitialized_copy), int*, int*, NotConvertibleFromInt*,
                                    NotConvertibleFromInt*>);
 
+template <class From, class To>
+void test_trivial(std::initializer_list<From> from) {
+  constexpr int N = 3;
+  Buffer<To, N> buf;
+
+  // (iter, sentinel) overload.
+  {
+    std::ranges::uninitialized_copy(from.begin(), from.end(), buf.begin(), buf.end());
+    auto buf_iter = buf.begin();
+    // Note: `std::equal` doesn't work with volatile types.
+    for (auto& e : from) {
+      assert(e == *buf_iter);
+      ++buf_iter;
+    }
+  }
+
+  // (range) overload.
+  {
+    std::ranges::uninitialized_copy(from, buf);
+    auto buf_iter = buf.begin();
+    for (auto& e : from) {
+      assert(e == *buf_iter);
+      ++buf_iter;
+    }
+  }
+}
+
 int main(int, char**) {
   // An empty range -- no default constructors should be invoked.
   {
     Counted in[] = {Counted()};
     Buffer<Counted, 1> out;
     Counted::reset();
 
     {
// Destination range is shorter than the source range, (range) overload.
     assert(Counted::total_copies == M);
     assert(Counted::total_moves == 0);
 
     assert(std::equal(in, in + M, out.begin(), out.end()));
     assert(result.in == in + M);
     assert(result.out == out.end());
   }
 
+  // Works with trivial types.
+  {
+    test_trivial<char, char>({'a', 'b', 'c'});
+    test_trivial<char, unsigned char>({'a', 'b', 'c'});
+    test_trivial<std::byte, std::byte>({std::byte(1), std::byte(2), std::byte(3)});
+
+    test_trivial<int, int>({1, 2, 3});
+    test_trivial<char, int>({'a', 'b', 'c'});
+    test_trivial<int, char>({1, 2, 3});
+
+    test_trivial<long long, int>({1, 2, 3});
+    test_trivial<int, long long>({1, 2, 3});
+
+    test_trivial<unsigned long, int>({1, 2, 3});
+    test_trivial<int, unsigned long>({1, 2, 3});
+
+    test_trivial<float, double>({1.5, 2.5, 3.5});
+    test_trivial<double, float>({1.5, 2.5, 3.5});
+
+    {
+      struct Trivial {
+        int a;
+        float b;
+        bool operator==(const Trivial& rhs) const { return a == rhs.a && b == rhs.b; }
+      };
+      static_assert(std::is_trivial<Trivial>::value);
+      test_trivial<Trivial, Trivial>({Trivial{1, 1}, Trivial{2, 2}, Trivial{3, 3}});
+    }
+
+    {
+      struct Empty {
+        bool operator==(const Empty&) const { return true; }
+      };
+      test_trivial<Empty, Empty>({Empty(), Empty(), Empty()});
+    }
+
+    // Conversion between user-defined trivial types.
+    {
+      struct TrivialFrom { char a; };
+      struct TrivialTo {
+        unsigned char a;
+        TrivialTo() = default;
+        TrivialTo(TrivialFrom from) : a(from.a) {}
+        bool operator==(TrivialFrom rhs) const { return a == rhs.a; }
+      };
+      static_assert(std::is_trivial<TrivialFrom>::value);
+      static_assert(std::is_trivial<TrivialTo>::value);
+
+      using From = TrivialFrom;
+      test_trivial<TrivialFrom, TrivialTo>({From{'a'}, From{'b'}, From{'c'}});
+    }
+  }
+
+  // Works on non-contiguous ranges.
+  {
+    const int N = 5;
+    NonContiguousBuffer<int, N> buf;
+
+    int from[N] = {1, 2, 3, 4, 5};
+    std::ranges::uninitialized_copy(from, from + N, buf.begin(), buf.end());
+    assert(std::equal(from, from + N, buf.begin()));
+    buf.validate();
+
+    // TODO(varconst): also test non-contiguous input range.
+  }
+
+  // Trivial types work with non-random-access iterators.
+  {
+    const int N = 5;
+    Buffer<int, N> buf;
+
+    int from[N] = {1, 2, 3, 4, 5};
+    forward_iterator<int*> from_begin(from), from_end(from + N);
+    forward_iterator<int*> to_begin(buf.begin()), to_end(buf.end());
+    std::ranges::uninitialized_copy(from_begin, from_end, to_begin, to_end);
+    assert(std::equal(from, from + N, buf.begin()));
+  }
+
+  // Works with const outputs.
+  {
+    test_trivial<char, const char>({'a', 'b', 'c'});
+    test_trivial<int, const int>({1, 2, 3});
+  }
+
+  // Works with volatile inputs and outputs.
+  {
+    test_trivial<volatile char, char>({'a', 'b', 'c'});
+    test_trivial<volatile int, int>({1, 2, 3});
+
+    test_trivial<char, volatile char>({'a', 'b', 'c'});
+    test_trivial<int, volatile int>({1, 2, 3});
+  }
+
+  // Works when only one of the ranges uses random-access iterators.
+  {
+    // (ptr, ptr) | (fwd_iter, fwd_iter)
+    {
+      int from[5] = {1, 2, 3, 4, 5};
+      Buffer<int, 3> buf;
+
+      forward_iterator<int*> to_begin(buf.begin()), to_end(buf.end());
+      std::ranges::uninitialized_copy(from, from + 5, to_begin, to_end);
+      assert(std::equal(from, from + 3, buf.begin()));
+    }
+
+    // (fwd_iter, fwd_iter) | (ptr, ptr)
+    {
+      int from[3] = {1, 2, 3};
+      Buffer<int, 5> buf;
+
+      forward_iterator<int*> from_begin(from), from_end(from + 3);
+      std::ranges::uninitialized_copy(from_begin, from_end, buf.begin(), buf.end());
+      assert(std::equal(from, from + 3, buf.begin()));
+    }
+
+    // (ptr, ptr) | (ptr, unreachable)
+    {
+      int from[3] = {1, 2, 3};
+      Buffer<int, 5> buf;
+
+      std::ranges::uninitialized_copy(from, from + 3, buf.begin(), std::unreachable_sentinel);
+      assert(std::equal(from, from + 3, buf.begin()));
+    }
+
+    // (ptr, unreachable) | (ptr, ptr)
+    {
+      int from[5] = {1, 2, 3, 4, 5};
+      Buffer<int, 3> buf;
+
+      std::ranges::uninitialized_copy(from, std::unreachable_sentinel, buf.begin(), buf.end());
+      assert(std::equal(from, from + 3, buf.begin()));
+    }
+  }
+
   return 0;
 }

libcxx/test/std/utilities/memory/specialized.algorithms/uninitialized.copy/ranges_uninitialized_copy_n.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 // UNSUPPORTED: libcpp-no-concepts, libcpp-has-no-incomplete-ranges
 
+// ADDITIONAL_COMPILE_FLAGS: -Wno-deprecated-volatile -Wno-sign-compare
+
 // <memory>
 //
-// template<input_iterator I, nothrow-forward-iterator O, nothrow-sentinel-for<O> S>
+// template <input_iterator I, nothrow-forward-iterator O, nothrow-sentinel-for<O> S>
 //   requires constructible_from<iter_value_t<O>, iter_reference_t<I>>
 // uninitialized_copy_n_result<I, O> uninitialized_copy_n(I ifirst, iter_difference_t<I> n, O ofirst, S olast); // since C++20
 
 #include <algorithm>
 #include <cassert>
+#include <initializer_list>
 #include <iterator>
 #include <memory>
 #include <ranges>
 #include <type_traits>
 
 #include "../buffer.h"
 #include "../counted.h"
 #include "test_macros.h"
 #include "test_iterators.h"
 
 // TODO(varconst): consolidate the ADL checks into a single file.
 // Because this is a variable and not a function, it's guaranteed that ADL won't be used. However,
 // implementations are allowed to use a different mechanism to achieve this effect, so this check is
 // libc++-specific.
 LIBCPP_STATIC_ASSERT(std::is_class_v<decltype(std::ranges::uninitialized_copy_n)>);
 
 static_assert(std::is_invocable_v<decltype(std::ranges::uninitialized_copy_n), int*, size_t, long*, long*>);
 struct NotConvertibleFromInt {};
 static_assert(!std::is_invocable_v<decltype(std::ranges::uninitialized_copy_n), int*, size_t, NotConvertibleFromInt*,
                                    NotConvertibleFromInt*>);
 
+template <class From, class To>
+void test_trivial(std::initializer_list<From> from) {
+  constexpr int N = 3;
+  Buffer<To, N> buf;
+
+  std::ranges::uninitialized_copy_n(from.begin(), N, buf.begin(), buf.end());
+  auto buf_iter = buf.begin();
+  // Note: `std::equal` doesn't work with volatile types.
+  for (auto& e : from) {
+    assert(e == *buf_iter);
+    ++buf_iter;
+  }
+}
+
 int main(int, char**) {
   // An empty range -- no default constructors should be invoked.
   {
     Counted in[] = {Counted()};
     Buffer<Counted, 1> out;
     Counted::reset();
 
     auto result = std::ranges::uninitialized_copy_n(in, 0, out.begin(), out.end());
// Destination range is shorter than the source range.
     assert(Counted::total_copies == M);
     assert(Counted::total_moves == 0);
 
     assert(std::equal(in, in + M, out.begin(), out.end()));
     assert(result.in == in + M);
     assert(result.out == out.end());
   }
 
+  // Works with trivial types.
+  {
+    test_trivial<char, char>({'a', 'b', 'c'});
+    test_trivial<char, unsigned char>({'a', 'b', 'c'});
+#if TEST_STD_VER > 14
+    test_trivial<std::byte, std::byte>({std::byte(1), std::byte(2), std::byte(3)});
+#endif
+
+    test_trivial<int, int>({1, 2, 3});
+    test_trivial<char, int>({'a', 'b', 'c'});
+    test_trivial<int, char>({1, 2, 3});
+
+    test_trivial<long long, int>({1, 2, 3});
+    test_trivial<int, long long>({1, 2, 3});
+
+    test_trivial<unsigned long, int>({1, 2, 3});
+    test_trivial<int, unsigned long>({1, 2, 3});
+
+    test_trivial<float, double>({1.5, 2.5, 3.5});
+    test_trivial<double, float>({1.5, 2.5, 3.5});
+
+    {
+      struct Trivial {
+        int a;
+        float b;
+        bool operator==(const Trivial& rhs) const { return a == rhs.a && b == rhs.b; }
+      };
+      static_assert(std::is_trivial<Trivial>::value);
+      test_trivial<Trivial, Trivial>({Trivial{1, 1}, Trivial{2, 2}, Trivial{3, 3}});
+    }
+
+    {
+      struct Empty {
+        bool operator==(const Empty&) const { return true; }
+      };
+      test_trivial<Empty, Empty>({Empty(), Empty(), Empty()});
+    }
+
+    // Conversion between user-defined trivial types.
+    {
+      struct TrivialFrom { char a; };
+      struct TrivialTo {
+        unsigned char a;
+        TrivialTo() = default;
+        TrivialTo(TrivialFrom from) : a(from.a) {}
+        bool operator==(TrivialFrom rhs) const { return a == rhs.a; }
+      };
+      static_assert(std::is_trivial<TrivialFrom>::value);
+      static_assert(std::is_trivial<TrivialTo>::value);
+
+      using From = TrivialFrom;
+      test_trivial<TrivialFrom, TrivialTo>({From{'a'}, From{'b'}, From{'c'}});
+    }
+  }
+
+  // Works on non-contiguous ranges.
+  {
+    const int N = 5;
+    NonContiguousBuffer<int, N> buf;
+
+    int from[N] = {1, 2, 3, 4, 5};
+    std::ranges::uninitialized_copy_n(from, N, buf.begin(), buf.end());
+    assert(std::equal(from, from + N, buf.begin()));
+    buf.validate();
+
+    // TODO(varconst): also test non-contiguous input range.
+  }
+
+  // Trivial types work with non-random-access iterators.
+  {
+    const int N = 5;
+    Buffer<int, N> buf;
+
+    int from[N] = {1, 2, 3, 4, 5};
+    forward_iterator<int*> from_begin(from);
+    forward_iterator<int*> to_begin(buf.begin()), to_end(buf.end());
+    std::ranges::uninitialized_copy_n(from_begin, N, to_begin, to_end);
+    assert(std::equal(from, from + N, buf.begin()));
+  }
+
+  // Works with const outputs.
+  {
+    test_trivial<char, const char>({'a', 'b', 'c'});
+    test_trivial<int, const int>({1, 2, 3});
+  }
+
+  // Works with volatile inputs and outputs.
+  {
+    test_trivial<volatile char, char>({'a', 'b', 'c'});
+    test_trivial<volatile int, int>({1, 2, 3});
+
+    test_trivial<char, volatile char>({'a', 'b', 'c'});
+    test_trivial<int, volatile int>({1, 2, 3});
+  }
+
+  // Works when only one of the ranges uses random-access iterators.
+  {
+    // (ptr, N) | (fwd_iter, fwd_iter)
+    {
+      int from[5] = {1, 2, 3, 4, 5};
+      Buffer<int, 3> buf;
+
+      forward_iterator<int*> to_begin(buf.begin()), to_end(buf.end());
+      std::ranges::uninitialized_copy_n(from, 5, to_begin, to_end);
+      assert(std::equal(from, from + 3, buf.begin()));
+    }
+
+    // (ptr, N) | (ptr, unreachable)
+    {
+      int from[3] = {1, 2, 3};
+      Buffer<int, 5> buf;
+
+      std::ranges::uninitialized_copy_n(from, 3, buf.begin(), std::unreachable_sentinel);
+      assert(std::equal(from, from + 3, buf.begin()));
+    }
+  }
+
   return 0;
 }

libcxx/test/std/utilities/memory/specialized.algorithms/uninitialized.copy/uninitialized_copy.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
+// ADDITIONAL_COMPILE_FLAGS: -Wno-deprecated-volatile -Wno-sign-compare
+
 // <memory>
 
 // template <class InputIterator, class ForwardIterator>
 //   ForwardIterator
 //   uninitialized_copy(InputIterator first, InputIterator last,
 //                      ForwardIterator result);
 
 #include <memory>
+#include <algorithm>
 #include <cassert>
+#include <initializer_list>
+#include <type_traits>
 
+#include "../buffer.h"
 #include "test_macros.h"
 
 struct B
 {
     static int count_;
     static int population_;
     int data_;
     explicit B() : data_(1) { ++population_; }
struct Nasty
     Nasty() : i_ ( counter_++ ) {}
     Nasty * operator &() const { return NULL; }
     int i_;
     static int counter_;
 };
 
 int Nasty::counter_ = 0;
 
+// Note: initializer_list is not supported in C++03.
+template <class From, class To>
+void test_trivial(From v1, From v2, From v3) {
+  constexpr int N = 3;
+  From from[] = {v1, v2, v3};
+  Buffer<To, N> buf;
+
+  std::uninitialized_copy(from, from + N, buf.begin());
+  auto buf_iter = buf.begin();
+  // Note: `std::equal` doesn't work with volatile types.
+  for (auto& e : from) {
+    assert(*buf_iter == e);
+    ++buf_iter;
+  }
+}
+
 int main(int, char**)
 {
     {
     const int N = 5;
     char pool[sizeof(B)*N] = {0};
     B* bp = (B*)pool;
     B b[N];
     assert(B::population_ == N);
#endif
     Nasty arr[N];
     std::uninitialized_copy(arr, arr+N, p);
     for (int i = 0; i < N; ++i) {
         assert(arr[i].i_ == i);
         assert(  p[i].i_ == i);
         }
     }
 
+    // Works with trivial types.
+    {
+      test_trivial<char, char>('a', 'b', 'c');
+      test_trivial<char, unsigned char>('a', 'b', 'c');
+#if TEST_STD_VER > 14
+      test_trivial<std::byte, std::byte>(std::byte(1), std::byte(2), std::byte(3));
+#endif
+
+      test_trivial<int, int>(1, 2, 3);
+      test_trivial<char, int>('a', 'b', 'c');
+      test_trivial<int, char>(1, 2, 3);
+
+      test_trivial<long long, int>(1, 2, 3);
+      test_trivial<int, long long>(1, 2, 3);
+
+      test_trivial<unsigned long, int>(1, 2, 3);
+      test_trivial<int, unsigned long>(1, 2, 3);
+
+      test_trivial<float, double>(1.5, 2.5, 3.5);
+      test_trivial<double, float>(1.5, 2.5, 3.5);
+
+      {
+        struct Trivial {
+          int a;
+          float b;
+          bool operator==(const Trivial& rhs) const { return a == rhs.a && b == rhs.b; }
+        };
+        static_assert(std::is_trivial<Trivial>::value, "");
+        test_trivial<Trivial, Trivial>(Trivial{1, 1}, Trivial{2, 2}, Trivial{3, 3});
+      }
+
+      {
+        struct Empty {
+          bool operator==(const Empty&) const { return true; }
+        };
+        test_trivial<Empty, Empty>(Empty(), Empty(), Empty());
+      }
+
+      // Conversion between user-defined trivial types.
+      {
+        struct TrivialFrom { char a; };
+        struct TrivialTo {
+          unsigned char a;
+          TrivialTo() = default;
+          TrivialTo(TrivialFrom from) : a(from.a) {}
+          bool operator==(TrivialFrom rhs) const { return a == rhs.a; }
+        };
+        static_assert(std::is_trivial<TrivialFrom>::value, "");
+        static_assert(std::is_trivial<TrivialTo>::value, "");
+
+        using From = TrivialFrom;
+        test_trivial<TrivialFrom, TrivialTo>(From{'a'}, From{'b'}, From{'c'});
+      }
+    }
+
+    // Works on non-contiguous ranges.
+    {
+      const int N = 5;
+      NonContiguousBuffer<int, N> buf;
+
+      int from[N] = {1, 2, 3, 4, 5};
+      std::uninitialized_copy(from, from + N, buf.begin());
+      assert(std::equal(from, from + N, buf.begin()));
+      buf.validate();
+
+      // TODO(varconst): also test non-contiguous input range.
+    }
+
+    // Trivial types work with non-random-access iterators.
+    {
+      const int N = 5;
+      Buffer<int, N> buf;
+
+      int from[N] = {1, 2, 3, 4, 5};
+      forward_iterator<int*> from_begin(from), from_end(from + N);
+      forward_iterator<int*> to_begin(buf.begin());
+      std::uninitialized_copy(from_begin, from_end, to_begin);
+      assert(std::equal(from, from + N, buf.begin()));
+    }
+
+    // Works with const outputs.
+    {
+      test_trivial<char, const char>('a', 'b', 'c');
+      test_trivial<int, const int>(1, 2, 3);
+    }
+
+    // Works with volatile inputs and outputs.
+    {
+      test_trivial<volatile char, char>('a', 'b', 'c');
+      test_trivial<volatile int, int>(1, 2, 3);
+
+      test_trivial<char, volatile char>('a', 'b', 'c');
+      test_trivial<int, volatile int>(1, 2, 3);
+    }
 
     return 0;
 }

libcxx/test/std/utilities/memory/specialized.algorithms/uninitialized.copy/uninitialized_copy_n.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
+// ADDITIONAL_COMPILE_FLAGS: -Wno-deprecated-volatile -Wno-sign-compare
+
 // <memory>
 
 // template <class InputIterator, class Size, class ForwardIterator>
 //   ForwardIterator
 //   uninitialized_copy_n(InputIterator first, Size n,
 //                        ForwardIterator result);
 
 #include <memory>
+#include <algorithm>
 #include <cassert>
 
+#include "../buffer.h"
 #include "test_macros.h"
 
 struct B
 {
     static int count_;
     static int population_;
     int data_;
     explicit B() : data_(1) { ++population_; }
struct Nasty
     Nasty() : i_ ( counter_++ ) {}
     Nasty * operator &() const { return NULL; }
     int i_;
     static int counter_;
 };
 
 int Nasty::counter_ = 0;
 
+// Note: initializer_list is not supported in C++03.
+template <class From, class To>
+void test_trivial(From v1, From v2, From v3) {
+  constexpr int N = 3;
+  From from[] = {v1, v2, v3};
+  Buffer<To, N> buf;
+
+  std::uninitialized_copy_n(from, N, buf.begin());
+  auto buf_iter = buf.begin();
+  // Note: `std::equal` doesn't work with volatile types.
+  for (auto& e : from) {
+    assert(*buf_iter == e);
+    ++buf_iter;
+  }
+}
+
 int main(int, char**)
 {
     {
     const int N = 5;
     char pool[sizeof(B)*N] = {0};
     B* bp = (B*)pool;
     B b[N];
     assert(B::population_ == N);
#endif
     Nasty arr[N];
     std::uninitialized_copy_n(arr, N, p);
     for (int i = 0; i < N; ++i) {
         assert(arr[i].i_ == i);
         assert(  p[i].i_ == i);
     }
     }
 
+    // Works with trivial types.
+    {
+      test_trivial<char, char>('a', 'b', 'c');
+      test_trivial<char, unsigned char>('a', 'b', 'c');
+#if TEST_STD_VER > 14
+      test_trivial<std::byte, std::byte>(std::byte(1), std::byte(2), std::byte(3));
+#endif
+
+      test_trivial<int, int>(1, 2, 3);
+      test_trivial<char, int>('a', 'b', 'c');
+      test_trivial<int, char>(1, 2, 3);
+
+      test_trivial<long long, int>(1, 2, 3);
+      test_trivial<int, long long>(1, 2, 3);
+
+      test_trivial<unsigned long, int>(1, 2, 3);
+      test_trivial<int, unsigned long>(1, 2, 3);
+
+      test_trivial<float, double>(1.5, 2.5, 3.5);
+      test_trivial<double, float>(1.5, 2.5, 3.5);
+
+      {
+        struct Trivial {
+          int a;
+          float b;
+          bool operator==(const Trivial& rhs) const { return a == rhs.a && b == rhs.b; }
+        };
+        static_assert(std::is_trivial<Trivial>::value, "");
+        test_trivial<Trivial, Trivial>(Trivial{1, 1}, Trivial{2, 2}, Trivial{3, 3});
+      }
+
+      {
+        struct Empty {
+          bool operator==(const Empty&) const { return true; }
+        };
+        test_trivial<Empty, Empty>(Empty(), Empty(), Empty());
+      }
+
+      // Conversion between user-defined trivial types.
+      {
+        struct TrivialFrom { char a; };
+        struct TrivialTo {
+          unsigned char a;
+          TrivialTo() = default;
+          TrivialTo(TrivialFrom from) : a(from.a) {}
+          bool operator==(TrivialFrom rhs) const { return a == rhs.a; }
+        };
+        static_assert(std::is_trivial<TrivialFrom>::value, "");
+        static_assert(std::is_trivial<TrivialTo>::value, "");
+
+        using From = TrivialFrom;
+        test_trivial<TrivialFrom, TrivialTo>(From{'a'}, From{'b'}, From{'c'});
+      }
+    }
+
+    // Works on non-contiguous ranges.
+    {
+      const int N = 5;
+      NonContiguousBuffer<int, N> buf;
+
+      int from[N] = {1, 2, 3, 4, 5};
+      std::uninitialized_copy_n(from, N, buf.begin());
+      assert(std::equal(from, from + N, buf.begin()));
+      buf.validate();
+
+      // TODO(varconst): also test non-contiguous input range.
+    }
+
+    // Trivial types work with non-random-access iterators.
+    {
+      const int N = 5;
+      Buffer<int, N> buf;
+
+      int from[N] = {1, 2, 3, 4, 5};
+      forward_iterator<int*> from_begin(from);
+      forward_iterator<int*> to_begin(buf.begin());
+      std::uninitialized_copy_n(from_begin, N, to_begin);
+      assert(std::equal(from, from + N, buf.begin()));
+    }
+
+    // Works with const outputs.
+    {
+      test_trivial<char, const char>('a', 'b', 'c');
+      test_trivial<int, const int>(1, 2, 3);
+    }
+
+    // Works with volatile inputs and outputs.
+    {
+      test_trivial<volatile char, char>('a', 'b', 'c');
+      test_trivial<volatile int, int>(1, 2, 3);
+
+      test_trivial<char, volatile char>('a', 'b', 'c');
+      test_trivial<int, volatile int>(1, 2, 3);
+    }
+
     return 0;
 }

libcxx/test/std/utilities/memory/specialized.algorithms/uninitialized.fill.n/ranges_uninitialized_fill_n.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
+// ADDITIONAL_COMPILE_FLAGS: -Wno-deprecated-volatile -Wno-sign-compare
+
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 // UNSUPPORTED: libcpp-no-concepts, libcpp-has-no-incomplete-ranges
 
 // <memory>
 
 // template <nothrow-forward-iterator ForwardIterator, class T>
 //   requires constructible_from<iter_value_t<ForwardIterator>, const T&>
 // ForwardIterator ranges::uninitialized_fill_n(ForwardIterator first, iter_difference_t<ForwardIterator> n);

 // Because this is a variable and not a function, it's guaranteed that ADL won't be used. However,
 // implementations are allowed to use a different mechanism to achieve this effect, so this check is
 // libc++-specific.
 LIBCPP_STATIC_ASSERT(std::is_class_v<decltype(std::ranges::uninitialized_fill_n)>);
 
 struct NotConvertibleFromInt {};
 static_assert(!std::is_invocable_v<decltype(std::ranges::uninitialized_fill_n), NotConvertibleFromInt*, size_t, int>);
 
+template <class From, class To>
+void test_trivial(From x) {
+  Buffer<To, 5> buf;
+  std::ranges::uninitialized_fill_n(buf.begin(), buf.size(), x);
+  assert(std::all_of(buf.begin(), buf.end(), [=](auto e) { return e == x; }));
+}
+
 int main(int, char**) {
   constexpr int value = 42;
   Counted x(value);
   Counted::reset();
   auto pred = [](const Counted& e) { return e.value == value; };
 
   // An empty range -- no default constructors should be invoked.
   {
// Works with const iterators.
     assert(Counted::current_objects == N);
     assert(Counted::total_objects == N);
     assert(std::all_of(buf.begin(), buf.end(), pred));
 
     std::destroy(buf.begin(), buf.end());
     Counted::reset();
   }
 
+  // Works with trivial types, .
+  {
+    test_trivial<char, char>('a');
+    test_trivial<char, unsigned char>('a');
+    test_trivial<std::byte, std::byte>(std::byte(4));
+
+    test_trivial<int, int>(4);
+    test_trivial<char, int>('a');
+    test_trivial<int, char>(4);
+
+    test_trivial<long long, int>(4);
+    test_trivial<int, long long>(4);
+
+    test_trivial<unsigned long, int>(4);
+    test_trivial<int, unsigned long>(4);
+
+    test_trivial<float, double>(1.5);
+    test_trivial<double, float>(1.5);
+
+    {
+      struct Trivial {
+        int a;
+        float b;
+        bool operator==(const Trivial& rhs) const { return a == rhs.a && b == rhs.b; }
+      };
+      static_assert(std::is_trivial<Trivial>::value);
+
+      Trivial foo = {3, 4.f};
+      test_trivial<Trivial, Trivial>(foo);
+    }
+
+    {
+      struct SmallTrivial {
+        char a;
+        bool operator==(const SmallTrivial& rhs) const { return a == rhs.a; }
+      };
+      static_assert(std::is_trivial<SmallTrivial>::value);
+
+      SmallTrivial foo = {'a'};
+      test_trivial<SmallTrivial, SmallTrivial>(foo);
+    }
+
+    {
+      struct Empty {
+        bool operator==(const Empty&) const { return true; }
+      };
+      Empty foo;
+      test_trivial<Empty, Empty>(foo);
+    }
+
+    // Conversion between user-defined trivial types.
+    {
+      struct SmallTrivialFrom { char a; };
+      struct SmallTrivialTo {
+        unsigned char a;
+        SmallTrivialTo() = default;
+        SmallTrivialTo(SmallTrivialFrom from) : a(from.a) {}
+        bool operator==(SmallTrivialFrom rhs) const { return a == rhs.a; }
+      };
+      static_assert(std::is_trivial<SmallTrivialFrom>::value);
+      static_assert(std::is_trivial<SmallTrivialTo>::value);
+
+      SmallTrivialFrom foo = {'a'};
+      test_trivial<SmallTrivialFrom, SmallTrivialTo>(foo);
+    }
+  }
+
+  // Works on non-contiguous ranges.
+  {
+    NonContiguousBuffer<char, 5> buf;
+
+    std::ranges::uninitialized_fill_n(buf.begin(), buf.size(), 'a');
+    assert(std::all_of(buf.begin(), buf.end(), [=](auto e) { return e == 'a'; }));
+    buf.validate();
+  }
+
+  // Works with const outputs.
+  {
+    test_trivial<int, const int>(42);
+  }
+
+  // Works with volatile inputs and outputs.
+  {
+    // Volatile input.
+    test_trivial<volatile char, char>('a');
+    test_trivial<volatile int, int>(42);
+
+    // Volatile output.
+    test_trivial<char, volatile char>('a');
+    test_trivial<int, volatile int>(42);
+  }
+
   return 0;
 }

libcxx/test/std/utilities/memory/specialized.algorithms/uninitialized.fill.n/uninitialized_fill_n.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
+// ADDITIONAL_COMPILE_FLAGS: -Wno-deprecated-volatile -Wno-sign-compare
+
 // <memory>
 
 // template <class ForwardIterator, class Size, class T>
 //   ForwardIterator
 //   uninitialized_fill_n(ForwardIterator first, Size n, const T& x);
 
 #include <memory>
+#include <algorithm>
 #include <cassert>
+#include <type_traits>
 
+#include "../buffer.h"
 #include "test_macros.h"
 
 struct B
 {
     static int count_;
     static int population_;
     int data_;
     explicit B() : data_(1) { ++population_; }
struct Nasty
     Nasty() : i_ ( counter_++ ) {}
     Nasty * operator &() const { return NULL; }
     int i_;
     static int counter_;
 };
 
 int Nasty::counter_ = 0;
 
+template <class From, class To>
+void test_trivial(From x) {
+  Buffer<To, 5> buf;
+
+  std::uninitialized_fill_n(buf.begin(), buf.size(), x);
+  assert(std::all_of(buf.begin(), buf.end(), [=](To e) { return e == x; }));
+}
+
 int main(int, char**)
 {
     {
     const int N = 5;
     char pool[sizeof(B)*N] = {0};
     B* bp = (B*)pool;
     assert(B::population_ == 0);
+
 #ifndef TEST_HAS_NO_EXCEPTIONS
     try
     {
         std::uninitialized_fill_n(bp, 5, B());
         assert(false);
     }
     catch (...)
     {
         assert(B::population_ == 0);
     }
 #endif
+
     B::count_ = 0;
     B* r = std::uninitialized_fill_n(bp, 2, B());
     assert(r == bp + 2);
     for (int i = 0; i < 2; ++i)
         assert(bp[i].data_ == 1);
     assert(B::population_ == 2);
     }
-    {
+
     {
     const int N = 5;
     char pool[N*sizeof(Nasty)] = {0};
     Nasty* bp = (Nasty*)pool;
 
     Nasty::counter_ = 23;
     std::uninitialized_fill_n(bp, N, Nasty());
     for (int i = 0; i < N; ++i)
         assert(bp[i].i_ == 23);
     }
 
+    // Works with trivial types.
+    {
+      test_trivial<char, char>('a');
+      test_trivial<char, unsigned char>('a');
+#if TEST_STD_VER > 14
+      test_trivial<std::byte, std::byte>(std::byte(4));
+#endif
+
+      test_trivial<int, int>(4);
+      test_trivial<char, int>('a');
+      test_trivial<int, char>(4);
+
+      test_trivial<long long, int>(4);
+      test_trivial<int, long long>(4);
+
+      test_trivial<unsigned long, int>(4);
+      test_trivial<int, unsigned long>(4);
+
+      test_trivial<float, double>(1.5);
+      test_trivial<double, float>(1.5);
+
+      {
+        struct Trivial {
+          int a;
+          float b;
+          bool operator==(const Trivial& rhs) const { return a == rhs.a && b == rhs.b; }
+        };
+        static_assert(std::is_trivial<Trivial>::value, "");
+
+        Trivial foo = {3, 4.f};
+        test_trivial<Trivial, Trivial>(foo);
+      }
+
+      {
+        struct SmallTrivial {
+          char a;
+          bool operator==(const SmallTrivial& rhs) const { return a == rhs.a; }
+        };
+        static_assert(std::is_trivial<SmallTrivial>::value, "");
+
+        SmallTrivial foo = {'a'};
+        test_trivial<SmallTrivial, SmallTrivial>(foo);
+      }
+
+      {
+        struct Empty {
+          bool operator==(const Empty&) const { return true; }
+        };
+        Empty foo;
+        test_trivial<Empty, Empty>(foo);
+      }
+
+      // Conversion between user-defined trivial types.
+      {
+        struct SmallTrivialFrom {
+          char a;
+        };
+        struct SmallTrivialTo {
+          unsigned char a;
+          SmallTrivialTo() = default;
+          SmallTrivialTo(SmallTrivialFrom from) : a(from.a) {}
+          bool operator==(SmallTrivialFrom rhs) const { return a == rhs.a; }
+        };
+        static_assert(std::is_trivial<SmallTrivialFrom>::value, "");
+        static_assert(std::is_trivial<SmallTrivialTo>::value, "");
+
+        SmallTrivialFrom foo = {'a'};
+        test_trivial<SmallTrivialFrom, SmallTrivialTo>(foo);
+      }
+    }
+
+    // Works on non-contiguous ranges.
+    {
+      NonContiguousBuffer<char, 5> buf;
+
+      std::uninitialized_fill_n(buf.begin(), buf.size(), 'a');
+      assert(std::all_of(buf.begin(), buf.end(), [=](char e) { return e == 'a'; }));
+      buf.validate();
+    }
+
+    // Works with const outputs.
+    { test_trivial<int, const int>(42); }
+
+    // Works with volatile inputs and outputs.
+    {
+      // Volatile input.
+      test_trivial<volatile char, char>('a');
+      test_trivial<volatile int, int>(42);
+
+      // Volatile output.
+      test_trivial<char, volatile char>('a');
+      test_trivial<int, volatile int>(42);
     }
 
     return 0;
 }

libcxx/test/std/utilities/memory/specialized.algorithms/uninitialized.fill/ranges_uninitialized_fill.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
+// ADDITIONAL_COMPILE_FLAGS: -Wno-deprecated-volatile -Wno-sign-compare
+
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 // UNSUPPORTED: libcpp-no-concepts, libcpp-has-no-incomplete-ranges
 
 // <memory>
 
 // template <nothrow-forward-iterator ForwardIterator, nothrow-sentinel-for<ForwardIterator> Sentinel, class T>
 //   requires constructible_from<iter_value_t<ForwardIterator>, const T&>
 // ForwardIterator ranges::uninitialized_fill(ForwardIterator first, Sentinel last, const T& x);

 // implementations are allowed to use a different mechanism to achieve this effect, so this check is
 // libc++-specific.
 LIBCPP_STATIC_ASSERT(std::is_class_v<decltype(std::ranges::uninitialized_fill)>);
 
 struct NotConvertibleFromInt {};
 static_assert(!std::is_invocable_v<decltype(std::ranges::uninitialized_fill), NotConvertibleFromInt*,
                                    NotConvertibleFromInt*, int>);
 
+template <class From, class To>
+void test_trivial(From x) {
+  constexpr int N = 5;
+
+  {
+    Buffer<To, N> buf;
+    std::ranges::uninitialized_fill(buf.begin(), buf.end(), x);
+    assert(std::all_of(buf.begin(), buf.end(), [=](auto e) { return e == x; }));
+  }
+
+  {
+    Buffer<To, N> buf;
+    std::ranges::subrange range(buf.begin(), buf.end());
+    std::ranges::uninitialized_fill(range, x);
+    assert(std::all_of(buf.begin(), buf.end(), [=](auto e) { return e == x; }));
+  }
+}
+
 int main(int, char**) {
   constexpr int value = 42;
   Counted x(value);
   Counted::reset();
   auto pred = [](const Counted& e) { return e.value == value; };
 
   // An empty range -- no default constructors should be invoked.
   {
// Works with const iterators, (range) overload.
     assert(Counted::current_objects == N);
     assert(Counted::total_objects == N);
     assert(std::all_of(buf.begin(), buf.end(), pred));
 
     std::destroy(buf.begin(), buf.end());
     Counted::reset();
   }
 
+  // Works with trivial types.
+  {
+    test_trivial<char, char>('a');
+    test_trivial<char, unsigned char>('a');
+    test_trivial<std::byte, std::byte>(std::byte(4));
+
+    test_trivial<int, int>(4);
+    test_trivial<char, int>('a');
+    test_trivial<int, char>(4);
+
+    test_trivial<long long, int>(4);
+    test_trivial<int, long long>(4);
+
+    test_trivial<unsigned long, int>(4);
+    test_trivial<int, unsigned long>(4);
+
+    test_trivial<float, double>(1.5);
+    test_trivial<double, float>(1.5);
+
+    {
+      struct Trivial {
+        int a;
+        float b;
+        bool operator==(const Trivial& rhs) const { return a == rhs.a && b == rhs.b; }
+      };
+      static_assert(std::is_trivial<Trivial>::value);
+
+      Trivial foo = {3, 4.f};
+      test_trivial<Trivial, Trivial>(foo);
+    }
+
+    {
+      struct SmallTrivial {
+        char a;
+        bool operator==(const SmallTrivial& rhs) const { return a == rhs.a; }
+      };
+      static_assert(std::is_trivial<SmallTrivial>::value);
+
+      SmallTrivial foo = {'a'};
+      test_trivial<SmallTrivial, SmallTrivial>(foo);
+    }
+
+    {
+      struct Empty {
+        bool operator==(const Empty&) const { return true; }
+      };
+      Empty foo;
+      test_trivial<Empty, Empty>(foo);
+    }
+
+    // Conversion between user-defined trivial types.
+    {
+      struct SmallTrivialFrom { char a; };
+      struct SmallTrivialTo {
+        unsigned char a;
+        SmallTrivialTo() = default;
+        SmallTrivialTo(SmallTrivialFrom from) : a(from.a) {}
+        bool operator==(SmallTrivialFrom rhs) const { return a == rhs.a; }
+      };
+      static_assert(std::is_trivial<SmallTrivialFrom>::value);
+      static_assert(std::is_trivial<SmallTrivialTo>::value);
+
+      SmallTrivialFrom foo = {'a'};
+      test_trivial<SmallTrivialFrom, SmallTrivialTo>(foo);
+    }
+  }
+
+  // Works on non-contiguous ranges, (iter, sentinel) overload.
+  {
+    NonContiguousBuffer<char, 5> buf;
+
+    std::ranges::uninitialized_fill(buf.begin(), buf.end(), 'a');
+    assert(std::all_of(buf.begin(), buf.end(), [=](auto e) { return e == 'a'; }));
+    buf.validate();
+  }
+
+  // Works on non-contiguous ranges, (range) overload.
+  {
+    NonContiguousBuffer<char, 5> buf;
+    std::ranges::subrange range(buf);
+
+    std::ranges::uninitialized_fill(range, 'a');
+    assert(std::all_of(buf.begin(), buf.end(), [=](auto e) { return e == 'a'; }));
+    buf.validate();
+  }
+
+  // Works with const outputs.
+  {
+    test_trivial<int, const int>(42);
+  }
+
+  // Works with volatile inputs and outputs.
+  {
+    test_trivial<volatile char, char>('a');
+    // Volatile input.
+    test_trivial<volatile int, int>(42);
+
+    // Volatile output.
+    test_trivial<char, volatile char>('a');
+    test_trivial<int, volatile int>(42);
+  }
+
   return 0;
 }

libcxx/test/std/utilities/memory/specialized.algorithms/uninitialized.fill/uninitialized_fill.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
+// ADDITIONAL_COMPILE_FLAGS: -Wno-deprecated-volatile -Wno-sign-compare
+
 // <memory>
 
 // template <class ForwardIterator, class T>
 //   void
 //   uninitialized_fill(ForwardIterator first, ForwardIterator last,
 //                      const T& x);
 
 #include <memory>
+#include <algorithm>
 #include <cassert>
+#include <type_traits>
 
+#include "../buffer.h"
 #include "test_macros.h"
 
 struct B
 {
     static int count_;
     static int population_;
     int data_;
     explicit B() : data_(1) { ++population_; }
struct Nasty
     Nasty() : i_ ( counter_++ ) {}
     Nasty * operator &() const { return NULL; }
     int i_;
     static int counter_;
 };
 
 int Nasty::counter_ = 0;
 
+template <class From, class To>
+void test_trivial(From x) {
+  Buffer<To, 5> buf;
+
+  std::uninitialized_fill(buf.begin(), buf.end(), x);
+  assert(std::all_of(buf.begin(), buf.end(), [=](To e) { return e == x; }));
+}
+
 int main(int, char**)
 {
     {
     const int N = 5;
     char pool[sizeof(B)*N] = {0};
     B* bp = (B*)pool;
     assert(B::population_ == 0);
+
 #ifndef TEST_HAS_NO_EXCEPTIONS
     try
     {
         std::uninitialized_fill(bp, bp+N, B());
         assert(false);
     }
     catch (...)
     {
         assert(B::population_ == 0);
     }
 #endif
+
     B::count_ = 0;
     std::uninitialized_fill(bp, bp+2, B());
     for (int i = 0; i < 2; ++i)
         assert(bp[i].data_ == 1);
     assert(B::population_ == 2);
     }
+
     {
     const int N = 5;
     char pool[N*sizeof(Nasty)] = {0};
     Nasty* bp = (Nasty*)pool;
 
     Nasty::counter_ = 23;
     std::uninitialized_fill(bp, bp+N, Nasty());
     for (int i = 0; i < N; ++i)
         assert(bp[i].i_ == 23);
     }
 
+    // Works with trivial types.
+    {
+      test_trivial<char, char>('a');
+      test_trivial<char, unsigned char>('a');
+#if TEST_STD_VER > 14
+      test_trivial<std::byte, std::byte>(std::byte(4));
+#endif
+
+      test_trivial<int, int>(4);
+      test_trivial<char, int>('a');
+      test_trivial<int, char>(4);
+
+      test_trivial<long long, int>(4);
+      test_trivial<int, long long>(4);
+
+      test_trivial<unsigned long, int>(4);
+      test_trivial<int, unsigned long>(4);
+
+      test_trivial<float, double>(1.5);
+      test_trivial<double, float>(1.5);
+
+      {
+        struct Trivial {
+          int a;
+          float b;
+          bool operator==(const Trivial& rhs) const { return a == rhs.a && b == rhs.b; }
+        };
+        static_assert(std::is_trivial<Trivial>::value, "");
+
+        Trivial foo = {3, 4.f};
+        test_trivial<Trivial, Trivial>(foo);
+      }
+
+      {
+        struct SmallTrivial {
+          char a;
+          bool operator==(const SmallTrivial& rhs) const { return a == rhs.a; }
+        };
+        static_assert(std::is_trivial<SmallTrivial>::value, "");
+
+        SmallTrivial x = {'a'};
+        test_trivial<SmallTrivial, SmallTrivial>(x);
+      }
+
+      {
+        struct Empty {
+          bool operator==(const Empty&) const { return true; }
+        };
+        Empty foo;
+        test_trivial<Empty, Empty>(foo);
+      }
+
+      // Conversion between user-defined trivial types.
+      {
+        struct SmallTrivialFrom {
+          char a;
+        };
+        struct SmallTrivialTo {
+          unsigned char a;
+          SmallTrivialTo() = default;
+          SmallTrivialTo(SmallTrivialFrom from) : a(from.a) {}
+          bool operator==(SmallTrivialFrom rhs) const { return a == rhs.a; }
+        };
+        static_assert(std::is_trivial<SmallTrivialFrom>::value, "");
+        static_assert(std::is_trivial<SmallTrivialTo>::value, "");
+
+        SmallTrivialFrom foo = {'a'};
+        test_trivial<SmallTrivialFrom, SmallTrivialTo>(foo);
+      }
+    }
+
+    // Works on non-contiguous ranges.
+    {
+      NonContiguousBuffer<char, 5> buf;
+
+      std::uninitialized_fill(buf.begin(), buf.end(), 'a');
+      assert(std::all_of(buf.begin(), buf.end(), [=](char e) { return e == 'a'; }));
+      buf.validate();
+    }
+
+    // Works with const outputs.
+    {
+      test_trivial<char, const char>('a');
+      test_trivial<int, const int>(42);
+    }
+
+    // Works with volatile inputs and outputs.
+    {
+      // Volatile input.
+      test_trivial<volatile char, char>('a');
+      test_trivial<volatile int, int>(42);
+
+      // Volatile output.
+      test_trivial<char, volatile char>('a');
+      test_trivial<int, volatile int>(42);
+    }
+
     return 0;
 }

libcxx/test/std/utilities/memory/specialized.algorithms/uninitialized.move/ranges_uninitialized_move.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 // UNSUPPORTED: libcpp-no-concepts, libcpp-has-no-incomplete-ranges
 
+// ADDITIONAL_COMPILE_FLAGS: -Wno-deprecated-volatile -Wno-sign-compare
+
 // <memory>
 //
-// template<input_iterator InputIterator, nothrow-forward-iterator OutputIterator, nothrow-sentinel-for<OutputIterator> Sentinel>
-// requires constructible_from<iter_value_t<OutputIterator>, iter_rvalue_reference_t<InputIterator>>
-// ranges::uninitialized_move_n_result<InputIterator, OutputIterator>
-// ranges::uninitialized_move_n(InputIterator ifirst, iter_difference_t<InputIterator> n, OutputIterator ofirst, Sentinel olast); // since C++20
-
+// template<input_iterator I, sentinel-for<I> S1, nothrow-forward-iterator O, nothrow-sentinel-for<O> S2>
+//   requires constructible_from<iter_value_t<O>, iter_rvalue_reference_t<I>>
+// uninitialized_move_result<I, O> ranges::uninitialized_move(I ifirst, S1 ilast, O ofirst, S2 olast); // since C++20
+//
+// template<input_range IR, nothrow-forward-range OR>
+//   requires constructible_from<range_value_t<OR>, range_rvalue_reference_t<IR>>
+// uninitialized_move_result<borrowed_iterator_t<IR>, borrowed_iterator_t<OR>> ranges::uninitialized_move(IR&& in_range, OR&& out_range); // since C++20
 
 #include <algorithm>
 #include <cassert>
+#include <initializer_list>
 #include <iterator>
 #include <memory>
 #include <ranges>
 #include <type_traits>
 #include <utility>
 
 #include "../buffer.h"
 #include "../counted.h"
friend T&& iter_move(Iterator iter) {
     return std::move(*iter);
   }
 
   friend bool operator==(const Iterator& lhs, const Iterator& rhs) { return lhs.ptr == rhs.ptr; }
 };
 
 } // namespace adl
 
+template <class From, class To>
+void test_trivial(std::initializer_list<From> from) {
+  constexpr int N = 3;
+  Buffer<To, N> buf;
+
+  std::ranges::uninitialized_move(from.begin(), from.end(), buf.begin(), buf.end());
+  auto buf_iter = buf.begin();
+  // Note: `std::equal` doesn't work with volatile types.
+  for (auto& e : from) {
+    assert(e == *buf_iter);
+    ++buf_iter;
+  }
+}
+
 int main(int, char**) {
   // An empty range -- no default constructors should be invoked.
   {
     Counted in[] = {Counted()};
     Buffer<Counted, 1> out;
     Counted::reset();
 
     {
// Ensure the `iter_move` customization point is being used.
     adl::iter_move_invocations = 0;
 
     std::ranges::subrange range(begin, end);
     std::ranges::uninitialized_move(range, out);
     assert(adl::iter_move_invocations == 3);
     adl::iter_move_invocations = 0;
   }
 
+  // Works with trivial types.
+  {
+    test_trivial<char, char>({'a', 'b', 'c'});
+    test_trivial<char, unsigned char>({'a', 'b', 'c'});
+    test_trivial<std::byte, std::byte>({std::byte(1), std::byte(2), std::byte(3)});
+
+    test_trivial<int, int>({1, 2, 3});
+    test_trivial<char, int>({'a', 'b', 'c'});
+    test_trivial<int, char>({1, 2, 3});
+
+    test_trivial<long long, int>({1, 2, 3});
+    test_trivial<int, long long>({1, 2, 3});
+
+    test_trivial<unsigned long, int>({1, 2, 3});
+    test_trivial<int, unsigned long>({1, 2, 3});
+
+    test_trivial<float, double>({1.5, 2.5, 3.5});
+    test_trivial<double, float>({1.5, 2.5, 3.5});
+
+    {
+      struct Trivial {
+        int a;
+        float b;
+        bool operator==(const Trivial& rhs) const { return a == rhs.a && b == rhs.b; }
+      };
+      static_assert(std::is_trivial<Trivial>::value);
+      test_trivial<Trivial, Trivial>({Trivial{1, 1}, Trivial{2, 2}, Trivial{3, 3}});
+    }
+
+    {
+      struct Empty {
+        bool operator==(const Empty&) const { return true; }
+      };
+      test_trivial<Empty, Empty>({Empty(), Empty(), Empty()});
+    }
+
+    // Conversion between user-defined trivial types.
+    {
+      struct TrivialFrom { char a; };
+      struct TrivialTo {
+        unsigned char a;
+        TrivialTo() = default;
+        TrivialTo(TrivialFrom from) : a(from.a) {}
+        bool operator==(TrivialFrom rhs) const { return a == rhs.a; }
+      };
+      static_assert(std::is_trivial<TrivialFrom>::value);
+      static_assert(std::is_trivial<TrivialTo>::value);
+
+      using From = TrivialFrom;
+      test_trivial<TrivialFrom, TrivialTo>({From{'a'}, From{'b'}, From{'c'}});
+    }
+  }
+
+  // Works on non-contiguous ranges.
+  {
+    const int N = 5;
+    NonContiguousBuffer<int, N> buf;
+
+    int from[N] = {1, 2, 3, 4, 5};
+    std::ranges::uninitialized_move(from, from + N, buf.begin(), buf.end());
+    assert(std::equal(from, from + N, buf.begin()));
+    buf.validate();
+
+    // TODO(varconst): also test non-contiguous input range.
+  }
+
+  // Trivial types work with non-random-access iterators.
+  {
+    const int N = 5;
+    Buffer<int, N> buf;
+
+    int from[N] = {1, 2, 3, 4, 5};
+    forward_iterator<int*> from_begin(from), from_end(from + N);
+    forward_iterator<int*> to_begin(buf.begin()), to_end(buf.end());
+    std::ranges::uninitialized_move(from_begin, from_end, to_begin, to_end);
+    assert(std::equal(from, from + N, buf.begin()));
+  }
+
+  // Works with const outputs.
+  {
+    test_trivial<char, const char>({'a', 'b', 'c'});
+    test_trivial<int, const int>({1, 2, 3});
+  }
+
+  // Works with volatile inputs and outputs.
+  {
+    test_trivial<volatile char, char>({'a', 'b', 'c'});
+    test_trivial<volatile int, int>({1, 2, 3});
+
+    test_trivial<char, volatile char>({'a', 'b', 'c'});
+    test_trivial<int, volatile int>({1, 2, 3});
+  }
+
+  // Works when only one of the ranges uses random-access iterators.
+  {
+    // (ptr, ptr) | (fwd_iter, fwd_iter)
+    {
+      int from[5] = {1, 2, 3, 4, 5};
+      Buffer<int, 3> buf;
+
+      forward_iterator<int*> to_begin(buf.begin()), to_end(buf.end());
+      std::ranges::uninitialized_move(from, from + 5, to_begin, to_end);
+      assert(std::equal(from, from + 3, buf.begin()));
+    }
+
+    // (fwd_iter, fwd_iter) | (ptr, ptr)
+    {
+      int from[3] = {1, 2, 3};
+      Buffer<int, 5> buf;
+
+      forward_iterator<int*> from_begin(from), from_end(from + 3);
+      std::ranges::uninitialized_move(from_begin, from_end, buf.begin(), buf.end());
+      assert(std::equal(from, from + 3, buf.begin()));
+    }
+
+    // (ptr, ptr) | (ptr, unreachable)
+    {
+      int from[3] = {1, 2, 3};
+      Buffer<int, 5> buf;
+
+      std::ranges::uninitialized_move(from, from + 3, buf.begin(), std::unreachable_sentinel);
+      assert(std::equal(from, from + 3, buf.begin()));
+    }
+
+    // (ptr, unreachable) | (ptr, ptr)
+    {
+      int from[5] = {1, 2, 3, 4, 5};
+      Buffer<int, 3> buf;
+
+      std::ranges::uninitialized_move(from, std::unreachable_sentinel, buf.begin(), buf.end());
+      assert(std::equal(from, from + 3, buf.begin()));
+    }
+  }
+
   return 0;
 }

libcxx/test/std/utilities/memory/specialized.algorithms/uninitialized.move/ranges_uninitialized_move_n.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 // UNSUPPORTED: libcpp-no-concepts, libcpp-has-no-incomplete-ranges
 
+// ADDITIONAL_COMPILE_FLAGS: -Wno-deprecated-volatile -Wno-sign-compare
+
 // <memory>
 //
-// template<input_iterator I, nothrow-forward-iterator O, nothrow-sentinel-for<O> S>
-//   requires constructible_from<iter_value_t<O>, iter_reference_t<I>>
-// uninitialized_copy_n_result<I, O> uninitialized_copy_n(I ifirst, iter_difference_t<I> n, O ofirst, S olast); // since C++20
+// template <input_iterator I, nothrow-forward-iterator O, nothrow-sentinel-for<O> S>
+//   requires constructible_from<iter_value_t<O>, iter_rvalue_reference_t<I>>
+// uninitialized_move_n_result<I, O> uninitialized_move_n(I ifirst, iter_difference_t<I> n, O ofirst, S olast); // since C++20
 
 #include <algorithm>
 #include <cassert>
+#include <initializer_list>
 #include <iterator>
 #include <memory>
 #include <ranges>
 #include <type_traits>
 
 #include "../buffer.h"
 #include "../counted.h"
 #include "test_macros.h"
friend T&& iter_move(Iterator iter) {
     return std::move(*iter);
   }
 
   friend bool operator==(const Iterator& lhs, const Iterator& rhs) { return lhs.ptr == rhs.ptr; }
 };
 
 } // namespace adl
 
+template <class From, class To>
+void test_trivial(std::initializer_list<From> from) {
+  constexpr int N = 3;
+  Buffer<To, N> buf;
+
+  std::ranges::uninitialized_move_n(from.begin(), N, buf.begin(), buf.end());
+  auto buf_iter = buf.begin();
+  // Note: `std::equal` doesn't work with volatile types.
+  for (auto& e : from) {
+    assert(e == *buf_iter);
+    ++buf_iter;
+  }
+}
+
 int main(int, char**) {
   // An empty range -- no default constructors should be invoked.
   {
     Counted in[] = {Counted()};
     Buffer<Counted, 1> out;
     Counted::reset();
 
     auto result = std::ranges::uninitialized_move_n(in, 0, out.begin(), out.end());
#endif // TEST_HAS_NO_EXCEPTIONS
   // Ensure the `iter_move` customization point is being used.
   {
     constexpr int N = 3;
     int in[N] = {1, 2, 3};
     Buffer<int, N> out;
     adl::Iterator<int> begin(in);
     adl::Iterator<int> end(in + N);
 
-    std::ranges::uninitialized_move(begin, end, out.begin(), out.end());
+    std::ranges::uninitialized_move_n(begin, N, out.begin(), out.end());
     assert(adl::iter_move_invocations == 3);
     adl::iter_move_invocations = 0;
+  }
 
-    std::ranges::subrange range(begin, end);
-    std::ranges::uninitialized_move(range, out);
-    assert(adl::iter_move_invocations == 3);
-    adl::iter_move_invocations = 0;
+  // Works with trivial types.
+  {
+    test_trivial<char, char>({'a', 'b', 'c'});
+    test_trivial<char, unsigned char>({'a', 'b', 'c'});
+#if TEST_STD_VER > 14
+    test_trivial<std::byte, std::byte>({std::byte(1), std::byte(2), std::byte(3)});
+#endif
+
+    test_trivial<int, int>({1, 2, 3});
+    test_trivial<char, int>({'a', 'b', 'c'});
+    test_trivial<int, char>({1, 2, 3});
+
+    test_trivial<long long, int>({1, 2, 3});
+    test_trivial<int, long long>({1, 2, 3});
+
+    test_trivial<unsigned long, int>({1, 2, 3});
+    test_trivial<int, unsigned long>({1, 2, 3});
+
+    test_trivial<float, double>({1.5, 2.5, 3.5});
+    test_trivial<double, float>({1.5, 2.5, 3.5});
+
+    {
+      struct Trivial {
+        int a;
+        float b;
+        bool operator==(const Trivial& rhs) const { return a == rhs.a && b == rhs.b; }
+      };
+      static_assert(std::is_trivial<Trivial>::value);
+      test_trivial<Trivial, Trivial>({Trivial{1, 1}, Trivial{2, 2}, Trivial{3, 3}});
+    }
+
+    {
+      struct Empty {
+        bool operator==(const Empty&) const { return true; }
+      };
+      test_trivial<Empty, Empty>({Empty(), Empty(), Empty()});
+    }
+
+    // Conversion between user-defined trivial types.
+    {
+      struct TrivialFrom { char a; };
+      struct TrivialTo {
+        unsigned char a;
+        TrivialTo() = default;
+        TrivialTo(TrivialFrom from) : a(from.a) {}
+        bool operator==(TrivialFrom rhs) const { return a == rhs.a; }
+      };
+      static_assert(std::is_trivial<TrivialFrom>::value);
+      static_assert(std::is_trivial<TrivialTo>::value);
+
+      using From = TrivialFrom;
+      test_trivial<TrivialFrom, TrivialTo>({From{'a'}, From{'b'}, From{'c'}});
+    }
+  }
+
+  // Works on non-contiguous ranges.
+  {
+    const int N = 5;
+    NonContiguousBuffer<int, N> buf;
+
+    int from[N] = {1, 2, 3, 4, 5};
+    std::ranges::uninitialized_move_n(from, N, buf.begin(), buf.end());
+    assert(std::equal(from, from + N, buf.begin()));
+    buf.validate();
+
+    // TODO(varconst): also test non-contiguous input range.
+  }
+
+  // Trivial types work with non-random-access iterators.
+  {
+    const int N = 5;
+    Buffer<int, N> buf;
+
+    int from[N] = {1, 2, 3, 4, 5};
+    forward_iterator<int*> from_begin(from);
+    forward_iterator<int*> to_begin(buf.begin()), to_end(buf.end());
+    std::ranges::uninitialized_move_n(from_begin, N, to_begin, to_end);
+    assert(std::equal(from, from + N, buf.begin()));
+  }
+
+  // Works with const outputs.
+  {
+    test_trivial<char, const char>({'a', 'b', 'c'});
+    test_trivial<int, const int>({1, 2, 3});
+  }
+
+  // Works with volatile inputs and outputs.
+  {
+    test_trivial<volatile char, char>({'a', 'b', 'c'});
+    test_trivial<volatile int, int>({1, 2, 3});
+
+    test_trivial<char, volatile char>({'a', 'b', 'c'});
+    test_trivial<int, volatile int>({1, 2, 3});
+  }
+
+  // Works when only one of the ranges uses random-access iterators.
+  {
+    // (ptr, N) | (fwd_iter, fwd_iter)
+    {
+      int from[5] = {1, 2, 3, 4, 5};
+      Buffer<int, 3> buf;
+
+      forward_iterator<int*> to_begin(buf.begin()), to_end(buf.end());
+      std::ranges::uninitialized_move_n(from, 5, to_begin, to_end);
+      assert(std::equal(from, from + 3, buf.begin()));
+    }
+
+    // (ptr, N) | (ptr, unreachable)
+    {
+      int from[3] = {1, 2, 3};
+      Buffer<int, 5> buf;
+
+      std::ranges::uninitialized_move_n(from, 3, buf.begin(), std::unreachable_sentinel);
+      assert(std::equal(from, from + 3, buf.begin()));
+    }
   }
 
   return 0;
 }

libcxx/test/std/utilities/memory/specialized.algorithms/uninitialized.move/uninitialized_move.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 
+// ADDITIONAL_COMPILE_FLAGS: -Wno-deprecated-volatile -Wno-sign-compare
+
 // <memory>
 
 // template <class InputIt, class ForwardIt>
 // ForwardIt uninitialized_move(InputIt, InputIt, ForwardIt);
 
 #include <memory>
+#include <algorithm>
 #include <cstdlib>
 #include <cassert>
+#include <initializer_list>
 
+#include "../buffer.h"
 #include "test_macros.h"
 #include "test_iterators.h"
 
 struct Counted {
   static int count;
   static int constructed;
   static void reset() { count = constructed =  0; }
   explicit Counted(int&& x) : value(x) { x = 0; ++count; ++constructed; }
void test_counted()
     assert(values[1] == 0);
     assert(values[2] == 0);
     assert(values[3] == 0);
     assert(values[4] == 0);
     std::destroy(p, p+N);
     assert(Counted::count == 0);
 }
 
+template <class From, class To>
+void test_trivial(std::initializer_list<From> from) {
+  constexpr int N = 3;
+  Buffer<To, N> buf;
+
+  std::uninitialized_move(from.begin(), from.end(), buf.begin());
+  auto buf_iter = buf.begin();
+  // Note: `std::equal` doesn't work with volatile types.
+  for (auto& e : from) {
+    assert(*buf_iter == e);
+    ++buf_iter;
+  }
+}
+
+void test_trivial() {
+    // Works with trivial types.
+    {
+      test_trivial<char, char>({'a', 'b', 'c'});
+      test_trivial<char, unsigned char>({'a', 'b', 'c'});
+#if TEST_STD_VER > 14
+      test_trivial<std::byte, std::byte>({std::byte(1), std::byte(2), std::byte(3)});
+#endif
+
+      test_trivial<int, int>({1, 2, 3});
+      test_trivial<char, int>({'a', 'b', 'c'});
+      test_trivial<int, char>({1, 2, 3});
+
+      test_trivial<long long, int>({1, 2, 3});
+      test_trivial<int, long long>({1, 2, 3});
+
+      test_trivial<unsigned long, int>({1, 2, 3});
+      test_trivial<int, unsigned long>({1, 2, 3});
+
+      test_trivial<float, double>({1.5, 2.5, 3.5});
+      test_trivial<double, float>({1.5, 2.5, 3.5});
+
+      {
+        struct Trivial {
+          int a;
+          float b;
+          bool operator==(const Trivial& rhs) const { return a == rhs.a && b == rhs.b; }
+        };
+        static_assert(std::is_trivial<Trivial>::value);
+        test_trivial<Trivial, Trivial>({Trivial{1, 1}, Trivial{2, 2}, Trivial{3, 3}});
+      }
+
+      {
+        struct Empty {
+          bool operator==(const Empty&) const { return true; }
+        };
+        test_trivial<Empty, Empty>({Empty(), Empty(), Empty()});
+      }
+
+      // Conversion between user-defined trivial types.
+      {
+        struct TrivialFrom { char a; };
+        struct TrivialTo {
+          unsigned char a;
+          TrivialTo() = default;
+          TrivialTo(TrivialFrom from) : a(from.a) {}
+          bool operator==(TrivialFrom rhs) const { return a == rhs.a; }
+        };
+        static_assert(std::is_trivial<TrivialFrom>::value);
+        static_assert(std::is_trivial<TrivialTo>::value);
+
+        using From = TrivialFrom;
+        test_trivial<TrivialFrom, TrivialTo>({From{'a'}, From{'b'}, From{'c'}});
+      }
+    }
+}
+
+void test_non_contiguous() {
+    // Works on non-contiguous ranges.
+    {
+      const int N = 5;
+      NonContiguousBuffer<int, N> buf;
+
+      int from[N] = {1, 2, 3, 4, 5};
+      std::uninitialized_move(from, from + N, buf.begin());
+      assert(std::equal(from, from + N, buf.begin()));
+      buf.validate();
+
+      // TODO(varconst): also test non-contiguous input range.
+    }
+}
+
+void test_non_random_access() {
+    // Trivial types work with non-random-access iterators.
+    {
+      const int N = 5;
+      Buffer<int, N> buf;
+
+      int from[N] = {1, 2, 3, 4, 5};
+      forward_iterator<int*> from_begin(from), from_end(from + N);
+      forward_iterator<int*> to_begin(buf.begin());
+      std::uninitialized_move(from_begin, from_end, to_begin);
+      assert(std::equal(from, from + N, buf.begin()));
+    }
+}
+
+void test_cv() {
+    // Works with const outputs.
+    {
+      test_trivial<char, const char>({'a', 'b', 'c'});
+      test_trivial<int, const int>({1, 2, 3});
+    }
+
+    // Works with volatile inputs and outputs.
+    {
+      test_trivial<volatile char, char>({'a', 'b', 'c'});
+      test_trivial<volatile int, int>({1, 2, 3});
+
+      test_trivial<char, volatile char>({'a', 'b', 'c'});
+      test_trivial<int, volatile int>({1, 2, 3});
+    }
+}
+
 int main(int, char**) {
     test_counted();
     test_ctor_throws();
+    test_trivial();
+    test_non_contiguous();
+    test_non_random_access();
+    test_cv();
 
     return 0;
 }

libcxx/test/std/utilities/memory/specialized.algorithms/uninitialized.move/uninitialized_move_n.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 
+// ADDITIONAL_COMPILE_FLAGS: -Wno-deprecated-volatile -Wno-sign-compare
+
 // <memory>
 
 // template <class InputIt, class Size, class ForwardIt>
 // pair<InputIt, ForwardIt> uninitialized_move_n(InputIt, Size, ForwardIt);
 
 #include <memory>
+#include <algorithm>
 #include <cstdlib>
 #include <cassert>
+#include <initializer_list>
 
+#include "../buffer.h"
 #include "test_macros.h"
 #include "test_iterators.h"
 
 struct Counted {
   static int count;
   static int constructed;
   static void reset() { count = constructed =  0; }
   explicit Counted(int&& x) : value(x) { x = 0; ++count; ++constructed; }
void test_counted()
     assert(values[1] == 0);
     assert(values[2] == 0);
     assert(values[3] == 0);
     assert(values[4] == 0);
     std::destroy(p, p+N);
     assert(Counted::count == 0);
 }
 
+template <class From, class To>
+void test_trivial(std::initializer_list<From> from) {
+  constexpr int N = 3;
+  Buffer<To, N> buf;
+
+  std::uninitialized_move_n(from.begin(), N, buf.begin());
+  auto buf_iter = buf.begin();
+  // Note: `std::equal` doesn't work with volatile types.
+  for (auto& e : from) {
+    assert(*buf_iter == e);
+    ++buf_iter;
+  }
+}
+
+void test_trivial() {
+    // Works with trivial types.
+    {
+      test_trivial<char, char>({'a', 'b', 'c'});
+      test_trivial<char, unsigned char>({'a', 'b', 'c'});
+#if TEST_STD_VER > 14
+      test_trivial<std::byte, std::byte>({std::byte(1), std::byte(2), std::byte(3)});
+#endif
+
+      test_trivial<int, int>({1, 2, 3});
+      test_trivial<char, int>({'a', 'b', 'c'});
+      test_trivial<int, char>({1, 2, 3});
+
+      test_trivial<long long, int>({1, 2, 3});
+      test_trivial<int, long long>({1, 2, 3});
+
+      test_trivial<unsigned long, int>({1, 2, 3});
+      test_trivial<int, unsigned long>({1, 2, 3});
+
+      test_trivial<float, double>({1.5, 2.5, 3.5});
+      test_trivial<double, float>({1.5, 2.5, 3.5});
+
+      {
+        struct Trivial {
+          int a;
+          float b;
+          bool operator==(const Trivial& rhs) const { return a == rhs.a && b == rhs.b; }
+        };
+        static_assert(std::is_trivial<Trivial>::value);
+        test_trivial<Trivial, Trivial>({Trivial{1, 1}, Trivial{2, 2}, Trivial{3, 3}});
+      }
+
+      {
+        struct Empty {
+          bool operator==(const Empty&) const { return true; }
+        };
+        test_trivial<Empty, Empty>({Empty(), Empty(), Empty()});
+      }
+
+      // Conversion between user-defined trivial types.
+      {
+        struct TrivialFrom { char a; };
+        struct TrivialTo {
+          unsigned char a;
+          TrivialTo() = default;
+          TrivialTo(TrivialFrom from) : a(from.a) {}
+          bool operator==(TrivialFrom rhs) const { return a == rhs.a; }
+        };
+        static_assert(std::is_trivial<TrivialFrom>::value);
+        static_assert(std::is_trivial<TrivialTo>::value);
+
+        using From = TrivialFrom;
+        test_trivial<TrivialFrom, TrivialTo>({From{'a'}, From{'b'}, From{'c'}});
+      }
+    }
+}
+
+void test_non_contiguous() {
+    // Works on non-contiguous ranges.
+    {
+      const int N = 5;
+      NonContiguousBuffer<int, N> buf;
+
+      int from[N] = {1, 2, 3, 4, 5};
+      std::uninitialized_move_n(from, N, buf.begin());
+      assert(std::equal(from, from + N, buf.begin()));
+      buf.validate();
+
+      // TODO(varconst): also test non-contiguous input range.
+    }
+}
+
+void test_non_random_access() {
+    // Trivial types work with non-random-access iterators.
+    {
+      const int N = 5;
+      Buffer<int, N> buf;
+
+      int from[N] = {1, 2, 3, 4, 5};
+      forward_iterator<int*> from_begin(from);
+      forward_iterator<int*> to_begin(buf.begin());
+      std::uninitialized_move_n(from_begin, N, to_begin);
+      assert(std::equal(from, from + N, buf.begin()));
+    }
+}
+
+void test_cv() {
+    // Works with const outputs.
+    {
+      test_trivial<char, const char>({'a', 'b', 'c'});
+      test_trivial<int, const int>({1, 2, 3});
+    }
+
+    // Works with volatile inputs and outputs.
+    {
+      test_trivial<volatile char, char>({'a', 'b', 'c'});
+      test_trivial<volatile int, int>({1, 2, 3});
+
+      test_trivial<char, volatile char>({'a', 'b', 'c'});
+      test_trivial<int, volatile int>({1, 2, 3});
+    }
+}
+
 int main(int, char**)
 {
     test_counted();
     test_ctor_throws();
+    test_trivial();
+    test_non_contiguous();
+    test_non_random_access();
+    test_cv();
 
     return 0;
 }