First attempt at support for dynamic library loading and unloading. Currently, only...

git-svn-id: http://svn.dsource.org/projects/druntime/trunk@38 4a9d5153-6564-4b3f-b5e1-7e8e9dac548f

diff --git a/src/common/core/runtime.d b/src/common/core/runtime.d
index 36607bec0129b093b2348cea43cb742fda492112..3344f2372d58b597932c3ba08465e5b31d06562e 100644 (file)
--- a/src/common/core/runtime.d
+++ b/src/common/core/runtime.d
@@ -24,7 +24,7 @@ private
     extern (C) bool rt_term( ExceptionHandler dg = null );
 
     extern (C) void* rt_loadLibrary( in char[] name );
-    extern (C) void  rt_unloadLibrary( void* ptr );
+    extern (C) bool  rt_unloadLibrary( void* ptr );
 }
 
 
@@ -116,9 +116,9 @@ struct Runtime
      * Params:
      *  p = A reference to the library to unload.
      */
-    static void unloadLibrary( void* p )
+    static bool unloadLibrary( void* p )
     {
-        rt_unloadLibrary( p );
+        return rt_unloadLibrary( p );
     }
 
 

diff --git a/src/compiler/dmd/dmain2.d b/src/compiler/dmd/dmain2.d
index 1991bd9cae43d40aeb300190860cf92623d1866e..8bccd62f258a7c42784ee6b9c37ed70584f04172 100644 (file)
--- a/src/compiler/dmd/dmain2.d
+++ b/src/compiler/dmd/dmain2.d
@@ -12,6 +12,7 @@ module rt.dmain2;
 
 private
 {
+    import memory;
     import util.console;
     import core.stdc.stddef;
     import core.stdc.stdlib;
@@ -48,15 +49,13 @@ extern (C) void thread_joinAll();
  */
 extern (C)
 {
-    void* gc_getHandle();
-    void  gc_setHandle(void* p);
-    void  gc_clrHandle();
+    void* gc_getProxy();
+    void  gc_setProxy(void* p);
+    void  gc_clrProxy();
 
     alias void* function()      gcGetFn;
     alias void  function(void*) gcSetFn;
     alias void  function()      gcClrFn;
-    alias bool  function(ExceptionHandler dg = null) rtInitFn;
-    alias bool  function(ExceptionHandler dg = null) rtTermFn;
 }
 
 extern (C) void* rt_loadLibrary(in char[] name)
@@ -69,12 +68,9 @@ extern (C) void* rt_loadLibrary(in char[] name)
         void* ptr = LoadLibraryA(temp.ptr);
         if (ptr is null)
             return ptr;
-        gcSetFn  gcSet = cast(gcSetFn) GetProcAddress(ptr, "_gc_setHandle");
-        rtInitFn rtInit = cast(rtInitFn) GetProcAddress(ptr, "_rt_init");
-        if (gcSet is null || rtInit is null)
-            return ptr;
-        gcSet(gc_getHandle());
-        rtInit();
+        gcSetFn gcSet = cast(gcSetFn) GetProcAddress(ptr, "gc_setProxy");
+        if (gcSet !is null)
+            gcSet(gc_getProxy());
         return ptr;
 
     }
@@ -84,18 +80,13 @@ extern (C) void* rt_loadLibrary(in char[] name)
     }
 }
 
