- Refactored TLS implementation, including Win32 support across DLL bondaries

- on_error now allocates dynamic storage (if enabled) before the stack unwind

Author: zajo

include/boost/leaf/common.hpp

@@ -1,7 +1,7 @@
 #ifndef BOOST_LEAF_COMMON_HPP_INCLUDED
 #define BOOST_LEAF_COMMON_HPP_INCLUDED
 
-// Copyright 2018-2024 Emil Dotchevski and Reverge Studios, Inc.
+// Copyright 2018-2025 Emil Dotchevski and Reverge Studios, Inc.
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
@@ -28,26 +28,26 @@
 
 namespace boost { namespace leaf {
 
-struct BOOST_LEAF_SYMBOL_VISIBLE e_api_function { char const * value; };
+struct e_api_function { char const * value; };
 
 #if BOOST_LEAF_CFG_STD_STRING
 
-struct BOOST_LEAF_SYMBOL_VISIBLE e_file_name
+struct e_file_name
 {
     std::string value;
 };
 
 #else
 
-struct BOOST_LEAF_SYMBOL_VISIBLE e_file_name
+struct e_file_name
 {
     char const * value = "<unavailable>";
     BOOST_LEAF_CONSTEXPR explicit e_file_name( char const * ) { }
 };
 
 #endif
 
-struct BOOST_LEAF_SYMBOL_VISIBLE e_errno
+struct e_errno
 {
     int value;
 
@@ -60,9 +60,9 @@ struct BOOST_LEAF_SYMBOL_VISIBLE e_errno
     }
 };
 
-struct BOOST_LEAF_SYMBOL_VISIBLE e_type_info_name { char const * value; };
+struct e_type_info_name { char const * value; };
 
-struct BOOST_LEAF_SYMBOL_VISIBLE e_at_line { int value; };
+struct e_at_line { int value; };
 
 namespace windows
 {
@@ -104,10 +104,10 @@ namespace windows
             }
             return os;
         }
-#endif
+#endif // #if BOOST_LEAF_CFG_WIN32
     };
-}
+} // namespace windows
 
-} }
+} } // namespace boost::leaf
 
-#endif // BOOST_LEAF_COMMON_HPP_INCLUDED
+#endif // #ifndef BOOST_LEAF_COMMON_HPP_INCLUDED

include/boost/leaf/config.hpp

@@ -1,7 +1,7 @@
 #ifndef BOOST_LEAF_CONFIG_HPP_INCLUDED
 #define BOOST_LEAF_CONFIG_HPP_INCLUDED
 
-// Copyright 2018-2024 Emil Dotchevski and Reverge Studios, Inc.
+// Copyright 2018-2025 Emil Dotchevski and Reverge Studios, Inc.
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
@@ -27,7 +27,7 @@
 #   ifndef BOOST_LEAF_CFG_CAPTURE
 #       define BOOST_LEAF_CFG_CAPTURE 0
 #   endif
-#endif
+#endif // #ifdef BOOST_LEAF_EMBEDDED
 
 ////////////////////////////////////////
 
@@ -162,7 +162,7 @@
 #       endif
 #   endif
 
-#endif
+#endif // #ifndef BOOST_LEAF_NO_EXCEPTIONS
 
 ////////////////////////////////////////
 
@@ -226,6 +226,8 @@
 #   define BOOST_LEAF_SYMBOL_VISIBLE
 #endif
 
+#include <boost/leaf/config/visibility.hpp>
+
 ////////////////////////////////////////
 
 #if defined(__GNUC__) && !(defined(__clang__) || defined(__INTEL_COMPILER) || defined(__ICL) || defined(__ICC) || defined(__ECC)) && (__GNUC__ * 100 + __GNUC_MINOR__) < 409
@@ -260,4 +262,4 @@ template <class T>
 // Configure TLS access
 #include <boost/leaf/config/tls.hpp>
 
-#endif // BOOST_LEAF_CONFIG_HPP_INCLUDED
+#endif // #ifndef BOOST_LEAF_CONFIG_HPP_INCLUDED

include/boost/leaf/config/tls.hpp

@@ -31,30 +31,32 @@ namespace tls
     // This function may not fail.
     unsigned read_current_error_id() noexcept;
 
-    // Write p to the TLS for T. The TLS may be allocated dynamically on the
-    // first call to write_ptr_alloc<T>, but subsequent calls must reuse the
-    // same TLS.
+    // Reserve TLS storage for T. The TLS may be allocated dynamically on the
+    // first call to reserve_ptr<T>, but subsequent calls must reuse the same
+    // TLS. On platforms where allocation is not needed, this function is
+    // still defined but does nothing.
     //
     // This function may throw on allocation failure.
     template <class T>
