[libc++] Complete refactor of tests for operator new

[ldionne]

Summary

I stumbled upon the operator new and operator new[] tests while
investigating an issue with operator new when exceptions are disabled,
and I realized that our test coverage was incomplete. This patch refactors
all the operator new and operator new[] tests to add consistency and
better coverage for scenarios in which it should be possible to override
an operator indirectly by defining another one (for example new(size_t, nothrow)
should use new(size_t) if it has been provided).

This is intended to be a NFC setting up the terrain for some refactoring
work and bug fix in operator new.

[ldionne]

Nits.

[philnik]

libcxx/test/std/language.support/support.dynamic/new.delete/new.delete.array/new.size.pass.cpp

27

libcxx/test/std/language.support/support.dynamic/new.delete/new.delete.array/new.size.replace.indirect.pass.cpp

29

Are you allowed to override only operator new or operator delete? It yes, we might want to add a test for that.

libcxx/test/std/language.support/support.dynamic/new.delete/new.delete.array/new.size_align.replace.indirect.pass.cpp

37

Or is this required?

libcxx/test/std/language.support/support.dynamic/new.delete/new.delete.array/new.size_align.replace.pass.cpp

59

Do we ever try calling the align_val_t overload explicitly?

libcxx/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_size.verify.cpp

0

We have this as an extension now, so we might as well enable this test for libc++ in all language versions.

libcxx/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_size_align.verify.cpp

0

Is there a reason the [[nodiscard]] tests aren't merged?

[ldionne]

Fix C++03

[ldionne]

libcxx/test/std/language.support/support.dynamic/new.delete/new.delete.array/new.size.replace.indirect.pass.cpp

29

I don't think so, because the memory allocated with one has to be deallocated with the other. They need to use a mechanism that matches. For example, if your custom operator new uses malloc and the system-provided operator delete happens to use free, that's fine. But that might not be the case in general, the exact mechanism isn't specified.

libcxx/test/std/language.support/support.dynamic/new.delete/new.delete.array/new.size_align.replace.indirect.pass.cpp

37

This is required in C++03 for some tests, but I removed it for others. Same for TEST_NOEXCEPT on operator delete, I replaced it with noexcept when I could.

libcxx/test/std/language.support/support.dynamic/new.delete/new.delete.array/new.size_align.replace.pass.cpp

59

I added some tests to explicitly call operator new for all variants.

libcxx/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_size_align.verify.cpp

0

Thanks for the suggestion, I just didn't think of it but it's much better indeed.

[ldionne]

Address comments.

[philnik]

LGTM % possible test case and green CI.

libcxx/test/std/language.support/support.dynamic/new.delete/new.delete.array/new.size.replace.indirect.pass.cpp

29

Yes, but a user could define operator new, operator delete and operator new[]. There would still be a mismatch, but the user knows how new and delete allocate memory.

[ldionne]

Poke CI.

[ldionne]

Poke CI again.

[ldionne]

Add missing XFAILs.

@mstorsjo it would be awesome if you (or someone else with easy Windows access) could help with these new tests.

[ldionne]

XFAIL => UNSUPPORTED

libcxx/test/libcxx/language.support/support.dynamic/libcpp_deallocate.sh.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
 //
 //===----------------------------------------------------------------------===//
 
 // test libc++'s implementation of align_val_t, and the relevant new/delete
 // overloads in all dialects when -faligned-allocation is present.
 
 // Some dylibs do not contain the aligned allocation functions, so trying to force
 // using those with -faligned-allocation results in a link error.
 // XFAIL: availability-aligned_allocation-missing
 
-// Libcxx when built for z/OS doesn't contain the aligned allocation functions,
+// Libc++ when built for z/OS doesn't contain the aligned allocation functions,
 // nor does the dynamic library shipped with z/OS.
 // UNSUPPORTED: target={{.+}}-zos{{.*}}
 
 // XFAIL: sanitizer-new-delete && !hwasan
 
 // It fails with clang-14 or clang-16, but passes with clang-15.
 // UNSUPPORTED: ubsan
 

libcxx/test/libcxx/language.support/support.dynamic/new_faligned_allocation.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
 //
 //===----------------------------------------------------------------------===//
 
 // test libc++'s implementation of align_val_t, and the relevant new/delete
 // overloads in all dialects when -faligned-allocation is present.
 
 // Some dylibs do not contain the aligned allocation functions, so trying to force
 // using those with -faligned-allocation results in a link error.
 // XFAIL: availability-aligned_allocation-missing
 
-// Libcxx when built for z/OS doesn't contain the aligned allocation functions,
+// Libc++ when built for z/OS doesn't contain the aligned allocation functions,
 // nor does the dynamic library shipped with z/OS.
 // UNSUPPORTED: target={{.+}}-zos{{.*}}
 
 // REQUIRES: -faligned-allocation
 // ADDITIONAL_COMPILE_FLAGS: -faligned-allocation
 
 #include <cassert>
 #include <new>

libcxx/test/std/language.support/support.dynamic/align_val_t.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
 //
 //===----------------------------------------------------------------------===//
 
 // enum class align_val_t : size_t {}
 
 // UNSUPPORTED: c++03, c++11, c++14
 
-// Libcxx when built for z/OS doesn't contain the aligned allocation functions,
+// Libc++ when built for z/OS doesn't contain the aligned allocation functions,
 // nor does the dynamic library shipped with z/OS.
 // UNSUPPORTED: target={{.+}}-zos{{.*}}
 
 #include <new>
 #include <type_traits>
 
 #include "test_macros.h"
 

libcxx/test/std/language.support/support.dynamic/new.delete/new.delete.array/delete_align_val_t_replace.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
 //
 //===----------------------------------------------------------------------===//
 
 // test aligned operator delete replacement.
 
 // UNSUPPORTED: sanitizer-new-delete, c++03, c++11, c++14
 
-// Libcxx when built for z/OS doesn't contain the aligned allocation functions,
+// Libc++ when built for z/OS doesn't contain the aligned allocation functions,
 // nor does the dynamic library shipped with z/OS.
 // UNSUPPORTED: target={{.+}}-zos{{.*}}
 
 #include <new>
 #include <cstddef>
 #include <cstdlib>
 #include <cassert>
 

libcxx/test/std/language.support/support.dynamic/new.delete/new.delete.array/new.size.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
+//
+//===----------------------------------------------------------------------===//
+
+// void* operator new[](std::size_t);
+
+// asan and msan will not call the new handler.
+// UNSUPPORTED: sanitizer-new-delete
+
+#include <new>
+#include <cstddef>
+#include <cassert>
+#include <limits>
+
+#include "test_macros.h"
+#include "../types.h"
+
+int new_handler_called = 0;
+
+void my_new_handler() {
+    ++new_handler_called;
+    std::set_new_handler(nullptr);
+}
+
+int main(int, char**) {
+    // Test that we can call the function directly
+    {
+        void* x = operator new[](10);
+        assert(x != nullptr);
+        operator delete[](x);
+    }
+
+    // Test that the new handler is called if allocation fails
+    {
+#ifndef TEST_HAS_NO_EXCEPTIONS
+        std::set_new_handler(my_new_handler);
+        try {
+            void* x = operator new[] (std::numeric_limits<std::size_t>::max());
+            (void)x;
+            assert(false);
+        }
+        catch (std::bad_alloc const&) {
+            assert(new_handler_called == 1);
+        } catch (...) {
+            assert(false);
+        }
+#endif
+    }
+
+    // Test that a new expression constructs the right objects
+    // and a delete expression deletes them. The brace-init requires C++11.
+    {
+#if TEST_STD_VER >= 11
+        LifetimeInformation infos[3];
+        TrackLifetime* x = new TrackLifetime[3]{infos[0], infos[1], infos[2]};
+        assert(x != nullptr);
+
+        void* addresses[3] = {&x[0], &x[1], &x[2]};
+        assert(infos[0].address_constructed == addresses[0]);
+        assert(infos[1].address_constructed == addresses[1]);
+        assert(infos[2].address_constructed == addresses[2]);
+
+        delete[] x;
+        assert(infos[0].address_destroyed == addresses[0]);
+        assert(infos[1].address_destroyed == addresses[1]);
+        assert(infos[2].address_destroyed == addresses[2]);
+#endif
+    }
+
+    return 0;
+}

libcxx/test/std/language.support/support.dynamic/new.delete/new.delete.array/new.size.replace.indirect.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
 //
 //===----------------------------------------------------------------------===//
 
-// test operator new[] replacement by replacing only operator new
+// void* operator new[](std::size_t);
+
+// Test that we can replace the operator by replacing the `operator new(std::size_t)` (the non-array version).
 
 // UNSUPPORTED: sanitizer-new-delete
 // XFAIL: libcpp-no-vcruntime
 // XFAIL: LIBCXX-AIX-FIXME
 
 #include <new>
 #include <cstddef>
 #include <cstdlib>
 #include <cassert>
 #include <limits>
 
 #include "test_macros.h"
 
 int new_called = 0;
+int delete_called = 0;
 
