Revert "[libc++] Fix std::copy and std::move for ranges with potentially overlapping tail padding"

[philnik]

Summary

This reverts commit c4e98722ca79c827dd57b809e0ef16b3b8da8c72, which breaks
vector<T>::erase(...) for move-only types.

See https://reviews.llvm.org/D151953#4472195

[alexfh]

Fix conflict resolution in module map (hopefully) correctly.

[ldionne]

We'll fix this one forward since we have a good understanding of what to do. Also, the diff was uploaded wrong but it shouldn't matter.

[alexfh]

In D154595#4476928, @ldionne wrote:

We'll fix this one forward since we have a good understanding of what to do. Also, the diff was uploaded wrong but it shouldn't matter.

Thanks! I started with the revert, since there was no further reaction after your comment on https://reviews.llvm.org/D151953#4472195

Given the impact, I'd expect a quicker resolution of the issue, one way or another.

[ldionne]

See D154613. The original issue was reported on the 4th of July, which was a Holiday in the US so @philnik couldn't take a look.

[ldionne]

(I'd abandon this to clear the review queue)

[alexfh]

Trying to upload the full patch. Just in case.

[alexfh]

In D154595#4477290, @ldionne wrote:

See D154613. The original issue was reported on the 4th of July, which was a Holiday in the US so @philnik couldn't take a look.

I understand there was a holiday in the US and many folks may take more days off on the week. But knowing this doesn't help folks in other parts of the world, whose work is blocked by a certain commit. Reverting is often the safest way to get back to good state.

Thanks for preparing the tests in D154613. How soon should we expect a fix?

[ldionne]

In D154595#4477589, @alexfh wrote:

In D154595#4477290, @ldionne wrote:

See D154613. The original issue was reported on the 4th of July, which was a Holiday in the US so @philnik couldn't take a look.

I understand there was a holiday in the US and many folks may take more days off on the week. But knowing this doesn't help folks in other parts of the world, whose work is blocked by a certain commit. Reverting is often the safest way to get back to good state.

Thanks for preparing the tests in D154613. How soon should we expect a fix?

Reverting this patch re-introduces the issue that this patch was fixing. It actually trades a compile-time issue for a runtime issue.

But knowing this doesn't help folks in other parts of the world, whose work is blocked by a certain commit.

We have a problem here, and it's not the first time this happens. The fact that you folks are living on trunk is great because it leads to important early feedback like this. This is a relationship we want to maintain because it's really useful to the project, and I think that is also useful to you because we do act on that feedback. However, there is clearly some tension around how you want us to deal with these reports and how we want to deal with them. In the general case, it's entirely unreasonable to expect that our tree is going to be free of defects at arbitrary points between releases. For example, if you take a look at the current state of hardening, it's not working as intended because it is *in development*. That's the principle of making incremental progress on features, and really all software development works that way. Does that mean we should refrain from making incremental changes or going through tree states that we know are not ready for a release? I don't think so.

The developer policy relates to keeping the CI (buildbot and others) green, and we *do* keep it green. You folks are living outside of that. That's where we draw the line: when a commit breaks the CI, you'll see us reverting the commit without too much discussion. But in this case, it's an entirely different story. It broke some funky code (*) internally in some organization and they just happen to be unwilling to unblock themselves by doing a temporary revert or using some branching scheme to only ship stuff that has been stabilized for a few days. We'll need to figure out a way to collaborate effectively on issues like this in the future, because the current tension is not healthy for anyone. I'll reach out for us to talk offline.

(*) The code is somewhat funky because the types for which this broke is a small set of types. It's only types that are TriviallyCopyable but that have a deleted copy assignment operator, not all move-only types like we initially thought. That's probably something you'd want to fix in your code BTW.

[alexfh]

In D154595#4480304, @ldionne wrote:

In D154595#4477589, @alexfh wrote:

In D154595#4477290, @ldionne wrote:

See D154613. The original issue was reported on the 4th of July, which was a Holiday in the US so @philnik couldn't take a look.

I understand there was a holiday in the US and many folks may take more days off on the week. But knowing this doesn't help folks in other parts of the world, whose work is blocked by a certain commit. Reverting is often the safest way to get back to good state.

Thanks for preparing the tests in D154613. How soon should we expect a fix?

Reverting this patch re-introduces the issue that this patch was fixing. It actually trades a compile-time issue for a runtime issue.

But knowing this doesn't help folks in other parts of the world, whose work is blocked by a certain commit.

We have a problem here, and it's not the first time this happens. The fact that you folks are living on trunk is great because it leads to important early feedback like this. This is a relationship we want to maintain because it's really useful to the project, and I think that is also useful to you because we do act on that feedback. However, there is clearly some tension around how you want us to deal with these reports and how we want to deal with them. In the general case, it's entirely unreasonable to expect that our tree is going to be free of defects at arbitrary points between releases. For example, if you take a look at the current state of hardening, it's not working as intended because it is *in development*. That's the principle of making incremental progress on features, and really all software development works that way. Does that mean we should refrain from making incremental changes or going through tree states that we know are not ready for a release? I don't think so.

I totally appreciate the hard work LLVM community (and libc++ part of it in particular) puts into the project and the readiness to fix issues we and others detect. And I also understand that incremental progress on features means some features would be in a half-baked state for certain periods of time. On the other hand, https://llvm.org/docs/DeveloperPolicy.html#patch-reversion-policy claims that LLVM tends to keep the tree healthy, but we need to come to an agreement of what "healthy" means. While "CI is green" is clear and unambiguous, this criterion is only as good as the tests are. If a certain important use case is not covered by tests, it only means that tests are insufficient. "Ready for a release" is on the other hand too subjective, expensive and long to verify. Apart from that, we're not expecting LLVM tree (libc++ included) to be in a good state after each commit. Our expectation is that for each problem found at a specific commit there is a fix (revert or fix forward) in a reasonable time after the problem is found. Now, we may need to agree on what "reasonable time" is or whether this expectation is reasonable in general. But for that I'll take your offer of bringing this conversation offline.

The developer policy relates to keeping the CI (buildbot and others) green, and we *do* keep it green. You folks are living outside of that. That's where we draw the line: when a commit breaks the CI, you'll see us reverting the commit without too much discussion. But in this case, it's an entirely different story. It broke some funky code (*) internally in some organization and they just happen to be unwilling to unblock themselves by doing a temporary revert or using some branching scheme to only ship stuff that has been stabilized for a few days. We'll need to figure out a way to collaborate effectively on issues like this in the future, because the current tension is not healthy for anyone. I'll reach out for us to talk offline.

(*) The code is somewhat funky because the types for which this broke is a small set of types. It's only types that are TriviallyCopyable but that have a deleted copy assignment operator, not all move-only types like we initially thought. That's probably something you'd want to fix in your code BTW.

This last point is interesting on its own. Having a large corpus of internal and third-party code, we're in a position where we regularly see some "funky code". And though we put a lot of effort into keeping the code healthy, we can't be ready to fix hundreds, thousands, or even more instances of "funky code" (by some definition) at random points in time. Thus, we expect a certain grace period (and short- or long-term opt-out mechanisms) for breaking changes with high impact.

[philnik]

@alexfh Please abandon this to clear up the review queue.

libcxx/include/CMakeLists.txt

set(files
   __type_traits/apply_cv.h
   __type_traits/can_extract_key.h
   __type_traits/common_reference.h
   __type_traits/common_type.h
   __type_traits/conditional.h
   __type_traits/conjunction.h
   __type_traits/copy_cv.h
   __type_traits/copy_cvref.h
-  __type_traits/datasizeof.h
   __type_traits/decay.h
   __type_traits/dependent_type.h
   __type_traits/disjunction.h
   __type_traits/enable_if.h
   __type_traits/extent.h
   __type_traits/has_unique_object_representation.h
   __type_traits/has_virtual_destructor.h
   __type_traits/integral_constant.h

libcxx/include/__algorithm/copy_move_common.h

 #define _LIBCPP___ALGORITHM_COPY_MOVE_COMMON_H
 
 #include <__algorithm/iterator_operations.h>
 #include <__algorithm/unwrap_iter.h>
 #include <__algorithm/unwrap_range.h>
 #include <__config>
 #include <__iterator/iterator_traits.h>
 #include <__memory/pointer_traits.h>
-#include <__string/constexpr_c_functions.h>
 #include <__type_traits/enable_if.h>
 #include <__type_traits/is_always_bitcastable.h>
 #include <__type_traits/is_constant_evaluated.h>
 #include <__type_traits/is_copy_constructible.h>
 #include <__type_traits/is_trivially_assignable.h>
 #include <__type_traits/is_trivially_copyable.h>
 #include <__type_traits/is_volatile.h>
 #include <__utility/move.h>

 };
 
 // `memmove` algorithms implementation.
 
 template <class _In, class _Out>
 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 pair<_In*, _Out*>
 __copy_trivial_impl(_In* __first, _In* __last, _Out* __result) {
   const size_t __n = static_cast<size_t>(__last - __first);
-
-  std::__constexpr_memmove(__result, __first, __element_count(__n));
+  ::__builtin_memmove(__result, __first, __n * sizeof(_Out));
 
   return std::make_pair(__last, __result + __n);
 }
 
 template <class _In, class _Out>
 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 pair<_In*, _Out*>
 __copy_backward_trivial_impl(_In* __first, _In* __last, _Out* __result) {
   const size_t __n = static_cast<size_t>(__last - __first);
   __result -= __n;
 
-  std::__constexpr_memmove(__result, __first, __element_count(__n));
+  ::__builtin_memmove(__result, __first, __n * sizeof(_Out));
 
   return std::make_pair(__last, __result);
 }
 
 // Iterator unwrapping and dispatching to the correct overload.
 
 template <class _F1, class _F2>
 struct __overload : _F1, _F2 {
template <class _Algorithm,
           class _Sent,
           class _OutIter,
           __enable_if_t<!__can_rewrap<_InIter, _Sent, _OutIter>::value, int> = 0>
 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 pair<_InIter, _OutIter>
 __unwrap_and_dispatch(_InIter __first, _Sent __last, _OutIter __out_first) {
   return _Algorithm()(std::move(__first), std::move(__last), std::move(__out_first));
 }
 
+template <class _IterOps, class _InValue, class _OutIter, class = void>
+struct __can_copy_without_conversion : false_type {};
+
+template <class _IterOps, class _InValue, class _OutIter>
+struct __can_copy_without_conversion<
+    _IterOps,
+    _InValue,
+    _OutIter,
+    __enable_if_t<is_same<_InValue, typename _IterOps::template __value_type<_OutIter> >::value> > : true_type {};
+
 template <class _AlgPolicy,
           class _NaiveAlgorithm,
           class _OptimizedAlgorithm,
           class _InIter,
           class _Sent,
           class _OutIter>
 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 pair<_InIter, _OutIter>
 __dispatch_copy_or_move(_InIter __first, _Sent __last, _OutIter __out_first) {
+#ifdef _LIBCPP_COMPILER_GCC
+  // GCC doesn't support `__builtin_memmove` during constant evaluation.
+  if (__libcpp_is_constant_evaluated()) {
+    return std::__unwrap_and_dispatch<_NaiveAlgorithm>(std::move(__first), std::move(__last), std::move(__out_first));
+  }
+#else
+  // In Clang, `__builtin_memmove` only supports fully trivially copyable types (just having trivial copy assignment is
+  // insufficient). Also, conversions are not supported.
+  if (__libcpp_is_constant_evaluated()) {
+    using _InValue = typename _IterOps<_AlgPolicy>::template __value_type<_InIter>;
+    if (!is_trivially_copyable<_InValue>::value ||
+        !__can_copy_without_conversion<_IterOps<_AlgPolicy>, _InValue, _OutIter>::value) {
+      return std::__unwrap_and_dispatch<_NaiveAlgorithm>(std::move(__first), std::move(__last), std::move(__out_first));
+    }
+  }
+#endif // _LIBCPP_COMPILER_GCC
+
   using _Algorithm = __overload<_NaiveAlgorithm, _OptimizedAlgorithm>;
   return std::__unwrap_and_dispatch<_Algorithm>(std::move(__first), std::move(__last), std::move(__out_first));
 }
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___ALGORITHM_COPY_MOVE_COMMON_H

libcxx/include/__string/char_traits.h

struct _LIBCPP_DEPRECATED_("char_traits<T> for T not equal to char, wchar_t, char8_t, char16_t or char32_t is non-standard and is provided for a temporary period. It will be removed in LLVM 18, so please migrate off of it.")
     static inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR int_type  to_int_type(char_type __c) _NOEXCEPT
         {return int_type(__c);}
     static inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR bool      eq_int_type(int_type __c1, int_type __c2) _NOEXCEPT
         {return __c1 == __c2;}
     static inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR int_type  eof() _NOEXCEPT
         {return int_type(EOF);}
 };
 
+template <class _CharT>
+_LIBCPP_HIDE_FROM_ABI static inline _LIBCPP_CONSTEXPR_SINCE_CXX20
+_CharT* __char_traits_move(_CharT* __dest, const _CharT* __source, size_t __n) _NOEXCEPT
+{
+#ifdef _LIBCPP_COMPILER_GCC
+  if (__libcpp_is_constant_evaluated()) {
+    if (__n == 0)
+      return __dest;
+    _CharT* __allocation = new _CharT[__n];
+    std::copy_n(__source, __n, __allocation);
+    std::copy_n(static_cast<const _CharT*>(__allocation), __n, __dest);
+    delete[] __allocation;
+    return __dest;
+  }
+#endif
+  ::__builtin_memmove(__dest, __source, __n * sizeof(_CharT));
+  return __dest;
+}
+
 // char_traits<char>
 
 template <>
 struct _LIBCPP_TEMPLATE_VIS char_traits<char>
 {
     using char_type           = char;
     using int_type            = int;
     using off_type            = streamoff;
#endif // _LIBCPP_COMPILER_CLANG_BASED
     const char_type* find(const char_type* __s, size_t __n, const char_type& __a) _NOEXCEPT {
       if (__n == 0)
           return nullptr;
       return std::__constexpr_memchr(__s, __a, __n);
     }
 
     static inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
     char_type* move(char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT {
-        return std::__constexpr_memmove(__s1, __s2, __element_count(__n));
+        return std::__char_traits_move(__s1, __s2, __n);
     }
 
     static inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
     char_type* copy(char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT {
         if (!__libcpp_is_constant_evaluated())
             _LIBCPP_ASSERT_UNCATEGORIZED(__s2 < __s1 || __s2 >= __s1+__n, "char_traits::copy overlapped range");
         std::copy_n(__s2, __n, __s1);
         return __s1;
#endif
   const char_type* find(const char_type* __s, size_t __n, const char_type& __a) _NOEXCEPT {
     if (__n == 0)
         return nullptr;
     return std::__constexpr_wmemchr(__s, __a, __n);
   }
 
     static inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
     char_type* move(char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT {
-        return std::__constexpr_memmove(__s1, __s2, __element_count(__n));
+        return std::__char_traits_move(__s1, __s2, __n);
     }
 
     static inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
     char_type* copy(char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT {
         if (!__libcpp_is_constant_evaluated())
             _LIBCPP_ASSERT_UNCATEGORIZED(__s2 < __s1 || __s2 >= __s1+__n, "char_traits::copy overlapped range");
         std::copy_n(__s2, __n, __s1);
         return __s1;
compare(const char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT {
     static _LIBCPP_HIDE_FROM_ABI constexpr
     size_t           length(const char_type* __s) _NOEXCEPT;
 
     _LIBCPP_INLINE_VISIBILITY static constexpr
     const char_type* find(const char_type* __s, size_t __n, const char_type& __a) _NOEXCEPT;
 
     static _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
     char_type*       move(char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT {
-        return std::__constexpr_memmove(__s1, __s2, __element_count(__n));
+        return std::__char_traits_move(__s1, __s2, __n);
     }
 
     static _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
     char_type*       copy(char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT {
         if (!__libcpp_is_constant_evaluated())
             _LIBCPP_ASSERT_UNCATEGORIZED(__s2 < __s1 || __s2 >= __s1+__n, "char_traits::copy overlapped range");
         std::copy_n(__s2, __n, __s1);
         return __s1;
#endif
     int              compare(const char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT;
     _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR_SINCE_CXX17
     size_t           length(const char_type* __s) _NOEXCEPT;
     _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR_SINCE_CXX17
     const char_type* find(const char_type* __s, size_t __n, const char_type& __a) _NOEXCEPT;
 
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
     static char_type*       move(char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT {
-        return std::__constexpr_memmove(__s1, __s2, __element_count(__n));
+        return std::__char_traits_move(__s1, __s2, __n);
     }
 
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
     static char_type*       copy(char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT {
         if (!__libcpp_is_constant_evaluated())
             _LIBCPP_ASSERT_UNCATEGORIZED(__s2 < __s1 || __s2 >= __s1+__n, "char_traits::copy overlapped range");
         std::copy_n(__s2, __n, __s1);
         return __s1;
#endif
     int              compare(const char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT;
     _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR_SINCE_CXX17
     size_t           length(const char_type* __s) _NOEXCEPT;
     _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR_SINCE_CXX17
     const char_type* find(const char_type* __s, size_t __n, const char_type& __a) _NOEXCEPT;
 
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
     static char_type*       move(char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT {
-        return std::__constexpr_memmove(__s1, __s2, __element_count(__n));
+        return std::__char_traits_move(__s1, __s2, __n);
     }
 
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
     static char_type*       copy(char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT {
         std::copy_n(__s2, __n, __s1);
         return __s1;
     }
 

libcxx/include/__string/constexpr_c_functions.h

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___STRING_CONSTEXPR_C_FUNCTIONS_H
 #define _LIBCPP___STRING_CONSTEXPR_C_FUNCTIONS_H
 
 #include <__config>
-#include <__type_traits/datasizeof.h>
-#include <__type_traits/is_always_bitcastable.h>
 #include <__type_traits/is_constant_evaluated.h>
 #include <__type_traits/is_equality_comparable.h>
 #include <__type_traits/is_same.h>
-#include <__type_traits/is_trivially_copyable.h>
 #include <__type_traits/is_trivially_lexicographically_comparable.h>
 #include <__type_traits/remove_cv.h>
-#include <__utility/is_pointer_in_range.h>
 #include <cstddef>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
#endif
     return nullptr;
   } else {
     char __value_buffer = 0;
     __builtin_memcpy(&__value_buffer, &__value, sizeof(char));
     return static_cast<_Tp*>(__builtin_memchr(__str, __value_buffer, __count));
   }
 }
 
-template <class _Tp, class _Up, __enable_if_t<__is_always_bitcastable<_Up, _Tp>::value, int> = 0>
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 _Tp*
-__constexpr_memmove(_Tp* __dest, _Up* __src, __element_count __n) {
-  size_t __count = static_cast<size_t>(__n);
-  if (__libcpp_is_constant_evaluated()) {
-#ifdef _LIBCPP_COMPILER_CLANG_BASED
-    if (is_same<__remove_cv_t<_Tp>, __remove_cv_t<_Up> >::value) {
-      ::__builtin_memmove(__dest, __src, __count * sizeof(_Tp));
-      return __dest;
-    }
-#endif
-    if (std::__is_pointer_in_range(__src, __src + __count, __dest)) {
-      for (; __count > 0; --__count)
-        __dest[__count - 1] = __src[__count - 1];
-    } else {
-      for (size_t __i = 0; __i != __count; ++__i)
-        __dest[__i] = __src[__i];
-    }
-  } else if (__count > 0) {
-    ::__builtin_memmove(__dest, __src, (__count - 1) * sizeof(_Tp) + __libcpp_datasizeof<_Tp>::value);
-  }
-  return __dest;
-}
-
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___STRING_CONSTEXPR_C_FUNCTIONS_H

libcxx/include/__type_traits/datasizeof.h

-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _LIBCPP___TYPE_TRAITS_DATASIZEOF_H
-#define _LIBCPP___TYPE_TRAITS_DATASIZEOF_H
-
-#include <__config>
-#include <__type_traits/is_class.h>
-#include <__type_traits/is_final.h>
-#include <cstddef>
-
-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#  pragma GCC system_header
-#endif
-
-// This trait provides the size of a type excluding any tail padding.
-//
-// It is useful in contexts where performing an operation using the full size of the class (including padding) may
-// have unintended side effects, such as overwriting a derived class' member when writing the tail padding of a class
-// through a pointer-to-base.
-
-_LIBCPP_BEGIN_NAMESPACE_STD
-
-template <class _Tp>
-struct __libcpp_datasizeof {
-#if __has_cpp_attribute(__no_unique_address__)
-  template <class = char>
-  struct _FirstPaddingByte {
-    [[__no_unique_address__]] _Tp __v_;
-    char __first_padding_byte_;
-  };
-#else
-  template <bool = __libcpp_is_final<_Tp>::value || !is_class<_Tp>::value>
-  struct _FirstPaddingByte : _Tp {
-    char __first_padding_byte_;
-  };
-
-  template <>
-  struct _FirstPaddingByte<true> {
-    _Tp __v_;
-    char __first_padding_byte_;
-  };
-#endif
-
-  static const size_t value = offsetof(_FirstPaddingByte<>, __first_padding_byte_);
-};
-
-_LIBCPP_END_NAMESPACE_STD
-
-#endif // _LIBCPP___TYPE_TRAITS_DATASIZEOF_H

libcxx/include/__utility/is_pointer_in_range.h

 #define _LIBCPP___UTILITY_IS_POINTER_IN_RANGE_H
 
 #include <__algorithm/comp.h>
 #include <__assert>
 #include <__config>
 #include <__type_traits/enable_if.h>
 #include <__type_traits/integral_constant.h>
 #include <__type_traits/is_constant_evaluated.h>
+#include <__type_traits/is_function.h>
+#include <__type_traits/is_member_pointer.h>
 #include <__type_traits/void_t.h>
 #include <__utility/declval.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template <class _Tp, class _Up, class = void>
-struct __is_less_than_comparable : false_type {};
-
 template <class _Tp, class _Up>
-struct __is_less_than_comparable<_Tp, _Up, __void_t<decltype(std::declval<_Tp>() < std::declval<_Up>())> > : true_type {
-};
-
-template <class _Tp, class _Up, __enable_if_t<__is_less_than_comparable<const _Tp*, const _Up*>::value, int> = 0>
 _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI _LIBCPP_NO_SANITIZE("address") bool __is_pointer_in_range(
     const _Tp* __begin, const _Tp* __end, const _Up* __ptr) {
+  static_assert(!is_function<_Tp>::value && !is_function<_Up>::value,
+                "__is_pointer_in_range should not be called with function pointers");
+  static_assert(!is_member_pointer<_Tp>::value && !is_member_pointer<_Up>::value,
+                "__is_pointer_in_range should not be called with member pointers");
+
   if (__libcpp_is_constant_evaluated()) {
     _LIBCPP_ASSERT_UNCATEGORIZED(__builtin_constant_p(__begin <= __end), "__begin and __end do not form a range");
 
     // If this is not a constant during constant evaluation we know that __ptr is not part of the allocation where
     // [__begin, __end) is.
     if (!__builtin_constant_p(__begin <= __ptr && __ptr < __end))
       return false;
   }
 
   // Checking this for unrelated pointers is technically UB, but no compiler optimizes based on it (currently).
   return !__less<>()(__ptr, __begin) && __less<>()(__ptr, __end);
 }
 
-template <class _Tp, class _Up, __enable_if_t<!__is_less_than_comparable<const _Tp*, const _Up*>::value, int> = 0>
-_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI _LIBCPP_NO_SANITIZE("address") bool __is_pointer_in_range(
-    const _Tp* __begin, const _Tp* __end, const _Up* __ptr) {
-  if (__libcpp_is_constant_evaluated())
-    return false;
-
-  return reinterpret_cast<const char*>(__begin) <= reinterpret_cast<const char*>(__ptr) &&
-         reinterpret_cast<const char*>(__ptr) < reinterpret_cast<const char*>(__end);
-}
-
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___UTILITY_IS_POINTER_IN_RANGE_H

libcxx/include/string

 struct __can_be_converted_to_string_view : public _BoolConstant<
       is_convertible<const _Tp&, basic_string_view<_CharT, _Traits> >::value &&
      !is_convertible<const _Tp&, const _CharT*>::value
     > {};
 
 struct __uninitialized_size_tag {};
 struct __init_with_sentinel_tag {};
 
+template <class _Tp, class _Up, class = void>
+struct __is_less_than_comparable : false_type {};
+
+template <class _Tp, class _Up>
+struct __is_less_than_comparable<_Tp, _Up, __void_t<decltype(std::declval<_Tp>() < std::declval<_Up>())> > : true_type {
+};
+
 template<class _CharT, class _Traits, class _Allocator>
 class basic_string
 {
 public:
     typedef basic_string                                 __self;
     typedef basic_string_view<_CharT, _Traits>           __self_view;
     typedef _Traits                                      traits_type;
     typedef _CharT                                       value_type;
#endif
 
     _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
     basic_string& __null_terminate_at(value_type* __p, size_type __newsz) {
       __set_size(__newsz);
       traits_type::assign(__p[__newsz], value_type());
       return *this;
     }
 
-    template <class _Tp>
+    template <
+        class _Tp,
+        __enable_if_t<__is_less_than_comparable<const __remove_cvref_t<_Tp>*, const value_type*>::value, int> = 0>
     _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 bool __addr_in_range(const _Tp& __v) const {
       return std::__is_pointer_in_range(data(), data() + size() + 1, std::addressof(__v));
     }
 
+    template <
+        class _Tp,
+        __enable_if_t<!__is_less_than_comparable<const __remove_cvref_t<_Tp>*, const value_type*>::value, int> = 0>
+    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 bool __addr_in_range(const _Tp& __v) const {
+      if (__libcpp_is_constant_evaluated())
+                return false;
+
+      auto __t_ptr = reinterpret_cast<const char*>(std::addressof(__v));
+      return reinterpret_cast<const char*>(data()) <= __t_ptr &&
+             __t_ptr < reinterpret_cast<const char*>(data() + size() + 1);
+    }
+
     _LIBCPP_NORETURN _LIBCPP_HIDE_FROM_ABI
     void __throw_length_error() const {
         std::__throw_length_error("basic_string");
     }
 
     _LIBCPP_NORETURN _LIBCPP_HIDE_FROM_ABI
     void __throw_out_of_range() const {
         std::__throw_out_of_range("basic_string");

libcxx/test/libcxx/algorithms/alg.modifying.operations/copy_move_trivial.pass.cpp

assert(std::equal(input, input + N, output, [](const From& lhs, const To& rhs) {
         // Prevents warnings/errors due to mismatched signed-ness.
         if constexpr (std::convertible_to<From, To>) {
           return static_cast<To>(lhs) == rhs;
         } else if constexpr (std::convertible_to<To, From>) {
           return lhs == static_cast<From>(rhs);
         }
     }));
   }
+
+  // Empty input sequence.
+  {
+    const std::size_t N = 0;
+
+    From input[1]  = {make<From>(1)};
+    To output[1] = {make<To>(2)};
+
+    auto in     = InIter(input);
+    auto in_end = InIter(input + N);
+    auto sent   = SentWrapper<decltype(in_end)>(in_end);
+    auto out    = OutIter(output);
+
+    assert(!memmove_called);
+    func(in, sent, out, N);
+
+    assert(memmove_called);
+    memmove_called = false;
+    assert(output[0] == make<To>(2));
+  }
 }
 
 template <class InIter, template <class> class SentWrapper, class OutIter>
 void test_copy_and_move() {
   // Classic.
   if constexpr (std::same_as<InIter, SentWrapper<InIter>>) {
     test_one<InIter, SentWrapper, OutIter>([](auto first, auto last, auto out, std::size_t) {
       std::copy(first, last, out);

libcxx/test/libcxx/transitive_includes/cxx03.csv

 any type_traits
 any typeinfo
 any variant
 any version
 array algorithm
 array compare
 array concepts
 array cstddef
-array cstdint
 array cstdlib
 array initializer_list
 array iterator
 array limits
 array stdexcept
 array type_traits
 array utility
 array version

 locale streambuf
 locale string
 locale type_traits
 locale typeinfo
 locale version
 map compare
 map concepts
 map cstddef
-map cstdint
 map cstdlib
 map functional
 map initializer_list
 map iterator
 map limits
 map new
 map optional
 map stdexcept

 semaphore iosfwd
 semaphore limits
 semaphore ratio
 semaphore type_traits
 semaphore version
 set compare
 set concepts
 set cstddef
-set cstdint
 set cstdlib
 set functional
 set initializer_list
 set iterator
 set limits
 set new
 set optional
 set stdexcept

libcxx/test/libcxx/transitive_includes/cxx11.csv

 any type_traits
 any typeinfo
 any variant
 any version
 array algorithm
 array compare
 array concepts
 array cstddef
-array cstdint
 array cstdlib
 array initializer_list
 array iterator
 array limits
 array stdexcept
 array type_traits
 array utility
 array version

 locale streambuf
 locale string
 locale type_traits
 locale typeinfo
 locale version
 map compare
 map concepts
 map cstddef
-map cstdint
 map cstdlib
 map functional
 map initializer_list
 map iterator
 map limits
 map new
 map optional
 map stdexcept

 semaphore iosfwd
 semaphore limits
 semaphore ratio
 semaphore type_traits
 semaphore version
 set compare
 set concepts
 set cstddef
-set cstdint
 set cstdlib
 set functional
 set initializer_list
 set iterator
 set limits
 set new
 set optional
 set stdexcept

libcxx/test/libcxx/transitive_includes/cxx14.csv

 any type_traits
 any typeinfo
 any variant
 any version
 array algorithm
 array compare
 array concepts
 array cstddef
-array cstdint
 array cstdlib
 array initializer_list
 array iterator
 array limits
 array stdexcept
 array type_traits
 array utility
 array version

 locale streambuf
 locale string
 locale type_traits
 locale typeinfo
 locale version
 map compare
 map concepts
 map cstddef
-map cstdint
 map cstdlib
 map functional
 map initializer_list
 map iterator
 map limits
 map new
 map optional
 map stdexcept

 semaphore iosfwd
 semaphore limits
 semaphore ratio
 semaphore type_traits
 semaphore version
 set compare
 set concepts
 set cstddef
-set cstdint
 set cstdlib
 set functional
 set initializer_list
 set iterator
 set limits
 set new
 set optional
 set stdexcept

libcxx/test/libcxx/transitive_includes/cxx17.csv

 any type_traits
 any typeinfo
 any variant
 any version
 array algorithm
 array compare
 array concepts
 array cstddef
-array cstdint
 array cstdlib
 array initializer_list
 array iterator
 array limits
 array stdexcept
 array type_traits
 array utility
 array version

 locale streambuf
 locale string
 locale type_traits
 locale typeinfo
 locale version
 map compare
 map concepts
 map cstddef
-map cstdint
 map cstdlib
 map functional
 map initializer_list
 map iterator
 map limits
 map new
 map optional
 map stdexcept

 semaphore iosfwd
 semaphore limits
 semaphore ratio
 semaphore type_traits
 semaphore version
 set compare
 set concepts
 set cstddef
-set cstdint
 set cstdlib
 set functional
 set initializer_list
 set iterator
 set limits
 set new
 set optional
 set stdexcept

libcxx/test/libcxx/transitive_includes/cxx20.csv

 any type_traits
 any typeinfo
 any variant
 any version
 array algorithm
 array compare
 array concepts
 array cstddef
-array cstdint
 array cstdlib
 array initializer_list
 array iterator
 array limits
 array stdexcept
 array type_traits
 array utility
 array version

 locale streambuf
 locale string
 locale type_traits
 locale typeinfo
 locale version
 map compare
 map concepts
 map cstddef
-map cstdint
 map cstdlib
 map functional
 map initializer_list
 map iterator
 map limits
 map new
 map optional
 map stdexcept

 semaphore iosfwd
 semaphore limits
 semaphore ratio
 semaphore type_traits
 semaphore version
 set compare
 set concepts
 set cstddef
-set cstdint
 set cstdlib
 set functional
 set initializer_list
 set iterator
 set limits
 set new
 set optional
 set stdexcept

libcxx/test/libcxx/transitive_includes/cxx23.csv

 any cstring
 any initializer_list
 any limits
 any new
 any typeinfo
 any version
 array compare
 array cstddef
-array cstdint
 array initializer_list
 array limits
 array stdexcept
 array version
 atomic cstddef
 atomic cstdint
 atomic cstdlib
 atomic cstring

 locale new
 locale stdexcept
 locale streambuf
 locale string
 locale typeinfo
 locale version
 map compare
 map cstddef
-map cstdint
 map initializer_list
 map limits
 map new
 map optional
 map stdexcept
 map tuple
 map version
 mdspan array

 semaphore cstring
 semaphore ctime
 semaphore iosfwd
 semaphore limits
 semaphore ratio
 semaphore version
 set compare
 set cstddef
-set cstdint
 set initializer_list
 set limits
 set new
 set optional
 set stdexcept
 set tuple
 set version
 shared_mutex cerrno

libcxx/test/libcxx/transitive_includes/cxx26.csv

 any cstring
 any initializer_list
 any limits
 any new
 any typeinfo
 any version
 array compare
 array cstddef
-array cstdint
 array initializer_list
 array limits
 array stdexcept
 array version
 atomic cstddef
 atomic cstdint
 atomic cstdlib
 atomic cstring

 locale new
 locale stdexcept
 locale streambuf
 locale string
 locale typeinfo
 locale version
 map compare
 map cstddef
-map cstdint
 map initializer_list
 map limits
 map new
 map optional
 map stdexcept
 map tuple
 map version
 mdspan array

 semaphore cstring
 semaphore ctime
 semaphore iosfwd
 semaphore limits
 semaphore ratio
 semaphore version
 set compare
 set cstddef
-set cstdint
 set initializer_list
 set limits
 set new
 set optional
 set stdexcept
 set tuple
 set version
 shared_mutex cerrno

libcxx/test/libcxx/type_traits/datasizeof.compile.pass.cpp

-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-// ADDITIONAL_COMPILE_FLAGS: -Wno-private-header
-
-#include <__type_traits/datasizeof.h>
-#include <cstdint>
-
-static_assert(std::__libcpp_datasizeof<std::int8_t>::value == 1, "");
-static_assert(std::__libcpp_datasizeof<std::int16_t>::value == 2, "");
-static_assert(std::__libcpp_datasizeof<std::int32_t>::value == 4, "");
-static_assert(std::__libcpp_datasizeof<std::int64_t>::value == 8, "");
-
-struct OneBytePadding {
-  OneBytePadding() {}
-
-  std::int16_t a;
-  std::int8_t b;
-};
-
-#if defined(_WIN32) && !defined(__MINGW32__)
-static_assert(std::__libcpp_datasizeof<OneBytePadding>::value == 4, "");
-#else
-static_assert(std::__libcpp_datasizeof<OneBytePadding>::value == 3, "");
-#endif
-
-struct InBetweenPadding {
-  InBetweenPadding() {}
-
-  std::int32_t a;
-  std::int8_t b;
-  std::int16_t c;
-};
-
-static_assert(std::__libcpp_datasizeof<InBetweenPadding>::value == 8, "");

libcxx/test/std/algorithms/alg.modifying.operations/alg.copy/copy.pass.cpp

 //   copy(InIter first, InIter last, OutIter result);
 
 #include <algorithm>
 #include <cassert>
 
 #include "test_macros.h"
 #include "test_iterators.h"
 
-class PaddedBase {
-public:
-  TEST_CONSTEXPR PaddedBase(std::int16_t a, std::int8_t b) : a_(a), b_(b) {}
-
-  std::int16_t a_;
-  std::int8_t b_;
-};
-
-class Derived : public PaddedBase {
-public:
-  TEST_CONSTEXPR Derived(std::int16_t a, std::int8_t b, std::int8_t c) : PaddedBase(a, b), c_(c) {}
-
-  std::int8_t c_;
-};
-
-template <class InIter>
-struct Test {
-  template <class OutIter>
-  TEST_CONSTEXPR_CXX20 void operator()() {
-    const unsigned N = 1000;
-    int ia[N]        = {};
-    for (unsigned i = 0; i < N; ++i)
-      ia[i] = i;
-    int ib[N] = {0};
+template <class InIter, class OutIter>
+TEST_CONSTEXPR_CXX20 void test_copy() {
 
-    OutIter r = std::copy(InIter(ia), InIter(ia + N), OutIter(ib));
-    assert(base(r) == ib + N);
-    for (unsigned i = 0; i < N; ++i)
-      assert(ia[i] == ib[i]);
-  }
-};
-
-struct TestInIters {
-  template <class InIter>
-  TEST_CONSTEXPR_CXX20 void operator()() {
-    types::for_each(
-        types::concatenate_t<types::cpp17_input_iterator_list<int*>, types::type_list<cpp17_output_iterator<int*> > >(),
-        Test<InIter>());
-  }
-};
 
 TEST_CONSTEXPR_CXX20 bool test() {
-  types::for_each(types::cpp17_input_iterator_list<int*>(), TestInIters());
-
-  { // Make sure that padding bits aren't copied
-    Derived src(1, 2, 3);
-    Derived dst(4, 5, 6);
-    std::copy(static_cast<PaddedBase*>(&src), static_cast<PaddedBase*>(&src) + 1, static_cast<PaddedBase*>(&dst));
-    assert(dst.a_ == 1);
-    assert(dst.b_ == 2);
-    assert(dst.c_ == 6);
-  }
+  test_copy<cpp17_input_iterator<const int*>, cpp17_output_iterator<int*> >();
+  test_copy<cpp17_input_iterator<const int*>, forward_iterator<int*> >();
+  test_copy<cpp17_input_iterator<const int*>, bidirectional_iterator<int*> >();
+  test_copy<cpp17_input_iterator<const int*>, random_access_iterator<int*> >();
+  test_copy<cpp17_input_iterator<const int*>, int*>();
+
+  test_copy<forward_iterator<const int*>, cpp17_output_iterator<int*> >();
+  test_copy<forward_iterator<const int*>, forward_iterator<int*> >();
+  test_copy<forward_iterator<const int*>, bidirectional_iterator<int*> >();
+  test_copy<forward_iterator<const int*>, random_access_iterator<int*> >();
+  test_copy<forward_iterator<const int*>, int*>();
+
+  test_copy<bidirectional_iterator<const int*>, cpp17_output_iterator<int*> >();
+  test_copy<bidirectional_iterator<const int*>, forward_iterator<int*> >();
+  test_copy<bidirectional_iterator<const int*>, bidirectional_iterator<int*> >();
+  test_copy<bidirectional_iterator<const int*>, random_access_iterator<int*> >();
+  test_copy<bidirectional_iterator<const int*>, int*>();
+
+  test_copy<random_access_iterator<const int*>, cpp17_output_iterator<int*> >();
+  test_copy<random_access_iterator<const int*>, forward_iterator<int*> >();
+  test_copy<random_access_iterator<const int*>, bidirectional_iterator<int*> >();
+  test_copy<random_access_iterator<const int*>, random_access_iterator<int*> >();
+  test_copy<random_access_iterator<const int*>, int*>();
+
+  test_copy<const int*, cpp17_output_iterator<int*> >();
+  test_copy<const int*, forward_iterator<int*> >();
+  test_copy<const int*, bidirectional_iterator<int*> >();
+  test_copy<const int*, random_access_iterator<int*> >();
+  test_copy<const int*, int*>();
 
-  { // Make sure that overlapping ranges can be copied
-    int a[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
-    std::copy(a + 3, a + 10, a);
-    int expected[] = {4, 5, 6, 7, 8, 9, 10, 8, 9, 10};
-    assert(std::equal(a, a + 10, expected));
-  }
+#if TEST_STD_VER > 17
+  test_copy<cpp17_input_iterator<const int*>, contiguous_iterator<int*>>();
+  test_copy<forward_iterator<const int*>, contiguous_iterator<int*>>();
+  test_copy<bidirectional_iterator<const int*>, contiguous_iterator<int*>>();
+  test_copy<random_access_iterator<const int*>, contiguous_iterator<int*>>();
+  test_copy<const int*, contiguous_iterator<int*>>();
+
+  test_copy<contiguous_iterator<const int*>, cpp17_output_iterator<int*>>();
+  test_copy<contiguous_iterator<const int*>, forward_iterator<int*>>();
+  test_copy<contiguous_iterator<const int*>, bidirectional_iterator<int*>>();
+  test_copy<contiguous_iterator<const int*>, random_access_iterator<int*>>();
+  test_copy<contiguous_iterator<const int*>, int*>();
+#endif
 
   return true;
 }
 
 int main(int, char**) {
   test();
 
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

libcxx/test/std/algorithms/alg.modifying.operations/alg.copy/copy_backward.pass.cpp

 
 #include <algorithm>
 #include <cassert>
 
 #include "test_macros.h"
 #include "test_iterators.h"
 #include "user_defined_integral.h"
 
-class PaddedBase {
-public:
-  TEST_CONSTEXPR PaddedBase(std::int16_t a, std::int8_t b) : a_(a), b_(b) {}
-
-  std::int16_t a_;
-  std::int8_t b_;
-};
-
-class Derived : public PaddedBase {
-public:
-  TEST_CONSTEXPR Derived(std::int16_t a, std::int8_t b, std::int8_t c) : PaddedBase(a, b), c_(c) {}
-
-  std::int8_t c_;
-};
-
 template <class InIter, class OutIter>
 TEST_CONSTEXPR_CXX20 void
 test_copy_backward()
 {
-  {
     const unsigned N = 1000;
     int ia[N] = {};
     for (unsigned i = 0; i < N; ++i)
         ia[i] = i;
     int ib[N] = {0};
 
     OutIter r = std::copy_backward(InIter(ia), InIter(ia+N), OutIter(ib+N));
     assert(base(r) == ib);
     for (unsigned i = 0; i < N; ++i)
         assert(ia[i] == ib[i]);
-  }
-}
 
 TEST_CONSTEXPR_CXX20 bool
 test()
 {
     test_copy_backward<bidirectional_iterator<const int*>, bidirectional_iterator<int*> >();
     test_copy_backward<bidirectional_iterator<const int*>, random_access_iterator<int*> >();
     test_copy_backward<bidirectional_iterator<const int*>, int*>();
 
#if TEST_STD_VER > 17
     test_copy_backward<contiguous_iterator<const int*>, int*>();
 
     test_copy_backward<bidirectional_iterator<const int*>, contiguous_iterator<int*>>();
     test_copy_backward<random_access_iterator<const int*>, contiguous_iterator<int*>>();
     test_copy_backward<contiguous_iterator<const int*>, contiguous_iterator<int*>>();
     test_copy_backward<const int*, contiguous_iterator<int*>>();
 #endif
 
-  { // Make sure that padding bits aren't copied
-    Derived src(1, 2, 3);
-    Derived dst(4, 5, 6);
-    std::copy_backward(
-        static_cast<PaddedBase*>(&src), static_cast<PaddedBase*>(&src) + 1, static_cast<PaddedBase*>(&dst) + 1);
-    assert(dst.a_ == 1);
-    assert(dst.b_ == 2);
-    assert(dst.c_ == 6);
-  }
-
-  { // Make sure that overlapping ranges can be copied
-    int a[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
-    std::copy_backward(a, a + 7, a + 10);
-    int expected[] = {1, 2, 3, 1, 2, 3, 4, 5, 6, 7};
-    assert(std::equal(a, a + 10, expected));
-  }
-
     return true;
 }
 
 int main(int, char**)
 {
     test();
 
 #if TEST_STD_VER > 17
     static_assert(test());
 #endif
 
   return 0;
 }

libcxx/test/std/algorithms/alg.modifying.operations/alg.copy/copy_n.pass.cpp

 #include <cassert>
 
 #include "test_macros.h"
 #include "test_iterators.h"
 #include "user_defined_integral.h"
 
 typedef UserDefinedIntegral<unsigned> UDI;
 
-class PaddedBase {
-public:
-  TEST_CONSTEXPR PaddedBase(std::int16_t a, std::int8_t b) : a_(a), b_(b) {}
-
-  std::int16_t a_;
-  std::int8_t b_;
-};
-
-class Derived : public PaddedBase {
-public:
-  TEST_CONSTEXPR Derived(std::int16_t a, std::int8_t b, std::int8_t c) : PaddedBase(a, b), c_(c) {}
-
-  std::int8_t c_;
-};
-
 template <class InIter, class OutIter>
 TEST_CONSTEXPR_CXX20 void
 test_copy_n()
 {
-  {
     const unsigned N = 1000;
     int ia[N] = {};
     for (unsigned i = 0; i < N; ++i)
         ia[i] = i;
     int ib[N] = {0};
 
     OutIter r = std::copy_n(InIter(ia), UDI(N/2), OutIter(ib));
     assert(base(r) == ib+N/2);
     for (unsigned i = 0; i < N/2; ++i)
         assert(ia[i] == ib[i]);
-  }
 
-  { // Make sure that padding bits aren't copied
-    Derived src(1, 2, 3);
-    Derived dst(4, 5, 6);
-    std::copy_n(static_cast<PaddedBase*>(&src), 1, static_cast<PaddedBase*>(&dst));
-    assert(dst.a_ == 1);
-    assert(dst.b_ == 2);
-    assert(dst.c_ == 6);
-  }
-
-  { // Make sure that overlapping ranges can be copied
-    int a[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
-    std::copy_n(a + 3, 7, a);
-    int expected[] = {4, 5, 6, 7, 8, 9, 10, 8, 9, 10};
-    assert(std::equal(a, a + 10, expected));
-  }
-}
-
 TEST_CONSTEXPR_CXX20 bool
 test()
 {
     test_copy_n<cpp17_input_iterator<const int*>, cpp17_output_iterator<int*> >();
     test_copy_n<cpp17_input_iterator<const int*>, cpp17_input_iterator<int*> >();
     test_copy_n<cpp17_input_iterator<const int*>, forward_iterator<int*> >();
     test_copy_n<cpp17_input_iterator<const int*>, bidirectional_iterator<int*> >();
     test_copy_n<cpp17_input_iterator<const int*>, random_access_iterator<int*> >();

libcxx/test/std/algorithms/alg.modifying.operations/alg.move/move.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: c++03 && !stdlib=libc++
-// ADDITIONAL_COMPILE_FLAGS(has-fconstexpr-steps): -fconstexpr-steps=2000000
-
 // <algorithm>
 
 // template<InputIterator InIter, typename OutIter>
 //   requires OutputIterator<OutIter, RvalueOf<InIter::reference>::type>
 //   OutIter
 //   move(InIter first, InIter last, OutIter result);
 
 #include <algorithm>
 #include <cassert>
 #include <memory>
 
 #include "test_macros.h"
 #include "test_iterators.h"
 
-class PaddedBase {
-public:
-  TEST_CONSTEXPR PaddedBase(std::int16_t a, std::int8_t b) : a_(a), b_(b) {}
-
-  std::int16_t a_;
-  std::int8_t b_;
-};
-
-class Derived : public PaddedBase {
-public:
-  TEST_CONSTEXPR Derived(std::int16_t a, std::int8_t b, std::int8_t c) : PaddedBase(a, b), c_(c) {}
-
-  std::int8_t c_;
-};
-
-template <class InIter>
-struct Test {
-  template <class OutIter>
-  TEST_CONSTEXPR_CXX20 void operator()() {
+template <class InIter, class OutIter>
+TEST_CONSTEXPR_CXX17 bool
+test()
+{
     const unsigned N = 1000;
     int ia[N] = {};
     for (unsigned i = 0; i < N; ++i)
         ia[i] = i;
     int ib[N] = {0};
 
     OutIter r = std::move(InIter(ia), InIter(ia+N), OutIter(ib));
     assert(base(r) == ib+N);
     for (unsigned i = 0; i < N; ++i)
         assert(ia[i] == ib[i]);
-  }
-};
 
-struct TestOutIters {
-  template <class InIter>
-  TEST_CONSTEXPR_CXX20 void operator()() {
-    types::for_each(
-        types::concatenate_t<types::cpp17_input_iterator_list<int*>, types::type_list<cpp17_output_iterator<int*> > >(),
-        Test<InIter>());
-  }
-};
+    return true;
 
-template <class InIter>
-struct Test1 {
-  template <class OutIter>
-  TEST_CONSTEXPR_CXX23 void operator()() {
+#if TEST_STD_VER >= 11
+template <class InIter, class OutIter>
+void
+test1()
+{
     const unsigned N = 100;
     std::unique_ptr<int> ia[N];
     for (unsigned i = 0; i < N; ++i)
         ia[i].reset(new int(i));
     std::unique_ptr<int> ib[N];
 
     OutIter r = std::move(InIter(ia), InIter(ia+N), OutIter(ib));
     assert(base(r) == ib+N);
     for (unsigned i = 0; i < N; ++i)
         assert(*ib[i] == static_cast<int>(i));
-  }
-};
-
-struct Test1OutIters {
-  template <class InIter>
-  TEST_CONSTEXPR_CXX23 void operator()() {
-    types::for_each(types::concatenate_t<types::cpp17_input_iterator_list<std::unique_ptr<int>*>,
-                                         types::type_list<cpp17_output_iterator<std::unique_ptr<int>*> > >(),
-                    Test1<InIter>());
-  }
-};
-
-TEST_CONSTEXPR_CXX20 bool test() {
-  types::for_each(types::cpp17_input_iterator_list<int*>(), TestOutIters());
-  if (TEST_STD_VER >= 23 || !TEST_IS_CONSTANT_EVALUATED)
-    types::for_each(types::cpp17_input_iterator_list<std::unique_ptr<int>*>(), Test1OutIters());
-
-  { // Make sure that padding bits aren't copied
-    Derived src(1, 2, 3);
-    Derived dst(4, 5, 6);
-    std::move(static_cast<PaddedBase*>(&src), static_cast<PaddedBase*>(&src) + 1, static_cast<PaddedBase*>(&dst));
-    assert(dst.a_ == 1);
-    assert(dst.b_ == 2);
-    assert(dst.c_ == 6);
-  }
-
-  { // Make sure that overlapping ranges can be copied
-    int a[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
-    std::move(a + 3, a + 10, a);
-    int expected[] = {4, 5, 6, 7, 8, 9, 10, 8, 9, 10};
-    assert(std::equal(a, a + 10, expected));
-  }
-
-  return true;
-}
+#endif
 
 int main(int, char**)
 {
-  test();
-#if TEST_STD_VER >= 20
-  static_assert(test());
-#endif
+    test<cpp17_input_iterator<const int*>, cpp17_output_iterator<int*> >();
+    test<cpp17_input_iterator<const int*>, forward_iterator<int*> >();
+    test<cpp17_input_iterator<const int*>, bidirectional_iterator<int*> >();
+    test<cpp17_input_iterator<const int*>, random_access_iterator<int*> >();
+    test<cpp17_input_iterator<const int*>, int*>();
+
+    test<forward_iterator<const int*>, cpp17_output_iterator<int*> >();
+    test<forward_iterator<const int*>, forward_iterator<int*> >();
+    test<forward_iterator<const int*>, bidirectional_iterator<int*> >();
+    test<forward_iterator<const int*>, random_access_iterator<int*> >();
+    test<forward_iterator<const int*>, int*>();
+
+    test<bidirectional_iterator<const int*>, cpp17_output_iterator<int*> >();
+    test<bidirectional_iterator<const int*>, forward_iterator<int*> >();
+    test<bidirectional_iterator<const int*>, bidirectional_iterator<int*> >();
+    test<bidirectional_iterator<const int*>, random_access_iterator<int*> >();
+    test<bidirectional_iterator<const int*>, int*>();
+
+    test<random_access_iterator<const int*>, cpp17_output_iterator<int*> >();
+    test<random_access_iterator<const int*>, forward_iterator<int*> >();
+    test<random_access_iterator<const int*>, bidirectional_iterator<int*> >();
+    test<random_access_iterator<const int*>, random_access_iterator<int*> >();
+    test<random_access_iterator<const int*>, int*>();
+
+    test<const int*, cpp17_output_iterator<int*> >();
+    test<const int*, forward_iterator<int*> >();
+    test<const int*, bidirectional_iterator<int*> >();
+    test<const int*, random_access_iterator<int*> >();
+    test<const int*, int*>();
+
+#if TEST_STD_VER >= 11
+    test1<cpp17_input_iterator<std::unique_ptr<int>*>, cpp17_output_iterator<std::unique_ptr<int>*> >();
+    test1<cpp17_input_iterator<std::unique_ptr<int>*>, forward_iterator<std::unique_ptr<int>*> >();
+    test1<cpp17_input_iterator<std::unique_ptr<int>*>, bidirectional_iterator<std::unique_ptr<int>*> >();
+    test1<cpp17_input_iterator<std::unique_ptr<int>*>, random_access_iterator<std::unique_ptr<int>*> >();
+    test1<cpp17_input_iterator<std::unique_ptr<int>*>, std::unique_ptr<int>*>();
+
+    test1<forward_iterator<std::unique_ptr<int>*>, cpp17_output_iterator<std::unique_ptr<int>*> >();
+    test1<forward_iterator<std::unique_ptr<int>*>, forward_iterator<std::unique_ptr<int>*> >();
+    test1<forward_iterator<std::unique_ptr<int>*>, bidirectional_iterator<std::unique_ptr<int>*> >();
+    test1<forward_iterator<std::unique_ptr<int>*>, random_access_iterator<std::unique_ptr<int>*> >();
+    test1<forward_iterator<std::unique_ptr<int>*>, std::unique_ptr<int>*>();
+
+    test1<bidirectional_iterator<std::unique_ptr<int>*>, cpp17_output_iterator<std::unique_ptr<int>*> >();
+    test1<bidirectional_iterator<std::unique_ptr<int>*>, forward_iterator<std::unique_ptr<int>*> >();
+    test1<bidirectional_iterator<std::unique_ptr<int>*>, bidirectional_iterator<std::unique_ptr<int>*> >();
+    test1<bidirectional_iterator<std::unique_ptr<int>*>, random_access_iterator<std::unique_ptr<int>*> >();
+    test1<bidirectional_iterator<std::unique_ptr<int>*>, std::unique_ptr<int>*>();
+
+    test1<random_access_iterator<std::unique_ptr<int>*>, cpp17_output_iterator<std::unique_ptr<int>*> >();
+    test1<random_access_iterator<std::unique_ptr<int>*>, forward_iterator<std::unique_ptr<int>*> >();
+    test1<random_access_iterator<std::unique_ptr<int>*>, bidirectional_iterator<std::unique_ptr<int>*> >();
+    test1<random_access_iterator<std::unique_ptr<int>*>, random_access_iterator<std::unique_ptr<int>*> >();
+    test1<random_access_iterator<std::unique_ptr<int>*>, std::unique_ptr<int>*>();
+
+    test1<std::unique_ptr<int>*, cpp17_output_iterator<std::unique_ptr<int>*> >();
+    test1<std::unique_ptr<int>*, forward_iterator<std::unique_ptr<int>*> >();
+    test1<std::unique_ptr<int>*, bidirectional_iterator<std::unique_ptr<int>*> >();
+    test1<std::unique_ptr<int>*, random_access_iterator<std::unique_ptr<int>*> >();
+    test1<std::unique_ptr<int>*, std::unique_ptr<int>*>();
+#endif // TEST_STD_VER >= 11
+
+#if TEST_STD_VER > 17
+    test<cpp17_input_iterator<const int*>, contiguous_iterator<int*>>();
+    test<forward_iterator<const int*>, contiguous_iterator<int*>>();
+    test<bidirectional_iterator<const int*>, contiguous_iterator<int*>>();
+    test<random_access_iterator<const int*>, contiguous_iterator<int*>>();
+    test<const int*, contiguous_iterator<int*>>();
+    test<contiguous_iterator<const int*>, cpp17_output_iterator<int*>>();
+    test<contiguous_iterator<const int*>, forward_iterator<int*>>();
+    test<contiguous_iterator<const int*>, bidirectional_iterator<int*>>();
+    test<contiguous_iterator<const int*>, random_access_iterator<int*>>();
+    test<contiguous_iterator<const int*>, int*>();
+    test<contiguous_iterator<const int*>, contiguous_iterator<int*>>();
+
+    test1<cpp17_input_iterator<std::unique_ptr<int>*>, contiguous_iterator<std::unique_ptr<int>*>>();
+    test1<forward_iterator<std::unique_ptr<int>*>, contiguous_iterator<std::unique_ptr<int>*>>();
+    test1<bidirectional_iterator<std::unique_ptr<int>*>, contiguous_iterator<std::unique_ptr<int>*>>();
+    test1<random_access_iterator<std::unique_ptr<int>*>, contiguous_iterator<std::unique_ptr<int>*>>();
+    test1<std::unique_ptr<int>*, contiguous_iterator<std::unique_ptr<int>*>>();
+    test1<contiguous_iterator<std::unique_ptr<int>*>, cpp17_output_iterator<std::unique_ptr<int>*>>();
+    test1<contiguous_iterator<std::unique_ptr<int>*>, forward_iterator<std::unique_ptr<int>*>>();
+    test1<contiguous_iterator<std::unique_ptr<int>*>, bidirectional_iterator<std::unique_ptr<int>*>>();
+    test1<contiguous_iterator<std::unique_ptr<int>*>, random_access_iterator<std::unique_ptr<int>*>>();
+    test1<contiguous_iterator<std::unique_ptr<int>*>, std::unique_ptr<int>*>();
+    test1<contiguous_iterator<std::unique_ptr<int>*>, contiguous_iterator<std::unique_ptr<int>*>>();
+
+    static_assert(test<cpp17_input_iterator<const int*>, cpp17_input_iterator<int*> >());
+    static_assert(test<cpp17_input_iterator<const int*>, forward_iterator<int*> >());
+    static_assert(test<cpp17_input_iterator<const int*>, bidirectional_iterator<int*> >());
+    static_assert(test<cpp17_input_iterator<const int*>, random_access_iterator<int*> >());
+    static_assert(test<cpp17_input_iterator<const int*>, contiguous_iterator<int*> >());
+    static_assert(test<cpp17_input_iterator<const int*>, int*>());
+
+    static_assert(test<forward_iterator<const int*>, cpp17_input_iterator<int*> >());
+    static_assert(test<forward_iterator<const int*>, forward_iterator<int*> >());
+    static_assert(test<forward_iterator<const int*>, bidirectional_iterator<int*> >());
+    static_assert(test<forward_iterator<const int*>, random_access_iterator<int*> >());
+    static_assert(test<forward_iterator<const int*>, contiguous_iterator<int*> >());
+    static_assert(test<forward_iterator<const int*>, int*>());
+
+    static_assert(test<bidirectional_iterator<const int*>, cpp17_input_iterator<int*> >());
+    static_assert(test<bidirectional_iterator<const int*>, forward_iterator<int*> >());
+    static_assert(test<bidirectional_iterator<const int*>, bidirectional_iterator<int*> >());
+    static_assert(test<bidirectional_iterator<const int*>, random_access_iterator<int*> >());
+    static_assert(test<bidirectional_iterator<const int*>, contiguous_iterator<int*> >());
+    static_assert(test<bidirectional_iterator<const int*>, int*>());
+
+    static_assert(test<random_access_iterator<const int*>, cpp17_input_iterator<int*> >());
+    static_assert(test<random_access_iterator<const int*>, forward_iterator<int*> >());
+    static_assert(test<random_access_iterator<const int*>, bidirectional_iterator<int*> >());
+    static_assert(test<random_access_iterator<const int*>, random_access_iterator<int*> >());
+    static_assert(test<random_access_iterator<const int*>, contiguous_iterator<int*> >());
+    static_assert(test<random_access_iterator<const int*>, int*>());
+
+    static_assert(test<contiguous_iterator<const int*>, cpp17_input_iterator<int*> >());
+    static_assert(test<contiguous_iterator<const int*>, forward_iterator<int*> >());
+    static_assert(test<contiguous_iterator<const int*>, bidirectional_iterator<int*> >());
+    static_assert(test<contiguous_iterator<const int*>, random_access_iterator<int*> >());
+    static_assert(test<contiguous_iterator<const int*>, contiguous_iterator<int*> >());
+    static_assert(test<contiguous_iterator<const int*>, int*>());
+
+    static_assert(test<const int*, cpp17_input_iterator<int*> >());
+    static_assert(test<const int*, forward_iterator<int*> >());
+    static_assert(test<const int*, bidirectional_iterator<int*> >());
+    static_assert(test<const int*, random_access_iterator<int*> >());
+    static_assert(test<const int*, contiguous_iterator<int*> >());
+    static_assert(test<const int*, int*>());
+#endif // TEST_STD_VER > 17
 
   return 0;
 }

libcxx/test/std/algorithms/alg.modifying.operations/alg.move/move_backward.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: c++03 && !stdlib=libc++
-
 // <algorithm>
 
 // template<BidirectionalIterator InIter, BidirectionalIterator OutIter>
 //   requires OutputIterator<OutIter, RvalueOf<InIter::reference>::type>
 //   OutIter
 //   move_backward(InIter first, InIter last, OutIter result);
 
 #include <algorithm>
 #include <cassert>
 #include <memory>
 
 #include "test_macros.h"
 #include "test_iterators.h"
 
-class PaddedBase {
-public:
-  TEST_CONSTEXPR PaddedBase(std::int16_t a, std::int8_t b) : a_(a), b_(b) {}
-
-  std::int16_t a_;
-  std::int8_t b_;
-};
-
-class Derived : public PaddedBase {
-public:
-  TEST_CONSTEXPR Derived(std::int16_t a, std::int8_t b, std::int8_t c) : PaddedBase(a, b), c_(c) {}
-
-  std::int8_t c_;
-};
-
-template <class InIter>
-struct Test {
-  template <class OutIter>
-  TEST_CONSTEXPR_CXX20 void operator()() {
-    const unsigned N = 1000;
-    int ia[N] = {};
-    for (unsigned i = 0; i < N; ++i)
-        ia[i] = i;
-    int ib[N] = {0};
+template <class InIter, class OutIter>
+TEST_CONSTEXPR_CXX17 bool test() {
+  int ia[N]        = {};
 
-    OutIter r = std::move_backward(InIter(ia), InIter(ia+N), OutIter(ib+N));
-    assert(base(r) == ib);
-    for (unsigned i = 0; i < N; ++i)
-        assert(ia[i] == ib[i]);
-  }
-};
+  OutIter r = std::move_backward(InIter(ia), InIter(ia + N), OutIter(ib + N));
 
-struct TestOutIters {
-  template <class InIter>
-  TEST_CONSTEXPR_CXX20 void operator()() {
-    types::for_each(
-        types::concatenate_t<types::bidirectional_iterator_list<int*> >(),
-        Test<InIter>());
-  }
-};
+  return true;
 
-template <class InIter>
-struct Test1 {
-  template <class OutIter>
-  TEST_CONSTEXPR_CXX23 void operator()() {
-    const unsigned N = 100;
-    std::unique_ptr<int> ia[N];
-    for (unsigned i = 0; i < N; ++i)
-        ia[i].reset(new int(i));
-    std::unique_ptr<int> ib[N];
+#if TEST_STD_VER >= 11
+template <class InIter, class OutIter>
+void test1() {
 
-    OutIter r = std::move_backward(InIter(ia), InIter(ia+N), OutIter(ib+N));
-    assert(base(r) == ib);
-    for (unsigned i = 0; i < N; ++i)
-        assert(*ib[i] == static_cast<int>(i));
-  }
-};
-
-struct Test1OutIters {
-  template <class InIter>
-  TEST_CONSTEXPR_CXX23 void operator()() {
-    types::for_each(types::concatenate_t<types::bidirectional_iterator_list<std::unique_ptr<int>*> >(),
-                    Test1<InIter>());
-  }
-};
-
-TEST_CONSTEXPR_CXX20 bool test() {
-  types::for_each(types::bidirectional_iterator_list<int*>(), TestOutIters());
-  if (TEST_STD_VER >= 23 || !TEST_IS_CONSTANT_EVALUATED)
-    types::for_each(types::bidirectional_iterator_list<std::unique_ptr<int>*>(), Test1OutIters());
-
-  { // Make sure that padding bits aren't copied
-    Derived src(1, 2, 3);
-    Derived dst(4, 5, 6);
-    std::move_backward(
-        static_cast<PaddedBase*>(&src), static_cast<PaddedBase*>(&src) + 1, static_cast<PaddedBase*>(&dst) + 1);
-    assert(dst.a_ == 1);
-    assert(dst.b_ == 2);
-    assert(dst.c_ == 6);
-  }
-
-  { // Make sure that overlapping ranges can be copied
-    int a[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
-    std::move_backward(a, a + 7, a + 10);
-    int expected[] = {1, 2, 3, 1, 2, 3, 4, 5, 6, 7};
-    assert(std::equal(a, a + 10, expected));
-  }
-
-  return true;
-}
+  OutIter r = std::move_backward(InIter(ia), InIter(ia + N), OutIter(ib + N));
+#endif
 
 int main(int, char**)
 {
-  test();
-#if TEST_STD_VER >= 20
-  static_assert(test());
-#endif
+  test<bidirectional_iterator<const int*>, bidirectional_iterator<int*> >();
+  test<bidirectional_iterator<const int*>, random_access_iterator<int*> >();
+  test<bidirectional_iterator<const int*>, int*>();
+
+  test<random_access_iterator<const int*>, bidirectional_iterator<int*> >();
+  test<random_access_iterator<const int*>, random_access_iterator<int*> >();
+  test<random_access_iterator<const int*>, int*>();
+
+  test<const int*, bidirectional_iterator<int*> >();
+  test<const int*, random_access_iterator<int*> >();
+  test<const int*, int*>();
+
+#if TEST_STD_VER >= 11
+  test1<bidirectional_iterator<std::unique_ptr<int>*>, bidirectional_iterator<std::unique_ptr<int>*> >();
+  test1<bidirectional_iterator<std::unique_ptr<int>*>, random_access_iterator<std::unique_ptr<int>*> >();
+  test1<bidirectional_iterator<std::unique_ptr<int>*>, std::unique_ptr<int>*>();
+
+  test1<random_access_iterator<std::unique_ptr<int>*>, bidirectional_iterator<std::unique_ptr<int>*> >();
+  test1<random_access_iterator<std::unique_ptr<int>*>, random_access_iterator<std::unique_ptr<int>*> >();
+  test1<random_access_iterator<std::unique_ptr<int>*>, std::unique_ptr<int>*>();
+
+  test1<std::unique_ptr<int>*, bidirectional_iterator<std::unique_ptr<int>*> >();
+  test1<std::unique_ptr<int>*, random_access_iterator<std::unique_ptr<int>*> >();
+  test1<std::unique_ptr<int>*, std::unique_ptr<int>*>();
+#endif // TEST_STD_VER >= 11
+
+#if TEST_STD_VER > 17
+  test<bidirectional_iterator<const int*>, contiguous_iterator<int*>>();
+  test<random_access_iterator<const int*>, contiguous_iterator<int*>>();
+  test<const int*, contiguous_iterator<int*>>();
+  test<contiguous_iterator<const int*>, bidirectional_iterator<int*>>();
+  test<contiguous_iterator<const int*>, random_access_iterator<int*>>();
+  test<contiguous_iterator<const int*>, int*>();
+  test<contiguous_iterator<const int*>, contiguous_iterator<int*>>();
+
+  test1<bidirectional_iterator<std::unique_ptr<int>*>, contiguous_iterator<std::unique_ptr<int>*>>();
+  test1<random_access_iterator<std::unique_ptr<int>*>, contiguous_iterator<std::unique_ptr<int>*>>();
+  test1<std::unique_ptr<int>*, contiguous_iterator<std::unique_ptr<int>*>>();
+  test1<contiguous_iterator<std::unique_ptr<int>*>, bidirectional_iterator<std::unique_ptr<int>*>>();
+  test1<contiguous_iterator<std::unique_ptr<int>*>, random_access_iterator<std::unique_ptr<int>*>>();
+  test1<contiguous_iterator<std::unique_ptr<int>*>, std::unique_ptr<int>*>();
+  test1<contiguous_iterator<std::unique_ptr<int>*>, contiguous_iterator<std::unique_ptr<int>*>>();
+
+  static_assert(test<bidirectional_iterator<const int*>, bidirectional_iterator<int*> >());
+  static_assert(test<bidirectional_iterator<const int*>, random_access_iterator<int*> >());
+  static_assert(test<bidirectional_iterator<const int*>, contiguous_iterator<int*> >());
+  static_assert(test<bidirectional_iterator<const int*>, int*>());
+
+  static_assert(test<random_access_iterator<const int*>, bidirectional_iterator<int*> >());
+  static_assert(test<random_access_iterator<const int*>, random_access_iterator<int*> >());
+  static_assert(test<random_access_iterator<const int*>, contiguous_iterator<int*> >());
+  static_assert(test<random_access_iterator<const int*>, int*>());
+
+  static_assert(test<contiguous_iterator<const int*>, bidirectional_iterator<int*> >());
+  static_assert(test<contiguous_iterator<const int*>, random_access_iterator<int*> >());
+  static_assert(test<contiguous_iterator<const int*>, contiguous_iterator<int*> >());
+  static_assert(test<contiguous_iterator<const int*>, int*>());
+
+  static_assert(test<const int*, bidirectional_iterator<int*> >());
+  static_assert(test<const int*, random_access_iterator<int*> >());
+  static_assert(test<const int*, contiguous_iterator<int*> >());
+  static_assert(test<const int*, int*>());
+#endif // TEST_STD_VER > 17
 
   return 0;
 }