| |
 | Posted by Walter Bright |  Permalink Reply |
|
Walter Bright 
| Most likely a change in druntime broke this. Windows, obviously.
======================================================
..\dmd -g -d -ofmydll2.dll -version=use_patch mydll2.d dll2.d mydll2.def
std.contracts has been scheduled for deprecation. Please use
std.exception instead.
implib /system mydll2.lib mydll2.dll
Digital Mars Import Library Manager Version 8.41n
Copyright (C) Digital Mars 2000-2004 All Rights Reserved,
www.digitalmars.com
implib/h for help
Input is a Windows NT DLL file 'MYDLL2.DLL'.
Output is a Windows NT import library.
Digital Mars Import Library Creator complete.
..\dmd -g -d testmydll2.d mydll2.lib
testmydll2
hello dll world
hello dll world
---- hangs here ----
================== mydll2.d ==================
module mydll2;
import std.stdio;
version(D_Version2)
{
import core.memory;
}
else
{
import std.gc;
}
export void dllprint()
{
writefln("hello dll world");
}
int glob;
// test access to (tls) globals
export int getglob()
{
return glob;
}
// test gc-mem-allocation from different threads
export char* alloc(int sz)
{
char* p = (new char[sz]).ptr;
version(D_Version2)
GC.addRange(p, sz);
else
addRange(p, p + sz);
return p;
}
export void free(char* p, int sz)
{
version(D_Version2)
GC.removeRange(p);
else
removeRange(p);
// delete p;
}
================== dll2.d =================
// Public Domain
import std.c.windows.windows;
import std.c.stdlib;
version(D_Version2)
{
import core.runtime;
import core.memory;
version(use_patch)
import core.dll_helper;
import core.stdc.string;
extern (C) void _moduleTlsCtor();
extern (C) void _moduleTlsDtor();
}
else
{
import std.gc;
import std.thread;
version(use_patch)
import std.thread_helper;
extern (C)
{
void gc_init();
void gc_term();
void _minit();
void _moduleCtor();
void _moduleDtor();
void _moduleUnitTests();
}
}
extern (Windows)
BOOL DllMain(HINSTANCE hInstance, ULONG ulReason, LPVOID pvReserved)
{
switch (ulReason)
{
case DLL_PROCESS_ATTACH:
version(D_Version2)
{
version(use_patch)
{
if( !dll_fixTLS( hInstance, &_tlsstart, &_tlsend,
&_tls_callbacks_a, &_tls_index ) )
return false;
thread_setNeedLock(true);
Runtime.initialize();
// attach to all other threads
enumProcessThreads( function (uint id, void* context) {
if( !Thread.findThread( id ) )
{
thread_attach( id );
thread_moduleTlsCtor( id );
}
return true;
}, null );
}
else
Runtime.initialize();
}
else
{
gc_init(); // initialize GC
_minit(); // initialize module list
_moduleCtor(); // run module constructors
_moduleUnitTests(); // run module unit tests
version(use_patch)
{
// attach to all other threads
enumProcessThreads( function (uint id, void* context) {
if( !Thread._getThreadById( id ) )
Thread.thread_attach( id, OpenThreadHandle( id ),
getThreadStackBottom( id ) );
return true;
}, null );
}
// enumThreads();
}
break;
case DLL_PROCESS_DETACH:
version(D_Version2)
{
version(use_patch)
{
// detach from all other threads
enumProcessThreads(
function (uint id, void* context) {
if( id != GetCurrentThreadId() && Thread.findThread( id ) )
thread_detach( id );
return true;
}, null );
}
Runtime.terminate();
}
else
{
version(use_patch)
{
// detach from all other threads
enumProcessThreads(
function (uint id, void* context) {
if( id != GetCurrentThreadId() )
{
thread_moduleTlsDtor( id );
Thread.thread_detach( id );
}
return true;
}, null );
}
_moduleDtor();
gc_term(); // shut down GC
}
break;
case DLL_THREAD_ATTACH:
version(use_patch)
{
version(D_Version2)
{
thread_attachThis();
_moduleTlsCtor();
}
else
Thread.thread_attach();
}
break;
case DLL_THREAD_DETACH:
version(use_patch)
{
version(D_Version2)
{
if( Thread.findThread( GetCurrentThreadId() ) )
_moduleTlsDtor();
thread_detachThis();
}
else
Thread.thread_detach();
}
break;
}
return true;
}
====================== mydll2.def ================
LIBRARY "mydll2.dll"
EXETYPE NT
SUBSYSTEM WINDOWS
CODE SHARED EXECUTE
DATA WRITE
===================== testmydll2.d ===================
version(D_Version2)
{
const string d2_shared = " __gshared ";
}
else
{
const string d2_shared = "";
}
version(dynload)
{
extern(Windows) void* LoadLibraryA(in char* dll);
extern(Windows) void* GetProcAddress(void* lib, in char* name);
typedef void fnDllPrint();
typedef int fnGetglob();
typedef char* fnAlloc(int sz);
typedef void fnFree(char* p, int sz);
mixin(d2_shared ~ "fnDllPrint* pDllPrint;");
mixin(d2_shared ~ "fnGetglob* pGetglob;");
mixin(d2_shared ~ "fnAlloc* pAlloc;");
mixin(d2_shared ~ "fnFree* pFree;");
int loadLib()
{
void* lib = LoadLibraryA("mydll2.dll".ptr);
assert(lib);
pDllPrint = cast(fnDllPrint*) GetProcAddress(lib,
"D6mydll28dllprintFZv".ptr);
pFree = cast(fnFree*) GetProcAddress(lib,
"D6mydll24freeFPaiZv".ptr);
pAlloc = cast(fnAlloc*) GetProcAddress(lib,
"D6mydll25allocFiZPa".ptr);
pGetglob = cast(fnGetglob*) GetProcAddress(lib,
"D6mydll27getglobFZi".ptr);
assert(pDllPrint && pFree && pAlloc && pGetglob);
return 0;
}
void dllprint()
{
(*pDllPrint)();
}
int getglob()
{
return (*pGetglob)();
}
char* alloc(int sz)
{
return (*pAlloc)(sz);
}
void free(char* p, int sz)
{
(*pFree)(p, sz);
}
}
else
{
import mydll2;
}
mixin(d2_shared ~ "Object syncobj;");
void runtest()
{
// wait until lib loaded
synchronized(syncobj) getglob();
//int g = mydll.glob;
char*[] mem;
for(int i = 0; i < 10000; i++)
{
mem ~= alloc(16);
}
for(int i = 0; i < 10000; i++)
{
free(mem[i], 16);
}
dllprint();
}
version(D_Version2)
{
import core.thread;
class TestThread : Thread
{
this()
{
super(&runtest);
}
}
}
else
{
import std.thread;
class TestThread : Thread
{
int run()
{
runtest();
return 0;
}
void join()
{
wait();
}
}
}
void test_threaded()
{
syncobj = new Object;
TestThread[] th;
for(int i = 0; i < 10; i++)
th ~= new TestThread();
// don't run threads before lib loaded
synchronized(syncobj)
{
for(int i = 0; i < 5; i++)
th[i].start();
// create some threads before loading the lib, other later
version(dynload) loadLib();
}
for(int i = 5; i < 10; i++)
th[i].start();
for(int i = 0; i < 10; i++)
th[i].join();
}
int main()
{
test_threaded();
return 0;
}
===============================================
|