-void* operator new(std::size_t s) TEST_THROW_SPEC(std::bad_alloc)
-{
+TEST_WORKAROUND_BUG_109234844_WEAK
+void* operator new(std::size_t s) TEST_THROW_SPEC(std::bad_alloc) {
     ++new_called;
     void* ret = std::malloc(s);
     if (!ret) std::abort(); // placate MSVC's unchecked malloc warning
     return  ret;
 }
 
-void  operator delete(void* p) TEST_NOEXCEPT
-{
-    --new_called;
+void operator delete(void* p) TEST_NOEXCEPT {
+    ++delete_called;
     std::free(p);
 }
 
-int A_constructed = 0;
-
-struct A
-{
-    A() {++A_constructed;}
-    ~A() {--A_constructed;}
-};
-
-int main(int, char**)
-{
-    new_called = 0;
-    A *ap = new A[3];
-    DoNotOptimize(ap);
-    assert(ap);
-    assert(A_constructed == 3);
+int main(int, char**) {
+    new_called = delete_called = 0;
+    int* x = new int[3];
+    assert(x != nullptr);
     ASSERT_WITH_OPERATOR_NEW_FALLBACKS(new_called == 1);
-    delete [] ap;
-    DoNotOptimize(ap);
-    assert(A_constructed == 0);
-    ASSERT_WITH_OPERATOR_NEW_FALLBACKS(new_called == 0);
+
+    delete[] x;
+    ASSERT_WITH_OPERATOR_NEW_FALLBACKS(delete_called == 1);
 
     return 0;
 }

libcxx/test/std/language.support/support.dynamic/new.delete/new.delete.array/new.size.replace.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
 //
 //===----------------------------------------------------------------------===//
 
-// test operator new [] nothrow by replacing only operator new
+// void* operator new[](std::size_t);
+
+// Test that we can replace the operator by defining our own.
 
 // UNSUPPORTED: sanitizer-new-delete
 // XFAIL: libcpp-no-vcruntime
-// XFAIL: LIBCXX-AIX-FIXME
 
 #include <new>
 #include <cstddef>
 #include <cstdlib>
 #include <cassert>
 #include <limits>
 
 #include "test_macros.h"
 
 int new_called = 0;
+int delete_called = 0;
 
-void* operator new(std::size_t s) TEST_THROW_SPEC(std::bad_alloc)
-{
+void* operator new[](std::size_t s) TEST_THROW_SPEC(std::bad_alloc) {
     ++new_called;
     void* ret = std::malloc(s);
     if (!ret) std::abort(); // placate MSVC's unchecked malloc warning
     return  ret;
 }
 
-void  operator delete(void* p) TEST_NOEXCEPT
-{
-    --new_called;
+void operator delete[](void* p) TEST_NOEXCEPT {
+    ++delete_called;
     std::free(p);
 }
 
-int A_constructed = 0;
+int main(int, char**) {
+    new_called = delete_called = 0;
+    int* x = new int[3];
+    assert(x != nullptr);
+    ASSERT_WITH_OPERATOR_NEW_FALLBACKS(new_called == 1);
 
-struct A
-{
-    A() {++A_constructed;}
-    ~A() {--A_constructed;}
-};
-
-int main(int, char**)
-{
-    new_called = 0;
-    A *ap = new (std::nothrow) A[3];
-    DoNotOptimize(ap);
-    assert(ap);
-    assert(A_constructed == 3);
-    ASSERT_WITH_OPERATOR_NEW_FALLBACKS(new_called);
-    delete [] ap;
-    DoNotOptimize(ap);
-    assert(A_constructed == 0);
-    ASSERT_WITH_OPERATOR_NEW_FALLBACKS(!new_called);
+    delete[] x;
+    ASSERT_WITH_OPERATOR_NEW_FALLBACKS(delete_called == 1);
 
     return 0;
 }

libcxx/test/std/language.support/support.dynamic/new.delete/new.delete.array/new.size_align.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
+//
+//===----------------------------------------------------------------------===//
+
+// void* operator new[](std::size_t, std::align_val_t);
+
+// UNSUPPORTED: c++03, c++11, c++14
+
+// asan and msan will not call the new handler.
+// UNSUPPORTED: sanitizer-new-delete
+
+// We get availability markup errors when aligned allocation is missing
+// XFAIL: availability-aligned_allocation-missing
+
+// Libc++ when built for z/OS doesn't contain the aligned allocation functions,
+// nor does the dynamic library shipped with z/OS.
+// UNSUPPORTED: target={{.+}}-zos{{.*}}
+
+#include <new>
+#include <cstddef>
+#include <cassert>
+#include <cstdint>
+#include <limits>
+
+#include "test_macros.h"
+#include "../types.h"
+
+int new_handler_called = 0;
+
+void my_new_handler() {
+    ++new_handler_called;
+    std::set_new_handler(nullptr);
+}
+
+int main(int, char**) {
+    // Test that we can call the function directly
+    {
+        void* x = operator new[](10, static_cast<std::align_val_t>(64));
+        assert(x != nullptr);
+        assert(reinterpret_cast<std::uintptr_t>(x) % 64 == 0);
+        operator delete[](x, static_cast<std::align_val_t>(64));
+    }
+
+    // Test that the new handler is called if allocation fails
+    {
+#ifndef TEST_HAS_NO_EXCEPTIONS
+        std::set_new_handler(my_new_handler);
+        try {
+            void* x = operator new[] (std::numeric_limits<std::size_t>::max(),
+                                      static_cast<std::align_val_t>(32));
+            (void)x;
+            assert(false);
+        } catch (std::bad_alloc const&) {
+            assert(new_handler_called == 1);
+        } catch (...) {
+            assert(false);
+        }
+#endif
+    }
+
+    // Test that a new expression constructs the right object
+    // and a delete expression deletes it
+    {
+        LifetimeInformation infos[3];
+        TrackLifetimeOverAligned* x = new TrackLifetimeOverAligned[3]{infos[0], infos[1], infos[2]};
+        assert(x != nullptr);
+        assert(reinterpret_cast<std::uintptr_t>(x) % alignof(TrackLifetimeOverAligned) == 0);
+
+        void* addresses[3] = {&x[0], &x[1], &x[2]};
+        assert(infos[0].address_constructed == addresses[0]);
+        assert(infos[1].address_constructed == addresses[1]);
+        assert(infos[2].address_constructed == addresses[2]);
+
+        delete[] x;
+        assert(infos[0].address_destroyed == addresses[0]);
+        assert(infos[1].address_destroyed == addresses[1]);
+        assert(infos[2].address_destroyed == addresses[2]);
+    }
+
+    return 0;
+}

libcxx/test/std/language.support/support.dynamic/new.delete/new.delete.array/new.size_align.replace.indirect.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
+//
+//===----------------------------------------------------------------------===//
+
+// void* operator new[](std::size_t, std::align_val_t);
+
+// Test that we can replace the operator by replacing `operator new(std::size_t, std::align_val_t)` (the non-array version).
+
+// UNSUPPORTED: c++03, c++11, c++14
+// UNSUPPORTED: sanitizer-new-delete
+
+// XFAIL: LIBCXX-AIX-FIXME
+
+// We get availability markup errors when aligned allocation is missing
+// XFAIL: availability-aligned_allocation-missing
+
+// Libc++ when built for z/OS doesn't contain the aligned allocation functions,
+// nor does the dynamic library shipped with z/OS.
+// UNSUPPORTED: target={{.+}}-zos{{.*}}
+
+// TODO: Investigate why this fails on MinGW-shared
+// UNSUPPORTED: target={{.+}}-windows-gnu
+
+#include <new>
+#include <cstddef>
+#include <cstdlib>
+#include <cstdint>
+#include <cassert>
+#include <limits>
+
+#include "test_macros.h"
+#include "../types.h"
+
+int new_called = 0;
+int delete_called = 0;
+
+alignas(OverAligned) char DummyData[alignof(OverAligned) * 3];
+
+TEST_WORKAROUND_BUG_109234844_WEAK
+void* operator new(std::size_t s, std::align_val_t a) {
+    assert(s <= sizeof(DummyData));
+    assert(static_cast<std::size_t>(a) == alignof(OverAligned));
+    ++new_called;
+    return DummyData;
+}
+
+void operator delete(void*, std::align_val_t) noexcept {
+    ++delete_called;
+    // nothing to delete, we didn't actually allocate in `operator new`
+}
+
+int main(int, char**) {
+    // Test with an overaligned type
+    {
+        new_called = delete_called = 0;
+        OverAligned* x = new OverAligned[3];
+        assert(static_cast<void*>(x) == DummyData);
+        assert(new_called == 1);
+
+        delete[] x;
+        assert(delete_called == 1);
+    }
+
+    // Test with a type that is right on the verge of being overaligned
+    {
+        new_called = delete_called = 0;
+        MaxAligned* x = new MaxAligned[3];
+        assert(x != nullptr);
+        assert(new_called == 0);
+
+        delete[] x;
+        assert(delete_called == 0);
+    }
+
+    // Test with a type that is clearly not overaligned
+    {
+        new_called = delete_called = 0;
+        int* x = new int[3];
+        assert(x != nullptr);
+        assert(new_called == 0);
+
+        delete[] x;
+        assert(delete_called == 0);
+    }
+
+    return 0;
+}

libcxx/test/std/language.support/support.dynamic/new.delete/new.delete.array/new.size_align.replace.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
+//
+//===----------------------------------------------------------------------===//
+
+// void* operator new[](std::size_t, std::align_val_t);
+
+// Test that we can replace the operator by defining our own.
+
+// UNSUPPORTED: c++03, c++11, c++14
+// UNSUPPORTED: sanitizer-new-delete
+
+// Libc++ when built for z/OS doesn't contain the aligned allocation functions,
+// nor does the dynamic library shipped with z/OS.
+// UNSUPPORTED: target={{.+}}-zos{{.*}}
+
+#include <new>
+#include <cstddef>
+#include <cstdlib>
+#include <cstdint>
+#include <cassert>
+#include <limits>
+
+#include "test_macros.h"
+#include "../types.h"
+
+int new_called = 0;
+int delete_called = 0;
+
+alignas(OverAligned) char DummyData[alignof(OverAligned) * 3];
+
+void* operator new[](std::size_t s, std::align_val_t a) {
+    assert(s <= sizeof(DummyData));
+    assert(static_cast<std::size_t>(a) == alignof(OverAligned));
+    ++new_called;
+    return DummyData;
+}
+
+void operator delete[](void*, std::align_val_t) noexcept {
+    ++delete_called;
+    // nothing to delete, we didn't actually allocate in `operator new`
+}
+
+int main(int, char**) {
+    // Test with an overaligned type
+    {
+        new_called = delete_called = 0;
+        OverAligned* x = new OverAligned[3];
+        assert(static_cast<void*>(x) == DummyData);
+        assert(new_called == 1);
+
+        delete[] x;
+        assert(delete_called == 1);
+    }
+
+    // Test with a type that is right on the verge of being overaligned
+    {
+        new_called = delete_called = 0;
+        MaxAligned* x = new MaxAligned[3];
+        assert(x != nullptr);
+        assert(new_called == 0);
+
+        delete[] x;
+        assert(delete_called == 0);
+    }
+
+    // Test with a type that is clearly not overaligned
+    {
+        new_called = delete_called = 0;
+        int* x = new int[3];
+        assert(x != nullptr);
+        assert(new_called == 0);
+
+        delete[] x;
+        assert(delete_called == 0);
+    }
+
+    return 0;
+}

libcxx/test/std/language.support/support.dynamic/new.delete/new.delete.array/new.size_align_nothrow.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
+//
+//===----------------------------------------------------------------------===//
+
+// void* operator new[](std::size_t, std::align_val_t, std::nothrow_t const&);
+
+// UNSUPPORTED: c++03, c++11, c++14
+
+// asan and msan will not call the new handler.
+// UNSUPPORTED: sanitizer-new-delete
+
+// We get availability markup errors when aligned allocation is missing
+// XFAIL: availability-aligned_allocation-missing
+
+// Libc++ when built for z/OS doesn't contain the aligned allocation functions,
+// nor does the dynamic library shipped with z/OS.
+// UNSUPPORTED: target={{.+}}-zos{{.*}}
+
+#include <new>
+#include <cstddef>
+#include <cstdint>
+#include <cassert>
+#include <limits>
+
+#include "test_macros.h"
+#include "../types.h"
+
+int new_handler_called = 0;
+
+void my_new_handler() {
+    ++new_handler_called;
+    std::set_new_handler(nullptr);
+}
+
+int main(int, char**) {
+    // Test that we can call the function directly
+    {
+        void* x = operator new[](10, static_cast<std::align_val_t>(64), std::nothrow);
+        assert(x != nullptr);
+        assert(reinterpret_cast<std::uintptr_t>(x) % 64 == 0);
+        operator delete[](x, static_cast<std::align_val_t>(64), std::nothrow);
+    }
+
+    // Test that the new handler is called and we return nullptr if allocation fails
+    {
+        std::set_new_handler(my_new_handler);
+        void* x = operator new[](std::numeric_limits<std::size_t>::max(),
+                                 static_cast<std::align_val_t>(32), std::nothrow);
+        assert(new_handler_called == 1);
+        assert(x == nullptr);
+    }
+
+    // Test that a new expression constructs the right object
+    // and a delete expression deletes it
+    {
+        LifetimeInformation infos[3];
+        TrackLifetimeOverAligned* x = new (std::nothrow) TrackLifetimeOverAligned[3]{infos[0], infos[1], infos[2]};
+        assert(x != nullptr);
+        assert(reinterpret_cast<std::uintptr_t>(x) % alignof(TrackLifetimeOverAligned) == 0);
+
+        void* addresses[3] = {&x[0], &x[1], &x[2]};
+        assert(infos[0].address_constructed == addresses[0]);
+        assert(infos[1].address_constructed == addresses[1]);
+        assert(infos[2].address_constructed == addresses[2]);
+
+        delete[] x;
+        assert(infos[0].address_destroyed == addresses[0]);
+        assert(infos[1].address_destroyed == addresses[1]);
+        assert(infos[2].address_destroyed == addresses[2]);
+    }
+
+    return 0;
+}

libcxx/test/std/language.support/support.dynamic/new.delete/new.delete.array/new.size_align_nothrow.replace.indirect.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
+//
+//===----------------------------------------------------------------------===//
+
+// void* operator new[](std::size_t, std::align_val_t, std::nothrow_t const&);
+
+// Test that we can replace the operator by replacing `operator new[](std::size_t, std::align_val_t)`
+// (the throwing version).
+
+// UNSUPPORTED: c++03, c++11, c++14
+// UNSUPPORTED: sanitizer-new-delete
+
+// XFAIL: LIBCXX-AIX-FIXME
+
+// We get availability markup errors when aligned allocation is missing
+// XFAIL: availability-aligned_allocation-missing
+
+// Libc++ when built for z/OS doesn't contain the aligned allocation functions,
+// nor does the dynamic library shipped with z/OS.
+// UNSUPPORTED: target={{.+}}-zos{{.*}}
+
+// TODO: Investigate why this fails on MinGW-shared
+// UNSUPPORTED: target={{.+}}-windows-gnu
+
+#include <new>
+#include <cstddef>
+#include <cstdlib>
+#include <cassert>
+#include <limits>
+
+#include "test_macros.h"
+#include "../types.h"
+
+int new_called = 0;
+int delete_called = 0;
+
+alignas(OverAligned) char DummyData[alignof(OverAligned) * 3];
+
+TEST_WORKAROUND_BUG_109234844_WEAK
+void* operator new[](std::size_t s, std::align_val_t a) {
+    assert(s <= sizeof(DummyData));
+    assert(static_cast<std::size_t>(a) == alignof(OverAligned));
+    ++new_called;
+    return DummyData;
+}
+
+void operator delete[](void*, std::align_val_t) noexcept {
+    ++delete_called;
+    // nothing to delete, we didn't actually allocate in `operator new`
+}
+
+int main(int, char**) {
+    // Test with an overaligned type
+    {
+        new_called = delete_called = 0;
+        OverAligned* x = new (std::nothrow) OverAligned[3];
+        assert(static_cast<void*>(x) == DummyData);
+        ASSERT_WITH_OPERATOR_NEW_FALLBACKS(new_called == 1);
+
+        delete[] x;
+        ASSERT_WITH_OPERATOR_NEW_FALLBACKS(delete_called == 1);
+    }
+
+    // Test with a type that is right on the verge of being overaligned
+    {
+        new_called = delete_called = 0;
+        MaxAligned* x = new (std::nothrow) MaxAligned[3];
+        assert(x != nullptr);
+        assert(new_called == 0);
+
+        delete[] x;
+        assert(delete_called == 0);
+    }
+
+    // Test with a type that is clearly not overaligned
+    {
+        new_called = delete_called = 0;
+        int* x = new (std::nothrow) int[3];
+        assert(x != nullptr);
+        assert(new_called == 0);
+
+        delete[] x;
+        assert(delete_called == 0);
+    }
+
+    return 0;
+}

libcxx/test/std/language.support/support.dynamic/new.delete/new.delete.array/new.size_align_nothrow.replace.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
+//
+//===----------------------------------------------------------------------===//
+
+// void* operator new[](std::size_t, std::align_val_t, std::nothrow_t const&);
+
+// Test that we can replace the operator by defining our own.
+
+// UNSUPPORTED: c++03, c++11, c++14
+// UNSUPPORTED: sanitizer-new-delete
+
+// We get availability markup errors when aligned allocation is missing
+// XFAIL: availability-aligned_allocation-missing
+
+// Libc++ when built for z/OS doesn't contain the aligned allocation functions,
+// nor does the dynamic library shipped with z/OS.
+// UNSUPPORTED: target={{.+}}-zos{{.*}}
+
+#include <new>
+#include <cstddef>
+#include <cstdlib>
+#include <cassert>
+#include <limits>
+
+#include "test_macros.h"
+#include "../types.h"
+
+int new_nothrow_called = 0;
+int delete_called = 0;
+
+alignas(OverAligned) char DummyData[alignof(OverAligned) * 3];
+
+TEST_WORKAROUND_BUG_109234844_WEAK
+void* operator new[](std::size_t s, std::align_val_t a, std::nothrow_t const&) noexcept {
+    assert(s <= sizeof(DummyData));
+    assert(static_cast<std::size_t>(a) == alignof(OverAligned));
+    ++new_nothrow_called;
+    return DummyData;
+}
+
+void operator delete[](void*, std::align_val_t) noexcept {
+    ++delete_called;
+    // nothing to delete, we didn't actually allocate in `operator new`
+}
+
+int main(int, char**) {
+    // Test with an overaligned type
+    {
+        new_nothrow_called = delete_called = 0;
+        OverAligned* x = new (std::nothrow) OverAligned[3];
+        assert(static_cast<void*>(x) == DummyData);
+        ASSERT_WITH_OPERATOR_NEW_FALLBACKS(new_nothrow_called == 1);
+
+        delete[] x;
+        ASSERT_WITH_OPERATOR_NEW_FALLBACKS(delete_called == 1);
+    }
+
+    // Test with a type that is right on the verge of being overaligned
+    {
+        new_nothrow_called = delete_called = 0;
+        MaxAligned* x = new (std::nothrow) MaxAligned[3];
+        assert(x != nullptr);
+        assert(new_nothrow_called == 0);
+
+        delete[] x;
+        assert(delete_called == 0);
+    }
+
+    // Test with a type that is clearly not overaligned
+    {
+        new_nothrow_called = delete_called = 0;
+        int* x = new (std::nothrow) int[3];
+        assert(x != nullptr);
+        assert(new_nothrow_called == 0);
+
+        delete[] x;
+        assert(delete_called == 0);
+    }
+
+    return 0;
+}

libcxx/test/std/language.support/support.dynamic/new.delete/new.delete.array/new.size_nothrow.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
+//
+//===----------------------------------------------------------------------===//
+
+// void* operator new[](std::size_t, std::nothrow_t const&);
+
+// asan and msan will not call the new handler.
+// UNSUPPORTED: sanitizer-new-delete
+
+#include <new>
+#include <cstddef>
+#include <cassert>
+#include <limits>
+
+#include "test_macros.h"
+#include "../types.h"
+
+int new_handler_called = 0;
+
+void my_new_handler() {
+    ++new_handler_called;
+    std::set_new_handler(nullptr);
+}
+
+int main(int, char**) {
+    // Test that we can call the function directly
+    {
+        void* x = operator new[](10, std::nothrow);
+        assert(x != nullptr);
+        operator delete[](x, std::nothrow);
+    }
+
+    // Test that the new handler is called and we return nullptr if allocation fails
+    {
+        std::set_new_handler(my_new_handler);
+        void* x = operator new[](std::numeric_limits<std::size_t>::max(), std::nothrow);
+        assert(new_handler_called == 1);
+        assert(x == nullptr);
+    }
+
+    // Test that a new expression constructs the right objects
+    // and a delete expression deletes them. The brace-init requires C++11.
+    {
+#if TEST_STD_VER >= 11
+        LifetimeInformation infos[3];
+        TrackLifetime* x = new (std::nothrow) TrackLifetime[3]{infos[0], infos[1], infos[2]};
+        assert(x != nullptr);
+
+        void* addresses[3] = {&x[0], &x[1], &x[2]};
+        assert(infos[0].address_constructed == addresses[0]);
+        assert(infos[1].address_constructed == addresses[1]);
+        assert(infos[2].address_constructed == addresses[2]);
+
+        delete[] x;
+        assert(infos[0].address_destroyed == addresses[0]);
+        assert(infos[1].address_destroyed == addresses[1]);
+        assert(infos[2].address_destroyed == addresses[2]);
+#endif
+    }
+
+    return 0;
+}

libcxx/test/std/language.support/support.dynamic/new.delete/new.delete.array/new.size_nothrow.replace.indirect.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
 //
 //===----------------------------------------------------------------------===//
 
-// test operator new[] replacement by replacing only operator new
+// void* operator new[](std::size_t, std::nothrow_t const&);
+
+// Test that we can replace the operator by replacing `operator new[](std::size_t)` (the throwing version).
 
 // UNSUPPORTED: sanitizer-new-delete
 // XFAIL: libcpp-no-vcruntime
 // XFAIL: LIBCXX-AIX-FIXME
 
+// TODO: Investigate why this fails on Windows
+// XFAIL: target={{.+}}-windows-msvc
+
 #include <new>
 #include <cstddef>
 #include <cstdlib>
 #include <cassert>
-#include <limits>
 
 #include "test_macros.h"
 
 int new_called = 0;
+int delete_called = 0;
 
-void* operator new(std::size_t s) TEST_THROW_SPEC(std::bad_alloc)
-{
+TEST_WORKAROUND_BUG_109234844_WEAK
+void* operator new[](std::size_t s) TEST_THROW_SPEC(std::bad_alloc) {
     ++new_called;
     void* ret = std::malloc(s);
     if (!ret) std::abort(); // placate MSVC's unchecked malloc warning
-    return  ret;
+    return ret;
 }
 
-void  operator delete(void* p) TEST_NOEXCEPT
-{
-    --new_called;
+void operator delete(void* p) TEST_NOEXCEPT {
+    ++delete_called;
     std::free(p);
 }
 
-int A_constructed = 0;
-
-struct A
-{
-    A() {++A_constructed;}
-    ~A() {--A_constructed;}
-};
-
-int main(int, char**)
-{
-    new_called = 0;
-    A *ap = new A[3];
-    DoNotOptimize(ap);
-    assert(ap);
-    assert(A_constructed == 3);
+int main(int, char**) {
+    new_called = delete_called = 0;
+    int* x = new (std::nothrow) int[3];
+    assert(x != nullptr);
     ASSERT_WITH_OPERATOR_NEW_FALLBACKS(new_called == 1);
-    delete [] ap;
-    DoNotOptimize(ap);
-    assert(A_constructed == 0);
-    ASSERT_WITH_OPERATOR_NEW_FALLBACKS(new_called == 0);
+
+    delete[] x;
+    ASSERT_WITH_OPERATOR_NEW_FALLBACKS(delete_called == 1);
 
     return 0;
 }

libcxx/test/std/language.support/support.dynamic/new.delete/new.delete.array/new.size_nothrow.replace.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
+//
+//===----------------------------------------------------------------------===//
+
+// void* operator new[](std::size_t, std::nothrow_t const&);
+
+// Test that we can replace the operator by defining our own.
+
+// UNSUPPORTED: sanitizer-new-delete
+// XFAIL: libcpp-no-vcruntime
+
+#include <new>
+#include <cstddef>
+#include <cstdlib>
+#include <cassert>
+
+#include "test_macros.h"
+
+int new_nothrow_called = 0;
+int delete_called = 0;
+
+void* operator new[](std::size_t s, std::nothrow_t const&) TEST_NOEXCEPT {
+    ++new_nothrow_called;
+    return std::malloc(s);
+}
+
+void operator delete[](void* p) TEST_NOEXCEPT {
+    ++delete_called;
+    std::free(p);
+}
+
+int main(int, char**) {
+    new_nothrow_called = delete_called = 0;
+    int* x = new (std::nothrow) int[3];
+    assert(x != nullptr);
+    ASSERT_WITH_OPERATOR_NEW_FALLBACKS(new_nothrow_called == 1);
+
+    assert(delete_called == 0);
+    delete[] x;
+    ASSERT_WITH_OPERATOR_NEW_FALLBACKS(delete_called == 1);
+
+    return 0;
+}

libcxx/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_align_val_t.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, c++11, c++14
-
-// asan and msan will not call the new handler.
-// UNSUPPORTED: sanitizer-new-delete
-
-// We get availability markup errors when aligned allocation is missing
-// XFAIL: availability-aligned_allocation-missing
-
-// Libcxx when built for z/OS doesn't contain the aligned allocation functions,
-// nor does the dynamic library shipped with z/OS.
-// UNSUPPORTED: target={{.+}}-zos{{.*}}
-
-// test operator new
-
-#include <new>
-#include <cstddef>
-#include <cassert>
-#include <cstdint>
-#include <limits>
-
-#include "test_macros.h"
-
-constexpr auto OverAligned = __STDCPP_DEFAULT_NEW_ALIGNMENT__ * 2;
-
-int new_handler_called = 0;
-
-void my_new_handler()
-{
-    ++new_handler_called;
-    std::set_new_handler(0);
-}
-
-int A_constructed = 0;
-
-struct alignas(OverAligned) A
-{
-    A() { ++A_constructed;}
-    ~A() { --A_constructed;}
-};
-
-void test_throw_max_size() {
-#ifndef TEST_HAS_NO_EXCEPTIONS
-    std::set_new_handler(my_new_handler);
-    try
-    {
-        void* vp = operator new[] (std::numeric_limits<std::size_t>::max(),
-                                   static_cast<std::align_val_t>(32));
-        ((void)vp);
-        assert(false);
-    }
-    catch (std::bad_alloc&)
-    {
-        assert(new_handler_called == 1);
-    }
-    catch (...)
-    {
-        assert(false);
-    }
-#endif
-}
-
-int main(int, char**)
-{
-    {
-        A* ap = new A[2];
-        assert(ap);
-        assert(reinterpret_cast<std::uintptr_t>(ap) % OverAligned == 0);
-        assert(A_constructed == 2);
-        delete [] ap;
-        assert(A_constructed == 0);
-    }
-    {
-        test_throw_max_size();
-    }
-
-  return 0;
-}

libcxx/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_align_val_t_nothrow.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, c++11, c++14
-
-// asan and msan will not call the new handler.
-// UNSUPPORTED: sanitizer-new-delete
-
-// We get availability markup errors when aligned allocation is missing
-// XFAIL: availability-aligned_allocation-missing
-
-// Libcxx when built for z/OS doesn't contain the aligned allocation functions,
-// nor does the dynamic library shipped with z/OS.
-// UNSUPPORTED: target={{.+}}-zos{{.*}}
-
-// test operator new (nothrow)
-
-#include <new>
-#include <cstddef>
-#include <cstdint>
-#include <cassert>
-#include <limits>
-
-#include "test_macros.h"
-
-constexpr auto OverAligned = __STDCPP_DEFAULT_NEW_ALIGNMENT__ * 2;
-
-int new_handler_called = 0;
-
-void my_new_handler()
-{
-    ++new_handler_called;
-    std::set_new_handler(0);
-}
-
-int A_constructed = 0;
-
-struct alignas(OverAligned) A
-{
-    A() { ++A_constructed; }
-    ~A() { --A_constructed; }
-};
-
-void test_max_alloc() {
-    std::set_new_handler(my_new_handler);
-    auto do_test = []() {
-        void* vp = operator new [](std::numeric_limits<std::size_t>::max(),
-                                 std::align_val_t(OverAligned),
-                                 std::nothrow);
-        assert(new_handler_called == 1);
-        assert(vp == 0);
-    };
-#ifndef TEST_HAS_NO_EXCEPTIONS
-    try
-    {
-        do_test();
-    }
-    catch (...)
-    {
-        assert(false);
-    }
-#else
-    do_test();
-#endif
-}
-
-int main(int, char**)
-{
-    {
-        A* ap = new(std::nothrow) A[3];
-        assert(ap);
-        assert(reinterpret_cast<std::uintptr_t>(ap) % OverAligned == 0);
-        assert(A_constructed == 3);
-        delete [] ap;
-        assert(!A_constructed);
-    }
-    {
-        test_max_alloc();
-    }
-
-  return 0;
-}

libcxx/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_align_val_t_nothrow_replace.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, c++11, c++14
-// UNSUPPORTED: sanitizer-new-delete
-
-// XFAIL: LIBCXX-AIX-FIXME
-
-// We get availability markup errors when aligned allocation is missing
-// XFAIL: availability-aligned_allocation-missing
-
-// Libcxx when built for z/OS doesn't contain the aligned allocation functions,
-// nor does the dynamic library shipped with z/OS.
-// UNSUPPORTED: target={{.+}}-zos{{.*}}
-
-// test operator new nothrow by replacing only operator new
-
-#include <new>
-#include <cstddef>
-#include <cstdlib>
-#include <cassert>
-#include <limits>
-
-#include "test_macros.h"
-
-constexpr auto OverAligned = __STDCPP_DEFAULT_NEW_ALIGNMENT__ * 2;
-
-int A_constructed = 0;
-
-struct alignas(OverAligned) A
-{
-    A() {++A_constructed;}
-    ~A() {--A_constructed;}
-};
-
-int B_constructed = 0;
-
-struct B {
-  std::max_align_t member;
-  B() { ++B_constructed; }
-  ~B() { --B_constructed; }
-};
-
-int new_called = 0;
-alignas(OverAligned) char Buff[OverAligned * 3];
-
-void* operator new[](std::size_t s, std::align_val_t a) TEST_THROW_SPEC(std::bad_alloc)
-{
-    assert(!new_called);
-    assert(s <= sizeof(Buff));
-    assert(static_cast<std::size_t>(a) == OverAligned);
-    ++new_called;
-    return Buff;
-}
-
-void  operator delete[](void* p, std::align_val_t a) TEST_NOEXCEPT
-{
-    ASSERT_WITH_OPERATOR_NEW_FALLBACKS(p == Buff);
-    assert(static_cast<std::size_t>(a) == OverAligned);
-    ASSERT_WITH_OPERATOR_NEW_FALLBACKS(new_called);
-    --new_called;
-}
-
-int main(int, char**)
-{
-    {
-        A* ap = new (std::nothrow) A[2];
-        assert(ap);
-        assert(A_constructed == 2);
-        ASSERT_WITH_OPERATOR_NEW_FALLBACKS(new_called);
-        delete [] ap;
-        assert(A_constructed == 0);
-        ASSERT_WITH_OPERATOR_NEW_FALLBACKS(!new_called);
-    }
-    {
-        B* bp = new (std::nothrow) B[2];
-        assert(bp);
-        assert(B_constructed == 2);
-        ASSERT_WITH_OPERATOR_NEW_FALLBACKS(!new_called);
-        delete [] bp;
-        ASSERT_WITH_OPERATOR_NEW_FALLBACKS(!new_called);
-        assert(!B_constructed);
-    }
-
-  return 0;
-}

libcxx/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_align_val_t_replace.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, c++11, c++14
-// UNSUPPORTED: sanitizer-new-delete
-
-// Libcxx when built for z/OS doesn't contain the aligned allocation functions,
-// nor does the dynamic library shipped with z/OS.
-// UNSUPPORTED: target={{.+}}-zos{{.*}}
-
-// test operator new replacement
-
-#include <new>
-#include <cstddef>
-#include <cstdlib>
-#include <cstdint>
-#include <cassert>
-#include <limits>
-
-#include "test_macros.h"
-
-constexpr auto OverAligned = __STDCPP_DEFAULT_NEW_ALIGNMENT__ * 2;
-
-int A_constructed = 0;
-
-struct alignas(OverAligned) A {
-    A() { ++A_constructed;}
-    ~A() { --A_constructed;}
-};
-
-
-int B_constructed = 0;
-
-struct alignas(std::max_align_t) B
-{
-    std::max_align_t member;
-    B() { ++B_constructed;}
-    ~B() { --B_constructed;}
-};
-
-int new_called = 0;
-
-alignas(OverAligned) char DummyData[OverAligned * 4];
-
-void* operator new[](std::size_t s, std::align_val_t a) TEST_THROW_SPEC(std::bad_alloc)
-{
-    assert(new_called == 0); // We already allocated
-    assert(s <= sizeof(DummyData));
-    assert(static_cast<std::size_t>(a) == OverAligned);
-    ++new_called;
-    void *Ret = DummyData;
-    DoNotOptimize(Ret);
-    return Ret;
-}
-
-void  operator delete[](void* p, std::align_val_t) TEST_NOEXCEPT
-{
-    assert(new_called == 1);
-    --new_called;
-    assert(p == DummyData);
-    DoNotOptimize(p);
-}
-
-
-int main(int, char**)
-{
-    {
-        A* ap = new A[3];
-        assert(ap);
-        assert(A_constructed == 3);
-        assert(new_called);
-        delete [] ap;
-        assert(!A_constructed);
-        assert(!new_called);
-    }
-    {
-        B* bp = new B[3];
-        assert(bp);
-        assert(B_constructed == 3);
-        assert(!new_called);
-        delete [] bp;
-        assert(!new_called);
-    }
-
-  return 0;
-}

libcxx/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_array.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
-//
-//===----------------------------------------------------------------------===//
-
-// test operator new[]
-// NOTE: asan and msan will not call the new handler.
-// UNSUPPORTED: sanitizer-new-delete
-
-
-#include <new>
-#include <cstddef>
-#include <cassert>
-#include <limits>
-
-#include "test_macros.h"
-
-int new_handler_called = 0;
-
-void my_new_handler()
-{
-    ++new_handler_called;
-    std::set_new_handler(0);
-}
-
-int A_constructed = 0;
-
-struct A
-{
-    A() {++A_constructed;}
-    ~A() {--A_constructed;}
-};
-
-int main(int, char**)
-{
-#ifndef TEST_HAS_NO_EXCEPTIONS
-    std::set_new_handler(my_new_handler);
-    try
-    {
-        void* vp = operator new[] (std::numeric_limits<std::size_t>::max());
-        DoNotOptimize(vp);
-        assert(false);
-    }
-    catch (std::bad_alloc&)
-    {
-        assert(new_handler_called == 1);
-    }
-    catch (...)
-    {
-        assert(false);
-    }
-#endif
-    A* ap = new A[3];
-    DoNotOptimize(ap);
-    assert(ap);
-    assert(A_constructed == 3);
-    delete [] ap;
-    DoNotOptimize(ap);
-    assert(A_constructed == 0);
-
-  return 0;
-}

libcxx/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_array_nothrow.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
-//
-//===----------------------------------------------------------------------===//
-
-// test operator new [] (nothrow)
-// NOTE: asan and msan will not call the new handler.
-// UNSUPPORTED: sanitizer-new-delete
-
-
-#include <new>
-#include <cstddef>
-#include <cassert>
-#include <limits>
-
-#include "test_macros.h"
-
-int new_handler_called = 0;
-
-void my_new_handler()
-{
-    ++new_handler_called;
-    std::set_new_handler(0);
-}
-
-int A_constructed = 0;
-
-struct A
-{
-    A() {++A_constructed;}
-    ~A() {--A_constructed;}
-};
-
-int main(int, char**)
-{
-    new_handler_called = 0;
-    std::set_new_handler(my_new_handler);
-#ifndef TEST_HAS_NO_EXCEPTIONS
-    try
-#endif
-    {
-        void* vp = operator new [] (std::numeric_limits<std::size_t>::max(), std::nothrow);
-        DoNotOptimize(vp);
-        assert(new_handler_called == 1);
-        assert(vp == 0);
-    }
-#ifndef TEST_HAS_NO_EXCEPTIONS
-    catch (...)
-    {
-        assert(false);
-    }
-#endif
-    A* ap = new(std::nothrow) A[3];
-    DoNotOptimize(ap);
-    assert(ap);
-    assert(A_constructed == 3);
-    delete [] ap;
-    DoNotOptimize(ap);
-    assert(A_constructed == 0);
-
-  return 0;
-}

libcxx/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_size.verify.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
-//
-//===----------------------------------------------------------------------===//
-
-// <new>
-
-// void* operator new[](std::size_t);
-
-// UNSUPPORTED: c++03, c++11, c++14, c++17
-
-// REQUIRES: -faligned-allocation
-// ADDITIONAL_COMPILE_FLAGS: -faligned-allocation
-
-#include <new>
-
-void f() {
-    ::operator new[](4);  // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
-}

libcxx/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_size_align.verify.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
-//
-//===----------------------------------------------------------------------===//
-
-// <new>
-
-// void* operator new[](std::size_t, std::align_val_t);
-
-// UNSUPPORTED: c++03, c++11, c++14, c++17
-
-// Libcxx when built for z/OS doesn't contain the aligned allocation functions,
-// nor does the dynamic library shipped with z/OS.
-// UNSUPPORTED: target={{.+}}-zos{{.*}}
-
-// REQUIRES: -faligned-allocation
-// ADDITIONAL_COMPILE_FLAGS: -faligned-allocation
-
-#include <new>
-
-void f() {
-    ::operator new[](4, std::align_val_t{4});  // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
-}

libcxx/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_size_align_nothrow.verify.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
-//
-//===----------------------------------------------------------------------===//
-
-// <new>
-
-// void* operator new[](std::size_t, std::align_val_t, std::nothrow_t &);
-
-// UNSUPPORTED: c++03, c++11, c++14, c++17
-
-// Libcxx when built for z/OS doesn't contain the aligned allocation functions,
-// nor does the dynamic library shipped with z/OS.
-// UNSUPPORTED: target={{.+}}-zos{{.*}}
-
-// REQUIRES: -faligned-allocation
-// ADDITIONAL_COMPILE_FLAGS: -faligned-allocation
-
-#include <new>
-
-void f() {
-    ::operator new[](4, std::align_val_t{4}, std::nothrow);  // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
-}

libcxx/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_size_nothrow.verify.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
-//
-//===----------------------------------------------------------------------===//
-
-// <new>
-
-// void* operator new[](std::size_t, std::nothrow_t &);
-
-// UNSUPPORTED: c++03, c++11, c++14, c++17
-
-// REQUIRES: -faligned-allocation
-// ADDITIONAL_COMPILE_FLAGS: -faligned-allocation
-
-#include <new>
-
-void f() {
-    ::operator new[](4, std::nothrow);  // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
-}

libcxx/test/std/language.support/support.dynamic/new.delete/new.delete.array/nodiscard.verify.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
+//
+//===----------------------------------------------------------------------===//
+
+// [[nodiscard]] void* operator new[](std::size_t);
+// [[nodiscard]] void* operator new[](std::size_t, std::nothrow_t const&);
+// [[nodiscard]] void* operator new[](std::size_t, std::align_val_t);
+// [[nodiscard]] void* operator new[](std::size_t, std::align_val_t, std::nothrow_t const&);
+
+// [[nodiscard]] is not supported at all in c++03
+// UNSUPPORTED: c++03
+
+// [[nodiscard]] enabled before C++20 in libc++ as an extension
+// UNSUPPORTED: (c++11 || c++14 || c++17) && !stdlib=libc++
+
+// We get availability markup errors when aligned allocation is missing
+// XFAIL: availability-aligned_allocation-missing
+
+// Libc++ when built for z/OS doesn't contain the aligned allocation functions,
+// nor does the dynamic library shipped with z/OS.
+// UNSUPPORTED: target={{.+}}-zos{{.*}}
+
+#include <new>
+
+#include "test_macros.h"
+
+void f() {
+    ::operator new[](4);  // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
+    ::operator new[](4, std::nothrow);  // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
+
+#if TEST_STD_VER >= 17
+    ::operator new[](4, std::align_val_t{4});  // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
+    ::operator new[](4, std::align_val_t{4}, std::nothrow);  // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
+#endif
+}

libcxx/test/std/language.support/support.dynamic/new.delete/new.delete.single/delete_align_val_t_replace.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
 //
 //===----------------------------------------------------------------------===//
 
 // test aligned operator delete replacement.
 
 // UNSUPPORTED: sanitizer-new-delete, c++03, c++11, c++14
 
-// Aligned allocation was not provided before macosx10.14 and as a result we
-// get availability errors when the deployment target is older than macosx10.14.
-
-// Libcxx when built for z/OS doesn't contain the aligned allocation functions,
+// Libc++ when built for z/OS doesn't contain the aligned allocation functions,
 // nor does the dynamic library shipped with z/OS.
 // UNSUPPORTED: target={{.+}}-zos{{.*}}
 
 #include <new>
 #include <cstddef>
 #include <cstdlib>
 #include <cassert>
 

libcxx/test/std/language.support/support.dynamic/new.delete/new.delete.single/new.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
-//
-//===----------------------------------------------------------------------===//
-
-// test operator new
-
-// asan and msan will not call the new handler.
-// UNSUPPORTED: sanitizer-new-delete
-
-#include <new>
-#include <cstddef>
-#include <cassert>
-#include <limits>
-
-#include "test_macros.h"
-
-int new_handler_called = 0;
-
-void my_new_handler()
-{
-    ++new_handler_called;
-    std::set_new_handler(0);
-}
-
-bool A_constructed = false;
-
-struct A
-{
-    A() {A_constructed = true;}
-    ~A() {A_constructed = false;}
-};
-
-int main(int, char**)
-{
-#ifndef TEST_HAS_NO_EXCEPTIONS
-    std::set_new_handler(my_new_handler);
-    try
-    {
-        void* vp = operator new (std::numeric_limits<std::size_t>::max());
-        ((void)vp);
-        assert(false);
-    }
-    catch (std::bad_alloc&)
-    {
-        assert(new_handler_called == 1);
-    }
-    catch (...)
-    {
-        assert(false);
-    }
-#endif
-    A* ap = new A;
-    assert(ap);
-    assert(A_constructed);
-    delete ap;
-    assert(!A_constructed);
-
-  return 0;
-}

libcxx/test/std/language.support/support.dynamic/new.delete/new.delete.single/new.size.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
+//
+//===----------------------------------------------------------------------===//
+
+// void* operator new(std::size_t);
+
+// asan and msan will not call the new handler.
+// UNSUPPORTED: sanitizer-new-delete
+
+#include <new>
+#include <cstddef>
+#include <cassert>
+#include <limits>
+
+#include "test_macros.h"
+#include "../types.h"
+
+int new_handler_called = 0;
+
+void my_new_handler() {
+    ++new_handler_called;
+    std::set_new_handler(nullptr);
+}
+
+int main(int, char**) {
+    // Test that we can call the function directly
+    {
+        void* x = operator new(10);
+        assert(x != nullptr);
+        operator delete(x);
+    }
+
+    // Test that the new handler is called if allocation fails
+    {
+#ifndef TEST_HAS_NO_EXCEPTIONS
+        std::set_new_handler(my_new_handler);
+        try {
+            void* x = operator new(std::numeric_limits<std::size_t>::max());
+            (void)x;
+            assert(false);
+        } catch (std::bad_alloc const&) {
+            assert(new_handler_called == 1);
+        } catch (...) {
+            assert(false);
+        }
+#endif
+    }
+
+    // Test that a new expression constructs the right object
+    // and a delete expression deletes it
+    {
+        LifetimeInformation info;
+        TrackLifetime* x = new TrackLifetime(info);
+        assert(x != nullptr);
+        assert(info.address_constructed == x);
+
+        delete x;
+        assert(info.address_destroyed == x);
+    }
+
+    return 0;
+}

libcxx/test/std/language.support/support.dynamic/new.delete/new.delete.single/new.size.replace.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
 //
 //===----------------------------------------------------------------------===//
 
-// test operator new replacement
+// void* operator new(std::size_t);
+
+// Test that we can replace the operator by defining our own.
 
 // UNSUPPORTED: sanitizer-new-delete
 
 #include <new>
 #include <cstddef>
 #include <cstdlib>
 #include <cassert>
-#include <limits>
 
 #include "test_macros.h"
 
 int new_called = 0;
+int delete_called = 0;
 
-void* operator new(std::size_t s) TEST_THROW_SPEC(std::bad_alloc)
-{
+void* operator new(std::size_t s) TEST_THROW_SPEC(std::bad_alloc) {
     ++new_called;
     void* ret = std::malloc(s);
     if (!ret) std::abort(); // placate MSVC's unchecked malloc warning
     return ret;
 }
 
-void  operator delete(void* p) TEST_NOEXCEPT
-{
-    --new_called;
+void operator delete(void* p) TEST_NOEXCEPT {
+    ++delete_called;
     std::free(p);
 }
 
-bool A_constructed = false;
+int main(int, char**) {
+    new_called = delete_called = 0;
+    int* x = new int(3);
+    assert(x != nullptr);
+    ASSERT_WITH_OPERATOR_NEW_FALLBACKS(new_called == 1);
 
-struct A
-{
-    A() {A_constructed = true;}
-    ~A() {A_constructed = false;}
-};
-
-int main(int, char**)
-{
-    new_called = 0;
-    A *ap = new A;
-    DoNotOptimize(ap);
-    assert(ap);
-    assert(A_constructed);
-    assert(new_called);
-    delete ap;
-    DoNotOptimize(ap);
-    assert(!A_constructed);
-    assert(!new_called);
+    delete x;
+    ASSERT_WITH_OPERATOR_NEW_FALLBACKS(delete_called == 1);
 
     return 0;
 }

libcxx/test/std/language.support/support.dynamic/new.delete/new.delete.single/new.size_align.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
+//
+//===----------------------------------------------------------------------===//
+
+// void* operator new(std::size_t, std::align_val_t);
+
+// UNSUPPORTED: c++03, c++11, c++14
+
+// We get availability markup errors when aligned allocation is missing
+// XFAIL: availability-aligned_allocation-missing
+
+// asan and msan will not call the new handler.
+// UNSUPPORTED: sanitizer-new-delete
+
+// Libc++ when built for z/OS doesn't contain the aligned allocation functions,
+// nor does the dynamic library shipped with z/OS.
+// UNSUPPORTED: target={{.+}}-zos{{.*}}
+
+#include <new>
+#include <cstddef>
+#include <cassert>
+#include <cstdint>
+#include <limits>
+
+#include "test_macros.h"
+#include "../types.h"
+
+int new_handler_called = 0;
+
+void my_new_handler() {
+    ++new_handler_called;
+    std::set_new_handler(nullptr);
+}
+
+int main(int, char**) {
+    // Test that we can call the function directly
+    {
+        void* x = operator new(10, static_cast<std::align_val_t>(64));
+        assert(x != nullptr);
+        assert(reinterpret_cast<std::uintptr_t>(x) % 64 == 0);
+        operator delete(x, static_cast<std::align_val_t>(64));
+    }
+
+    // Test that the new handler is called if allocation fails
+    {
+#ifndef TEST_HAS_NO_EXCEPTIONS
+        std::set_new_handler(my_new_handler);
+        try {
+            void* x = operator new(std::numeric_limits<std::size_t>::max(),
+                                   static_cast<std::align_val_t>(32));
+            (void)x;
+            assert(false);
+        } catch (std::bad_alloc const&) {
+            assert(new_handler_called == 1);
+        } catch (...) {
+            assert(false);
+        }
+#endif
+    }
+
+    // Test that a new expression constructs the right object
+    // and a delete expression deletes it
+    {
+        LifetimeInformation info;
+        TrackLifetimeOverAligned* x = new TrackLifetimeOverAligned(info);
+        assert(x != nullptr);
+        assert(reinterpret_cast<std::uintptr_t>(x) % alignof(TrackLifetimeOverAligned) == 0);
+        assert(info.address_constructed == x);
+
+        delete x;
+        assert(info.address_destroyed == x);
+    }
+
+    return 0;
+}

libcxx/test/std/language.support/support.dynamic/new.delete/new.delete.single/new.size_align.replace.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
+//
+//===----------------------------------------------------------------------===//
+
+// void* operator new(std::size_t, std::align_val_t);
+
+// Test that we can replace the operator by defining our own.
+
+// UNSUPPORTED: c++03, c++11, c++14
+// UNSUPPORTED: sanitizer-new-delete
+
+// Libc++ when built for z/OS doesn't contain the aligned allocation functions,
+// nor does the dynamic library shipped with z/OS.
+// UNSUPPORTED: target={{.+}}-zos{{.*}}
+
+#include <new>
+#include <cstddef>
+#include <cstdlib>
+#include <cstdint>
+#include <cassert>
+#include <limits>
+
+#include "test_macros.h"
+#include "../types.h"
+
+int new_called = 0;
+int delete_called = 0;
+
+alignas(OverAligned) char DummyData[alignof(OverAligned)];
+
+void* operator new(std::size_t s, std::align_val_t a) {
+    assert(s <= sizeof(DummyData));
+    assert(static_cast<std::size_t>(a) == alignof(OverAligned));
+    ++new_called;
+    return DummyData;
+}
+
+void operator delete(void*, std::align_val_t) noexcept {
+    ++delete_called;
+    // nothing to delete, we didn't actually allocate in `operator new`
+}
+
+int main(int, char**) {
+    // Test with an overaligned type
+    {
+        new_called = delete_called = 0;
+        OverAligned* x = new OverAligned;
+        assert(static_cast<void*>(x) == DummyData);
+        assert(new_called == 1);
+
+        delete x;
+        assert(delete_called == 1);
+    }
+
+    // Test with a type that is right on the verge of being overaligned
+    {
+        new_called = delete_called = 0;
+        MaxAligned* x = new MaxAligned;
+        assert(x != nullptr);
+        assert(new_called == 0);
+
+        delete x;
+        assert(delete_called == 0);
+    }
+
+    // Test with a type that is clearly not overaligned
+    {
+        new_called = delete_called = 0;
+        int* x = new int;
+        assert(x != nullptr);
+        assert(new_called == 0);
+
+        delete x;
+        assert(delete_called == 0);
+    }
+
+    return 0;
+}

libcxx/test/std/language.support/support.dynamic/new.delete/new.delete.single/new.size_align_nothrow.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
+//
+//===----------------------------------------------------------------------===//
+
+// void* operator new(std::size_t, std::align_val_t, std::nothrow_t const&);
+
+// UNSUPPORTED: c++03, c++11, c++14
+
+// We get availability markup errors when aligned allocation is missing
+// XFAIL: availability-aligned_allocation-missing
+
+// asan and msan will not call the new handler.
+// UNSUPPORTED: sanitizer-new-delete
+
+// Libc++ when built for z/OS doesn't contain the aligned allocation functions,
+// nor does the dynamic library shipped with z/OS.
+// UNSUPPORTED: target={{.+}}-zos{{.*}}
+
+#include <new>
+#include <cstddef>
+#include <cstdint>
+#include <cassert>
+#include <limits>
+
+#include "test_macros.h"
+#include "../types.h"
+
+int new_handler_called = 0;
+
+void my_new_handler() {
+    ++new_handler_called;
+    std::set_new_handler(nullptr);
+}
+
+int main(int, char**) {
+    // Test that we can call the function directly
+    {
+        void* x = operator new(10, static_cast<std::align_val_t>(64), std::nothrow);
+        assert(x != nullptr);
+        assert(reinterpret_cast<std::uintptr_t>(x) % 64 == 0);
+        operator delete(x, static_cast<std::align_val_t>(64), std::nothrow);
+    }
+
+    // Test that the new handler is called and we return nullptr if allocation fails
+    {
+        std::set_new_handler(my_new_handler);
+        void* x = operator new(std::numeric_limits<std::size_t>::max(),
+                               static_cast<std::align_val_t>(32), std::nothrow);
+        assert(new_handler_called == 1);
+        assert(x == nullptr);
+    }
+
+    // Test that a new expression constructs the right object
+    // and a delete expression deletes it
+    {
+        LifetimeInformation info;
+        TrackLifetimeOverAligned* x = new (std::nothrow) TrackLifetimeOverAligned(info);
+        assert(x != nullptr);
+        assert(reinterpret_cast<std::uintptr_t>(x) % alignof(TrackLifetimeOverAligned) == 0);
+        assert(info.address_constructed == x);
+
+        delete x;
+        assert(info.address_destroyed == x);
+    }
+
+    return 0;
+}

libcxx/test/std/language.support/support.dynamic/new.delete/new.delete.single/new.size_align_nothrow.replace.indirect.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
+//
+//===----------------------------------------------------------------------===//
+
+// void* operator new(std::size_t, std::align_val_t, std::nothrow_t const&);
+
+// Test that we can replace the operator by replacing `operator new(std::size_t, std::align_val_t)` (the throwing version).
+
+// UNSUPPORTED: c++03, c++11, c++14
+// UNSUPPORTED: sanitizer-new-delete
+
+// XFAIL: LIBCXX-AIX-FIXME
+
+// We get availability markup errors when aligned allocation is missing
+// XFAIL: availability-aligned_allocation-missing
+
+// Libc++ when built for z/OS doesn't contain the aligned allocation functions,
+// nor does the dynamic library shipped with z/OS.
+// UNSUPPORTED: target={{.+}}-zos{{.*}}
+
+// TODO: Investigate why this fails on MinGW-shared
+// UNSUPPORTED: target={{.+}}-windows-gnu
+
+#include <new>
+#include <cstddef>
+#include <cstdlib>
+#include <cassert>
+#include <limits>
+
+#include "test_macros.h"
+#include "../types.h"
+
+int new_called = 0;
+int delete_called = 0;
+
+alignas(OverAligned) char DummyData[alignof(OverAligned)];
+
+TEST_WORKAROUND_BUG_109234844_WEAK
+void* operator new(std::size_t s, std::align_val_t a) {
+    assert(s <= sizeof(DummyData));
+    assert(static_cast<std::size_t>(a) == alignof(OverAligned));
+    ++new_called;
+    return DummyData;
+}
+
+void operator delete(void*, std::align_val_t) noexcept {
+    ++delete_called;
+    // nothing to delete, we didn't actually allocate in `operator new`
+}
+
+int main(int, char**) {
+    // Test with an overaligned type
+    {
+        new_called = delete_called = 0;
+        OverAligned* x = new (std::nothrow) OverAligned;
+        assert(static_cast<void*>(x) == DummyData);
+        ASSERT_WITH_OPERATOR_NEW_FALLBACKS(new_called == 1);
+
+        delete x;
+        ASSERT_WITH_OPERATOR_NEW_FALLBACKS(delete_called == 1);
+    }
+
+    // Test with a type that is right on the verge of being overaligned
+    {
+        new_called = delete_called = 0;
+        MaxAligned* x = new (std::nothrow) MaxAligned;
+        assert(x != nullptr);
+        assert(new_called == 0);
+
+        delete x;
+        assert(delete_called == 0);
+    }
+
+    // Test with a type that is clearly not overaligned
+    {
+        new_called = delete_called = 0;
+        int* x = new (std::nothrow) int;
+        assert(x != nullptr);
+        assert(new_called == 0);
+
+        delete x;
+        assert(delete_called == 0);
+    }
+
+    return 0;
+}

libcxx/test/std/language.support/support.dynamic/new.delete/new.delete.single/new.size_align_nothrow.replace.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
+//
+//===----------------------------------------------------------------------===//
+
+// void* operator new(std::size_t, std::align_val_t, std::nothrow_t const&);
+
+// Test that we can replace the operator by defining our own.
+
+// UNSUPPORTED: c++03, c++11, c++14
+// UNSUPPORTED: sanitizer-new-delete
+
+// We get availability markup errors when aligned allocation is missing
+// XFAIL: availability-aligned_allocation-missing
+
+// Libc++ when built for z/OS doesn't contain the aligned allocation functions,
+// nor does the dynamic library shipped with z/OS.
+// UNSUPPORTED: target={{.+}}-zos{{.*}}
+
+#include <new>
+#include <cstddef>
+#include <cstdlib>
+#include <cassert>
+#include <limits>
+
+#include "test_macros.h"
+#include "../types.h"
+
+int new_nothrow_called = 0;
+int delete_called = 0;
+
+alignas(OverAligned) char DummyData[alignof(OverAligned)];
+
+void* operator new(std::size_t s, std::align_val_t a, std::nothrow_t const&) noexcept {
+    assert(s <= sizeof(DummyData));
+    assert(static_cast<std::size_t>(a) == alignof(OverAligned));
+    ++new_nothrow_called;
+    return DummyData;
+}
+
+void operator delete(void*, std::align_val_t) noexcept {
+    ++delete_called;
+    // nothing to delete, we didn't actually allocate in `operator new`
+}
+
+int main(int, char**) {
+    // Test with an overaligned type
+    {
+        new_nothrow_called = delete_called = 0;
+        OverAligned* x = new (std::nothrow) OverAligned;
+        assert(static_cast<void*>(x) == DummyData);
+        ASSERT_WITH_OPERATOR_NEW_FALLBACKS(new_nothrow_called == 1);
+
+        delete x;
+        ASSERT_WITH_OPERATOR_NEW_FALLBACKS(delete_called == 1);
+    }
+
+    // Test with a type that is right on the verge of being overaligned
+    {
+        new_nothrow_called = delete_called = 0;
+        MaxAligned* x = new (std::nothrow) MaxAligned;
+        assert(x != nullptr);
+        assert(new_nothrow_called == 0);
+
+        delete x;
+        assert(delete_called == 0);
+    }
+
+    // Test with a type that is clearly not overaligned
+    {
+        new_nothrow_called = delete_called = 0;
+        int* x = new (std::nothrow) int;
+        assert(x != nullptr);
+        assert(new_nothrow_called == 0);
+
+        delete x;
+        assert(delete_called == 0);
+    }
+
+    return 0;
+}

libcxx/test/std/language.support/support.dynamic/new.delete/new.delete.single/new.size_nothrow.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
+//
+//===----------------------------------------------------------------------===//
+
+// void* operator new(std::size_t, std::nothrow_t const&);
+
+// asan and msan will not call the new handler.
+// UNSUPPORTED: sanitizer-new-delete
+
+#include <new>
+#include <cstddef>
+#include <cassert>
+#include <limits>
+
+#include "test_macros.h"
+#include "../types.h"
+
+int new_handler_called = 0;
+
+void my_new_handler() {
+    ++new_handler_called;
+    std::set_new_handler(nullptr);
+}
+
+int main(int, char**) {
+    // Test that we can call the function directly
+    {
+        void* x = operator new(10, std::nothrow);
+        assert(x != nullptr);
+        operator delete(x, std::nothrow);
+    }
+
+    // Test that the new handler is called and we return nullptr if allocation fails
+    {
+        std::set_new_handler(my_new_handler);
+        void* x = operator new(std::numeric_limits<std::size_t>::max(), std::nothrow);
+        assert(new_handler_called == 1);
+        assert(x == nullptr);
+    }
+
+    // Test that a new expression constructs the right object
+    // and a delete expression deletes it
+    {
+        LifetimeInformation info;
+        TrackLifetime* x = new (std::nothrow) TrackLifetime(info);
+        assert(x != nullptr);
+        assert(info.address_constructed == x);
+
+        delete x;
+        assert(info.address_destroyed == x);
+    }
+
+    return 0;
+}

libcxx/test/std/language.support/support.dynamic/new.delete/new.delete.single/new.size_nothrow.replace.indirect.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
 //
 //===----------------------------------------------------------------------===//
 
-// test operator new nothrow by replacing only operator new
+// void* operator new(std::size_t, std::nothrow_t const&);
+
+// Test that we can replace the operator by replacing `operator new(std::size_t)` (the throwing version).
 
 // UNSUPPORTED: sanitizer-new-delete
 // XFAIL: libcpp-no-vcruntime
 // XFAIL: LIBCXX-AIX-FIXME
 
 #include <new>
 #include <cstddef>
 #include <cstdlib>
 #include <cassert>
-#include <limits>
 
 #include "test_macros.h"
 
 int new_called = 0;
+int delete_called = 0;
 
-void* operator new(std::size_t s) TEST_THROW_SPEC(std::bad_alloc)
-{
+TEST_WORKAROUND_BUG_109234844_WEAK
+void* operator new(std::size_t s) TEST_THROW_SPEC(std::bad_alloc) {
     ++new_called;
     void* ret = std::malloc(s);
     if (!ret) std::abort(); // placate MSVC's unchecked malloc warning
     return ret;
 }
 
-void  operator delete(void* p) TEST_NOEXCEPT
-{
-    --new_called;
+void operator delete(void* p) TEST_NOEXCEPT {
+    ++delete_called;
     std::free(p);
 }
 
-bool A_constructed = false;
+int main(int, char**) {
+    new_called = delete_called = 0;
+    int* x = new (std::nothrow) int(3);
+    assert(x != nullptr);
+    ASSERT_WITH_OPERATOR_NEW_FALLBACKS(new_called == 1);
 
-struct A
-{
-    A() {A_constructed = true;}
-    ~A() {A_constructed = false;}
-};
-
-int main(int, char**)
-{
-    new_called = 0;
-    A *ap = new (std::nothrow) A;
-    DoNotOptimize(ap);
-    assert(ap);
-    assert(A_constructed);
-    ASSERT_WITH_OPERATOR_NEW_FALLBACKS(new_called);
-    delete ap;
-    DoNotOptimize(ap);
-    assert(!A_constructed);
-    ASSERT_WITH_OPERATOR_NEW_FALLBACKS(!new_called);
+    delete x;
+    ASSERT_WITH_OPERATOR_NEW_FALLBACKS(delete_called == 1);
 
     return 0;
 }

libcxx/test/std/language.support/support.dynamic/new.delete/new.delete.single/new.size_nothrow.replace.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
+//
+//===----------------------------------------------------------------------===//
+
+// void* operator new(std::size_t, std::nothrow_t const&);
+
+// Test that we can replace the operator by defining our own.
+
+// UNSUPPORTED: sanitizer-new-delete
+// XFAIL: libcpp-no-vcruntime
+
+#include <new>
+#include <cstddef>
+#include <cstdlib>
+#include <cassert>
+
+#include "test_macros.h"
+
+int new_nothrow_called = 0;
+int delete_called = 0;
+
+void* operator new(std::size_t s, std::nothrow_t const&) TEST_NOEXCEPT {
+    ++new_nothrow_called;
+    return std::malloc(s);
+}
+
+void operator delete(void* p) TEST_NOEXCEPT {
+    ++delete_called;
+    std::free(p);
+}
+
+int main(int, char**) {
+    new_nothrow_called = delete_called = 0;
+    int* x = new (std::nothrow) int(3);
+    assert(x != nullptr);
+    ASSERT_WITH_OPERATOR_NEW_FALLBACKS(new_nothrow_called == 1);
+
+    assert(delete_called == 0);
+    delete x;
+    ASSERT_WITH_OPERATOR_NEW_FALLBACKS(delete_called == 1);
+
+    return 0;
+}

libcxx/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_align_val_t.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, c++11, c++14
-
-// We get availability markup errors when aligned allocation is missing
-// XFAIL: availability-aligned_allocation-missing
-
-// asan and msan will not call the new handler.
-// UNSUPPORTED: sanitizer-new-delete
-
-// Libcxx when built for z/OS doesn't contain the aligned allocation functions,
-// nor does the dynamic library shipped with z/OS.
-// UNSUPPORTED: target={{.+}}-zos{{.*}}
-
-// test operator new
-
-#include <new>
-#include <cstddef>
-#include <cassert>
-#include <cstdint>
-#include <limits>
-
-#include "test_macros.h"
-
-constexpr auto OverAligned = __STDCPP_DEFAULT_NEW_ALIGNMENT__ * 2;
-
-int new_handler_called = 0;
-
-void my_new_handler()
-{
-    ++new_handler_called;
-    std::set_new_handler(0);
-}
-
-bool A_constructed = false;
-
-struct alignas(OverAligned) A
-{
-    A() {A_constructed = true;}
-    ~A() {A_constructed = false;}
-};
-
-void test_throw_max_size() {
-#ifndef TEST_HAS_NO_EXCEPTIONS
-    std::set_new_handler(my_new_handler);
-    try
-    {
-        void* vp = operator new (std::numeric_limits<std::size_t>::max(),
-                                 static_cast<std::align_val_t>(32));
-        ((void)vp);
-        assert(false);
-    }
-    catch (std::bad_alloc&)
-    {
-        assert(new_handler_called == 1);
-    }
-    catch (...)
-    {
-        assert(false);
-    }
-#endif
-}
-
-int main(int, char**)
-{
-    {
-        A* ap = new A;
-        assert(ap);
-        assert(reinterpret_cast<std::uintptr_t>(ap) % OverAligned == 0);
-        assert(A_constructed);
-        delete ap;
-        assert(!A_constructed);
-    }
-    {
-        test_throw_max_size();
-    }
-
-  return 0;
-}

libcxx/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_align_val_t_nothrow.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, c++11, c++14
-
-// We get availability markup errors when aligned allocation is missing
-// XFAIL: availability-aligned_allocation-missing
-
-// asan and msan will not call the new handler.
-// UNSUPPORTED: sanitizer-new-delete
-
-// Libcxx when built for z/OS doesn't contain the aligned allocation functions,
-// nor does the dynamic library shipped with z/OS.
-// UNSUPPORTED: target={{.+}}-zos{{.*}}
-
-// test operator new (nothrow)
-
-#include <new>
-#include <cstddef>
-#include <cstdint>
-#include <cassert>
-#include <limits>
-
-#include "test_macros.h"
-
-constexpr auto OverAligned = __STDCPP_DEFAULT_NEW_ALIGNMENT__ * 2;
-
-int new_handler_called = 0;
-
-void my_new_handler()
-{
-    ++new_handler_called;
-    std::set_new_handler(0);
-}
-
-bool A_constructed = false;
-
-struct alignas(OverAligned) A
-{
-    A() {A_constructed = true;}
-    ~A() {A_constructed = false;}
-};
-
-void test_max_alloc() {
-    std::set_new_handler(my_new_handler);
-    auto do_test = []() {
-        void* vp = operator new (std::numeric_limits<std::size_t>::max(),
-                                 std::align_val_t(OverAligned),
-                                 std::nothrow);
-        assert(new_handler_called == 1);
-        assert(vp == 0);
-    };
-#ifndef TEST_HAS_NO_EXCEPTIONS
-    try
-    {
-        do_test();
-    }
-    catch (...)
-    {
-        assert(false);
-    }
-#else
-    do_test();
-#endif
-}
-
-int main(int, char**)
-{
-    {
-        A* ap = new(std::nothrow) A;
-        assert(ap);
-        assert(reinterpret_cast<std::uintptr_t>(ap) % OverAligned == 0);
-        assert(A_constructed);
-        delete ap;
-        assert(!A_constructed);
-    }
-    {
-        test_max_alloc();
-    }
-
-  return 0;
-}

libcxx/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_align_val_t_nothrow_replace.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, c++11, c++14
-// UNSUPPORTED: sanitizer-new-delete
-
-// XFAIL: LIBCXX-AIX-FIXME
-
-// We get availability markup errors when aligned allocation is missing
-// XFAIL: availability-aligned_allocation-missing
-
-// Libcxx when built for z/OS doesn't contain the aligned allocation functions,
-// nor does the dynamic library shipped with z/OS.
-// UNSUPPORTED: target={{.+}}-zos{{.*}}
-
-// test operator new nothrow by replacing only operator new
-
-#include <new>
-#include <cstddef>
-#include <cstdlib>
-#include <cassert>
-#include <limits>
-
-#include "test_macros.h"
-
-constexpr auto OverAligned = __STDCPP_DEFAULT_NEW_ALIGNMENT__ * 2;
-
-bool A_constructed = false;
-
-struct alignas(OverAligned) A
-{
-    A() {A_constructed = true;}
-    ~A() {A_constructed = false;}
-};
-
-bool B_constructed = false;
-
-struct B {
-  std::max_align_t  member;
-  B() { B_constructed = true; }
-  ~B() { B_constructed = false; }
-};
-
-int new_called = 0;
-alignas(OverAligned) char Buff[OverAligned * 2];
-
-void* operator new(std::size_t s, std::align_val_t a) TEST_THROW_SPEC(std::bad_alloc)
-{
-    assert(!new_called);
-    assert(s <= sizeof(Buff));
-    assert(static_cast<std::size_t>(a) == OverAligned);
-    ++new_called;
-    return Buff;
-}
-
-void  operator delete(void* p, std::align_val_t a) TEST_NOEXCEPT
-{
-    ASSERT_WITH_OPERATOR_NEW_FALLBACKS(p == Buff);
-    assert(static_cast<std::size_t>(a) == OverAligned);
-    ASSERT_WITH_OPERATOR_NEW_FALLBACKS(new_called);
-    --new_called;
-}
-
-
-int main(int, char**)
-{
-    {
-        A* ap = new (std::nothrow) A;
-        assert(ap);
-        assert(A_constructed);
-        ASSERT_WITH_OPERATOR_NEW_FALLBACKS(new_called);
-        delete ap;
-        assert(!A_constructed);
-        ASSERT_WITH_OPERATOR_NEW_FALLBACKS(!new_called);
-    }
-    {
-        B* bp = new (std::nothrow) B;
-        assert(bp);
-        assert(B_constructed);
-        ASSERT_WITH_OPERATOR_NEW_FALLBACKS(!new_called);
-        delete bp;
-        ASSERT_WITH_OPERATOR_NEW_FALLBACKS(!new_called);
-        assert(!B_constructed);
-    }
-
-  return 0;
-}

libcxx/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_align_val_t_replace.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, c++11, c++14
-// UNSUPPORTED: sanitizer-new-delete
-
-// Libcxx when built for z/OS doesn't contain the aligned allocation functions,
-// nor does the dynamic library shipped with z/OS.
-// UNSUPPORTED: target={{.+}}-zos{{.*}}
-
-// test operator new replacement
-
-#include <new>
-#include <cstddef>
-#include <cstdlib>
-#include <cstdint>
-#include <cassert>
-#include <limits>
-
-#include "test_macros.h"
-
-constexpr auto OverAligned = __STDCPP_DEFAULT_NEW_ALIGNMENT__ * 2;
-
-bool A_constructed = false;
-
-struct alignas(OverAligned) A {
-    A() {A_constructed = true;}
-    ~A() {A_constructed = false;}
-};
-
-
-bool B_constructed = false;
-
-struct alignas(std::max_align_t) B
-{
-    std::max_align_t member;
-    B() {B_constructed = true;}
-    ~B() {B_constructed = false;}
-};
-
-int new_called = 0;
-
-alignas(OverAligned) char DummyData[OverAligned];
-
-void* operator new(std::size_t s, std::align_val_t a) TEST_THROW_SPEC(std::bad_alloc)
-{
-    assert(new_called == 0); // We already allocated
-    assert(s <= sizeof(DummyData));
-    assert(static_cast<std::size_t>(a) == OverAligned);
-    ++new_called;
-    void *Ret = DummyData;
-    DoNotOptimize(Ret);
-    return Ret;
-}
-
-void  operator delete(void* p, std::align_val_t) TEST_NOEXCEPT
-{
-    assert(new_called == 1);
-    --new_called;
-    assert(p == DummyData);
-    DoNotOptimize(DummyData);
-}
-
-
-int main(int, char**)
-{
-    {
-        A* ap = new A;
-        assert(ap);
-        assert(A_constructed);
-        assert(new_called);
-        delete ap;
-        assert(!A_constructed);
-        assert(!new_called);
-    }
-    {
-        B* bp = new B;
-        assert(bp);
-        assert(B_constructed);
-        assert(!new_called);
-        delete bp;
-        assert(!new_called);
-    }
-
-  return 0;
-}

libcxx/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_nothrow.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
-//
-//===----------------------------------------------------------------------===//
-
-// test operator new (nothrow)
-
-// asan and msan will not call the new handler.
-// UNSUPPORTED: sanitizer-new-delete
-
-#include <new>
-#include <cstddef>
-#include <cassert>
-#include <limits>
-
-#include "test_macros.h"
-
-int new_handler_called = 0;
-
-void my_new_handler()
-{
-    ++new_handler_called;
-    std::set_new_handler(0);
-}
-
-bool A_constructed = false;
-
-struct A
-{
-    A() {A_constructed = true;}
-    ~A() {A_constructed = false;}
-};
-
-int main(int, char**)
-{
-    std::set_new_handler(my_new_handler);
-#ifndef TEST_HAS_NO_EXCEPTIONS
-    try
-#endif
-    {
-        void* vp = operator new (std::numeric_limits<std::size_t>::max(), std::nothrow);
-        assert(new_handler_called == 1);
-        assert(vp == 0);
-    }
-#ifndef TEST_HAS_NO_EXCEPTIONS
-    catch (...)
-    {
-        assert(false);
-    }
-#endif
-    A* ap = new(std::nothrow) A;
-    assert(ap);
-    assert(A_constructed);
-    delete ap;
-    assert(!A_constructed);
-
-  return 0;
-}

libcxx/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_size.verify.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
-//
-//===----------------------------------------------------------------------===//
-
-// <new>
-
-// void* operator new(std::size_t);
-
-// UNSUPPORTED: c++03, c++11, c++14, c++17
-
-#include <new>
-
-void f() {
-    ::operator new(4); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
-}

libcxx/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_size_align.verify.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
-//
-//===----------------------------------------------------------------------===//
-
-// <new>
-
-// void* operator new(std::size_t, std::align_val_t);
-
-// UNSUPPORTED: c++03, c++11, c++14, c++17
-
-// Libcxx when built for z/OS doesn't contain the aligned allocation functions,
-// nor does the dynamic library shipped with z/OS.
-// UNSUPPORTED: target={{.+}}-zos{{.*}}
-
-// REQUIRES: -faligned-allocation
-// ADDITIONAL_COMPILE_FLAGS: -faligned-allocation
-
-#include <new>
-
-void f() {
-    ::operator new(4, std::align_val_t{4});  // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
-}

libcxx/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_size_align_nothrow.verify.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
-//
-//===----------------------------------------------------------------------===//
-
-// <new>
-
-// void* operator new(std::size_t, std::align_val_t, std::nothrow_t &);
-
-// UNSUPPORTED: c++03, c++11, c++14, c++17
-
-// Libcxx when built for z/OS doesn't contain the aligned allocation functions,
-// nor does the dynamic library shipped with z/OS.
-// UNSUPPORTED: target={{.+}}-zos{{.*}}
-
-// REQUIRES: -faligned-allocation
-// ADDITIONAL_COMPILE_FLAGS: -faligned-allocation
-
-#include <new>
-
-void f() {
-    ::operator new(4, std::align_val_t{4}, std::nothrow);  // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
-}

libcxx/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_size_nothrow.verify.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
-//
-//===----------------------------------------------------------------------===//
-
-// <new>
-
-// void* operator new(std::size_t, std::nothrow_t &);
-
-// UNSUPPORTED: c++03, c++11, c++14, c++17
-
-#include <new>
-
-void f() {
-    ::operator new(4, std::nothrow); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
-}

libcxx/test/std/language.support/support.dynamic/new.delete/new.delete.single/nodiscard.verify.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
+//
+//===----------------------------------------------------------------------===//
+
+// [[nodiscard]] void* operator new(std::size_t);
+// [[nodiscard]] void* operator new(std::size_t, std::nothrow_t const&);
+// [[nodiscard]] void* operator new(std::size_t, std::align_val_t);
+// [[nodiscard]] void* operator new(std::size_t, std::align_val_t, std::nothrow_t const&);
+
+// [[nodiscard]] is not supported at all in c++03
+// UNSUPPORTED: c++03
+
+// [[nodiscard]] enabled before C++20 in libc++ as an extension
+// UNSUPPORTED: (c++11 || c++14 || c++17) && !stdlib=libc++
+
+// We get availability markup errors when aligned allocation is missing
+// XFAIL: availability-aligned_allocation-missing
+
+// Libc++ when built for z/OS doesn't contain the aligned allocation functions,
+// nor does the dynamic library shipped with z/OS.
+// UNSUPPORTED: target={{.+}}-zos{{.*}}
+
+#include <new>
+
+#include "test_macros.h"
+
+void f() {
+    ::operator new(4); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
+    ::operator new(4, std::nothrow); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
+
+#if TEST_STD_VER >= 17
+    ::operator new(4, std::align_val_t{4});  // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
+    ::operator new(4, std::align_val_t{4}, std::nothrow);  // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
+#endif
+}

libcxx/test/std/language.support/support.dynamic/new.delete/types.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 TEST_STD_LANGUAGE_SUPPORT_SUPPORT_DYNAMIC_NEW_DELETE_TYPES_H
+#define TEST_STD_LANGUAGE_SUPPORT_SUPPORT_DYNAMIC_NEW_DELETE_TYPES_H
+
+#include <cstddef>
+
+#include "test_macros.h"
+
+struct LifetimeInformation {
+    void* address_constructed = nullptr;
+    void* address_destroyed = nullptr;
+};
+
+struct TrackLifetime {
+    TrackLifetime(LifetimeInformation& info) : info_(&info) {
+        info_->address_constructed = this;
+    }
+    ~TrackLifetime() {
+        info_->address_destroyed = this;
+    }
+    LifetimeInformation* info_;
+};
+
+#if TEST_STD_VER >= 17
+struct alignas(__STDCPP_DEFAULT_NEW_ALIGNMENT__ * 2) TrackLifetimeOverAligned {
+    TrackLifetimeOverAligned(LifetimeInformation& info) : info_(&info) {
+        info_->address_constructed = this;
+    }
+    ~TrackLifetimeOverAligned() {
+        info_->address_destroyed = this;
+    }
+    LifetimeInformation* info_;
+};
+
+struct alignas(std::max_align_t) TrackLifetimeMaxAligned {
+    TrackLifetimeMaxAligned(LifetimeInformation& info) : info_(&info) {
+        info_->address_constructed = this;
+    }
+    ~TrackLifetimeMaxAligned() {
+        info_->address_destroyed = this;
+    }
+    LifetimeInformation* info_;
+};
+
+struct alignas(__STDCPP_DEFAULT_NEW_ALIGNMENT__ * 2) OverAligned {
+
+};
+
+struct alignas(std::max_align_t) MaxAligned {
+
+};
+#endif // TEST_STD_VER >= 17
+
+#endif // TEST_STD_LANGUAGE_SUPPORT_SUPPORT_DYNAMIC_NEW_DELETE_TYPES_H

libcxx/test/support/test_macros.h

 #else
 #define TEST_NO_UNIQUE_ADDRESS
 #endif
 
 #ifdef _LIBCPP_SHORT_WCHAR
 #  define TEST_SHORT_WCHAR
 #endif
 
+// This is a temporary workaround for user-defined `operator new` definitions
+// not being picked up on Apple platforms in some circumstances. This is under
+// investigation and should be short-lived.
+#ifdef __APPLE__
+#  define TEST_WORKAROUND_BUG_109234844_WEAK __attribute__((weak))
+#else
+#  define TEST_WORKAROUND_BUG_109234844_WEAK /* nothing */
+#endif
+
 #endif // SUPPORT_TEST_MACROS_HPP