Added BOOST_LEAF_UNREACHABLE, implemented allocation failure test for dynamic_allocator

Author: zajo

include/boost/leaf/config.hpp

@@ -238,6 +238,14 @@
 
 ////////////////////////////////////////
 
+#ifdef _MSC_VER
+#   define BOOST_LEAF_UNREACHABLE __assume(0)
+#else
+#   define BOOST_LEAF_UNREACHABLE __builtin_unreachable()
+#endif
+
+////////////////////////////////////////
+
 namespace boost
 {
     [[noreturn]] void throw_exception( std::exception const & ); // user defined

include/boost/leaf/config/tls_win32.hpp

@@ -16,10 +16,9 @@
 
 #include <atomic>
 #include <unordered_map>
-#include <typeinfo>
 #include <cstdint>
+#include <new>
 #include <stdexcept>
-#include <cstdio>
 #include <windows.h>
 #ifdef min
 #   undef min
@@ -41,14 +40,93 @@ class win32_tls_error:
     }
 };
 
-} }
+namespace detail
+{
+    __declspec(noreturn) inline void raise_fail_fast(NTSTATUS status) noexcept
+    {
+        EXCEPTION_RECORD rec = {};
+        rec.ExceptionCode = status;
+        rec.ExceptionFlags = EXCEPTION_NONCONTINUABLE;
+        RaiseFailFastException(&rec, nullptr, 0);
+        BOOST_LEAF_UNREACHABLE;
+    }
 
-////////////////////////////////////////
+    template <class T, class... Args>
+    T * heap_new(Args && ... args) noexcept
+    {
+        void * mem = HeapAlloc(GetProcessHeap(), 0, sizeof(T));
+        if (!mem)
+        {
+            raise_fail_fast(STATUS_NO_MEMORY);
+            BOOST_LEAF_UNREACHABLE;
+        }
+        return new (mem) T(static_cast<Args &&>(args)...);
+    }
 
-namespace boost { namespace leaf {
+    template <class T>
+    void heap_delete(T * p) noexcept
+    {
+        if (p)
+        {
+            p->~T();
+            BOOL r = HeapFree(GetProcessHeap(), 0, p);
+            BOOST_LEAF_ASSERT(r), (void) r;
+        }
+    }
+
+    template <class T>
+    class heap_allocator
+    {
+    public:
+
+        using value_type = T;
+
+        heap_allocator() noexcept = default;
+
+        template <class U>
+        heap_allocator(heap_allocator<U> const &) noexcept
+        {
+        }
+
+        T * allocate(std::size_t n) noexcept
+        {
+            if (void * p = HeapAlloc(GetProcessHeap(), 0, n * sizeof(T)))
+                return static_cast<T *>(p);
+            raise_fail_fast(STATUS_NO_MEMORY);
+            BOOST_LEAF_UNREACHABLE;
+        }
+
+        void deallocate(T * p, std::size_t) noexcept
+        {
+            BOOL r = HeapFree(GetProcessHeap(), 0, p);
+            BOOST_LEAF_ASSERT(r), (void) r;
+        }
+
+        friend bool operator==(heap_allocator const &, heap_allocator const &) noexcept { return true; }
+        friend bool operator!=(heap_allocator const &, heap_allocator const &) noexcept { return false; }
+    };
+
+    class critical_section_lock
+    {
+        critical_section_lock(critical_section_lock const &) = delete;
+        critical_section_lock & operator=(critical_section_lock const &) = delete;
+
+        CRITICAL_SECTION & cs_;
+
+    public:
+
+        explicit critical_section_lock(CRITICAL_SECTION & cs) noexcept:
+            cs_(cs)
+        {
+            EnterCriticalSection(&cs_);
+        }
+
+        ~critical_section_lock() noexcept
+        {
+            LeaveCriticalSection(&cs_);
+        }
+    };
 
-namespace detail
-{
     using atomic_unsigned_int = std::atomic<unsigned int>;
 
     template <int N, int I>
@@ -74,7 +152,7 @@ namespace detail
     {
         return cpp11_hash_step<N, N - 2>::compute(str, 2166136261u); // str[N-2] is the last character before the \0.
     }
-}
+} // namespace detail
 
 namespace n
 {
@@ -94,7 +172,7 @@ namespace detail
     }
 }
 
-} }
+} } // namespace boost::leaf
 
 ////////////////////////////////////////
 
@@ -107,13 +185,6 @@ namespace detail
         slot_map(slot_map const &) = delete;
         slot_map & operator=(slot_map const &) = delete;
 
