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

[var-const]

libcxx/include/__memory/uninitialized_algorithms.h

135

This is to simplify the initial implementation.

[ldionne]

libcxx/include/__memory/uninitialized_algorithms.h

139–140

Why is is_trivially_constructible_v<_ValueType, unsigned char> not sufficient?

146

I don't understand why this needs to be different from __can_use_memset_fill. Is the 0 value special?

153

Do you mean to use the new C++20 is_layout_compatible here, or is it something else?

161

I would simply use is_trivially_constructible<_To, _From> here. Do you see a reason why that wouldn't work?

187–190

IMO it would be cleaner to use std::enable_if instead -- we generally stay away from specializing function templates (we're happy overloading them though).

195

Perhaps we don't need those at all then, and we can always use ::value?

208

Why do we static_cast<unsigned char> and then pass it to memset(void*, int, ...), only for it to then cast again to unsigned char? Shouldn't we cast to int instead?

215

Why does this need to be a different function of its own? I'd understand if we used something like bzero (I think??) where there's OS-level optimizations with copy-on-write, but here I don't see the point.

The bzero stuff is far in my memory, but I think I remember there were optimizations around that.

225

226

My initial reaction to this is "we shouldn't try to guess whether a type is represented as zero". Indeed, that means that we need to pay for an additional memset and memcmp every time, and that could be pretty costly for large-ish types. Imagine arrays, for example.

[var-const]

• address feedback;
• implement the optimization for the destroy family of algorithms;
• add partial tests (missing copy and move).

[var-const]

libcxx/include/__memory/uninitialized_algorithms.h

139–140

Consider:

unsigned char x = 2;
int y = 0;
static_assert(std::is_trivially_constructible_v<decltype(y), decltype(x)>);
std::memset(&y, x, sizeof(y));
std::cout << y << std::endl; // 33686018

The intention of the check is to ensure memset would have the same effect as copying through the normal language means.

146

I've written a bit about this in the comment thread below regarding __memset_zero -- briefly, my understanding is that _any_ trivial object (including a POD struct) can be meaningfully set to all zeroes. However, because memset sets every byte in the output to the same byte value, it can only be used for filling if the type of the output fits into a byte (e.g. memsetting an array of chars to 10 is meaningful, producing [10 10 10...], whereas memsetting an array of ints to 10 would produce [168430090 168430090 168430090...]).

148

I'm actually not sure if this is addressed by the text of the Standard -- specifically, that memsetting all bytes of an arbitrary trivial struct to zero is a valid operation. It seems logical (a trivial type consists of trivial types recursively, meaning that a) it can be reduced to a sequence of primitive types and b) neither the type nor any nested types imposes any invariant on the values in its constructors), but AFAICT other implementations limit this optimization to built-in types.

153

The idea here is that all integral types are bitwise-compatible with each other, and all floating-point types are bitwise-compatible with each other, but integral types are _not_ bitwise-compatible with floating-point types; i.e., this is okay:

int x = ...;
long long y = ...;
memcpy(&x, &y, sizeof(x));

but this isn't:

int x = ...;
double y = ...;
memcpy(&x, &y, sizeof(x));

I don't think is_layout_compatible can help here -- for example, it wouldn't consider int and long bitwise-compatible.

This also leads to the question of whether we should allow truncation, e.g. using memcpy to initialize an int from long long, an unsigned int from int, or a float from a double. FWIW, some simple experiments show that, for Clang and GCC at least, memcpying and using normal language syntax produce the same truncating behavior for integral types, but not for floating-point types. To illustrate the last part:

{
  double x = std::numeric_limits<double>::max();
  float y = 0;
  y = x;
  std::cout << x << " " << y << std::endl;
  // 1.79769e+308 inf
}
{
  double x = std::numeric_limits<double>::max();
  float y = 0;
  std::memcpy(&y, &x, sizeof(y));
  std::cout << x << " " << y << std::endl;
  // 1.79769e+308 -nan
}

161

One example is converting between built-in floating-point and integer types -- is_trivially_constructible_v<long long, double> is true, but using memcpy would produce different (and incorrect) results compared to copying a double into a long long.

187–190

No longer applicable.

195

I don't have a very strong stance on this. Currently, there are more C++11-and-later algorithms (default_construct, value_construct, move) than C++03 algorithms (copy, fill) in this file, so it seemed reasonable to allow using the nicer syntax where possible. However, the gains are minimal, so I'm absolutely open to removing these.

208

memset is documented as converting to a unsigned char in its implementation (it accepts an int parameter for historical reasons), and I wanted to make that visible at the call site. If you feel this is confusing, I'm happy to change to an int cast like you mentioned (but I'd still prefer to add a comment that all possible values of __x should fit in a byte to avoid truncation).

215

