P1144 "Trivially relocatable" (1/3): is_trivially_relocatable, relocate_at, and uninitialized_relocate

[philnik]

Summary

Part 0/3 is D50119: it adds __has_extension(__is_trivially_relocatable) to the compiler.
Part 1/3 is D61761: it implements the library traits and algorithms mandated by P1144.
Part 2/3 is D63620: it implements Quality-of-Implementation features to warrant certain std library types as "trivially relocatable."
Part 3/3 is D67524: it implements Quality-of-Implementation features to optimize certain std library functions for better performance on types that have been warranted "trivially relocatable."

This implements the library behavior proposed in P1144R3. This patch doesn't do any special optimizations (e.g. to std::vector::reserve) nor add warrants to libc++ class types; those will come later. This is just the bare minimum to conform to P1144's additions to the standard.

We mangle relocate_at into __libcpp_relocate_at, and so on, in order to discourage users from using them. (The intent is that libc++ itself will be able to use them to enable optimizations. Such optimizations are the point of D67524.)

TODO:

• any reason to gate the new names on any particular _LIBCPP_STD_VER, such as 17? (I think not.)
• do the tests pass with a compiler that doesn't support __has_extension(__is_trivially_relocatable)? how best to structure the tests so as not to break this?

[zoecarver]

include/memory

3463 ↗

