[libc++abi] Update new/delete definitions to match libc++

[EricWF]

Summary

Currently both libc++ and libc++abi provide definitions for new/delete. However libc++abi's definitions haven't been updated to include aligned new/delete or sized deallocation.
I don't see any reason why libc++abi shouldn't provide these newer overloads.

This patch copies libc++'s implementation of new/delete into libc++abi so that it's now up to date.

After applying this patch I plan to fix a longstanding bug where both libc++ and libc++abi provide definitions for new/delete.

[mehdi_amini]

LGTM.

(It seems that having libc++ and libc++abi in the same repo would help sharing code like this)

[jroelofs]

In D30514#690318, @mehdi_amini wrote:

LGTM.

(It seems that having libc++ and libc++abi in the same repo would help sharing code like this)

I think it would be a step backwards in terms of opening things up for layering violations. We already have one unavoidable one that comes from they way typeinfo matching works in ARM EHABI... I'd be afraid of it getting worse.

[mehdi_amini]

In D30514#690702, @jroelofs wrote:

In D30514#690318, @mehdi_amini wrote:

LGTM.

(It seems that having libc++ and libc++abi in the same repo would help sharing code like this)

I think it would be a step backwards in terms of opening things up for layering violations. We already have one unavoidable one that comes from they way typeinfo matching works in ARM EHABI... I'd be afraid of it getting worse.

I don't see why: this is about discipline and bots. Enforcing layering using separate repository sounds awful to me.

src/stdlib_new_delete.cpp

-//===------------------------ cxa_new_delete.cpp --------------------------===//
+//===--------------------- stdlib_new_delete.cpp --------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //
 // This file implements the new and delete operators.
 //===----------------------------------------------------------------------===//
 
 #define _LIBCPP_BUILDING_NEW
-
+#define _LIBCPP_BUILDING_LIBRARY
 #include "__cxxabi_config.h"
 #include <new>
 #include <cstdlib>
 
-#if !defined(_THROW_BAD_ALLOC) || !defined(_NOEXCEPT)
-#error _THROW_BAD_ALLOC and _NOEXCEPT libc++ macros must already be defined \
-       by libc++.
+#if !defined(_THROW_BAD_ALLOC) || !defined(_NOEXCEPT) || !defined(_LIBCXXABI_WEAK)
+#error The _THROW_BAD_ALLOC, _NOEXCEPT, and _LIBCXXABI_WEAK libc++ macros must \
+       already be defined by libc++.
 #endif
+// 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.
 
-/*
-[new.delete.single]
-
-* Executes a loop: Within the loop, the function first attempts to allocate
-  the requested storage. Whether the attempt involves a call to the Standard C
-  library function malloc is unspecified.
-
-* Returns a pointer to the allocated storage if the attempt is successful.
-  Otherwise, if the current new_handler (18.6.2.5) is a null pointer value,
-  throws bad_alloc.
-
-* Otherwise, the function calls the current new_handler function (18.6.2.3).
-  If the called function returns, the loop repeats.
-
-* The loop terminates when an attempt to allocate the requested storage is
-  successful or when a called new_handler function does not return.
-*/
 _LIBCXXABI_WEAK
 void *
 operator new(std::size_t size) _THROW_BAD_ALLOC
 {
     if (size == 0)
         size = 1;
     void* p;
-    while ((p = std::malloc(size)) == 0)
+    while ((p = ::malloc(size)) == 0)
     {
+        // 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
             throw std::bad_alloc();
 #else
             break;
 #endif
     }
     return p;
 }
 
-/*
-Note:  The relationships among these operators is both carefully considered
-and standard in C++11.  Please do not change them without fully understanding
-the consequences of doing so.  Reference:
-http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2158.html
-*/
-/*
-[new.delete.single]
-
-Calls operator new(size). If the call returns normally, returns the result of
-that call. Otherwise, returns a null pointer.
-*/
 _LIBCXXABI_WEAK
 void*
 operator new(size_t size, const std::nothrow_t&) _NOEXCEPT
 {
     void* p = 0;
 #ifndef _LIBCXXABI_NO_EXCEPTIONS
     try
     {
-#endif
+#endif  // _LIBCXXABI_NO_EXCEPTIONS
         p = ::operator new(size);
 #ifndef _LIBCXXABI_NO_EXCEPTIONS
     }
     catch (...)
     {
     }
-#endif
+#endif  // _LIBCXXABI_NO_EXCEPTIONS
     return p;
 }
 
-/*
-[new.delete.array]
-
-Returns operator new(size).
-*/
 _LIBCXXABI_WEAK
 void*
 operator new[](size_t size) _THROW_BAD_ALLOC
 {
     return ::operator new(size);
 }
 
-/*
-[new.delete.array]
-
-Calls operator new[](size). If the call returns normally, returns the result
-of that call. Otherwise, returns a null pointer.
-*/
 _LIBCXXABI_WEAK
 void*
 operator new[](size_t size, const std::nothrow_t&) _NOEXCEPT
 {
     void* p = 0;
 #ifndef _LIBCXXABI_NO_EXCEPTIONS
     try
     {
-#endif
+#endif  // _LIBCXXABI_NO_EXCEPTIONS
         p = ::operator new[](size);
 #ifndef _LIBCXXABI_NO_EXCEPTIONS
     }
     catch (...)
     {
     }
-#endif
+#endif  // _LIBCXXABI_NO_EXCEPTIONS
     return p;
 }
 
