Merge pull request #441 from dawgfoto/SharedRuntime_6

SectionGroup support for TLS

Author: alexrp

src/core/sys/windows/threadaux.d

@@ -266,10 +266,15 @@ private:
         // execute function on the TLS for the given thread
         alias extern(C) void function() externCVoidFunc;
         static void impersonate_thread( uint id, externCVoidFunc fn )
+        {
+            impersonate_thread(id, () => fn());
+        }
+
+        static void impersonate_thread( uint id, scope void delegate() dg)
         {
             if( id == GetCurrentThreadId() )
             {
-                fn();
+                dg();
                 return;
             }
 
@@ -284,7 +289,7 @@ private:
                 return;
 
             curteb[11] = tlsarray;
-            fn();
+            dg();
             curteb[11] = curtlsarray;
         }
     }
@@ -295,6 +300,7 @@ public:
     alias thread_aux.getThreadStackBottom getThreadStackBottom;
     alias thread_aux.OpenThreadHandle OpenThreadHandle;
     alias thread_aux.enumProcessThreads enumProcessThreads;
+    alias thread_aux.impersonate_thread impersonate_thread;
 
     // get the start of the TLS memory of the thread with the given handle
     void* GetTlsDataAddress( HANDLE hnd ) nothrow

src/core/thread.d

@@ -14,6 +14,7 @@ module core.thread;
 
 public import core.time; // for Duration
 static import rt.tlsgc;
+import rt.sections;
 
 // this should be true for most architectures
 version = StackGrowsDown;
@@ -124,40 +125,6 @@ version( Windows )
         extern (Windows) alias uint function(void*) btex_fptr;
         extern (C) uintptr_t _beginthreadex(void*, uint, btex_fptr, void*, uint, uint*);
 
-        version( DigitalMars )
-        {
-            version (Win32)
-            {
-                // NOTE: The memory between the addresses of _tlsstart and _tlsend
-                //       is the storage for thread-local data in D 2.0.  Both of
-                //       these are defined in dm\src\win32\tlsseg.asm by DMC.
-                extern (C)
-                {
-                    extern int _tlsstart;
-                    extern int _tlsend;
-                }
-            }
-            version (Win64)
-            {
-                // NOTE: The memory between the addresses of _tls_start and _tls_end
-                //       is the storage for thread-local data in D 2.0.  Both of
-                //       these are defined in LIBCMT:tlssub.obj
-                extern (C)
-                {
-                    extern int _tls_start;
-                    extern int _tls_end;
-                }
-                alias _tls_start _tlsstart;
-                alias _tls_end   _tlsend;
-            }
-        }
-        else
-        {
-            __gshared int   _tlsstart;
-            alias _tlsstart _tlsend;
-        }
-
-
         //
         // Entry point for Windows threads
         //
@@ -169,10 +136,7 @@ version( Windows )
             assert( obj.m_curr is &obj.m_main );
             obj.m_main.bstack = getStackBottom();
             obj.m_main.tstack = obj.m_main.bstack;
-
-            void* pstart = cast(void*) &_tlsstart;
-            void* pend   = cast(void*) &_tlsend;
-            obj.m_tls = pstart[0 .. pend - pstart];
+            obj.m_tlsgcdata = rt.tlsgc.init();
 
             Thread.setThis( obj );
             //Thread.add( obj );
@@ -181,7 +145,6 @@ version( Windows )
                 Thread.remove( obj );
             }
             Thread.add( &obj.m_main );
-            obj.m_tlsgcdata = rt.tlsgc.init();
 
             // NOTE: No GC allocations may occur until the stack pointers have
             //       been set and Thread.getThis returns a valid reference to
@@ -267,44 +230,6 @@ else version( Posix )
             import gcc.builtins;
         }
 
-        version( DigitalMars )
-        {
-            version( linux )
-            {
-                extern (C)
-                {
-                    extern int _tlsstart;
-                    extern int _tlsend;
-                }
-            }
-            else version( OSX )
-            {
-                extern (C)
-                {
-                    __gshared void[][2] _tls_data_array;
-                }
-            }
-            else version( FreeBSD )
-            {
-                extern (C)
-                {
-                    extern void* _tlsstart;
-                    extern void* _tlsend;
-                }
-            }
-            else
-            {
-                __gshared int   _tlsstart;
-                alias _tlsstart _tlsend;
-            }
-        }
-        else
-        {
-            __gshared int   _tlsstart;
-            alias _tlsstart _tlsend;
-        }
-
-
         //
         // Entry point for POSIX threads
         //
@@ -316,27 +241,7 @@ else version( Posix )
             assert( obj.m_curr is &obj.m_main );
             obj.m_main.bstack = getStackBottom();
             obj.m_main.tstack = obj.m_main.bstack;
