P1144 "Trivially relocatable" (2/3): explicit warrants for std library types

[Mordante]

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 patch has no ABI implications (or if it does, that's a bug, please tell me about it). This patch doesn't do any special optimizations (e.g. to std::vector::reserve); those will come in part 3/3.

TODO:

• how should the new tests be guarded so that they don't fail on compilers lacking __has_extension(__is_trivially_relocatable)?
• I made std::vector<bool>::__storage_pointer a public member; I don't know if this is acceptable.
• The code for many containers would be shorter if we use [[maybe_trivially_relocatable]] instead of [[trivially_relocatable(all my members are trivially relocatable)]]. P1144 discusses, but doesn't propose, [[maybe_trivially_relocatable]]. D50119 does implement it.
• explicit warrants for stack, queue, and priority_queue (which would not be needed if those types could follow the Rule of Zero; see D61139 for details)

[• Quuxplusone]

Rebase on the latest version of D61761: Hide is_trivially_relocatable behind a __libcpp_ prefix.

[• Quuxplusone]

Rebase on master/D61761, and finally implement conditionally trivial relocatability for stack, queue, and priority_queue.

[• Quuxplusone]

Rebased on master.

[• Quuxplusone]

Migrate to the monorepo.

[Mordante]

Since P1144 is still in flight in WG21 abandoning this patch for now. When the paper is approved we can look it up again and see how outdated it is.

libcxx/include/__bit_reference

 bool
 equal(__bit_iterator<_Cp, _IC1> __first1, __bit_iterator<_Cp, _IC1> __last1, __bit_iterator<_Cp, _IC2> __first2)
 {
     if (__first1.__ctz_ == __first2.__ctz_)
         return __equal_aligned(__first1, __last1, __first2);
     return __equal_unaligned(__first1, __last1, __first2);
 }
 
+template <class _Cp, bool _IsConst>
+struct __bit_iterator_is_trivially_relocatable {
+    typedef typename conditional<_IsConst, typename _Cp::__const_storage_pointer,
+                                           typename _Cp::__storage_pointer>::type  __storage_pointer;
+
+    typedef __libcpp_is_trivially_relocatable<__storage_pointer> type;
+};
+
 template <class _Cp, bool _IsConst,
           typename _Cp::__storage_type>
-class __bit_iterator
+class _LIBCPP_TRIVIALLY_RELOCATABLE_IF((__bit_iterator_is_trivially_relocatable<_Cp, _IsConst>::type::value)) __bit_iterator
 {
 public:
     typedef typename _Cp::difference_type                                                          difference_type;
     typedef bool                                                                                  value_type;
     typedef __bit_iterator                                                                        pointer;
     typedef typename conditional<_IsConst, __bit_const_reference<_Cp>, __bit_reference<_Cp> >::type reference;
     typedef random_access_iterator_tag                                                            iterator_category;
 

libcxx/include/__config

 #if !defined(__cpp_deduction_guides) || __cpp_deduction_guides < 201611
 #define _LIBCPP_HAS_NO_DEDUCTION_GUIDES
 #endif
 
 #if !__has_keyword(__is_aggregate) && (_GNUC_VER_NEW < 7001)
 #define _LIBCPP_HAS_NO_IS_AGGREGATE
 #endif
 
+#if __has_extension(trivially_relocatable)
+#define _LIBCPP_TRIVIALLY_RELOCATABLE [[clang::trivially_relocatable]]
+#define _LIBCPP_TRIVIALLY_RELOCATABLE_IF(x) [[clang::trivially_relocatable(x)]]
+#else
+#define _LIBCPP_TRIVIALLY_RELOCATABLE
+#define _LIBCPP_TRIVIALLY_RELOCATABLE_IF(x)
+#endif
+
 #if !defined(__cpp_coroutines) || __cpp_coroutines < 201703L
 #define _LIBCPP_HAS_NO_COROUTINES
 #endif
 
 // FIXME: Correct this macro when either (A) a feature test macro for the
 // spaceship operator is provided, or (B) a compiler provides a complete
 // implementation.
 #define _LIBCPP_HAS_NO_SPACESHIP_OPERATOR

libcxx/include/__hash_table

__hash_const_local_iterator(__next_pointer __node, size_t __bucket,
                 __node_ = __node_->__next_;
         }
 #endif
     template <class, class, class, class> friend class __hash_table;
     template <class> friend class _LIBCPP_TEMPLATE_VIS __hash_map_const_iterator;
 };
 
 template <class _Alloc>
-class __bucket_list_deallocator
+class _LIBCPP_TRIVIALLY_RELOCATABLE_IF((__libcpp_is_trivially_relocatable<__compressed_pair<typename allocator_traits<_Alloc>::size_type, _Alloc>>::value))
+      __bucket_list_deallocator
 {
     typedef _Alloc                                          allocator_type;
     typedef allocator_traits<allocator_type>                __alloc_traits;
     typedef typename __alloc_traits::size_type              size_type;
 
     __compressed_pair<size_type, allocator_type> __data_;
 public:
     typedef typename __alloc_traits::pointer pointer;
#ifndef _LIBCPP_CXX03_LANG
     }
     _LIBCPP_INLINE_VISIBILITY
         void __move_assign_alloc(__hash_table&, false_type) _NOEXCEPT {}
 #endif // _LIBCPP_CXX03_LANG
 
     void __deallocate_node(__next_pointer __np) _NOEXCEPT;
     __next_pointer __detach() _NOEXCEPT;
 
+public:
+    typedef integral_constant<bool,
+#if _LIBCPP_DEBUG_LEVEL >= 2
+        false
+#else
+        __libcpp_is_trivially_relocatable<__bucket_list>::value &&
+        __libcpp_is_trivially_relocatable<__first_node>::value &&
+        __libcpp_is_trivially_relocatable<__node_allocator>::value &&
+        __libcpp_is_trivially_relocatable<hasher>::value &&
+        __libcpp_is_trivially_relocatable<key_equal>::value
+#endif
+    > __allow_trivial_relocation;
+
     template <class, class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS unordered_map;
     template <class, class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS unordered_multimap;
 };
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
 inline
 __hash_table<_Tp, _Hash, _Equal, _Alloc>::__hash_table()
     _NOEXCEPT_(

libcxx/include/__locale

 bool
 has_facet(const locale&) _NOEXCEPT;
 
 template <class _Facet>
 _LIBCPP_INLINE_VISIBILITY
 const _Facet&
 use_facet(const locale&);
 
-class _LIBCPP_TYPE_VIS locale
+class _LIBCPP_TYPE_VIS _LIBCPP_TRIVIALLY_RELOCATABLE locale
 {
 public:
     // types:
     class _LIBCPP_TYPE_VIS facet;
     class _LIBCPP_TYPE_VIS id;
 
     typedef int category;
     _LIBCPP_AVAILABILITY_LOCALE_CATEGORY

libcxx/include/__mutex_base

public:
     ~lock_guard() _LIBCPP_THREAD_SAFETY_ANNOTATION(release_capability()) {__m_.unlock();}
 
 private:
     lock_guard(lock_guard const&) _LIBCPP_EQUAL_DELETE;
     lock_guard& operator=(lock_guard const&) _LIBCPP_EQUAL_DELETE;
 };
 
 template <class _Mutex>
-class _LIBCPP_TEMPLATE_VIS unique_lock
+class _LIBCPP_TEMPLATE_VIS _LIBCPP_TRIVIALLY_RELOCATABLE unique_lock
 {
 public:
     typedef _Mutex mutex_type;
 
 private:
     mutex_type* __m_;
     bool __owns_;
 

libcxx/include/bitset

 
 template <size_t _N_words, size_t _Size>
 class __bitset
 {
 public:
     typedef ptrdiff_t              difference_type;
     typedef size_t                 size_type;
     typedef size_type              __storage_type;
-protected:
     typedef __bitset __self;
     typedef       __storage_type*  __storage_pointer;
     typedef const __storage_type*  __const_storage_pointer;
     static const unsigned __bits_per_word = static_cast<unsigned>(sizeof(__storage_type) * CHAR_BIT);
 
+protected:
     friend class __bit_reference<__bitset>;
     friend class __bit_const_reference<__bitset>;
     friend class __bit_iterator<__bitset, false>;
     friend class __bit_iterator<__bitset, true>;
     friend struct __bit_array<__bitset>;
 
     __storage_type __first_[_N_words];
 

 
 template <size_t _Size>
 class __bitset<1, _Size>
 {
 public:
     typedef ptrdiff_t              difference_type;
     typedef size_t                 size_type;
     typedef size_type              __storage_type;
-protected:
     typedef __bitset __self;
     typedef       __storage_type*  __storage_pointer;
     typedef const __storage_type*  __const_storage_pointer;
     static const unsigned __bits_per_word = static_cast<unsigned>(sizeof(__storage_type) * CHAR_BIT);
 
+protected:
     friend class __bit_reference<__bitset>;
     friend class __bit_const_reference<__bitset>;
     friend class __bit_iterator<__bitset, false>;
     friend class __bit_iterator<__bitset, true>;
     friend struct __bit_array<__bitset>;
 
     __storage_type __first_;
 

 
 template <>
 class __bitset<0, 0>
 {
 public:
     typedef ptrdiff_t              difference_type;
     typedef size_t                 size_type;
     typedef size_type              __storage_type;
-protected:
     typedef __bitset __self;
     typedef       __storage_type*  __storage_pointer;
     typedef const __storage_type*  __const_storage_pointer;
     static const unsigned __bits_per_word = static_cast<unsigned>(sizeof(__storage_type) * CHAR_BIT);
 
+protected:
     friend class __bit_reference<__bitset>;
     friend class __bit_const_reference<__bitset>;
     friend class __bit_iterator<__bitset, false>;
     friend class __bit_iterator<__bitset, true>;
     friend struct __bit_array<__bitset>;
 
     typedef __bit_reference<__bitset>                  reference;
     typedef __bit_const_reference<__bitset>            const_reference;

libcxx/include/deque

 
       pointer __pos_;
       const pointer __end_;
     private:
       const pointer __begin_;
       __deque_base * const __base_;
     };
 
+public:
+    typedef integral_constant<bool,
+        __libcpp_is_trivially_relocatable<pointer>::value &&
+        __libcpp_is_trivially_relocatable<__pointer_allocator>::value &&
+        __libcpp_is_trivially_relocatable<size_type>::value &&
+        __libcpp_is_trivially_relocatable<allocator_type>::value
+    > __allow_trivial_relocation;
+
 protected:
     __map __map_;
     size_type __start_;
     __compressed_pair<size_type, allocator_type> __size_;
 
     iterator       begin() _NOEXCEPT;
     const_iterator begin() const _NOEXCEPT;
     iterator       end() _NOEXCEPT;

         break;
     case 2:
         __start_ = __block_size;
         break;
     }
 }
 
 template <class _Tp, class _Allocator /*= allocator<_Tp>*/>
-class _LIBCPP_TEMPLATE_VIS deque
+class _LIBCPP_TEMPLATE_VIS _LIBCPP_TRIVIALLY_RELOCATABLE_IF((__deque_base<_Tp, _Allocator>::__allow_trivial_relocation::value)) deque
     : private __deque_base<_Tp, _Allocator>
 {
 public:
     // types:
 
     typedef _Tp value_type;
     typedef _Allocator allocator_type;
 

libcxx/include/exception

 
 class _LIBCPP_TYPE_VIS exception_ptr;
 
 _LIBCPP_FUNC_VIS exception_ptr current_exception() _NOEXCEPT;
 _LIBCPP_NORETURN _LIBCPP_FUNC_VIS void rethrow_exception(exception_ptr);
 
 #ifndef _LIBCPP_ABI_MICROSOFT
 
-class _LIBCPP_TYPE_VIS exception_ptr
+class _LIBCPP_TYPE_VIS _LIBCPP_TRIVIALLY_RELOCATABLE exception_ptr
 {
     void* __ptr_;
 public:
     _LIBCPP_INLINE_VISIBILITY exception_ptr() _NOEXCEPT : __ptr_() {}
     _LIBCPP_INLINE_VISIBILITY exception_ptr(nullptr_t) _NOEXCEPT : __ptr_() {}
 
     exception_ptr(const exception_ptr&) _NOEXCEPT;
     exception_ptr& operator=(const exception_ptr&) _NOEXCEPT;

libcxx/include/forward_list

private:
 
     _LIBCPP_INLINE_VISIBILITY
     void __move_assign_alloc(__forward_list_base&, false_type) _NOEXCEPT
         {}
     _LIBCPP_INLINE_VISIBILITY
     void __move_assign_alloc(__forward_list_base& __x, true_type)
         _NOEXCEPT_(is_nothrow_move_assignable<__node_allocator>::value)
         {__alloc() = _VSTD::move(__x.__alloc());}
+
+public:
+    typedef __libcpp_is_trivially_relocatable<__compressed_pair<__begin_node, __node_allocator> > __allow_trivial_relocation;
 };
 
 #ifndef _LIBCPP_CXX03_LANG
 
 template <class _Tp, class _Alloc>
 inline
 __forward_list_base<_Tp, _Alloc>::__forward_list_base(__forward_list_base&& __x)
         _NOEXCEPT_(is_nothrow_move_constructible<__node_allocator>::value)
for (__node_pointer __p = __before_begin()->__next_; __p != nullptr;)
         __node_traits::destroy(__a, _VSTD::addressof(__p->__value_));
         __node_traits::deallocate(__a, __p, 1);
         __p = __next;
     }
     __before_begin()->__next_ = nullptr;
 }
 
 template <class _Tp, class _Alloc /*= allocator<_Tp>*/>
-class _LIBCPP_TEMPLATE_VIS forward_list
+class _LIBCPP_TEMPLATE_VIS
+      _LIBCPP_TRIVIALLY_RELOCATABLE_IF((__forward_list_base<_Tp, _Alloc>::__allow_trivial_relocation::value))
+      forward_list
     : private __forward_list_base<_Tp, _Alloc>
 {
     typedef __forward_list_base<_Tp, _Alloc> base;
     typedef typename base::__node_allocator  __node_allocator;
     typedef typename base::__node               __node;
     typedef typename base::__node_traits        __node_traits;
     typedef typename base::__node_pointer       __node_pointer;
     typedef typename base::__begin_node_pointer __begin_node_pointer;

libcxx/include/future

 _LIBCPP_INLINE_VISIBILITY future<_Rp>
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 __make_async_assoc_state(_Fp&& __f);
 #else
 __make_async_assoc_state(_Fp __f);
 #endif
 
 template <class _Rp>
-class _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FUTURE future
+class _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FUTURE _LIBCPP_TRIVIALLY_RELOCATABLE future
 {
     __assoc_state<_Rp>* __state_;
 
     explicit future(__assoc_state<_Rp>* __state);
 
     template <class> friend class promise;
     template <class> friend class shared_future;
 

 {
     unique_ptr<__shared_count, __release_shared_count> __(__state_);
     __assoc_state<_Rp>* __s = __state_;
     __state_ = nullptr;
     return __s->move();
 }
 
 template <class _Rp>
-class _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FUTURE future<_Rp&>
+class _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FUTURE _LIBCPP_TRIVIALLY_RELOCATABLE future<_Rp&>
 {
     __assoc_state<_Rp&>* __state_;
 
     explicit future(__assoc_state<_Rp&>* __state);
 
     template <class> friend class promise;
     template <class> friend class shared_future;
 

 {
     unique_ptr<__shared_count, __release_shared_count> __(__state_);
     __assoc_state<_Rp&>* __s = __state_;
     __state_ = nullptr;
     return __s->copy();
 }
 
 template <>
-class _LIBCPP_TYPE_VIS _LIBCPP_AVAILABILITY_FUTURE future<void>
+class _LIBCPP_TYPE_VIS _LIBCPP_AVAILABILITY_FUTURE _LIBCPP_TRIVIALLY_RELOCATABLE future<void>
 {
     __assoc_sub_state* __state_;
 
     explicit future(__assoc_sub_state* __state);
 
     template <class> friend class promise;
     template <class> friend class shared_future;
 

     __x.swap(__y);
 }
 
 // promise<R>
 
 template <class _Callable> class packaged_task;
 
 template <class _Rp>
-class _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FUTURE promise
+class _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FUTURE _LIBCPP_TRIVIALLY_RELOCATABLE promise
 {
     __assoc_state<_Rp>* __state_;
 
     _LIBCPP_INLINE_VISIBILITY
     explicit promise(nullptr_t) _NOEXCEPT : __state_(nullptr) {}
 
     template <class> friend class packaged_task;
 public:

     if (__state_ == nullptr)
         __throw_future_error(future_errc::no_state);
     __state_->set_exception_at_thread_exit(__p);
 }
 
 // promise<R&>
 
 template <class _Rp>
-class _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FUTURE promise<_Rp&>
+class _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FUTURE _LIBCPP_TRIVIALLY_RELOCATABLE promise<_Rp&>
 {
     __assoc_state<_Rp&>* __state_;
 
     _LIBCPP_INLINE_VISIBILITY
     explicit promise(nullptr_t) _NOEXCEPT : __state_(nullptr) {}
 
     template <class> friend class packaged_task;
 

     if (__state_ == nullptr)
         __throw_future_error(future_errc::no_state);
     __state_->set_exception_at_thread_exit(__p);
 }
 
 // promise<void>
 
 template <>
-class _LIBCPP_TYPE_VIS _LIBCPP_AVAILABILITY_FUTURE promise<void>
+class _LIBCPP_TYPE_VIS _LIBCPP_AVAILABILITY_FUTURE _LIBCPP_TRIVIALLY_RELOCATABLE promise<void>
 {
     __assoc_sub_state* __state_;
 
     _LIBCPP_INLINE_VISIBILITY
     explicit promise(nullptr_t) _NOEXCEPT : __state_(nullptr) {}
 
     template <class> friend class packaged_task;
 

                                     _VSTD::forward<_Args>(__args)...);
 }
 
 #endif  // _LIBCPP_HAS_NO_VARIADICS
 
 // shared_future
 
 template <class _Rp>
-class _LIBCPP_TEMPLATE_VIS shared_future
+class _LIBCPP_TEMPLATE_VIS _LIBCPP_TRIVIALLY_RELOCATABLE shared_future
 {
     __assoc_state<_Rp>* __state_;
 
 public:
     _LIBCPP_INLINE_VISIBILITY
     shared_future() _NOEXCEPT : __state_(nullptr) {}
     _LIBCPP_INLINE_VISIBILITY
     shared_future(const shared_future& __rhs)  _NOEXCEPT : __state_(__rhs.__state_)

         __rhs.__state_->__add_shared();
     if (__state_)
         __state_->__release_shared();
     __state_ = __rhs.__state_;
     return *this;
 }
 
 template <class _Rp>
-class _LIBCPP_TEMPLATE_VIS shared_future<_Rp&>
+class _LIBCPP_TEMPLATE_VIS _LIBCPP_TRIVIALLY_RELOCATABLE shared_future<_Rp&>
 {
     __assoc_state<_Rp&>* __state_;
 
 public:
     _LIBCPP_INLINE_VISIBILITY
     shared_future() _NOEXCEPT : __state_(nullptr) {}
     _LIBCPP_INLINE_VISIBILITY
     shared_future(const shared_future& __rhs) : __state_(__rhs.__state_)

         __rhs.__state_->__add_shared();
     if (__state_)
         __state_->__release_shared();
     __state_ = __rhs.__state_;
     return *this;
 }
 
 template <>
-class _LIBCPP_TYPE_VIS _LIBCPP_AVAILABILITY_FUTURE shared_future<void>
+class _LIBCPP_TYPE_VIS _LIBCPP_AVAILABILITY_FUTURE _LIBCPP_TRIVIALLY_RELOCATABLE shared_future<void>
 {
     __assoc_sub_state* __state_;
 
 public:
     _LIBCPP_INLINE_VISIBILITY
     shared_future() _NOEXCEPT : __state_(nullptr) {}
     _LIBCPP_INLINE_VISIBILITY
     shared_future(const shared_future& __rhs) : __state_(__rhs.__state_)

libcxx/include/memory

 
 template <class _Deleter>
 struct __unique_ptr_deleter_sfinae<_Deleter&> {
   typedef _Deleter& __lval_ref_type;
   typedef _Deleter&& __bad_rval_ref_type;
   typedef false_type __enable_rval_overload;
 };
 
+template <class _Tp, class _Dp>
+struct __unique_ptr_is_trivially_relocatable {
+  typedef _Tp element_type;
+  typedef _Dp deleter_type;
+  typedef typename __pointer_type<_Tp, deleter_type>::type pointer;
+  typedef __libcpp_is_trivially_relocatable<__compressed_pair<pointer, deleter_type> > type;
+};
+
 template <class _Tp, class _Dp = default_delete<_Tp> >
-class _LIBCPP_TEMPLATE_VIS unique_ptr {
+class _LIBCPP_TEMPLATE_VIS _LIBCPP_TRIVIALLY_RELOCATABLE_IF((__unique_ptr_is_trivially_relocatable<_Tp, _Dp>::type::value)) unique_ptr {
 public:
   typedef _Tp element_type;
   typedef _Dp deleter_type;
   typedef _LIBCPP_NODEBUG_TYPE typename __pointer_type<_Tp, deleter_type>::type pointer;
 
   static_assert(!is_rvalue_reference<deleter_type>::value,
                 "the specified deleter type cannot be an rvalue reference");
 

   _LIBCPP_INLINE_VISIBILITY
   void swap(unique_ptr& __u) _NOEXCEPT {
     __ptr_.swap(__u.__ptr_);
   }
 };
 
 
 template <class _Tp, class _Dp>
-class _LIBCPP_TEMPLATE_VIS unique_ptr<_Tp[], _Dp> {
+class _LIBCPP_TEMPLATE_VIS _LIBCPP_TRIVIALLY_RELOCATABLE_IF((__unique_ptr_is_trivially_relocatable<_Tp, _Dp>::type::value)) unique_ptr<_Tp[], _Dp> {
 public:
   typedef _Tp element_type;
   typedef _Dp deleter_type;
   typedef typename __pointer_type<_Tp, deleter_type>::type pointer;
 
 private:
   __compressed_pair<pointer, deleter_type> __ptr_;
 

     {
         typedef allocator<_Other> other;
     };
 };
 
 template<class _Tp> class _LIBCPP_TEMPLATE_VIS enable_shared_from_this;
 
 template<class _Tp>
-class _LIBCPP_TEMPLATE_VIS shared_ptr
+class _LIBCPP_TEMPLATE_VIS _LIBCPP_TRIVIALLY_RELOCATABLE shared_ptr
 {
 public:
     typedef _Tp element_type;
 
 #if _LIBCPP_STD_VER > 14
     typedef weak_ptr<_Tp> weak_type;
 #endif
 private:

 get_deleter(const shared_ptr<_Tp>& __p) _NOEXCEPT
 {
     return __p.template __get_deleter<_Dp>();
 }
 
 #endif  // _LIBCPP_NO_RTTI
 
 template<class _Tp>
-class _LIBCPP_TEMPLATE_VIS weak_ptr
+class _LIBCPP_TEMPLATE_VIS _LIBCPP_TRIVIALLY_RELOCATABLE weak_ptr
 {
 public:
     typedef _Tp element_type;
 private:
     element_type*        __ptr_;
     __shared_weak_count* __cntrl_;
 
 public:

libcxx/include/optional

 
 template <class _Tp>
 using __optional_sfinae_assign_base_t = __sfinae_assign_base<
     (is_copy_constructible<_Tp>::value && is_copy_assignable<_Tp>::value),
     (is_move_constructible<_Tp>::value && is_move_assignable<_Tp>::value)
 >;
 
 template <class _Tp>
-class optional
+class _LIBCPP_TRIVIALLY_RELOCATABLE_IF(__libcpp_is_trivially_relocatable<_Tp>::value) optional
     : private __optional_move_assign_base<_Tp>
     , private __optional_sfinae_ctor_base_t<_Tp>
     , private __optional_sfinae_assign_base_t<_Tp>
 {
     using __base = __optional_move_assign_base<_Tp>;
 public:
     using value_type = _Tp;
 

libcxx/include/queue

 operator==(const queue<_Tp, _Container>& __x,const queue<_Tp, _Container>& __y);
 
 template <class _Tp, class _Container>
 _LIBCPP_INLINE_VISIBILITY
 bool
 operator< (const queue<_Tp, _Container>& __x,const queue<_Tp, _Container>& __y);
 
 template <class _Tp, class _Container /*= deque<_Tp>*/>
-class _LIBCPP_TEMPLATE_VIS queue
+class _LIBCPP_TEMPLATE_VIS _LIBCPP_TRIVIALLY_RELOCATABLE_IF((__libcpp_is_trivially_relocatable<_Container>::value)) queue
 {
 public:
     typedef _Container                               container_type;
     typedef typename container_type::value_type      value_type;
     typedef typename container_type::reference       reference;
     typedef typename container_type::const_reference const_reference;
     typedef typename container_type::size_type       size_type;
     static_assert((is_same<_Tp, value_type>::value), "" );

 template <class _Tp, class _Container, class _Alloc>
 struct _LIBCPP_TEMPLATE_VIS uses_allocator<queue<_Tp, _Container>, _Alloc>
     : public uses_allocator<_Container, _Alloc>
 {
 };
 
 template <class _Tp, class _Container = vector<_Tp>,
           class _Compare = less<typename _Container::value_type> >
-class _LIBCPP_TEMPLATE_VIS priority_queue
+class _LIBCPP_TEMPLATE_VIS _LIBCPP_TRIVIALLY_RELOCATABLE_IF((__libcpp_is_trivially_relocatable<_Container>::value && __libcpp_is_trivially_relocatable<_Compare>::value)) priority_queue
 {
 public:
     typedef _Container                               container_type;
     typedef _Compare                                 value_compare;
     typedef typename container_type::value_type      value_type;
     typedef typename container_type::reference       reference;
     typedef typename container_type::const_reference const_reference;
     typedef typename container_type::size_type       size_type;

libcxx/include/shared_mutex

shared_timed_mutex::try_lock_shared_until(
     }
     unsigned __num_readers = (__base.__state_ & __base.__n_readers_) + 1;
     __base.__state_ &= ~__base.__n_readers_;
     __base.__state_ |= __num_readers;
     return true;
 }
 
 template <class _Mutex>
-class shared_lock
+class _LIBCPP_TEMPLATE_VIS _LIBCPP_TRIVIALLY_RELOCATABLE shared_lock
 {
 public:
     typedef _Mutex mutex_type;
 
 private:
     mutex_type* __m_;
     bool __owns_;
 

libcxx/include/stack

 operator==(const stack<_Tp, _Container>& __x, const stack<_Tp, _Container>& __y);
 
 template <class _Tp, class _Container>
 _LIBCPP_INLINE_VISIBILITY
 bool
 operator< (const stack<_Tp, _Container>& __x, const stack<_Tp, _Container>& __y);
 
 template <class _Tp, class _Container /*= deque<_Tp>*/>
-class _LIBCPP_TEMPLATE_VIS stack
+class _LIBCPP_TEMPLATE_VIS _LIBCPP_TRIVIALLY_RELOCATABLE_IF((__libcpp_is_trivially_relocatable<_Container>::value)) stack
 {
 public:
     typedef _Container                               container_type;
     typedef typename container_type::value_type      value_type;
     typedef typename container_type::reference       reference;
     typedef typename container_type::const_reference const_reference;
     typedef typename container_type::size_type       size_type;
     static_assert((is_same<_Tp, value_type>::value), "" );

libcxx/include/string

 
 template <class _CharT>
 struct __padding<_CharT, 1>
 {
 };
 
 #endif  // _LIBCPP_ABI_ALTERNATE_STRING_LAYOUT
 
+template<class _Allocator>
+struct __basic_string_is_trivially_relocatable {
+#if _LIBCPP_DEBUG_LEVEL >= 2
+    typedef false_type type;
+#else
+    typedef typename allocator_traits<_Allocator>::pointer pointer;
+    typedef integral_constant<bool,
+        __libcpp_is_trivially_relocatable<pointer>::value &&
+        __libcpp_is_trivially_relocatable<_Allocator>::value
+    > type;
+#endif
+};
+
 template<class _CharT, class _Traits, class _Allocator>
-class _LIBCPP_TEMPLATE_VIS basic_string
+class _LIBCPP_TEMPLATE_VIS _LIBCPP_TRIVIALLY_RELOCATABLE_IF(__basic_string_is_trivially_relocatable<_Allocator>::type::value) basic_string
     : private __basic_string_common<true>
 {
 public:
     typedef basic_string                                 __self;
     typedef basic_string_view<_CharT, _Traits>           __self_view;
     typedef _Traits                                      traits_type;
     typedef _CharT                                       value_type;
     typedef _Allocator                                   allocator_type;

libcxx/include/thread

 };
 
 template<class _CharT, class _Traits>
 _LIBCPP_INLINE_VISIBILITY
 basic_ostream<_CharT, _Traits>&
 operator<<(basic_ostream<_CharT, _Traits>& __os, __thread_id __id)
 {return __os << __id.__id_;}
 
-class _LIBCPP_TYPE_VIS thread
+class _LIBCPP_TYPE_VIS _LIBCPP_TRIVIALLY_RELOCATABLE thread
 {
     __libcpp_thread_t __t_;
 
     thread(const thread&);
     thread& operator=(const thread&);
 public:
     typedef __thread_id id;
     typedef __libcpp_thread_t native_handle_type;

libcxx/include/unordered_map

public:
     template <class> friend class _LIBCPP_TEMPLATE_VIS __hash_const_local_iterator;
 };
 
 template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
 class unordered_multimap;
 
 template <class _Key, class _Tp, class _Hash = hash<_Key>, class _Pred = equal_to<_Key>,
           class _Alloc = allocator<pair<const _Key, _Tp> > >
-class _LIBCPP_TEMPLATE_VIS unordered_map
+class _LIBCPP_TEMPLATE_VIS
+      _LIBCPP_TRIVIALLY_RELOCATABLE_IF((__hash_table<pair<const _Key, _Tp>, _Hash, _Pred, _Alloc>::__allow_trivial_relocation::value))
+      unordered_map
 {
 public:
     // types
     typedef _Key                                           key_type;
     typedef _Tp                                            mapped_type;
     typedef typename __identity<_Hash>::type               hasher;
     typedef typename __identity<_Pred>::type               key_equal;
     typedef typename __identity<_Alloc>::type              allocator_type;

 operator!=(const unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
            const unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
 {
     return !(__x == __y);
 }
 
 template <class _Key, class _Tp, class _Hash = hash<_Key>, class _Pred = equal_to<_Key>,
           class _Alloc = allocator<pair<const _Key, _Tp> > >
-class _LIBCPP_TEMPLATE_VIS unordered_multimap
+class _LIBCPP_TEMPLATE_VIS
+      _LIBCPP_TRIVIALLY_RELOCATABLE_IF((__hash_table<pair<const _Key, _Tp>, _Hash, _Pred, _Alloc>::__allow_trivial_relocation::value))
+      unordered_multimap
 {
 public:
     // types
     typedef _Key                                           key_type;
     typedef _Tp                                            mapped_type;
     typedef typename __identity<_Hash>::type               hasher;
     typedef typename __identity<_Pred>::type               key_equal;
     typedef typename __identity<_Alloc>::type              allocator_type;

libcxx/include/unordered_set

 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Value, class _Hash, class _Pred, class _Alloc>
 class unordered_multiset;
 
 template <class _Value, class _Hash = hash<_Value>, class _Pred = equal_to<_Value>,
           class _Alloc = allocator<_Value> >
-class _LIBCPP_TEMPLATE_VIS unordered_set
+class _LIBCPP_TEMPLATE_VIS
+      _LIBCPP_TRIVIALLY_RELOCATABLE_IF((__hash_table<_Value, _Hash, _Pred, _Alloc>::__allow_trivial_relocation::value))
+      unordered_set
 {
 public:
     // types
     typedef _Value                                                     key_type;
     typedef key_type                                                   value_type;
     typedef typename __identity<_Hash>::type                           hasher;
     typedef typename __identity<_Pred>::type                           key_equal;
     typedef typename __identity<_Alloc>::type                          allocator_type;

 operator!=(const unordered_set<_Value, _Hash, _Pred, _Alloc>& __x,
            const unordered_set<_Value, _Hash, _Pred, _Alloc>& __y)
 {
     return !(__x == __y);
 }
 
 template <class _Value, class _Hash = hash<_Value>, class _Pred = equal_to<_Value>,
           class _Alloc = allocator<_Value> >
-class _LIBCPP_TEMPLATE_VIS unordered_multiset
+class _LIBCPP_TEMPLATE_VIS
+      _LIBCPP_TRIVIALLY_RELOCATABLE_IF((__hash_table<_Value, _Hash, _Pred, _Alloc>::__allow_trivial_relocation::value))
+      unordered_multiset
 {
 public:
     // types
     typedef _Value                                                     key_type;
     typedef key_type                                                   value_type;
     typedef typename __identity<_Hash>::type                           hasher;
     typedef typename __identity<_Pred>::type                           key_equal;
     typedef typename __identity<_Alloc>::type                          allocator_type;

libcxx/include/variant

 
 template <class _Tp, class... _Types>
 using __best_match_t =
     typename invoke_result_t<_MakeOverloads<_Types...>, _Tp, _Tp>::type;
 
 } // __variant_detail
 
 template <class... _Types>
-class _LIBCPP_TEMPLATE_VIS variant
+class _LIBCPP_TEMPLATE_VIS _LIBCPP_TRIVIALLY_RELOCATABLE_IF(__all<__libcpp_is_trivially_relocatable_v<_Types>...>::value) variant
     : private __sfinae_ctor_base<
           __all<is_copy_constructible_v<_Types>...>::value,
           __all<is_move_constructible_v<_Types>...>::value>,
       private __sfinae_assign_base<
           __all<(is_copy_constructible_v<_Types> &&
                  is_copy_assignable_v<_Types>)...>::value,
           __all<(is_move_constructible_v<_Types> &&
                  is_move_assignable_v<_Types>)...>::value> {

libcxx/include/vector

void __move_assign_alloc(__vector_base& __c, true_type)
         {
             __alloc() = _VSTD::move(__c.__alloc());
         }
 
     _LIBCPP_INLINE_VISIBILITY
     void __move_assign_alloc(__vector_base&, false_type)
         _NOEXCEPT
         {}
+
+public:
+#if _LIBCPP_DEBUG_LEVEL >= 2
+    typedef false_type __allow_trivial_relocation;
+#else
+    typedef __libcpp_is_trivially_relocatable<__compressed_pair<pointer, allocator_type> > __allow_trivial_relocation;
+#endif
 };
 
 template <class _Tp, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
 void
 __vector_base<_Tp, _Allocator>::__destruct_at_end(pointer __new_last) _NOEXCEPT
 {
     pointer __soon_to_be_end = __end_;
__vector_base<_Tp, _Allocator>::~__vector_base()
     if (__begin_ != nullptr)
     {
         clear();
         __alloc_traits::deallocate(__alloc(), __begin_, capacity());
     }
 }
 
 template <class _Tp, class _Allocator /* = allocator<_Tp> */>
-class _LIBCPP_TEMPLATE_VIS vector
+class _LIBCPP_TEMPLATE_VIS
+      _LIBCPP_TRIVIALLY_RELOCATABLE_IF((__vector_base<_Tp, _Allocator>::__allow_trivial_relocation::value))
+    vector
     : private __vector_base<_Tp, _Allocator>
 {
 private:
     typedef __vector_base<_Tp, _Allocator>           __base;
     typedef allocator<_Tp>                           __default_allocator_type;
 public:
     typedef vector                                   __self;
     typedef _Tp                                      value_type;

 
 template <class _Allocator>
 struct __has_storage_type<vector<bool, _Allocator> >
 {
     static const bool value = true;
 };
 
 template <class _Allocator>
-class _LIBCPP_TEMPLATE_VIS vector<bool, _Allocator>
+struct __vector_bool_is_trivially_relocatable {
+    typedef _Allocator                               allocator_type;
+    typedef allocator_traits<allocator_type>         __alloc_traits;
+    typedef typename __alloc_traits::size_type       size_type;
+    typedef size_type                                __storage_type;
+    typedef typename __rebind_alloc_helper<__alloc_traits, __storage_type>::type __storage_allocator;
+    typedef allocator_traits<__storage_allocator>    __storage_traits;
+    typedef typename __storage_traits::pointer       __storage_pointer;
+
+    typedef integral_constant<bool,
+        __libcpp_is_trivially_relocatable<__storage_pointer>::value &&
+        __libcpp_is_trivially_relocatable<size_type>::value &&
+        __libcpp_is_trivially_relocatable<__compressed_pair<size_type, __storage_allocator> >::value
+    > type;
+};
+
+template <class _Allocator>
+class _LIBCPP_TEMPLATE_VIS
+      _LIBCPP_TRIVIALLY_RELOCATABLE_IF(__vector_bool_is_trivially_relocatable<_Allocator>::type::value)
+    vector<bool, _Allocator>
     : private __vector_base_common<true>
 {
 public:
     typedef vector                                   __self;
     typedef bool                                     value_type;
     typedef _Allocator                               allocator_type;
     typedef allocator_traits<allocator_type>         __alloc_traits;
     typedef typename __alloc_traits::size_type       size_type;
     typedef typename __alloc_traits::difference_type difference_type;
-    typedef size_type __storage_type;
+    typedef size_type                                __storage_type;
     typedef __bit_iterator<vector, false>            pointer;
     typedef __bit_iterator<vector, true>             const_pointer;
     typedef pointer                                  iterator;
     typedef const_pointer                            const_iterator;
     typedef _VSTD::reverse_iterator<iterator>         reverse_iterator;
     typedef _VSTD::reverse_iterator<const_iterator>   const_reverse_iterator;
 
-private:
     typedef typename __rebind_alloc_helper<__alloc_traits, __storage_type>::type __storage_allocator;
     typedef allocator_traits<__storage_allocator>    __storage_traits;
     typedef typename __storage_traits::pointer       __storage_pointer;
     typedef typename __storage_traits::const_pointer __const_storage_pointer;
 
+private:
     __storage_pointer                                      __begin_;
     size_type                                              __size_;
     __compressed_pair<size_type, __storage_allocator> __cap_alloc_;
 public:
     typedef __bit_reference<vector>                  reference;
     typedef __bit_const_reference<vector>            const_reference;
 private:
     _LIBCPP_INLINE_VISIBILITY

libcxx/test/libcxx/containers/sequences/deque/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
+
+// <deque>
+
+// template<class T> class deque;
+
+#include <deque>
+#include <memory>
+#include <type_traits>
+
+// Define the P1144 name for convenience.
+#define is_trivially_relocatable __libcpp_is_trivially_relocatable
+
+
+struct NonTriv { ~NonTriv(); };
+
+namespace fa {
+    template<class T>
+    struct FakeAllocator : std::allocator<T> {
+        template<class U> struct rebind {
+            using other = FakeAllocator<U>;
+        };
+        template<class U>
+        FakeAllocator(const FakeAllocator<U>&);
+        // The defaulted (trivial) copy constructor is still present here!
+    };
+    static_assert(std::is_trivially_copy_constructible<FakeAllocator<int>>::value, "");
+    static_assert(std::is_trivially_relocatable<FakeAllocator<int>>::value, "");
+
+    template<class T> using deque = std::deque<T, FakeAllocator<T>>;
+}
+
+namespace fa2 {
+    template<class T>
+    struct FakeAllocator : std::allocator<T> {
+        template<class U> struct rebind {
+            using other = FakeAllocator<U>;
+        };
+        template<class U>
+        FakeAllocator(const FakeAllocator<U>&);
+        FakeAllocator(const FakeAllocator&);
+    };
+    static_assert(!std::is_trivially_copy_constructible<FakeAllocator<int>>::value, "");
+    static_assert(!std::is_trivially_relocatable<FakeAllocator<int>>::value, "");
+
+    template<class T> using deque = std::deque<T, FakeAllocator<T>>;
+}
+
+namespace fa3 {
+    template<class T>
+    struct FakePointer {
+        int offset;
+        FakePointer();
+        FakePointer(const FakePointer&) = default;
+        FakePointer& operator=(const FakePointer&) = default;
+        T& operator*() const;
+        T* operator->() const;
+        FakePointer operator + (unsigned int) const;
+        FakePointer& operator += (unsigned int);
+        FakePointer operator ++(int);
+        FakePointer& operator ++();
+        FakePointer operator --(int);
+        FakePointer& operator --();
+    };
+    static_assert(std::is_trivially_copy_constructible<FakePointer<int>>::value, "");
+    static_assert(std::is_trivially_relocatable<FakePointer<int>>::value, "");
+
+    template<class T>
+    struct FakeAllocator : std::allocator<T> {
+        template<class U> struct rebind {
+            using other = FakeAllocator<U>;
+        };
+        using pointer = FakePointer<T>;
+    };
+
+    template<class T> using deque = std::deque<T, FakeAllocator<T>>;
+}
+
+namespace fa4 {
+    template<class T>
+    struct FakePointer {
+        int offset;
+        FakePointer();
+        FakePointer(const FakePointer&);
+        FakePointer& operator=(const FakePointer&);
+        T& operator*() const;
+        T* operator->() const;
+        FakePointer operator + (unsigned int) const;
+        FakePointer& operator += (unsigned int);
+        FakePointer operator ++(int);
+        FakePointer& operator ++();
+        FakePointer operator --(int);
+        FakePointer& operator --();
+    };
+    static_assert(!std::is_trivially_copy_constructible<FakePointer<int>>::value, "");
+    static_assert(!std::is_trivially_relocatable<FakePointer<int>>::value, "");
+
+    template<class T>
+    struct FakeAllocator : std::allocator<T> {
+        template<class U> struct rebind {
+            using other = FakeAllocator<U>;
+        };
+        using pointer = FakePointer<T>;
+    };
+
+    template<class T> using deque = std::deque<T, FakeAllocator<T>>;
+}
+
+
+static_assert(std::is_trivially_relocatable< std::allocator<int> >::value, "");
+static_assert(!std::is_trivially_relocatable< fa2::FakeAllocator<int> >::value, "");
+static_assert(std::is_trivially_relocatable< fa4::FakeAllocator<int> >::value, "");
+static_assert(!std::is_trivially_relocatable< fa4::FakePointer<int> >::value, "");
+
+template<class VT, bool Expected>
+void check_trivial_relocatability()
+{
+#if !__has_extension(trivially_relocatable)
+    // Making deque trivially relocatable requires using the attribute.
+    static_assert(std::is_trivially_relocatable< VT >::value == false, "");
+#else
+    static_assert(std::is_trivially_relocatable< VT >::value == Expected, "");
+#endif
+}
+
+int main()
+{
+    check_trivial_relocatability< std::deque<int>, true >();
+    check_trivial_relocatability< std::deque<NonTriv>, true >();
+
+    check_trivial_relocatability< fa::deque<int>, true >();
+    check_trivial_relocatability< fa::deque<NonTriv>, true >();
+
+    check_trivial_relocatability< fa2::deque<int>, false >();
+    check_trivial_relocatability< fa2::deque<NonTriv>, false >();
+
+    check_trivial_relocatability< fa3::deque<int>, true >();
+    check_trivial_relocatability< fa3::deque<NonTriv>, true >();
+
+    check_trivial_relocatability< fa4::deque<int>, false >();
+    check_trivial_relocatability< fa4::deque<NonTriv>, false >();
+}

libcxx/test/libcxx/containers/sequences/vector/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
+
+// <vector>
+
+// template<class T> class vector;
+
+#include <memory>
+#include <vector>
+#include <type_traits>
+
+// Define the P1144 name for convenience.
+#define is_trivially_relocatable __libcpp_is_trivially_relocatable
+
+struct Incomplete;
+struct NonTriv { ~NonTriv(); };
+
+namespace fa {
+    template<class T>
+    struct FakeAllocator : std::allocator<T> {
+        template<class U> struct rebind {
+            using other = FakeAllocator<U>;
+        };
+        template<class U>
+        FakeAllocator(const FakeAllocator<U>&);
+        // The defaulted (trivial) copy constructor is still present here!
+    };
+    static_assert(std::is_trivially_copy_constructible<FakeAllocator<int>>::value, "");
+    static_assert(std::is_trivially_relocatable<FakeAllocator<int>>::value, "");
+
+    template<class T> using vector = std::vector<T, FakeAllocator<T>>;
+}
+
+namespace fa2 {
+    template<class T>
+    struct FakeAllocator : std::allocator<T> {
+        template<class U> struct rebind {
+            using other = FakeAllocator<U>;
+        };
+        template<class U>
+        FakeAllocator(const FakeAllocator<U>&);
+        FakeAllocator(const FakeAllocator&);
+    };
+    static_assert(!std::is_trivially_copy_constructible<FakeAllocator<int>>::value, "");
+    static_assert(!std::is_trivially_relocatable<FakeAllocator<int>>::value, "");
+
+    template<class T> using vector = std::vector<T, FakeAllocator<T>>;
+}
+
+namespace fa3 {
+    template<class T>
+    struct FakePointer {
+        int offset;
+        FakePointer();
+        FakePointer(const FakePointer&) = default;
+        FakePointer& operator=(const FakePointer&) = default;
+        T& operator*() const;
+        T* operator->() const;
+        FakePointer operator + (unsigned int) const;
+        FakePointer& operator += (unsigned int);
+        FakePointer operator ++(int);
+        FakePointer& operator ++();
+        FakePointer operator --(int);
+        FakePointer& operator --();
+    };
+    static_assert(std::is_trivially_copy_constructible<FakePointer<int>>::value, "");
+    static_assert(std::is_trivially_relocatable<FakePointer<int>>::value, "");
+
+    template<class T>
+    struct FakeAllocator : std::allocator<T> {
+        template<class U> struct rebind {
+            using other = FakeAllocator<U>;
+        };
+        using pointer = FakePointer<T>;
+    };
+
+    template<class T> using vector = std::vector<T, FakeAllocator<T>>;
+}
+
+namespace fa4 {
+    template<class T>
+    struct FakePointer {
+        int offset;
+        FakePointer();
+        FakePointer(const FakePointer&);
+        FakePointer& operator=(const FakePointer&);
+        T& operator*() const;
+        T* operator->() const;
+        FakePointer operator + (unsigned int) const;
+        FakePointer& operator += (unsigned int);
+        FakePointer operator ++(int);
+        FakePointer& operator ++();
+        FakePointer operator --(int);
+        FakePointer& operator --();
+    };
+    static_assert(!std::is_trivially_copy_constructible<FakePointer<int>>::value, "");
+    static_assert(!std::is_trivially_relocatable<FakePointer<int>>::value, "");
+
+    template<class T>
+    struct FakeAllocator : std::allocator<T> {
+        template<class U> struct rebind {
+            using other = FakeAllocator<U>;
+        };
+        using pointer = FakePointer<T>;
+    };
+
+    template<class T> using vector = std::vector<T, FakeAllocator<T>>;
+}
+
+
+static_assert(std::is_trivially_relocatable< std::allocator<int> >::value, "");
+static_assert(!std::is_trivially_relocatable< fa2::FakeAllocator<int> >::value, "");
+static_assert(std::is_trivially_relocatable< fa4::FakeAllocator<int> >::value, "");
+static_assert(!std::is_trivially_relocatable< fa4::FakePointer<int> >::value, "");
+
+template<class VT, bool Expected>
+void check_trivial_relocatability()
+{
+#if _LIBCPP_DEBUG_LEVEL >= 2
+    // Debugging adds significant operations to vector's move-constructor and destructor.
+    static_assert(std::is_trivially_relocatable< VT >::value == false, "");
+#elif !__has_extension(trivially_relocatable)
+    // Making vector trivially relocatable requires using the attribute.
+    static_assert(std::is_trivially_relocatable< VT >::value == false, "");
+#else
+    static_assert(std::is_trivially_relocatable< VT >::value == Expected, "");
+#endif
+}
+
+int main()
+{
+    check_trivial_relocatability< std::vector<int>, true >();
+    check_trivial_relocatability< std::vector<Incomplete>, true >();
+    check_trivial_relocatability< std::vector<NonTriv>, true >();
+
+    check_trivial_relocatability< fa::vector<int>, true >();
+    check_trivial_relocatability< fa::vector<Incomplete>, true >();
+    check_trivial_relocatability< fa::vector<NonTriv>, true >();
+
+    check_trivial_relocatability< fa2::vector<int>, false >();
+    check_trivial_relocatability< fa2::vector<Incomplete>, false >();
+    check_trivial_relocatability< fa2::vector<NonTriv>, false >();
+
+    check_trivial_relocatability< fa3::vector<int>, true >();
+    check_trivial_relocatability< fa3::vector<Incomplete>, true >();
+    check_trivial_relocatability< fa3::vector<NonTriv>, true >();
+
+    check_trivial_relocatability< fa4::vector<int>, false >();
+    check_trivial_relocatability< fa4::vector<Incomplete>, false >();
+    check_trivial_relocatability< fa4::vector<NonTriv>, false >();
+}

libcxx/test/libcxx/containers/unord/unord.map/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
+
+// <unordered_map>
+
+#include <unordered_map>
+#include <memory>
+#include <type_traits>
+
+// Define the P1144 name for convenience.
+#define is_trivially_relocatable __libcpp_is_trivially_relocatable
+
+
+struct NonTriv { ~NonTriv(); };
+template <> struct std::hash<NonTriv> { size_t operator()(const NonTriv&) const; };
+bool operator==(const NonTriv&, const NonTriv&);
+
+namespace fa {
+    template<class T>
+    struct FakeAllocator : std::allocator<T> {
+        template<class U> struct rebind {
+            using other = FakeAllocator<U>;
+        };
+        template<class U>
+        FakeAllocator(const FakeAllocator<U>&);
+        // The defaulted (trivial) copy constructor is still present here!
+    };
+    static_assert(std::is_trivially_copy_constructible<FakeAllocator<int>>::value, "");
+    static_assert(std::is_trivially_relocatable<FakeAllocator<int>>::value, "");
+
+    template<class K, class V> using alloc = FakeAllocator<std::pair<const K, V>>;
+    template<class K, class V> using unordered_map = std::unordered_map<K, V, std::hash<K>, std::equal_to<K>, alloc<K, V>>;
+}
+
+namespace fa2 {
+    template<class T>
+    struct FakeAllocator : std::allocator<T> {
+        template<class U> struct rebind {
+            using other = FakeAllocator<U>;
+        };
+        template<class U>
+        FakeAllocator(const FakeAllocator<U>&);
+        FakeAllocator(const FakeAllocator&);
+    };
+    static_assert(!std::is_trivially_copy_constructible<FakeAllocator<int>>::value, "");
+    static_assert(!std::is_trivially_relocatable<FakeAllocator<int>>::value, "");
+
+    template<class K, class V> using alloc = FakeAllocator<std::pair<const K, V>>;
+    template<class K, class V> using unordered_map = std::unordered_map<K, V, std::hash<K>, std::equal_to<K>, alloc<K, V>>;
+}
+
+namespace fa3 {
+    template<class T>
+    struct FakePointer {
+        int offset;
+        FakePointer();
+        FakePointer(const FakePointer&) = default;
+        FakePointer& operator=(const FakePointer&) = default;
+        std::conditional_t<std::is_void<T>::value, char, T>& operator*() const;
+        T* operator->() const;
+        FakePointer operator + (unsigned int) const;
+        FakePointer& operator += (unsigned int);
+        FakePointer operator ++(int);
+        FakePointer& operator ++();
+        FakePointer operator --(int);
+        FakePointer& operator --();
+    };
+    static_assert(std::is_trivially_copy_constructible<FakePointer<int>>::value, "");
+    static_assert(std::is_trivially_relocatable<FakePointer<int>>::value, "");
+
+    template<class T>
+    struct FakeAllocator : std::allocator<T> {
+        template<class U> struct rebind {
+            using other = FakeAllocator<U>;
+        };
+        using pointer = FakePointer<T>;
+    };
+
+    template<class K, class V> using alloc = FakeAllocator<std::pair<const K, V>>;
+    template<class K, class V> using unordered_map = std::unordered_map<K, V, std::hash<K>, std::equal_to<K>, alloc<K, V>>;
+}
+
+namespace fa4 {
+    template<class T>
+    struct FakePointer {
+        int offset;
+        FakePointer();
+        FakePointer(const FakePointer&);
+        FakePointer& operator=(const FakePointer&);
+        std::conditional_t<std::is_void<T>::value, char, T>& operator*() const;
+        T* operator->() const;
+        FakePointer operator + (unsigned int) const;
+        FakePointer& operator += (unsigned int);
+        FakePointer operator ++(int);
+        FakePointer& operator ++();
+        FakePointer operator --(int);
+        FakePointer& operator --();
+    };
+    static_assert(!std::is_trivially_copy_constructible<FakePointer<int>>::value, "");
+    static_assert(!std::is_trivially_relocatable<FakePointer<int>>::value, "");
+
+    template<class T>
+    struct FakeAllocator : std::allocator<T> {
+        template<class U> struct rebind {
+            using other = FakeAllocator<U>;
+        };
+        using pointer = FakePointer<T>;
+    };
+
+    template<class K, class V> using alloc = FakeAllocator<std::pair<const K, V>>;
+    template<class K, class V> using unordered_map = std::unordered_map<K, V, std::hash<K>, std::equal_to<K>, alloc<K, V>>;
+}
+
+namespace fa5 {
+    template<class T>
+    struct FakeHasher : std::hash<T> {
+        ~FakeHasher();
+    };
+    static_assert(!std::is_trivially_relocatable<FakeHasher<int>>::value, "");
+
+    template<class K, class V> using unordered_map = std::unordered_map<K, V, FakeHasher<K>, std::equal_to<K>>;
+}
+
+namespace fa6 {
+    template<class T>
+    struct FakeEqualTo : std::equal_to<T> {
+        ~FakeEqualTo();
+    };
+    static_assert(!std::is_trivially_relocatable<FakeEqualTo<int>>::value, "");
+
+    template<class K, class V> using unordered_map = std::unordered_map<K, V, std::hash<K>, FakeEqualTo<K>>;
+}
+
+static_assert(std::is_trivially_relocatable< std::allocator<int> >::value, "");
+static_assert(!std::is_trivially_relocatable< fa2::FakeAllocator<int> >::value, "");
+static_assert(std::is_trivially_relocatable< fa4::FakeAllocator<int> >::value, "");
+static_assert(!std::is_trivially_relocatable< fa4::FakePointer<int> >::value, "");
+
+template<class VT, bool Expected>
+void check_trivial_relocatability()
+{
+#if _LIBCPP_DEBUG_LEVEL >= 2
+    // Debugging adds significant operations to unordered_set's move-constructor and destructor.
+    static_assert(std::is_trivially_relocatable< VT >::value == false, "");
+#elif !__has_extension(trivially_relocatable)
+    // Making unordered_set trivially relocatable requires using the attribute.
+    static_assert(std::is_trivially_relocatable< VT >::value == false, "");
+#else
+    static_assert(std::is_trivially_relocatable< VT >::value == Expected, "");
+#endif
+}
+
+int main()
+{
+    check_trivial_relocatability< std::unordered_map<int, int>, true >();
+    check_trivial_relocatability< std::unordered_map<NonTriv, int>, true >();
+
+    check_trivial_relocatability< fa::unordered_map<int, int>, true >();
+    check_trivial_relocatability< fa::unordered_map<NonTriv, int>, true >();
+
+    check_trivial_relocatability< fa2::unordered_map<int, int>, false >();
+    check_trivial_relocatability< fa2::unordered_map<NonTriv, int>, false >();
+
+    check_trivial_relocatability< fa3::unordered_map<int, int>, true >();
+    check_trivial_relocatability< fa3::unordered_map<NonTriv, int>, true >();
+
+    check_trivial_relocatability< fa4::unordered_map<int, int>, false >();
+    check_trivial_relocatability< fa4::unordered_map<NonTriv, int>, false >();
+
+    check_trivial_relocatability< fa5::unordered_map<int, int>, false >();
+    check_trivial_relocatability< fa5::unordered_map<NonTriv, int>, false >();
+
+    check_trivial_relocatability< fa6::unordered_map<int, int>, false >();
+    check_trivial_relocatability< fa6::unordered_map<NonTriv, int>, false >();
+}

libcxx/test/libcxx/containers/unord/unord.set/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
+
+// <unordered_set>
+
+#include <unordered_set>
+#include <memory>
+#include <type_traits>
+
+// Define the P1144 name for convenience.
+#define is_trivially_relocatable __libcpp_is_trivially_relocatable
+
+
+struct NonTriv { ~NonTriv(); };
+template <> struct std::hash<NonTriv> { size_t operator()(const NonTriv&) const; };
+bool operator==(const NonTriv&, const NonTriv&);
+
+namespace fa {
+    template<class T>
+    struct FakeAllocator : std::allocator<T> {
+        template<class U> struct rebind {
+            using other = FakeAllocator<U>;
+        };
+        template<class U>
+        FakeAllocator(const FakeAllocator<U>&);
+        // The defaulted (trivial) copy constructor is still present here!
+    };
+    static_assert(std::is_trivially_copy_constructible<FakeAllocator<int>>::value, "");
+    static_assert(std::is_trivially_relocatable<FakeAllocator<int>>::value, "");
+
+    template<class T> using unordered_set = std::unordered_set<T, std::hash<T>, std::equal_to<T>, FakeAllocator<T>>;
+}
+
+namespace fa2 {
+    template<class T>
+    struct FakeAllocator : std::allocator<T> {
+        template<class U> struct rebind {
+            using other = FakeAllocator<U>;
+        };
+        template<class U>
+        FakeAllocator(const FakeAllocator<U>&);
+        FakeAllocator(const FakeAllocator&);
+    };
+    static_assert(!std::is_trivially_copy_constructible<FakeAllocator<int>>::value, "");
+    static_assert(!std::is_trivially_relocatable<FakeAllocator<int>>::value, "");
+
+    template<class T> using unordered_set = std::unordered_set<T, std::hash<T>, std::equal_to<T>, FakeAllocator<T>>;
+}
+
+namespace fa3 {
+    template<class T>
+    struct FakePointer {
+        int offset;
+        FakePointer();
+        FakePointer(const FakePointer&) = default;
+        FakePointer& operator=(const FakePointer&) = default;
+        std::conditional_t<std::is_void<T>::value, char, T>& operator*() const;
+        T* operator->() const;
+        FakePointer operator + (unsigned int) const;
+        FakePointer& operator += (unsigned int);
+        FakePointer operator ++(int);
+        FakePointer& operator ++();
+        FakePointer operator --(int);
+        FakePointer& operator --();
+    };
+    static_assert(std::is_trivially_copy_constructible<FakePointer<int>>::value, "");
+    static_assert(std::is_trivially_relocatable<FakePointer<int>>::value, "");
+
+    template<class T>
+    struct FakeAllocator : std::allocator<T> {
+        template<class U> struct rebind {
+            using other = FakeAllocator<U>;
+        };
+        using pointer = FakePointer<T>;
+    };
+
+    template<class T> using unordered_set = std::unordered_set<T, std::hash<T>, std::equal_to<T>, FakeAllocator<T>>;
+}
+
+namespace fa4 {
+    template<class T>
+    struct FakePointer {
+        int offset;
+        FakePointer();
+        FakePointer(const FakePointer&);
+        FakePointer& operator=(const FakePointer&);
+        std::conditional_t<std::is_void<T>::value, char, T>& operator*() const;
+        T* operator->() const;
+        FakePointer operator + (unsigned int) const;
+        FakePointer& operator += (unsigned int);
+        FakePointer operator ++(int);
+        FakePointer& operator ++();
+        FakePointer operator --(int);
+        FakePointer& operator --();
+    };
+    static_assert(!std::is_trivially_copy_constructible<FakePointer<int>>::value, "");
+    static_assert(!std::is_trivially_relocatable<FakePointer<int>>::value, "");
+
+    template<class T>
+    struct FakeAllocator : std::allocator<T> {
+        template<class U> struct rebind {
+            using other = FakeAllocator<U>;
+        };
+        using pointer = FakePointer<T>;
+    };
+
+    template<class T> using unordered_set = std::unordered_set<T, std::hash<T>, std::equal_to<T>, FakeAllocator<T>>;
+}
+
+namespace fa5 {
+    template<class T>
+    struct FakeHasher : std::hash<T> {
+        ~FakeHasher();
+    };
+    static_assert(!std::is_trivially_relocatable<FakeHasher<int>>::value, "");
+
+    template<class T> using unordered_set = std::unordered_set<T, FakeHasher<T>, std::equal_to<T>, std::allocator<T>>;
+}
+
+namespace fa6 {
+    template<class T>
+    struct FakeEqualTo : std::equal_to<T> {
+        ~FakeEqualTo();
+    };
+    static_assert(!std::is_trivially_relocatable<FakeEqualTo<int>>::value, "");
+
+    template<class T> using unordered_set = std::unordered_set<T, std::hash<T>, FakeEqualTo<T>, std::allocator<T>>;
+}
+
+static_assert(std::is_trivially_relocatable< std::allocator<int> >::value, "");
+static_assert(!std::is_trivially_relocatable< fa2::FakeAllocator<int> >::value, "");
+static_assert(std::is_trivially_relocatable< fa4::FakeAllocator<int> >::value, "");
+static_assert(!std::is_trivially_relocatable< fa4::FakePointer<int> >::value, "");
+
+template<class VT, bool Expected>
+void check_trivial_relocatability()
+{
+#if _LIBCPP_DEBUG_LEVEL >= 2
+    // Debugging adds significant operations to unordered_set's move-constructor and destructor.
+    static_assert(std::is_trivially_relocatable< VT >::value == false, "");
+#elif !__has_extension(trivially_relocatable)
+    // Making unordered_set trivially relocatable requires using the attribute.
+    static_assert(std::is_trivially_relocatable< VT >::value == false, "");
+#else
+    static_assert(std::is_trivially_relocatable< VT >::value == Expected, "");
+#endif
+}
+
+int main()
+{
+    check_trivial_relocatability< std::unordered_set<int>, true >();
+    check_trivial_relocatability< std::unordered_set<NonTriv>, true >();
+
+    check_trivial_relocatability< fa::unordered_set<int>, true >();
+    check_trivial_relocatability< fa::unordered_set<NonTriv>, true >();
+
+    check_trivial_relocatability< fa2::unordered_set<int>, false >();
+    check_trivial_relocatability< fa2::unordered_set<NonTriv>, false >();
+
+    check_trivial_relocatability< fa3::unordered_set<int>, true >();
+    check_trivial_relocatability< fa3::unordered_set<NonTriv>, true >();
+
+    check_trivial_relocatability< fa4::unordered_set<int>, false >();
+    check_trivial_relocatability< fa4::unordered_set<NonTriv>, false >();
+
+    check_trivial_relocatability< fa5::unordered_set<int>, false >();
+    check_trivial_relocatability< fa5::unordered_set<NonTriv>, false >();
+
+    check_trivial_relocatability< fa6::unordered_set<int>, false >();
+    check_trivial_relocatability< fa6::unordered_set<NonTriv>, false >();
+}

libcxx/test/libcxx/strings/basic.string/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
+
+// <string>
+
+#include <memory>
+#include <string>
+#include <type_traits>
+
+// Define the P1144 name for convenience.
+#define is_trivially_relocatable __libcpp_is_trivially_relocatable
+
+
+namespace fa {
+    template<class T>
+    struct FakeAllocator : std::allocator<T> {
+        template<class U> struct rebind {
+            using other = FakeAllocator<U>;
+        };
+        template<class U>
+        FakeAllocator(const FakeAllocator<U>&);
+        // The defaulted (trivial) copy constructor is still present here!
+    };
+    static_assert(std::is_trivially_copy_constructible<FakeAllocator<int>>::value, "");
+    static_assert(std::is_trivially_relocatable<FakeAllocator<int>>::value, "");
+
+    using string = std::basic_string<char, std::char_traits<char>, FakeAllocator<char>>;
+    using wstring = std::basic_string<wchar_t, std::char_traits<wchar_t>, FakeAllocator<wchar_t>>;
+}
+
+namespace fa2 {
+    template<class T>
+    struct FakeAllocator : std::allocator<T> {
+        template<class U> struct rebind {
+            using other = FakeAllocator<U>;
+        };
+        template<class U>
+        FakeAllocator(const FakeAllocator<U>&);
+        FakeAllocator(const FakeAllocator&);
+    };
+    static_assert(!std::is_trivially_copy_constructible<FakeAllocator<int>>::value, "");
+    static_assert(!std::is_trivially_relocatable<FakeAllocator<int>>::value, "");
+
+    using string = std::basic_string<char, std::char_traits<char>, FakeAllocator<char>>;
+    using wstring = std::basic_string<wchar_t, std::char_traits<wchar_t>, FakeAllocator<wchar_t>>;
+}
+
+namespace fa3 {
+    template<class T>
+    struct FakePointer {
+        int offset;
+        FakePointer();
+        FakePointer(const FakePointer&) = default;
+        FakePointer& operator=(const FakePointer&) = default;
+        T& operator*() const;
+        T* operator->() const;
+        FakePointer operator + (unsigned int) const;
+        FakePointer& operator += (unsigned int);
+        FakePointer operator ++(int);
+        FakePointer& operator ++();
+        FakePointer operator --(int);
+        FakePointer& operator --();
+    };
+    static_assert(std::is_trivially_copy_constructible<FakePointer<int>>::value, "");
+    static_assert(std::is_trivially_relocatable<FakePointer<int>>::value, "");
+
+    template<class T>
+    struct FakeAllocator : std::allocator<T> {
+        template<class U> struct rebind {
+            using other = FakeAllocator<U>;
+        };
+        using pointer = FakePointer<T>;
+    };
+
+    using string = std::basic_string<char, std::char_traits<char>, FakeAllocator<char>>;
+    using wstring = std::basic_string<wchar_t, std::char_traits<wchar_t>, FakeAllocator<wchar_t>>;
+}
+
+namespace fa4 {
+    template<class T>
+    struct FakePointer {
+        int offset;
+        FakePointer();
+        FakePointer(const FakePointer&);
+        FakePointer& operator=(const FakePointer&);
+        T& operator*() const;
+        T* operator->() const;
+        FakePointer operator + (unsigned int) const;
+        FakePointer& operator += (unsigned int);
+        FakePointer operator ++(int);
+        FakePointer& operator ++();
+        FakePointer operator --(int);
+        FakePointer& operator --();
+    };
+    static_assert(!std::is_trivially_copy_constructible<FakePointer<int>>::value, "");
+    static_assert(!std::is_trivially_relocatable<FakePointer<int>>::value, "");
+
+    template<class T>
+    struct FakeAllocator : std::allocator<T> {
+        template<class U> struct rebind {
+            using other = FakeAllocator<U>;
+        };
+        using pointer = FakePointer<T>;
+    };
+
+    using string = std::basic_string<char, std::char_traits<char>, FakeAllocator<char>>;
+    using wstring = std::basic_string<wchar_t, std::char_traits<wchar_t>, FakeAllocator<wchar_t>>;
+}
+
+
+static_assert(std::is_trivially_relocatable< std::allocator<int> >::value, "");
+static_assert(!std::is_trivially_relocatable< fa2::FakeAllocator<int> >::value, "");
+static_assert(std::is_trivially_relocatable< fa4::FakeAllocator<int> >::value, "");
+static_assert(!std::is_trivially_relocatable< fa4::FakePointer<int> >::value, "");
+
+template<class VT, bool Expected>
+void check_trivial_relocatability()
+{
+#if _LIBCPP_DEBUG_LEVEL >= 2
+    // Debugging adds significant operations to string's move-constructor and destructor.
+    static_assert(std::is_trivially_relocatable< VT >::value == false, "");
+#elif !__has_extension(trivially_relocatable)
+    // Making string trivially relocatable requires using the attribute.
+    static_assert(std::is_trivially_relocatable< VT >::value == false, "");
+#else
+    static_assert(std::is_trivially_relocatable< VT >::value == Expected, "");
+#endif
+}
+
+int main()
+{
+    check_trivial_relocatability< std::string, true >();
+    check_trivial_relocatability< std::wstring, true >();
+
+    check_trivial_relocatability< fa::string, true >();
+    check_trivial_relocatability< fa::wstring, true >();
+
+    check_trivial_relocatability< fa2::string, false >();
+    check_trivial_relocatability< fa2::wstring, false >();
+
+    check_trivial_relocatability< fa3::string, true >();
+    check_trivial_relocatability< fa3::wstring, true >();
+
+    check_trivial_relocatability< fa4::string, false >();
+    check_trivial_relocatability< fa4::wstring, false >();
+}

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

 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;
+    struct Cmp {
+        Cmp(); Cmp(const Cmp&); ~Cmp();
+        bool operator()(const K&, 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 the P1144 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::memory_resource>::value, "");  // virtual destructor
 //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::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::locale>::value, "");
+static_assert(std::is_trivially_relocatable<std::exception_ptr>::value, "");
+static_assert(!std::is_trivially_relocatable<std::exception>::value, "");  // virtual destructor
 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::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::unordered_map<K,T>>::value == NotDebug, "");
+static_assert(std::is_trivially_relocatable<std::unordered_multimap<K,T>>::value == NotDebug, "");
+static_assert(std::is_trivially_relocatable<std::unordered_multiset<K>>::value == NotDebug, "");
+static_assert(std::is_trivially_relocatable<std::unordered_set<K>>::value == NotDebug, "");
+static_assert(std::is_trivially_relocatable<std::vector<T>>::value == NotDebug, "");
+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::stack<T, std::list<T>>>::value, "");
+static_assert(std::is_trivially_relocatable<std::queue<T>>::value, "");
+static_assert(!std::is_trivially_relocatable<std::queue<T, std::list<T>>>::value, "");
+static_assert(std::is_trivially_relocatable<std::priority_queue<K>>::value == NotDebug, "");
+static_assert(std::is_trivially_relocatable<std::priority_queue<K, std::deque<K>>>::value, "");
+static_assert(!std::is_trivially_relocatable<std::priority_queue<K, std::deque<K>, K::Cmp>>::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::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::regex_traits<char>>::value, "");  // contains a locale
+static_assert(std::is_trivially_relocatable<std::regex>::value, "");  // contains a regex_traits
+static_assert(std::is_trivially_relocatable<std::cmatch>::value == NotDebug, "");  // contains a vector
+static_assert(std::is_trivially_relocatable<std::smatch>::value == NotDebug, "");  // contains a vector
+static_assert(std::is_trivially_relocatable<std::string>::value == NotDebug, "");
 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>::value == NotDebug, "");
 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::cmatch>::value == NotDebug, "");  // contains a vector
+//static_assert(std::is_trivially_relocatable<std::pmr::smatch>::value == NotDebug, "");  // contains a vector
 //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::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::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, "");

libcxx/test/libcxx/utilities/memory/util.smartptr/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++03
+//
+// <memory>
+//
+// class shared_ptr
+// class unique_ptr
+// class weak_ptr
+
+#include <memory>
+
+// Define the P1144 name for convenience.
+#define is_trivially_relocatable __libcpp_is_trivially_relocatable
+
+
+class Incomplete;
+class NonTriv { ~NonTriv(); };
+class _LIBCPP_TRIVIALLY_RELOCATABLE Reloc { ~Reloc(); };
+
+static_assert(std::is_trivially_relocatable<int>::value, "");
+static_assert(!std::is_trivially_relocatable<NonTriv>::value, "");
+#if __has_extension(trivially_relocatable)
+static_assert(std::is_trivially_relocatable<Reloc>::value, "");
+#endif
+
+#if __has_extension(trivially_relocatable)
+static_assert(std::is_trivially_relocatable< std::shared_ptr<int> >::value, "");
+static_assert(std::is_trivially_relocatable< std::shared_ptr<Incomplete> >::value, "");
+static_assert(std::is_trivially_relocatable< std::shared_ptr<NonTriv> >::value, "");
+
+static_assert(std::is_trivially_relocatable< std::weak_ptr<int> >::value, "");
+static_assert(std::is_trivially_relocatable< std::weak_ptr<Incomplete> >::value, "");
+static_assert(std::is_trivially_relocatable< std::weak_ptr<NonTriv> >::value, "");
+
+static_assert(std::is_trivially_relocatable< std::default_delete<int> >::value, "");
+static_assert(std::is_trivially_relocatable< std::unique_ptr<int> >::value, "");
+static_assert(std::is_trivially_relocatable< std::unique_ptr<Incomplete> >::value, "");
+static_assert(std::is_trivially_relocatable< std::unique_ptr<NonTriv> >::value, "");
+
+static_assert(std::is_trivially_relocatable< std::default_delete<int[]> >::value, "");
+static_assert(std::is_trivially_relocatable< std::unique_ptr<int[]> >::value, "");
+static_assert(std::is_trivially_relocatable< std::unique_ptr<Incomplete[]> >::value, "");
+static_assert(std::is_trivially_relocatable< std::unique_ptr<NonTriv[]> >::value, "");
+#endif
+
+int main() {}

libcxx/test/libcxx/utilities/memory/util.smartptr/trivially_relocatable_with_deleter.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
+
+// <memory>
+
+// template<class T, class D> class unique_ptr;
+
+#include <memory>
+#include <type_traits>
+
+// Define the P1144 name for convenience.
+#define is_trivially_relocatable __libcpp_is_trivially_relocatable
+
+
+struct Incomplete;
+struct NonTriv { ~NonTriv(); };
+
+namespace fa {
+    template<class T>
+    struct FakeDeleter {
+        using pointer = T*;
+        void operator()(pointer p) const;
+    };
+    static_assert(std::is_trivially_copy_constructible<FakeDeleter<int>>::value, "");
+    static_assert(std::is_trivially_relocatable<FakeDeleter<int>>::value, "");
+
+    template<class T> using unique_ptr = std::unique_ptr<T, FakeDeleter<T>>;
+}
+
+namespace fa2 {
+    template<class T>
+    struct FakeDeleter {
+        using pointer = T*;
+        ~FakeDeleter();
+        void operator()(pointer p) const;
+    };
+    static_assert(!std::is_trivially_destructible<FakeDeleter<int>>::value, "");
+    static_assert(!std::is_trivially_relocatable<FakeDeleter<int>>::value, "");
+
+    template<class T> using unique_ptr = std::unique_ptr<T, FakeDeleter<T>>;
+}
+
+namespace fa3 {
+    template<class T>
+    struct FakePointer {
+        int offset;
+        FakePointer();
+        FakePointer(const FakePointer&) = default;
+        FakePointer& operator=(const FakePointer&) = default;
+        T& operator*() const;
+        T* operator->() const;
+        FakePointer operator + (unsigned int) const;
+        FakePointer& operator += (unsigned int);
+        FakePointer operator ++(int);
+        FakePointer& operator ++();
+        FakePointer operator --(int);
+        FakePointer& operator --();
+    };
+    static_assert(std::is_trivially_copy_constructible<FakePointer<int>>::value, "");
+    static_assert(std::is_trivially_relocatable<FakePointer<int>>::value, "");
+
+    template<class T>
+    struct FakeDeleter {
+        using pointer = FakePointer<T>;
+        void operator()(pointer p) const;
+    };
+
+    template<class T> using unique_ptr = std::unique_ptr<T, FakeDeleter<T>>;
+}
+
+namespace fa4 {
+    template<class T>
+    struct FakePointer {
+        int offset;
+        FakePointer();
+        FakePointer(const FakePointer&);
+        FakePointer& operator=(const FakePointer&);
+        T& operator*() const;
+        T* operator->() const;
+        FakePointer operator + (unsigned int) const;
+        FakePointer& operator += (unsigned int);
+        FakePointer operator ++(int);
+        FakePointer& operator ++();
+        FakePointer operator --(int);
+        FakePointer& operator --();
+    };
+    static_assert(!std::is_trivially_copy_constructible<FakePointer<int>>::value, "");
+    static_assert(!std::is_trivially_relocatable<FakePointer<int>>::value, "");
+
+    template<class T>
+    struct FakeDeleter {
+        using pointer = FakePointer<T>;
+        void operator()(pointer p) const;
+    };
+
+    template<class T> using unique_ptr = std::unique_ptr<T, FakeDeleter<T>>;
+}
+
+
+static_assert(std::is_trivially_relocatable< std::default_delete<int> >::value, "");
+static_assert(std::is_trivially_relocatable< std::default_delete<int[]> >::value, "");
+static_assert(!std::is_trivially_relocatable< fa2::FakeDeleter<int> >::value, "");
+static_assert(std::is_trivially_relocatable< typename fa2::FakeDeleter<int>::pointer >::value, "");
+static_assert(std::is_trivially_relocatable< fa4::FakeDeleter<int> >::value, "");
+static_assert(!std::is_trivially_relocatable< typename fa4::FakeDeleter<int>::pointer >::value, "");
+
+template<class T, bool Expected>
+void check_trivial_relocatability()
+{
+#if __has_extension(trivially_relocatable)
+    static_assert(std::is_trivially_relocatable< T >::value == Expected, "");
+#else
+    // Making unique_ptr trivially relocatable requires using the attribute.
+    static_assert(std::is_trivially_relocatable< T >::value == false, "");
+#endif
+}
+
+int main()
+{
+    check_trivial_relocatability< std::unique_ptr<int>, true >();
+    check_trivial_relocatability< std::unique_ptr<Incomplete>, true >();
+    check_trivial_relocatability< std::unique_ptr<NonTriv>, true >();
+    check_trivial_relocatability< std::unique_ptr<int[]>, true >();
+    check_trivial_relocatability< std::unique_ptr<Incomplete[]>, true >();
+    check_trivial_relocatability< std::unique_ptr<NonTriv[]>, true >();
+
+    check_trivial_relocatability< fa::unique_ptr<int>, true >();
+    check_trivial_relocatability< fa::unique_ptr<Incomplete>, true >();
+    check_trivial_relocatability< fa::unique_ptr<NonTriv>, true >();
+    check_trivial_relocatability< std::unique_ptr<int[]>, true >();
+    check_trivial_relocatability< std::unique_ptr<Incomplete[]>, true >();
+    check_trivial_relocatability< std::unique_ptr<NonTriv[]>, true >();
+
+    check_trivial_relocatability< fa2::unique_ptr<int>, false >();
+    check_trivial_relocatability< fa2::unique_ptr<Incomplete>, false >();
+    check_trivial_relocatability< fa2::unique_ptr<NonTriv>, false >();
+    check_trivial_relocatability< fa2::unique_ptr<int[]>, false >();
+    check_trivial_relocatability< fa2::unique_ptr<Incomplete[]>, false >();
+    check_trivial_relocatability< fa2::unique_ptr<NonTriv[]>, false >();
+
+    check_trivial_relocatability< fa3::unique_ptr<int>, true >();
+    check_trivial_relocatability< fa3::unique_ptr<Incomplete>, true >();
+    check_trivial_relocatability< fa3::unique_ptr<NonTriv>, true >();
+    check_trivial_relocatability< fa3::unique_ptr<int[]>, true >();
+    check_trivial_relocatability< fa3::unique_ptr<Incomplete[]>, true >();
+    check_trivial_relocatability< fa3::unique_ptr<NonTriv[]>, true >();
+
+    check_trivial_relocatability< fa4::unique_ptr<int>, false >();
+    check_trivial_relocatability< fa4::unique_ptr<Incomplete>, false >();
+    check_trivial_relocatability< fa4::unique_ptr<NonTriv>, false >();
+    check_trivial_relocatability< fa4::unique_ptr<int[]>, false >();
+    check_trivial_relocatability< fa4::unique_ptr<Incomplete[]>, false >();
+    check_trivial_relocatability< fa4::unique_ptr<NonTriv[]>, false >();
+}

libcxx/test/libcxx/utilities/optional/optional.object/trivial_copy_move_ABI.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.
+//
+//===----------------------------------------------------------------------===//
+
+// The test fails due to the missing is_trivially_constructible intrinsic.
+// XFAIL: gcc-4.9
+// UNSUPPORTED: c++03, c++11, c++14
+
+// <optional>
+
+// template <class T> class optional
+
+// Test that we properly provide the trivial copy operations by default.
+
+// FreeBSD provides the old ABI. This test checks the new ABI so we need
+// to manually turn it on.
+#if defined(__FreeBSD__)
+#define _LIBCPP_ABI_UNSTABLE
+#endif
+
+#include <optional>
+#include <type_traits>
+#include <utility>
+#include <cstdlib>
+#include <cassert>
+
+#include "test_macros.h"
+
+// Define the P1144 name for convenience.
+#define is_trivially_relocatable __libcpp_is_trivially_relocatable
+
+
+#if defined(_LIBCPP_DEPRECATED_ABI_DISABLE_PAIR_TRIVIAL_COPY_CTOR)
+#error Non-trivial ctor ABI macro defined
+#endif
+
+template <class T>
+struct HasTrivialABI : std::integral_constant<bool,
+    std::is_trivially_destructible<T>::value
+    && (!std::is_copy_constructible<T>::value || std::is_trivially_copy_constructible<T>::value)
+#if TEST_STD_VER >= 11
+   && (!std::is_move_constructible<T>::value || std::is_trivially_move_constructible<T>::value)
+#endif
+> {};
+
+#if TEST_STD_VER >= 11
+struct NonTrivialDtor {
+    NonTrivialDtor(NonTrivialDtor const&) = default;
+    ~NonTrivialDtor();
+};
+NonTrivialDtor::~NonTrivialDtor() {}
+static_assert(!HasTrivialABI<NonTrivialDtor>::value, "");
+
+struct NonTrivialCopy {
+    NonTrivialCopy(NonTrivialCopy const&);
+};
+NonTrivialCopy::NonTrivialCopy(NonTrivialCopy const&) {}
+static_assert(!HasTrivialABI<NonTrivialCopy>::value, "");
+
+struct NonTrivialMove {
+    NonTrivialMove(NonTrivialMove const&) = default;
+    NonTrivialMove(NonTrivialMove&&);
+};
+NonTrivialMove::NonTrivialMove(NonTrivialMove&&) {}
+static_assert(!HasTrivialABI<NonTrivialMove>::value, "");
+
+struct DeletedCopy {
+    DeletedCopy(DeletedCopy const&) = delete;
+    DeletedCopy(DeletedCopy&&) = default;
+};
+static_assert(HasTrivialABI<DeletedCopy>::value, "");
+
+struct TrivialMove {
+  TrivialMove(TrivialMove &&) = default;
+};
+static_assert(HasTrivialABI<TrivialMove>::value, "");
+
+struct Trivial {
+    Trivial(Trivial const&) = default;
+};
+static_assert(HasTrivialABI<Trivial>::value, "");
+#endif
+
+struct _LIBCPP_TRIVIALLY_RELOCATABLE TrivialRelocEmpty {
+    TrivialRelocEmpty(const TrivialRelocEmpty&);
+    TrivialRelocEmpty(TrivialRelocEmpty&&);
+    ~TrivialRelocEmpty();
+};
+#if __has_extension(trivially_relocatable)
+static_assert(std::is_trivially_relocatable<TrivialRelocEmpty>::value, "");
+#endif
+
+struct _LIBCPP_TRIVIALLY_RELOCATABLE TrivialReloc {
+    int i;
+    TrivialReloc(const TrivialReloc&);
+    TrivialReloc(TrivialReloc&&);
+    ~TrivialReloc();
+};
+#if __has_extension(trivially_relocatable)
+static_assert(std::is_trivially_relocatable<TrivialReloc>::value, "");
+#endif
+
+int main()
+{
+    {
+        typedef std::optional<short> P;
+        static_assert(std::is_copy_constructible<P>::value, "");
+        static_assert(HasTrivialABI<P>::value, "");
+        static_assert(std::is_trivially_relocatable<P>::value, "");
+    }
+#if TEST_STD_VER >= 11
+    {
+        typedef std::optional<short> P;
+        static_assert(std::is_move_constructible<P>::value, "");
+        static_assert(HasTrivialABI<P>::value, "");
+        static_assert(std::is_trivially_relocatable<P>::value, "");
+    }
+    {
+        using P = std::optional<NonTrivialDtor>;
+        static_assert(!std::is_trivially_destructible<P>::value, "");
+        static_assert(std::is_copy_constructible<P>::value, "");
+        static_assert(!std::is_trivially_copy_constructible<P>::value, "");
+        static_assert(std::is_move_constructible<P>::value, "");
+        static_assert(!std::is_trivially_move_constructible<P>::value, "");
+        static_assert(!HasTrivialABI<P>::value, "");
+        static_assert(!std::is_trivially_relocatable<P>::value, "");
+    }
+    {
+        using P = std::optional<NonTrivialCopy>;
+        static_assert(std::is_copy_constructible<P>::value, "");
+        static_assert(!std::is_trivially_copy_constructible<P>::value, "");
+        static_assert(std::is_move_constructible<P>::value, "");
+        static_assert(!std::is_trivially_move_constructible<P>::value, "");
+        static_assert(!HasTrivialABI<P>::value, "");
+        static_assert(!std::is_trivially_relocatable<P>::value, "");
+    }
+    {
+        using P = std::optional<NonTrivialMove>;
+        static_assert(std::is_copy_constructible<P>::value, "");
+        static_assert(std::is_trivially_copy_constructible<P>::value, "");
+        static_assert(std::is_move_constructible<P>::value, "");
+        static_assert(!std::is_trivially_move_constructible<P>::value, "");
+        static_assert(!HasTrivialABI<P>::value, "");
+        static_assert(!std::is_trivially_relocatable<P>::value, "");
+    }
+    {
+        using P = std::optional<DeletedCopy>;
+        static_assert(!std::is_copy_constructible<P>::value, "");
+        static_assert(!std::is_trivially_copy_constructible<P>::value, "");
+        static_assert(std::is_move_constructible<P>::value, "");
+        static_assert(std::is_trivially_move_constructible<P>::value, "");
+        static_assert(HasTrivialABI<P>::value, "");
+        static_assert(std::is_trivially_relocatable<P>::value, "");
+    }
+    {
+        using P = std::optional<Trivial>;
+        static_assert(std::is_copy_constructible<P>::value, "");
+        static_assert(std::is_trivially_copy_constructible<P>::value, "");
+        static_assert(std::is_move_constructible<P>::value, "");
+        static_assert(std::is_trivially_move_constructible<P>::value, "");
+        static_assert(HasTrivialABI<P>::value, "");
+        static_assert(std::is_trivially_relocatable<P>::value, "");
+    }
+    {
+        using P = std::optional<TrivialMove>;
+        static_assert(!std::is_copy_constructible<P>::value, "");
+        static_assert(!std::is_trivially_copy_constructible<P>::value, "");
+        static_assert(std::is_move_constructible<P>::value, "");
+        static_assert(std::is_trivially_move_constructible<P>::value, "");
+        static_assert(HasTrivialABI<P>::value, "");
+        static_assert(std::is_trivially_relocatable<P>::value, "");
+    }
+#if __has_extension(trivially_relocatable)
+    {
+        using P = std::optional<TrivialReloc>;
+        static_assert(std::is_copy_constructible<P>::value, "");
+        static_assert(!std::is_trivially_copy_constructible<P>::value, "");
+        static_assert(std::is_move_constructible<P>::value, "");
+        static_assert(!std::is_trivially_move_constructible<P>::value, "");
+        static_assert(!HasTrivialABI<P>::value, "");
+        static_assert(std::is_trivially_relocatable<P>::value, "");
+    }
+    {
+        using P = std::optional<TrivialRelocEmpty>;
+        static_assert(std::is_copy_constructible<P>::value, "");
+        static_assert(!std::is_trivially_copy_constructible<P>::value, "");
+        static_assert(std::is_move_constructible<P>::value, "");
+        static_assert(!std::is_trivially_move_constructible<P>::value, "");
+        static_assert(!HasTrivialABI<P>::value, "");
+        static_assert(std::is_trivially_relocatable<P>::value, "");
+    }
+#endif
+#endif
+}

libcxx/test/libcxx/utilities/tuple/tuple.tuple/trivial_copy_move_ABI.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.
+//
+//===----------------------------------------------------------------------===//
+
+// The test fails due to the missing is_trivially_constructible intrinsic.
+// XFAIL: gcc-4.9
+// UNSUPPORTED: c++03
+
+// <tuple>
+
+// template <class... Ts> struct tuple
+
+// Test that we properly provide the trivial copy operations by default.
+
+// FreeBSD provides the old ABI. This test checks the new ABI so we need
+// to manually turn it on.
+#if defined(__FreeBSD__)
+#define _LIBCPP_ABI_UNSTABLE
+#endif
+
+#include <utility>
+#include <tuple>
+#include <type_traits>
+#include <cstdlib>
+#include <cassert>
+
+#include "test_macros.h"
+
+// Define the P1144 name for convenience.
+#define is_trivially_relocatable __libcpp_is_trivially_relocatable
+
+
+#if defined(_LIBCPP_DEPRECATED_ABI_DISABLE_PAIR_TRIVIAL_COPY_CTOR)
+#error Non-trivial ctor ABI macro defined
+#endif
+
+template <class T>
+struct HasTrivialABI : std::integral_constant<bool,
+    std::is_trivially_destructible<T>::value
+    && (!std::is_copy_constructible<T>::value || std::is_trivially_copy_constructible<T>::value)
+#if TEST_STD_VER >= 11
+   && (!std::is_move_constructible<T>::value || std::is_trivially_move_constructible<T>::value)
+#endif
+> {};
+
+#if TEST_STD_VER >= 11
+struct NonTrivialDtor {
+    NonTrivialDtor(NonTrivialDtor const&) = default;
+    ~NonTrivialDtor();
+};
+NonTrivialDtor::~NonTrivialDtor() {}
+static_assert(!HasTrivialABI<NonTrivialDtor>::value, "");
+
+struct NonTrivialCopy {
+    NonTrivialCopy(NonTrivialCopy const&);
+};
+NonTrivialCopy::NonTrivialCopy(NonTrivialCopy const&) {}
+static_assert(!HasTrivialABI<NonTrivialCopy>::value, "");
+
+struct NonTrivialMove {
+    NonTrivialMove(NonTrivialMove const&) = default;
+    NonTrivialMove(NonTrivialMove&&);
+};
+NonTrivialMove::NonTrivialMove(NonTrivialMove&&) {}
+static_assert(!HasTrivialABI<NonTrivialMove>::value, "");
+
+struct DeletedCopy {
+    DeletedCopy(DeletedCopy const&) = delete;
+    DeletedCopy(DeletedCopy&&) = default;
+};
+static_assert(HasTrivialABI<DeletedCopy>::value, "");
+
+struct TrivialMove {
+  TrivialMove(TrivialMove &&) = default;
+};
+static_assert(HasTrivialABI<TrivialMove>::value, "");
+
+struct Trivial {
+    Trivial(Trivial const&) = default;
+};
+static_assert(HasTrivialABI<Trivial>::value, "");
+#endif
+
+struct _LIBCPP_TRIVIALLY_RELOCATABLE TrivialRelocEmpty {
+    TrivialRelocEmpty(const TrivialRelocEmpty&);
+    TrivialRelocEmpty(TrivialRelocEmpty&&);
+    ~TrivialRelocEmpty();
+};
+#if __has_extension(trivially_relocatable)
+static_assert(std::is_trivially_relocatable<TrivialRelocEmpty>::value, "");
+#endif
+
+struct _LIBCPP_TRIVIALLY_RELOCATABLE TrivialReloc {
+    int i;
+    TrivialReloc(const TrivialReloc&);
+    TrivialReloc(TrivialReloc&&);
+    ~TrivialReloc();
+};
+#if __has_extension(trivially_relocatable)
+static_assert(std::is_trivially_relocatable<TrivialReloc>::value, "");
+#endif
+
+int main()
+{
+    {
+        typedef std::tuple<int, int, short> P;
+        static_assert(std::is_copy_constructible<P>::value, "");
+        static_assert(HasTrivialABI<P>::value, "");
+        static_assert(std::is_trivially_relocatable<P>::value, "");
+    }
+#if TEST_STD_VER >= 11
+    {
+        typedef std::tuple<int, int, short> P;
+        static_assert(std::is_move_constructible<P>::value, "");
+        static_assert(HasTrivialABI<P>::value, "");
+        static_assert(std::is_trivially_relocatable<P>::value, "");
+    }
+    {
+        using P = std::tuple<int, NonTrivialDtor, int>;
+        static_assert(!std::is_trivially_destructible<P>::value, "");
+        static_assert(std::is_copy_constructible<P>::value, "");
+        static_assert(!std::is_trivially_copy_constructible<P>::value, "");
+        static_assert(std::is_move_constructible<P>::value, "");
+        static_assert(!std::is_trivially_move_constructible<P>::value, "");
+        static_assert(!HasTrivialABI<P>::value, "");
+        static_assert(!std::is_trivially_relocatable<P>::value, "");
+    }
+    {
+        using P = std::tuple<int, NonTrivialCopy, int>;
+        static_assert(std::is_copy_constructible<P>::value, "");
+        static_assert(!std::is_trivially_copy_constructible<P>::value, "");
+        static_assert(std::is_move_constructible<P>::value, "");
+        static_assert(!std::is_trivially_move_constructible<P>::value, "");
+        static_assert(!HasTrivialABI<P>::value, "");
+        static_assert(!std::is_trivially_relocatable<P>::value, "");
+    }
+    {
+        using P = std::tuple<int, NonTrivialMove, int>;
+        static_assert(std::is_copy_constructible<P>::value, "");
+        static_assert(std::is_trivially_copy_constructible<P>::value, "");
+        static_assert(std::is_move_constructible<P>::value, "");
+        static_assert(!std::is_trivially_move_constructible<P>::value, "");
+        static_assert(!HasTrivialABI<P>::value, "");
+        static_assert(!std::is_trivially_relocatable<P>::value, "");
+    }
+    {
+        using P = std::tuple<int, DeletedCopy, int>;
+        static_assert(!std::is_copy_constructible<P>::value, "");
+        static_assert(!std::is_trivially_copy_constructible<P>::value, "");
+        static_assert(std::is_move_constructible<P>::value, "");
+        static_assert(std::is_trivially_move_constructible<P>::value, "");
+        static_assert(HasTrivialABI<P>::value, "");
+        static_assert(std::is_trivially_relocatable<P>::value, "");
+    }
+    {
+        using P = std::tuple<int, Trivial, int>;
+        static_assert(std::is_copy_constructible<P>::value, "");
+        static_assert(std::is_trivially_copy_constructible<P>::value, "");
+        static_assert(std::is_move_constructible<P>::value, "");
+        static_assert(std::is_trivially_move_constructible<P>::value, "");
+        static_assert(HasTrivialABI<P>::value, "");
+        static_assert(std::is_trivially_relocatable<P>::value, "");
+    }
+    {
+        using P = std::tuple<int, TrivialMove, int>;
+        static_assert(!std::is_copy_constructible<P>::value, "");
+        static_assert(!std::is_trivially_copy_constructible<P>::value, "");
+        static_assert(std::is_move_constructible<P>::value, "");
+        static_assert(std::is_trivially_move_constructible<P>::value, "");
+        static_assert(HasTrivialABI<P>::value, "");
+        static_assert(std::is_trivially_relocatable<P>::value, "");
+    }
+#if __has_extension(trivially_relocatable)
+    {
+        using P = std::tuple<int, TrivialReloc, int>;
+        static_assert(std::is_copy_constructible<P>::value, "");
+        static_assert(!std::is_trivially_copy_constructible<P>::value, "");
+        static_assert(std::is_move_constructible<P>::value, "");
+        static_assert(!std::is_trivially_move_constructible<P>::value, "");
+        static_assert(!HasTrivialABI<P>::value, "");
+        static_assert(std::is_trivially_relocatable<P>::value, "");
+    }
+    {
+        using P = std::tuple<int, TrivialRelocEmpty, int>;
+        static_assert(std::is_copy_constructible<P>::value, "");
+        static_assert(!std::is_trivially_copy_constructible<P>::value, "");
+        static_assert(std::is_move_constructible<P>::value, "");
+        static_assert(!std::is_trivially_move_constructible<P>::value, "");
+        static_assert(!HasTrivialABI<P>::value, "");
+        static_assert(std::is_trivially_relocatable<P>::value, "");
+    }
+#endif
+#endif
+}

libcxx/test/libcxx/utilities/utility/pairs/pairs.pair/trivial_copy_move_ABI.pass.cpp

 #include <utility>
 #include <type_traits>
 #include <cstdlib>
 #include <cstddef>
 #include <cassert>
 
 #include "test_macros.h"
 
+// Define the P1144 name for convenience.
+#define is_trivially_relocatable __libcpp_is_trivially_relocatable
+
+
 #if defined(_LIBCPP_DEPRECATED_ABI_DISABLE_PAIR_TRIVIAL_COPY_CTOR)
 #error Non-trivial ctor ABI macro defined
 #endif
 
 template <class T>
 struct HasTrivialABI : std::integral_constant<bool,
     std::is_trivially_destructible<T>::value
     && (!std::is_copy_constructible<T>::value || std::is_trivially_copy_constructible<T>::value)

 static_assert(HasTrivialABI<TrivialMove>::value, "");
 
 struct Trivial {
     Trivial(Trivial const&) = default;
 };
 static_assert(HasTrivialABI<Trivial>::value, "");
 #endif
 
+struct _LIBCPP_TRIVIALLY_RELOCATABLE TrivialRelocEmpty {
+    TrivialRelocEmpty(const TrivialRelocEmpty&);
+    TrivialRelocEmpty(TrivialRelocEmpty&&);
+    ~TrivialRelocEmpty();
+};
+#if __has_extension(trivially_relocatable)
+static_assert(std::is_trivially_relocatable<TrivialRelocEmpty>::value, "");
+#endif
+
+struct _LIBCPP_TRIVIALLY_RELOCATABLE TrivialReloc {
+    int i;
+    TrivialReloc(const TrivialReloc&);
+    TrivialReloc(TrivialReloc&&);
+    ~TrivialReloc();
+};
+#if __has_extension(trivially_relocatable)
+static_assert(std::is_trivially_relocatable<TrivialReloc>::value, "");
+#endif
 
 void test_trivial()
 {
     {
         typedef std::pair<int, short> P;
         static_assert(std::is_copy_constructible<P>::value, "");
         static_assert(HasTrivialABI<P>::value, "");
+        static_assert(std::is_trivially_relocatable<P>::value, "");
     }
 #if TEST_STD_VER >= 11
     {
         typedef std::pair<int, short> P;
         static_assert(std::is_move_constructible<P>::value, "");
         static_assert(HasTrivialABI<P>::value, "");
+        static_assert(std::is_trivially_relocatable<P>::value, "");
     }
     {
         using P = std::pair<NonTrivialDtor, int>;
         static_assert(!std::is_trivially_destructible<P>::value, "");
         static_assert(std::is_copy_constructible<P>::value, "");
         static_assert(!std::is_trivially_copy_constructible<P>::value, "");
         static_assert(std::is_move_constructible<P>::value, "");
         static_assert(!std::is_trivially_move_constructible<P>::value, "");
         static_assert(!HasTrivialABI<P>::value, "");
+        static_assert(!std::is_trivially_relocatable<P>::value, "");
     }
     {
         using P = std::pair<NonTrivialCopy, int>;
         static_assert(std::is_copy_constructible<P>::value, "");
         static_assert(!std::is_trivially_copy_constructible<P>::value, "");
         static_assert(std::is_move_constructible<P>::value, "");
         static_assert(!std::is_trivially_move_constructible<P>::value, "");
         static_assert(!HasTrivialABI<P>::value, "");
+        static_assert(!std::is_trivially_relocatable<P>::value, "");
     }
     {
         using P = std::pair<NonTrivialMove, int>;
         static_assert(std::is_copy_constructible<P>::value, "");
         static_assert(std::is_trivially_copy_constructible<P>::value, "");
         static_assert(std::is_move_constructible<P>::value, "");
         static_assert(!std::is_trivially_move_constructible<P>::value, "");
         static_assert(!HasTrivialABI<P>::value, "");
+        static_assert(!std::is_trivially_relocatable<P>::value, "");
     }
     {
         using P = std::pair<DeletedCopy, int>;
         static_assert(!std::is_copy_constructible<P>::value, "");
         static_assert(!std::is_trivially_copy_constructible<P>::value, "");
         static_assert(std::is_move_constructible<P>::value, "");
         static_assert(std::is_trivially_move_constructible<P>::value, "");
         static_assert(HasTrivialABI<P>::value, "");
+        static_assert(std::is_trivially_relocatable<P>::value, "");
     }
     {
         using P = std::pair<Trivial, int>;
         static_assert(std::is_copy_constructible<P>::value, "");
         static_assert(std::is_trivially_copy_constructible<P>::value, "");
         static_assert(std::is_move_constructible<P>::value, "");
         static_assert(std::is_trivially_move_constructible<P>::value, "");
         static_assert(HasTrivialABI<P>::value, "");
+        static_assert(std::is_trivially_relocatable<P>::value, "");
     }
     {
         using P = std::pair<TrivialMove, int>;
         static_assert(!std::is_copy_constructible<P>::value, "");
         static_assert(!std::is_trivially_copy_constructible<P>::value, "");
         static_assert(std::is_move_constructible<P>::value, "");
         static_assert(std::is_trivially_move_constructible<P>::value, "");
         static_assert(HasTrivialABI<P>::value, "");
+        static_assert(std::is_trivially_relocatable<P>::value, "");
+    }
+#if __has_extension(trivially_relocatable)
+    {
+        using P = std::pair<TrivialReloc, int>;
+        static_assert(std::is_copy_constructible<P>::value, "");
+        static_assert(!std::is_trivially_copy_constructible<P>::value, "");
+        static_assert(std::is_move_constructible<P>::value, "");
+        static_assert(!std::is_trivially_move_constructible<P>::value, "");
+        static_assert(!HasTrivialABI<P>::value, "");
+        static_assert(std::is_trivially_relocatable<P>::value, "");
     }
+    {
+        using P = std::pair<TrivialRelocEmpty, int>;
+        static_assert(std::is_copy_constructible<P>::value, "");
+        static_assert(!std::is_trivially_copy_constructible<P>::value, "");
+        static_assert(std::is_move_constructible<P>::value, "");
+        static_assert(!std::is_trivially_move_constructible<P>::value, "");
+        static_assert(!HasTrivialABI<P>::value, "");
+        static_assert(std::is_trivially_relocatable<P>::value, "");
+    }
+#endif
 #endif
 }
 
 void test_layout() {
     typedef std::pair<std::pair<char, char>, char> PairT;
     static_assert(sizeof(PairT) == 3, "");
     static_assert(TEST_ALIGNOF(PairT) == TEST_ALIGNOF(char), "");
     static_assert(offsetof(PairT, first) == 0, "");
 }
 
 int main(int, char**) {
     test_trivial();
     test_layout();
     return 0;
 }

libcxx/test/libcxx/utilities/variant/variant.variant/trivial_copy_move_ABI.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.
+//
+//===----------------------------------------------------------------------===//
+
+// The test fails due to the missing is_trivially_constructible intrinsic.
+// XFAIL: gcc-4.9
+// UNSUPPORTED: c++03, c++11, c++14
+
+// <variant>
+
+// template <class... Ts> class variant
+
+// Test that we properly provide the trivial copy operations by default.
+
+// FreeBSD provides the old ABI. This test checks the new ABI so we need
+// to manually turn it on.
+#if defined(__FreeBSD__)
+#define _LIBCPP_ABI_UNSTABLE
+#endif
+
+#include <type_traits>
+#include <utility>
+#include <variant>
+#include <cstdlib>
+#include <cassert>
+
+#include "test_macros.h"
+
+// Define the P1144 name for convenience.
+#define is_trivially_relocatable __libcpp_is_trivially_relocatable
+
+
+#if defined(_LIBCPP_DEPRECATED_ABI_DISABLE_PAIR_TRIVIAL_COPY_CTOR)
+#error Non-trivial ctor ABI macro defined
+#endif
+
+template <class T>
+struct HasTrivialABI : std::integral_constant<bool,
+    std::is_trivially_destructible<T>::value
+    && (!std::is_copy_constructible<T>::value || std::is_trivially_copy_constructible<T>::value)
+#if TEST_STD_VER >= 11
+   && (!std::is_move_constructible<T>::value || std::is_trivially_move_constructible<T>::value)
+#endif
+> {};
+
+#if TEST_STD_VER >= 11
+struct NonTrivialDtor {
+    NonTrivialDtor(NonTrivialDtor const&) = default;
+    ~NonTrivialDtor();
+};
+NonTrivialDtor::~NonTrivialDtor() {}
+static_assert(!HasTrivialABI<NonTrivialDtor>::value, "");
+
+struct NonTrivialCopy {
+    NonTrivialCopy(NonTrivialCopy const&);
+};
+NonTrivialCopy::NonTrivialCopy(NonTrivialCopy const&) {}
+static_assert(!HasTrivialABI<NonTrivialCopy>::value, "");
+
+struct NonTrivialMove {
+    NonTrivialMove(NonTrivialMove const&) = default;
+    NonTrivialMove(NonTrivialMove&&);
+};
+NonTrivialMove::NonTrivialMove(NonTrivialMove&&) {}
+static_assert(!HasTrivialABI<NonTrivialMove>::value, "");
+
+struct DeletedCopy {
+    DeletedCopy(DeletedCopy const&) = delete;
+    DeletedCopy(DeletedCopy&&) = default;
+};
+static_assert(HasTrivialABI<DeletedCopy>::value, "");
+
+struct TrivialMove {
+  TrivialMove(TrivialMove &&) = default;
+};
+static_assert(HasTrivialABI<TrivialMove>::value, "");
+
+struct Trivial {
+    Trivial(Trivial const&) = default;
+};
+static_assert(HasTrivialABI<Trivial>::value, "");
+#endif
+
+struct _LIBCPP_TRIVIALLY_RELOCATABLE TrivialRelocEmpty {
+    TrivialRelocEmpty(const TrivialRelocEmpty&);
+    TrivialRelocEmpty(TrivialRelocEmpty&&);
+    ~TrivialRelocEmpty();
+};
+#if __has_extension(trivially_relocatable)
+static_assert(std::is_trivially_relocatable<TrivialRelocEmpty>::value, "");
+#endif
+
+struct _LIBCPP_TRIVIALLY_RELOCATABLE TrivialReloc {
+    int i;
+    TrivialReloc(const TrivialReloc&);
+    TrivialReloc(TrivialReloc&&);
+    ~TrivialReloc();
+};
+#if __has_extension(trivially_relocatable)
+static_assert(std::is_trivially_relocatable<TrivialReloc>::value, "");
+#endif
+
+int main()
+{
+    {
+        typedef std::variant<int, int, short> P;
+        static_assert(std::is_copy_constructible<P>::value, "");
+        static_assert(HasTrivialABI<P>::value, "");
+        static_assert(std::is_trivially_relocatable<P>::value, "");
+    }
+#if TEST_STD_VER >= 11
+    {
+        typedef std::variant<int, int, short> P;
+        static_assert(std::is_move_constructible<P>::value, "");
+        static_assert(HasTrivialABI<P>::value, "");
+        static_assert(std::is_trivially_relocatable<P>::value, "");
+    }
+    {
+        using P = std::variant<int, NonTrivialDtor, int>;
+        static_assert(!std::is_trivially_destructible<P>::value, "");
+        static_assert(std::is_copy_constructible<P>::value, "");
+        static_assert(!std::is_trivially_copy_constructible<P>::value, "");
+        static_assert(std::is_move_constructible<P>::value, "");
+        static_assert(!std::is_trivially_move_constructible<P>::value, "");
+        static_assert(!HasTrivialABI<P>::value, "");
+        static_assert(!std::is_trivially_relocatable<P>::value, "");
+    }
+    {
+        using P = std::variant<int, NonTrivialCopy, int>;
+        static_assert(std::is_copy_constructible<P>::value, "");
+        static_assert(!std::is_trivially_copy_constructible<P>::value, "");
+        static_assert(std::is_move_constructible<P>::value, "");
+        static_assert(!std::is_trivially_move_constructible<P>::value, "");
+        static_assert(!HasTrivialABI<P>::value, "");
+        static_assert(!std::is_trivially_relocatable<P>::value, "");
+    }
+    {
+        using P = std::variant<int, NonTrivialMove, int>;
+        static_assert(std::is_copy_constructible<P>::value, "");
+        static_assert(std::is_trivially_copy_constructible<P>::value, "");
+        static_assert(std::is_move_constructible<P>::value, "");
+        static_assert(!std::is_trivially_move_constructible<P>::value, "");
+        static_assert(!HasTrivialABI<P>::value, "");
+        static_assert(!std::is_trivially_relocatable<P>::value, "");
+    }
+    {
+        using P = std::variant<int, DeletedCopy, int>;
+        static_assert(!std::is_copy_constructible<P>::value, "");
+        static_assert(!std::is_trivially_copy_constructible<P>::value, "");
+        static_assert(std::is_move_constructible<P>::value, "");
+        static_assert(std::is_trivially_move_constructible<P>::value, "");
+        static_assert(HasTrivialABI<P>::value, "");
+        static_assert(std::is_trivially_relocatable<P>::value, "");
+    }
+    {
+        using P = std::variant<int, Trivial, int>;
+        static_assert(std::is_copy_constructible<P>::value, "");
+        static_assert(std::is_trivially_copy_constructible<P>::value, "");
+        static_assert(std::is_move_constructible<P>::value, "");
+        static_assert(std::is_trivially_move_constructible<P>::value, "");
+        static_assert(HasTrivialABI<P>::value, "");
+        static_assert(std::is_trivially_relocatable<P>::value, "");
+    }
+    {
+        using P = std::variant<int, TrivialMove, int>;
+        static_assert(!std::is_copy_constructible<P>::value, "");
+        static_assert(!std::is_trivially_copy_constructible<P>::value, "");
+        static_assert(std::is_move_constructible<P>::value, "");
+        static_assert(std::is_trivially_move_constructible<P>::value, "");
+        static_assert(HasTrivialABI<P>::value, "");
+        static_assert(std::is_trivially_relocatable<P>::value, "");
+    }
+#if __has_extension(trivially_relocatable)
+    {
+        using P = std::variant<int, TrivialReloc, int>;
+        static_assert(std::is_copy_constructible<P>::value, "");
+        static_assert(!std::is_trivially_copy_constructible<P>::value, "");
+        static_assert(std::is_move_constructible<P>::value, "");
+        static_assert(!std::is_trivially_move_constructible<P>::value, "");
+        static_assert(!HasTrivialABI<P>::value, "");
+        static_assert(std::is_trivially_relocatable<P>::value, "");
+    }
+    {
+        using P = std::variant<int, TrivialRelocEmpty, int>;
+        static_assert(std::is_copy_constructible<P>::value, "");
+        static_assert(!std::is_trivially_copy_constructible<P>::value, "");
+        static_assert(std::is_move_constructible<P>::value, "");
+        static_assert(!std::is_trivially_move_constructible<P>::value, "");
+        static_assert(!HasTrivialABI<P>::value, "");
+        static_assert(std::is_trivially_relocatable<P>::value, "");
+    }
+#endif
+#endif
+}