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

[philnik]

Summary

This fixes thr bug reported in https://gcc.gnu.org/bugzilla/show_bug.cgi?id=108846.

[ldionne]

libcxx/include/__string/constexpr_c_functions.h

136

I think we are fine with __constexpr_memmove, but the confusion here comes from the fact that we don't have a great way of conveying what the __count is: is it a number of elements or a number of bytes? This is also a problem we have in our other functions like __constexpr_memcmp_equal and others.

One suggestion would be to introduce types like this:

enum class _NumberOfElements : size_t {};
enum class _NumberOfBytes : size_t {};

And then we could take the appropriate parameter in __constexpr_memmove. The benefit is that callers would now explicitly pass the value so there's no ambiguity:

__constexpr_memmove(dest, src, _NumberOfElements(n)) // works
__constexpr_memmove(dest, src, _NumberOfBytes(n)) // doesn't work
__constexpr_memmove(dest, src, n) // doesn't work

We could apply the same thing to the other functions. If we do this, perhaps we should start with a refactoring of the existing functions?

139

Can we replace __char_traits_move by this?

147

This is the case where __is_ptr_in_range(dst, dstend, src) is true. This must be implemented using a normal forward for-loop:

|-------------------------------------------------|
                         ^ src                    ^ srcend
        ^ dst                         ^ dstend

This is the case where __is_ptr_in_range(src, srcend, dst) is true. This must be implemented by looping backwards from srcend to src and writing from dstend to dst.

|-------------------------------------------------|
        ^ src                    ^ srcend
                    ^ dst                         ^ dstend

Right now I think you have the logic the wrong way around. This also needs a test.

The logic should be

std::__is_pointer_in_range(__src, __src + __count, __dest)

libcxx/include/__type_traits/datasizeof.h

23–24

32–33

This fails for builtin types. Needs a test!

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

1

What about copy_n, copy_backward and move_backward?

52–58

Let's enclose this in {} to make it clear we're testing a separate property. (everywhere)

[philnik]

Address comments

[philnik]

Rebased

[philnik]

Try to fix CI

[philnik]

Rebased

[philnik]

Next try

[ldionne]

I think this LGTM but I'd like to see again once the rebase issues have been resolved.

[philnik]

Fix diff

[ldionne]

libcxx/include/__utility/is_pointer_in_range.h

40

This is never true since you're passing _Tp*. is_function<_Tp> was correct, I think.

Edit: Actually the overload won't match if passed a function, so let's remove this altogether. You can probably remove some includes too.

42–43

If T is a ptr to member, this function doesn't match so I don't think it's too useful to have this static_assert at all: https://godbolt.org/z/8z8KPn9e5

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

53

Since this test case and the one below it are not dependent on any template params, let's move them out of this function. It confused me at first. Probably applies to the other test files as well.

[philnik]

Address comments

[philnik]

Fix formatting

[philnik]

Try to fix CI

[philnik]

Next try

[philnik]

Try to fix CI

[philnik]

Try to fix CI

[alexfh]

libcxx/include/__string/constexpr_c_functions.h

149

Some of our (and third-party) code started triggering an error related to this line after this commit. It turns out, std::vector<T>::erase() doesn't compile now, if T is move-only: https://gcc.godbolt.org/z/Txnc66M97

Is this intended?

[ldionne]

libcxx/include/__string/constexpr_c_functions.h

149

Hmm, thanks for the heads up. vector<T>::erase(...) should only require that T is move assignable. In fact, it looks like this is being triggered in the std::move algorithm -- we probably don't have tests with move-only types in std::move, which is pretty embarrassing. @philnik it looks like we need to check additional constraints before calling __constexpr_memmove. Using std::move(__src[__count - 1]) here wouldn't be an option since the semantics wouldn't match those of memmove IMO.

[alexfh]

libcxx/include/__string/constexpr_c_functions.h

149

If this is not intended, I'd ask for a revert, since the impact of this is rather large.

[hans]

libcxx/include/__string/constexpr_c_functions.h

149

+1 this is breaking us (Chromium) also.

[ldionne]

libcxx/include/__string/constexpr_c_functions.h

149

See D154613. This patch is old enough that we'd like to avoid reverting, especially since we have a clear understanding of the issue.

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);
-  ::__builtin_memmove(__result, __first, __n * sizeof(_Out));
+
+  std::__constexpr_memmove(__result, __first, __element_count(__n));
 
   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;
 
-  ::__builtin_memmove(__result, __first, __n * sizeof(_Out));
+  std::__constexpr_memmove(__result, __first, __element_count(__n));
 
   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::__char_traits_move(__s1, __s2, __n);