I think zero is special in that, for a trivial but potentially large struct, it is the only value that can be used to set every byte in that struct and still get a meaningful result. __memset_fill presumes it is given a scalar __x that fits in a char. __memset_zero can work with a trivial _ValueType of an arbitrary size. I don't see a great way to use __memset_fill in that situation -- at the very least, in its current form it relies on being able to cast __x to int, whereas __memset_zero doesn't need to have that restriction.

226

Agreed -- I also feel like this optimization probably isn't worth it. Removed now.

[var-const]

Remove a leftover debug comment

[ldionne]

libcxx/include/__memory/construct_at.h

30

This namespacing is unusual and IMO looks weird since __next_n has nothing to do specifically with __construct_at.

I would suggest instead using std::next, which is normally C++11 but we support in all Standard modes.

87–89

IMO we should not try to make the optimization here. I am fairly confident that the optimizer is going to remove the ~_Tp() call down in __destroy_at for trivially destructible types, however we still want to hit the _LIBCPP_ASSERT in there in case a nullptr is passed.

libcxx/include/__memory/uninitialized_algorithms.h

119

How about moving this to __iterator/next.h alongside std::next?

Also, I think this basically needs to do the same optimizations that std::ranges::next does through using std::ranges::advance. For example, if we have a random access iterator and we can assign the sentinel to the iterator, why would we increment it N times?

Alternatively, per what you just said offline, perhaps it's not worth trying to pretend that these utilities can work on types other than pointers?

139–140

Good point.

I think what we should do is this:

is_pointer<...> &&
is_trivially_constructible_v<_To, _From> &&
sizeof(_From) == sizeof(unsigned char) &&
sizeof(_To) == sizeof(unsigned char) &&
! is_volatile<...>

And then, what we should do in __memset_fill is use std::bit_cast<unsigned char>(__x) instead of static_cast. That way, this optimization can kick in for something like struct Foo { char c; }; (which is a valid case for this optimization).

148

Given how this is used (for uninitialized_value_construct), I think the right criteria here is just is_pointer && is_trivially_default_constructible && !is_volatile. In other words, I don't think it matters whether the type is trivially copyable (which is what is_trivial adds IIUC).

[var-const]

• add more tests;
• fix handling of volatile;
• for memcpy, support using the unreachable sentinel.

[var-const]

libcxx/include/__memory/uninitialized_algorithms.h

148

Done.

