From 4ad99d8242dd8d43717c0ee400a505e3605061e7 Mon Sep 17 00:00:00 2001
From: Michael Glassford <glassfordm@hotmail.com>
Date: Thu, 5 Aug 2004 17:33:07 +0000
Subject: [PATCH] Completely restructured tss cleanup. Automatic tss cleanup in
 Win32 static Boost.Threads library now works for both VC++ 6 and 7.1
 (probably also 7.0, but this hasn't been tested).

[SVN r24307]
---
 build/Jamfile                          |  14 +-
 include/boost/thread/detail/config.hpp |  27 +++-
 src/thread.cpp                         |   9 +-
 src/tss.cpp                            |  21 +--
 src/tss_dll.cpp                        |  70 +++++++++
 src/tss_hooks.cpp                      | 192 +++++++++++++++++++++++++
 src/tss_null.cpp                       |  33 +++++
 src/tss_pe.cpp                         | 179 +++++++++++++++++++++++
 8 files changed, 512 insertions(+), 33 deletions(-)
 create mode 100644 src/tss_dll.cpp
 create mode 100644 src/tss_hooks.cpp
 create mode 100644 src/tss_null.cpp
 create mode 100644 src/tss_pe.cpp

diff --git a/build/Jamfile b/build/Jamfile
index f11fdec5..1902fc87 100644
--- a/build/Jamfile
+++ b/build/Jamfile
@@ -32,7 +32,9 @@ import ./threads ;
         recursive_mutex 
         read_write_mutex
         thread 
-        threadmon 
+        tss_hooks
+        tss_dll
+        tss_pe
         tss 
         xtime 
         ;
@@ -48,11 +50,11 @@ import ./threads ;
           # the common names rule ensures that the library will
           # be named according to the rules used by the install
           # and auto-link features:
-          common-variant-tag 
+          common-variant-tag
         : ## default build ##
     ;
 
-    template thread_dll_base
+    template boost_thread_dll_base
         : ## sources ##
           <template>thread_base 
           ../src/$(CPP_SOURCES).cpp
@@ -63,7 +65,7 @@ import ./threads ;
           # the common names rule ensures that the library will
           # be named according to the rules used by the install
           # and auto-link features:
-          common-variant-tag 
+          common-variant-tag
         : ## default build ##
     ;
 
@@ -77,7 +79,7 @@ import ./threads ;
 
     dll $(boost_thread_lib_name)
         : ## sources ##
-          <template>thread_dll_base 
+          <template>boost_thread_dll_base 
         : ## requirements ##
           <define>BOOST_THREAD_LIB_NAME=$(boost_thread_lib_name)
         : ## default build ##
@@ -105,7 +107,7 @@ import ./threads ;
 
         dll $(boost_thread_lib_name_ptw32)
             : ## sources ##
-              <template>thread_dll_base
+              <template>boost_thread_dll_base
             : ## requirements ##
               <define>BOOST_THREAD_LIB_NAME=$(boost_thread_lib_name_ptw32)
               $(pthreads-win32)
diff --git a/include/boost/thread/detail/config.hpp b/include/boost/thread/detail/config.hpp
index e6fc2fa8..da3e7178 100644
--- a/include/boost/thread/detail/config.hpp
+++ b/include/boost/thread/detail/config.hpp
@@ -27,9 +27,26 @@
 #       define BOOST_DYN_LINK
 #   elif defined(BOOST_THREAD_USE_LIB) //Use lib
 #       define BOOST_THREAD_DECL
-#   else //Use default (currently dll)
-#       define BOOST_THREAD_DECL __declspec(dllimport)
-#       define BOOST_DYN_LINK
+#   else //Use default
+#       if defined(BOOST_MSVC)
+            //For VC++, choose according to threading library setting
+#           #if defined(_DLL)
+                //Threading library is dll: use Boost.Threads dll
+#               define BOOST_THREAD_USE_DLL
+#               define BOOST_THREAD_DECL __declspec(dllimport)
+#               define BOOST_DYN_LINK
+#           #else
+                //Threading library is lib: used Boost.Threads lib
+#               define BOOST_THREAD_USE_LIB
+#               define BOOST_THREAD_DECL
+#           #endif
+#       else
+            //For compilers not yet supporting auto-tss cleanup
+            //with Boost.Threads lib, use Boost.Threads dll
+#           define BOOST_THREAD_USE_DLL
+#           define BOOST_THREAD_DECL __declspec(dllimport)
+#           define BOOST_DYN_LINK
+#       endif
 #   endif
 #else
 #   define BOOST_THREAD_DECL
@@ -40,8 +57,8 @@
 #endif // BOOST_HAS_WINTHREADS
 
 //
-// Automatically link to the correct build variant where possible. 
-// 
+// Automatically link to the correct build variant where possible.
+//
 #if !defined(BOOST_ALL_NO_LIB) && !defined(BOOST_THREAD_NO_LIB) && !defined(BOOST_THREAD_BUILD_DLL) && !defined(BOOST_THREAD_BUILD_LIB)
 //
 // Set the name of our library, this will get undef'ed by auto_link.hpp
diff --git a/src/thread.cpp b/src/thread.cpp
index c0e45037..2575e184 100644
--- a/src/thread.cpp
+++ b/src/thread.cpp
@@ -32,7 +32,7 @@
 #include "timeconv.inl"
 
 #if defined(BOOST_HAS_WINTHREADS)
-#   include "boost/thread/detail/threadmon.hpp"
+#   include "boost/thread/detail/tss_hooks.hpp"
 #endif
 
 namespace {
@@ -56,7 +56,7 @@ DWORD WINAPI ThreadProxy(LPVOID args)
     return ret;
 }
 
-inline unsigned _beginthreadex(void* security, unsigned stack_size, unsigned (__stdcall* start_address)(void*), 
+inline unsigned _beginthreadex(void* security, unsigned stack_size, unsigned (__stdcall* start_address)(void*),
 void* arglist, unsigned initflag,unsigned* thrdaddr)
 {
     DWORD threadID;
@@ -368,8 +368,3 @@ void thread_group::join_all()
 }
 
 } // namespace boost
-
-// Change Log:
-//    8 Feb 01  WEKEMPF Initial version.
-//    1 Jun 01  WEKEMPF Added boost::thread initial implementation.
-//    3 Jul 01  WEKEMPF Redesigned boost::thread to be noncopyable.
diff --git a/src/tss.cpp b/src/tss.cpp
index f1191eff..84d2be10 100644
--- a/src/tss.cpp
+++ b/src/tss.cpp
@@ -24,7 +24,7 @@
 
 #if defined(BOOST_HAS_WINTHREADS)
 #   include <windows.h>
-#   include <boost/thread/detail/threadmon.hpp>
+#   include <boost/thread/detail/tss_hooks.hpp>
 #endif
 
 namespace {
@@ -63,6 +63,10 @@ void init_tss_data()
     std::auto_ptr<tss_data_t> temp(new tss_data_t);
 
 #if defined(BOOST_HAS_WINTHREADS)
+    //Force the cleanup implementation library to be linked in
+    tss_cleanup_implemented();
+
+    //Allocate tls slot
     temp->native_key = TlsAlloc();
     if (temp->native_key == 0xFFFFFFFF)
         return;
@@ -199,17 +203,4 @@ void tss::cleanup(void* value)
 } // namespace detail
 } // namespace boost
 