-/*
-[new.delete.single]
-
-If ptr is null, does nothing. Otherwise, reclaims the storage allocated by the
-earlier call to operator new.
-*/
 _LIBCXXABI_WEAK
 void
 operator delete(void* ptr) _NOEXCEPT
 {
     if (ptr)
-        std::free(ptr);
+        ::free(ptr);
 }
 
-/*
-[new.delete.single]
-
-calls operator delete(ptr)
-*/
 _LIBCXXABI_WEAK
 void
 operator delete(void* ptr, const std::nothrow_t&) _NOEXCEPT
 {
     ::operator delete(ptr);
 }
 
-/*
-[new.delete.array]
+_LIBCXXABI_WEAK
+void
+operator delete(void* ptr, size_t) _NOEXCEPT
+{
+    ::operator delete(ptr);
+}
 
-Calls operator delete(ptr)
-*/
 _LIBCXXABI_WEAK
 void
 operator delete[] (void* ptr) _NOEXCEPT
 {
     ::operator delete(ptr);
 }
 
-/*
-[new.delete.array]
-
-calls operator delete[](ptr)
-*/
 _LIBCXXABI_WEAK
 void
 operator delete[] (void* ptr, const std::nothrow_t&) _NOEXCEPT
 {
     ::operator delete[](ptr);
 }
+
+_LIBCXXABI_WEAK
+void
+operator delete[] (void* ptr, size_t) _NOEXCEPT
+{
+    ::operator delete[](ptr);
+}
+
+#if !defined(_LIBCPP_HAS_NO_ALIGNED_ALLOCATION)
+
+_LIBCXXABI_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*));
+    void* p;
+#if defined(_LIBCPP_MSVCRT)
+    while ((p = _aligned_malloc(size, static_cast<size_t>(alignment))) == nullptr)
+#else
+    while (::posix_memalign(&p, static_cast<size_t>(alignment), size) != 0)
+#endif
+    {
+        // If posix_memalign 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
+            throw std::bad_alloc();
+#else
+            p = nullptr; // posix_memalign doesn't initialize 'p' on failure
+            break;
+#endif
+        }
+    }
+    return p;
+}
+
+_LIBCXXABI_WEAK
+void*
+operator new(size_t size, std::align_val_t alignment, const std::nothrow_t&) _NOEXCEPT
+{
+    void* p = 0;
+#ifndef _LIBCXXABI_NO_EXCEPTIONS
+    try
+    {
+#endif  // _LIBCXXABI_NO_EXCEPTIONS
+        p = ::operator new(size, alignment);
+#ifndef _LIBCXXABI_NO_EXCEPTIONS
+    }
+    catch (...)
+    {
+    }
+#endif  // _LIBCXXABI_NO_EXCEPTIONS
+    return p;
+}
+
+_LIBCXXABI_WEAK
+void*
+operator new[](size_t size, std::align_val_t alignment) _THROW_BAD_ALLOC
+{
+    return ::operator new(size, alignment);
+}
+
+_LIBCXXABI_WEAK
+void*
+operator new[](size_t size, std::align_val_t alignment, const std::nothrow_t&) _NOEXCEPT
+{
+    void* p = 0;
+#ifndef _LIBCXXABI_NO_EXCEPTIONS
+    try
+    {
+#endif  // _LIBCXXABI_NO_EXCEPTIONS
+        p = ::operator new[](size, alignment);
+#ifndef _LIBCXXABI_NO_EXCEPTIONS
+    }
+    catch (...)
+    {
+    }
+#endif  // _LIBCXXABI_NO_EXCEPTIONS
+    return p;
+}
+
+_LIBCXXABI_WEAK
+void
+operator delete(void* ptr, std::align_val_t) _NOEXCEPT
+{
+    if (ptr)
+#if defined(_LIBCPP_MSVCRT)
+        ::_aligned_free(ptr);
+#else
+        ::free(ptr);
+#endif
+}
+
+_LIBCXXABI_WEAK
+void
+operator delete(void* ptr, std::align_val_t alignment, const std::nothrow_t&) _NOEXCEPT
+{
+    ::operator delete(ptr, alignment);
+}
+
+_LIBCXXABI_WEAK
+void
+operator delete(void* ptr, size_t, std::align_val_t alignment) _NOEXCEPT
+{
+    ::operator delete(ptr, alignment);
+}
+
+_LIBCXXABI_WEAK
+void
+operator delete[] (void* ptr, std::align_val_t alignment) _NOEXCEPT
+{
+    ::operator delete(ptr, alignment);
+}
+
+_LIBCXXABI_WEAK
+void
+operator delete[] (void* ptr, std::align_val_t alignment, const std::nothrow_t&) _NOEXCEPT
+{
+    ::operator delete[](ptr, alignment);
+}
+
+_LIBCXXABI_WEAK
+void
+operator delete[] (void* ptr, size_t, std::align_val_t alignment) _NOEXCEPT
+{
+    ::operator delete[](ptr, alignment);
+}
+
+#endif // !_LIBCPP_HAS_NO_ALIGNED_ALLOCATION