2 #include "private/gc_priv.h"
4 #if defined(GC_WIN32_THREADS)
8 #ifdef THREAD_LOCAL_ALLOC
9 # include "private/thread_local_alloc.h"
10 #endif /* THREAD_LOCAL_ALLOC */
12 /* Allocation lock declarations. */
13 #if !defined(USE_PTHREAD_LOCKS)
15 __declspec(dllexport) CRITICAL_SECTION GC_allocate_ml;
17 CRITICAL_SECTION GC_allocate_ml;
19 DWORD GC_lock_holder = NO_THREAD;
20 /* Thread id for current holder of allocation lock */
22 pthread_mutex_t GC_allocate_ml = PTHREAD_MUTEX_INITIALIZER;
23 unsigned long GC_lock_holder = NO_THREAD;
29 /* GC_DLL should not normally be defined, especially since we often do turn */
30 /* on THREAD_LOCAL_ALLOC, which is currently incompatible. */
31 /* It might be possible to get GC_DLL and DllMain-based thread registration */
32 /* to work with Cygwin, but if you try you are on your own. */
34 # error GC_DLL untested with Cygwin
37 /* Cygwin-specific forward decls */
38 # undef pthread_create
39 # undef pthread_sigmask
41 # undef pthread_detach
46 # define DEBUG_CYGWIN_THREADS 1
47 # define DEBUG_WIN32_PTHREADS 0
49 # define DEBUG_WIN32_PTHREADS 1
50 # define DEBUG_CYGWIN_THREADS 0
53 # define DEBUG_CYGWIN_THREADS 0
54 # define DEBUG_WIN32_PTHREADS 0
57 void * GC_pthread_start(void * arg);
58 void GC_thread_exit_proc(void *arg);
65 # define DEBUG_WIN32_THREADS 1
67 # define DEBUG_WIN32_THREADS 0
72 # undef _beginthreadex
76 # define DEBUG_WIN32_THREADS 1
78 # define DEBUG_WIN32_THREADS 0
81 # include <process.h> /* For _beginthreadex, _endthreadex */
85 #if defined(GC_DLL) && !defined(MSWINCE)
86 static GC_bool GC_win32_dll_threads = FALSE;
87 /* This code operates in two distinct modes, depending on */
88 /* the setting of GC_win32_dll_threads. If */
89 /* GC_win32_dll_threads is set, all threads in the process */
90 /* are implicitly registered with the GC by DllMain. */
91 /* No explicit registration is required, and attempts at */
92 /* explicit registration are ignored. This mode is */
93 /* very different from the Posix operation of the collector. */
94 /* In this mode access to the thread table is lock-free. */
95 /* Hence there is a static limit on the number of threads. */
97 /* If GC_win32_dll_threads is FALSE, or the collector is */
98 /* built without GC_DLL defined, things operate in a way */
99 /* that is very similar to Posix platforms, and new threads */
100 /* must be registered with the collector, e.g. by using */
101 /* preprocessor-based interception of the thread primitives. */
102 /* In this case, we use a real data structure for the thread */
103 /* table. Note that there is no equivalent of linker-based */
104 /* call interception, since we don't have ELF-like */
105 /* facilities. The Windows analog appears to be "API */
106 /* hooking", which really seems to be a standard way to */
107 /* do minor binary rewriting (?). I'd prefer not to have */
108 /* the basic collector rely on such facilities, but an */
109 /* optional package that intercepts thread calls this way */
110 /* would probably be nice. */
112 /* GC_win32_dll_threads must be set at initialization time, */
113 /* i.e. before any collector or thread calls. We make it a */
114 /* "dynamic" option only to avoid multiple library versions. */
116 # define GC_win32_dll_threads FALSE
119 /* We have two versions of the thread table. Which one */
120 /* we us depends on whether or not GC_win32_dll_threads */
121 /* is set. Note that before initialization, we don't */
122 /* add any entries to either table, even if DllMain is */
123 /* called. The main thread will be added on */
124 /* initialization. */
126 /* The type of the first argument to InterlockedExchange. */
127 /* Documented to be LONG volatile *, but at least gcc likes */
131 GC_bool GC_thr_initialized = FALSE;
133 GC_bool GC_need_to_lock = FALSE;
135 static GC_bool parallel_initialized = FALSE;
137 void GC_init_parallel(void);
140 /* Turn on GC_win32_dll_threads */
141 GC_API void GC_use_DllMain(void)
143 # ifdef THREAD_LOCAL_ALLOC
144 ABORT("Cannot use thread local allocation with DllMain-based "
145 "thread registration.");
146 /* Thread-local allocation really wants to lock at thread */
147 /* entry and exit. */
149 GC_ASSERT(!parallel_initialized);
150 GC_win32_dll_threads = TRUE;
154 GC_API void GC_use_DllMain(void)
156 ABORT("GC not configured as DLL");
160 DWORD GC_main_thread = 0;
162 struct GC_Thread_Rep {
164 AO_t tm_in_use; /* Updated without lock. */
165 /* We assert that unused */
166 /* entries have invalid ids of */
167 /* zero and zero stack fields. */
168 /* Used only with GC_win32_dll_threads. */
169 struct GC_Thread_Rep * tm_next;
170 /* Hash table link without */
171 /* GC_win32_dll_threads. */
172 /* More recently allocated threads */
173 /* with a given pthread id come */
174 /* first. (All but the first are */
175 /* guaranteed to be dead, but we may */
176 /* not yet have registered the join.) */
178 # define in_use table_management.tm_in_use
179 # define next table_management.tm_next
182 ptr_t stack_base; /* The cold end of the stack. */
183 /* 0 ==> entry not valid. */
184 /* !in_use ==> stack_base == 0 */
188 void *status; /* hold exit value until join in case it's a pointer */
189 pthread_t pthread_id;
190 short flags; /* Protected by GC lock. */
191 # define FINISHED 1 /* Thread has exited. */
192 # define DETACHED 2 /* Thread is intended to be detached. */
193 # define KNOWN_FINISHED(t) (((t) -> flags) & FINISHED)
195 # define KNOWN_FINISHED(t) 0
197 # ifdef THREAD_LOCAL_ALLOC
198 struct thread_local_freelists tlfs;
202 typedef struct GC_Thread_Rep * GC_thread;
203 typedef volatile struct GC_Thread_Rep * GC_vthread;
206 * We assumed that volatile ==> memory ordering, at least among
207 * volatiles. This code should consistently use atomic_ops.
210 volatile GC_bool GC_please_stop = FALSE;
213 * We track thread attachments while the world is supposed to be stopped.
214 * Unfortunately, we can't stop them from starting, since blocking in
215 * DllMain seems to cause the world to deadlock. Thus we have to recover
216 * If we notice this in the middle of marking.
219 AO_t GC_attached_thread = FALSE;
220 /* Return TRUE if an thread was attached since we last asked or */
221 /* since GC_attached_thread was explicitly reset. */
222 GC_bool GC_started_thread_while_stopped(void)
226 if (GC_win32_dll_threads) {
227 AO_nop_full(); /* Prior heap reads need to complete earlier. */
228 result = AO_load(&GC_attached_thread);
230 AO_store(&GC_attached_thread, FALSE);
232 return ((GC_bool)result);
238 /* Thread table used if GC_win32_dll_threads is set. */
239 /* This is a fixed size array. */
240 /* Since we use runtime conditionals, both versions */
241 /* are always defined. */
243 # define MAX_THREADS 512
245 /* Things may get quite slow for large numbers of threads, */
246 /* since we look them up with sequential search. */
248 volatile struct GC_Thread_Rep dll_thread_table[MAX_THREADS];
250 volatile LONG GC_max_thread_index = 0;
251 /* Largest index in dll_thread_table */
252 /* that was ever used. */
254 /* And now the version used if GC_win32_dll_threads is not set. */
255 /* This is a chained hash table, with much of the code borrowed */
256 /* From the Posix implementation. */
257 # define THREAD_TABLE_SZ 256 /* Must be power of 2 */
258 GC_thread GC_threads[THREAD_TABLE_SZ];
261 /* Add a thread to GC_threads. We assume it wasn't already there. */
262 /* Caller holds allocation lock. */
263 /* Unlike the pthreads version, the id field is set by the caller. */
264 GC_thread GC_new_thread(DWORD id)
266 word hv = ((word)id) % THREAD_TABLE_SZ;
268 /* It may not be safe to allocate when we register the first thread. */
269 static struct GC_Thread_Rep first_thread;
270 static GC_bool first_thread_used = FALSE;
272 GC_ASSERT(I_HOLD_LOCK());
273 if (!first_thread_used) {
274 result = &first_thread;
275 first_thread_used = TRUE;
277 GC_ASSERT(!GC_win32_dll_threads);
278 result = (struct GC_Thread_Rep *)
279 GC_INTERNAL_MALLOC(sizeof(struct GC_Thread_Rep), NORMAL);
281 /* result can be NULL -> segfault */
282 GC_ASSERT(result -> flags == 0);
285 if (result == 0) return(0);
286 /* result -> id = id; Done by caller. */
287 result -> next = GC_threads[hv];
288 GC_threads[hv] = result;
290 GC_ASSERT(result -> flags == 0 /* && result -> thread_blocked == 0 */);
295 extern LONG WINAPI GC_write_fault_handler(struct _EXCEPTION_POINTERS *exc_info);
297 #if defined(GWW_VDB) && defined(MPROTECT_VDB)
298 extern GC_bool GC_gww_dirty_init(void);
299 /* Defined in os_dep.c. Returns TRUE if GetWriteWatch is available. */
300 /* may be called repeatedly. */
303 GC_bool GC_in_thread_creation = FALSE; /* Protected by allocation lock. */
306 * This may be called from DllMain, and hence operates under unusual
307 * constraints. In particular, it must be lock-free if GC_win32_dll_threads
308 * is set. Always called from the thread being added.
309 * If GC_win32_dll_threads is not set, we already hold the allocation lock,
310 * except possibly during single-threaded start-up code.
312 static GC_thread GC_register_my_thread_inner(struct GC_stack_base *sb,
317 /* The following should be a noop according to the win32 */
318 /* documentation. There is empirical evidence that it */
320 # if defined(MPROTECT_VDB)
321 # if defined(GWW_VDB)
322 if (GC_incremental && !GC_gww_dirty_init())
323 SetUnhandledExceptionFilter(GC_write_fault_handler);
325 if (GC_incremental) SetUnhandledExceptionFilter(GC_write_fault_handler);
329 if (GC_win32_dll_threads) {
331 /* It appears to be unsafe to acquire a lock here, since this */
332 /* code is apparently not preeemptible on some systems. */
333 /* (This is based on complaints, not on Microsoft's official */
334 /* documentation, which says this should perform "only simple */
335 /* initialization tasks".) */
336 /* Hence we make do with nonblocking synchronization. */
337 /* It has been claimed that DllMain is really only executed with */
338 /* a particular system lock held, and thus careful use of locking */
339 /* around code that doesn't call back into the system libraries */
340 /* might be OK. But this hasn't been tested across all win32 */
342 /* cast away volatile qualifier */
343 for (i = 0; InterlockedExchange((IE_t)&dll_thread_table[i].in_use,1) != 0;
345 /* Compare-and-swap would make this cleaner, but that's not */
346 /* supported before Windows 98 and NT 4.0. In Windows 2000, */
347 /* InterlockedExchange is supposed to be replaced by */
348 /* InterlockedExchangePointer, but that's not really what I */
350 /* FIXME: We should eventually declare Win95 dead and use AO_ */
351 /* primitives here. */
352 if (i == MAX_THREADS - 1)
353 ABORT("too many threads");
355 /* Update GC_max_thread_index if necessary. The following is safe, */
356 /* and unlike CompareExchange-based solutions seems to work on all */
357 /* Windows95 and later platforms. */
358 /* Unfortunately, GC_max_thread_index may be temporarily out of */
359 /* bounds, so readers have to compensate. */
360 while (i > GC_max_thread_index) {
361 InterlockedIncrement((IE_t)&GC_max_thread_index);
363 if (GC_max_thread_index >= MAX_THREADS) {
364 /* We overshot due to simultaneous increments. */
365 /* Setting it to MAX_THREADS-1 is always safe. */
366 GC_max_thread_index = MAX_THREADS - 1;
368 me = dll_thread_table + i;
369 } else /* Not using DllMain */ {
370 GC_ASSERT(I_HOLD_LOCK());
371 GC_in_thread_creation = TRUE; /* OK to collect from unknown thread. */
372 me = GC_new_thread(thread_id);
373 GC_in_thread_creation = FALSE;
376 /* me can be NULL -> segfault */
377 me -> pthread_id = pthread_self();
380 if (!DuplicateHandle(GetCurrentProcess(),
383 (HANDLE*)&(me -> handle),
386 DUPLICATE_SAME_ACCESS)) {
387 DWORD last_error = GetLastError();
388 GC_err_printf("Last error code: %d\n", last_error);
389 ABORT("DuplicateHandle failed");
391 me -> stack_base = sb -> mem_base;
392 /* Up until this point, GC_push_all_stacks considers this thread */
394 /* Up until this point, this entry is viewed as reserved but invalid */
395 /* by GC_delete_thread. */
396 me -> id = thread_id;
397 # if defined(THREAD_LOCAL_ALLOC)
398 GC_init_thread_local((GC_tlfs)(&(me->tlfs)));
400 if (me -> stack_base == NULL)
401 ABORT("Bad stack base in GC_register_my_thread_inner");
402 if (GC_win32_dll_threads) {
403 if (GC_please_stop) {
404 AO_store(&GC_attached_thread, TRUE);
405 AO_nop_full(); // Later updates must become visible after this.
407 /* We'd like to wait here, but can't, since waiting in DllMain */
408 /* provokes deadlocks. */
409 /* Thus we force marking to be restarted instead. */
411 GC_ASSERT(!GC_please_stop);
412 /* Otherwise both we and the thread stopping code would be */
413 /* holding the allocation lock. */
415 return (GC_thread)(me);
419 * GC_max_thread_index may temporarily be larger than MAX_THREADS.
420 * To avoid subscript errors, we check on access.
425 LONG GC_get_max_thread_index()
427 LONG my_max = GC_max_thread_index;
429 if (my_max >= MAX_THREADS) return MAX_THREADS-1;
433 /* Return the GC_thread corresponding to a thread id. May be called */
434 /* without a lock, but should be called in contexts in which the */
435 /* requested thread cannot be asynchronously deleted, e.g. from the */
437 /* This version assumes that either GC_win32_dll_threads is set, or */
438 /* we hold the allocator lock. */
439 /* Also used (for assertion checking only) from thread_local_alloc.c. */
440 GC_thread GC_lookup_thread_inner(DWORD thread_id) {
441 if (GC_win32_dll_threads) {
443 LONG my_max = GC_get_max_thread_index();
446 (!AO_load_acquire(&(dll_thread_table[i].in_use))
447 || dll_thread_table[i].id != thread_id);
448 /* Must still be in_use, since nobody else can store our thread_id. */
453 return (GC_thread)(dll_thread_table + i);
456 word hv = ((word)thread_id) % THREAD_TABLE_SZ;
457 register GC_thread p = GC_threads[hv];
459 GC_ASSERT(I_HOLD_LOCK());
460 while (p != 0 && p -> id != thread_id) p = p -> next;
465 /* A version of the above that acquires the lock if necessary. Note */
466 /* that the identically named function for pthreads is different, and */
467 /* just assumes we hold the lock. */
468 /* Also used (for assertion checking only) from thread_local_alloc.c. */
469 static GC_thread GC_lookup_thread(DWORD thread_id)
471 if (GC_win32_dll_threads) {
472 return GC_lookup_thread_inner(thread_id);
476 result = GC_lookup_thread_inner(thread_id);
482 /* If a thread has been joined, but we have not yet */
483 /* been notified, then there may be more than one thread */
484 /* in the table with the same win32 id. */
485 /* This is OK, but we need a way to delete a specific one. */
486 /* Assumes we hold the allocation lock unless */
487 /* GC_win32_dll_threads is set. */
488 /* If GC_win32_dll_threads is set it should be called from the */
489 /* thread being deleted. */
490 void GC_delete_gc_thread(GC_vthread gc_id)
492 CloseHandle(gc_id->handle);
493 if (GC_win32_dll_threads) {
494 /* This is intended to be lock-free. */
495 /* It is either called synchronously from the thread being deleted, */
496 /* or by the joining thread. */
497 /* In this branch asynchronosu changes to *gc_id are possible. */
498 gc_id -> stack_base = 0;
501 gc_id -> pthread_id = 0;
502 # endif /* CYGWIN32 */
503 # ifdef GC_WIN32_PTHREADS
504 gc_id -> pthread_id.p = NULL;
505 # endif /* GC_WIN32_PTHREADS */
506 AO_store_release(&(gc_id->in_use), FALSE);
508 /* Cast away volatile qualifier, since we have lock. */
509 GC_thread gc_nvid = (GC_thread)gc_id;
510 DWORD id = gc_nvid -> id;
511 word hv = ((word)id) % THREAD_TABLE_SZ;
512 register GC_thread p = GC_threads[hv];
513 register GC_thread prev = 0;
515 GC_ASSERT(I_HOLD_LOCK());
516 while (p != gc_nvid) {
521 GC_threads[hv] = p -> next;
523 prev -> next = p -> next;
529 /* Delete a thread from GC_threads. We assume it is there. */
530 /* (The code intentionally traps if it wasn't.) */
531 /* Assumes we hold the allocation lock unless */
532 /* GC_win32_dll_threads is set. */
533 /* If GC_win32_dll_threads is set it should be called from the */
534 /* thread being deleted. */
535 void GC_delete_thread(DWORD id)
537 if (GC_win32_dll_threads) {
538 GC_thread t = GC_lookup_thread_inner(id);
541 WARN("Removing nonexistent thread %ld\n", (GC_word)id);
543 GC_delete_gc_thread(t);
546 word hv = ((word)id) % THREAD_TABLE_SZ;
547 register GC_thread p = GC_threads[hv];
548 register GC_thread prev = 0;
550 GC_ASSERT(I_HOLD_LOCK());
551 while (p -> id != id) {
555 CloseHandle(p->handle);
557 GC_threads[hv] = p -> next;
559 prev -> next = p -> next;
565 GC_API int GC_register_my_thread(struct GC_stack_base *sb) {
566 DWORD t = GetCurrentThreadId();
568 if (0 == GC_lookup_thread(t)) {
569 /* We lock here, since we want to wait for an ongoing GC. */
571 GC_register_my_thread_inner(sb, t);
579 GC_API int GC_unregister_my_thread(void)
581 DWORD t = GetCurrentThreadId();
583 # if defined(THREAD_LOCAL_ALLOC)
586 GC_thread me = GC_lookup_thread_inner(t);
587 GC_destroy_thread_local(&(me->tlfs));
591 if (GC_win32_dll_threads) {
592 /* Should we just ignore this? */
605 /* A quick-and-dirty cache of the mapping between pthread_t */
606 /* and win32 thread id. */
607 #define PTHREAD_MAP_SIZE 512
608 DWORD GC_pthread_map_cache[PTHREAD_MAP_SIZE];
609 #define HASH(pthread_id) ((NUMERIC_THREAD_ID(pthread_id) >> 5) % PTHREAD_MAP_SIZE)
610 /* It appears pthread_t is really a pointer type ... */
611 #define SET_PTHREAD_MAP_CACHE(pthread_id, win32_id) \
612 GC_pthread_map_cache[HASH(pthread_id)] = (win32_id);
613 #define GET_PTHREAD_MAP_CACHE(pthread_id) \
614 GC_pthread_map_cache[HASH(pthread_id)]
616 /* Return a GC_thread corresponding to a given pthread_t. */
617 /* Returns 0 if it's not there. */
618 /* We assume that this is only called for pthread ids that */
619 /* have not yet terminated or are still joinable, and */
620 /* cannot be concurrently terminated. */
621 /* Assumes we do NOT hold the allocation lock. */
622 static GC_thread GC_lookup_pthread(pthread_t id)
624 if (GC_win32_dll_threads) {
626 LONG my_max = GC_get_max_thread_index();
630 (!AO_load_acquire(&(dll_thread_table[i].in_use))
631 || THREAD_EQUAL(dll_thread_table[i].pthread_id, id));
632 /* Must still be in_use, since nobody else can store our thread_id. */
634 if (i > my_max) return 0;
635 return (GC_thread)(dll_thread_table + i);
637 /* We first try the cache. If that fails, we use a very slow */
639 int hv_guess = GET_PTHREAD_MAP_CACHE(id) % THREAD_TABLE_SZ;
644 for (p = GC_threads[hv_guess]; 0 != p; p = p -> next) {
645 if (THREAD_EQUAL(p -> pthread_id, id))
648 for (hv = 0; hv < THREAD_TABLE_SZ; ++hv) {
649 for (p = GC_threads[hv]; 0 != p; p = p -> next) {
650 if (THREAD_EQUAL(p -> pthread_id, id))
661 #endif /* GC_PTHREADS */
663 void GC_push_thread_structures(void)
665 GC_ASSERT(I_HOLD_LOCK());
666 if (GC_win32_dll_threads) {
667 /* Unlike the other threads implementations, the thread table here */
668 /* contains no pointers to the collectable heap. Thus we have */
669 /* no private structures we need to preserve. */
671 { int i; /* pthreads may keep a pointer in the thread exit value */
672 LONG my_max = GC_get_max_thread_index();
674 for (i = 0; i <= my_max; i++)
675 if (dll_thread_table[i].in_use)
676 GC_push_all((ptr_t)&(dll_thread_table[i].status),
677 (ptr_t)(&(dll_thread_table[i].status)+1));
681 GC_push_all((ptr_t)(GC_threads), (ptr_t)(GC_threads)+sizeof(GC_threads));
683 # if defined(THREAD_LOCAL_ALLOC)
684 GC_push_all((ptr_t)(&GC_thread_key),
685 (ptr_t)(&GC_thread_key)+sizeof(&GC_thread_key));
686 /* Just in case we ever use our own TLS implementation. */
690 /* Suspend the given thread, if it's still active. */
691 void GC_suspend(GC_thread t)
694 /* SuspendThread will fail if thread is running kernel code */
695 while (SuspendThread(t -> handle) == (DWORD)-1)
698 /* Apparently the Windows 95 GetOpenFileName call creates */
699 /* a thread that does not properly get cleaned up, and */
700 /* SuspendThread on its descriptor may provoke a crash. */
701 /* This reduces the probability of that event, though it still */
702 /* appears there's a race here. */
704 if (GetExitCodeThread(t -> handle, &exitCode) &&
705 exitCode != STILL_ACTIVE) {
706 t -> stack_base = 0; /* prevent stack from being pushed */
708 /* this breaks pthread_join on Cygwin, which is guaranteed to */
709 /* only see user pthreads */
710 GC_ASSERT(GC_win32_dll_threads);
711 GC_delete_gc_thread(t);
715 if (SuspendThread(t -> handle) == (DWORD)-1)
716 ABORT("SuspendThread failed");
718 t -> suspended = TRUE;
721 /* Defined in misc.c */
723 extern CRITICAL_SECTION GC_write_cs;
726 void GC_stop_world(void)
728 DWORD thread_id = GetCurrentThreadId();
731 if (!GC_thr_initialized) ABORT("GC_stop_world() called before GC_thr_init()");
732 GC_ASSERT(I_HOLD_LOCK());
734 GC_please_stop = TRUE;
736 EnterCriticalSection(&GC_write_cs);
738 if (GC_win32_dll_threads) {
739 /* Any threads being created during this loop will end up setting */
740 /* GC_attached_thread when they start. This will force marking to */
742 /* This is not ideal, but hopefully correct. */
743 GC_attached_thread = FALSE;
744 for (i = 0; i <= GC_get_max_thread_index(); i++) {
745 GC_vthread t = dll_thread_table + i;
746 if (t -> stack_base != 0
747 && t -> id != thread_id) {
748 GC_suspend((GC_thread)t);
755 for (i = 0; i < THREAD_TABLE_SZ; i++) {
756 for (t = GC_threads[i]; t != 0; t = t -> next) {
757 if (t -> stack_base != 0
758 && !KNOWN_FINISHED(t)
759 && t -> id != thread_id) {
766 LeaveCriticalSection(&GC_write_cs);
770 void GC_start_world(void)
772 DWORD thread_id = GetCurrentThreadId();
774 LONG my_max = GC_get_max_thread_index();
776 GC_ASSERT(I_HOLD_LOCK());
777 if (GC_win32_dll_threads) {
778 for (i = 0; i <= my_max; i++) {
779 GC_thread t = (GC_thread)(dll_thread_table + i);
780 if (t -> stack_base != 0 && t -> suspended
781 && t -> id != thread_id) {
782 if (ResumeThread(t -> handle) == (DWORD)-1)
783 ABORT("ResumeThread failed");
784 t -> suspended = FALSE;
791 for (i = 0; i < THREAD_TABLE_SZ; i++) {
792 for (t = GC_threads[i]; t != 0; t = t -> next) {
793 if (t -> stack_base != 0 && t -> suspended
794 && t -> id != thread_id) {
795 if (ResumeThread(t -> handle) == (DWORD)-1)
796 ABORT("ResumeThread failed");
797 t -> suspended = FALSE;
802 GC_please_stop = FALSE;
806 /* The VirtualQuery calls below won't work properly on WinCE, but */
807 /* since each stack is restricted to an aligned 64K region of */
808 /* virtual memory we can just take the next lowest multiple of 64K. */
809 # define GC_get_stack_min(s) \
810 ((ptr_t)(((DWORD)(s) - 1) & 0xFFFF0000))
812 static ptr_t GC_get_stack_min(ptr_t s)
815 MEMORY_BASIC_INFORMATION info;
816 VirtualQuery(s, &info, sizeof(info));
818 bottom = info.BaseAddress;
819 VirtualQuery(bottom - 1, &info, sizeof(info));
820 } while ((info.Protect & PAGE_READWRITE)
821 && !(info.Protect & PAGE_GUARD));
826 void GC_push_stack_for(GC_thread thread)
830 DWORD me = GetCurrentThreadId();
832 if (thread -> stack_base) {
833 if (thread -> id == me) {
837 context.ContextFlags = CONTEXT_INTEGER|CONTEXT_CONTROL;
838 if (!GetThreadContext(thread -> handle, &context))
839 ABORT("GetThreadContext failed");
841 /* Push all registers that might point into the heap. Frame */
842 /* pointer registers are included in case client code was */
843 /* compiled with the 'omit frame pointer' optimisation. */
844 # define PUSH1(reg) GC_push_one((word)context.reg)
845 # define PUSH2(r1,r2) PUSH1(r1), PUSH1(r2)
846 # define PUSH4(r1,r2,r3,r4) PUSH2(r1,r2), PUSH2(r3,r4)
848 PUSH4(Edi,Esi,Ebx,Edx), PUSH2(Ecx,Eax), PUSH1(Ebp);
849 sp = (ptr_t)context.Esp;
850 # elif defined(X86_64)
851 PUSH4(Rax,Rcx,Rdx,Rbx); PUSH2(Rbp, Rsi); PUSH1(Rdi);
852 PUSH4(R8, R9, R10, R11); PUSH4(R12, R13, R14, R15);
853 sp = (ptr_t)context.Rsp;
854 # elif defined(ARM32)
855 PUSH4(R0,R1,R2,R3),PUSH4(R4,R5,R6,R7),PUSH4(R8,R9,R10,R11),PUSH1(R12);
856 sp = (ptr_t)context.Sp;
858 PUSH4(R0,R1,R2,R3), PUSH4(R4,R5,R6,R7), PUSH4(R8,R9,R10,R11);
859 PUSH2(R12,R13), PUSH1(R14);
860 sp = (ptr_t)context.R15;
862 PUSH4(IntAt,IntV0,IntV1,IntA0), PUSH4(IntA1,IntA2,IntA3,IntT0);
863 PUSH4(IntT1,IntT2,IntT3,IntT4), PUSH4(IntT5,IntT6,IntT7,IntS0);
864 PUSH4(IntS1,IntS2,IntS3,IntS4), PUSH4(IntS5,IntS6,IntS7,IntT8);
865 PUSH4(IntT9,IntK0,IntK1,IntS8);
866 sp = (ptr_t)context.IntSp;
868 PUSH4(Gpr0, Gpr3, Gpr4, Gpr5), PUSH4(Gpr6, Gpr7, Gpr8, Gpr9);
869 PUSH4(Gpr10,Gpr11,Gpr12,Gpr14), PUSH4(Gpr15,Gpr16,Gpr17,Gpr18);
870 PUSH4(Gpr19,Gpr20,Gpr21,Gpr22), PUSH4(Gpr23,Gpr24,Gpr25,Gpr26);
871 PUSH4(Gpr27,Gpr28,Gpr29,Gpr30), PUSH1(Gpr31);
872 sp = (ptr_t)context.Gpr1;
873 # elif defined(ALPHA)
874 PUSH4(IntV0,IntT0,IntT1,IntT2), PUSH4(IntT3,IntT4,IntT5,IntT6);
875 PUSH4(IntT7,IntS0,IntS1,IntS2), PUSH4(IntS3,IntS4,IntS5,IntFp);
876 PUSH4(IntA0,IntA1,IntA2,IntA3), PUSH4(IntA4,IntA5,IntT8,IntT9);
877 PUSH4(IntT10,IntT11,IntT12,IntAt);
878 sp = (ptr_t)context.IntSp;
880 # error "architecture is not supported"
882 } /* ! current thread */
884 stack_min = GC_get_stack_min(thread->stack_base);
886 if (sp >= stack_min && sp < thread->stack_base) {
887 # if DEBUG_WIN32_PTHREADS || DEBUG_WIN32_THREADS \
888 || DEBUG_CYGWIN_THREADS
889 GC_printf("Pushing thread from %p to %p for 0x%x from 0x%x\n",
890 sp, thread -> stack_base, thread -> id, me);
892 GC_push_all_stack(sp, thread->stack_base);
894 WARN("Thread stack pointer 0x%lx out of range, pushing everything\n",
895 (unsigned long)(size_t)sp);
896 GC_push_all_stack(stack_min, thread->stack_base);
898 } /* thread looks live */
901 void GC_push_all_stacks(void)
903 DWORD me = GetCurrentThreadId();
904 GC_bool found_me = FALSE;
907 if (GC_win32_dll_threads) {
909 LONG my_max = GC_get_max_thread_index();
911 for (i = 0; i <= my_max; i++) {
912 GC_thread t = (GC_thread)(dll_thread_table + i);
915 GC_push_stack_for(t);
916 if (t -> id == me) found_me = TRUE;
923 for (i = 0; i < THREAD_TABLE_SZ; i++) {
924 for (t = GC_threads[i]; t != 0; t = t -> next) {
926 if (!KNOWN_FINISHED(t)) GC_push_stack_for(t);
927 if (t -> id == me) found_me = TRUE;
931 if (GC_print_stats == VERBOSE) {
932 GC_log_printf("Pushed %d thread stacks ", nthreads);
933 if (GC_win32_dll_threads) {
934 GC_log_printf("based on DllMain thread tracking\n");
939 if (!found_me && !GC_in_thread_creation)
940 ABORT("Collecting from unknown thread.");
943 void GC_get_next_stack(char *start, char **lo, char **hi)
946 # define ADDR_LIMIT (char *)(-1L)
947 char * current_min = ADDR_LIMIT;
949 if (GC_win32_dll_threads) {
950 LONG my_max = GC_get_max_thread_index();
952 for (i = 0; i <= my_max; i++) {
953 ptr_t s = (ptr_t)(dll_thread_table[i].stack_base);
955 if (0 != s && s > start && s < current_min) {
960 for (i = 0; i < THREAD_TABLE_SZ; i++) {
963 for (t = GC_threads[i]; t != 0; t = t -> next) {
964 ptr_t s = (ptr_t)(t -> stack_base);
966 if (0 != s && s > start && s < current_min) {
973 if (current_min == ADDR_LIMIT) {
977 *lo = GC_get_stack_min(current_min);
978 if (*lo < start) *lo = start;
983 /* We have no DllMain to take care of new threads. Thus we */
984 /* must properly intercept thread creation. */
987 LPTHREAD_START_ROUTINE start;
991 static DWORD WINAPI thread_start(LPVOID arg);
993 void * GC_win32_start_inner(struct GC_stack_base *sb, LPVOID arg)
996 thread_args *args = (thread_args *)arg;
998 # if DEBUG_WIN32_THREADS
999 GC_printf("thread 0x%x starting...\n", GetCurrentThreadId());
1002 GC_register_my_thread(sb); /* This waits for an in-progress GC. */
1004 /* Clear the thread entry even if we exit with an exception. */
1005 /* This is probably pointless, since an uncaught exception is */
1006 /* supposed to result in the process being killed. */
1009 #endif /* __GNUC__ */
1010 ret = (void *)(size_t)args->start (args->param);
1013 #endif /* __GNUC__ */
1014 GC_unregister_my_thread();
1018 #endif /* __GNUC__ */
1020 # if DEBUG_WIN32_THREADS
1021 GC_printf("thread 0x%x returned from start routine.\n",
1022 GetCurrentThreadId());
1027 DWORD WINAPI GC_win32_start(LPVOID arg)
1029 return (DWORD)(size_t)GC_call_with_stack_base(GC_win32_start_inner, arg);
1032 GC_API HANDLE WINAPI GC_CreateThread(
1033 LPSECURITY_ATTRIBUTES lpThreadAttributes,
1034 DWORD dwStackSize, LPTHREAD_START_ROUTINE lpStartAddress,
1035 LPVOID lpParameter, DWORD dwCreationFlags, LPDWORD lpThreadId )
1037 HANDLE thread_h = NULL;
1041 if (!parallel_initialized) GC_init_parallel();
1042 /* make sure GC is initialized (i.e. main thread is attached,
1045 # if DEBUG_WIN32_THREADS
1046 GC_printf("About to create a thread from 0x%x\n", GetCurrentThreadId());
1048 if (GC_win32_dll_threads) {
1049 return CreateThread(lpThreadAttributes, dwStackSize, lpStartAddress,
1050 lpParameter, dwCreationFlags, lpThreadId);
1052 args = GC_malloc_uncollectable(sizeof(thread_args));
1053 /* Handed off to and deallocated by child thread. */
1055 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
1059 /* set up thread arguments */
1060 args -> start = lpStartAddress;
1061 args -> param = lpParameter;
1063 GC_need_to_lock = TRUE;
1064 thread_h = CreateThread(lpThreadAttributes,
1065 dwStackSize, GC_win32_start,
1066 args, dwCreationFlags,
1068 if( thread_h == 0 ) GC_free( args );
1073 void WINAPI GC_ExitThread(DWORD dwExitCode)
1075 GC_unregister_my_thread();
1076 ExitThread(dwExitCode);
1079 uintptr_t GC_beginthreadex(
1080 void *security, unsigned stack_size,
1081 unsigned ( __stdcall *start_address )( void * ),
1082 void *arglist, unsigned initflag, unsigned *thrdaddr)
1088 if (!parallel_initialized) GC_init_parallel();
1089 /* make sure GC is initialized (i.e. main thread is attached,
1091 # if DEBUG_WIN32_THREADS
1092 GC_printf("About to create a thread from 0x%x\n", GetCurrentThreadId());
1095 if (GC_win32_dll_threads) {
1096 return _beginthreadex(security, stack_size, start_address,
1097 arglist, initflag, thrdaddr);
1099 args = GC_malloc_uncollectable(sizeof(thread_args));
1100 /* Handed off to and deallocated by child thread. */
1102 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
1103 return (uintptr_t)(-1L);
1106 /* set up thread arguments */
1107 args -> start = (LPTHREAD_START_ROUTINE)start_address;
1108 args -> param = arglist;
1110 GC_need_to_lock = TRUE;
1111 thread_h = _beginthreadex(security, stack_size,
1112 (unsigned (__stdcall *) (void *))GC_win32_start,
1113 args, initflag, thrdaddr);
1114 if( thread_h == 0 ) GC_free( args );
1119 void GC_endthreadex(unsigned retval)
1121 GC_unregister_my_thread();
1122 _endthreadex(retval);
1125 #endif /* !GC_PTHREADS */
1130 HINSTANCE hInstance;
1131 HINSTANCE hPrevInstance;
1136 DWORD WINAPI main_thread_start(LPVOID arg);
1138 int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
1139 LPWSTR lpCmdLine, int nShowCmd)
1141 DWORD exit_code = 1;
1143 main_thread_args args = {
1144 hInstance, hPrevInstance, lpCmdLine, nShowCmd
1149 /* initialize everything */
1152 /* start the main thread */
1153 thread_h = GC_CreateThread(
1154 NULL, 0, main_thread_start, &args, 0, &thread_id);
1156 if (thread_h != NULL)
1158 WaitForSingleObject (thread_h, INFINITE);
1159 GetExitCodeThread (thread_h, &exit_code);
1160 CloseHandle (thread_h);
1164 DeleteCriticalSection(&GC_allocate_ml);
1166 return (int) exit_code;
1169 DWORD WINAPI main_thread_start(LPVOID arg)
1171 main_thread_args * args = (main_thread_args *) arg;
1173 return (DWORD) GC_WinMain (args->hInstance, args->hPrevInstance,
1174 args->lpCmdLine, args->nShowCmd);
1177 # else /* !MSWINCE */
1179 /* Called by GC_init() - we hold the allocation lock. */
1180 void GC_thr_init(void) {
1181 struct GC_stack_base sb;
1184 GC_ASSERT(I_HOLD_LOCK());
1185 if (GC_thr_initialized) return;
1186 GC_main_thread = GetCurrentThreadId();
1187 GC_thr_initialized = TRUE;
1189 /* Add the initial thread, so we can stop it. */
1190 sb_result = GC_get_stack_base(&sb);
1191 GC_ASSERT(sb_result == GC_SUCCESS);
1192 GC_register_my_thread(&sb);
1198 void *(*start_routine)(void *);
1203 int GC_pthread_join(pthread_t pthread_id, void **retval) {
1208 # if DEBUG_CYGWIN_THREADS
1209 GC_printf("thread 0x%x(0x%x) is joining thread 0x%x.\n",
1210 (int)pthread_self(), GetCurrentThreadId(), (int)pthread_id);
1212 # if DEBUG_WIN32_PTHREADS
1213 GC_printf("thread 0x%x(0x%x) is joining thread 0x%x.\n",
1214 (int)(pthread_self()).p, GetCurrentThreadId(), pthread_id.p);
1217 if (!parallel_initialized) GC_init_parallel();
1218 /* Thread being joined might not have registered itself yet. */
1219 /* After the join,thread id may have been recycled. */
1220 /* FIXME: It would be better if this worked more like */
1221 /* pthread_support.c. */
1223 #ifndef GC_WIN32_PTHREADS
1224 while ((joinee = GC_lookup_pthread(pthread_id)) == 0) Sleep(10);
1227 result = pthread_join(pthread_id, retval);
1229 #ifdef GC_WIN32_PTHREADS
1230 /* win32_pthreads id are unique */
1231 joinee = GC_lookup_pthread(pthread_id);
1234 if (!GC_win32_dll_threads) {
1236 GC_delete_gc_thread(joinee);
1238 } /* otherwise dllmain handles it. */
1240 # if DEBUG_CYGWIN_THREADS
1241 GC_printf("thread 0x%x(0x%x) completed join with thread 0x%x.\n",
1242 (int)pthread_self(), GetCurrentThreadId(), (int)pthread_id);
1244 # if DEBUG_WIN32_PTHREADS
1245 GC_printf("thread 0x%x(0x%x) completed join with thread 0x%x.\n",
1246 (int)(pthread_self()).p, GetCurrentThreadId(), pthread_id.p);
1252 /* Cygwin-pthreads calls CreateThread internally, but it's not
1253 * easily interceptible by us..
1254 * so intercept pthread_create instead
1257 GC_pthread_create(pthread_t *new_thread,
1258 const pthread_attr_t *attr,
1259 void *(*start_routine)(void *), void *arg) {
1261 struct start_info * si;
1263 if (!parallel_initialized) GC_init_parallel();
1264 /* make sure GC is initialized (i.e. main thread is attached) */
1265 if (GC_win32_dll_threads) {
1266 return pthread_create(new_thread, attr, start_routine, arg);
1269 /* This is otherwise saved only in an area mmapped by the thread */
1270 /* library, which isn't visible to the collector. */
1271 si = GC_malloc_uncollectable(sizeof(struct start_info));
1272 if (0 == si) return(EAGAIN);
1274 si -> start_routine = start_routine;
1277 pthread_attr_getdetachstate(attr, &si->detached)
1278 == PTHREAD_CREATE_DETACHED) {
1279 si->detached = TRUE;
1282 # if DEBUG_CYGWIN_THREADS
1283 GC_printf("About to create a thread from 0x%x(0x%x)\n",
1284 (int)pthread_self(), GetCurrentThreadId);
1286 # if DEBUG_WIN32_PTHREADS
1287 GC_printf("About to create a thread from 0x%x(0x%x)\n",
1288 (int)(pthread_self()).p, GetCurrentThreadId());
1290 GC_need_to_lock = TRUE;
1291 result = pthread_create(new_thread, attr, GC_pthread_start, si);
1293 if (result) { /* failure */
1300 void * GC_pthread_start_inner(struct GC_stack_base *sb, void * arg)
1302 struct start_info * si = arg;
1304 void *(*start)(void *);
1306 DWORD thread_id = GetCurrentThreadId();
1307 pthread_t pthread_id = pthread_self();
1312 # if DEBUG_CYGWIN_THREADS
1313 GC_printf("thread 0x%x(0x%x) starting...\n",(int)pthread_id,
1316 # if DEBUG_WIN32_PTHREADS
1317 GC_printf("thread 0x%x(0x%x) starting...\n",(int) pthread_id.p,
1321 GC_ASSERT(!GC_win32_dll_threads);
1322 /* If a GC occurs before the thread is registered, that GC will */
1323 /* ignore this thread. That's fine, since it will block trying to */
1324 /* acquire the allocation lock, and won't yet hold interesting */
1327 /* We register the thread here instead of in the parent, so that */
1328 /* we don't need to hold the allocation lock during pthread_create. */
1329 me = GC_register_my_thread_inner(sb, thread_id);
1330 SET_PTHREAD_MAP_CACHE(pthread_id, thread_id);
1333 start = si -> start_routine;
1334 start_arg = si -> arg;
1335 if (si-> detached) me -> flags |= DETACHED;
1336 me -> pthread_id = pthread_id;
1338 GC_free(si); /* was allocated uncollectable */
1340 pthread_cleanup_push(GC_thread_exit_proc, (void *)me);
1341 result = (*start)(start_arg);
1342 me -> status = result;
1343 pthread_cleanup_pop(1);
1345 # if DEBUG_CYGWIN_THREADS
1346 GC_printf("thread 0x%x(0x%x) returned from start routine.\n",
1347 (int)pthread_self(),GetCurrentThreadId());
1349 # if DEBUG_WIN32_PTHREADS
1350 GC_printf("thread 0x%x(0x%x) returned from start routine.\n",
1351 (int)(pthread_self()).p, GetCurrentThreadId());
1357 void * GC_pthread_start(void * arg)
1359 return GC_call_with_stack_base(GC_pthread_start_inner, arg);
1362 void GC_thread_exit_proc(void *arg)
1364 GC_thread me = (GC_thread)arg;
1367 GC_ASSERT(!GC_win32_dll_threads);
1368 # if DEBUG_CYGWIN_THREADS
1369 GC_printf("thread 0x%x(0x%x) called pthread_exit().\n",
1370 (int)pthread_self(),GetCurrentThreadId());
1372 # if DEBUG_WIN32_PTHREADS
1373 GC_printf("thread 0x%x(0x%x) called pthread_exit().\n",
1374 (int)(pthread_self()).p,GetCurrentThreadId());
1378 # if defined(THREAD_LOCAL_ALLOC)
1379 GC_destroy_thread_local(&(me->tlfs));
1381 if (me -> flags & DETACHED) {
1382 GC_delete_thread(GetCurrentThreadId());
1384 /* deallocate it as part of join */
1385 me -> flags |= FINISHED;
1390 #ifndef GC_WIN32_PTHREADS
1391 /* win32 pthread does not support sigmask */
1392 /* nothing required here... */
1393 int GC_pthread_sigmask(int how, const sigset_t *set, sigset_t *oset) {
1394 if (!parallel_initialized) GC_init_parallel();
1395 return pthread_sigmask(how, set, oset);
1399 int GC_pthread_detach(pthread_t thread)
1402 GC_thread thread_gc_id;
1404 if (!parallel_initialized) GC_init_parallel();
1406 thread_gc_id = GC_lookup_pthread(thread);
1408 result = pthread_detach(thread);
1411 thread_gc_id -> flags |= DETACHED;
1412 /* Here the pthread thread id may have been recycled. */
1413 if (thread_gc_id -> flags & FINISHED) {
1414 GC_delete_gc_thread(thread_gc_id);
1421 #else /* !GC_PTHREADS */
1424 * We avoid acquiring locks here, since this doesn't seem to be preemptable.
1425 * This may run with an uninitialized collector, in which case we don't do much.
1426 * This implies that no threads other than the main one should be created
1427 * with an uninitialized collector. (The alternative of initializing
1428 * the collector here seems dangerous, since DllMain is limited in what it
1432 GC_API BOOL WINAPI DllMain(HINSTANCE inst, ULONG reason, LPVOID reserved)
1434 struct GC_stack_base sb;
1437 static int entry_count = 0;
1439 if (parallel_initialized && !GC_win32_dll_threads) return TRUE;
1442 case DLL_THREAD_ATTACH:
1443 GC_ASSERT(entry_count == 0 || parallel_initialized);
1444 ++entry_count; /* and fall through: */
1445 case DLL_PROCESS_ATTACH:
1446 /* This may run with the collector uninitialized. */
1447 thread_id = GetCurrentThreadId();
1448 if (parallel_initialized && GC_main_thread != thread_id) {
1449 /* Don't lock here. */
1450 sb_result = GC_get_stack_base(&sb);
1451 GC_ASSERT(sb_result == GC_SUCCESS);
1452 # ifdef THREAD_LOCAL_ALLOC
1453 ABORT("Cannot initialize thread local cache from DllMain");
1455 GC_register_my_thread_inner(&sb, thread_id);
1456 } /* o.w. we already did it during GC_thr_init(), called by GC_init() */
1459 case DLL_THREAD_DETACH:
1460 /* We are hopefully running in the context of the exiting thread. */
1461 GC_ASSERT(parallel_initialized);
1462 if (!GC_win32_dll_threads) return TRUE;
1463 GC_delete_thread(GetCurrentThreadId());
1466 case DLL_PROCESS_DETACH:
1470 if (!GC_win32_dll_threads) return TRUE;
1471 for (i = 0; i <= GC_get_max_thread_index(); ++i)
1473 if (AO_load(&(dll_thread_table[i].in_use)))
1474 GC_delete_gc_thread(dll_thread_table + i);
1478 DeleteCriticalSection(&GC_allocate_ml);
1486 #endif /* !GC_PTHREADS */
1488 # endif /* !MSWINCE */
1490 /* Perform all initializations, including those that */
1491 /* may require allocation. */
1492 /* Called without allocation lock. */
1493 /* Must be called before a second thread is created. */
1494 void GC_init_parallel(void)
1496 if (parallel_initialized) return;
1497 parallel_initialized = TRUE;
1498 /* GC_init() calls us back, so set flag first. */
1500 if (!GC_is_initialized) GC_init();
1501 if (GC_win32_dll_threads) {
1502 GC_need_to_lock = TRUE;
1503 /* Cannot intercept thread creation. Hence we don't know if */
1504 /* other threads exist. However, client is not allowed to */
1505 /* create other threads before collector initialization. */
1506 /* Thus it's OK not to lock before this. */
1508 /* Initialize thread local free lists if used. */
1509 # if defined(THREAD_LOCAL_ALLOC)
1511 GC_init_thread_local(&(GC_lookup_thread(GetCurrentThreadId())->tlfs));
1516 #if defined(USE_PTHREAD_LOCKS)
1517 /* Support for pthread locking code. */
1518 /* Pthread_mutex_try_lock may not win here, */
1519 /* due to builtinsupport for spinning first? */
1521 volatile GC_bool GC_collecting = 0;
1522 /* A hint that we're in the collector and */
1523 /* holding the allocation lock for an */
1524 /* extended period. */
1528 pthread_mutex_lock(&GC_allocate_ml);
1530 #endif /* USE_PTHREAD ... */
1532 # if defined(THREAD_LOCAL_ALLOC)
1534 /* Add thread-local allocation support. Microsoft uses __declspec(thread) */
1536 /* We must explicitly mark ptrfree and gcj free lists, since the free */
1537 /* list links wouldn't otherwise be found. We also set them in the */
1538 /* normal free lists, since that involves touching less memory than if */
1539 /* we scanned them normally. */
1540 void GC_mark_thread_local_free_lists(void)
1545 for (i = 0; i < THREAD_TABLE_SZ; ++i) {
1546 for (p = GC_threads[i]; 0 != p; p = p -> next) {
1547 GC_mark_thread_local_fls_for(&(p->tlfs));
1552 #if defined(GC_ASSERTIONS)
1553 /* Check that all thread-local free-lists are completely marked. */
1554 /* also check that thread-specific-data structures are marked. */
1555 void GC_check_tls(void) {
1559 for (i = 0; i < THREAD_TABLE_SZ; ++i) {
1560 for (p = GC_threads[i]; 0 != p; p = p -> next) {
1561 GC_check_tls_for(&(p->tlfs));
1564 # if defined(USE_CUSTOM_SPECIFIC)
1565 if (GC_thread_key != 0)
1566 GC_check_tsd_marks(GC_thread_key);
1569 #endif /* GC_ASSERTIONS */
1571 #endif /* THREAD_LOCAL_ALLOC ... */
1573 #endif /* GC_WIN32_THREADS */