FIGMA HACK FOR XCODE 15: Revert "[libc++] Fix the behavior of throwing operator new under -fno-exceptions (llvm#69498)"

This reverts commit 3145265.

This commit caused conflicts with Xcode 15's linker as described [here](https://issues.chromium.org/issues/326898585)

Author: jmcclellan-figma

libcxx/docs/ReleaseNotes/18.rst

@@ -239,29 +239,6 @@ LLVM 20
 ABI Affecting Changes
 ---------------------
 
-- When the shared/static library is built with ``-fno-exceptions``, the behavior of ``operator new`` was changed
-  to make it standards-conforming. In LLVM 17 and before, the throwing versions of ``operator new`` would return
-  ``nullptr`` upon failure to allocate, when the shared/static library was built with exceptions disabled. This
-  was non-conforming, since the throwing versions of ``operator new`` are never expected to return ``nullptr``, and
-  this non-conformance could actually lead to miscompiles in subtle cases.
-
-  Starting in LLVM 18, the throwing versions of ``operator new`` will abort the program when they fail to allocate
-  if the shared/static library has been built with ``-fno-exceptions``. This is consistent with the behavior of all
-  other potentially-throwing functions in the library, which abort the program instead of throwing when ``-fno-exceptions``
-  is used.
-
-  Furthermore, when the shared/static library is built with ``-fno-exceptions``, users who override the throwing
-  version of ``operator new`` will now need to also override the ``std::nothrow_t`` version of ``operator new`` if
-  they want to use it. Indeed, this is because there is no way to implement a conforming ``operator new(nothrow)``
-  from a conforming potentially-throwing ``operator new`` when compiled with ``-fno-exceptions``. In that case, using
-  ``operator new(nothrow)`` without overriding it explicitly but after overriding the throwing ``operator new`` will
-  result in an error.
-
-  Note that this change only impacts vendors/users that build the shared/static library themselves and pass
-  ``-DLIBCXX_ENABLE_EXCEPTIONS=OFF``, which is not the default configuration. If you are using the default
-  configuration of the library, the libc++ shared/static library will be built with exceptions enabled, and
-  there is no change between LLVM 17 and LLVM 18, even for users who build their own code using ``-fno-exceptions``.
-
 - The symbol of a non-visible function part of ``std::system_error`` was removed.
   This is not a breaking change as the private function ``__init`` was never referenced internally outside of the dylib.
 

libcxx/src/include/overridable_function.h

@@ -6,10 +6,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "include/overridable_function.h"
-#include <__assert>
 #include <__memory/aligned_alloc.h>
-#include <cstddef>
 #include <cstdlib>
 #include <new>
 
@@ -18,10 +15,6 @@
 // The code below is copied as-is into libc++abi's libcxxabi/src/stdlib_new_delete.cpp
 // file. The version in this file is the canonical one.
 
-inline void __throw_bad_alloc_shim() { std::__throw_bad_alloc(); }
-
-#  define _LIBCPP_ASSERT_SHIM(expr, str) _LIBCPP_ASSERT(expr, str)
-
 // ------------------ BEGIN COPY ------------------
 // Implement all new and delete operators as weak definitions
 // in this shared library, so that they can be overridden by programs
@@ -43,63 +36,41 @@ static void* operator_new_impl(std::size_t size) {
   return p;
 }
 
