import of libc++ 6.0.0

1 files changed, 150 insertions, 93 deletions

diff --git a/lib/libcxx/src/new.cpp b/lib/libcxx/src/new.cpp
index f4f73d86803..e228a0d83d8 100644
--- a/lib/libcxx/src/new.cpp
+++ b/lib/libcxx/src/new.cpp
@@ -12,37 +12,61 @@
 #include <stdlib.h>
 
 #include "new"
+#include "include/atomic_support.h"
 
-#if defined(__APPLE__) && !defined(LIBCXXRT)
-    #include <cxxabi.h>
-
-    #ifndef _LIBCPPABI_VERSION
-        // On Darwin, there are two STL shared libraries and a lower level ABI
-        // shared library.  The global holding the current new handler is
-        // in the ABI library and named __cxa_new_handler.
-        #define __new_handler __cxxabiapple::__cxa_new_handler
-    #endif
-#else  // __APPLE__
-    #if defined(LIBCXXRT) || defined(LIBCXX_BUILDING_LIBCXXABI)
-        #include <cxxabi.h>
-    #endif  // defined(LIBCXX_BUILDING_LIBCXXABI)
-    #if !defined(_LIBCPPABI_VERSION) && !defined(__GLIBCXX__)
-        static std::new_handler __new_handler;
-    #endif  // _LIBCPPABI_VERSION
+#if defined(_LIBCPP_ABI_MICROSOFT)
+#if defined(_LIBCPP_NO_VCRUNTIME)
+#include "support/runtime/new_handler_fallback.ipp"
+#endif
+#elif defined(LIBCXX_BUILDING_LIBCXXABI)
+#include <cxxabi.h>
+#elif defined(LIBCXXRT)
+#include <cxxabi.h>
+#include "support/runtime/new_handler_fallback.ipp"
+#elif defined(__GLIBCXX__)
+// nothing todo
+#else
+# if defined(__APPLE__) && !defined(_LIBCPP_BUILDING_HAS_NO_ABI_LIBRARY)
+#   include <cxxabi.h> // FIXME: remove this once buildit is gone.
+# else
+#   include "support/runtime/new_handler_fallback.ipp"
+# endif
 #endif
 
+namespace std
+{
+
 #ifndef __GLIBCXX__
+const nothrow_t nothrow = {};
+#endif
+
+#ifndef LIBSTDCXX
+
+void
+__throw_bad_alloc()
+{
+#ifndef _LIBCPP_NO_EXCEPTIONS
+    throw bad_alloc();
+#else
+    _VSTD::abort();
+#endif
+}
+
+#endif // !LIBSTDCXX
+
+}  // std
+
+#if !defined(__GLIBCXX__) &&                                                   \
+    (!defined(_LIBCPP_ABI_MICROSOFT) || defined(_LIBCPP_NO_VCRUNTIME)) &&      \
+    !defined(_LIBCPP_DISABLE_NEW_DELETE_DEFINITIONS)
 
 // 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 _LIBCPP_NEW_DELETE_VIS
+_LIBCPP_WEAK
 void *
-operator new(std::size_t size)
-#if !__has_feature(cxx_noexcept)
-    throw(std::bad_alloc)
-#endif
+operator new(std::size_t size) _THROW_BAD_ALLOC
 {
     if (size == 0)
         size = 1;
@@ -64,7 +88,7 @@ operator new(std::size_t size)
     return p;
 }
 
-_LIBCPP_WEAK _LIBCPP_NEW_DELETE_VIS
+_LIBCPP_WEAK
 void*
 operator new(size_t size, const std::nothrow_t&) _NOEXCEPT
 {
@@ -83,17 +107,14 @@ operator new(size_t size, const std::nothrow_t&) _NOEXCEPT
     return p;
 }
 
-_LIBCPP_WEAK _LIBCPP_NEW_DELETE_VIS
+_LIBCPP_WEAK
 void*