-    void write_ptr_alloc( T * p );
+    void reserve_ptr();
 
-    // Write p to the TLS previously allocated for T by a successful call to
-    // write_ptr_alloc<T>.
+    // Write p to the TLS previously reserved for T by a call to reserve_ptr<T>.
+    // It is illegal to call write_ptr<T> without a prior successful call to
+    // reserve_ptr<T>.
     //
     // This function may not fail.
     template <class T>
     void write_ptr( T * p ) noexcept;
 
     // Read the T * value previously written in the TLS for T. Returns nullptr
-    // if TLS for T has not yet been allocated.
+    // if TLS for T has not yet been reserved.
     //
     // This function may not fail.
     template <class T>
     T * read_ptr() noexcept;
-}
+} // namespace tls
 
-} }
+} } // namespace boost::leaf
 
 #if defined(BOOST_LEAF_TLS_FREERTOS)
 #   include <boost/leaf/config/tls_freertos.hpp>
@@ -85,4 +87,4 @@ namespace tls
 #   include <boost/leaf/config/tls_cpp11.hpp>
 #endif
 
-#endif // BOOST_LEAF_CONFIG_TLS_HPP_INCLUDED
+#endif // #ifndef BOOST_LEAF_CONFIG_TLS_HPP_INCLUDED

include/boost/leaf/config/tls_array.hpp

@@ -100,16 +100,16 @@ namespace detail
     BOOST_LEAF_CFG_TLS_INDEX_TYPE tls_index<T>::idx = BOOST_LEAF_CFG_TLS_ARRAY_START_INDEX + 1;
 
     template <class T>
-    struct BOOST_LEAF_SYMBOL_VISIBLE alloc_tls_index
+    struct BOOST_LEAF_SYMBOL_VISIBLE reserve_tls_index
     {
         static BOOST_LEAF_CFG_TLS_INDEX_TYPE const idx;
     };
 
     template <class T>
-    BOOST_LEAF_CFG_TLS_INDEX_TYPE const alloc_tls_index<T>::idx = tls_index<T>::idx = index_counter<>::next<T>();
-}
+    BOOST_LEAF_CFG_TLS_INDEX_TYPE const reserve_tls_index<T>::idx = tls_index<T>::idx = index_counter<>::next<T>();
+} // namespace detail
 
-} }
+} } // namespace boost::leaf
 
 ////////////////////////////////////////
 
@@ -137,12 +137,9 @@ namespace tls
     }
 
     template <class T>
-    BOOST_LEAF_ALWAYS_INLINE void write_ptr_alloc( T * p )
+    BOOST_LEAF_ALWAYS_INLINE void reserve_ptr()
     {
-        int tls_idx = detail::alloc_tls_index<T>::idx;
-        --tls_idx;
-        write_void_ptr(tls_idx, p);
-        BOOST_LEAF_ASSERT(read_void_ptr(tls_idx) == p);
+        (void) detail::reserve_tls_index<T>::idx;
     }
 
     template <class T>
@@ -164,8 +161,8 @@ namespace tls
         --tls_idx;
         return reinterpret_cast<T *>(read_void_ptr(tls_idx));
     }
-}
+} // namespace tls
 
-} }
+} } // namespace boost::leaf
 
-#endif // BOOST_LEAF_CONFIG_TLS_ARRAY_HPP_INCLUDED
+#endif // #ifndef BOOST_LEAF_CONFIG_TLS_ARRAY_HPP_INCLUDED

include/boost/leaf/config/tls_cpp11.hpp

@@ -38,15 +38,17 @@ namespace detail
     template <class T>
     thread_local T * ptr<T>::p;
 
-    struct current_error_id_storage
+    template <class=void>
+    struct BOOST_LEAF_SYMBOL_VISIBLE current_error_id_storage
     {
         static thread_local unsigned x;
     };
 
-    thread_local unsigned current_error_id_storage::x;
-}
+    template <class T>
+    thread_local unsigned current_error_id_storage<T>::x;
+} // namespace detail
 
-} }
+} } // namespace boost::leaf
 
 ////////////////////////////////////////
 
@@ -63,18 +65,17 @@ namespace tls
 
     BOOST_LEAF_ALWAYS_INLINE void write_current_error_id( unsigned x ) noexcept
     {
-        detail::current_error_id_storage::x = x;
+        detail::current_error_id_storage<>::x = x;
     }
 
     BOOST_LEAF_ALWAYS_INLINE unsigned read_current_error_id() noexcept
     {
-        return detail::current_error_id_storage::x;
+        return detail::current_error_id_storage<>::x;
     }
 
     template <class T>
-    BOOST_LEAF_ALWAYS_INLINE void write_ptr_alloc( T * p )
+    BOOST_LEAF_ALWAYS_INLINE void reserve_ptr()
     {
-        detail::ptr<T>::p = p;
     }
 
     template <class T>