-_LIBCPP_MAKE_OVERRIDABLE_FUNCTION_DETECTABLE _LIBCPP_WEAK void* operator new(std::size_t size) _THROW_BAD_ALLOC {
+_LIBCPP_WEAK void* operator new(std::size_t size) _THROW_BAD_ALLOC {
   void* p = operator_new_impl(size);
+#  ifndef _LIBCPP_HAS_NO_EXCEPTIONS
   if (p == nullptr)
-    __throw_bad_alloc_shim();
+    throw std::bad_alloc();
+#  endif
   return p;
 }
 
 _LIBCPP_WEAK void* operator new(size_t size, const std::nothrow_t&) noexcept {
-#  ifdef _LIBCPP_HAS_NO_EXCEPTIONS
-#    if _LIBCPP_CAN_DETECT_OVERRIDDEN_FUNCTION
-  _LIBCPP_ASSERT_SHIM(
-      !std::__is_function_overridden(static_cast<void* (*)(std::size_t)>(&operator new)),
-      "libc++ was configured with exceptions disabled and `operator new(size_t)` has been overridden, "
-      "but `operator new(size_t, nothrow_t)` has not been overridden. This is problematic because "
-      "`operator new(size_t, nothrow_t)` must call `operator new(size_t)`, which will terminate in case "
-      "it fails to allocate, making it impossible for `operator new(size_t, nothrow_t)` to fulfill its "
-      "contract (since it should return nullptr upon failure). Please make sure you override "
-      "`operator new(size_t, nothrow_t)` as well.");
-#    endif
-
-  return operator_new_impl(size);
-#  else
   void* p = nullptr;
+#  ifndef _LIBCPP_HAS_NO_EXCEPTIONS
   try {
+#  endif // _LIBCPP_HAS_NO_EXCEPTIONS
     p = ::operator new(size);
+#  ifndef _LIBCPP_HAS_NO_EXCEPTIONS
   } catch (...) {
   }
+#  endif // _LIBCPP_HAS_NO_EXCEPTIONS
   return p;
-#  endif
 }
 
-_LIBCPP_MAKE_OVERRIDABLE_FUNCTION_DETECTABLE _LIBCPP_WEAK void* operator new[](size_t size) _THROW_BAD_ALLOC {
-  return ::operator new(size);
-}
+_LIBCPP_WEAK void* operator new[](size_t size) _THROW_BAD_ALLOC { return ::operator new(size); }
 
 _LIBCPP_WEAK void* operator new[](size_t size, const std::nothrow_t&) noexcept {
-#  ifdef _LIBCPP_HAS_NO_EXCEPTIONS
-#    if _LIBCPP_CAN_DETECT_OVERRIDDEN_FUNCTION
-  _LIBCPP_ASSERT_SHIM(
-      !std::__is_function_overridden(static_cast<void* (*)(std::size_t)>(&operator new[])),
-      "libc++ was configured with exceptions disabled and `operator new[](size_t)` has been overridden, "
-      "but `operator new[](size_t, nothrow_t)` has not been overridden. This is problematic because "
-      "`operator new[](size_t, nothrow_t)` must call `operator new[](size_t)`, which will terminate in case "
-      "it fails to allocate, making it impossible for `operator new[](size_t, nothrow_t)` to fulfill its "
-      "contract (since it should return nullptr upon failure). Please make sure you override "
-      "`operator new[](size_t, nothrow_t)` as well.");
-#    endif
-
-  return operator_new_impl(size);
-#  else
   void* p = nullptr;
+#  ifndef _LIBCPP_HAS_NO_EXCEPTIONS
   try {
+#  endif // _LIBCPP_HAS_NO_EXCEPTIONS
     p = ::operator new[](size);
+#  ifndef _LIBCPP_HAS_NO_EXCEPTIONS
   } catch (...) {
   }
+#  endif // _LIBCPP_HAS_NO_EXCEPTIONS
   return p;
-#  endif
 }
 
 _LIBCPP_WEAK void operator delete(void* ptr) noexcept { std::free(ptr); }
@@ -136,66 +107,43 @@ static void* operator_new_aligned_impl(std::size_t size, std::align_val_t alignm
   return p;
 }
 
-_LIBCPP_MAKE_OVERRIDABLE_FUNCTION_DETECTABLE _LIBCPP_WEAK void*
-operator new(std::size_t size, std::align_val_t alignment) _THROW_BAD_ALLOC {
+_LIBCPP_WEAK void* operator new(std::size_t size, std::align_val_t alignment) _THROW_BAD_ALLOC {
   void* p = operator_new_aligned_impl(size, alignment);
+#    ifndef _LIBCPP_HAS_NO_EXCEPTIONS
   if (p == nullptr)
-    __throw_bad_alloc_shim();
+    throw std::bad_alloc();
+#    endif
   return p;
 }
 
 _LIBCPP_WEAK void* operator new(size_t size, std::align_val_t alignment, const std::nothrow_t&) noexcept {
-#    ifdef _LIBCPP_HAS_NO_EXCEPTIONS
-#      if _LIBCPP_CAN_DETECT_OVERRIDDEN_FUNCTION
-  _LIBCPP_ASSERT_SHIM(
-      !std::__is_function_overridden(static_cast<void* (*)(std::size_t, std::align_val_t)>(&operator new)),
-      "libc++ was configured with exceptions disabled and `operator new(size_t, align_val_t)` has been overridden, "
-      "but `operator new(size_t, align_val_t, nothrow_t)` has not been overridden. This is problematic because "
-      "`operator new(size_t, align_val_t, nothrow_t)` must call `operator new(size_t, align_val_t)`, which will "
-      "terminate in case it fails to allocate, making it impossible for `operator new(size_t, align_val_t, nothrow_t)` "
-      "to fulfill its contract (since it should return nullptr upon failure). Please make sure you override "
-      "`operator new(size_t, align_val_t, nothrow_t)` as well.");
-#      endif
-
-  return operator_new_aligned_impl(size, alignment);
-#    else
   void* p = nullptr;
+#    ifndef _LIBCPP_HAS_NO_EXCEPTIONS
   try {
+#    endif // _LIBCPP_HAS_NO_EXCEPTIONS
     p = ::operator new(size, alignment);
+#    ifndef _LIBCPP_HAS_NO_EXCEPTIONS
   } catch (...) {
   }
+#    endif // _LIBCPP_HAS_NO_EXCEPTIONS
   return p;
-#    endif
 }
 
-_LIBCPP_MAKE_OVERRIDABLE_FUNCTION_DETECTABLE _LIBCPP_WEAK void*
-operator new[](size_t size, std::align_val_t alignment) _THROW_BAD_ALLOC {
+_LIBCPP_WEAK void* operator new[](size_t size, std::align_val_t alignment) _THROW_BAD_ALLOC {
   return ::operator new(size, alignment);
 }
 
 _LIBCPP_WEAK void* operator new[](size_t size, std::align_val_t alignment, const std::nothrow_t&) noexcept {
-#    ifdef _LIBCPP_HAS_NO_EXCEPTIONS
-#      if _LIBCPP_CAN_DETECT_OVERRIDDEN_FUNCTION
-  _LIBCPP_ASSERT_SHIM(
-      !std::__is_function_overridden(static_cast<void* (*)(std::size_t, std::align_val_t)>(&operator new[])),
-      "libc++ was configured with exceptions disabled and `operator new[](size_t, align_val_t)` has been overridden, "
-      "but `operator new[](size_t, align_val_t, nothrow_t)` has not been overridden. This is problematic because "
-      "`operator new[](size_t, align_val_t, nothrow_t)` must call `operator new[](size_t, align_val_t)`, which will "
-      "terminate in case it fails to allocate, making it impossible for `operator new[](size_t, align_val_t, "
-      "nothrow_t)` to fulfill its contract (since it should return nullptr upon failure). Please make sure you "
-      "override "
-      "`operator new[](size_t, align_val_t, nothrow_t)` as well.");
-#      endif
-
-  return operator_new_aligned_impl(size, alignment);
-#    else
   void* p = nullptr;
+#    ifndef _LIBCPP_HAS_NO_EXCEPTIONS
   try {
+#    endif // _LIBCPP_HAS_NO_EXCEPTIONS
     p = ::operator new[](size, alignment);
+#    ifndef _LIBCPP_HAS_NO_EXCEPTIONS
   } catch (...) {
   }
+#    endif // _LIBCPP_HAS_NO_EXCEPTIONS
   return p;
-#    endif
 }
 
 _LIBCPP_WEAK void operator delete(void* ptr, std::align_val_t) noexcept { std::__libcpp_aligned_free(ptr); }