-
-            version (OSX)
-            {
-                // NOTE: OSX does not support TLS, so we do it ourselves.  The TLS
-                //       data output by the compiler is bracketed by _tls_data_array[2],
-                //       so make a copy of it for each thread.
-                const sz0 = (_tls_data_array[0].length + 15) & ~cast(size_t)15;
-                const sz2 = sz0 + _tls_data_array[1].length;
-                auto p = malloc( sz2 );
-                assert( p );
-                obj.m_tls = p[0 .. sz2];
-                memcpy( p, _tls_data_array[0].ptr, _tls_data_array[0].length );
-                memcpy( p + sz0, _tls_data_array[1].ptr, _tls_data_array[1].length );
-                scope (exit) { free( p ); obj.m_tls = null; }
-            }
-            else
-            {
-                auto pstart = cast(void*) &_tlsstart;
-                auto pend   = cast(void*) &_tlsend;
-                obj.m_tls = pstart[0 .. pend - pstart];
-            }
+            obj.m_tlsgcdata = rt.tlsgc.init();
 
             obj.m_isRunning = true;
             Thread.setThis( obj );
@@ -350,7 +255,6 @@ else version( Posix )
                 obj.m_isRunning = false;
             }
             Thread.add( &obj.m_main );
-            obj.m_tlsgcdata = rt.tlsgc.init();
 
             static extern (C) void thread_cleanupHandler( void* arg ) nothrow
             {
@@ -1388,7 +1292,6 @@ private:
     Context             m_main;
     Context*            m_curr;
     bool                m_lock;
-    void[]              m_tls;  // spans implicit thread local storage
     rt.tlsgc.Data*      m_tlsgcdata;
 
     version( Windows )
@@ -1678,13 +1581,13 @@ private:
 version (D_LP64)
 {
     version (Windows)
-        static assert(__traits(classInstanceSize, Thread) == 312);
+        static assert(__traits(classInstanceSize, Thread) == 296);
     else version (OSX)
-        static assert(__traits(classInstanceSize, Thread) == 320);
+        static assert(__traits(classInstanceSize, Thread) == 304);
     else version (Solaris)
-        static assert(__traits(classInstanceSize, Thread) == 176);
+        static assert(__traits(classInstanceSize, Thread) == 160);
     else version (Posix)
-        static assert(__traits(classInstanceSize, Thread) == 184);
+        static assert(__traits(classInstanceSize, Thread) == 168);
     else
             static assert(0, "Platform not supported.");
 }
@@ -1693,11 +1596,11 @@ else
     static assert((void*).sizeof == 4); // 32-bit
 
     version (Windows)
-        static assert(__traits(classInstanceSize, Thread) == 128);
+        static assert(__traits(classInstanceSize, Thread) == 120);
     else version (OSX)
-        static assert(__traits(classInstanceSize, Thread) == 128);
+        static assert(__traits(classInstanceSize, Thread) == 120);
     else version (Posix)
-        static assert(__traits(classInstanceSize, Thread) ==  92);
+        static assert(__traits(classInstanceSize, Thread) ==  84);
     else
         static assert(0, "Platform not supported.");
 }
@@ -1857,6 +1760,7 @@ extern (C) Thread thread_attachThis()
         thisThread.m_isRunning = true;
     }
     thisThread.m_isDaemon = true;
+    thisThread.m_tlsgcdata = rt.tlsgc.init();
     Thread.setThis( thisThread );
 
     version( OSX )
@@ -1865,34 +1769,10 @@ extern (C) Thread thread_attachThis()
         assert( thisThread.m_tmach != thisThread.m_tmach.init );
     }
 
-    version (OSX)
-    {
-        //printf("test3 %p %p\n", _tls_data_array[0].ptr, &_tls_data_array[1][length]);
-        //printf("test3 %p %p\n", &_tls_beg, &_tls_end);
-        // NOTE: OSX does not support TLS, so we do it ourselves.  The TLS
-        //       data output by the compiler is bracketed by _tls_data_array[2],
-        //       so make a copy of it for each thread.
-        const sz0 = (_tls_data_array[0].length + 15) & ~cast(size_t)15;
-        const sz2 = sz0 + _tls_data_array[1].length;
-        auto p = gc_malloc( sz2 );
-        assert( p );
-        thisThread.m_tls = p[0 .. sz2];
-        memcpy( p, _tls_data_array[0].ptr, _tls_data_array[0].length );
-        memcpy( p + sz0, _tls_data_array[1].ptr, _tls_data_array[1].length );
-        // used gc_malloc so no need to free
-    }
-    else
-    {
-        auto pstart = cast(void*) &_tlsstart;
-        auto pend   = cast(void*) &_tlsend;
-        thisThread.m_tls = pstart[0 .. pend - pstart];
-    }
-
     Thread.add( thisThread );
     Thread.add( thisContext );
     if( Thread.sm_main !is null )
         multiThreadedFlag = true;