-extern (C) void rt_unloadLibrary(void* ptr)
+extern (C) bool rt_unloadLibrary(void* ptr)
 {
     version (Windows)
     {
-        gcClrFn  gcClr  = cast(gcClrFn) GetProcAddress(ptr, "_gc_clrHandle");
-        rtTermFn rtTerm = cast(rtTermFn) GetProcAddress(ptr, "_rt_term");
-
-        if (gcClr !is null && rtTerm !is null)
-        {
-            rtTerm();
+        gcClrFn gcClr  = cast(gcClrFn) GetProcAddress(ptr, "gc_clrProxy");
+        if (gcClr !is null)
             gcClr();
-        }
         return FreeLibrary(ptr) != 0;
     }
     else version (linux)
@@ -178,6 +169,7 @@ extern (C) bool rt_init(ExceptionHandler dg = null)
     try
     {
         gc_init();
+        initStaticDataGC();
         version (Windows)
             _minit();
         _moduleCtor();
@@ -359,6 +351,7 @@ extern (C) int main(int argc, char **argv)
     void runAll()
     {
         gc_init();
+        initStaticDataGC();
         version (Windows)
             _minit();
         _moduleCtor();

diff --git a/src/compiler/dmd/memory.d b/src/compiler/dmd/memory.d
index 5f09d7ed9c2bc05b95800e9b4021ac241d8e14f4..afd2d9010d14c0ea0c09bbcf57e9f14634f7482c 100644 (file)
--- a/src/compiler/dmd/memory.d
+++ b/src/compiler/dmd/memory.d
@@ -37,6 +37,8 @@ private
             extern (C) extern void* __libc_stack_end;
         }
     }
+    extern (C) void gc_addRange( void* p, size_t sz );
+    extern (C) void gc_removeRange( void *p );
 }
 
 
@@ -130,50 +132,18 @@ private
             alias __data_start  Data_Start;
             alias _end          Data_End;
     }
-
-    alias void delegate( void*, void* ) scanFn;
 }
 
 