I based this on this remark in [cppreference about memset](https://en.cppreference.com/w/cpp/string/byte/memset):

If the object is a potentially-overlapping subobject or is not `TriviallyCopyable` (e.g., scalar, C-compatible struct, or an array of trivially copyable type), the behavior is undefined.

Now that I think about it, however, that probably applies to already-initialized objects (in which case using memset is akin to reassigning) and making sure the class is trivially copyable makes sense. Here, however, we're essentially creating a new object, so whether it is trivially copyable probably doesn't matter.

[var-const]

Remove commented-out code.

[ldionne]

Per our offline discussion, I think we can simplify a lot if we have some fancy internal unreachable_sentinel that is also a "sized sentinel" for pointers, and which returns INT_MAX or something when subtracted.

libcxx/include/__iterator/next.h

42 ↗

(On Diff #402788)

We don't remove existing inlines until we've figured out the situation with code size regressions, but I would suggest not using it for new code unless it is needed semantically (or has been measured to be better).

libcxx/include/__memory/uninitialized_algorithms.h

136

I feel like it wouldn't add that much complexity to use __enable_if_t right away in this patch. In fact, having a separate function might give you a place to put the logic that is currently in __memcpy & friends, allowing you to remove these small helpers.

146

I think we should simplify this by inlining it into __can_memcpy_between. Also, here's a weak name suggestion that IMO is a bit clearer than __are_bitwise_compatible and __can_memcpy_between: __is_bitwise_copyable.

__are_bitwise_compatible: "compatible" is a bit vague IMO, it's not clear what it means until I read the definition
__can_memcpy_between: this is very clear, however I find it confusing with the other traits that check whether we can do memcpy, i.e. __can_use_memcpy_impl. It requires some cycles to think that those are entirely different properties.

154

I think this is_trivial could be replaced by is_trivially_copyable.

159

Unless I missed something subtle, you should be able to get rid of __can_use_memset_fill by doing:

template <class _InputIterator, class _OutputIterator, 
                  class _From = typename __iter_cv_value_type<_InputIterator>::type, 
                  class _To = typename __iter_cv_value_type<_OutputIterator>::type>
struct __can_use_memcpy_impl { ... };

Alternatively, you could simply do:

template <class _InputIterator, class _OutputIterator>
struct __can_use_memcpy_impl {
  using _From = typename __iter_cv_value_type<_InputIterator>::type;
  using _To = typename __iter_cv_value_type<_OutputIterator>::type;
  static constexpr bool value = ...;
};

197

You had the right reflex to use __value instead of value because this is an internal helper, however this (and ::type) are the only two places where we use non-internal names even in internal-only code. If someone were to define a macro named type or value, everything would break anyway. I think we should go for consistency with the rest of our code here and use value instead.

204

If there is only a few uses of these type traits, the cost of conditionally defining their _v counterparts is usually not worth it, and we generally don't bother doing it. It seems like the case here -- IMO the patch would be simpler if we didn't have those, even though I understand it means a couple more characters every time we use those traits.

223

I'm really curious to know whether/how other implementations are doing the bit_cast part. I think other implementations have been performing these optimizations for a long time, way before bit_cast was available. Do you know what they do?

299

I don't *think* we're allowed to perform this optimization as-is, because it wouldn't be equivalent in case the iterator throws an exception. Without the optimization, we'd normally call __destroy, which could be meaningful if the _ValueType has a non-trivial destructor.

To be safe, we could add && is_trivially_destructible. This might apply elsewhere too.

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

40

Any reason why this isn't called iterator (and then we don't need the iterator_t typedef)?

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

115–127

You probably want to move this to tests() below directly, cause nothing here depends on It.

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

198

Consider inlining N for consistency with other test cases (here and elsewhere, in some other files too I think).

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

103

You can indent this (and all the new code you are adding too).

[var-const]

Address feedback

[ldionne]

libcxx/include/__bit/bit_cast.h

22

libcxx/include/__memory/uninitialized_algorithms.h

29

Please also comment about the added operator- and its purpose, since that's a significant difference (and a reason to use this over unreachable_sentinel for internal code, I guess?).

64–65

79

86–88

And actually, as we just discussed: The floating point part here assumes that if two floating point types T and U have the same size, then they have the same representation. I don't think there are two floating point types with the same size and the same representation that are *not* the same type, and that would be unlikely. In other words, I think the only time when we want the floating point criteria to kick in is already covered by is_same<From, To>, and so we should just remove the floating point criteria.

129

Another pattern we sometimes use is __enable_if_t<condition>* = nullptr, I think it's a tiny bit shorter. Whichever you prefer.

299

Here you don't guard against an iterator throwing and destruction not being trivial unless I missed something. In all places, you need to make sure that if you skip initialization, it's safe to also skip destruction in case of an exception thrown by the iterator.

[var-const]

libcxx/include/__memory/uninitialized_algorithms.h

223

Both GCC and MSVC use static_cast<unsigned char>.

GCC:

__builtin_memset(__first, static_cast<unsigned char>(__tmp), __len);

MSVC:

_CSTD memset(_To_address(_Dest), static_cast<unsigned char>(_Dest_val), _Count);

[var-const]

Address feedback, implement _copy and _move tests, handle pointers to members correctly.

[var-const]

libcxx/include/__memory/uninitialized_algorithms.h

154

Hmm, I think so.

299

Done.

Interestingly enough, from what I could find in practice is_trivially_default_constructible is only true if is_trivially_destructible is also true -- see https://wandbox.org/permlink/OsAl5tGsIJJNI9cO.

It looks like Clang implements the former trait using a compiler function __is_trivially_constructible, so I can't quickly check how it's defined. However, I think that even if adding is_trivially_destructible may have no effect, it still makes things a little clearer.

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

198

I'd rather keep the constant unless you feel strongly about it. The code above mostly uses it, and I slightly prefer to keep it.

[var-const]

Missing tests

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/__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
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 // construct_at
 
 #if _LIBCPP_STD_VER > 17
 
 template<class _Tp, class ..._Args, class = decltype(
     ::new (declval<void*>()) _Tp(declval<_Args>()...)
 )>
 _LIBCPP_HIDE_FROM_ABI
 constexpr _Tp* construct_at(_Tp* __location, _Args&& ...__args) {
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) {
+    if constexpr (is_trivially_destructible_v<__iter_value_type<_ForwardIterator>>) {
+      return __last;
+    }
+
     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_at(_Tp* __loc) {
     _VSTD::__destroy_at(__loc);
 }
 
 #if _LIBCPP_STD_VER > 17
 template <class _Tp, enable_if_t<is_array_v<_Tp>, int> = 0>
 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17
 void destroy_at(_Tp* __loc) {
   _VSTD::__destroy_at(__loc);
 }
 #endif
 
 template <class _ForwardIterator>
 _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_v<__iter_value_type<_ForwardIterator>>) {
+      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
         for (; __idx != __last; ++__idx)
             ::new (_VSTD::__voidify(*__idx)) _ValueType(__x);
 #ifndef _LIBCPP_NO_EXCEPTIONS
     }
     catch (...)
     {
         _VSTD::__destroy(__first, __idx);
         throw;
     }
 #endif
 
     return __idx;
 }
 
 template <class _ForwardIterator, class _Tp>
 inline _LIBCPP_HIDE_FROM_ABI
 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 "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;
+
+    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(e == *buf_iter);
+    ++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(e == *buf_iter);
+    ++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(), [=](auto 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(), [=](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/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(), [=](auto 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(), [=](auto 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(e == *buf_iter);
+    ++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(e == *buf_iter);
+    ++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;
 }