[libc++][test] Add '-Wdeprecated-copy', '-Wdeprecated-copy-dtor' warnings to the test suite

[ldionne]

Summary

This is a follow up to https://reviews.llvm.org/D144694.
Fixes https://github.com/llvm/llvm-project/issues/60977.

[fsb4000]

fix tests

[fsb4000]

fix more tests

[CaseyCarter]

Guess I'll stop working on this ;)

libcxx/utils/libcxx/test/params.py

15

I suggest using both -Wdeprecated-copy and -Wdeprecated-copy-dtor here (I'm not sure if GCC supports the longer -Wdeprecated-copy-with-user-provided-dtor, but the manual does include -Wdeprecated-copy-dtor.)

[fsb4000]

libcxx/utils/libcxx/test/params.py

15

Yes, GCC doesn't support -Wdeprecated-copy-with-user-provided-dtor

I changed the warning flag.

[Mordante]

Thanks for working on this!
I assume this fixes https://github.com/llvm/llvm-project/issues/60977. If so can you mention it in the commit message?

libcxx/test/libcxx/memory/trivial_abi/unique_ptr_destruction_order.pass.cpp

30

Can these be deleted instead? I assume the id was intentionally const qualified.

libcxx/test/support/counting_predicates.h

24

Are they used? Copying the count_ seems wrong.

The same for copies of other stateful parts in the tests.

[fsb4000]

libcxx/test/libcxx/memory/trivial_abi/unique_ptr_destruction_order.pass.cpp

30

Without my changes:

/home/libcxx-builder/.buildkite-agent/builds/99763c758770-1/llvm-project/libcxx-ci/libcxx/test/libcxx/memory/trivial_abi/unique_ptr_destruction_order.pass.cpp:29:3: error: definition of implicit copy constructor for 'Base' is deprecated because it has a user-provided destructor [-Werror,-Wdeprecated-copy-with-user-provided-dtor]
  ~Base() { shared_buff[(*cur_idx)++] = id; }
  ^
/home/libcxx-builder/.buildkite-agent/builds/99763c758770-1/llvm-project/libcxx-ci/libcxx/test/libcxx/memory/trivial_abi/unique_ptr_destruction_order.pass.cpp:32:8: note: in implicit copy constructor for 'Base' first required here
struct A : Base {
       ^
/home/libcxx-builder/.buildkite-agent/builds/99763c758770-1/llvm-project/libcxx-ci/libcxx/test/libcxx/memory/trivial_abi/unique_ptr_destruction_order.pass.cpp:53:8: note: in implicit move constructor for 'A' first required here
  func(A(shared_buf, &cur_idx), std::unique_ptr<B>(new B(shared_buf, &cur_idx)),

If I add =default:

/home/libcxx-builder/.buildkite-agent/builds/c072959aa3b7-1/llvm-project/libcxx-ci/libcxx/test/libcxx/memory/trivial_abi/unique_ptr_destruction_order.pass.cpp:30:9: error: explicitly defaulted copy assignment operator is implicitly deleted [-Werror,-Wdefaulted-function-deleted]
  Base& operator=(const Base&) = default;
        ^
/home/libcxx-builder/.buildkite-agent/builds/c072959aa3b7-1/llvm-project/libcxx-ci/libcxx/test/libcxx/memory/trivial_abi/unique_ptr_destruction_order.pass.cpp:25:14: note: copy assignment operator of 'Base' is implicitly deleted because field 'id' is of const-qualified type 'const char'
  const char id;
             ^
/home/libcxx-builder/.buildkite-agent/builds/c072959aa3b7-1/llvm-project/libcxx-ci/libcxx/test/libcxx/memory/trivial_abi/unique_ptr_destruction_order.pass.cpp:30:34: note: replace 'default' with 'delete'
  Base& operator=(const Base&) = default;
                                 ^~~~~~~
                                 delete
1 error generated.

If I add =delete

/home/libcxx-builder/.buildkite-agent/builds/ab7607b38669-1/llvm-project/libcxx-ci/libcxx/test/libcxx/memory/trivial_abi/unique_ptr_destruction_order.pass.cpp:34:8: error: call to deleted constructor of 'Base'
struct A : Base {
       ^
/home/libcxx-builder/.buildkite-agent/builds/ab7607b38669-1/llvm-project/libcxx-ci/libcxx/test/libcxx/memory/trivial_abi/unique_ptr_destruction_order.pass.cpp:55:8: note: in implicit copy constructor for 'A' first required here
  func(A(shared_buf, &cur_idx), std::unique_ptr<B>(new B(shared_buf, &cur_idx)),
       ^
/home/libcxx-builder/.buildkite-agent/builds/ab7607b38669-1/llvm-project/libcxx-ci/libcxx/test/libcxx/memory/trivial_abi/unique_ptr_destruction_order.pass.cpp:29:3: note: 'Base' has been explicitly marked deleted here
  Base(const Base&) = delete;
  ^
/home/libcxx-builder/.buildkite-agent/builds/ab7607b38669-1/llvm-project/libcxx-ci/libcxx/test/libcxx/memory/trivial_abi/unique_ptr_destruction_order.pass.cpp:42:8: error: call to deleted constructor of 'Base'
struct C : Base {
       ^
/home/libcxx-builder/.buildkite-agent/builds/ab7607b38669-1/llvm-project/libcxx-ci/libcxx/test/libcxx/memory/trivial_abi/unique_ptr_destruction_order.pass.cpp:56:8: note: in implicit copy constructor for 'C' first required here
       C(shared_buf, &cur_idx));
       ^
/home/libcxx-builder/.buildkite-agent/builds/ab7607b38669-1/llvm-project/libcxx-ci/libcxx/test/libcxx/memory/trivial_abi/unique_ptr_destruction_order.pass.cpp:29:3: note: 'Base' has been explicitly marked deleted here
  Base(const Base&) = delete;
  ^
2 errors generated.

30

one more thing.
On Windows I can write whatever in that test.
It passes without my changes, it passes with =default, it passes with =delete

I run the test this way:

C:\Dev\STL\llvm-project\build>python bin\llvm-lit.py ..\libcxx\test\libcxx\memory\trivial_abi\unique_ptr_destruction_order.pass.cpp -v
llvm-lit.py: C:\Dev\STL\llvm-project\libcxx\utils\libcxx\test\config.py:19: note: (llvm-libc++-shared-clangcl.cfg.in) Using %{cxx} substitution: ''C:/Program Files/Microsoft Visual Studio/2022/Preview/VC/Tools/Llvm/x64/bin/clang-cl.exe''
llvm-lit.py: C:\Dev\STL\llvm-project\libcxx\utils\libcxx\test\config.py:19: note: (llvm-libc++-shared-clangcl.cfg.in) Using %{flags} substitution: '--driver-mode=g++ --target=x86_64-pc-windows-msvc'
llvm-lit.py: C:\Dev\STL\llvm-project\libcxx\utils\libcxx\test\config.py:19: note: (llvm-libc++-shared-clangcl.cfg.in) Using %{compile_flags} substitution: '-nostdinc++ -I %{include} -I %{target-include} -I %{libcxx}/test/support -D_CRT_SECURE_NO_WARNINGS -D_CRT_NONSTDC_NO_WARNINGS -D_CRT_STDIO_ISO_WIDE_SPECIFIERS -DNOMINMAX -std=c++2b -Werror -Wall -Wctad-maybe-unsupported -Wextra -Wshadow -Wundef -Wno-unused-command-line-argument -Wno-attributes -Wno-pessimizing-move -Wno-c++11-extensions -Wno-noexcept-type -Wno-atomic-alignment -Wno-user-defined-literals -Wno-tautological-compare -Wsign-compare -Wunused-variable -Wunused-parameter -Wunreachable-code -Wno-unused-local-typedef -Wdeprecated-copy -Wdeprecated-copy-dtor -D_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER -D_LIBCPP_ENABLE_EXPERIMENTAL -D_LIBCPP_DISABLE_AVAILABILITY -Werror=thread-safety -Wuser-defined-warnings -DTEST_WINDOWS_DLL'
llvm-lit.py: C:\Dev\STL\llvm-project\libcxx\utils\libcxx\test\config.py:19: note: (llvm-libc++-shared-clangcl.cfg.in) Using %{link_flags} substitution: '-llibc++experimental -nostdlib -L %{lib} -lc++ -lmsvcrt -lmsvcprt -loldnames'
llvm-lit.py: C:\Dev\STL\llvm-project\libcxx\utils\libcxx\test\config.py:19: note: (llvm-libc++-shared-clangcl.cfg.in) Using %{exec} substitution: '%{executor} --execdir %T --env PATH=%{lib} -- '
llvm-lit.py: C:\Dev\STL\llvm-project\libcxx\utils\libcxx\test\config.py:19: note: (llvm-libc++-shared-clangcl.cfg.in) All available features: no-filesystem, buildhost=win32, clang-15.0, target=x86_64-pc-windows-msvc, stdlib=libc++, stdlib=llvm-libc++, locale.fr_CA.ISO8859-1, -faligned-allocation, locale.zh_CN.UTF-8, locale.fr_FR.UTF-8, buildhost=windows, clang-15, clang-15.0.1, -fsized-deallocation, locale.en_US.UTF-8, clang, executor-has-no-bash, libcpp-abi-version=1, msvc-19.36, win32-broken-utf8-wchar-ctype, diagnose-if-support, windows, fdelayed-template-parsing, c++2b, thread-safety, objective-c++, c++experimental, windows-dll, long_tests, msvc-19, has-fblocks, locale.ja_JP.UTF-8, verify-support, locale.ru_RU.UTF-8, has-fconstexpr-steps, msvc
-- Testing: 1 tests, 1 workers --
PASS: llvm-libc++-shared-clangcl.cfg.in :: libcxx/memory/trivial_abi/unique_ptr_destruction_order.pass.cpp (1 of 1)

Testing Time: 5.96s
  Passed: 1

libcxx/test/support/counting_predicates.h

24

I saw the warnings but I will invistigate that.

[fsb4000]

libcxx/test/support/counting_predicates.h

24

Yes, they called.

C:/Dev/STL/llvm-project/libcxx/test/support\counting_predicates.h:25:5: error: definition of implicit copy constructor for 'unary_counting_predicate<bool (*)(int), int>' is deprecated because it has a user-provided destructor [-Werror,-Wdeprecated-copy-with-user-provided-dtor]
    ~unary_counting_predicate() {}
    ^
C:\Dev\STL\llvm-project\libcxx\test\std\utilities\function.objects\refwrap\refwrap.helpers\ref_2.pass.cpp:60:22: note: in implicit copy constructor for 'unary_counting_predicate<bool (*)(int), int>' first required here
    assert(call_pred(cp));
                     ^

https://github.com/llvm/llvm-project/blob/bbaa79470423e63d075abef869ab4d5a203c51d3/libcxx/test/std/utilities/function.objects/refwrap/refwrap.helpers/ref_2.pass.cpp#L25

https://github.com/llvm/llvm-project/blob/bbaa79470423e63d075abef869ab4d5a203c51d3/libcxx/test/std/utilities/function.objects/refwrap/refwrap.helpers/ref_2.pass.cpp#L60

[fsb4000]

libcxx/test/libcxx/memory/trivial_abi/unique_ptr_destruction_order.pass.cpp

30

I can add

Base(const Base&) = default;
Base& operator=(const Base&) = delete;

It seems it works: https://gcc.godbolt.org/z/6nEGfffEj

[fsb4000]

restore const char in test\libcxx\memory\trivial_abi\unique_ptr_destruction_order.pass.cpp

[fsb4000]

libcxx/test/support/counting_predicates.h

24

About CDeleter:

In file included from C:\Dev\STL\llvm-project\libcxx\test\std\utilities\smartptr\unique.ptr\unique.ptr.class\unique.ptr.asgn\move.pass.cpp:28:
C:/Dev/STL/llvm-project/libcxx/test/support/deleter_types.h:169:24: error: definition of implicit copy assignment operator for 'CDeleter<A>' is deprecated because it has a user-provided destructor [-Werror,-Wdeprecated-copy-with-user-provided-dtor]
  TEST_CONSTEXPR_CXX23 ~CDeleter() {
                       ^
C:/Dev/STL/llvm-project/build/include/c++/v1\__memory/unique_ptr.h:232:21: note: in implicit copy assignment operator for 'CDeleter<A>' first required here
    __ptr_.second() = _VSTD::forward<deleter_type>(__u.get_deleter());
                    ^
C:\Dev\STL\llvm-project\libcxx\test\std\utilities\smartptr\unique.ptr\unique.ptr.class\unique.ptr.asgn\move.pass.cpp:76:8: note: in instantiation of member function 'std::unique_ptr<A, CDeleter<A> &>::operator=' requested here
    s2 = std::move(s1);
       ^
C:\Dev\STL\llvm-project\libcxx\test\std\utilities\smartptr\unique.ptr\unique.ptr.class\unique.ptr.asgn\move.pass.cpp:133:5: note: in instantiation of function template specialization 'test_basic<false>' requested here
    test_basic</*IsArray*/ false>();
    ^
In file included from C:\Dev\STL\llvm-project\libcxx\test\std\utilities\smartptr\unique.ptr\unique.ptr.class\unique.ptr.asgn\move.pass.cpp:28:
C:/Dev/STL/llvm-project/libcxx/test/support/deleter_types.h:194:24: error: definition of implicit copy assignment operator for 'CDeleter<A[]>' is deprecated because it has a user-provided destructor [-Werror,-Wdeprecated-copy-with-user-provided-dtor]
  TEST_CONSTEXPR_CXX23 ~CDeleter() {
                       ^
C:/Dev/STL/llvm-project/build/include/c++/v1\__memory/unique_ptr.h:434:21: note: in implicit copy assignment operator for 'CDeleter<A[]>' first required here
    __ptr_.second() = _VSTD::forward<deleter_type>(__u.get_deleter());
                    ^
C:\Dev\STL\llvm-project\libcxx\test\std\utilities\smartptr\unique.ptr\unique.ptr.class\unique.ptr.asgn\move.pass.cpp:76:8: note: in instantiation of member function 'std::unique_ptr<A[], CDeleter<A[]> &>::operator=' requested here
    s2 = std::move(s1);
       ^
C:\Dev\STL\llvm-project\libcxx\test\std\utilities\smartptr\unique.ptr\unique.ptr.class\unique.ptr.asgn\move.pass.cpp:137:5: note: in instantiation of function template specialization 'test_basic<true>' requested here
    test_basic</*IsArray*/ true>();
    ^
2 errors generated.

error: command failed with exit status: 1

[philnik]

libcxx/test/support/nasty_containers.h

46–48

Maybe just remove the destructor instead? If it breaks a test ignore the suggestion.

[ldionne]

[Github PR transition cleanup]

Commandeering to pick up.

[ldionne]

Rebase.

[ldionne]

Based on the discussion, I don't think any of the comments are blocking. I'll ship this if CI is green, everything in this patch seems reasonable to me and it fixes a real issue for MSVC's STL usage of the test suite.

[ldionne]

Clang-format.

[ldionne]

More missing format.

[ldionne]

Rebase and fix C++11 test.

libcxx/include/__exception/exception.h

 
 #else  // !defined(_LIBCPP_ABI_VCRUNTIME)
 // On all other platforms, we define our own std::exception and std::bad_exception types
 // regardless of whether exceptions are turned on as a language feature.
 
 class _LIBCPP_EXPORTED_FROM_ABI exception {
 public:
   _LIBCPP_HIDE_FROM_ABI exception() _NOEXCEPT {}
-  _LIBCPP_HIDE_FROM_ABI exception(const exception&) _NOEXCEPT = default;
+  _LIBCPP_HIDE_FROM_ABI exception(const exception&) _NOEXCEPT            = default;
+  _LIBCPP_HIDE_FROM_ABI exception& operator=(const exception&) _NOEXCEPT = default;
 
   virtual ~exception() _NOEXCEPT;
   virtual const char* what() const _NOEXCEPT;
 };
 
 class _LIBCPP_EXPORTED_FROM_ABI bad_exception : public exception {
 public:
   _LIBCPP_HIDE_FROM_ABI bad_exception() _NOEXCEPT {}
+  _LIBCPP_HIDE_FROM_ABI bad_exception(const bad_exception&) _NOEXCEPT            = default;
+  _LIBCPP_HIDE_FROM_ABI bad_exception& operator=(const bad_exception&) _NOEXCEPT = default;
   ~bad_exception() _NOEXCEPT override;
   const char* what() const _NOEXCEPT override;
 };
 #endif // !_LIBCPP_ABI_VCRUNTIME
 
 } // namespace std
 
 #endif // _LIBCPP___EXCEPTION_EXCEPTION_H

libcxx/include/__exception/nested_exception.h

 
 namespace std { // purposefully not using versioning namespace
 
 class _LIBCPP_EXPORTED_FROM_ABI nested_exception {
   exception_ptr __ptr_;
 
 public:
   nested_exception() _NOEXCEPT;
-  //     nested_exception(const nested_exception&) noexcept = default;
-  //     nested_exception& operator=(const nested_exception&) noexcept = default;
+  _LIBCPP_HIDE_FROM_ABI nested_exception(const nested_exception&) _NOEXCEPT            = default;
+  _LIBCPP_HIDE_FROM_ABI nested_exception& operator=(const nested_exception&) _NOEXCEPT = default;
   virtual ~nested_exception() _NOEXCEPT;
 
   // access functions
   _LIBCPP_NORETURN void rethrow_nested() const;
   _LIBCPP_HIDE_FROM_ABI exception_ptr nested_ptr() const _NOEXCEPT { return __ptr_; }
 };
 
 template <class _Tp>

libcxx/include/__expected/expected.h

private:
   // use named union because [[no_unique_address]] cannot be applied to an unnamed union,
   // also guaranteed elision into a potentially-overlapping subobject is unsettled (and
   // it's not clear that it's implementable, given that the function is allowed to clobber
   // the tail padding) - see https://github.com/itanium-cxx-abi/cxx-abi/issues/107.
   template <class _ValueType, class _ErrorType>
     requires(is_trivially_move_constructible_v<_ValueType> && is_trivially_move_constructible_v<_ErrorType>)
   union __union_t<_ValueType, _ErrorType> {
     _LIBCPP_HIDE_FROM_ABI constexpr __union_t() : __empty_() {}
+    _LIBCPP_HIDE_FROM_ABI constexpr __union_t(const __union_t&) = default;
+    _LIBCPP_HIDE_FROM_ABI constexpr __union_t& operator=(const __union_t&) = default;
 
     template <class _Func, class... _Args>
     _LIBCPP_HIDE_FROM_ABI constexpr explicit __union_t(
         std::__expected_construct_in_place_from_invoke_tag, _Func&& __f, _Args&&... __args)
         : __val_(std::invoke(std::forward<_Func>(__f), std::forward<_Args>(__args)...)) {}
 
     template <class _Func, class... _Args>
     _LIBCPP_HIDE_FROM_ABI constexpr explicit __union_t(
private:
   // use named union because [[no_unique_address]] cannot be applied to an unnamed union,
   // also guaranteed elision into a potentially-overlapping subobject is unsettled (and
   // it's not clear that it's implementable, given that the function is allowed to clobber
   // the tail padding) - see https://github.com/itanium-cxx-abi/cxx-abi/issues/107.
   template <class _ErrorType>
     requires is_trivially_move_constructible_v<_ErrorType>
   union __union_t<_ErrorType> {
     _LIBCPP_HIDE_FROM_ABI constexpr __union_t() : __empty_() {}
+    _LIBCPP_HIDE_FROM_ABI constexpr __union_t(const __union_t&) = default;
+    _LIBCPP_HIDE_FROM_ABI constexpr __union_t& operator=(const __union_t&) = default;
 
     template <class _Func, class... _Args>
     _LIBCPP_HIDE_FROM_ABI constexpr explicit __union_t(
         __expected_construct_unexpected_from_invoke_tag, _Func&& __f, _Args&&... __args)
         : __unex_(std::invoke(std::forward<_Func>(__f), std::forward<_Args>(__args)...)) {}
 
     _LIBCPP_HIDE_FROM_ABI constexpr ~__union_t()
       requires(is_trivially_destructible_v<_ErrorType>)

libcxx/include/__format/format_error.h

 _LIBCPP_DIAGNOSTIC_PUSH
 _LIBCPP_CLANG_DIAGNOSTIC_IGNORED("-Wweak-vtables")
 class _LIBCPP_EXPORTED_FROM_ABI format_error : public runtime_error {
 public:
   _LIBCPP_HIDE_FROM_ABI explicit format_error(const string& __s)
       : runtime_error(__s) {}
   _LIBCPP_HIDE_FROM_ABI explicit format_error(const char* __s)
       : runtime_error(__s) {}
+  _LIBCPP_HIDE_FROM_ABI format_error(const format_error&) = default;
+  _LIBCPP_HIDE_FROM_ABI format_error& operator=(const format_error&) = default;
   _LIBCPP_HIDE_FROM_ABI_VIRTUAL
   ~format_error() noexcept override = default;
 };
 _LIBCPP_DIAGNOSTIC_POP
 
 _LIBCPP_NORETURN inline _LIBCPP_HIDE_FROM_ABI void
 __throw_format_error(const char* __s) {
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS

libcxx/include/__functional/function.h

 // bad_function_call
 
 _LIBCPP_DIAGNOSTIC_PUSH
 _LIBCPP_CLANG_DIAGNOSTIC_IGNORED("-Wweak-vtables")
 class _LIBCPP_EXPORTED_FROM_ABI bad_function_call
     : public exception
 {
 public:
+    _LIBCPP_HIDE_FROM_ABI bad_function_call() _NOEXCEPT = default;
+    _LIBCPP_HIDE_FROM_ABI bad_function_call(const bad_function_call&) _NOEXCEPT = default;
+    _LIBCPP_HIDE_FROM_ABI bad_function_call& operator=(const bad_function_call&) _NOEXCEPT = default;
 // Note that when a key function is not used, every translation unit that uses
 // bad_function_call will end up containing a weak definition of the vtable and
 // typeinfo.
 #ifdef _LIBCPP_ABI_BAD_FUNCTION_CALL_KEY_FUNCTION
     ~bad_function_call() _NOEXCEPT override;
 #else
     _LIBCPP_HIDE_FROM_ABI_VIRTUAL ~bad_function_call() _NOEXCEPT override {}
 #endif

libcxx/include/__memory/shared_ptr.h

 }
 
 class _LIBCPP_EXPORTED_FROM_ABI bad_weak_ptr
     : public std::exception
 {
 public:
     _LIBCPP_HIDE_FROM_ABI bad_weak_ptr() _NOEXCEPT = default;
     _LIBCPP_HIDE_FROM_ABI bad_weak_ptr(const bad_weak_ptr&) _NOEXCEPT = default;
+    _LIBCPP_HIDE_FROM_ABI bad_weak_ptr& operator=(const bad_weak_ptr&) _NOEXCEPT = default;
     ~bad_weak_ptr() _NOEXCEPT override;
     const char* what() const  _NOEXCEPT override;
 };
 
 _LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
 void __throw_bad_weak_ptr()
 {
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS

libcxx/include/new

 struct _LIBCPP_EXPORTED_FROM_ABI nothrow_t { explicit nothrow_t() = default; };
 extern _LIBCPP_EXPORTED_FROM_ABI const nothrow_t nothrow;
 
 class _LIBCPP_EXPORTED_FROM_ABI bad_alloc
     : public exception
 {
 public:
     bad_alloc() _NOEXCEPT;
+    _LIBCPP_HIDE_FROM_ABI bad_alloc(const bad_alloc&) _NOEXCEPT = default;
+    _LIBCPP_HIDE_FROM_ABI bad_alloc& operator=(const bad_alloc&) _NOEXCEPT = default;
     ~bad_alloc() _NOEXCEPT override;
     const char* what() const _NOEXCEPT override;
 };
 
 class _LIBCPP_EXPORTED_FROM_ABI bad_array_new_length
     : public bad_alloc
 {
 public:
     bad_array_new_length() _NOEXCEPT;
+    _LIBCPP_HIDE_FROM_ABI bad_array_new_length(const bad_array_new_length&) _NOEXCEPT = default;
+    _LIBCPP_HIDE_FROM_ABI bad_array_new_length& operator=(const bad_array_new_length&) _NOEXCEPT = default;
     ~bad_array_new_length() _NOEXCEPT override;
     const char* what() const _NOEXCEPT override;
 };
 
 typedef void (*new_handler)();
 _LIBCPP_EXPORTED_FROM_ABI new_handler set_new_handler(new_handler) _NOEXCEPT;
 _LIBCPP_EXPORTED_FROM_ABI new_handler get_new_handler() _NOEXCEPT;
 

libcxx/include/optional

 
 namespace std  // purposefully not using versioning namespace
 {
 
 class _LIBCPP_EXPORTED_FROM_ABI _LIBCPP_AVAILABILITY_BAD_OPTIONAL_ACCESS bad_optional_access
     : public exception
 {
 public:
+    _LIBCPP_HIDE_FROM_ABI bad_optional_access() _NOEXCEPT = default;
+    _LIBCPP_HIDE_FROM_ABI bad_optional_access(const bad_optional_access&) _NOEXCEPT = default;
+    _LIBCPP_HIDE_FROM_ABI bad_optional_access& operator=(const bad_optional_access&) _NOEXCEPT = default;
     // Get the key function ~bad_optional_access() into the dylib
     ~bad_optional_access() _NOEXCEPT override;
     const char* what() const _NOEXCEPT override;
 };
 
 } // namespace std
 
 #if _LIBCPP_STD_VER >= 17

libcxx/include/stdexcept

class _LIBCPP_EXPORTED_FROM_ABI domain_error
     : public logic_error
 {
 public:
     _LIBCPP_INLINE_VISIBILITY explicit domain_error(const string& __s) : logic_error(__s) {}
     _LIBCPP_INLINE_VISIBILITY explicit domain_error(const char* __s)   : logic_error(__s) {}
 
 #ifndef _LIBCPP_ABI_VCRUNTIME
     _LIBCPP_HIDE_FROM_ABI domain_error(const domain_error&) _NOEXCEPT = default;
+    _LIBCPP_HIDE_FROM_ABI domain_error& operator=(const domain_error&) _NOEXCEPT = default;
     ~domain_error() _NOEXCEPT override;
 #endif
 };
 
 class _LIBCPP_EXPORTED_FROM_ABI invalid_argument
     : public logic_error
 {
 public:
     _LIBCPP_INLINE_VISIBILITY explicit invalid_argument(const string& __s) : logic_error(__s) {}
     _LIBCPP_INLINE_VISIBILITY explicit invalid_argument(const char* __s)   : logic_error(__s) {}
 
 #ifndef _LIBCPP_ABI_VCRUNTIME
     _LIBCPP_HIDE_FROM_ABI invalid_argument(const invalid_argument&) _NOEXCEPT = default;
+    _LIBCPP_HIDE_FROM_ABI invalid_argument& operator=(const invalid_argument&) _NOEXCEPT = default;
     ~invalid_argument() _NOEXCEPT override;
 #endif
 };
 
 class _LIBCPP_EXPORTED_FROM_ABI length_error
     : public logic_error
 {
 public:
     _LIBCPP_INLINE_VISIBILITY explicit length_error(const string& __s) : logic_error(__s) {}
     _LIBCPP_INLINE_VISIBILITY explicit length_error(const char* __s)   : logic_error(__s) {}
 #ifndef _LIBCPP_ABI_VCRUNTIME
     _LIBCPP_HIDE_FROM_ABI length_error(const length_error&) _NOEXCEPT = default;
+    _LIBCPP_HIDE_FROM_ABI length_error& operator=(const length_error&) _NOEXCEPT = default;
     ~length_error() _NOEXCEPT override;
 #endif
 };
 
 class _LIBCPP_EXPORTED_FROM_ABI out_of_range
     : public logic_error
 {
 public:
     _LIBCPP_INLINE_VISIBILITY explicit out_of_range(const string& __s) : logic_error(__s) {}
     _LIBCPP_INLINE_VISIBILITY explicit out_of_range(const char* __s)   : logic_error(__s) {}
 
 #ifndef _LIBCPP_ABI_VCRUNTIME
     _LIBCPP_HIDE_FROM_ABI out_of_range(const out_of_range&) _NOEXCEPT = default;
+    _LIBCPP_HIDE_FROM_ABI out_of_range& operator=(const out_of_range&) _NOEXCEPT = default;
     ~out_of_range() _NOEXCEPT override;
 #endif
 };
 
 class _LIBCPP_EXPORTED_FROM_ABI range_error
     : public runtime_error
 {
 public:
     _LIBCPP_INLINE_VISIBILITY explicit range_error(const string& __s) : runtime_error(__s) {}
     _LIBCPP_INLINE_VISIBILITY explicit range_error(const char* __s)   : runtime_error(__s) {}
 
 #ifndef _LIBCPP_ABI_VCRUNTIME
     _LIBCPP_HIDE_FROM_ABI range_error(const range_error&) _NOEXCEPT = default;
+    _LIBCPP_HIDE_FROM_ABI range_error& operator=(const range_error&) _NOEXCEPT = default;
     ~range_error() _NOEXCEPT override;
 #endif
 };
 
 class _LIBCPP_EXPORTED_FROM_ABI overflow_error
     : public runtime_error
 {
 public:
     _LIBCPP_INLINE_VISIBILITY explicit overflow_error(const string& __s) : runtime_error(__s) {}
     _LIBCPP_INLINE_VISIBILITY explicit overflow_error(const char* __s)   : runtime_error(__s) {}
 
 #ifndef _LIBCPP_ABI_VCRUNTIME
     _LIBCPP_HIDE_FROM_ABI overflow_error(const overflow_error&) _NOEXCEPT = default;
+    _LIBCPP_HIDE_FROM_ABI overflow_error& operator=(const overflow_error&) _NOEXCEPT = default;
     ~overflow_error() _NOEXCEPT override;
 #endif
 };
 
 class _LIBCPP_EXPORTED_FROM_ABI underflow_error
     : public runtime_error
 {
 public:
     _LIBCPP_INLINE_VISIBILITY explicit underflow_error(const string& __s) : runtime_error(__s) {}
     _LIBCPP_INLINE_VISIBILITY explicit underflow_error(const char* __s)   : runtime_error(__s) {}
 
 #ifndef _LIBCPP_ABI_VCRUNTIME
     _LIBCPP_HIDE_FROM_ABI underflow_error(const underflow_error&) _NOEXCEPT = default;
+    _LIBCPP_HIDE_FROM_ABI underflow_error& operator=(const underflow_error&) _NOEXCEPT = default;
     ~underflow_error() _NOEXCEPT override;
 #endif
 };
 
 } // namespace std
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 

libcxx/include/typeinfo

 #endif // defined(_LIBCPP_ABI_MICROSOFT)
 
 class _LIBCPP_EXPORTED_FROM_ABI bad_cast
     : public exception
 {
  public:
   bad_cast() _NOEXCEPT;
   _LIBCPP_HIDE_FROM_ABI bad_cast(const bad_cast&) _NOEXCEPT = default;
+  _LIBCPP_HIDE_FROM_ABI bad_cast& operator=(const bad_cast&) _NOEXCEPT = default;
   ~bad_cast() _NOEXCEPT override;
   const char* what() const _NOEXCEPT override;
 };
 
 class _LIBCPP_EXPORTED_FROM_ABI bad_typeid
     : public exception
 {
  public:
   bad_typeid() _NOEXCEPT;
+  _LIBCPP_HIDE_FROM_ABI bad_typeid(const bad_typeid&) _NOEXCEPT = default;
+  _LIBCPP_HIDE_FROM_ABI bad_typeid& operator=(const bad_typeid&) _NOEXCEPT = default;
   ~bad_typeid() _NOEXCEPT override;
   const char* what() const _NOEXCEPT override;
 };
 
 } // namespace std
 
 #endif // defined(_LIBCPP_ABI_VCRUNTIME)
 

libcxx/test/libcxx/iterators/predef.iterators/__unconstrained_reverse_iterator/reverse.iter.elem/arrow.pass.cpp

 
 #include "test_macros.h"
 
 class A
 {
     int data_;
 public:
     A() : data_(1) {}
+    A(const A&) = default;
+    A& operator=(const A&) = default;
     ~A() {data_ = -1;}
 
     int get() const {return data_;}
 
     friend bool operator==(const A& x, const A& y)
         {return x.data_ == y.data_;}
 };
 
 template <class It>
 void
 test(It i, typename std::iterator_traits<It>::value_type x)
 {
     std::__unconstrained_reverse_iterator<It> r(i);
     assert(r->get() == x.get());
 }
 
 class B
 {
     int data_;
 public:
     B(int d=1) : data_(d) {}
+    B(const B&) = default;
+    B& operator=(const B&) = default;
     ~B() {data_ = -1;}
 
     int get() const {return data_;}
 
     friend bool operator==(const B& x, const B& y)
         {return x.data_ == y.data_;}
     const B *operator&() const { return nullptr; }
     B       *operator&()       { return nullptr; }

libcxx/test/libcxx/iterators/predef.iterators/__unconstrained_reverse_iterator/reverse.iter.elem/dereference.pass.cpp

 
 #include "test_macros.h"
 
 class A
 {
     int data_;
 public:
     A() : data_(1) {}
+    A(const A&) = default;
+    A& operator=(const A&) = default;
     ~A() {data_ = -1;}
 
     friend bool operator==(const A& x, const A& y)
         {return x.data_ == y.data_;}
 };
 
 template <class It>
 void

libcxx/test/libcxx/memory/trivial_abi/unique_ptr_array.pass.cpp

 #include <cassert>
 
 __attribute__((noinline)) void call_something() { asm volatile(""); }
 
 struct Node {
   int* shared_val;
 
   explicit Node(int* ptr) : shared_val(ptr) {}
+  Node(const Node&) = default;
+  Node& operator=(const Node&) = default;
   ~Node() { ++(*shared_val); }
 };
 
 __attribute__((noinline)) bool get_val(std::unique_ptr<Node[]> /*unused*/) {
   call_something();
   return true;
 }
 

libcxx/test/libcxx/memory/trivial_abi/unique_ptr_destruction_order.pass.cpp

 
 struct Base {
   char* shared_buff;
   int* cur_idx;
   const char id;
 
   explicit Base(char* buf, int* idx, char ch)
       : shared_buff(buf), cur_idx(idx), id(ch) {}
+  Base(const Base& other) = default;
+  Base& operator=(const Base&) = delete;
   ~Base() { shared_buff[(*cur_idx)++] = id; }
 };
 
 struct A : Base {
   explicit A(char* buf, int* idx) : Base(buf, idx, 'A') {}
 };
 
 struct B : Base {

libcxx/test/libcxx/memory/trivial_abi/unique_ptr_ret.pass.cpp

 
 #include <memory>
 #include <cassert>
 
 __attribute__((noinline)) void call_something() { asm volatile(""); }
 
 struct Node {
   explicit Node() {}
+  Node(const Node&) = default;
+  Node& operator=(const Node&) = default;
   ~Node() {}
 };
 
 __attribute__((noinline)) std::unique_ptr<Node> make_val(void** local_addr) {
   call_something();
 
   auto ret = std::unique_ptr<Node>(new Node);
 

libcxx/test/libcxx/memory/trivial_abi/weak_ptr_ret.pass.cpp

 
 #include <memory>
 #include <cassert>
 
 __attribute__((noinline)) void call_something() { asm volatile(""); }
 
 struct Node {
   explicit Node() {}
+  Node(const Node&) = default;
+  Node& operator=(const Node&) = default;
   ~Node() {}
 };
 
 __attribute__((noinline)) std::weak_ptr<Node>
 make_val(std::shared_ptr<Node>& sptr, void** local_addr) {
   call_something();
 
   std::weak_ptr<Node> ret;

libcxx/test/libcxx/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/move_reentrant.pass.cpp

 
 #include "test_macros.h"
 
 struct A
 {
   static std::function<void()> global;
   static bool cancel;
 
+  A() = default;
+  A(const A&) = default;
+  A& operator=(const A&) = default;
   ~A() {
     DoNotOptimize(cancel);
     if (cancel)
       global = std::function<void()>(nullptr);
   }
   void operator()() {}
 };
 

libcxx/test/libcxx/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/nullptr_t_assign_reentrant.pass.cpp

 
 #include "test_macros.h"
 
 struct A
 {
   static std::function<void()> global;
   static bool cancel;
 
+  A() = default;
+  A(const A&) = default;
+  A& operator=(const A&) = default;
   ~A() {
     DoNotOptimize(cancel);
     if (cancel)
       global = nullptr;
   }
   void operator()() {}
 };
 

libcxx/test/std/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/back.insert.iter.op=/lv_value.pass.cpp

test(C c)
     return true;
 }
 
 class Copyable
 {
     int data_;
 public:
     Copyable() : data_(0) {}
+    Copyable(const Copyable&) = default;
+    Copyable& operator=(const Copyable&) = default;
     ~Copyable() {data_ = -1;}
 
     friend bool operator==(const Copyable& x, const Copyable& y)
         {return x.data_ == y.data_;}
 };
 
 int main(int, char**)
 {
     test(std::vector<Copyable>());
 #if TEST_STD_VER >= 20
     test(ConstexprFixedCapacityDeque<int, 10>());
     static_assert(test(ConstexprFixedCapacityDeque<int, 10>()));
 #endif
     return 0;
 }

libcxx/test/std/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/front.insert.iter.op=/lv_value.pass.cpp

test(C c)
     return true;
 }
 
 class Copyable
 {
     int data_;
 public:
     Copyable() : data_(0) {}
+    Copyable(const Copyable&) = default;
+    Copyable& operator=(const Copyable&) = default;
     ~Copyable() {data_ = -1;}
 
     friend bool operator==(const Copyable& x, const Copyable& y)
         {return x.data_ == y.data_;}
 };
 
 int main(int, char**)
 {
     test(std::list<Copyable>());
     test(nasty_list<Copyable>());
 #if TEST_STD_VER >= 20
     test(ConstexprFixedCapacityDeque<int, 10>());
     static_assert(test(ConstexprFixedCapacityDeque<int, 10>()));
 #endif
     return 0;
 }

libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.star/op_star.pass.cpp

 #include "test_iterators.h"
 #include "test_macros.h"
 
 class A
 {
     int data_;
 public:
     A() : data_(1) {}
+    A(const A&) = default;
+    A& operator=(const A&) = default;
     ~A() {data_ = -1;}
 
     friend bool operator==(const A& x, const A& y)
         {return x.data_ == y.data_;}
 };
 
 template <class It>
 void

libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.elem/arrow.pass.cpp

 
 #include "test_macros.h"
 
 class A
 {
     int data_;
 public:
     A() : data_(1) {}
+    A(const A&) = default;
+    A& operator=(const A&) = default;
     ~A() {data_ = -1;}
 
     int get() const {return data_;}
 
     friend bool operator==(const A& x, const A& y)
         {return x.data_ == y.data_;}
 };
 
 template <class It>
 void
 test(It i, typename std::iterator_traits<It>::value_type x)
 {
     std::reverse_iterator<It> r(i);
     assert(r->get() == x.get());
 }
 
 class B
 {
     int data_;
 public:
     B(int d=1) : data_(d) {}
+    B(const B&) = default;
+    B& operator=(const B&) = default;
     ~B() {data_ = -1;}
 
     int get() const {return data_;}
 
     friend bool operator==(const B& x, const B& y)
         {return x.data_ == y.data_;}
     const B *operator&() const { return nullptr; }
     B       *operator&()       { return nullptr; }

libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.elem/dereference.pass.cpp

 
 #include "test_macros.h"
 
 class A
 {
     int data_;
 public:
     A() : data_(1) {}
+    A(const A&) = default;
+    A& operator=(const A&) = default;
     ~A() {data_ = -1;}
 
     friend bool operator==(const A& x, const A& y)
         {return x.data_ == y.data_;}
 };
 
 template <class It>
 void

libcxx/test/std/language.support/support.coroutines/end.to.end/go.pass.cpp

struct goroutine
 
   static void schedule(std::coroutine_handle<>& rh)
   {
     assert(count < N);
     stack[count++] = rh;
     rh = nullptr;
   }
 
+  goroutine() = default;
+  goroutine(const goroutine&) = default;
+  goroutine& operator=(const goroutine&) = default;
   ~goroutine() {}
 
   static void run_one()
   {
     assert(count > 0);
     stack[--count]();
   }
 

libcxx/test/std/language.support/support.exception/except.nested/rethrow_if_nested.pass.cpp

 
 #include "test_macros.h"
 
 class A
 {
     int data_;
 public:
     explicit A(int data) : data_(data) {}
+    A(const A&) = default;
+    A& operator=(const A&) = default;
     virtual ~A() TEST_NOEXCEPT {}
 
     friend bool operator==(const A& x, const A& y) {return x.data_ == y.data_;}
 };
 
 class B
     : public std::nested_exception,
       public A

libcxx/test/std/ranges/range.adaptors/range.drop/dangling.cache.pass.cpp

struct ZeroOnDestroy : std::ranges::view_base {
   unsigned count = 0;
   int buff[8] = {1, 2, 3, 4, 5, 6, 7, 8};
 
   constexpr ForwardIter begin() { return ForwardIter(buff); }
   constexpr ForwardIter begin() const { return ForwardIter(); }
   constexpr ForwardIter end() { return ForwardIter(buff + 8); }
   constexpr ForwardIter end() const { return ForwardIter(); }
 
+  ZeroOnDestroy() = default;
+  ZeroOnDestroy(const ZeroOnDestroy&) = default;
+  ZeroOnDestroy& operator=(const ZeroOnDestroy&) = default;
   ~ZeroOnDestroy() {
     std::memset(buff, 0, sizeof(buff));
   }
 
   static auto dropFirstFour() {
     ZeroOnDestroy zod;
     std::ranges::drop_view dv(zod, 4);
     // Make sure we call begin here so the next call to begin will

libcxx/test/std/utilities/tuple/tuple.tuple/alloc_first.h

struct alloc_first
 
     alloc_first(std::allocator_arg_t, const A1<int>& a, const alloc_first& d)
         : data_(d.data_)
     {
         assert(a.id() == 5);
         allocator_constructed = true;
     }
 
+    alloc_first(const alloc_first&) = default;
+    alloc_first& operator=(const alloc_first&) = default;
     ~alloc_first() {data_ = -1;}
 
     friend bool operator==(const alloc_first& x, const alloc_first& y)
         {return x.data_ == y.data_;}
     friend bool operator< (const alloc_first& x, const alloc_first& y)
         {return x.data_ < y.data_;}
 };
 
 bool alloc_first::allocator_constructed = false;
 
 #endif // ALLOC_FIRST_H

libcxx/test/std/utilities/tuple/tuple.tuple/alloc_last.h

struct alloc_last
 
     alloc_last(const alloc_last& d, const A1<int>& a)
         : data_(d.data_)
     {
         assert(a.id() == 5);
         allocator_constructed = true;
     }
 
+    alloc_last(const alloc_last&) = default;
+    alloc_last& operator=(const alloc_last&) = default;
     ~alloc_last() {data_ = -1;}
 
     friend bool operator==(const alloc_last& x, const alloc_last& y)
         {return x.data_ == y.data_;}
     friend bool operator< (const alloc_last& x, const alloc_last& y)
         {return x.data_ < y.data_;}
 };
 
 bool alloc_last::allocator_constructed = false;
 
 #endif // ALLOC_LAST_H

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.assign/convert_move.pass.cpp

 #include <utility>
 #include <cassert>
 
 #include "test_macros.h"
 
 struct B {
     int id_;
     explicit B(int i = 0) : id_(i) {}
+    B(const B&) = default;
+    B& operator=(const B&) = default;
     virtual ~B() {}
 };
 
 struct D : B {
     explicit D(int i) : B(i) {}
 };
 
 struct E {

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

struct Implicit {
   Implicit(int x) : value(x) {}
 };
 
 struct B
 {
     int id_;
 
     explicit B(int i) : id_(i) {}
-
+    B(const B&) = default;
+    B& operator=(const B&) = default;
     virtual ~B() {}
 };
 
 struct D
     : B
 {
     explicit D(int i) : B(i) {}
 };

libcxx/test/support/counting_predicates.h

 
 template <typename Predicate, typename Arg>
 struct unary_counting_predicate {
 public:
     typedef Arg argument_type;
     typedef bool result_type;
 
     unary_counting_predicate(Predicate p) : p_(p), count_(0) {}
+    unary_counting_predicate(const unary_counting_predicate&) = default;
+    unary_counting_predicate& operator=(const unary_counting_predicate&) = default;
     ~unary_counting_predicate() {}
 
     bool operator () (const Arg &a) const { ++count_; return p_(a); }
     std::size_t count() const { return count_; }
     void reset() { count_ = 0; }
 
 private:
     Predicate p_;

libcxx/test/support/deleter_types.h

 
 template <class T>
 class CDeleter {
   int state_;
 
 public:
   TEST_CONSTEXPR_CXX23 CDeleter() : state_(0) {}
   TEST_CONSTEXPR_CXX23 explicit CDeleter(int s) : state_(s) {}
+  TEST_CONSTEXPR_CXX23 CDeleter(const CDeleter&) = default;
+  TEST_CONSTEXPR_CXX23 CDeleter& operator=(const CDeleter&) = default;
   TEST_CONSTEXPR_CXX23 ~CDeleter() {
     assert(state_ >= 0);
     state_ = -1;
   }
 
   template <class U>
   TEST_CONSTEXPR_CXX23 CDeleter(const CDeleter<U>& d) : state_(d.state()) {}
 
   TEST_CONSTEXPR_CXX23 int state() const { return state_; }
   TEST_CONSTEXPR_CXX23 void set_state(int i) { state_ = i; }
 
   TEST_CONSTEXPR_CXX23 void operator()(T* p) { delete p; }
 };
 
 template <class T>
 class CDeleter<T[]> {
   int state_;
 
 public:
   TEST_CONSTEXPR_CXX23 CDeleter() : state_(0) {}
   TEST_CONSTEXPR_CXX23 explicit CDeleter(int s) : state_(s) {}
   template <class U>
   TEST_CONSTEXPR_CXX23 CDeleter(const CDeleter<U>& d) : state_(d.state()) {}
-
+  TEST_CONSTEXPR_CXX23 CDeleter(const CDeleter&) = default;
+  TEST_CONSTEXPR_CXX23 CDeleter& operator=(const CDeleter&) = default;
   TEST_CONSTEXPR_CXX23 ~CDeleter() {
     assert(state_ >= 0);
     state_ = -1;
   }
 
   TEST_CONSTEXPR_CXX23 int state() const { return state_; }
   TEST_CONSTEXPR_CXX23 void set_state(int i) { state_ = i; }
 

libcxx/test/support/nasty_containers.h

public:
 
     nasty_vector() : v_() {}
     explicit nasty_vector(size_type n) : v_(n) {}
     nasty_vector(size_type n, const value_type& value) : v_(n, value) {}
     template <class InputIterator> nasty_vector(InputIterator first, InputIterator last) : v_(first, last) {}
 #if TEST_STD_VER >= 11
     nasty_vector(std::initializer_list<value_type> il) : v_(il) {}
 #endif
+    nasty_vector(const nasty_vector&) = default;
+    nasty_vector& operator=(const nasty_vector&) = default;
     ~nasty_vector() {}
 
     template <class InputIterator>
         void assign(InputIterator first, InputIterator last) { v_.assign(first, last); }
     void assign(size_type n, const value_type& u) { v_.assign(n, u); }
 #if TEST_STD_VER >= 11
     void assign(std::initializer_list<value_type> il)  { v_.assign(il); }
 #endif
 
public:
     nasty_list() : l_() {}
     explicit nasty_list(size_type n)  : l_(n) {}
     nasty_list(size_type n, const value_type& value)  : l_(n,value) {}
     template <class Iter>
         nasty_list(Iter first, Iter last)  : l_(first, last) {}
 #if TEST_STD_VER >= 11
     nasty_list(std::initializer_list<value_type> il) : l_(il) {}
 #endif
-
+    nasty_list(const nasty_list&) = default;
+    nasty_list& operator=(const nasty_list&) = default;
     ~nasty_list() {}
 
 #if TEST_STD_VER >= 11
     nasty_list& operator=(std::initializer_list<value_type> il) { l_ = il; return *this; }
 #endif
     template <class Iter>
         void assign(Iter first, Iter last) { l_.assign(first, last); }
     void assign(size_type n, const value_type& t) { l_.assign(n, t); }

libcxx/utils/libcxx/test/params.py

 # ===----------------------------------------------------------------------===##
 #
 # 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
 #
 # ===----------------------------------------------------------------------===##
 
 from libcxx.test.dsl import *
 from libcxx.test.features import _isMSVC
 import re
 
 _warningFlags = [
     "-Werror",
     "-Wall",
     "-Wctad-maybe-unsupported",
     "-Wextra",
     "-Wshadow",
     "-Wundef",
     "-Wunused-template",
     "-Wno-unused-command-line-argument",
     "-Wno-attributes",
     "-Wno-pessimizing-move",
     "-Wno-noexcept-type",
     "-Wno-aligned-allocation-unavailable",
     "-Wno-atomic-alignment",
     "-Wno-reserved-module-identifier",
+    '-Wdeprecated-copy',
+    '-Wdeprecated-copy-dtor',
     # GCC warns about places where we might want to add sized allocation/deallocation
     # functions, but we know better what we're doing/testing in the test suite.
     "-Wno-sized-deallocation",
     # Turn off warnings about user-defined literals with reserved suffixes. Those are
     # just noise since we are testing the Standard Library itself.
     "-Wno-literal-suffix",  # GCC
     "-Wno-user-defined-literals",  # Clang
     # GCC warns about this when TEST_IS_CONSTANT_EVALUATED is used on a non-constexpr

libcxxabi/test/exception_object_alignment.2.pass.cpp

 // course).
 //
 // There was a bug where Clang would emit a call to memset assuming a 16-byte
 // aligned exception even when back-deploying to older Darwin systems where
 // exceptions are 8-byte aligned, which caused a segfault on those systems.
 
 struct exception {
     exception() : x(0) { }
+    exception(const exception&) = default;
+    exception& operator=(const exception&) = default;
     virtual ~exception() { }
     int x;
 };
 
 struct foo : exception { };
 
 int main(int, char**) {
     try {
       throw foo();
     } catch (...) {
 
     }
     return 0;
 }