[libc++] Make libc++ and libc++abi's definitions of operator new be exact copies

[ldionne]

Summary

This allows mechanically copying any changes made to operator new
from libc++ into libc++abi as-is. This is also a step towards
de-duplicating this code entirely.

libcxx/src/new.cpp

 #endif // !LIBSTDCXX
 
 }  // std
 
 #if !defined(__GLIBCXX__) &&                                                   \
     !defined(_LIBCPP_ABI_VCRUNTIME) &&      \
     !defined(_LIBCPP_DISABLE_NEW_DELETE_DEFINITIONS)
 
+// 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.
+
+// ------------------ BEGIN COPY ------------------
 // Implement all new and delete operators as weak definitions
 // in this shared library, so that they can be overridden by programs
 // that define non-weak copies of the functions.
 
 _LIBCPP_WEAK
 void *
 operator new(std::size_t size) _THROW_BAD_ALLOC
 {

 _LIBCPP_WEAK
 void
 operator delete[] (void* ptr, size_t, std::align_val_t alignment) noexcept
 {
     ::operator delete[](ptr, alignment);
 }
 
 #endif // !_LIBCPP_HAS_NO_LIBRARY_ALIGNED_ALLOCATION
+// ------------------ END COPY ------------------
+
 #endif // !__GLIBCXX__ && !_LIBCPP_ABI_VCRUNTIME && !_LIBCPP_DISABLE_NEW_DELETE_DEFINITIONS

libcxxabi/src/stdlib_new_delete.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
 //
-//
-// This file implements the new and delete operators.
 //===----------------------------------------------------------------------===//
 
 #include "__cxxabi_config.h"
 #include <__memory/aligned_alloc.h>
 #include <cstdlib>
 #include <new>
 
-#if !defined(_THROW_BAD_ALLOC) || !defined(_LIBCXXABI_WEAK)
-#error The _THROW_BAD_ALLOC and _LIBCXXABI_WEAK libc++ macros must \
-       already be defined by libc++.
+// Perform a few sanity checks on libc++ and libc++abi macros to ensure that
+// the code below can be an exact copy of the code in libcxx/src/new.cpp.
+#if !defined(_THROW_BAD_ALLOC)
+#  error The _THROW_BAD_ALLOC macro should be already defined by libc++
+#endif
+
+#ifndef _LIBCPP_WEAK
+#  error The _LIBCPP_WEAK macro should be already defined by libc++
 #endif
+
+#if defined(_LIBCXXABI_NO_EXCEPTIONS) != defined(_LIBCPP_HAS_NO_EXCEPTIONS)
+#  error libc++ and libc++abi seem to disagree on whether exceptions are enabled
+#endif
+
+// ------------------ BEGIN COPY ------------------
 // Implement all new and delete operators as weak definitions
 // in this shared library, so that they can be overridden by programs
 // that define non-weak copies of the functions.
 
-_LIBCXXABI_WEAK
+_LIBCPP_WEAK
 void *
 operator new(std::size_t size) _THROW_BAD_ALLOC
 {
     if (size == 0)
         size = 1;
     void* p;
     while ((p = ::malloc(size)) == nullptr)
     {
         // If malloc fails and there is a new_handler,
         // call it to try free up memory.
         std::new_handler nh = std::get_new_handler();
         if (nh)
             nh();
         else
-#ifndef _LIBCXXABI_NO_EXCEPTIONS
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
             throw std::bad_alloc();
 #else
             break;
 #endif
     }
     return p;
 }
 
-_LIBCXXABI_WEAK
+_LIBCPP_WEAK
 void*
 operator new(size_t size, const std::nothrow_t&) noexcept
 {
     void* p = nullptr;
-#ifndef _LIBCXXABI_NO_EXCEPTIONS
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
     try
     {
-#endif // _LIBCXXABI_NO_EXCEPTIONS
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
         p = ::operator new(size);
-#ifndef _LIBCXXABI_NO_EXCEPTIONS
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
     }
     catch (...)
     {
     }
-#endif // _LIBCXXABI_NO_EXCEPTIONS
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
     return p;
 }
 
-_LIBCXXABI_WEAK
+_LIBCPP_WEAK
 void*
 operator new[](size_t size) _THROW_BAD_ALLOC
 {
     return ::operator new(size);
 }
 
-_LIBCXXABI_WEAK
+_LIBCPP_WEAK
 void*
 operator new[](size_t size, const std::nothrow_t&) noexcept
 {
     void* p = nullptr;
-#ifndef _LIBCXXABI_NO_EXCEPTIONS
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
     try
     {
-#endif // _LIBCXXABI_NO_EXCEPTIONS
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
         p = ::operator new[](size);
-#ifndef _LIBCXXABI_NO_EXCEPTIONS
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
     }
     catch (...)
     {
     }
-#endif // _LIBCXXABI_NO_EXCEPTIONS
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
     return p;
 }
 
-_LIBCXXABI_WEAK
+_LIBCPP_WEAK
 void
 operator delete(void* ptr) noexcept
 {
     ::free(ptr);
 }
 
-_LIBCXXABI_WEAK
+_LIBCPP_WEAK
 void
 operator delete(void* ptr, const std::nothrow_t&) noexcept
 {
     ::operator delete(ptr);
 }
 
-_LIBCXXABI_WEAK
+_LIBCPP_WEAK
 void
 operator delete(void* ptr, size_t) noexcept
 {
     ::operator delete(ptr);
 }
 
-_LIBCXXABI_WEAK
+_LIBCPP_WEAK
 void
 operator delete[] (void* ptr) noexcept
 {
     ::operator delete(ptr);
 }
 
-_LIBCXXABI_WEAK
+_LIBCPP_WEAK
 void
 operator delete[] (void* ptr, const std::nothrow_t&) noexcept
 {
     ::operator delete[](ptr);
 }
 
-_LIBCXXABI_WEAK
+_LIBCPP_WEAK
 void
 operator delete[] (void* ptr, size_t) noexcept
 {
     ::operator delete[](ptr);
 }
 
 #if !defined(_LIBCPP_HAS_NO_LIBRARY_ALIGNED_ALLOCATION)
 
-_LIBCXXABI_WEAK
+_LIBCPP_WEAK
 void *
 operator new(std::size_t size, std::align_val_t alignment) _THROW_BAD_ALLOC
 {
     if (size == 0)
         size = 1;
     if (static_cast<size_t>(alignment) < sizeof(void*))
       alignment = std::align_val_t(sizeof(void*));
 
     // Try allocating memory. If allocation fails and there is a new_handler,
     // call it to try free up memory, and try again until it succeeds, or until
     // the new_handler decides to terminate.
     //
     // If allocation fails and there is no new_handler, we throw bad_alloc
     // (or return nullptr if exceptions are disabled).
     void* p;
     while ((p = std::__libcpp_aligned_alloc(static_cast<std::size_t>(alignment), size)) == nullptr)
     {
         std::new_handler nh = std::get_new_handler();
         if (nh)
             nh();
         else {
-#ifndef _LIBCXXABI_NO_EXCEPTIONS
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
             throw std::bad_alloc();
 #else
             break;
 #endif
         }
     }
     return p;
 }
 
-_LIBCXXABI_WEAK
+_LIBCPP_WEAK
 void*
 operator new(size_t size, std::align_val_t alignment, const std::nothrow_t&) noexcept
 {
     void* p = nullptr;
-#ifndef _LIBCXXABI_NO_EXCEPTIONS
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
     try
     {
-#endif // _LIBCXXABI_NO_EXCEPTIONS
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
         p = ::operator new(size, alignment);
-#ifndef _LIBCXXABI_NO_EXCEPTIONS
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
     }
     catch (...)
     {
     }
-#endif // _LIBCXXABI_NO_EXCEPTIONS
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
     return p;
 }
 
-_LIBCXXABI_WEAK
+_LIBCPP_WEAK
 void*
 operator new[](size_t size, std::align_val_t alignment) _THROW_BAD_ALLOC
 {
     return ::operator new(size, alignment);
 }
 
-_LIBCXXABI_WEAK
+_LIBCPP_WEAK
 void*
 operator new[](size_t size, std::align_val_t alignment, const std::nothrow_t&) noexcept
 {
     void* p = nullptr;
-#ifndef _LIBCXXABI_NO_EXCEPTIONS
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
     try
     {
-#endif // _LIBCXXABI_NO_EXCEPTIONS
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
         p = ::operator new[](size, alignment);
-#ifndef _LIBCXXABI_NO_EXCEPTIONS
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
     }
     catch (...)
     {
     }
-#endif // _LIBCXXABI_NO_EXCEPTIONS
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
     return p;
 }
 
-_LIBCXXABI_WEAK
+_LIBCPP_WEAK
 void
 operator delete(void* ptr, std::align_val_t) noexcept
 {
     std::__libcpp_aligned_free(ptr);
 }
 
-_LIBCXXABI_WEAK
+_LIBCPP_WEAK
 void
 operator delete(void* ptr, std::align_val_t alignment, const std::nothrow_t&) noexcept
 {
     ::operator delete(ptr, alignment);
 }
 
-_LIBCXXABI_WEAK
+_LIBCPP_WEAK
 void
 operator delete(void* ptr, size_t, std::align_val_t alignment) noexcept
 {
     ::operator delete(ptr, alignment);
 }
 
-_LIBCXXABI_WEAK
+_LIBCPP_WEAK
 void
 operator delete[] (void* ptr, std::align_val_t alignment) noexcept
 {
     ::operator delete(ptr, alignment);
 }
 
-_LIBCXXABI_WEAK
+_LIBCPP_WEAK
 void
 operator delete[] (void* ptr, std::align_val_t alignment, const std::nothrow_t&) noexcept
 {
     ::operator delete[](ptr, alignment);
 }
 
-_LIBCXXABI_WEAK
+_LIBCPP_WEAK
 void
 operator delete[] (void* ptr, size_t, std::align_val_t alignment) noexcept
 {
     ::operator delete[](ptr, alignment);
 }
 
 #endif // !_LIBCPP_HAS_NO_LIBRARY_ALIGNED_ALLOCATION
+// ------------------ END COPY ------------------