-#endif //BOOST_THREAD_NO_TSS_CLEANUP
-
-// Change Log:
-//   6 Jun 01  
-//      WEKEMPF Initial version.
-//  30 May 02  WEKEMPF 
-//      Added interface to set specific cleanup handlers.
-//      Removed TLS slot limits from most implementations.
-//  22 Mar 04 GlassfordM for WEKEMPF
-//      Fixed: thread_specific_ptr::reset() doesn't check error returned
-//          by tss::set(); tss::set() now throws if it fails.
-//      Fixed: calling thread_specific_ptr::reset() or 
-//          thread_specific_ptr::release() causes double-delete: once on
-//          reset()/release() and once on ~thread_specific_ptr().
+#endif //BOOST_THREAD_NO_TSS_CLEANUP
\ No newline at end of file
diff --git a/src/tss_dll.cpp b/src/tss_dll.cpp
new file mode 100644
index 00000000..f7229ae3
--- /dev/null
+++ b/src/tss_dll.cpp
@@ -0,0 +1,70 @@
+// (C) Copyright Michael Glassford 2004.
+// Use, modification and distribution are subject to 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)
+
+#include <boost/thread/detail/config.hpp>
+
+#if defined(BOOST_HAS_WINTHREADS) && defined(BOOST_THREAD_BUILD_DLL)
+
+    #include <boost/thread/detail/tss_hooks.hpp>
+
+    #define WIN32_LEAN_AND_MEAN
+    #include <windows.h>
+
+    #if defined(__BORLANDC__)
+        extern "C" BOOL WINAPI DllEntryPoint(HINSTANCE /*hInstance*/, DWORD dwReason, LPVOID /*lpReserved*/)
+    #else
+        extern "C" BOOL WINAPI DllMain(HINSTANCE /*hInstance*/, DWORD dwReason, LPVOID /*lpReserved*/)
+    #endif
+    {
+        switch(dwReason)
+        {
+            case DLL_PROCESS_ATTACH:
+            {
+                on_process_enter();
+                on_thread_enter();
+                break;
+            }
+
+            case DLL_THREAD_ATTACH:
+            {
+                on_thread_enter();
+                break;
+            }
+
+            case DLL_THREAD_DETACH:
+            {
+                on_thread_exit();
+                break;
+            }
+
+            case DLL_PROCESS_DETACH:
+            {
+                on_thread_exit();
+                on_process_exit();
+                break;
+            }
+        }
+
+        return TRUE;
+    }
+
+    extern "C" void tss_cleanup_implemented(void)
+    {
+        /*
+        This function's sole purpose is to cause a link error in cases where
+        automatic tss cleanup is not implemented by Boost.Threads as a
+        reminder that user code is responsible for calling the necessary
+        functions at the appropriate times (and for implementing an a
+        tss_cleanup_implemented() function to eliminate the linker's
+        missing symbol error).
+
+        If Boost.Threads later implements automatic tss cleanup in cases
+        where it currently doesn't (which is the plan), the duplicate
+        symbol error will warn the user that their custom solution is no
+        longer needed and can be removed.
+        */
+    }
+
+#endif //defined(BOOST_HAS_WINTHREADS) && defined(BOOST_THREAD_BUILD_DLL)
diff --git a/src/tss_hooks.cpp b/src/tss_hooks.cpp
new file mode 100644
index 00000000..261b1271
--- /dev/null
+++ b/src/tss_hooks.cpp
@@ -0,0 +1,192 @@
+// (C) Copyright Michael Glassford 2004.
+// Use, modification and distribution are subject to 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)
+
+#include <boost/thread/detail/config.hpp>
+
+#if defined(BOOST_HAS_WINTHREADS)
+
+    #include <boost/thread/detail/tss_hooks.hpp>
+
+    #include <boost/assert.hpp>
+    #include <boost/thread/mutex.hpp>
+    #include <boost/thread/once.hpp>
+
+    #include <list>
+
+    #define WIN32_LEAN_AND_MEAN
+    #include <windows.h>
+
+    namespace
+    {
+        typedef std::list<thread_exit_handler> thread_exit_handlers;
+
+        boost::once_flag once_init_threadmon_mutex = BOOST_ONCE_INIT;
+        boost::mutex* threadmon_mutex;
+        void init_threadmon_mutex(void)
+        {
+            threadmon_mutex = new boost::mutex;
+            if (!threadmon_mutex)
+                throw boost::thread_resource_error();
+        }
+
+        const DWORD invalid_key = TLS_OUT_OF_INDEXES;
+        DWORD tls_key = invalid_key;
+
+        unsigned long attached_thread_count = 0;
+    }
+
+    /*
+    Calls to DllMain() and tls_callback() are serialized by the OS;
+    however, calls to at_thread_exit are not, so it must be protected
+    by a mutex. Since we already need a mutex for at_thread_exit(),
+    and since there is no guarantee that on_process_enter(),
+    on_process_exit(), on_thread_enter(), and on_thread_exit()
+    will be called only from DllMain() or tls_callback(), it makes
+    sense to protect those, too.
+    */
+
+    extern "C" BOOST_THREAD_DECL int at_thread_exit(
+        thread_exit_handler exit_handler
+        )
+    {
+        boost::call_once(init_threadmon_mutex, once_init_threadmon_mutex);
+        boost::mutex::scoped_lock lock(*threadmon_mutex);
+
+        //Allocate a tls slot if necessary.
+
+        if (tls_key == invalid_key)
+            tls_key = TlsAlloc();
+
+        if (tls_key == invalid_key)
+            return -1;
+
+        //Get the exit handlers list for the current thread from tls.
+
+        thread_exit_handlers* exit_handlers =
+            static_cast<thread_exit_handlers*>(TlsGetValue(tls_key));
+
+        if (!exit_handlers)
+        {
+            //No exit handlers list was created yet.
+
+            try
+            {
+                //Attempt to create a new exit handlers list.
+
+                exit_handlers = new thread_exit_handlers;
+                if (!exit_handlers)
+                    return -1;
+
+                //Attempt to store the list pointer in tls.
+
+                if (TlsSetValue(tls_key, exit_handlers))
+                    ++attached_thread_count;
+                else
+                {
+                    delete exit_handlers;
+                    return -1;
+                }
+            }
+            catch (...)
+            {
+                return -1;
+            }
+        }
+
+        //Like the C runtime library atexit() function,
+        //functions should be called in the reverse of
+        //the order they are added, so push them on the
+        //front of the list.
+
+        try
+        {
+            exit_handlers->push_front(exit_handler);
+        }
+        catch (...)
+        {
+            return -1;
+        }
+
+        //Like the atexit() function, a result of zero
+        //indicates success.
+
+        return 0;
+    }
+
+    extern "C" BOOST_THREAD_DECL void on_process_enter(void)
+    {
+        boost::call_once(init_threadmon_mutex, once_init_threadmon_mutex);
+        boost::mutex::scoped_lock lock(*threadmon_mutex);
+
+        BOOST_ASSERT(attached_thread_count == 0);
+    }
+
+    extern "C" BOOST_THREAD_DECL void on_process_exit(void)
+    {
+        boost::call_once(init_threadmon_mutex, once_init_threadmon_mutex);
+        boost::mutex::scoped_lock lock(*threadmon_mutex);
+
+        BOOST_ASSERT(attached_thread_count == 0);
+
+        //Free the tls slot if one was allocated.
+
+        if (tls_key != invalid_key)
+        {
+            TlsFree(tls_key);
+            tls_key = invalid_key;
+        }
+    }
+
+    extern "C" BOOST_THREAD_DECL void on_thread_enter(void)
+    {
+        //boost::call_once(init_threadmon_mutex, once_init_threadmon_mutex);
+        //boost::mutex::scoped_lock lock(*threadmon_mutex);
+    }
+
+    extern "C" BOOST_THREAD_DECL void on_thread_exit(void)
+    {
+        boost::call_once(init_threadmon_mutex, once_init_threadmon_mutex);
+        boost::mutex::scoped_lock lock(*threadmon_mutex);
+
+        //Get the exit handlers list for the current thread from tls.
+
+        if (tls_key == invalid_key)
+            return;
+
+        thread_exit_handlers* exit_handlers =
+            static_cast<thread_exit_handlers*>(TlsGetValue(tls_key));
+
+        //If a handlers list was found, use it.
+
+        if (exit_handlers)
+        {
+            //Call each handler and remove it from the list
+
+            while (!exit_handlers->empty())
+            {
+                if (thread_exit_handler exit_handler = *exit_handlers->begin())
+                    (*exit_handler)();
+                exit_handlers->pop_front();
+            }
+
+            //Remove the exit handlers list from tls and delete it
+
+            if (TlsSetValue(tls_key, 0))
+            {
+                BOOST_ASSERT(attached_thread_count > 0);
+                --attached_thread_count;
+
+                //Only delete the handlers list if we succeed in
+                //setting the tls value to 0; otherwise, another call
+                //to this function might get a pointer to the deleted
+                //handlers and try to use it.
+
+                delete exit_handlers;
+                exit_handlers = 0;
+            }
+        }
+    }
+
+#endif //defined(BOOST_HAS_WINTHREADS)
diff --git a/src/tss_null.cpp b/src/tss_null.cpp
new file mode 100644
index 00000000..38bd6d4e
--- /dev/null
+++ b/src/tss_null.cpp
@@ -0,0 +1,33 @@
+// (C) Copyright Michael Glassford 2004.
+// Use, modification and distribution are subject to 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)
+
+#include <boost/thread/detail/config.hpp>
+
+#if defined(BOOST_HAS_WINTHREADS)
+
+    /*
+    This file is a "null" implementation of tss cleanup; it's
+    purpose is to to eliminate link errors in cases
+    where it is known that tss cleanup is not needed.
+    */
+
+    extern "C" void tss_cleanup_implemented(void)
+    {
+        /*
+        This function's sole purpose is to cause a link error in cases where
+        automatic tss cleanup is not implemented by Boost.Threads as a
+        reminder that user code is responsible for calling the necessary
+        functions at the appropriate times (and for implementing an a
+        tss_cleanup_implemented() function to eliminate the linker's
+        missing symbol error).
+
+        If Boost.Threads later implements automatic tss cleanup in cases
+        where it currently doesn't (which is the plan), the duplicate
+        symbol error will warn the user that their custom solution is no
+        longer needed and can be removed.
+        */
+    }
+
+#endif //defined(BOOST_HAS_WINTHREADS)
diff --git a/src/tss_pe.cpp b/src/tss_pe.cpp
new file mode 100644
index 00000000..69152e62
--- /dev/null
+++ b/src/tss_pe.cpp
@@ -0,0 +1,179 @@
+// (C) Copyright Aaron W. LaFramboise, Roland Schwarz, Michael Glassford 2004.
+// Use, modification and distribution are subject to 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)
+
+#include <boost/thread/detail/config.hpp>
+
+#if defined(BOOST_HAS_WINTHREADS) && defined(BOOST_THREAD_BUILD_LIB) && defined(BOOST_MSVC)
+
+    #include <boost/thread/detail/tss_hooks.hpp>
+
+    #include <stdlib.h>
+
+    #define WIN32_LEAN_AND_MEAN
+    #include <windows.h>
+
+    //Definitions required by implementation
+
+    #if (BOOST_MSVC < 1310) // 1310 == VC++ 7.1
+        typedef void (__cdecl *_PVFV)(void);
+        #define INIRETSUCCESS
+        #define PVAPI void
+    #else
+        typedef int (__cdecl *_PVFV)(void);
+        #define INIRETSUCCESS 0
+        #define PVAPI int
+    #endif
+
+    typedef void (NTAPI* _TLSCB)(HINSTANCE, DWORD, PVOID);
+
+    //Symbols for connection to the runtime environment
+
+    extern "C"
+    {
+        extern DWORD _tls_used; //the tls directory (located in .rdata segment)
+        extern _TLSCB __xl_a[], __xl_z[];    //tls initializers */
+    }
+
+    namespace
+    {
+        //Forward declarations
+
+        static PVAPI on_tls_prepare(void);
+        static PVAPI on_process_init(void);
+        static PVAPI on_process_term(void);
+        static void NTAPI on_tls_callback(HINSTANCE, DWORD, PVOID);
+
+        //The .CRT$Xxx information is taken from Codeguru:
+        //http://www.codeguru.com/Cpp/misc/misc/threadsprocesses/article.php/c6945__2/
+
+        #if (BOOST_MSVC >= 1310) // 1310 == VC++ 7.1
+        #   pragma data_seg(push, old_seg)
+        #endif
+            //Callback to run tls glue code first.
+            //I don't think it is necessary to run it
+            //at .CRT$XIB level, since we are only
+            //interested in thread detachement. But
+            //this could be changed easily if required.
+
+            #pragma data_seg(".CRT$XIU")
+            static _PVFV p_tls_prepare = on_tls_prepare;
+            #pragma data_seg()
+
+            //Callback after all global ctors.
+
+            #pragma data_seg(".CRT$XCU")
+            static _PVFV p_process_init = on_process_init;
+            #pragma data_seg()
+
+            //Callback for tls notifications.
+
+            #pragma data_seg(".CRT$XLB")
+            _TLSCB p_thread_callback = on_tls_callback;
+            #pragma data_seg()
+
+            //Callback for termination.
+
+            #pragma data_seg(".CRT$XTU")
+            static _PVFV p_process_term = on_process_term;
+            #pragma data_seg()
+        #if (BOOST_MSVC >= 1310) // 1310 == VC++ 7.1
+        #   pragma data_seg(pop, old_seg)
+        #endif
+
+        PVAPI on_tls_prepare(void)
+        {
+            //The following line has an important side effect:
+            //if the TLS directory is not already there, it will
+            //be created by the linker. In other words, it forces a tls
+            //directory to be generated by the linker even when static tls
+            //(i.e. __declspec(thread)) is not used.
+            //The volatile should prevent the optimizer
+            //from removing the reference.
+
+            DWORD volatile dw = _tls_used;
+
+            #if (BOOST_MSVC < 1310) // 1310 == VC++ 7.1
+                _TLSCB* pfbegin = __xl_a;
+                _TLSCB* pfend = __xl_z;
+                _TLSCB* pfdst = pfbegin;
+                //pfdst = (_TLSCB*)_tls_used.AddressOfCallBacks;
+
+                //The following loop will merge the address pointers
+                //into a contiguous area, since the tlssup code seems
+                //to require this (at least on MSVC 6)
+
+                while (pfbegin < pfend)
+                {
+                    if (*pfbegin != 0)
+                    {
+                        *pfdst = *pfbegin;
+                        ++pfdst;
+                    }
+                    ++pfbegin;
+                }
+
+                *pfdst = 0;
+            #endif
+
+            return INIRETSUCCESS;
+        }
+
+        PVAPI on_process_init(void)
+        {
+            //Schedule on_thread_exit() to be called for the main
+            //thread before destructors of global objects have been
+            //called.
+
+            //It will not be run when 'quick' exiting the
+            //library; however, this is the standard behaviour
+            //for destructors of global objects, so that
+            //shouldn't be a problem.
+
+            atexit(on_thread_exit);
+
+//:         //Call Boost process entry callback here
+//:
+//:         on_process_enter();
+
+            return INIRETSUCCESS;
+        }
+
+        PVAPI on_process_term(void)
+        {
+            on_process_exit();
+            return INIRETSUCCESS;
+        }
+
+        void NTAPI on_tls_callback(HINSTANCE h, DWORD dwReason, PVOID pv)
+        {
+            switch (dwReason)
+            {
+                case DLL_THREAD_DETACH:
+                {
+                    on_thread_exit();
+                    break;
+                }
+            }
+        }
+    } //namespace
+
+    extern "C" void tss_cleanup_implemented(void)
+    {
+        /*
+        This function's sole purpose is to cause a link error in cases where
+        automatic tss cleanup is not implemented by Boost.Threads as a
+        reminder that user code is responsible for calling the necessary
+        functions at the appropriate times (and for implementing an a
+        tss_cleanup_implemented() function to eliminate the linker's
+        missing symbol error).
+
+        If Boost.Threads later implements automatic tss cleanup in cases
+        where it currently doesn't (which is the plan), the duplicate
+        symbol error will warn the user that their custom solution is no
+        longer needed and can be removed.
+        */
+    }
+
+#endif //defined(BOOST_HAS_WINTHREADS) && defined(BOOST_THREAD_BUILD_LIB)