+        return std::__constexpr_memmove(__s1, __s2, __element_count(__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(__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::__char_traits_move(__s1, __s2, __n);
+        return std::__constexpr_memmove(__s1, __s2, __element_count(__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(__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::__char_traits_move(__s1, __s2, __n);
+        return std::__constexpr_memmove(__s1, __s2, __element_count(__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(__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::__char_traits_move(__s1, __s2, __n);
+        return std::__constexpr_memmove(__s1, __s2, __element_count(__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(__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::__char_traits_move(__s1, __s2, __n);
+        return std::__constexpr_memmove(__s1, __s2, __element_count(__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

 #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/is_trivially_lexicographically_comparable.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,
+  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,
+  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(__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/module.modulemap.in

module type_traits {
     module apply_cv                                  { private header "__type_traits/apply_cv.h" }
     module can_extract_key                           { private header "__type_traits/can_extract_key.h" }
     module common_reference                          { private header "__type_traits/common_reference.h" }
     module common_type                               { private header "__type_traits/common_type.h" }
     module conditional                               { private header "__type_traits/conditional.h" }
     module conjunction                               { private header "__type_traits/conjunction.h" }
     module copy_cv                                   { private header "__type_traits/copy_cv.h" }
     module copy_cvref                                { private header "__type_traits/copy_cvref.h" }
+    module datasizeof                                { private header "__type_traits/datasizeof.h" }
     module decay                                     { private header "__type_traits/decay.h" }
     module dependent_type                            { private header "__type_traits/dependent_type.h" }
     module disjunction                               { private header "__type_traits/disjunction.h" }
     module enable_if                                 { private header "__type_traits/enable_if.h" }
     module extent                                    { private header "__type_traits/extent.h" }
     module has_unique_object_representation          { private header "__type_traits/has_unique_object_representation.h" }
     module has_virtual_destructor                    { private header "__type_traits/has_virtual_destructor.h" }
     module integral_constant                         { private header "__type_traits/integral_constant.h" }

libcxx/include/string

 template <class _CharT, class _Traits, class _Tp>
 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 {};
 
-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;
basic_string& __null_terminate_at(value_type* __p, size_type __newsz) {
       __set_size(__newsz);
       __invalidate_iterators_past(__newsz);
       traits_type::assign(__p[__newsz], value_type());
       return *this;
     }
 
     _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void __invalidate_iterators_past(size_type);
 
-    template <
-        class _Tp,
-        __enable_if_t<__is_less_than_comparable<const __remove_cvref_t<_Tp>*, const value_type*>::value, int> = 0>
+    template <class _Tp>
     _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 limits
 locale mutex
 locale new
 locale streambuf
 locale string
 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 limits
 locale mutex
 locale new
 locale streambuf
 locale string
 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;
+};
+
+static_assert(std::__libcpp_datasizeof<OneBytePadding>::value == 3, "");
+
+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

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // <algorithm>
 
 // template<InputIterator InIter, OutputIterator<auto, InIter::reference> OutIter>
 //   constexpr OutIter   // constexpr after C++17
 //   copy(InIter first, InIter last, OutIter result);
 
 #include <algorithm>
 #include <cassert>
 
 #include "test_macros.h"
 #include "test_iterators.h"
 
-template <class InIter, class OutIter>
-TEST_CONSTEXPR_CXX20 void
-test_copy()
+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] = {};
+      int ia[N]        = {};
       for (unsigned i = 0; i < N; ++i)
         ia[i] = i;
       int ib[N] = {0};
 
-    OutIter r = std::copy(InIter(ia), InIter(ia+N), OutIter(ib));
-    assert(base(r) == ib+N);
+      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]);
     }
 
-TEST_CONSTEXPR_CXX20 bool
-test()
-{
-    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 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);
+    }
 
-#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
+    { // 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));
+    }
+  }
+};
+
+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());
 
   return true;
 }
 
-int main(int, char**)
-{
-    test();
+int main(int, char**) {
 
 #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]);
   }
 
+  { // 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));
+  }
+}
+
 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*>();
 
     test_copy_backward<random_access_iterator<const int*>, bidirectional_iterator<int*> >();

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++
+
 // <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, 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]);
 
+    // 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);
+
     return true;
 }
 
-#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));
 }
-#endif
 
 int main(int, char**)
 {
     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*>();
int main(int, char**)
     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>*> >();
int main(int, char**)
     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*>>();

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

 
 #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, class OutIter>
 TEST_CONSTEXPR_CXX17 bool
 test()
 {
     const unsigned N = 1000;
     int ia[N] = {};
     for (unsigned i = 0; i < N; ++i)
         ia[i] = i;
#if TEST_STD_VER > 17
     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
 
+  { // 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 0;
 }

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/move.pass.cpp

struct ConstructsWithTupleLeaf
 
     template <class T>
     ConstructsWithTupleLeaf(T) {
         static_assert(!std::is_same<T, T>::value,
                       "Constructor instantiated for type other than int");
     }
 };
 
+class PaddedBase {
+public:
+  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:
+  constexpr Derived(std::int16_t a, std::int8_t b, std::int8_t c) : PaddedBase(a, b), c_(c) {}
+
+  std::int8_t c_;
+};
+
 // move_only type which triggers the empty base optimization
 struct move_only_ebo {
   move_only_ebo() = default;
   move_only_ebo(move_only_ebo&&) = default;
 };
 
 // a move_only type which does not trigger the empty base optimization
 struct move_only_large final {
// uses-allocator special member constructors
         static_assert(!std::is_constructible<Tup, Tag, Alloc, Tup &>::value, "");
     }
     // uses-allocator args constructors
     {
         static_assert(std::is_constructible<Tup, Tag, Alloc, Elem&&>::value, "");
         static_assert(!std::is_constructible<Tup, Tag, Alloc, Elem const&>::value, "");
         static_assert(!std::is_constructible<Tup, Tag, Alloc, Elem &>::value, "");
     }
+
+    { // 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));
+    }
 }
 
 int main(int, char**)
 {
     {
         typedef std::tuple<> T;
         T t0;
         T t = std::move(t0);