diff --git a/libcxx/include/memory b/libcxx/include/memory
--- a/libcxx/include/memory
+++ b/libcxx/include/memory
@@ -3353,6 +3353,170 @@
 #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
 
diff --git a/libcxx/include/type_traits b/libcxx/include/type_traits
--- a/libcxx/include/type_traits
+++ b/libcxx/include/type_traits
@@ -124,6 +124,7 @@
     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;
@@ -350,6 +351,8 @@
         = 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
@@ -3059,6 +3062,25 @@
     = 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)
diff --git a/libcxx/test/libcxx/type_traits/is_trivially_relocatable.pass.cpp b/libcxx/test/libcxx/type_traits/is_trivially_relocatable.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/libcxx/type_traits/is_trivially_relocatable.pass.cpp
@@ -0,0 +1,223 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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;
+}
diff --git a/libcxx/test/libcxx/utilities/memory/specialized.algorithms/specialized.relocate/relocate_at.pass.cpp b/libcxx/test/libcxx/utilities/memory/specialized.algorithms/specialized.relocate/relocate_at.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/libcxx/utilities/memory/specialized.algorithms/specialized.relocate/relocate_at.pass.cpp
@@ -0,0 +1,79 @@
+//===----------------------------------------------------------------------===//
+//
+// 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;
+}
diff --git a/libcxx/test/libcxx/utilities/memory/specialized.algorithms/uninitialized.relocate/uninitialized_relocate.pass.cpp b/libcxx/test/libcxx/utilities/memory/specialized.algorithms/uninitialized.relocate/uninitialized_relocate.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/libcxx/utilities/memory/specialized.algorithms/uninitialized.relocate/uninitialized_relocate.pass.cpp
@@ -0,0 +1,165 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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;
+}
diff --git a/libcxx/test/libcxx/utilities/memory/specialized.algorithms/uninitialized.relocate/uninitialized_relocate_n.pass.cpp b/libcxx/test/libcxx/utilities/memory/specialized.algorithms/uninitialized.relocate/uninitialized_relocate_n.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/libcxx/utilities/memory/specialized.algorithms/uninitialized.relocate/uninitialized_relocate_n.pass.cpp
@@ -0,0 +1,168 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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;
+}
diff --git a/libcxx/test/libcxx/utilities/meta/meta.unary/meta.unary.prop/is_trivially_relocatable.pass.cpp b/libcxx/test/libcxx/utilities/meta/meta.unary/meta.unary.prop/is_trivially_relocatable.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/libcxx/utilities/meta/meta.unary/meta.unary.prop/is_trivially_relocatable.pass.cpp
@@ -0,0 +1,115 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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;
+}