-    thisThread.m_tlsgcdata = rt.tlsgc.init();
     return thisThread;
 }
 
@@ -1932,44 +1812,24 @@ version( Windows )
         thisContext.bstack = bstack;
         thisContext.tstack = thisContext.bstack;
 
-        if( addr == GetCurrentThreadId() )
-        {
-            thisThread.m_hndl = GetCurrentThreadHandle();
-        }
-        else
-        {
-            thisThread.m_hndl = OpenThreadHandle( addr );
-        }
-
         thisThread.m_isDaemon = true;
 
         if( addr == GetCurrentThreadId() )
         {
-            auto pstart = cast(void*) &_tlsstart;
-            auto pend   = cast(void*) &_tlsend;
-            thisThread.m_tls = pstart[0 .. pend - pstart];
+            thisThread.m_hndl = GetCurrentThreadHandle();
+            thisThread.m_tlsgcdata = rt.tlsgc.init();
             Thread.setThis( thisThread );
         }
         else
         {
-            // TODO: This seems wrong.  If we're binding threads from
-            //       a DLL, will they always have space reserved for
-            //       the TLS chunk we expect?  I don't know Windows
-            //       well enough to say.
-            auto pstart = cast(void*) &_tlsstart;
-            auto pend   = cast(void*) &_tlsend;
-            auto pos    = GetTlsDataAddress( thisThread.m_hndl );
-            if( pos ) // on x64, threads without TLS happen to exist
-                thisThread.m_tls = pos[0 .. pend - pstart];
-            else
-                thisThread.m_tls = [];
+            thisThread.m_hndl = OpenThreadHandle( addr );
+            impersonate_thread(addr, { thisThread.m_tlsgcdata = rt.tlsgc.init(); });
         }
 
         Thread.add( thisThread );
         Thread.add( thisContext );
         if( Thread.sm_main !is null )
             multiThreadedFlag = true;
-        thisThread.m_tlsgcdata = rt.tlsgc.init();
         return thisThread;
     }
 }
@@ -2632,16 +2492,15 @@ private void scanAllTypeImpl( scope ScanAllThreadsTypeFn scan, void* curStackTop
 
     for( Thread t = Thread.sm_tbeg; t; t = t.next )
     {
-        scan( ScanType.tls, t.m_tls.ptr, t.m_tls.ptr + t.m_tls.length );
-
         version( Windows )
         {
             // Ideally, we'd pass ScanType.regs or something like that, but this
             // would make portability annoying because it only makes sense on Windows.
             scan( ScanType.stack, t.m_reg.ptr, t.m_reg.ptr + t.m_reg.length );
         }
 
-        rt.tlsgc.scan(t.m_tlsgcdata, (p1, p2) => scan(ScanType.tls, p1, p2));
+        if (t.m_tlsgcdata !is null)
+            rt.tlsgc.scan(t.m_tlsgcdata, (p1, p2) => scan(ScanType.tls, p1, p2));
     }
 }
 
@@ -4534,38 +4393,3 @@ version( AsmX86_64_Posix )
         fib.call();
     }
 }
-
-
-version( OSX )
-{
-    // NOTE: The Mach-O object file format does not allow for thread local
-    //       storage declarations. So instead we roll our own by putting tls
-    //       into the sections bracketed by _tls_beg and _tls_end.
-    //
-    //       This function is called by the code emitted by the compiler.  It
-    //       is expected to translate an address into the TLS static data to
-    //       the corresponding address in the TLS dynamic per-thread data.
-    extern (D) void* ___tls_get_addr( void* p )
-    {
-        // NOTE: p is an address in the TLS static data emitted by the
-        //       compiler.  If it isn't, something is disastrously wrong.
-        auto obj = Thread.getThis();
-
-        immutable off0 = cast(size_t)(p - _tls_data_array[0].ptr);
-        if (off0 < _tls_data_array[0].length)
-        {
-            return obj.m_tls.ptr + off0;
-        }
-        immutable off1 = cast(size_t)(p - _tls_data_array[1].ptr);
-        if (off1 < _tls_data_array[1].length)
-        {
-            size_t sz = (_tls_data_array[0].length + 15) & ~cast(size_t)15;
-            return obj.m_tls.ptr + sz + off1;
-        }
-        else
-            assert(0);
-
-        //assert( p >= cast(void*) &_tls_beg && p < cast(void*) &_tls_end );
-        //return obj.m_tls.ptr + (p - cast(void*) &_tls_beg);
-    }
-}