(On Diff #198907)

Nit: is _IsMemcpyable guaranteed to be true_type or false_type? If so, maybe make it specifically false_type.

3510 ↗

(On Diff #198907)

I think this should require _LIBCPP_STD_VER > 03.

3556 ↗

(On Diff #198907)

What is the reason for is_volatile? I don't see that in the paper (but maybe I am missing something).

test/libcxx/type_traits/is_trivially_relocatable.pass.cpp

33 ↗

(On Diff #198907)

Maybe add a test for things that are experimental?

test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_relocatable.pass.cpp

14 ↗

(On Diff #198907)

Shouldn't this also contain c++98?

[• Quuxplusone]

include/memory

3463 ↗

(On Diff #198907)

Brain fart on my part. (This isn't a class template with a partial specialization, it's two overloaded function templates!) Will fix.

3466 ↗

(On Diff #198907)

I'm not sure whether this launder is doing anything.
Alternatively, should I assign __dest = ::new (... and then return __dest?

3510 ↗

(On Diff #198907)

libc++ supports std::move even in _LIBCPP_HAS_NO_RVALUE_REFERENCES-mode, presumably because it would be too tedious to #ifdef all the places where we use std::move (such as here).

3556 ↗

(On Diff #198907)

It's related to https://quuxplusone.github.io/blog/2018/07/13/trivially-copyable-corner-cases/ — if we have a range of volatile Foo, then the user is probably expecting us to follow the abstract machine and copy the Foo objects one by one, instead of byte-by-byte (possible tearing). The library doesn't technically have to follow the abstract machine here, but I think it's QoI to do so.

I just re-examined std::copy and it doesn't bother to check is_volatile, so I guess it would be consistent for libc++ not to check is_volatile here either. (That would make the QoI consistently low, IMHO.)

test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_relocatable.pass.cpp

14 ↗

(On Diff #198907)

Hmm. My impression had been that c++98 and c++03 were synonymous, and that the tests only ever passed c++03. But now I see that most tests do refer to c++98, c++03, except for the ones I added and also

test/std/diagnostics/syserr/is_error_code_enum.pass.cpp
test/std/input.output/iostreams.base/is_error_code_enum_io_errc.pass.cpp
test/std/utilities/time/time.duration/time.duration.alg/abs.fail.cpp
test/std/utilities/time/time.duration/time.duration.cast/ceil.fail.cpp
test/std/utilities/time/time.duration/time.duration.cast/floor.fail.cpp
test/std/utilities/time/time.duration/time.duration.cast/round.fail.cpp
test/std/utilities/time/time.point/time.point.cast/ceil.fail.cpp
test/std/utilities/time/time.point/time.point.cast/floor.fail.cpp
test/std/utilities/time/time.point/time.point.cast/round.fail.cpp

Should these other tests also get c++98 added, or should c++98 and c++03 be synonymous in tests?

[• Quuxplusone]

Fixed brain fart. Added UNSUPPORTED: c++98 to test.

[zoecarver]

include/memory

3466 ↗

(On Diff #198907)

That seems more correct. After calling new the pointer should still be active, so you won't need launder .

I think launder is only necessary after memmove because then the pointer's lifetime is over.

3510 ↗

(On Diff #198907)

Good to know.

3556 ↗

(On Diff #198907)

Maybe open an issue about this (in bugzilla) so that once/if P1153 is introduced it can be updated.

3464 ↗

(On Diff #199160)

Are you intentionally not doing anything with the result of new? Also, I am not sure you need to static_cast to void*.

Also, also, I think you want to move __source not __dest (because I am pretty sure __dest is where you want to relocate the new thing and __source is where you want to get it).

3481 ↗

(On Diff #199160)

I think this should be is_trivially_relocatable<_Tp>().

[zoecarver]

include/memory

3518 ↗

(On Diff #199160)

I don't think this overload is necessary in addition to the below one.

[• Quuxplusone]

Add a heterogeneous __relocate_at2 helper for uninitialized_relocate.
Also fix a major typo-bug in relocate_at; thanks @zoecarver!

include/memory

3464 ↗

(On Diff #199160)

Yikes! That was a pretty bad bug. Thanks.

3518 ↗

(On Diff #199160)

I think this overload would never really be useful in practice, but since it does something different from the below one (element-wise memcpy in a loop, instead of one big memcpy), I figured I should implement it.

However, since P1144R3 adds relocate_at, I can refactor this overload and the one above into a single overload that does relocate_at-in-a-loop! Will do.

In the process of rewriting this code, I realized that whereas uninitialized_relocate copies uninitialized_move in not requiring the two iterator types to have the same value_type, relocate_at requires the exact same type _Tp * for both __source and __dest. I have added an internal version __relocate_at2(_Sp *__source, _Dp *__dest), and am ambivalently considering adding it to the proposal P1144R4. That would require some kind of change to the word "homogeneous" in P1144R3, though. Feel free to comment on this idea here and/or by email.

[zoecarver]

include/memory

3464 ↗

(On Diff #199160)

Of course! That's what code review is for :)

Maybe add a test for this though.

3518 ↗

(On Diff #199160)

IMVHO I think it would be better to have them be one type and let the user static_cast the pointer if they want something different.

If the difference is meaningful, maybe another overload should be added in P1144R3. Otherwise, I think combining them and using relocate_at is a good idea.

[• Quuxplusone]

include/memory

3518 ↗

(On Diff #199160)

I think I don't understand what you thought I meant. :)
By "homogeneous" relocate_at, I mean it can only relocate from T to that same type T (not even with different cv-qualifiers). As opposed to uninitialized_relocate, which is heterogeneous just like uninitialized_move and std::copy. For example:

long *src;
double *dest;
std::uninitialized_relocate(src, src+n, dest);  // OK
std::relocate_at(src, dest);  // not OK, because the types differ
std::__relocate_at2(src, dest);  // OK

The above case uses a non-trivial relocation operation.

int *src;
std::unique_ptr<int> *dest;
std::uninitialized_relocate(src, src+n, dest);  // OK
std::relocate_at(src, dest);  // not OK, because the types differ
std::__relocate_at2(src, dest);  // OK

The above case is functionally equivalent to memcpy, although this patch won't go so far as to actually make it use memcpy.

[zoecarver]

include/memory

3518 ↗

(On Diff #199160)

I understand what you meant. I think it is important that (for the most part) pointer functions are "homogeneous", especially the ones that rely on sizeof.

Here is an example of what I mean:

template<class T>
void cpy(T* dst, T* src)
{
	std::memcpy(dst, src, sizeof(T));
}

int main()
{
	int x = 42;
	int* iptr = &x;
	void* vptr = &x;
	cpy(iptr, vptr); // fails
	cpy(iptr, static_cast<int*>(vptr)); // works
}

The above function will prevent easy run time out of bounds errors from differently sized types.

[ldionne]

Context for other reviewers:

I spoke to Arthur at C++Now after his talk, and my opinion was that it would be useful to implement the trivially relocatable proposal as a conforming extension to libc++ to allow gathering some usage experience. However, I am dead against making any change that is user visible. So what I would like is for us to implement the traits and algorithms but use reserved identifiers -- this way we can implement optimizations inside the library without changing the user-visible API. And if the proposal never makes it into C++, we could even remove everything that has to do with trivially relocatable since it was only an internal optimization anyway -- that's the spirit.

Y'all know I'm against extensions, however I think gathering usage experience is useful and this is an opportunity to do so without making user-visible changes, which is one case where I think extensions are easy to sell. Please LMK if you disagree, otherwise I told Arthur I would help shepherd the patch through (the libc++ part).

• hide names? how?

Use __libcpp_xxx or whatever scheme you like. Those are implementation details anyway, we can change them as we see fit.

• any reason to gate the new names on any particular _LIBCPP_STD_VER, such as 17? (I think not.)

Good question. On the one hand, you want to get as much usage experience as possible, so that would mean enabling it on the oldest possible standard. On the other hand, once (if) the proposal makes it into C++, we won't want to implement the functionality in older standards. But removing the optimizations from C++03 will cause regressions, which is bad.

• split up the tests for uninitialized_relocate{,_n} into three or four files each?

The tests look reasonable to me as-is. However, they should all be in test/libcxx/ because they are libc++ specific.

• write a test for relocate_at

Please do.

[ldionne]

Requesting change so it shows up properly in my review queue.

[• Quuxplusone]

• Hide all the P1144 names consistently behind a __libcpp_ prefix.
• Add a unit test for __libcpp_relocate_at.
• Use remove_all_extents in the fallback implementation of is_trivially_relocatable<T>, so that is_trivially_relocatable_v<int[10]> will be true. (is_trivially_relocatable_v<int[]> currently has UB according to P1144, because int[] is an incomplete type.)

[• Quuxplusone]

@ldionne I've adopted your request to hide all the new names behind __libcpp_.
I think I still need some guidance on how to structure the tests so that they pass with a D50119-enabled Clang and {either pass or are XFAILed} for other compilers.

[• Quuxplusone]

Rebased on master. (I don't think I've made any changes since last time.)

[• Quuxplusone]

Rebased on master.

[• Quuxplusone]

Migrate to the monorepo.
@ldionne @EricWF ping?

[philnik]

[Github PR transition cleanup]

I'm commandeering and abandoning this, since this has been stale for quite a while and we probably won't implement it in this way unless it becomes standard. (Also, Arthur probably won't work on it)

libcxx/include/memory

 #ifndef _LIBCPP_NO_EXCEPTIONS
     } catch (...) {
         _VSTD::destroy(__first_res, __idx);
         throw;
     }
 #endif
 }
 
+// __libcpp_relocate_at
+
+template<class _St, class _Dt>
+inline _LIBCPP_INLINE_VISIBILITY
+_Dt *__relocate_at2_impl(_St *__source, _Dt *__dest, false_type) {
+    __dest = ::new (static_cast<void*>(__dest)) _Dt(_VSTD::move(*__source));
+    __source->~_St();
+    return __dest;
+}
+
+template<class _St, class _Dt>
+inline _LIBCPP_INLINE_VISIBILITY
+_Dt *__relocate_at2_impl(_St *__source, _Dt *__dest, true_type) {
+    _VSTD::memmove(__dest, __source, sizeof (_St));
+    return _VSTD::__launder(__dest);
+}
+
+template<class _St, class _Dt>
+inline _LIBCPP_INLINE_VISIBILITY
+_Dt *__relocate_at2(_St *__source, _Dt *__dest) {
+    using _ViaMemcpy = integral_constant<bool,
+        __is_same_uncvref<_St, _Dt>::value &&
+        __libcpp_is_trivially_relocatable<typename __uncvref<_Dt>::type>::value &&
+        !is_volatile<_St>::value && !is_volatile<_Dt>::value
+    >;
+    return _VSTD::__relocate_at2_impl(__source, __dest, _ViaMemcpy());
+}
+
+template<class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY
+_Tp *__libcpp_relocate_at(_Tp *__source, _Tp *__dest) {
+    return _VSTD::__relocate_at2(__source, __dest);
+}
+
+// __libcpp_uninitialized_relocate
+
+template<class _ForwardIt1, class _ForwardIt2>
+inline _LIBCPP_INLINE_VISIBILITY
+_ForwardIt2
+__uninitialized_relocate_impl(_ForwardIt1 __first, _ForwardIt1 __last,
+                              _ForwardIt2 __result, false_type, false_type)
+{
+    __result = _VSTD::uninitialized_move(__first, __last, __result);
+    _VSTD::destroy(__first, __last);
+    return __result;
+}
+
+template<class _ForwardIt1, class _ForwardIt2>
+inline _LIBCPP_INLINE_VISIBILITY
+_ForwardIt2
+__uninitialized_relocate_impl(_ForwardIt1 __first, _ForwardIt1 __last,
+                              _ForwardIt2 __result, false_type, true_type)
+{
+    for (; __first != __last; ++__result, void(), ++__first) {
+        _VSTD::__relocate_at2(_VSTD::addressof(*__first), _VSTD::addressof(*__result));
+    }
+    return __result;
+}
+
+template<class _ForwardIt1, class _ForwardIt2, class _RelocateInALoop>
+inline _LIBCPP_INLINE_VISIBILITY
+_ForwardIt2
+__uninitialized_relocate_impl(_ForwardIt1 __first, _ForwardIt1 __last,
+                              _ForwardIt2 __result, true_type, _RelocateInALoop)
+{
+    using _Dt = typename iterator_traits<_ForwardIt2>::value_type;
+    auto __count = __last - __first;
+    if (__count != 0) {
+        _VSTD::memmove(_VSTD::addressof(*__result), _VSTD::addressof(*__first), __count * sizeof (_Dt));
+        __result += __count;
+    }
+    return __result;
+}
+
+template<class _ForwardIt1, class _ForwardIt2>
+inline _LIBCPP_INLINE_VISIBILITY
+_ForwardIt2
+__libcpp_uninitialized_relocate(_ForwardIt1 __first, _ForwardIt1 __last,
+                       _ForwardIt2 __result)
+{
+    using _St = typename remove_reference<decltype(_VSTD::move(*__first))>::type;
+    using _Dt = typename remove_reference<typename iterator_traits<_ForwardIt2>::value_type>::type;
+    using _ElementTypeIsMemcpyable = integral_constant<bool,
+        __is_same_uncvref<_St, _Dt>::value &&
+        __libcpp_is_trivially_relocatable<typename __uncvref<_Dt>::type>::value &&
+        !is_volatile<_St>::value && !is_volatile<_Dt>::value
+    >;
+    using _SingleMemcpy = integral_constant<bool,
+        _ElementTypeIsMemcpyable::value &&
+        is_pointer<_ForwardIt1>::value &&
+        is_pointer<_ForwardIt2>::value
+    >;
+    using _RelocateInALoop = integral_constant<bool,
+        _ElementTypeIsMemcpyable::value ||
+        is_nothrow_constructible<_Dt, decltype(_VSTD::move(*__first))>::value
+    >;
+    return _VSTD::__uninitialized_relocate_impl(__first, __last, __result,
+        _SingleMemcpy(), _RelocateInALoop());
+}
+
+// __libcpp_uninitialized_relocate_n
+
+template<class _ForwardIt1, class _Size, class _ForwardIt2>
+inline _LIBCPP_INLINE_VISIBILITY
+pair<_ForwardIt1, _ForwardIt2>
+__uninitialized_relocate_n_impl(_ForwardIt1 __first, _Size __n,
+                                _ForwardIt2 __result, false_type, false_type)
+{
+    pair<_ForwardIt1, _ForwardIt2> __pair = _VSTD::uninitialized_move_n(__first, __n, __result);
+    _VSTD::destroy_n(__first, __n);
+    return __pair;
+}
+
+template<class _ForwardIt1, class _Size, class _ForwardIt2>
+inline _LIBCPP_INLINE_VISIBILITY
+pair<_ForwardIt1, _ForwardIt2>
+__uninitialized_relocate_n_impl(_ForwardIt1 __first, _Size __n,
+                                _ForwardIt2 __result, false_type, true_type)
+{
+    for (; __n > 0; ++__result, ++__first, void(), --__n) {
+        _VSTD::__relocate_at2(_VSTD::addressof(*__first), _VSTD::addressof(*__result));
+    }
+    return {__first, __result};
+}
+
+template<class _ForwardIt1, class _Size, class _ForwardIt2, class _RelocateInALoop>
+inline _LIBCPP_INLINE_VISIBILITY
+pair<_ForwardIt1, _ForwardIt2>
+__uninitialized_relocate_n_impl(_ForwardIt1 __first, _Size __n,
+                                _ForwardIt2 __result, true_type, _RelocateInALoop)
+{
+    using _Dt = typename iterator_traits<_ForwardIt2>::value_type;
+    if (__n != 0) {
+        _VSTD::memmove(_VSTD::addressof(*__result), _VSTD::addressof(*__first), __n * sizeof (_Dt));
+        __first += __n;
+        __result += __n;
+    }
+    return {__first, __result};
+}
+
+template<class _ForwardIt1, class _Size, class _ForwardIt2>
+inline _LIBCPP_INLINE_VISIBILITY
+pair<_ForwardIt1, _ForwardIt2>
+__libcpp_uninitialized_relocate_n(_ForwardIt1 __first, _Size __n, _ForwardIt2 __result)
+{
+    using _St = typename remove_reference<decltype(_VSTD::move(*__first))>::type;
+    using _Dt = typename remove_reference<typename iterator_traits<_ForwardIt2>::value_type>::type;
+    using _ElementTypeIsMemcpyable = integral_constant<bool,
+        __is_same_uncvref<_St, _Dt>::value &&
+        __libcpp_is_trivially_relocatable<typename __uncvref<_Dt>::type>::value &&
+        !is_volatile<_St>::value && !is_volatile<_Dt>::value
+    >;
+    using _SingleMemcpy = integral_constant<bool,
+        _ElementTypeIsMemcpyable::value &&
+        is_pointer<_ForwardIt1>::value &&
+        is_pointer<_ForwardIt2>::value
+    >;
+    using _RelocateInALoop = integral_constant<bool,
+        _ElementTypeIsMemcpyable::value ||
+        is_nothrow_constructible<_Dt, decltype(_VSTD::move(*__first))>::value
+    >;
+    return _VSTD::__uninitialized_relocate_n_impl(__first, __n, __result,
+        _SingleMemcpy(), _RelocateInALoop());
+}
 
 #endif // _LIBCPP_STD_VER > 14
 
 // NOTE: Relaxed and acq/rel atomics (for increment and decrement respectively)
 // should be sufficient for thread safety.
 // See https://bugs.llvm.org/show_bug.cgi?id=22803
 #if defined(__clang__) && __has_builtin(__atomic_add_fetch)          \
                        && defined(__ATOMIC_RELAXED)                  \

libcxx/include/type_traits

     template <class T, class... Args> struct is_trivially_constructible;
     template <class T>                struct is_trivially_default_constructible;
     template <class T>                struct is_trivially_copy_constructible;
     template <class T>                struct is_trivially_move_constructible;
     template <class T, class U>       struct is_trivially_assignable;
     template <class T>                struct is_trivially_copy_assignable;
     template <class T>                struct is_trivially_move_assignable;
     template <class T>                struct is_trivially_destructible;
+    template <class T>                struct __libcpp_is_trivially_relocatable;  // extension
 
     template <class T, class... Args> struct is_nothrow_constructible;
     template <class T>                struct is_nothrow_default_constructible;
     template <class T>                struct is_nothrow_copy_constructible;
     template <class T>                struct is_nothrow_move_constructible;
     template <class T, class U>       struct is_nothrow_assignable;
     template <class T>                struct is_nothrow_copy_assignable;
     template <class T>                struct is_nothrow_move_assignable;

       template <class T, class U> inline constexpr bool is_trivially_assignable_v
         = is_trivially_assignable<T, U>::value;                          // C++17
       template <class T> inline constexpr bool is_trivially_copy_assignable_v
         = is_trivially_copy_assignable<T>::value;                        // C++17
       template <class T> inline constexpr bool is_trivially_move_assignable_v
         = is_trivially_move_assignable<T>::value;                        // C++17
       template <class T> inline constexpr bool is_trivially_destructible_v
         = is_trivially_destructible<T>::value;                           // C++17
+      template <class T> inline constexpr bool __libcpp_is_trivially_relocatable_v
+        = __libcpp_is_trivially_relocatable<T>::value;                   // extension
       template <class T, class... Args> inline constexpr bool is_nothrow_constructible_v
         = is_nothrow_constructible<T, Args...>::value;                   // C++17
       template <class T> inline constexpr bool is_nothrow_default_constructible_v
         = is_nothrow_default_constructible<T>::value;                    // C++17
       template <class T> inline constexpr bool is_nothrow_copy_constructible_v
         = is_nothrow_copy_constructible<T>::value;                       // C++17
       template <class T> inline constexpr bool is_nothrow_move_constructible_v
         = is_nothrow_move_constructible<T>::value;                       // C++17

 #endif
 
 #if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
 template <class _Tp>
 _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_trivially_destructible_v
     = is_trivially_destructible<_Tp>::value;
 #endif
 
+// __libcpp_is_trivially_relocatable
+
+template <class _Tp>
+struct _LIBCPP_TEMPLATE_VIS __libcpp_is_trivially_relocatable
+    : public integral_constant<bool,
+#if __has_extension(trivially_relocatable)
+    __is_trivially_relocatable(_Tp)
+#else
+    is_trivially_move_constructible<typename remove_all_extents<_Tp>::type>::value &&
+    is_trivially_destructible<typename remove_all_extents<_Tp>::type>::value
+#endif
+    > {};
+
+#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
+template <class _Tp>
+_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool __libcpp_is_trivially_relocatable_v
+    = __libcpp_is_trivially_relocatable<_Tp>::value;
+#endif
+
 // is_nothrow_constructible
 
 #if __has_keyword(__is_nothrow_constructible)
 
 template <class _Tp, class... _Args>
 struct _LIBCPP_TEMPLATE_VIS is_nothrow_constructible
     : public integral_constant<bool, __is_nothrow_constructible(_Tp, _Args...)> {};
 

libcxx/test/libcxx/type_traits/is_trivially_relocatable.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// UNSUPPORTED: c++98, c++03, c++11, c++14
+//
+// <type_traits>
+//
+// Test that many standard types are trivially relocatable.
+
+#include <any>
+#include <array>
+#include <atomic>
+#include <bitset>
+#include <chrono>
+#include <condition_variable>
+#include <deque>
+#include <forward_list>
+#include <functional>
+#include <future>
+#include <initializer_list>
+#include <ios>
+#include <iterator>
+#include <list>
+#include <locale>
+#include <map>
+#include <memory>
+//#include <memory_resource>
+#include <mutex>
+#include <optional>
+#include <queue>
+#include <random>
+#include <ratio>
+#include <regex>
+#include <set>
+#include <shared_mutex>
+#include <stack>
+#include <string>
+#include <string_view>
+#include <system_error>
+#include <thread>
+#include <tuple>
+#include <typeindex>
+#include <type_traits>
+#include <unordered_map>
+#include <unordered_set>
+#include <utility>
+#include <variant>
+#include <vector>
+
+
+struct T { T(); T(const T&); ~T(); };
+struct R { };
+struct SM { void lock_shared(); void unlock_shared(); ~SM(); };
+
+struct K {
+    T t;
+    bool operator==(const K&) const;
+    bool operator< (const K&) const;
+};
+template<> struct std::hash<K> { size_t operator()(const K&) const; };
+
+static const bool NotDebug =
+#if _LIBCPP_DEBUG_LEVEL >= 2
+    false;
+#else
+    true;
+#endif
+
+// Define this name for convenience.
+#define is_trivially_relocatable __libcpp_is_trivially_relocatable
+
+static_assert(std::is_trivially_relocatable<R>::value, "");
+static_assert(!std::is_trivially_relocatable<T>::value, "");
+static_assert(std::is_trivially_relocatable<T*>::value, "");
+static_assert(std::is_trivially_relocatable<std::reference_wrapper<T>>::value, "");
+static_assert(std::is_trivially_relocatable<std::initializer_list<T>>::value, "");
+static_assert(std::is_trivially_relocatable<std::allocator<T>>::value, "");
+//static_assert(std::is_trivially_relocatable<std::pmr::polymorphic_allocator<T>>::value, "");
+static_assert(std::is_trivially_relocatable<std::default_delete<T>>::value, "");
+static_assert(std::is_trivially_relocatable<std::hash<std::string>>::value, "");
+static_assert(std::is_trivially_relocatable<std::less<T>>::value, "");
+static_assert(std::is_trivially_relocatable<std::less<void>>::value, "");
+static_assert(!std::is_trivially_relocatable<std::unique_ptr<T>>::value, "");
+static_assert(!std::is_trivially_relocatable<std::shared_ptr<T>>::value, "");
+static_assert(!std::is_trivially_relocatable<std::weak_ptr<T>>::value, "");
+static_assert(std::is_trivially_relocatable<std::pair<R,R>>::value, "");
+static_assert(!std::is_trivially_relocatable<std::pair<R,T>>::value, "");
+static_assert(std::is_trivially_relocatable<std::tuple<R,R,R>>::value, "");
+static_assert(!std::is_trivially_relocatable<std::tuple<R,T,R>>::value, "");
+static_assert(std::is_trivially_relocatable<std::variant<R,R,R>>::value, "");
+static_assert(!std::is_trivially_relocatable<std::variant<R,T,R>>::value, "");
+static_assert(std::is_trivially_relocatable<std::optional<R>>::value, "");
+static_assert(!std::is_trivially_relocatable<std::optional<T>>::value, "");
+static_assert(!std::is_trivially_relocatable<std::any>::value, "");
+static_assert(!std::is_trivially_relocatable<std::locale>::value, "");
+static_assert(!std::is_trivially_relocatable<std::exception_ptr>::value, "");
+static_assert(!std::is_trivially_relocatable<std::exception>::value, "");
+static_assert(!std::is_trivially_relocatable<std::error_category>::value, "");
+static_assert(std::is_trivially_relocatable<std::error_code>::value, "");
+static_assert(std::is_trivially_relocatable<std::error_condition>::value, "");
+static_assert(std::is_trivially_relocatable<std::errc>::value, "");
+static_assert(std::is_trivially_relocatable<std::type_index>::value, "");
+static_assert(std::is_trivially_relocatable<std::array<R, 5>>::value, "");
+static_assert(!std::is_trivially_relocatable<std::array<T, 5>>::value, "");
+static_assert(!std::is_trivially_relocatable<std::deque<T>>::value, "");
+static_assert(!std::is_trivially_relocatable<std::forward_list<T>>::value, "");
+static_assert(!std::is_trivially_relocatable<std::list<T>>::value, "");
+static_assert(!std::is_trivially_relocatable<std::map<K,T>>::value, "");
+static_assert(!std::is_trivially_relocatable<std::multimap<K,T>>::value, "");
+static_assert(!std::is_trivially_relocatable<std::multiset<K>>::value, "");
+static_assert(!std::is_trivially_relocatable<std::set<K>>::value, "");
+static_assert(!std::is_trivially_relocatable<std::unordered_map<K,T>>::value, "");
+static_assert(!std::is_trivially_relocatable<std::unordered_multimap<K,T>>::value, "");
+static_assert(!std::is_trivially_relocatable<std::unordered_multiset<K>>::value, "");
+static_assert(!std::is_trivially_relocatable<std::unordered_set<K>>::value, "");
+static_assert(!std::is_trivially_relocatable<std::vector<T>>::value, "");
+static_assert(!std::is_trivially_relocatable<std::vector<bool>>::value, "");
+static_assert(!std::is_trivially_relocatable<std::stack<T>>::value, "");
+static_assert(!std::is_trivially_relocatable<std::queue<T>>::value, "");
+static_assert(!std::is_trivially_relocatable<std::priority_queue<T>>::value, "");
+//static_assert(std::is_trivially_relocatable<std::pmr::deque<T>>::value, "");
+//static_assert(std::is_trivially_relocatable<std::pmr::forward_list<T>>::value, "");
+//static_assert(!std::is_trivially_relocatable<std::pmr::list<T>>::value, "");
+//static_assert(!std::is_trivially_relocatable<std::pmr::map<K,T>>::value, "");
+//static_assert(!std::is_trivially_relocatable<std::pmr::multimap<K,T>>::value, "");
+//static_assert(!std::is_trivially_relocatable<std::pmr::multiset<K>>::value, "");
+//static_assert(!std::is_trivially_relocatable<std::pmr::set<K>>::value, "");
+//static_assert(std::is_trivially_relocatable<std::pmr::unordered_map<K,T>>::value == NotDebug, "");
+//static_assert(std::is_trivially_relocatable<std::pmr::unordered_multimap<K,T>>::value == NotDebug, "");
+//static_assert(std::is_trivially_relocatable<std::pmr::unordered_multiset<K>>::value == NotDebug, "");
+//static_assert(std::is_trivially_relocatable<std::pmr::unordered_set<K>>::value == NotDebug, "");
+//static_assert(std::is_trivially_relocatable<std::pmr::vector<T>>::value == NotDebug, "");
+//static_assert(std::is_trivially_relocatable<std::pmr::vector<bool>>::value, "");
+static_assert(std::is_trivially_relocatable<std::array<R, 5>::iterator>::value, "");
+static_assert(std::is_trivially_relocatable<std::array<T, 5>::iterator>::value, "");
+static_assert(std::is_trivially_relocatable<std::deque<T>::iterator>::value, "");
+static_assert(std::is_trivially_relocatable<std::forward_list<T>::iterator>::value, "");
+static_assert(std::is_trivially_relocatable<std::list<T>::iterator>::value == NotDebug, "");
+static_assert(std::is_trivially_relocatable<std::map<K,T>::iterator>::value, "");
+static_assert(std::is_trivially_relocatable<std::multimap<K,T>::iterator>::value, "");
+static_assert(std::is_trivially_relocatable<std::multiset<K>::iterator>::value, "");
+static_assert(std::is_trivially_relocatable<std::set<K>::iterator>::value, "");
+static_assert(std::is_trivially_relocatable<std::unordered_map<K,T>::iterator>::value == NotDebug, "");
+static_assert(std::is_trivially_relocatable<std::unordered_multimap<K,T>::iterator>::value == NotDebug, "");
+static_assert(std::is_trivially_relocatable<std::unordered_multiset<K>::iterator>::value == NotDebug, "");
+static_assert(std::is_trivially_relocatable<std::unordered_set<K>::iterator>::value == NotDebug, "");
+static_assert(std::is_trivially_relocatable<std::unordered_map<K,T>::local_iterator>::value == NotDebug, "");
+static_assert(std::is_trivially_relocatable<std::unordered_multimap<K,T>::local_iterator>::value == NotDebug, "");
+static_assert(std::is_trivially_relocatable<std::unordered_multiset<K>::local_iterator>::value == NotDebug, "");
+static_assert(std::is_trivially_relocatable<std::unordered_set<K>::local_iterator>::value == NotDebug, "");
+static_assert(std::is_trivially_relocatable<std::vector<T>::iterator>::value == NotDebug, "");
+static_assert(std::is_trivially_relocatable<std::vector<T>::const_iterator>::value == NotDebug, "");
+static_assert(std::is_trivially_relocatable<std::vector<bool>::iterator>::value, "");
+static_assert(std::is_trivially_relocatable<std::vector<bool>::const_iterator>::value, "");
+static_assert(std::is_trivially_relocatable<std::reverse_iterator<int*>>::value, "");
+static_assert(std::is_trivially_relocatable<std::back_insert_iterator<std::deque<int>>>::value, "");
+static_assert(std::is_trivially_relocatable<std::front_insert_iterator<std::list<int>>>::value, "");
+static_assert(std::is_trivially_relocatable<std::insert_iterator<std::vector<int>>>::value == NotDebug, "");
+static_assert(std::is_trivially_relocatable<std::insert_iterator<std::vector<bool>>>::value, "");
+static_assert(std::is_trivially_relocatable<std::istream_iterator<R>>::value, "");
+static_assert(!std::is_trivially_relocatable<std::istream_iterator<T>>::value, "");
+static_assert(std::is_trivially_relocatable<std::ostream_iterator<R>>::value, "");
+static_assert(std::is_trivially_relocatable<std::ostream_iterator<T>>::value, "");
+static_assert(std::is_trivially_relocatable<std::char_traits<char>>::value, "");
+static_assert(!std::is_trivially_relocatable<std::regex_traits<char>>::value, "");
+static_assert(!std::is_trivially_relocatable<std::regex>::value, "");
+static_assert(!std::is_trivially_relocatable<std::cmatch>::value, "");  // because it uses vector internally
+static_assert(!std::is_trivially_relocatable<std::smatch>::value, "");  // because it uses vector internally
+static_assert(!std::is_trivially_relocatable<std::string>::value, "");
+static_assert(std::is_trivially_relocatable<std::string::iterator>::value == NotDebug, "");
+static_assert(!std::is_trivially_relocatable<std::wstring>::value, "");
+static_assert(std::is_trivially_relocatable<std::wstring::iterator>::value == NotDebug, "");
+//static_assert(std::is_trivially_relocatable<std::pmr::cmatch>::value == NotDebug, "");  // because it uses vector internally
+//static_assert(std::is_trivially_relocatable<std::pmr::smatch>::value == NotDebug, "");  // because it uses vector internally
+//static_assert(std::is_trivially_relocatable<std::pmr::string>::value == NotDebug, "");
+//static_assert(std::is_trivially_relocatable<std::pmr::string::iterator>::value == NotDebug, "");
+//static_assert(std::is_trivially_relocatable<std::pmr::wstring>::value == NotDebug, "");
+//static_assert(std::is_trivially_relocatable<std::pmr::wstring::iterator>::value == NotDebug, "");
+static_assert(std::is_trivially_relocatable<std::integral_constant<int, 42>>::value, "");
+static_assert(std::is_trivially_relocatable<std::index_sequence<1,2,3,4>>::value, "");
+static_assert(std::is_trivially_relocatable<std::ratio<1, 2>>::value, "");
+static_assert(std::is_trivially_relocatable<std::chrono::system_clock::duration>::value, "");
+static_assert(std::is_trivially_relocatable<std::chrono::system_clock::time_point>::value, "");
+static_assert(std::is_trivially_relocatable<std::streampos>::value, "");
+static_assert(std::is_trivially_relocatable<std::bitset<42>>::value, "");
+static_assert(std::is_trivially_relocatable<std::bitset<420>>::value, "");
+static_assert(!std::is_trivially_relocatable<std::unique_lock<std::mutex>>::value, "");
+static_assert(!std::is_trivially_relocatable<std::shared_lock<SM>>::value, "");
+static_assert(!std::is_trivially_relocatable<std::thread>::value, "");
+static_assert(std::is_trivially_relocatable<std::thread::id>::value, "");
+static_assert(!std::is_trivially_relocatable<std::promise<T>>::value, "");
+static_assert(!std::is_trivially_relocatable<std::promise<T&>>::value, "");
+static_assert(!std::is_trivially_relocatable<std::promise<void>>::value, "");
+static_assert(!std::is_trivially_relocatable<std::future<T>>::value, "");
+static_assert(!std::is_trivially_relocatable<std::future<T&>>::value, "");
+static_assert(!std::is_trivially_relocatable<std::future<void>>::value, "");
+static_assert(!std::is_trivially_relocatable<std::shared_future<T>>::value, "");
+static_assert(!std::is_trivially_relocatable<std::shared_future<T&>>::value, "");
+static_assert(!std::is_trivially_relocatable<std::shared_future<void>>::value, "");
+static_assert(!std::is_trivially_relocatable<std::function<void()>>::value, "");  // contains pointer into self
+static_assert(!std::is_trivially_relocatable<std::packaged_task<T(T)>>::value, "");  // contains pointer into self
+static_assert(!std::is_trivially_relocatable<std::packaged_task<T&(T)>>::value, "");  // contains pointer into self
+static_assert(!std::is_trivially_relocatable<std::packaged_task<void(T)>>::value, "");  // contains pointer into self
+
+// The following types are not move-constructible at all.
+static_assert(!std::is_trivially_relocatable<std::atomic<int>>::value, "");
+static_assert(!std::is_trivially_relocatable<std::atomic_flag>::value, "");
+static_assert(!std::is_trivially_relocatable<std::condition_variable>::value, "");
+static_assert(!std::is_trivially_relocatable<std::condition_variable_any>::value, "");
+static_assert(!std::is_trivially_relocatable<std::lock_guard<std::mutex>>::value, "");
+static_assert(!std::is_trivially_relocatable<std::mutex>::value, "");
+static_assert(!std::is_trivially_relocatable<std::seed_seq>::value, "");
+
+int main(int, char**)
+{
+    return 0;
+}

libcxx/test/libcxx/utilities/memory/specialized.algorithms/specialized.relocate/relocate_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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03
+
+// <memory>
+
+// template <class _Tp>
+// void __libcpp_relocate_at(_Tp *source, _Tp *dest);
+
+#include <memory>
+#include <cstdlib>
+#include <cassert>
+
+struct Counted {
+  static int count;
+  int m_data;
+  Counted(int i) : m_data(i) { ++count; }
+  Counted(Counted&& rhs) : m_data(rhs.m_data) { rhs.m_data = 0; ++count; }
+  ~Counted() { --count; }
+  friend void operator&(Counted) = delete;
+};
+int Counted::count = 0;
+
+#ifdef _LIBCPP_TRIVIALLY_RELOCATABLE
+struct _LIBCPP_TRIVIALLY_RELOCATABLE RCounted {
+#else
+struct RCounted {
+#endif
+  static int count;
+  int m_data;
+  RCounted(int i) : m_data(i) { ++count; }
+  RCounted(RCounted const& rhs) : m_data(rhs.m_data) { ++count; }
+  ~RCounted() { --count; }
+  friend void operator&(RCounted) = delete;
+};
+int RCounted::count = 0;
+
+int main(int, char**)
+{
+    {
+    void *mem1 = std::malloc(sizeof(Counted));
+    void *mem2 = std::malloc(sizeof(Counted));
+    assert(mem1 && mem2);
+    assert(Counted::count == 0);
+    Counted *ptr1 = ::new (mem1) Counted(1234);
+    Counted *ptr2 = static_cast<Counted*>(mem2);
+    assert(Counted::count == 1);
+    std::__libcpp_relocate_at(ptr1, ptr2);
+    assert(Counted::count == 1);
+    assert(ptr2->m_data == 1234);
+    ptr2->~Counted();
+    std::free(mem1);
+    std::free(mem2);
+    }
+
+    {
+    void *mem1 = std::malloc(sizeof(RCounted));
+    void *mem2 = std::malloc(sizeof(RCounted));
+    assert(mem1 && mem2);
+    assert(RCounted::count == 0);
+    RCounted *ptr1 = ::new (mem1) RCounted(5678);
+    RCounted *ptr2 = static_cast<RCounted*>(mem2);
+    assert(RCounted::count == 1);
+    std::__libcpp_relocate_at(ptr1, ptr2);
+    assert(RCounted::count == 1);
+    assert(ptr2->m_data == 5678);
+    ptr2->~RCounted();
+    std::free(mem1);
+    std::free(mem2);
+    }
+
+    return 0;
+}

libcxx/test/libcxx/utilities/memory/specialized.algorithms/uninitialized.relocate/uninitialized_relocate.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14
+
+// <memory>
+
+// template <class InputIt, class ForwardIt>
+// ForwardIt __libcpp_uninitialized_relocate(InputIt, InputIt, ForwardIt);
+
+#include <iterator>
+#include <memory>
+#include <cstdlib>
+#include <cassert>
+
+#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; }
+    Counted(Counted const&) { assert(false); }
+    ~Counted() { assert(count > 0); --count; }
+    friend void operator&(Counted) = delete;
+    int value;
+};
+int Counted::count = 0;
+int Counted::constructed = 0;
+
+struct ThrowsCounted {
+    static int count;
+    static int constructed;
+    static int throw_after;
+    static void reset() { throw_after = count = constructed = 0; }
+    explicit ThrowsCounted(int&& x) {
+        ++constructed;
+        if (throw_after > 0 && --throw_after == 0) {
+            TEST_THROW(1);
+        }
+        ++count;
+        x = 0;
+    }
+    ThrowsCounted(ThrowsCounted const&) { assert(false); }
+    ~ThrowsCounted() { assert(count > 0); --count; }
+    friend void operator&(ThrowsCounted) = delete;
+};
+int ThrowsCounted::count = 0;
+int ThrowsCounted::constructed = 0;
+int ThrowsCounted::throw_after = 0;
+
+void test_ctor_throws()
+{
+#ifndef TEST_HAS_NO_EXCEPTIONS
+    using It = forward_iterator<ThrowsCounted*>;
+    const int N = 5;
+    int values[N] = {1, 2, 3, 4, 5};
+    alignas(ThrowsCounted) char pool[sizeof(ThrowsCounted)*N] = {};
+    ThrowsCounted* p = (ThrowsCounted*)pool;
+    try {
+        ThrowsCounted::throw_after = 4;
+        std::__libcpp_uninitialized_relocate(values, values + N, It(p));
+        assert(false);
+    } catch (...) {}
+    assert(ThrowsCounted::count == 0);  // the ones constructed have been destroyed automatically
+    assert(ThrowsCounted::constructed == 4); // fourth construction throws
+    assert(values[0] == 0);
+    assert(values[1] == 0);
+    assert(values[2] == 0);
+    assert(values[3] == 4);
+    assert(values[4] == 5);
+#endif
+}
+
+void test_counted()
+{
+    using It = input_iterator<int*>;
+    using FIt = forward_iterator<Counted*>;
+    const int N = 5;
+    int values[N] = {1, 2, 3, 4, 5};
+    alignas(Counted) char pool[sizeof(Counted)*N] = {};
+    Counted* p = (Counted*)pool;
+    auto ret = std::__libcpp_uninitialized_relocate(It(values), It(values + 1), FIt(p));
+    assert(ret == FIt(p +1));
+    assert(Counted::constructed == 1);
+    assert(Counted::count == 1);
+    assert(p[0].value == 1);
+    assert(values[0] == 0);
+    ret = std::__libcpp_uninitialized_relocate(It(values+1), It(values+N), FIt(p+1));
+    assert(ret == FIt(p + N));
+    assert(Counted::count == 5);
+    assert(Counted::constructed == 5);
+    assert(p[1].value == 2);
+    assert(p[2].value == 3);
+    assert(p[3].value == 4);
+    assert(p[4].value == 5);
+    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);
+}
+
+void test_unique_ptr_forward()
+{
+    using T = std::unique_ptr<int>;
+    const int N = 5;
+    alignas(T) char sourcepool[sizeof(T) * N];
+    alignas(T) char destpool[sizeof(T) * N];
+    T *source = (T*)sourcepool;
+    T *dest = (T*)destpool;
+    for (int i=0; i < N; ++i) {
+        ::new ((void*)&source[i]) T(std::make_unique<int>(i));
+    }
+    auto result = std::__libcpp_uninitialized_relocate(source, source + 3, dest);
+    assert(result == dest + 3);
+    assert(*dest[0] == 0);
+    assert(*dest[1] == 1);
+    assert(*dest[2] == 2);
+    assert(*source[3] == 3);
+    assert(*source[4] == 4);
+    std::destroy(dest, dest + 3);
+    std::destroy(source + 3, source + N);
+}
+
+void test_unique_ptr_backward()
+{
+    using T = std::unique_ptr<int>;
+    const int N = 5;
+    alignas(T) char sourcepool[sizeof(T) * N];
+    alignas(T) char destpool[sizeof(T) * N];
+    T *source = (T*)sourcepool;
+    T *dest = (T*)destpool;
+    for (int i=0; i < N; ++i) {
+        ::new ((void*)&source[i]) T(std::make_unique<int>(i));
+    }
+    auto result = std::__libcpp_uninitialized_relocate(
+        std::make_reverse_iterator(source + 3),
+        std::make_reverse_iterator(source), dest);
+    assert(result == dest + 3);
+    assert(*dest[0] == 2);
+    assert(*dest[1] == 1);
+    assert(*dest[2] == 0);
+    assert(*source[3] == 3);
+    assert(*source[4] == 4);
+    std::destroy(dest, dest + 3);
+    std::destroy(source + 3, source + N);
+}
+
+int main(int, char**)
+{
+    test_counted();
+    test_ctor_throws();
+    test_unique_ptr_forward();
+    test_unique_ptr_backward();
+    return 0;
+}

libcxx/test/libcxx/utilities/memory/specialized.algorithms/uninitialized.relocate/uninitialized_relocate_n.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14
+
+// <memory>
+
+// template <class InputIt, class Size, class ForwardIt>
+// pair<InputIt, ForwardIt> __libcpp_uninitialized_relocate_n(InputIt, Size, ForwardIt);
+
+#include <memory>
+#include <cstdlib>
+#include <cassert>
+
+#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; }
+    Counted(Counted const&) { assert(false); }
+    ~Counted() { assert(count > 0); --count; }
+    friend void operator&(Counted) = delete;
+    int value;
+};
+int Counted::count = 0;
+int Counted::constructed = 0;
+
+struct ThrowsCounted {
+    static int count;
+    static int constructed;
+    static int throw_after;
+    static void reset() { throw_after = count = constructed = 0; }
+    explicit ThrowsCounted(int&& x) {
+        ++constructed;
+        if (throw_after > 0 && --throw_after == 0) {
+            TEST_THROW(1);
+        }
+        ++count;
+        x = 0;
+    }
+    ThrowsCounted(ThrowsCounted const&) { assert(false); }
+    ~ThrowsCounted() { assert(count > 0); --count; }
+    friend void operator&(ThrowsCounted) = delete;
+};
+int ThrowsCounted::count = 0;
+int ThrowsCounted::constructed = 0;
+int ThrowsCounted::throw_after = 0;
+
+void test_ctor_throws()
+{
+#ifndef TEST_HAS_NO_EXCEPTIONS
+    using It = forward_iterator<ThrowsCounted*>;
+    const int N = 5;
+    int values[N] = {1, 2, 3, 4, 5};
+    alignas(ThrowsCounted) char pool[sizeof(ThrowsCounted)*N] = {};
+    ThrowsCounted* p = (ThrowsCounted*)pool;
+    try {
+        ThrowsCounted::throw_after = 4;
+        std::__libcpp_uninitialized_relocate_n(values, N, It(p));
+        assert(false);
+    } catch (...) {}
+    assert(ThrowsCounted::count == 0);  // the ones constructed have been destroyed automatically
+    assert(ThrowsCounted::constructed == 4); // fourth construction throws
+    assert(values[0] == 0);
+    assert(values[1] == 0);
+    assert(values[2] == 0);
+    assert(values[3] == 4);
+    assert(values[4] == 5);
+#endif
+}
+
+void test_counted()
+{
+    using It = input_iterator<int*>;
+    using FIt = forward_iterator<Counted*>;
+    const int N = 5;
+    int values[N] = {1, 2, 3, 4, 5};
+    alignas(Counted) char pool[sizeof(Counted)*N] = {};
+    Counted* p = (Counted*)pool;
+    auto ret = std::__libcpp_uninitialized_relocate_n(It(values), 1, FIt(p));
+    assert(ret.first == It(values+1));
+    assert(ret.second == FIt(p + 1));
+    assert(Counted::constructed == 1);
+    assert(Counted::count == 1);
+    assert(p[0].value == 1);
+    assert(values[0] == 0);
+    ret = std::__libcpp_uninitialized_relocate_n(It(values+1), N-1, FIt(p+1));
+    assert(ret.first == It(values+N));
+    assert(ret.second == FIt(p + N));
+    assert(Counted::count == 5);
+    assert(Counted::constructed == 5);
+    assert(p[1].value == 2);
+    assert(p[2].value == 3);
+    assert(p[3].value == 4);
+    assert(p[4].value == 5);
+    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);
+}
+
+void test_unique_ptr_forward()
+{
+    using T = std::unique_ptr<int>;
+    const int N = 5;
+    alignas(T) char sourcepool[sizeof(T) * N];
+    alignas(T) char destpool[sizeof(T) * N];
+    T *source = (T*)sourcepool;
+    T *dest = (T*)destpool;
+    for (int i=0; i < N; ++i) {
+        ::new ((void*)&source[i]) T(std::make_unique<int>(i));
+    }
+    auto result = std::__libcpp_uninitialized_relocate_n(source, 3, dest);
+    assert(result.first == source + 3);
+    assert(result.second == dest + 3);
+    assert(*dest[0] == 0);
+    assert(*dest[1] == 1);
+    assert(*dest[2] == 2);
+    assert(*source[3] == 3);
+    assert(*source[4] == 4);
+    std::destroy(dest, dest + 3);
+    std::destroy(source + 3, source + N);
+}
+
+void test_unique_ptr_backward()
+{
+    using T = std::unique_ptr<int>;
+    const int N = 5;
+    alignas(T) char sourcepool[sizeof(T) * N];
+    alignas(T) char destpool[sizeof(T) * N];
+    T *source = (T*)sourcepool;
+    T *dest = (T*)destpool;
+    for (int i=0; i < N; ++i) {
+        ::new ((void*)&source[i]) T(std::make_unique<int>(i));
+    }
+    auto result = std::__libcpp_uninitialized_relocate_n(
+        std::make_reverse_iterator(source + 3),
+        3, dest);
+    assert(result.first == std::make_reverse_iterator(source));
+    assert(result.second == dest + 3);
+    assert(*dest[0] == 2);
+    assert(*dest[1] == 1);
+    assert(*dest[2] == 0);
+    assert(*source[3] == 3);
+    assert(*source[4] == 4);
+    std::destroy(dest, dest + 3);
+    std::destroy(source + 3, source + N);
+}
+
+int main(int, char**)
+{
+    test_counted();
+    test_ctor_throws();
+    test_unique_ptr_forward();
+    test_unique_ptr_backward();
+    return 0;
+}

libcxx/test/libcxx/utilities/meta/meta.unary/meta.unary.prop/is_trivially_relocatable.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// type_traits
+
+// __libcpp_is_trivially_relocatable
+// __libcpp_is_trivially_relocatable_v
+
+// UNSUPPORTED: c++98, c++03
+// XFAIL: gcc-4.9
+
+#include <memory>
+#include <type_traits>
+#include "test_macros.h"
+
+
+template <class T>
+void test_is_trivially_relocatable()
+{
+    static_assert( std::__libcpp_is_trivially_relocatable<T>::value, "");
+#if TEST_STD_VER > 14
+    static_assert( std::__libcpp_is_trivially_relocatable_v<T>, "");
+#endif
+}
+
+template <class T>
+void test_is_not_trivially_relocatable()
+{
+    static_assert(!std::__libcpp_is_trivially_relocatable<T>::value, "");
+#if TEST_STD_VER > 14
+    static_assert(!std::__libcpp_is_trivially_relocatable_v<T>, "");
+#endif
+}
+
+class Empty
+{
+};
+
+class NotEmpty
+{
+public:
+    virtual ~NotEmpty();
+};
+
+union Union {};
+
+struct bit_zero
+{
+    int :  0;
+};
+
+class Abstract
+{
+public:
+    virtual ~Abstract() = 0;
+};
+
+struct A
+{
+    A(const A&);
+};
+
+#if TEST_STD_VER >= 11
+
+struct MoveOnly1
+{
+    MoveOnly1(MoveOnly1&&);
+};
+
+struct MoveOnly2
+{
+    MoveOnly2(MoveOnly2&&) = default;
+};
+#endif
+
+int main(int, char**)
+{
+    test_is_not_trivially_relocatable<void>();
+    test_is_not_trivially_relocatable<const void>();
+    test_is_not_trivially_relocatable<A>();
+    test_is_not_trivially_relocatable<Abstract>();
+    test_is_not_trivially_relocatable<NotEmpty>();
+
+    test_is_trivially_relocatable<Union>();
+    test_is_trivially_relocatable<Empty>();
+    test_is_trivially_relocatable<double>();
+    test_is_trivially_relocatable<int*>();
+    test_is_trivially_relocatable<const int*>();
+    test_is_trivially_relocatable<bit_zero>();
+
+    test_is_trivially_relocatable<int>();
+    test_is_trivially_relocatable<const int>();
+    test_is_trivially_relocatable<volatile int>();
+    test_is_trivially_relocatable<const volatile int>();
+
+    test_is_trivially_relocatable<int[]>();
+    test_is_trivially_relocatable<int[10]>();
+    test_is_trivially_relocatable<int[][2]>();
+    test_is_trivially_relocatable<int[1][2]>();
+
+#if TEST_STD_VER >= 11
+    test_is_not_trivially_relocatable<MoveOnly1>();
+    test_is_not_trivially_relocatable<const MoveOnly1>();
+    test_is_trivially_relocatable<MoveOnly2>();
+    test_is_trivially_relocatable<const MoveOnly2>();
+#endif
+
+    return 0;
+}