-operator new[](size_t size)
-#if !__has_feature(cxx_noexcept)
-    throw(std::bad_alloc)
-#endif
+operator new[](size_t size) _THROW_BAD_ALLOC
 {
     return ::operator new(size);
 }
 
-_LIBCPP_WEAK _LIBCPP_NEW_DELETE_VIS
+_LIBCPP_WEAK
 void*
 operator new[](size_t size, const std::nothrow_t&) _NOEXCEPT
 {
@@ -112,7 +133,7 @@ operator new[](size_t size, const std::nothrow_t&) _NOEXCEPT
     return p;
 }
 
-_LIBCPP_WEAK _LIBCPP_NEW_DELETE_VIS
+_LIBCPP_WEAK
 void
 operator delete(void* ptr) _NOEXCEPT
 {
@@ -120,130 +141,166 @@ operator delete(void* ptr) _NOEXCEPT
         ::free(ptr);
 }
 
-_LIBCPP_WEAK _LIBCPP_NEW_DELETE_VIS
+_LIBCPP_WEAK
 void
 operator delete(void* ptr, const std::nothrow_t&) _NOEXCEPT
 {
     ::operator delete(ptr);
 }
 
-_LIBCPP_WEAK _LIBCPP_NEW_DELETE_VIS
+_LIBCPP_WEAK
 void
 operator delete(void* ptr, size_t) _NOEXCEPT
 {
     ::operator delete(ptr);
 }
 
-_LIBCPP_WEAK _LIBCPP_NEW_DELETE_VIS
+_LIBCPP_WEAK
 void
 operator delete[] (void* ptr) _NOEXCEPT
 {
     ::operator delete(ptr);
 }
 
-_LIBCPP_WEAK _LIBCPP_NEW_DELETE_VIS
+_LIBCPP_WEAK
 void
 operator delete[] (void* ptr, const std::nothrow_t&) _NOEXCEPT
 {
     ::operator delete[](ptr);
 }
 
-_LIBCPP_WEAK _LIBCPP_NEW_DELETE_VIS
+_LIBCPP_WEAK
 void
 operator delete[] (void* ptr, size_t) _NOEXCEPT
 {
     ::operator delete[](ptr);
 }
 
-#endif // !__GLIBCXX__
+#if !defined(_LIBCPP_HAS_NO_ALIGNED_ALLOCATION)
 
-namespace std
+_LIBCPP_WEAK
+void *
+operator new(std::size_t size, std::align_val_t alignment) _THROW_BAD_ALLOC
 {
-
-#ifndef __GLIBCXX__
-const nothrow_t nothrow = {};
+    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_LIKE)
+    while ((p = _aligned_malloc(size, static_cast<size_t>(alignment))) == nullptr)
+#else
+    while (::posix_memalign(&p, static_cast<size_t>(alignment), size) != 0)
 #endif
-
-#ifndef _LIBCPPABI_VERSION
-
-#ifndef __GLIBCXX__
-
-new_handler
-set_new_handler(new_handler handler) _NOEXCEPT
-{
-    return __sync_lock_test_and_set(&__new_handler, handler);
-}
-
-new_handler
-get_new_handler() _NOEXCEPT
-{
-    return __sync_fetch_and_add(&__new_handler, nullptr);
-}
-
-#endif // !__GLIBCXX__
-
-#ifndef LIBCXXRT
-
-bad_alloc::bad_alloc() _NOEXCEPT
-{
+    {
+        // 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 _LIBCPP_NO_EXCEPTIONS
+            throw std::bad_alloc();
+#else
+            p = nullptr; // posix_memalign doesn't initialize 'p' on failure
+            break;
+#endif
+        }
+    }
+    return p;
 }
 
