1 /* Threads compatibility routines for libgcc2 and libobjc. */
2 /* Compile this one with gcc. */
4 /* Copyright (C) 1999, 2000, 2002, 2003, 2004, 2005, 2008, 2009
5 Free Software Foundation, Inc.
6 Contributed by Mumit Khan <khan@xraylith.wisc.edu>.
8 This file is part of GCC.
10 GCC is free software; you can redistribute it and/or modify it under
11 the terms of the GNU General Public License as published by the Free
12 Software Foundation; either version 3, or (at your option) any later
15 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
16 WARRANTY; without even the implied warranty of MERCHANTABILITY or
17 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
20 Under Section 7 of GPL version 3, you are granted additional
21 permissions described in the GCC Runtime Library Exception, version
22 3.1, as published by the Free Software Foundation.
24 You should have received a copy of the GNU General Public License and
25 a copy of the GCC Runtime Library Exception along with this program;
26 see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
27 <http://www.gnu.org/licenses/>. */
29 #ifndef GCC_GTHR_WIN32_H
30 #define GCC_GTHR_WIN32_H
32 /* Make sure CONST_CAST2 (origin in system.h) is declared. */
34 #define CONST_CAST2(TOTYPE,FROMTYPE,X) ((__extension__(union {FROMTYPE _q; TOTYPE _nq;})(X))._nq)
37 /* Windows32 threads specific definitions. The windows32 threading model
38 does not map well into pthread-inspired gcc's threading model, and so
39 there are caveats one needs to be aware of.
41 1. The destructor supplied to __gthread_key_create is ignored for
42 generic x86-win32 ports. This will certainly cause memory leaks
43 due to unreclaimed eh contexts (sizeof (eh_context) is at least
44 24 bytes for x86 currently).
46 This memory leak may be significant for long-running applications
47 that make heavy use of C++ EH.
49 However, Mingw runtime (version 0.3 or newer) provides a mechanism
50 to emulate pthreads key dtors; the runtime provides a special DLL,
51 linked in if -mthreads option is specified, that runs the dtors in
52 the reverse order of registration when each thread exits. If
53 -mthreads option is not given, a stub is linked in instead of the
54 DLL, which results in memory leak. Other x86-win32 ports can use
55 the same technique of course to avoid the leak.
57 2. The error codes returned are non-POSIX like, and cast into ints.
58 This may cause incorrect error return due to truncation values on
59 hw where sizeof (DWORD) > sizeof (int).
61 3. We are currently using a special mutex instead of the Critical
62 Sections, since Win9x does not support TryEnterCriticalSection
65 The basic framework should work well enough. In the long term, GCC
66 needs to use Structured Exception Handling on Windows32. */
77 /* This is necessary to prevent windef.h (included from windows.h) from
78 defining its own BOOL as a typedef. */
83 /* Now undef the windows BOOL. */
86 /* Key structure for maintaining thread specific storage */
87 static DWORD __gthread_objc_data_tls
= (DWORD
) -1;
89 /* Backend initialization functions */
91 /* Initialize the threads subsystem. */
93 __gthread_objc_init_thread_system (void)
95 /* Initialize the thread storage key. */
96 if ((__gthread_objc_data_tls
= TlsAlloc ()) != (DWORD
) -1)
102 /* Close the threads subsystem. */
104 __gthread_objc_close_thread_system (void)
106 if (__gthread_objc_data_tls
!= (DWORD
) -1)
107 TlsFree (__gthread_objc_data_tls
);
111 /* Backend thread functions */
113 /* Create a new thread of execution. */
115 __gthread_objc_thread_detach (void (*func
)(void *arg
), void *arg
)
120 if (!(win32_handle
= CreateThread (NULL
, 0, (LPTHREAD_START_ROUTINE
) func
,
121 arg
, 0, &thread_id
)))
124 return (objc_thread_t
) thread_id
;
127 /* Set the current thread's priority. */
129 __gthread_objc_thread_set_priority (int priority
)
131 int sys_priority
= 0;
135 case OBJC_THREAD_INTERACTIVE_PRIORITY
:
136 sys_priority
= THREAD_PRIORITY_NORMAL
;
139 case OBJC_THREAD_BACKGROUND_PRIORITY
:
140 sys_priority
= THREAD_PRIORITY_BELOW_NORMAL
;
142 case OBJC_THREAD_LOW_PRIORITY
:
143 sys_priority
= THREAD_PRIORITY_LOWEST
;
147 /* Change priority */
148 if (SetThreadPriority (GetCurrentThread (), sys_priority
))
154 /* Return the current thread's priority. */
156 __gthread_objc_thread_get_priority (void)
160 sys_priority
= GetThreadPriority (GetCurrentThread ());
162 switch (sys_priority
)
164 case THREAD_PRIORITY_HIGHEST
:
165 case THREAD_PRIORITY_TIME_CRITICAL
:
166 case THREAD_PRIORITY_ABOVE_NORMAL
:
167 case THREAD_PRIORITY_NORMAL
:
168 return OBJC_THREAD_INTERACTIVE_PRIORITY
;
171 case THREAD_PRIORITY_BELOW_NORMAL
:
172 return OBJC_THREAD_BACKGROUND_PRIORITY
;
174 case THREAD_PRIORITY_IDLE
:
175 case THREAD_PRIORITY_LOWEST
:
176 return OBJC_THREAD_LOW_PRIORITY
;
179 /* Couldn't get priority. */
183 /* Yield our process time to another thread. */
185 __gthread_objc_thread_yield (void)
190 /* Terminate the current thread. */
192 __gthread_objc_thread_exit (void)
194 /* exit the thread */
195 ExitThread (__objc_thread_exit_status
);
197 /* Failed if we reached here */
201 /* Returns an integer value which uniquely describes a thread. */
203 __gthread_objc_thread_id (void)
205 return (objc_thread_t
) GetCurrentThreadId ();
208 /* Sets the thread's local storage pointer. */
210 __gthread_objc_thread_set_data (void *value
)
212 if (TlsSetValue (__gthread_objc_data_tls
, value
))
218 /* Returns the thread's local storage pointer. */
220 __gthread_objc_thread_get_data (void)
225 lasterror
= GetLastError ();
227 ptr
= TlsGetValue (__gthread_objc_data_tls
); /* Return thread data. */
229 SetLastError (lasterror
);
234 /* Backend mutex functions */
236 /* Allocate a mutex. */
238 __gthread_objc_mutex_allocate (objc_mutex_t mutex
)
240 if ((mutex
->backend
= (void *) CreateMutex (NULL
, 0, NULL
)) == NULL
)
246 /* Deallocate a mutex. */
248 __gthread_objc_mutex_deallocate (objc_mutex_t mutex
)
250 CloseHandle ((HANDLE
) (mutex
->backend
));
254 /* Grab a lock on a mutex. */
256 __gthread_objc_mutex_lock (objc_mutex_t mutex
)
260 status
= WaitForSingleObject ((HANDLE
) (mutex
->backend
), INFINITE
);
261 if (status
!= WAIT_OBJECT_0
&& status
!= WAIT_ABANDONED
)
267 /* Try to grab a lock on a mutex. */
269 __gthread_objc_mutex_trylock (objc_mutex_t mutex
)
273 status
= WaitForSingleObject ((HANDLE
) (mutex
->backend
), 0);
274 if (status
!= WAIT_OBJECT_0
&& status
!= WAIT_ABANDONED
)
280 /* Unlock the mutex */
282 __gthread_objc_mutex_unlock (objc_mutex_t mutex
)
284 if (ReleaseMutex ((HANDLE
) (mutex
->backend
)) == 0)
290 /* Backend condition mutex functions */
292 /* Allocate a condition. */
294 __gthread_objc_condition_allocate (objc_condition_t condition
)
300 /* Deallocate a condition. */
302 __gthread_objc_condition_deallocate (objc_condition_t condition
)
308 /* Wait on the condition */
310 __gthread_objc_condition_wait (objc_condition_t condition
, objc_mutex_t mutex
)
316 /* Wake up all threads waiting on this condition. */
318 __gthread_objc_condition_broadcast (objc_condition_t condition
)
324 /* Wake up one thread waiting on this condition. */
326 __gthread_objc_condition_signal (objc_condition_t condition
)
338 typedef unsigned long __gthread_key_t
;
355 } __gthread_recursive_mutex_t
;
357 #define __GTHREAD_ONCE_INIT {0, -1}
358 #define __GTHREAD_MUTEX_INIT_FUNCTION __gthread_mutex_init_function
359 #define __GTHREAD_MUTEX_INIT_DEFAULT {-1, 0}
360 #define __GTHREAD_RECURSIVE_MUTEX_INIT_FUNCTION \
361 __gthread_recursive_mutex_init_function
362 #define __GTHREAD_RECURSIVE_MUTEX_INIT_DEFAULT {-1, 0, 0, 0}
364 #if __MINGW32_MAJOR_VERSION >= 1 || \
365 (__MINGW32_MAJOR_VERSION == 0 && __MINGW32_MINOR_VERSION > 2)
366 #define MINGW32_SUPPORTS_MT_EH 1
367 /* Mingw runtime >= v0.3 provides a magic variable that is set to nonzero
368 if -mthreads option was specified, or 0 otherwise. This is to get around
369 the lack of weak symbols in PE-COFF. */
371 extern int __mingwthr_key_dtor (unsigned long, void (*) (void *));
372 #endif /* __MINGW32__ version */
374 /* The Windows95 kernel does not export InterlockedCompareExchange.
375 This provides a substitute. When building apps that reference
376 gthread_mutex_try_lock, the __GTHREAD_I486_INLINE_LOCK_PRIMITIVES
377 macro must be defined if Windows95 is a target. Currently
378 gthread_mutex_try_lock is not referenced by libgcc or libstdc++. */
379 #ifdef __GTHREAD_I486_INLINE_LOCK_PRIMITIVES
381 __gthr_i486_lock_cmp_xchg(long *__dest
, long __xchg
, long __comperand
)
384 __asm__
__volatile__ ("\n\
386 cmpxchg{l} {%4, %1|%1, %4}\n"
387 : "=a" (result
), "=m" (*__dest
)
388 : "0" (__comperand
), "m" (*__dest
), "r" (__xchg
)
392 #define __GTHR_W32_InterlockedCompareExchange __gthr_i486_lock_cmp_xchg
393 #else /* __GTHREAD_I486_INLINE_LOCK_PRIMITIVES */
394 #define __GTHR_W32_InterlockedCompareExchange InterlockedCompareExchange
395 #endif /* __GTHREAD_I486_INLINE_LOCK_PRIMITIVES */
398 __gthread_active_p (void)
400 #ifdef MINGW32_SUPPORTS_MT_EH
407 #if __GTHREAD_HIDE_WIN32API
409 /* The implementations are in config/i386/gthr-win32.c in libgcc.a.
410 Only stubs are exposed to avoid polluting the C++ namespace with
411 windows api definitions. */
413 extern int __gthr_win32_once (__gthread_once_t
*, void (*) (void));
414 extern int __gthr_win32_key_create (__gthread_key_t
*, void (*) (void*));
415 extern int __gthr_win32_key_delete (__gthread_key_t
);
416 extern void * __gthr_win32_getspecific (__gthread_key_t
);
417 extern int __gthr_win32_setspecific (__gthread_key_t
, const void *);
418 extern void __gthr_win32_mutex_init_function (__gthread_mutex_t
*);
419 extern int __gthr_win32_mutex_lock (__gthread_mutex_t
*);
420 extern int __gthr_win32_mutex_trylock (__gthread_mutex_t
*);
421 extern int __gthr_win32_mutex_unlock (__gthread_mutex_t
*);
423 __gthr_win32_recursive_mutex_init_function (__gthread_recursive_mutex_t
*);
424 extern int __gthr_win32_recursive_mutex_lock (__gthread_recursive_mutex_t
*);
426 __gthr_win32_recursive_mutex_trylock (__gthread_recursive_mutex_t
*);
427 extern int __gthr_win32_recursive_mutex_unlock (__gthread_recursive_mutex_t
*);
428 extern void __gthr_win32_mutex_destroy (__gthread_mutex_t
*);
431 __gthread_once (__gthread_once_t
*__once
, void (*__func
) (void))
433 if (__gthread_active_p ())
434 return __gthr_win32_once (__once
, __func
);
440 __gthread_key_create (__gthread_key_t
*__key
, void (*__dtor
) (void *))
442 return __gthr_win32_key_create (__key
, __dtor
);
446 __gthread_key_delete (__gthread_key_t __key
)
448 return __gthr_win32_key_delete (__key
);
452 __gthread_getspecific (__gthread_key_t __key
)
454 return __gthr_win32_getspecific (__key
);
458 __gthread_setspecific (__gthread_key_t __key
, const void *__ptr
)
460 return __gthr_win32_setspecific (__key
, __ptr
);
464 __gthread_mutex_init_function (__gthread_mutex_t
*__mutex
)
466 __gthr_win32_mutex_init_function (__mutex
);
470 __gthread_mutex_destroy (__gthread_mutex_t
*__mutex
)
472 __gthr_win32_mutex_destroy (__mutex
);
476 __gthread_mutex_lock (__gthread_mutex_t
*__mutex
)
478 if (__gthread_active_p ())
479 return __gthr_win32_mutex_lock (__mutex
);
485 __gthread_mutex_trylock (__gthread_mutex_t
*__mutex
)
487 if (__gthread_active_p ())
488 return __gthr_win32_mutex_trylock (__mutex
);
494 __gthread_mutex_unlock (__gthread_mutex_t
*__mutex
)
496 if (__gthread_active_p ())
497 return __gthr_win32_mutex_unlock (__mutex
);
503 __gthread_recursive_mutex_init_function (__gthread_recursive_mutex_t
*__mutex
)
505 __gthr_win32_recursive_mutex_init_function (__mutex
);
509 __gthread_recursive_mutex_lock (__gthread_recursive_mutex_t
*__mutex
)
511 if (__gthread_active_p ())
512 return __gthr_win32_recursive_mutex_lock (__mutex
);
518 __gthread_recursive_mutex_trylock (__gthread_recursive_mutex_t
*__mutex
)
520 if (__gthread_active_p ())
521 return __gthr_win32_recursive_mutex_trylock (__mutex
);
527 __gthread_recursive_mutex_unlock (__gthread_recursive_mutex_t
*__mutex
)
529 if (__gthread_active_p ())
530 return __gthr_win32_recursive_mutex_unlock (__mutex
);
535 #else /* ! __GTHREAD_HIDE_WIN32API */
541 __gthread_once (__gthread_once_t
*__once
, void (*__func
) (void))
543 if (! __gthread_active_p ())
545 else if (__once
== NULL
|| __func
== NULL
)
550 if (InterlockedIncrement (&(__once
->started
)) == 0)
557 /* Another thread is currently executing the code, so wait for it
558 to finish; yield the CPU in the meantime. If performance
559 does become an issue, the solution is to use an Event that
560 we wait on here (and set above), but that implies a place to
561 create the event before this routine is called. */
562 while (! __once
->done
)
570 /* Windows32 thread local keys don't support destructors; this leads to
571 leaks, especially in threaded applications making extensive use of
572 C++ EH. Mingw uses a thread-support DLL to work-around this problem. */
574 __gthread_key_create (__gthread_key_t
*__key
,
575 void (*__dtor
) (void *) __attribute__((unused
)))
578 DWORD __tls_index
= TlsAlloc ();
579 if (__tls_index
!= 0xFFFFFFFF)
581 *__key
= __tls_index
;
582 #ifdef MINGW32_SUPPORTS_MT_EH
583 /* Mingw runtime will run the dtors in reverse order for each thread
584 when the thread exits. */
585 __status
= __mingwthr_key_dtor (*__key
, __dtor
);
589 __status
= (int) GetLastError ();
594 __gthread_key_delete (__gthread_key_t __key
)
596 return (TlsFree (__key
) != 0) ? 0 : (int) GetLastError ();
600 __gthread_getspecific (__gthread_key_t __key
)
605 __lasterror
= GetLastError ();
607 __ptr
= TlsGetValue (__key
);
609 SetLastError (__lasterror
);
615 __gthread_setspecific (__gthread_key_t __key
, const void *__ptr
)
617 if (TlsSetValue (__key
, CONST_CAST2(void *, const void *, __ptr
)) != 0)
620 return GetLastError ();
624 __gthread_mutex_init_function (__gthread_mutex_t
*__mutex
)
626 __mutex
->counter
= -1;
627 __mutex
->sema
= CreateSemaphore (NULL
, 0, 65535, NULL
);
631 __gthread_mutex_destroy (__gthread_mutex_t
*__mutex
)
633 CloseHandle ((HANDLE
) __mutex
->sema
);
637 __gthread_mutex_lock (__gthread_mutex_t
*__mutex
)
641 if (__gthread_active_p ())
643 if (InterlockedIncrement (&__mutex
->counter
) == 0 ||
644 WaitForSingleObject (__mutex
->sema
, INFINITE
) == WAIT_OBJECT_0
)
648 /* WaitForSingleObject returns WAIT_FAILED, and we can only do
649 some best-effort cleanup here. */
650 InterlockedDecrement (&__mutex
->counter
);
658 __gthread_mutex_trylock (__gthread_mutex_t
*__mutex
)
662 if (__gthread_active_p ())
664 if (__GTHR_W32_InterlockedCompareExchange (&__mutex
->counter
, 0, -1) < 0)
673 __gthread_mutex_unlock (__gthread_mutex_t
*__mutex
)
675 if (__gthread_active_p ())
677 if (InterlockedDecrement (&__mutex
->counter
) >= 0)
678 return ReleaseSemaphore (__mutex
->sema
, 1, NULL
) ? 0 : 1;
684 __gthread_recursive_mutex_init_function (__gthread_recursive_mutex_t
*__mutex
)
686 __mutex
->counter
= -1;
689 __mutex
->sema
= CreateSemaphore (NULL
, 0, 65535, NULL
);
693 __gthread_recursive_mutex_lock (__gthread_recursive_mutex_t
*__mutex
)
695 if (__gthread_active_p ())
697 DWORD __me
= GetCurrentThreadId();
698 if (InterlockedIncrement (&__mutex
->counter
) == 0)
701 __mutex
->owner
= __me
;
703 else if (__mutex
->owner
== __me
)
705 InterlockedDecrement (&__mutex
->counter
);
708 else if (WaitForSingleObject (__mutex
->sema
, INFINITE
) == WAIT_OBJECT_0
)
711 __mutex
->owner
= __me
;
715 /* WaitForSingleObject returns WAIT_FAILED, and we can only do
716 some best-effort cleanup here. */
717 InterlockedDecrement (&__mutex
->counter
);
725 __gthread_recursive_mutex_trylock (__gthread_recursive_mutex_t
*__mutex
)
727 if (__gthread_active_p ())
729 DWORD __me
= GetCurrentThreadId();
730 if (__GTHR_W32_InterlockedCompareExchange (&__mutex
->counter
, 0, -1) < 0)
733 __mutex
->owner
= __me
;
735 else if (__mutex
->owner
== __me
)
744 __gthread_recursive_mutex_unlock (__gthread_recursive_mutex_t
*__mutex
)
746 if (__gthread_active_p ())
749 if (__mutex
->depth
== 0)
753 if (InterlockedDecrement (&__mutex
->counter
) >= 0)
754 return ReleaseSemaphore (__mutex
->sema
, 1, NULL
) ? 0 : 1;
760 #endif /* __GTHREAD_HIDE_WIN32API */
766 #endif /* _LIBOBJC */
768 #endif /* ! GCC_GTHR_WIN32_H */