[libc++] Make std::allocator always trivially default constructible

Author: philnik777

libcxx/docs/ReleaseNotes/22.rst

@@ -121,5 +121,9 @@ ABI Affecting Changes
 - ``ranges::iota_view`` is now aware of ``__int128``. This causes ``iota_view::difference_type`` to change from
   ``long long`` to ``__int128`` in some cases.
 
+- ``std::allocator`` is now trivially default constructible. The behaviour can be reverted by defining
+  ``_LIBCPP_DEPRECATED_ABI_NON_TRIVIAL_ALLOCATOR``. Please inform the libc++ team if you need this flag, since it will
+  be removed in LLVM 24 if there is no evidence that it's required.
+
 Build System Changes
 --------------------

libcxx/include/__memory/allocator.h

@@ -14,7 +14,6 @@
 #include <__cstddef/ptrdiff_t.h>
 #include <__cstddef/size_t.h>
 #include <__memory/addressof.h>
-#include <__memory/allocate_at_least.h>
 #include <__memory/allocator_traits.h>
 #include <__new/allocate.h>
 #include <__new/exceptions.h>
@@ -51,33 +50,21 @@ class allocator<void> {
 };
 #endif // _LIBCPP_STD_VER <= 17
 
-// This class provides a non-trivial default constructor to the class that derives from it
-// if the condition is satisfied.
-//
-// The second template parameter exists to allow giving a unique type to __non_trivial_if,
-// which makes it possible to avoid breaking the ABI when making this a base class of an
-// existing class. Without that, imagine we have classes D1 and D2, both of which used to
-// have no base classes, but which now derive from __non_trivial_if. The layout of a class
-// that inherits from both D1 and D2 will change because the two __non_trivial_if base
-// classes are not allowed to share the same address.
-//
-// By making those __non_trivial_if base classes unique, we work around this problem and
-// it is safe to start deriving from __non_trivial_if in existing classes.
-template <bool _Cond, class _Unique>
-struct __non_trivial_if {};
+template <bool, class _Unique>
+struct __non_trivially_default_constructible_if {};
 
 template <class _Unique>
-struct __non_trivial_if<true, _Unique> {
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR __non_trivial_if() _NOEXCEPT {}
+struct __non_trivially_default_constructible_if<true, _Unique> {
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR __non_trivially_default_constructible_if() {}
 };
 
-// allocator
-//
-// Note: For ABI compatibility between C++20 and previous standards, we make
-//       allocator<void> trivial in C++20.
-
 template <class _Tp>
-class allocator : private __non_trivial_if<!is_void<_Tp>::value, allocator<_Tp> > {
+class allocator
+// TODO(LLVM 24): Remove the opt-out
+#ifdef _LIBCPP_DEPRECATED_ABI_NON_TRIVIAL_ALLOCATOR
+  : __non_trivially_default_constructible_if<!is_void<_Tp>::value, allocator<_Tp> >
+#endif
+{
   static_assert(!is_const<_Tp>::value, "std::allocator does not support const types");
   static_assert(!is_volatile<_Tp>::value, "std::allocator does not support volatile types");
 

libcxx/test/libcxx/memory/allocator_triviality.compile.pass.cpp

@@ -0,0 +1,23 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+//
+
+// Make sure that std::allocator<T> is trivial.
+
+// <memory>
+
+#include <memory>
+#include <string>
+
+static_assert(std::is_trivially_default_constructible<std::allocator<char>>::value, "");
+static_assert(std::is_trivially_default_constructible<std::allocator<std::string>>::value, "");
+static_assert(std::is_trivially_default_constructible<std::allocator<void>>::value, "");
+
+static_assert(std::is_trivially_copyable<std::allocator<char>>::value, "");
+static_assert(std::is_trivially_copyable<std::allocator<std::string>>::value, "");
+static_assert(std::is_trivially_copyable<std::allocator<void>>::value, "");

libcxx/test/libcxx/memory/allocator_triviality.deprecated_abi.compile.pass.cpp

@@ -0,0 +1,26 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+//
+
+// Make sure that std::allocator<T> is not trivial if _LIBCPP_DEPRECATED_ABI_NON_TRIVIAL_ALLOCATOR if defined.
+// std::allocator<void> _should_ still be trivial, since it has always been trivial.
+
+// <memory>
+
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEPRECATED_ABI_NON_TRIVIAL_ALLOCATOR
+
+#include <memory>
+#include <string>
+
+static_assert(!std::is_trivially_default_constructible<std::allocator<char>>::value, "");
+static_assert(!std::is_trivially_default_constructible<std::allocator<std::string>>::value, "");
+static_assert(std::is_trivially_default_constructible<std::allocator<void>>::value, "");
+
+static_assert(std::is_trivially_copyable<std::allocator<char>>::value, "");
+static_assert(std::is_trivially_copyable<std::allocator<std::string>>::value, "");
+static_assert(std::is_trivially_copyable<std::allocator<void>>::value, "");

libcxx/test/libcxx/memory/allocator_void.trivial.compile.pass.cpp

@@ -12,9 +12,6 @@
 // template <class T, class... Args>
 //   constexpr optional<T> make_optional(Args&&... args);
 
-// GCC crashes on this file, see https://gcc.gnu.org/bugzilla/show_bug.cgi?id=120577
-// XFAIL: gcc-15
-
 #include <cassert>
 #include <memory>
 #include <optional>

libcxx/test/std/utilities/optional/optional.specalg/make_optional_explicit.pass.cpp

@@ -12,9 +12,6 @@
 // template <class T, class U, class... Args>
 //   constexpr optional<T> make_optional(initializer_list<U> il, Args&&... args);
 
-// GCC crashes on this file, see https://gcc.gnu.org/bugzilla/show_bug.cgi?id=120577
-// XFAIL: gcc-15
-
 #include <cassert>
 #include <memory>
 #include <optional>