-#ifndef __GLIBCXX__
-
-bad_alloc::~bad_alloc() _NOEXCEPT
+_LIBCPP_WEAK
+void*
+operator new(size_t size, std::align_val_t alignment, const std::nothrow_t&) _NOEXCEPT
 {
+    void* p = 0;
+#ifndef _LIBCPP_NO_EXCEPTIONS
+    try
+    {
+#endif  // _LIBCPP_NO_EXCEPTIONS
+        p = ::operator new(size, alignment);
+#ifndef _LIBCPP_NO_EXCEPTIONS
+    }
+    catch (...)
+    {
+    }
+#endif  // _LIBCPP_NO_EXCEPTIONS
+    return p;
 }
 
-const char*
-bad_alloc::what() const _NOEXCEPT
+_LIBCPP_WEAK
+void*
+operator new[](size_t size, std::align_val_t alignment) _THROW_BAD_ALLOC
 {
-    return "std::bad_alloc";
+    return ::operator new(size, alignment);
 }
 
-#endif // !__GLIBCXX__
-
-bad_array_new_length::bad_array_new_length() _NOEXCEPT
+_LIBCPP_WEAK
+void*
+operator new[](size_t size, std::align_val_t alignment, const std::nothrow_t&) _NOEXCEPT
 {
+    void* p = 0;
+#ifndef _LIBCPP_NO_EXCEPTIONS
+    try
+    {
+#endif  // _LIBCPP_NO_EXCEPTIONS
+        p = ::operator new[](size, alignment);
+#ifndef _LIBCPP_NO_EXCEPTIONS
+    }
+    catch (...)
+    {
+    }
+#endif  // _LIBCPP_NO_EXCEPTIONS
+    return p;
 }
 
-bad_array_new_length::~bad_array_new_length() _NOEXCEPT
+_LIBCPP_WEAK
+void
+operator delete(void* ptr, std::align_val_t) _NOEXCEPT
 {
+    if (ptr)
+#if defined(_LIBCPP_MSVCRT_LIKE)
+        ::_aligned_free(ptr);
+#else
+        ::free(ptr);
+#endif
 }
 
-const char*
-bad_array_new_length::what() const _NOEXCEPT
+_LIBCPP_WEAK
+void
+operator delete(void* ptr, std::align_val_t alignment, const std::nothrow_t&) _NOEXCEPT
 {
-    return "bad_array_new_length";
+    ::operator delete(ptr, alignment);
 }
 
-#endif //LIBCXXRT
-
-const char*
-bad_array_length::what() const _NOEXCEPT
+_LIBCPP_WEAK
+void
+operator delete(void* ptr, size_t, std::align_val_t alignment) _NOEXCEPT
 {
-    return "bad_array_length";
+    ::operator delete(ptr, alignment);
 }
 
-bad_array_length::bad_array_length() _NOEXCEPT
+_LIBCPP_WEAK
+void
+operator delete[] (void* ptr, std::align_val_t alignment) _NOEXCEPT
 {
+    ::operator delete(ptr, alignment);
 }
 
-bad_array_length::~bad_array_length() _NOEXCEPT
+_LIBCPP_WEAK
+void
+operator delete[] (void* ptr, std::align_val_t alignment, const std::nothrow_t&) _NOEXCEPT
 {
+    ::operator delete[](ptr, alignment);
 }
 
-#endif // _LIBCPPABI_VERSION
-
-#ifndef LIBSTDCXX
-
+_LIBCPP_WEAK
 void
-__throw_bad_alloc()
+operator delete[] (void* ptr, size_t, std::align_val_t alignment) _NOEXCEPT
 {
-#ifndef _LIBCPP_NO_EXCEPTIONS
-    throw bad_alloc();
-#endif
+    ::operator delete[](ptr, alignment);
 }
 
-#endif // !LIBSTDCXX
-
-}  // std
+#endif // !_LIBCPP_HAS_NO_ALIGNED_ALLOCATION
+#endif // !__GLIBCXX__ && (!_LIBCPP_ABI_MICROSOFT || _LIBCPP_NO_VCRUNTIME) && !_LIBCPP_DISABLE_NEW_DELETE_DEFINITIONS