@@ -88,8 +89,8 @@ namespace tls
     {
         return detail::ptr<T>::p;
     }
-}
+} // namespace tls
 
-} }
+} } // namespace boost::leaf
 
-#endif // BOOST_LEAF_CONFIG_TLS_CPP11_HPP_INCLUDED
+#endif // #ifndef BOOST_LEAF_CONFIG_TLS_CPP11_HPP_INCLUDED

include/boost/leaf/config/tls_globals.hpp

@@ -42,9 +42,9 @@ namespace detail
 
     template <class T>
     unsigned current_error_id_storage<T>::x = 0;
-}
+} // namespace detail
 
-} }
+} } // namespace boost::leaf
 
 ////////////////////////////////////////
 
@@ -70,9 +70,8 @@ namespace tls
     }
 
     template <class T>
-    BOOST_LEAF_ALWAYS_INLINE void write_ptr_alloc( T * p )
+    BOOST_LEAF_ALWAYS_INLINE void reserve_ptr()
     {
-        detail::ptr<T>::p = p;
     }
 
     template <class T>
@@ -86,8 +85,8 @@ namespace tls
     {
         return detail::ptr<T>::p;
     }
-}
+} // namespace tls
 
-} }
+} } // namespace boost::leaf
 
-#endif // BOOST_LEAF_CONFIG_TLS_GLOBALS_HPP_INCLUDED
+#endif // #ifndef BOOST_LEAF_CONFIG_TLS_GLOBALS_HPP_INCLUDED

include/boost/leaf/config/tls_win32.hpp

@@ -211,7 +211,7 @@ namespace detail
         {
             return error_id_storage_;
         }
-    };
+    }; // class slot_map
 
     class module_state
     {
@@ -300,14 +300,15 @@ namespace detail
             }
             else if (dwReason == DLL_PROCESS_DETACH)
             {
+                BOOST_LEAF_ASSERT(sm_ || tls_failures_);
                 if (sm_)
                 {
                     sm_->release();
                     sm_ = nullptr;
                 }
             }
         }
-    };
+    }; // class module_state
 
     template<int = 0>
     struct module
@@ -334,19 +335,19 @@ namespace detail
 #ifdef _MSC_VER
 #pragma section(".CRT$XLB", long, read)
 #pragma data_seg(push, ".CRT$XLB")
-    extern "C" PIMAGE_TLS_CALLBACK boost_leaf_tls_callback = tls_callback;
+    extern "C" __declspec(selectany) PIMAGE_TLS_CALLBACK boost_leaf_tls_callback = tls_callback;
 #pragma data_seg(pop)
 #ifdef _WIN64
 #pragma comment(linker, "/INCLUDE:boost_leaf_tls_callback")
 #else
 #pragma comment(linker, "/INCLUDE:_boost_leaf_tls_callback")
 #endif
 #elif defined(__GNUC__)
-    extern "C" __attribute__((used)) PIMAGE_TLS_CALLBACK boost_leaf_tls_callback __attribute__((section(".CRT$XLB"))) = tls_callback;
+    extern "C" __attribute__((used, weak)) PIMAGE_TLS_CALLBACK boost_leaf_tls_callback __attribute__((section(".CRT$XLB"))) = tls_callback;
 #endif
-}
+} // namespace detail
 
-} }
+} } // namespace boost::leaf
 
 ////////////////////////////////////////
 
@@ -377,14 +378,11 @@ namespace tls
     }
 
     template <class T>
-    BOOST_LEAF_ALWAYS_INLINE void write_ptr_alloc(T * p)
+    BOOST_LEAF_ALWAYS_INLINE void reserve_ptr()
     {
         using namespace detail;
         thread_local DWORD const cached_slot = module<>::state.sm().get(type_hash<T>());
-        DWORD slot = cached_slot;
-        BOOST_LEAF_ASSERT(slot != TLS_OUT_OF_INDEXES);
-        BOOL r = TlsSetValue(slot, p);
-        BOOST_LEAF_ASSERT(r), (void) r;
+        BOOST_LEAF_ASSERT(cached_slot != TLS_OUT_OF_INDEXES), (void) cached_slot;
     }
 
     template <class T>
@@ -412,8 +410,8 @@ namespace tls
         BOOST_LEAF_ASSERT(GetLastError() == ERROR_SUCCESS);
         return static_cast<T *>(value);
     }
-}
+} // namespace tls
 
-} }
+} } // namespace boost::leaf
 
-#endif // BOOST_LEAF_CONFIG_TLS_WIN32_HPP_INCLUDED
+#endif // #ifndef BOOST_LEAF_CONFIG_TLS_WIN32_HPP_INCLUDED