Add exception handling for new operator

The new operator in the snmalloc did not throw exceptions in the case of
allocation failure.  Moreover, it was not possible to override the
behaviour of the failure of the new operator using the
std::set_new_handler function.

This commit adds the necessary code to the snmalloc new operator to
throw std::bad_alloc when the allocation fails. It also allows the
std::set_new_handler function to be used to set a custom handler for
allocation failures.

Author: mjp41

CMakeLists.txt

@@ -379,7 +379,7 @@ endif()
 function(add_warning_flags name)
   target_compile_options(${name} PRIVATE
     $<$<CXX_COMPILER_ID:MSVC>:/Zi /W4 /WX /wd4127 /wd4324 /wd4201>
-    $<$<NOT:$<OR:$<CXX_COMPILER_ID:MSVC>,$<STREQUAL:${CMAKE_CXX_SIMULATE_ID},MSVC>>>:-fno-exceptions -fno-rtti -Wall -Wextra -Werror -Wundef>
+    $<$<NOT:$<OR:$<CXX_COMPILER_ID:MSVC>,$<STREQUAL:${CMAKE_CXX_SIMULATE_ID},MSVC>>>:-fno-rtti -Wall -Wextra -Werror -Wundef>
     $<$<CXX_COMPILER_ID:Clang>:-Wsign-conversion -Wconversion>)
   target_link_options(${name} PRIVATE 
     $<$<BOOL:${SNMALLOC_LINKER_SUPPORT_NO_ALLOW_SHLIB_UNDEF}>:-Wl,--no-undefined>
@@ -540,13 +540,13 @@ endif()
       # If the compiler supports excluding the C++ stdlib implementation, use
       # it.  Otherwise, fall back to linking the library as if it were C, which
       # has roughly the same effect.
-      if (NOT ${SNMALLOC_CLEANUP} STREQUAL CXX11_DESTRUCTORS)
-        if (SNMALLOC_LINKER_SUPPORT_NOSTDLIBXX)
-          target_link_options(${name} PRIVATE -nostdlib++)
-        else()
-          set_target_properties(${name} PROPERTIES LINKER_LANGUAGE C)
-        endif()
-      endif()
+      # if (NOT ${SNMALLOC_CLEANUP} STREQUAL CXX11_DESTRUCTORS)
+      #   if (SNMALLOC_LINKER_SUPPORT_NOSTDLIBXX)
+      #     target_link_options(${name} PRIVATE -nostdlib++)
+      #   else()
+      #     set_target_properties(${name} PROPERTIES LINKER_LANGUAGE C)
+      #   endif()
+      # endif()
       # Remove all the duplicate new/malloc and free/delete definitions
       target_link_options(${name} PRIVATE $<$<BOOL:${LLD_WORKS}>:$<$<BOOL:${SNMALLOC_LINK_ICF}>:-Wl,--icf=all> -fuse-ld=lld>)
     endif()

src/snmalloc/override/new.cc

@@ -20,24 +20,90 @@
 
 // only define these if we are not using the vendored STL
 #ifndef SNMALLOC_USE_SELF_VENDORED_STL
+
+namespace snmalloc
+{
+  template<bool ShouldThrow = true>
+  class SetHandlerContinuations
+  {
+  public:
+    static void* success(void* p, size_t size, bool secondary_allocator = false)
+    {
+      UNUSED(secondary_allocator, size);
+      SNMALLOC_ASSERT(p != nullptr);
+
+      SNMALLOC_ASSERT(
+        secondary_allocator ||
+        is_start_of_object(size_to_sizeclass_full(size), address_cast(p)));
+
+      return p;
+    }
+
+    static void* failure(size_t size)
+    {
+      UNUSED(size);
+
+      auto new_handler = std::get_new_handler();
+      if (new_handler != nullptr)
+      {
+        if constexpr (ShouldThrow)
+        {
+          try
+          {
+            // Call the new handler, which may throw an exception.
+            new_handler();
+          }
+          catch (...)
+          {
+            // If the new handler throws, we just return nullptr.
+            return nullptr;
+          }
+        }
+        // Retry now new_handler has been called.
+        // I dislike the unbounded retrying here, but that seems to be what
+        // other implementations do.
+        return snmalloc::alloc<SetHandlerContinuations<ShouldThrow>>(size);
+      }
+
+      if constexpr (ShouldThrow)
+      {
+        // Throw std::bad_alloc on failure.
+        throw std::bad_alloc();
+      }
+      else
+      {
+        // If we are here, then the allocation failed.
+        // Set errno to ENOMEM, as per the C standard.
+        errno = ENOMEM;
+
+        // Return nullptr on failure.
+        return nullptr;
+      }
+    }
+  };
+
+  using NoThrow = SetHandlerContinuations<false>;
+  using Throw = SetHandlerContinuations<true>;
+} // namespace snmalloc
+
 void* operator new(size_t size)
 {
-  return snmalloc::libc::malloc(size);
+  return snmalloc::alloc<snmalloc::Throw>(size);
 }
 
 void* operator new[](size_t size)
 {
-  return snmalloc::libc::malloc(size);
+  return snmalloc::alloc<snmalloc::Throw>(size);
 }
 
 void* operator new(size_t size, std::nothrow_t&)
 {
-  return snmalloc::libc::malloc(size);
+  return snmalloc::alloc<snmalloc::NoThrow>(size);
 }
 
 void* operator new[](size_t size, std::nothrow_t&)
 {
-  return snmalloc::libc::malloc(size);
+  return snmalloc::alloc<snmalloc::NoThrow>(size);
 }
 
 void operator delete(void* p) EXCEPTSPEC
@@ -73,25 +139,25 @@ void operator delete[](void* p, std::nothrow_t&)
 void* operator new(size_t size, std::align_val_t val)
 {
   size = snmalloc::aligned_size(size_t(val), size);
-  return snmalloc::libc::malloc(size);
+  return snmalloc::alloc<snmalloc::Throw>(size);
 }
 
 void* operator new[](size_t size, std::align_val_t val)
 {
   size = snmalloc::aligned_size(size_t(val), size);
-  return snmalloc::libc::malloc(size);
+  return snmalloc::alloc<snmalloc::Throw>(size);
 }
 
 void* operator new(size_t size, std::align_val_t val, std::nothrow_t&)
 {
   size = snmalloc::aligned_size(size_t(val), size);
-  return snmalloc::libc::malloc(size);
+  return snmalloc::alloc<snmalloc::NoThrow>(size);
 }
 
 void* operator new[](size_t size, std::align_val_t val, std::nothrow_t&)
 {
   size = snmalloc::aligned_size(size_t(val), size);
-  return snmalloc::libc::malloc(size);
+  return snmalloc::alloc<snmalloc::NoThrow>(size);
 }
 
 void operator delete(void* p, std::align_val_t) EXCEPTSPEC

src/test/func/miracle_ptr/miracle_ptr.cc

@@ -18,9 +18,27 @@ int main()
 #  include <atomic>
 #  include <iostream>
 #  include <memory>
+#  include <new>
 #  include <snmalloc/backend/globalconfig.h>
 #  include <snmalloc/snmalloc_core.h>
 
+// This code makes the delete overloads build with the correct noexcept spec.
+#  ifdef _WIN32
+#    ifdef __clang__
+#      define EXCEPTSPEC noexcept
+#    else
+#      define EXCEPTSPEC
+#    endif
+#  else
+#    ifdef _GLIBCXX_USE_NOEXCEPT
+#      define EXCEPTSPEC _GLIBCXX_USE_NOEXCEPT
+#    elif defined(_NOEXCEPT)
+#      define EXCEPTSPEC _NOEXCEPT
+#    else
+#      define EXCEPTSPEC
+#    endif
+#  endif
+
 namespace snmalloc
 {
   // Instantiate the allocator with a client meta data provider that uses an
@@ -170,12 +188,12 @@ void* operator new(size_t size)
   return snmalloc::miracle::malloc(size);
 }
 
-void operator delete(void* p)
+void operator delete(void* p) EXCEPTSPEC
 {
   snmalloc::miracle::free(p);
 }
 
-void operator delete(void* p, size_t)
+void operator delete(void* p, size_t) EXCEPTSPEC
 {
   snmalloc::miracle::free(p);
 }