diff options
Diffstat (limited to 'boehm_gc/win32_threads.c')
| -rw-r--r-- | boehm_gc/win32_threads.c | 1570 |
1 files changed, 1570 insertions, 0 deletions
diff --git a/boehm_gc/win32_threads.c b/boehm_gc/win32_threads.c new file mode 100644 index 0000000..ac57971 --- /dev/null +++ b/boehm_gc/win32_threads.c @@ -0,0 +1,1570 @@ +#include "private/gc_priv.h" + +#if defined(GC_WIN32_THREADS) + +#include <windows.h> + +#ifdef THREAD_LOCAL_ALLOC +# include "private/thread_local_alloc.h" +#endif /* THREAD_LOCAL_ALLOC */ + +/* Allocation lock declarations. */ +#if !defined(USE_PTHREAD_LOCKS) +# if defined(GC_DLL) + __declspec(dllexport) CRITICAL_SECTION GC_allocate_ml; +# else + CRITICAL_SECTION GC_allocate_ml; +# endif + DWORD GC_lock_holder = NO_THREAD; + /* Thread id for current holder of allocation lock */ +#else + pthread_mutex_t GC_allocate_ml = PTHREAD_MUTEX_INITIALIZER; + unsigned long GC_lock_holder = NO_THREAD; +#endif + +#ifdef GC_PTHREADS +# include <errno.h> + +/* GC_DLL should not normally be defined, especially since we often do turn */ +/* on THREAD_LOCAL_ALLOC, which is currently incompatible. */ +/* It might be possible to get GC_DLL and DllMain-based thread registration */ +/* to work with Cygwin, but if you try you are on your own. */ +#ifdef GC_DLL +# error GC_DLL untested with Cygwin +#endif + + /* Cygwin-specific forward decls */ +# undef pthread_create +# undef pthread_sigmask +# undef pthread_join +# undef pthread_detach +# undef dlopen + +# ifdef DEBUG_THREADS +# ifdef CYGWIN32 +# define DEBUG_CYGWIN_THREADS 1 +# define DEBUG_WIN32_PTHREADS 0 +# else +# define DEBUG_WIN32_PTHREADS 1 +# define DEBUG_CYGWIN_THREADS 0 +# endif +# else +# define DEBUG_CYGWIN_THREADS 0 +# define DEBUG_WIN32_PTHREADS 0 +# endif + + void * GC_pthread_start(void * arg); + void GC_thread_exit_proc(void *arg); + +# include <pthread.h> + +#else + +# ifdef DEBUG_THREADS +# define DEBUG_WIN32_THREADS 1 +# else +# define DEBUG_WIN32_THREADS 0 +# endif + +# undef CreateThread +# undef ExitThread +# undef _beginthreadex +# undef _endthreadex +# undef _beginthread +# ifdef DEBUG_THREADS +# define DEBUG_WIN32_THREADS 1 +# else +# define DEBUG_WIN32_THREADS 0 +# endif + +# include <process.h> /* For _beginthreadex, _endthreadex */ + +#endif + +#if defined(GC_DLL) && !defined(MSWINCE) + static GC_bool GC_win32_dll_threads = FALSE; + /* This code operates in two distinct modes, depending on */ + /* the setting of GC_win32_dll_threads. If */ + /* GC_win32_dll_threads is set, all threads in the process */ + /* are implicitly registered with the GC by DllMain. */ + /* No explicit registration is required, and attempts at */ + /* explicit registration are ignored. This mode is */ + /* very different from the Posix operation of the collector. */ + /* In this mode access to the thread table is lock-free. */ + /* Hence there is a static limit on the number of threads. */ + + /* If GC_win32_dll_threads is FALSE, or the collector is */ + /* built without GC_DLL defined, things operate in a way */ + /* that is very similar to Posix platforms, and new threads */ + /* must be registered with the collector, e.g. by using */ + /* preprocessor-based interception of the thread primitives. */ + /* In this case, we use a real data structure for the thread */ + /* table. Note that there is no equivalent of linker-based */ + /* call interception, since we don't have ELF-like */ + /* facilities. The Windows analog appears to be "API */ + /* hooking", which really seems to be a standard way to */ + /* do minor binary rewriting (?). I'd prefer not to have */ + /* the basic collector rely on such facilities, but an */ + /* optional package that intercepts thread calls this way */ + /* would probably be nice. */ + + /* GC_win32_dll_threads must be set at initialization time, */ + /* i.e. before any collector or thread calls. We make it a */ + /* "dynamic" option only to avoid multiple library versions. */ +#else +# define GC_win32_dll_threads FALSE +#endif + +/* We have two versions of the thread table. Which one */ +/* we us depends on whether or not GC_win32_dll_threads */ +/* is set. Note that before initialization, we don't */ +/* add any entries to either table, even if DllMain is */ +/* called. The main thread will be added on */ +/* initialization. */ + +/* The type of the first argument to InterlockedExchange. */ +/* Documented to be LONG volatile *, but at least gcc likes */ +/* this better. */ +typedef LONG * IE_t; + +GC_bool GC_thr_initialized = FALSE; + +GC_bool GC_need_to_lock = FALSE; + +static GC_bool parallel_initialized = FALSE; + +void GC_init_parallel(void); + +#ifdef GC_DLL + /* Turn on GC_win32_dll_threads */ + GC_API void GC_use_DllMain(void) + { +# ifdef THREAD_LOCAL_ALLOC + ABORT("Cannot use thread local allocation with DllMain-based " + "thread registration."); + /* Thread-local allocation really wants to lock at thread */ + /* entry and exit. */ +# endif + GC_ASSERT(!parallel_initialized); + GC_win32_dll_threads = TRUE; + } +#else + GC_API void GC_use_DllMain(void) + { + ABORT("GC not configured as DLL"); + } +#endif + +DWORD GC_main_thread = 0; + +struct GC_Thread_Rep { + union { + AO_t tm_in_use; /* Updated without lock. */ + /* We assert that unused */ + /* entries have invalid ids of */ + /* zero and zero stack fields. */ + /* Used only with GC_win32_dll_threads. */ + struct GC_Thread_Rep * tm_next; + /* Hash table link without */ + /* GC_win32_dll_threads. */ + /* More recently allocated threads */ + /* with a given pthread id come */ + /* first. (All but the first are */ + /* guaranteed to be dead, but we may */ + /* not yet have registered the join.) */ + } table_management; +# define in_use table_management.tm_in_use +# define next table_management.tm_next + DWORD id; + HANDLE handle; + ptr_t stack_base; /* The cold end of the stack. */ + /* 0 ==> entry not valid. */ + /* !in_use ==> stack_base == 0 */ + GC_bool suspended; + +# ifdef GC_PTHREADS + void *status; /* hold exit value until join in case it's a pointer */ + pthread_t pthread_id; + short flags; /* Protected by GC lock. */ +# define FINISHED 1 /* Thread has exited. */ +# define DETACHED 2 /* Thread is intended to be detached. */ +# define KNOWN_FINISHED(t) (((t) -> flags) & FINISHED) +# else +# define KNOWN_FINISHED(t) 0 +# endif +# ifdef THREAD_LOCAL_ALLOC + struct thread_local_freelists tlfs; +# endif +}; + +typedef struct GC_Thread_Rep * GC_thread; +typedef volatile struct GC_Thread_Rep * GC_vthread; + +/* + * We assumed that volatile ==> memory ordering, at least among + * volatiles. This code should consistently use atomic_ops. + */ + +volatile GC_bool GC_please_stop = FALSE; + +/* + * We track thread attachments while the world is supposed to be stopped. + * Unfortunately, we can't stop them from starting, since blocking in + * DllMain seems to cause the world to deadlock. Thus we have to recover + * If we notice this in the middle of marking. + */ + +AO_t GC_attached_thread = FALSE; +/* Return TRUE if an thread was attached since we last asked or */ +/* since GC_attached_thread was explicitly reset. */ +GC_bool GC_started_thread_while_stopped(void) +{ + AO_t result; + + if (GC_win32_dll_threads) { + AO_nop_full(); /* Prior heap reads need to complete earlier. */ + result = AO_load(&GC_attached_thread); + if (result) { + AO_store(&GC_attached_thread, FALSE); + } + return ((GC_bool)result); + } else { + return FALSE; + } +} + +/* Thread table used if GC_win32_dll_threads is set. */ +/* This is a fixed size array. */ +/* Since we use runtime conditionals, both versions */ +/* are always defined. */ +# ifndef MAX_THREADS +# define MAX_THREADS 512 +# endif + /* Things may get quite slow for large numbers of threads, */ + /* since we look them up with sequential search. */ + + volatile struct GC_Thread_Rep dll_thread_table[MAX_THREADS]; + + volatile LONG GC_max_thread_index = 0; + /* Largest index in dll_thread_table */ + /* that was ever used. */ + +/* And now the version used if GC_win32_dll_threads is not set. */ +/* This is a chained hash table, with much of the code borrowed */ +/* From the Posix implementation. */ +# define THREAD_TABLE_SZ 256 /* Must be power of 2 */ + GC_thread GC_threads[THREAD_TABLE_SZ]; + + +/* Add a thread to GC_threads. We assume it wasn't already there. */ +/* Caller holds allocation lock. */ +/* Unlike the pthreads version, the id field is set by the caller. */ +GC_thread GC_new_thread(DWORD id) +{ + word hv = ((word)id) % THREAD_TABLE_SZ; + GC_thread result; + /* It may not be safe to allocate when we register the first thread. */ + static struct GC_Thread_Rep first_thread; + static GC_bool first_thread_used = FALSE; + + GC_ASSERT(I_HOLD_LOCK()); + if (!first_thread_used) { + result = &first_thread; + first_thread_used = TRUE; + } else { + GC_ASSERT(!GC_win32_dll_threads); + result = (struct GC_Thread_Rep *) + GC_INTERNAL_MALLOC(sizeof(struct GC_Thread_Rep), NORMAL); +# ifdef GC_PTHREADS + /* result can be NULL -> segfault */ + GC_ASSERT(result -> flags == 0); +# endif + } + if (result == 0) return(0); + /* result -> id = id; Done by caller. */ + result -> next = GC_threads[hv]; + GC_threads[hv] = result; +# ifdef GC_PTHREADS + GC_ASSERT(result -> flags == 0 /* && result -> thread_blocked == 0 */); +# endif + return(result); +} + +extern LONG WINAPI GC_write_fault_handler(struct _EXCEPTION_POINTERS *exc_info); + +#if defined(GWW_VDB) && defined(MPROTECT_VDB) + extern GC_bool GC_gww_dirty_init(void); + /* Defined in os_dep.c. Returns TRUE if GetWriteWatch is available. */ + /* may be called repeatedly. */ +#endif + +GC_bool GC_in_thread_creation = FALSE; /* Protected by allocation lock. */ + +/* + * This may be called from DllMain, and hence operates under unusual + * constraints. In particular, it must be lock-free if GC_win32_dll_threads + * is set. Always called from the thread being added. + * If GC_win32_dll_threads is not set, we already hold the allocation lock, + * except possibly during single-threaded start-up code. + */ +static GC_thread GC_register_my_thread_inner(struct GC_stack_base *sb, + DWORD thread_id) +{ + GC_vthread me; + + /* The following should be a noop according to the win32 */ + /* documentation. There is empirical evidence that it */ + /* isn't. - HB */ +# if defined(MPROTECT_VDB) +# if defined(GWW_VDB) + if (GC_incremental && !GC_gww_dirty_init()) + SetUnhandledExceptionFilter(GC_write_fault_handler); +# else + if (GC_incremental) SetUnhandledExceptionFilter(GC_write_fault_handler); +# endif +# endif + + if (GC_win32_dll_threads) { + int i; + /* It appears to be unsafe to acquire a lock here, since this */ + /* code is apparently not preeemptible on some systems. */ + /* (This is based on complaints, not on Microsoft's official */ + /* documentation, which says this should perform "only simple */ + /* initialization tasks".) */ + /* Hence we make do with nonblocking synchronization. */ + /* It has been claimed that DllMain is really only executed with */ + /* a particular system lock held, and thus careful use of locking */ + /* around code that doesn't call back into the system libraries */ + /* might be OK. But this hasn't been tested across all win32 */ + /* variants. */ + /* cast away volatile qualifier */ + for (i = 0; InterlockedExchange((IE_t)&dll_thread_table[i].in_use,1) != 0; + i++) { + /* Compare-and-swap would make this cleaner, but that's not */ + /* supported before Windows 98 and NT 4.0. In Windows 2000, */ + /* InterlockedExchange is supposed to be replaced by */ + /* InterlockedExchangePointer, but that's not really what I */ + /* want here. */ + /* FIXME: We should eventually declare Win95 dead and use AO_ */ + /* primitives here. */ + if (i == MAX_THREADS - 1) + ABORT("too many threads"); + } + /* Update GC_max_thread_index if necessary. The following is safe, */ + /* and unlike CompareExchange-based solutions seems to work on all */ + /* Windows95 and later platforms. */ + /* Unfortunately, GC_max_thread_index may be temporarily out of */ + /* bounds, so readers have to compensate. */ + while (i > GC_max_thread_index) { + InterlockedIncrement((IE_t)&GC_max_thread_index); + } + if (GC_max_thread_index >= MAX_THREADS) { + /* We overshot due to simultaneous increments. */ + /* Setting it to MAX_THREADS-1 is always safe. */ + GC_max_thread_index = MAX_THREADS - 1; + } + me = dll_thread_table + i; + } else /* Not using DllMain */ { + GC_ASSERT(I_HOLD_LOCK()); + GC_in_thread_creation = TRUE; /* OK to collect from unknown thread. */ + me = GC_new_thread(thread_id); + GC_in_thread_creation = FALSE; + } +# ifdef GC_PTHREADS + /* me can be NULL -> segfault */ + me -> pthread_id = pthread_self(); +# endif + + if (!DuplicateHandle(GetCurrentProcess(), + GetCurrentThread(), + GetCurrentProcess(), + (HANDLE*)&(me -> handle), + 0, + 0, + DUPLICATE_SAME_ACCESS)) { + DWORD last_error = GetLastError(); + GC_err_printf("Last error code: %d\n", last_error); + ABORT("DuplicateHandle failed"); + } + me -> stack_base = sb -> mem_base; + /* Up until this point, GC_push_all_stacks considers this thread */ + /* invalid. */ + /* Up until this point, this entry is viewed as reserved but invalid */ + /* by GC_delete_thread. */ + me -> id = thread_id; +# if defined(THREAD_LOCAL_ALLOC) + GC_init_thread_local((GC_tlfs)(&(me->tlfs))); +# endif + if (me -> stack_base == NULL) + ABORT("Bad stack base in GC_register_my_thread_inner"); + if (GC_win32_dll_threads) { + if (GC_please_stop) { + AO_store(&GC_attached_thread, TRUE); + AO_nop_full(); // Later updates must become visible after this. + } + /* We'd like to wait here, but can't, since waiting in DllMain */ + /* provokes deadlocks. */ + /* Thus we force marking to be restarted instead. */ + } else { + GC_ASSERT(!GC_please_stop); + /* Otherwise both we and the thread stopping code would be */ + /* holding the allocation lock. */ + } + return (GC_thread)(me); +} + +/* + * GC_max_thread_index may temporarily be larger than MAX_THREADS. + * To avoid subscript errors, we check on access. + */ +#ifdef __GNUC__ +__inline__ +#endif +LONG GC_get_max_thread_index() +{ + LONG my_max = GC_max_thread_index; + + if (my_max >= MAX_THREADS) return MAX_THREADS-1; + return my_max; +} + +/* Return the GC_thread corresponding to a thread id. May be called */ +/* without a lock, but should be called in contexts in which the */ +/* requested thread cannot be asynchronously deleted, e.g. from the */ +/* thread itself. */ +/* This version assumes that either GC_win32_dll_threads is set, or */ +/* we hold the allocator lock. */ +/* Also used (for assertion checking only) from thread_local_alloc.c. */ +GC_thread GC_lookup_thread_inner(DWORD thread_id) { + if (GC_win32_dll_threads) { + int i; + LONG my_max = GC_get_max_thread_index(); + for (i = 0; + i <= my_max && + (!AO_load_acquire(&(dll_thread_table[i].in_use)) + || dll_thread_table[i].id != thread_id); + /* Must still be in_use, since nobody else can store our thread_id. */ + i++) {} + if (i > my_max) { + return 0; + } else { + return (GC_thread)(dll_thread_table + i); + } + } else { + word hv = ((word)thread_id) % THREAD_TABLE_SZ; + register GC_thread p = GC_threads[hv]; + + GC_ASSERT(I_HOLD_LOCK()); + while (p != 0 && p -> id != thread_id) p = p -> next; + return(p); + } +} + +/* A version of the above that acquires the lock if necessary. Note */ +/* that the identically named function for pthreads is different, and */ +/* just assumes we hold the lock. */ +/* Also used (for assertion checking only) from thread_local_alloc.c. */ +static GC_thread GC_lookup_thread(DWORD thread_id) +{ + if (GC_win32_dll_threads) { + return GC_lookup_thread_inner(thread_id); + } else { + GC_thread result; + LOCK(); + result = GC_lookup_thread_inner(thread_id); + UNLOCK(); + return result; + } +} + +/* If a thread has been joined, but we have not yet */ +/* been notified, then there may be more than one thread */ +/* in the table with the same win32 id. */ +/* This is OK, but we need a way to delete a specific one. */ +/* Assumes we hold the allocation lock unless */ +/* GC_win32_dll_threads is set. */ +/* If GC_win32_dll_threads is set it should be called from the */ +/* thread being deleted. */ +void GC_delete_gc_thread(GC_vthread gc_id) +{ + if (GC_win32_dll_threads) { + /* This is intended to be lock-free. */ + /* It is either called synchronously from the thread being deleted, */ + /* or by the joining thread. */ + /* In this branch asynchronosu changes to *gc_id are possible. */ + CloseHandle(gc_id->handle); + gc_id -> stack_base = 0; + gc_id -> id = 0; +# ifdef CYGWIN32 + gc_id -> pthread_id = 0; +# endif /* CYGWIN32 */ +# ifdef GC_WIN32_PTHREADS + gc_id -> pthread_id.p = NULL; +# endif /* GC_WIN32_PTHREADS */ + AO_store_release(&(gc_id->in_use), FALSE); + } else { + /* Cast away volatile qualifier, since we have lock. */ + GC_thread gc_nvid = (GC_thread)gc_id; + DWORD id = gc_nvid -> id; + word hv = ((word)id) % THREAD_TABLE_SZ; + register GC_thread p = GC_threads[hv]; + register GC_thread prev = 0; + + GC_ASSERT(I_HOLD_LOCK()); + while (p != gc_nvid) { + prev = p; + p = p -> next; + } + if (prev == 0) { + GC_threads[hv] = p -> next; + } else { + prev -> next = p -> next; + } + GC_INTERNAL_FREE(p); + } +} + +/* Delete a thread from GC_threads. We assume it is there. */ +/* (The code intentionally traps if it wasn't.) */ +/* Assumes we hold the allocation lock unless */ +/* GC_win32_dll_threads is set. */ +/* If GC_win32_dll_threads is set it should be called from the */ +/* thread being deleted. */ +void GC_delete_thread(DWORD id) +{ + if (GC_win32_dll_threads) { + GC_thread t = GC_lookup_thread_inner(id); + + if (0 == t) { + WARN("Removing nonexistent thread %ld\n", (GC_word)id); + } else { + GC_delete_gc_thread(t); + } + } else { + word hv = ((word)id) % THREAD_TABLE_SZ; + register GC_thread p = GC_threads[hv]; + register GC_thread prev = 0; + + GC_ASSERT(I_HOLD_LOCK()); + while (p -> id != id) { + prev = p; + p = p -> next; + } + if (prev == 0) { + GC_threads[hv] = p -> next; + } else { + prev -> next = p -> next; + } + GC_INTERNAL_FREE(p); + } +} + +int GC_register_my_thread(struct GC_stack_base *sb) { + DWORD t = GetCurrentThreadId(); + + if (0 == GC_lookup_thread(t)) { + /* We lock here, since we want to wait for an ongoing GC. */ + LOCK(); + GC_register_my_thread_inner(sb, t); + UNLOCK(); + return GC_SUCCESS; + } else { + return GC_DUPLICATE; + } +} + +int GC_unregister_my_thread(void) +{ + DWORD t = GetCurrentThreadId(); + +# if defined(THREAD_LOCAL_ALLOC) + LOCK(); + { + GC_thread me = GC_lookup_thread_inner(t); + GC_destroy_thread_local(&(me->tlfs)); + } + UNLOCK(); +# endif + if (GC_win32_dll_threads) { + /* Should we just ignore this? */ + GC_delete_thread(t); + } else { + LOCK(); + GC_delete_thread(t); + UNLOCK(); + } + return GC_SUCCESS; +} + + +#ifdef GC_PTHREADS + +/* A quick-and-dirty cache of the mapping between pthread_t */ +/* and win32 thread id. */ +#define PTHREAD_MAP_SIZE 512 +DWORD GC_pthread_map_cache[PTHREAD_MAP_SIZE]; +#define HASH(pthread_id) ((NUMERIC_THREAD_ID(pthread_id) >> 5) % PTHREAD_MAP_SIZE) + /* It appears pthread_t is really a pointer type ... */ +#define SET_PTHREAD_MAP_CACHE(pthread_id, win32_id) \ + GC_pthread_map_cache[HASH(pthread_id)] = (win32_id); +#define GET_PTHREAD_MAP_CACHE(pthread_id) \ + GC_pthread_map_cache[HASH(pthread_id)] + +/* Return a GC_thread corresponding to a given pthread_t. */ +/* Returns 0 if it's not there. */ +/* We assume that this is only called for pthread ids that */ +/* have not yet terminated or are still joinable, and */ +/* cannot be concurrently terminated. */ +/* Assumes we do NOT hold the allocation lock. */ +static GC_thread GC_lookup_pthread(pthread_t id) +{ + if (GC_win32_dll_threads) { + int i; + LONG my_max = GC_get_max_thread_index(); + + for (i = 0; + i <= my_max && + (!AO_load_acquire(&(dll_thread_table[i].in_use)) + || THREAD_EQUAL(dll_thread_table[i].pthread_id, id)); + /* Must still be in_use, since nobody else can store our thread_id. */ + i++); + if (i > my_max) return 0; + return (GC_thread)(dll_thread_table + i); + } else { + /* We first try the cache. If that fails, we use a very slow */ + /* approach. */ + int hv_guess = GET_PTHREAD_MAP_CACHE(id) % THREAD_TABLE_SZ; + int hv; + GC_thread p; + + LOCK(); + for (p = GC_threads[hv_guess]; 0 != p; p = p -> next) { + if (THREAD_EQUAL(p -> pthread_id, id)) + goto foundit; + } + for (hv = 0; hv < THREAD_TABLE_SZ; ++hv) { + for (p = GC_threads[hv]; 0 != p; p = p -> next) { + if (THREAD_EQUAL(p -> pthread_id, id)) + goto foundit; + } + } + p = 0; + foundit: + UNLOCK(); + return p; + } +} + +#endif /* GC_PTHREADS */ + +void GC_push_thread_structures(void) +{ + GC_ASSERT(I_HOLD_LOCK()); + if (GC_win32_dll_threads) { + /* Unlike the other threads implementations, the thread table here */ + /* contains no pointers to the collectable heap. Thus we have */ + /* no private structures we need to preserve. */ +# ifdef GC_PTHREADS + { int i; /* pthreads may keep a pointer in the thread exit value */ + LONG my_max = GC_get_max_thread_index(); + + for (i = 0; i <= my_max; i++) + if (dll_thread_table[i].in_use) + GC_push_all((ptr_t)&(dll_thread_table[i].status), + (ptr_t)(&(dll_thread_table[i].status)+1)); + } +# endif + } else { + GC_push_all((ptr_t)(GC_threads), (ptr_t)(GC_threads)+sizeof(GC_threads)); + } +# if defined(THREAD_LOCAL_ALLOC) + GC_push_all((ptr_t)(&GC_thread_key), + (ptr_t)(&GC_thread_key)+sizeof(&GC_thread_key)); + /* Just in case we ever use our own TLS implementation. */ +# endif +} + +/* Suspend the given thread, if it's still active. */ +void GC_suspend(GC_thread t) +{ +# ifdef MSWINCE + /* SuspendThread will fail if thread is running kernel code */ + while (SuspendThread(t -> handle) == (DWORD)-1) + Sleep(10); +# else + /* Apparently the Windows 95 GetOpenFileName call creates */ + /* a thread that does not properly get cleaned up, and */ + /* SuspendThread on its descriptor may provoke a crash. */ + /* This reduces the probability of that event, though it still */ + /* appears there's a race here. */ + DWORD exitCode; + if (GetExitCodeThread(t -> handle, &exitCode) && + exitCode != STILL_ACTIVE) { + t -> stack_base = 0; /* prevent stack from being pushed */ +# ifndef GC_PTHREADS + /* this breaks pthread_join on Cygwin, which is guaranteed to */ + /* only see user pthreads */ + AO_store(&(t -> in_use), FALSE); + CloseHandle(t -> handle); +# endif + return; + } + if (SuspendThread(t -> handle) == (DWORD)-1) + ABORT("SuspendThread failed"); +# endif + t -> suspended = TRUE; +} + +/* Defined in misc.c */ +#ifndef CYGWIN32 + extern CRITICAL_SECTION GC_write_cs; +#endif + +void GC_stop_world(void) +{ + DWORD thread_id = GetCurrentThreadId(); + int i; + + if (!GC_thr_initialized) ABORT("GC_stop_world() called before GC_thr_init()"); + GC_ASSERT(I_HOLD_LOCK()); + + GC_please_stop = TRUE; +# ifndef CYGWIN32 + EnterCriticalSection(&GC_write_cs); +# endif + if (GC_win32_dll_threads) { + /* Any threads being created during this loop will end up setting */ + /* GC_attached_thread when they start. This will force marking to */ + /* restart. */ + /* This is not ideal, but hopefully correct. */ + GC_attached_thread = FALSE; + for (i = 0; i <= GC_get_max_thread_index(); i++) { + GC_vthread t = dll_thread_table + i; + if (t -> stack_base != 0 + && t -> id != thread_id) { + GC_suspend((GC_thread)t); + } + } + } else { + GC_thread t; + int i; + + for (i = 0; i < THREAD_TABLE_SZ; i++) { + for (t = GC_threads[i]; t != 0; t = t -> next) { + if (t -> stack_base != 0 + && !KNOWN_FINISHED(t) + && t -> id != thread_id) { + GC_suspend(t); + } + } + } + } +# ifndef CYGWIN32 + LeaveCriticalSection(&GC_write_cs); +# endif +} + +void GC_start_world(void) +{ + DWORD thread_id = GetCurrentThreadId(); + int i; + LONG my_max = GC_get_max_thread_index(); + + GC_ASSERT(I_HOLD_LOCK()); + if (GC_win32_dll_threads) { + for (i = 0; i <= my_max; i++) { + GC_thread t = (GC_thread)(dll_thread_table + i); + if (t -> stack_base != 0 && t -> suspended + && t -> id != thread_id) { + if (ResumeThread(t -> handle) == (DWORD)-1) + ABORT("ResumeThread failed"); + t -> suspended = FALSE; + } + } + } else { + GC_thread t; + int i; + + for (i = 0; i < THREAD_TABLE_SZ; i++) { + for (t = GC_threads[i]; t != 0; t = t -> next) { + if (t -> stack_base != 0 && t -> suspended + && t -> id != thread_id) { + if (ResumeThread(t -> handle) == (DWORD)-1) + ABORT("ResumeThread failed"); + t -> suspended = FALSE; + } + } + } + } + GC_please_stop = FALSE; +} + +# ifdef MSWINCE + /* The VirtualQuery calls below won't work properly on WinCE, but */ + /* since each stack is restricted to an aligned 64K region of */ + /* virtual memory we can just take the next lowest multiple of 64K. */ +# define GC_get_stack_min(s) \ + ((ptr_t)(((DWORD)(s) - 1) & 0xFFFF0000)) +# else + static ptr_t GC_get_stack_min(ptr_t s) + { + ptr_t bottom; + MEMORY_BASIC_INFORMATION info; + VirtualQuery(s, &info, sizeof(info)); + do { + bottom = info.BaseAddress; + VirtualQuery(bottom - 1, &info, sizeof(info)); + } while ((info.Protect & PAGE_READWRITE) + && !(info.Protect & PAGE_GUARD)); + return(bottom); + } +# endif + +void GC_push_stack_for(GC_thread thread) +{ + int dummy; + ptr_t sp, stack_min; + DWORD me = GetCurrentThreadId(); + + if (thread -> stack_base) { + if (thread -> id == me) { + sp = (ptr_t) &dummy; + } else { + CONTEXT context; + context.ContextFlags = CONTEXT_INTEGER|CONTEXT_CONTROL; + if (!GetThreadContext(thread -> handle, &context)) + ABORT("GetThreadContext failed"); + + /* Push all registers that might point into the heap. Frame */ + /* pointer registers are included in case client code was */ + /* compiled with the 'omit frame pointer' optimisation. */ +# define PUSH1(reg) GC_push_one((word)context.reg) +# define PUSH2(r1,r2) PUSH1(r1), PUSH1(r2) +# define PUSH4(r1,r2,r3,r4) PUSH2(r1,r2), PUSH2(r3,r4) +# if defined(I386) + PUSH4(Edi,Esi,Ebx,Edx), PUSH2(Ecx,Eax), PUSH1(Ebp); + sp = (ptr_t)context.Esp; +# elif defined(X86_64) + PUSH4(Rax,Rcx,Rdx,Rbx); PUSH2(Rbp, Rsi); PUSH1(Rdi); + PUSH4(R8, R9, R10, R11); PUSH4(R12, R13, R14, R15); + sp = (ptr_t)context.Rsp; +# elif defined(ARM32) + PUSH4(R0,R1,R2,R3),PUSH4(R4,R5,R6,R7),PUSH4(R8,R9,R10,R11),PUSH1(R12); + sp = (ptr_t)context.Sp; +# elif defined(SHx) + PUSH4(R0,R1,R2,R3), PUSH4(R4,R5,R6,R7), PUSH4(R8,R9,R10,R11); + PUSH2(R12,R13), PUSH1(R14); + sp = (ptr_t)context.R15; +# elif defined(MIPS) + PUSH4(IntAt,IntV0,IntV1,IntA0), PUSH4(IntA1,IntA2,IntA3,IntT0); + PUSH4(IntT1,IntT2,IntT3,IntT4), PUSH4(IntT5,IntT6,IntT7,IntS0); + PUSH4(IntS1,IntS2,IntS3,IntS4), PUSH4(IntS5,IntS6,IntS7,IntT8); + PUSH4(IntT9,IntK0,IntK1,IntS8); + sp = (ptr_t)context.IntSp; +# elif defined(PPC) + PUSH4(Gpr0, Gpr3, Gpr4, Gpr5), PUSH4(Gpr6, Gpr7, Gpr8, Gpr9); + PUSH4(Gpr10,Gpr11,Gpr12,Gpr14), PUSH4(Gpr15,Gpr16,Gpr17,Gpr18); + PUSH4(Gpr19,Gpr20,Gpr21,Gpr22), PUSH4(Gpr23,Gpr24,Gpr25,Gpr26); + PUSH4(Gpr27,Gpr28,Gpr29,Gpr30), PUSH1(Gpr31); + sp = (ptr_t)context.Gpr1; +# elif defined(ALPHA) + PUSH4(IntV0,IntT0,IntT1,IntT2), PUSH4(IntT3,IntT4,IntT5,IntT6); + PUSH4(IntT7,IntS0,IntS1,IntS2), PUSH4(IntS3,IntS4,IntS5,IntFp); + PUSH4(IntA0,IntA1,IntA2,IntA3), PUSH4(IntA4,IntA5,IntT8,IntT9); + PUSH4(IntT10,IntT11,IntT12,IntAt); + sp = (ptr_t)context.IntSp; +# else +# error "architecture is not supported" +# endif + } /* ! current thread */ + + stack_min = GC_get_stack_min(thread->stack_base); + + if (sp >= stack_min && sp < thread->stack_base) { +# if DEBUG_WIN32_PTHREADS || DEBUG_WIN32_THREADS \ + || DEBUG_CYGWIN_THREADS + GC_printf("Pushing thread from %p to %p for 0x%x from 0x%x\n", + sp, thread -> stack_base, thread -> id, me); +# endif + GC_push_all_stack(sp, thread->stack_base); + } else { + WARN("Thread stack pointer 0x%lx out of range, pushing everything\n", + (unsigned long)(size_t)sp); + GC_push_all_stack(stack_min, thread->stack_base); + } + } /* thread looks live */ +} + +void GC_push_all_stacks(void) +{ + DWORD me = GetCurrentThreadId(); + GC_bool found_me = FALSE; + size_t nthreads = 0; + + if (GC_win32_dll_threads) { + int i; + LONG my_max = GC_get_max_thread_index(); + + for (i = 0; i <= my_max; i++) { + GC_thread t = (GC_thread)(dll_thread_table + i); + if (t -> in_use) { + ++nthreads; + GC_push_stack_for(t); + if (t -> id == me) found_me = TRUE; + } + } + } else { + GC_thread t; + int i; + + for (i = 0; i < THREAD_TABLE_SZ; i++) { + for (t = GC_threads[i]; t != 0; t = t -> next) { + ++nthreads; + if (!KNOWN_FINISHED(t)) GC_push_stack_for(t); + if (t -> id == me) found_me = TRUE; + } + } + } + if (GC_print_stats == VERBOSE) { + GC_log_printf("Pushed %d thread stacks ", nthreads); + if (GC_win32_dll_threads) { + GC_log_printf("based on DllMain thread tracking\n"); + } else { + GC_log_printf("\n"); + } + } + if (!found_me && !GC_in_thread_creation) + ABORT("Collecting from unknown thread."); +} + +void GC_get_next_stack(char *start, char **lo, char **hi) +{ + int i; +# define ADDR_LIMIT (char *)(-1L) + char * current_min = ADDR_LIMIT; + + if (GC_win32_dll_threads) { + LONG my_max = GC_get_max_thread_index(); + + for (i = 0; i <= my_max; i++) { + ptr_t s = (ptr_t)(dll_thread_table[i].stack_base); + + if (0 != s && s > start && s < current_min) { + current_min = s; + } + } + } else { + for (i = 0; i < THREAD_TABLE_SZ; i++) { + GC_thread t; + + for (t = GC_threads[i]; t != 0; t = t -> next) { + ptr_t s = (ptr_t)(t -> stack_base); + + if (0 != s && s > start && s < current_min) { + current_min = s; + } + } + } + } + *hi = current_min; + if (current_min == ADDR_LIMIT) { + *lo = ADDR_LIMIT; + return; + } + *lo = GC_get_stack_min(current_min); + if (*lo < start) *lo = start; +} + +#ifndef GC_PTHREADS + +/* We have no DllMain to take care of new threads. Thus we */ +/* must properly intercept thread creation. */ + +typedef struct { + LPTHREAD_START_ROUTINE start; + LPVOID param; +} thread_args; + +static DWORD WINAPI thread_start(LPVOID arg); + +void * GC_win32_start_inner(struct GC_stack_base *sb, LPVOID arg) +{ + void * ret; + thread_args *args = (thread_args *)arg; + +# if DEBUG_WIN32_THREADS + GC_printf("thread 0x%x starting...\n", GetCurrentThreadId()); +# endif + + GC_register_my_thread(sb); /* This waits for an in-progress GC. */ + + /* Clear the thread entry even if we exit with an exception. */ + /* This is probably pointless, since an uncaught exception is */ + /* supposed to result in the process being killed. */ +#ifndef __GNUC__ + __try { +#endif /* __GNUC__ */ + ret = (void *)(size_t)args->start (args->param); +#ifndef __GNUC__ + } __finally { +#endif /* __GNUC__ */ + GC_unregister_my_thread(); + GC_free(args); +#ifndef __GNUC__ + } +#endif /* __GNUC__ */ + +# if DEBUG_WIN32_THREADS + GC_printf("thread 0x%x returned from start routine.\n", + GetCurrentThreadId()); +# endif + return ret; +} + +DWORD WINAPI GC_win32_start(LPVOID arg) +{ + return (DWORD)(size_t)GC_call_with_stack_base(GC_win32_start_inner, arg); +} + +GC_API HANDLE WINAPI GC_CreateThread( + LPSECURITY_ATTRIBUTES lpThreadAttributes, + DWORD dwStackSize, LPTHREAD_START_ROUTINE lpStartAddress, + LPVOID lpParameter, DWORD dwCreationFlags, LPDWORD lpThreadId ) +{ + HANDLE thread_h = NULL; + + thread_args *args; + + if (!parallel_initialized) GC_init_parallel(); + /* make sure GC is initialized (i.e. main thread is attached, + tls initialized) */ + +# if DEBUG_WIN32_THREADS + GC_printf("About to create a thread from 0x%x\n", GetCurrentThreadId()); +# endif + if (GC_win32_dll_threads) { + return CreateThread(lpThreadAttributes, dwStackSize, lpStartAddress, + lpParameter, dwCreationFlags, lpThreadId); + } else { + args = GC_malloc_uncollectable(sizeof(thread_args)); + /* Handed off to and deallocated by child thread. */ + if (0 == args) { + SetLastError(ERROR_NOT_ENOUGH_MEMORY); + return NULL; + } + + /* set up thread arguments */ + args -> start = lpStartAddress; + args -> param = lpParameter; + + GC_need_to_lock = TRUE; + thread_h = CreateThread(lpThreadAttributes, + dwStackSize, GC_win32_start, + args, dwCreationFlags, + lpThreadId); + if( thread_h == 0 ) GC_free( args ); + return thread_h; + } +} + +void WINAPI GC_ExitThread(DWORD dwExitCode) +{ + GC_unregister_my_thread(); + ExitThread(dwExitCode); +} + +uintptr_t GC_beginthreadex( + void *security, unsigned stack_size, + unsigned ( __stdcall *start_address )( void * ), + void *arglist, unsigned initflag, unsigned *thrdaddr) +{ + uintptr_t thread_h = -1L; + + thread_args *args; + + if (!parallel_initialized) GC_init_parallel(); + /* make sure GC is initialized (i.e. main thread is attached, + tls initialized) */ +# if DEBUG_WIN32_THREADS + GC_printf("About to create a thread from 0x%x\n", GetCurrentThreadId()); +# endif + + if (GC_win32_dll_threads) { + return _beginthreadex(security, stack_size, start_address, + arglist, initflag, thrdaddr); + } else { + args = GC_malloc_uncollectable(sizeof(thread_args)); + /* Handed off to and deallocated by child thread. */ + if (0 == args) { + SetLastError(ERROR_NOT_ENOUGH_MEMORY); + return (uintptr_t)(-1); + } + + /* set up thread arguments */ + args -> start = (LPTHREAD_START_ROUTINE)start_address; + args -> param = arglist; + + GC_need_to_lock = TRUE; + thread_h = _beginthreadex(security, stack_size, + (unsigned (__stdcall *) (void *))GC_win32_start, + args, initflag, thrdaddr); + if( thread_h == 0 ) GC_free( args ); + return thread_h; + } +} + +void GC_endthreadex(unsigned retval) +{ + GC_unregister_my_thread(); + _endthreadex(retval); +} + +#endif /* !GC_PTHREADS */ + +#ifdef MSWINCE + +typedef struct { + HINSTANCE hInstance; + HINSTANCE hPrevInstance; + LPWSTR lpCmdLine; + int nShowCmd; +} main_thread_args; + +DWORD WINAPI main_thread_start(LPVOID arg); + +int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, + LPWSTR lpCmdLine, int nShowCmd) +{ + DWORD exit_code = 1; + + main_thread_args args = { + hInstance, hPrevInstance, lpCmdLine, nShowCmd + }; + HANDLE thread_h; + DWORD thread_id; + + /* initialize everything */ + GC_init(); + + /* start the main thread */ + thread_h = GC_CreateThread( + NULL, 0, main_thread_start, &args, 0, &thread_id); + + if (thread_h != NULL) + { + WaitForSingleObject (thread_h, INFINITE); + GetExitCodeThread (thread_h, &exit_code); + CloseHandle (thread_h); + } + + GC_deinit(); + DeleteCriticalSection(&GC_allocate_ml); + + return (int) exit_code; +} + +DWORD WINAPI main_thread_start(LPVOID arg) +{ + main_thread_args * args = (main_thread_args *) arg; + + return (DWORD) GC_WinMain (args->hInstance, args->hPrevInstance, + args->lpCmdLine, args->nShowCmd); +} + +# else /* !MSWINCE */ + +/* Called by GC_init() - we hold the allocation lock. */ +void GC_thr_init(void) { + struct GC_stack_base sb; + int sb_result; + + GC_ASSERT(I_HOLD_LOCK()); + if (GC_thr_initialized) return; + GC_main_thread = GetCurrentThreadId(); + GC_thr_initialized = TRUE; + + /* Add the initial thread, so we can stop it. */ + sb_result = GC_get_stack_base(&sb); + GC_ASSERT(sb_result == GC_SUCCESS); + GC_register_my_thread(&sb); +} + +#ifdef GC_PTHREADS + +struct start_info { + void *(*start_routine)(void *); + void *arg; + GC_bool detached; +}; + +int GC_pthread_join(pthread_t pthread_id, void **retval) { + int result; + int i; + GC_thread joinee; + +# if DEBUG_CYGWIN_THREADS + GC_printf("thread 0x%x(0x%x) is joining thread 0x%x.\n", + (int)pthread_self(), GetCurrentThreadId(), (int)pthread_id); +# endif +# if DEBUG_WIN32_PTHREADS + GC_printf("thread 0x%x(0x%x) is joining thread 0x%x.\n", + (int)(pthread_self()).p, GetCurrentThreadId(), pthread_id.p); +# endif + + if (!parallel_initialized) GC_init_parallel(); + /* Thread being joined might not have registered itself yet. */ + /* After the join,thread id may have been recycled. */ + /* FIXME: It would be better if this worked more like */ + /* pthread_support.c. */ + + #ifndef GC_WIN32_PTHREADS + while ((joinee = GC_lookup_pthread(pthread_id)) == 0) Sleep(10); + #endif + + result = pthread_join(pthread_id, retval); + + #ifdef GC_WIN32_PTHREADS + /* win32_pthreads id are unique */ + joinee = GC_lookup_pthread(pthread_id); + #endif + + if (!GC_win32_dll_threads) { + LOCK(); + GC_delete_gc_thread(joinee); + UNLOCK(); + } /* otherwise dllmain handles it. */ + +# if DEBUG_CYGWIN_THREADS + GC_printf("thread 0x%x(0x%x) completed join with thread 0x%x.\n", + (int)pthread_self(), GetCurrentThreadId(), (int)pthread_id); +# endif +# if DEBUG_WIN32_PTHREADS + GC_printf("thread 0x%x(0x%x) completed join with thread 0x%x.\n", + (int)(pthread_self()).p, GetCurrentThreadId(), pthread_id.p); +# endif + + return result; +} + +/* Cygwin-pthreads calls CreateThread internally, but it's not + * easily interceptible by us.. + * so intercept pthread_create instead + */ +int +GC_pthread_create(pthread_t *new_thread, + const pthread_attr_t *attr, + void *(*start_routine)(void *), void *arg) { + int result; + struct start_info * si; + + if (!parallel_initialized) GC_init_parallel(); + /* make sure GC is initialized (i.e. main thread is attached) */ + if (GC_win32_dll_threads) { + return pthread_create(new_thread, attr, start_routine, arg); + } + + /* This is otherwise saved only in an area mmapped by the thread */ + /* library, which isn't visible to the collector. */ + si = GC_malloc_uncollectable(sizeof(struct start_info)); + if (0 == si) return(EAGAIN); + + si -> start_routine = start_routine; + si -> arg = arg; + if (attr != 0 && + pthread_attr_getdetachstate(attr, &si->detached) + == PTHREAD_CREATE_DETACHED) { + si->detached = TRUE; + } + +# if DEBUG_CYGWIN_THREADS + GC_printf("About to create a thread from 0x%x(0x%x)\n", + (int)pthread_self(), GetCurrentThreadId); +# endif +# if DEBUG_WIN32_PTHREADS + GC_printf("About to create a thread from 0x%x(0x%x)\n", + (int)(pthread_self()).p, GetCurrentThreadId()); +# endif + GC_need_to_lock = TRUE; + result = pthread_create(new_thread, attr, GC_pthread_start, si); + + if (result) { /* failure */ + GC_free(si); + } + + return(result); +} + +void * GC_pthread_start_inner(struct GC_stack_base *sb, void * arg) +{ + struct start_info * si = arg; + void * result; + void *(*start)(void *); + void *start_arg; + DWORD thread_id = GetCurrentThreadId(); + pthread_t pthread_id = pthread_self(); + GC_thread me; + GC_bool detached; + int i; + +# if DEBUG_CYGWIN_THREADS + GC_printf("thread 0x%x(0x%x) starting...\n",(int)pthread_id, + thread_id); +# endif +# if DEBUG_WIN32_PTHREADS + GC_printf("thread 0x%x(0x%x) starting...\n",(int) pthread_id.p, + thread_id); +# endif + + GC_ASSERT(!GC_win32_dll_threads); + /* If a GC occurs before the thread is registered, that GC will */ + /* ignore this thread. That's fine, since it will block trying to */ + /* acquire the allocation lock, and won't yet hold interesting */ + /* pointers. */ + LOCK(); + /* We register the thread here instead of in the parent, so that */ + /* we don't need to hold the allocation lock during pthread_create. */ + me = GC_register_my_thread_inner(sb, thread_id); + SET_PTHREAD_MAP_CACHE(pthread_id, thread_id); + UNLOCK(); + + start = si -> start_routine; + start_arg = si -> arg; + if (si-> detached) me -> flags |= DETACHED; + me -> pthread_id = pthread_id; + + GC_free(si); /* was allocated uncollectable */ + + pthread_cleanup_push(GC_thread_exit_proc, (void *)me); + result = (*start)(start_arg); + me -> status = result; + pthread_cleanup_pop(1); + +# if DEBUG_CYGWIN_THREADS + GC_printf("thread 0x%x(0x%x) returned from start routine.\n", + (int)pthread_self(),GetCurrentThreadId()); +# endif +# if DEBUG_WIN32_PTHREADS + GC_printf("thread 0x%x(0x%x) returned from start routine.\n", + (int)(pthread_self()).p, GetCurrentThreadId()); +# endif + + return(result); +} + +void * GC_pthread_start(void * arg) +{ + return GC_call_with_stack_base(GC_pthread_start_inner, arg); +} + +void GC_thread_exit_proc(void *arg) +{ + GC_thread me = (GC_thread)arg; + int i; + + GC_ASSERT(!GC_win32_dll_threads); +# if DEBUG_CYGWIN_THREADS + GC_printf("thread 0x%x(0x%x) called pthread_exit().\n", + (int)pthread_self(),GetCurrentThreadId()); +# endif +# if DEBUG_WIN32_PTHREADS + GC_printf("thread 0x%x(0x%x) called pthread_exit().\n", + (int)(pthread_self()).p,GetCurrentThreadId()); +# endif + + LOCK(); +# if defined(THREAD_LOCAL_ALLOC) + GC_destroy_thread_local(&(me->tlfs)); +# endif + if (me -> flags & DETACHED) { + GC_delete_thread(GetCurrentThreadId()); + } else { + /* deallocate it as part of join */ + me -> flags |= FINISHED; + } + UNLOCK(); +} + +#ifndef GC_WIN32_PTHREADS +/* win32 pthread does not support sigmask */ +/* nothing required here... */ +int GC_pthread_sigmask(int how, const sigset_t *set, sigset_t *oset) { + if (!parallel_initialized) GC_init_parallel(); + return pthread_sigmask(how, set, oset); +} +#endif + +int GC_pthread_detach(pthread_t thread) +{ + int result; + GC_thread thread_gc_id; + + if (!parallel_initialized) GC_init_parallel(); + LOCK(); + thread_gc_id = GC_lookup_pthread(thread); + UNLOCK(); + result = pthread_detach(thread); + if (result == 0) { + LOCK(); + thread_gc_id -> flags |= DETACHED; + /* Here the pthread thread id may have been recycled. */ + if (thread_gc_id -> flags & FINISHED) { + GC_delete_gc_thread(thread_gc_id); + } + UNLOCK(); + } + return result; +} + +#else /* !GC_PTHREADS */ + +/* + * We avoid acquiring locks here, since this doesn't seem to be preemptable. + * This may run with an uninitialized collector, in which case we don't do much. + * This implies that no threads other than the main one should be created + * with an uninitialized collector. (The alternative of initializing + * the collector here seems dangerous, since DllMain is limited in what it + * can do.) + */ +#ifdef GC_DLL +GC_API BOOL WINAPI DllMain(HINSTANCE inst, ULONG reason, LPVOID reserved) +{ + struct GC_stack_base sb; + DWORD thread_id; + int sb_result; + static int entry_count = 0; + + if (parallel_initialized && !GC_win32_dll_threads) return TRUE; + + switch (reason) { + case DLL_THREAD_ATTACH: + GC_ASSERT(entry_count == 0 || parallel_initialized); + ++entry_count; /* and fall through: */ + case DLL_PROCESS_ATTACH: + /* This may run with the collector uninitialized. */ + thread_id = GetCurrentThreadId(); + if (parallel_initialized && GC_main_thread != thread_id) { + /* Don't lock here. */ + sb_result = GC_get_stack_base(&sb); + GC_ASSERT(sb_result == GC_SUCCESS); +# ifdef THREAD_LOCAL_ALLOC + ABORT("Cannot initialize thread local cache from DllMain"); +# endif + GC_register_my_thread_inner(&sb, thread_id); + } /* o.w. we already did it during GC_thr_init(), called by GC_init() */ + break; + + case DLL_THREAD_DETACH: + /* We are hopefully running in the context of the exiting thread. */ + GC_ASSERT(parallel_initialized); + if (!GC_win32_dll_threads) return TRUE; + GC_delete_thread(GetCurrentThreadId()); + break; + + case DLL_PROCESS_DETACH: + { + int i; + + if (!GC_win32_dll_threads) return TRUE; + for (i = 0; i <= GC_get_max_thread_index(); ++i) + { + if (AO_load(&(dll_thread_table[i].in_use))) + GC_delete_gc_thread(dll_thread_table + i); + } + + GC_deinit(); + DeleteCriticalSection(&GC_allocate_ml); + } + break; + + } + return TRUE; +} +#endif /* GC_DLL */ +#endif /* !GC_PTHREADS */ + +# endif /* !MSWINCE */ + +/* Perform all initializations, including those that */ +/* may require allocation. */ +/* Called without allocation lock. */ +/* Must be called before a second thread is created. */ +void GC_init_parallel(void) +{ + if (parallel_initialized) return; + parallel_initialized = TRUE; + /* GC_init() calls us back, so set flag first. */ + + if (!GC_is_initialized) GC_init(); + if (GC_win32_dll_threads) { + GC_need_to_lock = TRUE; + /* Cannot intercept thread creation. Hence we don't know if other */ + /* threads exist. However, client is not allowed to create other */ + /* threads before collector initialization. Thus it's OK not to */ + /* lock before this. */ + } + /* Initialize thread local free lists if used. */ +# if defined(THREAD_LOCAL_ALLOC) + LOCK(); + GC_init_thread_local(&(GC_lookup_thread(GetCurrentThreadId())->tlfs)); + UNLOCK(); +# endif +} + +#if defined(USE_PTHREAD_LOCKS) + /* Support for pthread locking code. */ + /* Pthread_mutex_try_lock may not win here, */ + /* due to builtinsupport for spinning first? */ + +volatile GC_bool GC_collecting = 0; + /* A hint that we're in the collector and */ + /* holding the allocation lock for an */ + /* extended period. */ + +void GC_lock(void) +{ + pthread_mutex_lock(&GC_allocate_ml); +} +#endif /* USE_PTHREAD ... */ + +# if defined(THREAD_LOCAL_ALLOC) + +/* Add thread-local allocation support. Microsoft uses __declspec(thread) */ + +/* We must explicitly mark ptrfree and gcj free lists, since the free */ +/* list links wouldn't otherwise be found. We also set them in the */ +/* normal free lists, since that involves touching less memory than if */ +/* we scanned them normally. */ +void GC_mark_thread_local_free_lists(void) +{ + int i; + GC_thread p; + + for (i = 0; i < THREAD_TABLE_SZ; ++i) { + for (p = GC_threads[i]; 0 != p; p = p -> next) { + GC_mark_thread_local_fls_for(&(p->tlfs)); + } + } +} + +#if defined(GC_ASSERTIONS) + /* Check that all thread-local free-lists are completely marked. */ + /* also check that thread-specific-data structures are marked. */ + void GC_check_tls(void) { + int i; + GC_thread p; + + for (i = 0; i < THREAD_TABLE_SZ; ++i) { + for (p = GC_threads[i]; 0 != p; p = p -> next) { + GC_check_tls_for(&(p->tlfs)); + } + } +# if defined(USE_CUSTOM_SPECIFIC) + if (GC_thread_key != 0) + GC_check_tsd_marks(GC_thread_key); +# endif + } +#endif /* GC_ASSERTIONS */ + +#endif /* THREAD_LOCAL_ALLOC ... */ + +#endif /* GC_WIN32_THREADS */ |