[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?

54–60

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 ↗

(On Diff #530722)

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 ↗

(On Diff #530722)

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

55

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/string

 #include <__type_traits/is_convertible.h>
 #include <__type_traits/is_nothrow_default_constructible.h>
 #include <__type_traits/is_nothrow_move_assignable.h>
 #include <__type_traits/is_same.h>
 #include <__type_traits/is_standard_layout.h>
 #include <__type_traits/is_trivial.h>
 #include <__type_traits/noexcept_move_assign_container.h>
 #include <__type_traits/remove_cvref.h>
+#include <__type_traits/void_t.h>
 #include <__utility/auto_cast.h>
+#include <__utility/declval.h>
 #include <__utility/is_pointer_in_range.h>
 #include <__utility/move.h>
 #include <__utility/swap.h>
 #include <__utility/unreachable.h>
 #include <climits>
 #include <cstdint>
 #include <cstdio>  // EOF
 #include <cstring>

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:
+  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_;
+};
+
+static_assert(sizeof(Derived) == 4);
+
+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:
+  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_;
+};
+
 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:
+  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_;
+};
+
 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:
+  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_;
+};
+
 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:
+  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_;
+};
+
 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);