-        ~slot_map() noexcept
-        {
-            DeleteCriticalSection(&cs_);
-            BOOL r = CloseHandle(mapping_);
-            BOOST_LEAF_ASSERT(r), (void) r;
-        }
-
         class tls_slot_index
         {
             tls_slot_index(tls_slot_index const &) = delete;
@@ -156,7 +227,12 @@ namespace detail
         HANDLE const mapping_;
         tls_slot_index const error_id_slot_;
         mutable CRITICAL_SECTION cs_;
-        std::unordered_map<std::uint32_t, tls_slot_index> map_;
+        std::unordered_map<
+            std::uint32_t,
+            tls_slot_index,
+            std::hash<std::uint32_t>,
+            std::equal_to<std::uint32_t>,
+            heap_allocator<std::pair<std::uint32_t const, tls_slot_index>>> map_;
         atomic_unsigned_int error_id_storage_;
 
     public:
@@ -170,6 +246,13 @@ namespace detail
             InitializeCriticalSection(&cs_);
         }
 
+        ~slot_map() noexcept
+        {
+            DeleteCriticalSection(&cs_);
+            BOOL r = CloseHandle(mapping_);
+            BOOST_LEAF_ASSERT(r), (void) r;
+        }
+
         BOOST_LEAF_ALWAYS_INLINE void add_ref() noexcept
         {
             BOOST_LEAF_ASSERT(refcount_ >= 1);
@@ -181,23 +264,20 @@ namespace detail
             --refcount_;
             BOOST_LEAF_ASSERT(refcount_ >= 0);
             if (refcount_ == 0)
-                delete this;
+                heap_delete(this);
         }
 
         DWORD check(std::uint32_t type_hash) const noexcept
         {
-            EnterCriticalSection(&cs_);
+            critical_section_lock lock(cs_);
             auto it = map_.find(type_hash);
-            DWORD idx = (it != map_.end()) ? it->second.get() : TLS_OUT_OF_INDEXES;
-            LeaveCriticalSection(&cs_);
-            return idx;
+            return (it != map_.end()) ? it->second.get() : TLS_OUT_OF_INDEXES;
         }
 
         DWORD get(std::uint32_t type_hash)
         {
-            EnterCriticalSection(&cs_);
+            critical_section_lock lock(cs_);
             DWORD idx = map_[type_hash].get();
-            LeaveCriticalSection(&cs_);
             BOOST_LEAF_ASSERT(idx != TLS_OUT_OF_INDEXES);
             return idx;
         }
@@ -220,7 +300,6 @@ namespace detail
 
         static constexpr unsigned tls_failure_create_mapping = 0x01;
         static constexpr unsigned tls_failure_map_view = 0x02;
-        static constexpr unsigned tls_failure_slot_map = 0x04;
 
         void * hinstance_;
         unsigned tls_failures_;
@@ -240,7 +319,6 @@ namespace detail
             BOOST_LEAF_ASSERT(hinstance_);
             BOOST_LEAF_ASSERT(!(tls_failures_ & tls_failure_create_mapping));
             BOOST_LEAF_ASSERT(!(tls_failures_ & tls_failure_map_view));
-            BOOST_LEAF_ASSERT(!(tls_failures_ & tls_failure_slot_map));
             BOOST_LEAF_ASSERT(sm_);
             return *sm_;
         }
@@ -250,16 +328,24 @@ namespace detail
             if (dwReason == DLL_PROCESS_ATTACH)
             {
                 hinstance_ = hinstDLL;
-                char name[64];
-                int num_written = std::snprintf(name, sizeof(name), "Local\\boost_leaf_tls_%lu", GetCurrentProcessId());
-                BOOST_LEAF_ASSERT(num_written >= 0 && num_written < int(sizeof(name))), (void) num_written;
+                char name[32] = "Local\\boost_leaf_";
+                {
+                    constexpr static char const hex[] = "0123456789ABCDEF";
+                    DWORD pid = GetCurrentProcessId();
+                    for (int i = 7; i >= 0; --i)
+                    {
+                        name[17 + i] = hex[pid & 0xf];
+                        pid >>= 4;
+                    }
+                    name[25] = '\0';
+                }
                 HANDLE mapping = CreateFileMappingA(INVALID_HANDLE_VALUE, nullptr, PAGE_READWRITE, 0, sizeof(slot_map *), name);
+                DWORD mapping_status = GetLastError();
                 if (!mapping)
                 {
                     tls_failures_ |= tls_failure_create_mapping;
                     return;
                 }
-                DWORD mapping_status = GetLastError();
                 BOOST_LEAF_ASSERT(mapping_status == ERROR_ALREADY_EXISTS || mapping_status == ERROR_SUCCESS);
                 bool is_first_module = (mapping_status == ERROR_SUCCESS);
                 slot_map * * mapped_ptr = static_cast<slot_map * *>(MapViewOfFile(mapping, FILE_MAP_WRITE, 0, 0, sizeof(slot_map *)));
@@ -271,26 +357,7 @@ namespace detail
                     return;
                 }
                 if (is_first_module)