-/**
- *
- */
-extern (C) void rt_scanStaticData( scanFn scan )
-{
-    scan(rt_staticDataBottom(), rt_staticDataTop());
-}
-
-/**
- *
- */
-extern (C) void* rt_staticDataBottom()
-{
-    version( Windows )
-    {
-        return &_xi_a;
-    }
-    else version( linux )
-    {
-        return &__data_start;
-    }
-    else
-    {
-        static assert( false, "Operating system not supported." );
-    }
-}
-
-/**
- *
- */
-extern (C) void* rt_staticDataTop()
+void initStaticDataGC()
 {
     version( Windows )
     {
-        return &_end;
+        gc_addRange( &_xi_a, &_end - &_xi_a );
     }
     else version( linux )
     {
-        return &_end;
+        gc_addRange( &__data_start, &_end - &__data_start );
     }
     else
     {

diff --git a/src/gc/basic/gc.d b/src/gc/basic/gc.d
index 3f8a642e6bd34bc0900da9184f302ac19797f209..6b2418299c7cbfbaa3ab60b0a865823d37b85d26 100644 (file)
--- a/src/gc/basic/gc.d
+++ b/src/gc/basic/gc.d
@@ -79,133 +79,241 @@ extern (C) void gc_term()
 
 extern (C) void gc_enable()
 {
-    _gc.enable();
+    if( proxy is null )
+        return _gc.enable();
+    return proxy.gc_enable();
 }
 
 extern (C) void gc_disable()
 {
-    _gc.disable();
+    if( proxy is null )
+        return _gc.disable();
+    return proxy.gc_disable();
 }
 
 extern (C) void gc_collect()
 {
-    _gc.fullCollect();
+    if( proxy is null )
+        return _gc.fullCollect();
+    return proxy.gc_collect();
 }
 
 
 extern (C) void gc_minimize()
 {
-    _gc.minimize();
+    if( proxy is null )
+        return _gc.minimize();
+    return proxy.gc_minimize();
 }
 
 extern (C) uint gc_getAttr( void* p )
 {
-    return _gc.getAttr( p );
+    if( proxy is null )
+        return _gc.getAttr( p );
+    return proxy.gc_getAttr( p );
 }
 
 extern (C) uint gc_setAttr( void* p, uint a )
 {
-    return _gc.setAttr( p, a );
+    if( proxy is null )
+        return _gc.setAttr( p, a );
+    return proxy.gc_setAttr( p, a );
 }
 
 extern (C) uint gc_clrAttr( void* p, uint a )
 {
-    return _gc.clrAttr( p, a );
+    if( proxy is null )
+        return _gc.clrAttr( p, a );
+    return proxy.gc_clrAttr( p, a );
 }
 
 extern (C) void* gc_malloc( size_t sz, uint ba = 0 )
 {
-    return _gc.malloc( sz, ba );
+    if( proxy is null )
+        return _gc.malloc( sz, ba );
+    return proxy.gc_malloc( sz, ba );
 }
 
 extern (C) void* gc_calloc( size_t sz, uint ba = 0 )
 {
-    return _gc.calloc( sz, ba );
+    if( proxy is null )
+        return _gc.calloc( sz, ba );
+    return proxy.gc_calloc( sz, ba );
 }
 
 extern (C) void* gc_realloc( void* p, size_t sz, uint ba = 0 )
 {
-    return _gc.realloc( p, sz, ba );
+    if( proxy is null )
+        return _gc.realloc( p, sz, ba );
+    return proxy.gc_realloc( p, sz, ba );
 }
 
 extern (C) size_t gc_extend( void* p, size_t mx, size_t sz )
 {
-    return _gc.extend( p, mx, sz );
+    if( proxy is null )
+        return _gc.extend( p, mx, sz );
+    return proxy.gc_extend( p, mx, sz );
 }
 
 extern (C) size_t gc_reserve( size_t sz )
 {
-    return _gc.reserve( sz );
+    if( proxy is null )
+        return _gc.reserve( sz );
+    return proxy.gc_reserve( sz );
 }
 
 extern (C) void gc_free( void* p )
 {
-    _gc.free( p );
+    if( proxy is null )
+        return _gc.free( p );
+    return proxy.gc_free( p );
 }
 
 extern (C) void* gc_addrOf( void* p )
 {
-    return _gc.addrOf( p );
+    if( proxy is null )
+        return _gc.addrOf( p );
+    return proxy.gc_addrOf( p );
 }
 
 extern (C) size_t gc_sizeOf( void* p )
 {
-    return _gc.sizeOf( p );
+    if( proxy is null )
+        return _gc.sizeOf( p );
+    return proxy.gc_sizeOf( p );
 }
 
 extern (C) BlkInfo gc_query( void* p )
 {
-    return _gc.query( p );
+    if( proxy is null )
+        return _gc.query( p );
+    return proxy.gc_query( p );
 }
 
 // NOTE: This routine is experimental.  The stats or function name may change
 //       before it is made officially available.
 extern (C) GCStats gc_stats()
 {
-    GCStats stats = void;
-    _gc.getStats( stats );
-    return stats;
+    if( proxy is null )
+    {
+        GCStats stats = void;
+        _gc.getStats( stats );
+        return stats;
+    }
+    // TODO: Add proxy support for this once the layout of GCStats is
+    //       finalized.
+    //return proxy.gc_stats();
+    return GCStats.init;
 }
 
 extern (C) void gc_addRoot( void* p )
 {
-    _gc.addRoot( p );
+    if( proxy is null )
+        return _gc.addRoot( p );
+    return proxy.gc_addRoot( p );
 }
 
 extern (C) void gc_addRange( void* p, size_t sz )
 {
-    _gc.addRange( p, sz );
+    if( proxy is null )
+        return _gc.addRange( p, sz );
+    return proxy.gc_addRange( p, sz );
 }
 
-extern (C) void gc_removeRoot( void *p )
+extern (C) void gc_removeRoot( void* p )
 {
-    _gc.removeRoot( p );
+    if( proxy is null )
+        return _gc.removeRoot( p );
+    return proxy.gc_removeRoot( p );
 }
 
-extern (C) void gc_removeRange( void *p )
+extern (C) void gc_removeRange( void* p )
 {
-    _gc.removeRange( p );
+    if( proxy is null )
+        return _gc.removeRange( p );
+    return proxy.gc_removeRange( p );
 }
 
-extern (C) void* gc_getHandle()
+struct Proxy
 {
-    return cast(void*)_gc;
+    extern (C) void function() gc_enable;
+    extern (C) void function() gc_disable;
+    extern (C) void function() gc_collect;
+    extern (C) void function() gc_minimize;
+
+    extern (C) uint function(void*) gc_getAttr;
+    extern (C) uint function(void*, uint) gc_setAttr;
+    extern (C) uint function(void*, uint) gc_clrAttr;
+
+    extern (C) void*  function(size_t, uint) gc_malloc;
+    extern (C) void*  function(size_t, uint) gc_calloc;
+    extern (C) void*  function(void*, size_t, uint ba) gc_realloc;
+    extern (C) size_t function(void*, size_t, size_t) gc_extend;
+    extern (C) size_t function(size_t) gc_reserve;
+    extern (C) void   function(void*) gc_free;
+
+    extern (C) void*   function(void*) gc_addrOf;
+    extern (C) size_t  function(void*) gc_sizeOf;
+
+    extern (C) BlkInfo function(void*) gc_query;
+
+    extern (C) void function(void*) gc_addRoot;
+    extern (C) void function(void*, size_t) gc_addRange;
+
+    extern (C) void function(void*) gc_removeRoot;
+    extern (C) void function(void*) gc_removeRange;
 }
 
-extern (C) void gc_setHandle(void* p)
+Proxy  pthis;
+Proxy* proxy;
+
+static this()
 {
-    void* oldp = gc_getHandle();
-    gc_t g = cast(gc_t)p;
-    if (g.gcversion != gcx.GCVERSION)
-        throw new Error("incompatible gc versions");
+    pthis.gc_enable = &gc_enable;
+    pthis.gc_disable = &gc_disable;
+    pthis.gc_collect = &gc_collect;
+    pthis.gc_minimize = &gc_minimize;
+
+    pthis.gc_getAttr = &gc_getAttr;
+    pthis.gc_setAttr = &gc_setAttr;
+    pthis.gc_clrAttr = &gc_clrAttr;
+
+    pthis.gc_malloc = &gc_malloc;
+    pthis.gc_calloc = &gc_calloc;
+    pthis.gc_realloc = &gc_realloc;
+    pthis.gc_extend = &gc_extend;
+    pthis.gc_reserve = &gc_reserve;
+    pthis.gc_free = &gc_free;
 
-    // Add our static data to the new gc
-    GC.scanStaticData(g);
+    pthis.gc_addrOf = &gc_addrOf;
+    pthis.gc_sizeOf = &gc_sizeOf;
 
-    _gc = g;
+    pthis.gc_query = &gc_query;
+
+    pthis.gc_addRoot = &gc_addRoot;
+    pthis.gc_addRange = &gc_addRange;
+
+    pthis.gc_removeRoot = &gc_removeRoot;
+    pthis.gc_removeRange = &gc_removeRange;
+}
+
+extern (C) Proxy* gc_getProxy()
+{
+    return &pthis;
+}
+
+export extern (C) void gc_setProxy( Proxy* p )
+{
+    if( proxy !is null )
+    {
+        // TODO: Decide if this is an error condition.
+    }
+    proxy = p;
+    // TODO: Add known ranges and roots to the proxy.
 }
 
-extern (C) void gc_endHandle()
+export extern (C) void gc_clrProxy()
 {
-    GC.unscanStaticData(_gc);
+    // TODO: Remove known ranges and roots from the proxy.
+    proxy = null;
 }

diff --git a/src/gc/basic/gcx.d b/src/gc/basic/gcx.d
index 0b6d1d0154e5042739a1b7c626adf3f0ab1ec64b..4c6396e72f7586e3a3403e8bd85f9d55b167e129 100644 (file)
--- a/src/gc/basic/gcx.d
+++ b/src/gc/basic/gcx.d
@@ -86,21 +86,16 @@ private
 
     extern (C) void* rt_stackBottom();
     extern (C) void* rt_stackTop();
-    extern (C) void* rt_staticDataBottom();
-    extern (C) void* rt_staticDataTop();
 
     extern (C) void rt_finalize( void* p, bool det = true );
 
-    alias void delegate( void*, void* ) scanFn;
-
-    extern (C) void rt_scanStaticData( scanFn scan );
-
     version (MULTI_THREADED)
     {
         extern (C) bool thread_needLock();
         extern (C) void thread_suspendAll();
         extern (C) void thread_resumeAll();
 
+        alias void delegate( void*, void* ) scanFn;
         extern (C) void thread_scanAll( scanFn fn, void* curStackTop = null );
     }
 
@@ -1126,21 +1121,6 @@ class GC
     }
 
 
-    static void scanStaticData(gc_t g)
-    {
-        //debug(PRINTF) printf("+GC.scanStaticData()\n");
-        auto pbot = rt_staticDataBottom();
-        auto ptop = rt_staticDataTop();
-        g.addRange(pbot, ptop - pbot);
-        //debug(PRINTF) printf("-GC.scanStaticData()\n");
-    }
-
-    static void unscanStaticData(gc_t g)
-    {
-        auto pbot = rt_staticDataBottom();
-        g.removeRange(pbot);
-    }
-
     /**
      * add p to list of roots
      */
@@ -2262,8 +2242,6 @@ struct Gcx
             pool.mark.copy(&pool.freebits);
         }
 