-                {
-#ifndef BOOST_LEAF_NO_EXCEPTIONS
-                    try
-                    {
-#endif
-                        sm_ = *mapped_ptr = new slot_map(mapping);
-#ifdef BOOST_LEAF_NO_EXCEPTIONS
-                        if (!sm_)
-#else
-                    }
-                    catch(...)
-#endif
-                    {
-                        tls_failures_ |= tls_failure_slot_map;
-                        EXCEPTION_RECORD rec = {};
-                        rec.ExceptionCode = STATUS_NO_MEMORY;
-                        rec.ExceptionFlags = EXCEPTION_NONCONTINUABLE;
-                        RaiseFailFastException(&rec, nullptr, 0);
-                    }
-                }
+                    sm_ = *mapped_ptr = heap_new<slot_map>(mapping);
                 else
                 {
                     sm_ = *mapped_ptr;

include/boost/leaf/error.hpp

@@ -179,12 +179,18 @@ namespace detail
 {
     class preloaded_base;
 
+    template <class E>
+    struct capturing_slot_node_allocator;
+
     class dynamic_allocator:
         capture_list
     {
         dynamic_allocator( dynamic_allocator const & ) = delete;
         dynamic_allocator & operator=( dynamic_allocator const & ) = delete;
 
+        template <class>
+        friend struct capturing_slot_node_allocator;
+
         preloaded_base * preloaded_list_;
 
         class capturing_node:
@@ -319,7 +325,7 @@ namespace detail
             BOOST_LEAF_ASSERT(last_ != nullptr);
             BOOST_LEAF_ASSERT(*last_ == nullptr);
             BOOST_LEAF_ASSERT(tls::read_ptr<slot<E>>() == nullptr);
-            capturing_slot_node<E> * csn = new capturing_slot_node<E>(last_);
+            capturing_slot_node<E> * csn = capturing_slot_node_allocator<E>::new_(last_);
             csn->activate();
             return csn;
         }
@@ -359,6 +365,21 @@ namespace detail
         using capture_list::print;
     }; // class dynamic_allocator
 
+    template <class E>
+    struct capturing_slot_node_allocator
+    {
+        template <class... A>
+        static dynamic_allocator::capturing_slot_node<E> * new_( A && ... a )
+        {
+            return new dynamic_allocator::capturing_slot_node<E>(std::forward<A>(a)...);
+        }
+
+        static void delete_( dynamic_allocator::capturing_slot_node<E> * p ) noexcept
+        {
+            delete p;
+        }
+    };
+
     template <>
     class slot<dynamic_allocator>
     {

meson.build

@@ -152,6 +152,7 @@ if option_enable_unit_tests
         'on_error_accumulate_nested_new_error_result_test',
         'on_error_accumulate_nested_success_exception_test',
         'on_error_accumulate_nested_success_result_test',
+        'on_error_alloc_fail_test',
         'on_error_defer_basic_test',
         'on_error_defer_nested_error_exception_test',
         'on_error_defer_nested_error_result_test',

test/Jamfile.v2

@@ -71,7 +71,7 @@ run diagnostics_test4.cpp ;
 run diagnostics_test5.cpp ;
 run e_errno_test.cpp ;
 run e_LastError_test.cpp : : : <target-os>windows:<define>BOOST_LEAF_CFG_WIN32=1 ;
-run error_code_test.cpp ;
+run error_code_test.cpp : : : <toolset>clang-darwin,<exception-handling>off,<rtti>off:<linkflags>"-Wl,-ld_classic" ; # workaround for macos-14 linker bug
 run error_id_test.cpp ;
 run exception_test.cpp ;
 run exception_to_result_test.cpp ;
@@ -94,6 +94,7 @@ run on_error_accumulate_nested_new_error_exception_test.cpp ;
 run on_error_accumulate_nested_new_error_result_test.cpp ;
 run on_error_accumulate_nested_success_exception_test.cpp ;
 run on_error_accumulate_nested_success_result_test.cpp ;
+run on_error_alloc_fail_test.cpp ;
 run on_error_defer_basic_test.cpp ;
 run on_error_defer_nested_error_exception_test.cpp ;
 run on_error_defer_nested_error_result_test.cpp ;