-        rt_scanStaticData( &mark );
-
         version (MULTI_THREADED)
         {
             if (!noStack)

diff --git a/src/gc/stub/gc.d b/src/gc/stub/gc.d
index dd805ef45a6069bdee0b55e915b6a2dd20ea44fd..a5426ff8fa182b8b9fba614066402ea6868c359e 100644 (file)
--- a/src/gc/stub/gc.d
+++ b/src/gc/stub/gc.d
@@ -57,126 +57,251 @@ extern (C) void gc_term()
 
 extern (C) void gc_enable()
 {
-
+    if( proxy is null )
+        return;
+    return proxy.gc_enable();
 }
 
 extern (C) void gc_disable()
 {
-
+    if( proxy is null )
+        return;
+    return proxy.gc_disable();
 }
 
 extern (C) void gc_collect()
 {
-
+    if( proxy is null )
+        return;
+    return proxy.gc_collect();
 }
 
 extern (C) void gc_minimize()
 {
-
+    if( proxy is null )
+        return;
+    return proxy.gc_minimize();
 }
 
 extern (C) uint gc_getAttr( void* p )
 {
-    return 0;
+    if( proxy is null )
+        return 0;
+    return proxy.gc_getAttr( p );
 }
 
 extern (C) uint gc_setAttr( void* p, uint a )
 {
-    return 0;
+    if( proxy is null )
+        return 0;
+    return proxy.gc_setAttr( p, a );
 }
 
 extern (C) uint gc_clrAttr( void* p, uint a )
 {
-    return 0;
+    if( proxy is null )
+        return 0;
+    return proxy.gc_clrAttr( p, a );
 }
 
 extern (C) void* gc_malloc( size_t sz, uint ba = 0 )
 {
-    void* p = malloc( sz );
+    if( proxy is null )
+    {
+        void* p = malloc( sz );
 
-    if( sz && p is null )
-        onOutOfMemoryError();
-    return p;
+        if( sz && p is null )
+            onOutOfMemoryError();
+        return p;
+    }
+    return proxy.gc_malloc( sz, ba );
 }
 
 extern (C) void* gc_calloc( size_t sz, uint ba = 0 )
 {
-    void* p = calloc( 1, sz );
+    if( proxy is null )
+    {
+        void* p = calloc( 1, sz );
 
-    if( sz && p is null )
-        onOutOfMemoryError();
-    return p;
+        if( sz && p is null )
+            onOutOfMemoryError();
+        return p;
+    }
+    return proxy.gc_calloc( sz, ba );
 }
 
 extern (C) void* gc_realloc( void* p, size_t sz, uint ba = 0 )
 {
-    p = realloc( p, sz );
+    if( proxy is null )
+    {
+        p = realloc( p, sz );
 
-    if( sz && p is null )
-        onOutOfMemoryError();
-    return p;
+        if( sz && p is null )
+            onOutOfMemoryError();
+        return p;
+    }
+    return proxy.gc_realloc( p, sz, ba );
 }
 
 extern (C) size_t gc_extend( void* p, size_t mx, size_t sz )
 {
-    return 0;
+    if( proxy is null )
+        return 0;
+    return proxy.gc_extend( p, mx, sz );
 }
 
 extern (C) size_t gc_reserve( size_t sz )
 {
-    return 0;
+    if( proxy is null )
+        return 0;
+    return proxy.gc_reserve( sz );
 }
 
 extern (C) void gc_free( void* p )
 {
-    free( p );
+    if( proxy is null )
+        return free( p );
+    return proxy.gc_free( p );
 }
 
 extern (C) void* gc_addrOf( void* p )
 {
-    return null;
+    if( proxy is null )
+        return null;
+    return proxy.gc_addrOf( p );
 }
 
 extern (C) size_t gc_sizeOf( void* p )
 {
-    return 0;
+    if( proxy is null )
+        return 0;
+    return proxy.gc_sizeOf( p );
 }
 
 extern (C) BlkInfo gc_query( void* p )
 {
-    return BlkInfo.init;
+    if( proxy is null )
+        return BlkInfo.init;
+    return proxy.gc_query( p );
 }
 
+// TODO: Implement range storage.
+// TODO: Implement root storage.
+
 extern (C) void gc_addRoot( void* p )
 {
-
+    if( proxy is null )
+        return;
+    return proxy.gc_addRoot( p );
 }
 
 extern (C) void gc_addRange( void* p, size_t sz )
 {
-
+    if( proxy is null )
+        return;
+    return proxy.gc_addRange( p, sz );
 }
 
 extern (C) void gc_removeRoot( void *p )
 {
-
+    if( proxy is null )
+        return;
+    return proxy.gc_removeRoot( p );
 }
 
 extern (C) void gc_removeRange( void *p )
 {
+    if( proxy is null )
+        return;
+    return proxy.gc_removeRange( p );
+}
+
+struct Proxy
+{
+    extern (C) void function() gc_enable;
+    extern (C) void function() gc_disable;
+    extern (C) void function() gc_collect;
+    extern (C) void function() gc_minimize;
+
+    extern (C) uint function(void*) gc_getAttr;
+    extern (C) uint function(void*, uint) gc_setAttr;
+    extern (C) uint function(void*, uint) gc_clrAttr;
+
+    extern (C) void*  function(size_t, uint) gc_malloc;
+    extern (C) void*  function(size_t, uint) gc_calloc;
+    extern (C) void*  function(void*, size_t, uint ba) gc_realloc;
+    extern (C) size_t function(void*, size_t, size_t) gc_extend;
+    extern (C) size_t function(size_t) gc_reserve;
+    extern (C) void   function(void*) gc_free;
+
+    extern (C) void*   function(void*) gc_addrOf;
+    extern (C) size_t  function(void*) gc_sizeOf;
 
+    extern (C) BlkInfo function(void*) gc_query;
+
+    extern (C) void function(void*) gc_addRoot;
+    extern (C) void function(void*, size_t) gc_addRange;
+
+    extern (C) void function(void*) gc_removeRoot;
+    extern (C) void function(void*) gc_removeRange;
 }
 
-extern (C) void* gc_getHandle()
+Proxy  pthis;
+Proxy* proxy;
+
+static this()
 {
-    return null;
+    pthis.gc_enable = &gc_enable;
+    pthis.gc_disable = &gc_disable;
+    pthis.gc_collect = &gc_collect;
+    pthis.gc_minimize = &gc_minimize;
+
+    pthis.gc_getAttr = &gc_getAttr;
+    pthis.gc_setAttr = &gc_setAttr;
+    pthis.gc_clrAttr = &gc_clrAttr;
+
+    pthis.gc_malloc = &gc_malloc;
+    pthis.gc_calloc = &gc_calloc;
+    pthis.gc_realloc = &gc_realloc;
+    pthis.gc_extend = &gc_extend;
+    pthis.gc_reserve = &gc_reserve;
+    pthis.gc_free = &gc_free;
+
+    pthis.gc_addrOf = &gc_addrOf;
+    pthis.gc_sizeOf = &gc_sizeOf;
+
+    pthis.gc_query = &gc_query;
+
+    pthis.gc_addRoot = &gc_addRoot;
+    pthis.gc_addRange = &gc_addRange;
+
+    pthis.gc_removeRoot = &gc_removeRoot;
+    pthis.gc_removeRange = &gc_removeRange;
 }
 
-extern (C) void gc_setHandle(void* p)
+extern (C) Proxy* gc_getProxy()
 {
+    return &pthis;
 }
 
-extern (C) void gc_endHandle()
+export extern (C) void gc_setProxy( Proxy* p )
 {
+    if( proxy !is null )
+    {
+        // error?
+    }
+    proxy = p;
+    ///foreach range
+    //proxy.addRange();
+    //foreach root
+    //proxy.addRoot()
 }
 
+export extern (C) void gc_clrProxy()
+{
+    // foreach root
+    // proxy.removeRoot();
+    // foreach range
+    // proxy.removeReange();
+    proxy = null;
+}
\ No newline at end of file