Work around MinGW mangling of "host:/path"
[msysgit/historical-msysgit.git] / mingw / include / c++ / 3.4.2 / mingw32 / bits / gthr-default.h
blobbd86b4724d28e8433d0b0e3e8a7b41813a1edf7d
1 /* Threads compatibility routines for libgcc2 and libobjc. */
2 /* Compile this one with gcc. */
3 /* Copyright (C) 1999, 2000, 2002, 2003, 2004 Free Software Foundation, Inc.
4 Contributed by Mumit Khan <khan@xraylith.wisc.edu>.
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 2, or (at your option) any later
11 version.
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16 for more details.
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING. If not, write to the Free
20 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
21 02111-1307, USA. */
23 /* As a special exception, if you link this library with other files,
24 some of which are compiled with GCC, to produce an executable,
25 this library does not by itself cause the resulting executable
26 to be covered by the GNU General Public License.
27 This exception does not however invalidate any other reasons why
28 the executable file might be covered by the GNU General Public License. */
30 #ifndef GCC_GTHR_WIN32_H
31 #define GCC_GTHR_WIN32_H
33 /* Windows32 threads specific definitions. The windows32 threading model
34 does not map well into pthread-inspired gcc's threading model, and so
35 there are caveats one needs to be aware of.
37 1. The destructor supplied to __gthread_key_create is ignored for
38 generic x86-win32 ports. This will certainly cause memory leaks
39 due to unreclaimed eh contexts (sizeof (eh_context) is at least
40 24 bytes for x86 currently).
42 This memory leak may be significant for long-running applications
43 that make heavy use of C++ EH.
45 However, Mingw runtime (version 0.3 or newer) provides a mechanism
46 to emulate pthreads key dtors; the runtime provides a special DLL,
47 linked in if -mthreads option is specified, that runs the dtors in
48 the reverse order of registration when each thread exits. If
49 -mthreads option is not given, a stub is linked in instead of the
50 DLL, which results in memory leak. Other x86-win32 ports can use
51 the same technique of course to avoid the leak.
53 2. The error codes returned are non-POSIX like, and cast into ints.
54 This may cause incorrect error return due to truncation values on
55 hw where sizeof (DWORD) > sizeof (int).
57 3. We are currently using a special mutex instead of the Critical
58 Sections, since Win9x does not support TryEnterCriticalSection
59 (while NT does).
61 The basic framework should work well enough. In the long term, GCC
62 needs to use Structured Exception Handling on Windows32. */
64 #define __GTHREADS 1
66 #include <errno.h>
67 #ifdef __MINGW32__
68 #include <_mingw.h>
69 #endif
71 #ifdef _LIBOBJC
73 /* This is necessary to prevent windef.h (included from windows.h) from
74 defining it's own BOOL as a typedef. */
75 #ifndef __OBJC__
76 #define __OBJC__
77 #endif
78 #include <windows.h>
79 /* Now undef the windows BOOL. */
80 #undef BOOL
82 /* Key structure for maintaining thread specific storage */
83 static DWORD __gthread_objc_data_tls = (DWORD) -1;
85 /* Backend initialization functions */
87 /* Initialize the threads subsystem. */
88 int
89 __gthread_objc_init_thread_system (void)
91 /* Initialize the thread storage key */
92 if ((__gthread_objc_data_tls = TlsAlloc ()) != (DWORD) -1)
93 return 0;
94 else
95 return -1;
98 /* Close the threads subsystem. */
99 int
100 __gthread_objc_close_thread_system (void)
102 if (__gthread_objc_data_tls != (DWORD) -1)
103 TlsFree (__gthread_objc_data_tls);
104 return 0;
107 /* Backend thread functions */
109 /* Create a new thread of execution. */
110 objc_thread_t
111 __gthread_objc_thread_detach (void (*func)(void *arg), void *arg)
113 DWORD thread_id = 0;
114 HANDLE win32_handle;
116 if (!(win32_handle = CreateThread (NULL, 0, (LPTHREAD_START_ROUTINE) func,
117 arg, 0, &thread_id)))
118 thread_id = 0;
120 return (objc_thread_t) thread_id;
123 /* Set the current thread's priority. */
125 __gthread_objc_thread_set_priority (int priority)
127 int sys_priority = 0;
129 switch (priority)
131 case OBJC_THREAD_INTERACTIVE_PRIORITY:
132 sys_priority = THREAD_PRIORITY_NORMAL;
133 break;
134 default:
135 case OBJC_THREAD_BACKGROUND_PRIORITY:
136 sys_priority = THREAD_PRIORITY_BELOW_NORMAL;
137 break;
138 case OBJC_THREAD_LOW_PRIORITY:
139 sys_priority = THREAD_PRIORITY_LOWEST;
140 break;
143 /* Change priority */
144 if (SetThreadPriority (GetCurrentThread (), sys_priority))
145 return 0;
146 else
147 return -1;
150 /* Return the current thread's priority. */
152 __gthread_objc_thread_get_priority (void)
154 int sys_priority;
156 sys_priority = GetThreadPriority (GetCurrentThread ());
158 switch (sys_priority)
160 case THREAD_PRIORITY_HIGHEST:
161 case THREAD_PRIORITY_TIME_CRITICAL:
162 case THREAD_PRIORITY_ABOVE_NORMAL:
163 case THREAD_PRIORITY_NORMAL:
164 return OBJC_THREAD_INTERACTIVE_PRIORITY;
166 default:
167 case THREAD_PRIORITY_BELOW_NORMAL:
168 return OBJC_THREAD_BACKGROUND_PRIORITY;
170 case THREAD_PRIORITY_IDLE:
171 case THREAD_PRIORITY_LOWEST:
172 return OBJC_THREAD_LOW_PRIORITY;
175 /* Couldn't get priority. */
176 return -1;
179 /* Yield our process time to another thread. */
180 void
181 __gthread_objc_thread_yield (void)
183 Sleep (0);
186 /* Terminate the current thread. */
188 __gthread_objc_thread_exit (void)
190 /* exit the thread */
191 ExitThread (__objc_thread_exit_status);
193 /* Failed if we reached here */
194 return -1;
197 /* Returns an integer value which uniquely describes a thread. */
198 objc_thread_t
199 __gthread_objc_thread_id (void)
201 return (objc_thread_t) GetCurrentThreadId ();
204 /* Sets the thread's local storage pointer. */
206 __gthread_objc_thread_set_data (void *value)
208 if (TlsSetValue (__gthread_objc_data_tls, value))
209 return 0;
210 else
211 return -1;
214 /* Returns the thread's local storage pointer. */
215 void *
216 __gthread_objc_thread_get_data (void)
218 DWORD lasterror;
219 void *ptr;
221 lasterror = GetLastError ();
223 ptr = TlsGetValue (__gthread_objc_data_tls); /* Return thread data. */
225 SetLastError (lasterror);
227 return ptr;
230 /* Backend mutex functions */
232 /* Allocate a mutex. */
234 __gthread_objc_mutex_allocate (objc_mutex_t mutex)
236 if ((mutex->backend = (void *) CreateMutex (NULL, 0, NULL)) == NULL)
237 return -1;
238 else
239 return 0;
242 /* Deallocate a mutex. */
244 __gthread_objc_mutex_deallocate (objc_mutex_t mutex)
246 CloseHandle ((HANDLE) (mutex->backend));
247 return 0;
250 /* Grab a lock on a mutex. */
252 __gthread_objc_mutex_lock (objc_mutex_t mutex)
254 int status;
256 status = WaitForSingleObject ((HANDLE) (mutex->backend), INFINITE);
257 if (status != WAIT_OBJECT_0 && status != WAIT_ABANDONED)
258 return -1;
259 else
260 return 0;
263 /* Try to grab a lock on a mutex. */
265 __gthread_objc_mutex_trylock (objc_mutex_t mutex)
267 int status;
269 status = WaitForSingleObject ((HANDLE) (mutex->backend), 0);
270 if (status != WAIT_OBJECT_0 && status != WAIT_ABANDONED)
271 return -1;
272 else
273 return 0;
276 /* Unlock the mutex */
278 __gthread_objc_mutex_unlock (objc_mutex_t mutex)
280 if (ReleaseMutex ((HANDLE) (mutex->backend)) == 0)
281 return -1;
282 else
283 return 0;
286 /* Backend condition mutex functions */
288 /* Allocate a condition. */
290 __gthread_objc_condition_allocate (objc_condition_t condition)
292 /* Unimplemented. */
293 return -1;
296 /* Deallocate a condition. */
298 __gthread_objc_condition_deallocate (objc_condition_t condition)
300 /* Unimplemented. */
301 return -1;
304 /* Wait on the condition */
306 __gthread_objc_condition_wait (objc_condition_t condition, objc_mutex_t mutex)
308 /* Unimplemented. */
309 return -1;
312 /* Wake up all threads waiting on this condition. */
314 __gthread_objc_condition_broadcast (objc_condition_t condition)
316 /* Unimplemented. */
317 return -1;
320 /* Wake up one thread waiting on this condition. */
322 __gthread_objc_condition_signal (objc_condition_t condition)
324 /* Unimplemented. */
325 return -1;
328 #else /* _LIBOBJC */
330 #ifdef __cplusplus
331 extern "C" {
332 #endif
334 typedef unsigned long __gthread_key_t;
336 typedef struct {
337 int done;
338 long started;
339 } __gthread_once_t;
341 typedef struct {
342 long counter;
343 void *sema;
344 } __gthread_mutex_t;
346 #define __GTHREAD_ONCE_INIT {0, -1}
347 #define __GTHREAD_MUTEX_INIT_FUNCTION __gthread_mutex_init_function
348 #define __GTHREAD_MUTEX_INIT_DEFAULT {-1, 0}
350 #if __MINGW32_MAJOR_VERSION >= 1 || \
351 (__MINGW32_MAJOR_VERSION == 0 && __MINGW32_MINOR_VERSION > 2)
352 #define MINGW32_SUPPORTS_MT_EH 1
353 /* Mingw runtime >= v0.3 provides a magic variable that is set to nonzero
354 if -mthreads option was specified, or 0 otherwise. This is to get around
355 the lack of weak symbols in PE-COFF. */
356 extern int _CRT_MT;
357 extern int __mingwthr_key_dtor (unsigned long, void (*) (void *));
358 #endif /* __MINGW32__ version */
360 #ifdef __GTHREAD_I486_INLINE_LOCK_PRIMITIVES
362 static inline long
363 __gthr_i486_lock_cmp_xchg(long *dest, long xchg, long comperand)
365 long result;
366 __asm__ __volatile__ ("\n\
367 lock\n\
368 cmpxchg{l} {%4, %1|%1, %4}\n"
369 : "=a" (result), "=m" (*dest)
370 : "0" (comperand), "m" (*dest), "r" (xchg)
371 : "cc");
372 return result;
375 #define __GTHR_W32_InterlockedCompareExchange __gthr_i486_lock_cmp_xchg
377 #else /* __GTHREAD_I486_INLINE_LOCK_PRIMITIVES */
379 #define __GTHR_W32_InterlockedCompareExchange InterlockedCompareExchange
381 #endif /* __GTHREAD_I486_INLINE_LOCK_PRIMITIVES */
383 static inline int
384 __gthread_active_p (void)
386 #ifdef MINGW32_SUPPORTS_MT_EH
387 return _CRT_MT;
388 #else
389 return 1;
390 #endif
393 #if __GTHREAD_HIDE_WIN32API
395 /* The implementations are in config/i386/gthr-win32.c in libgcc.a.
396 Only stubs are exposed to avoid polluting the C++ namespace with
397 windows api definitions. */
399 extern int __gthr_win32_once (__gthread_once_t *, void (*) (void));
400 extern int __gthr_win32_key_create (__gthread_key_t *, void (*) (void*));
401 extern int __gthr_win32_key_delete (__gthread_key_t);
402 extern void * __gthr_win32_getspecific (__gthread_key_t);
403 extern int __gthr_win32_setspecific (__gthread_key_t, const void *);
404 extern void __gthr_win32_mutex_init_function (__gthread_mutex_t *);
405 extern int __gthr_win32_mutex_lock (__gthread_mutex_t *);
406 extern int __gthr_win32_mutex_trylock (__gthread_mutex_t *);
407 extern int __gthr_win32_mutex_unlock (__gthread_mutex_t *);
409 static inline int
410 __gthread_once (__gthread_once_t *once, void (*func) (void))
412 if (__gthread_active_p ())
413 return __gthr_win32_once (once, func);
414 else
415 return -1;
418 static inline int
419 __gthread_key_create (__gthread_key_t *key, void (*dtor) (void *))
421 return __gthr_win32_key_create (key, dtor);
424 static inline int
425 __gthread_key_delete (__gthread_key_t key)
427 return __gthr_win32_key_delete (key);
430 static inline void *
431 __gthread_getspecific (__gthread_key_t key)
433 return __gthr_win32_getspecific (key);
436 static inline int
437 __gthread_setspecific (__gthread_key_t key, const void *ptr)
439 return __gthr_win32_setspecific (key, ptr);
442 static inline void
443 __gthread_mutex_init_function (__gthread_mutex_t *mutex)
445 __gthr_win32_mutex_init_function (mutex);
448 static inline int
449 __gthread_mutex_lock (__gthread_mutex_t *mutex)
451 if (__gthread_active_p ())
452 return __gthr_win32_mutex_lock (mutex);
453 else
454 return 0;
457 static inline int
458 __gthread_mutex_trylock (__gthread_mutex_t *mutex)
460 if (__gthread_active_p ())
461 return __gthr_win32_mutex_trylock (mutex);
462 else
463 return 0;
466 static inline int
467 __gthread_mutex_unlock (__gthread_mutex_t *mutex)
469 if (__gthread_active_p ())
470 return __gthr_win32_mutex_unlock (mutex);
471 else
472 return 0;
475 #else /* ! __GTHREAD_HIDE_WIN32API */
477 #include <windows.h>
478 #include <errno.h>
480 static inline int
481 __gthread_once (__gthread_once_t *once, void (*func) (void))
483 if (! __gthread_active_p ())
484 return -1;
485 else if (once == NULL || func == NULL)
486 return EINVAL;
488 if (! once->done)
490 if (InterlockedIncrement (&(once->started)) == 0)
492 (*func) ();
493 once->done = TRUE;
495 else
497 /* Another thread is currently executing the code, so wait for it
498 to finish; yield the CPU in the meantime. If performance
499 does become an issue, the solution is to use an Event that
500 we wait on here (and set above), but that implies a place to
501 create the event before this routine is called. */
502 while (! once->done)
503 Sleep (0);
507 return 0;
510 /* Windows32 thread local keys don't support destructors; this leads to
511 leaks, especially in threaded applications making extensive use of
512 C++ EH. Mingw uses a thread-support DLL to work-around this problem. */
513 static inline int
514 __gthread_key_create (__gthread_key_t *key, void (*dtor) (void *))
516 int status = 0;
517 DWORD tls_index = TlsAlloc ();
518 if (tls_index != 0xFFFFFFFF)
520 *key = tls_index;
521 #ifdef MINGW32_SUPPORTS_MT_EH
522 /* Mingw runtime will run the dtors in reverse order for each thread
523 when the thread exits. */
524 status = __mingwthr_key_dtor (*key, dtor);
525 #endif
527 else
528 status = (int) GetLastError ();
529 return status;
532 static inline int
533 __gthread_key_delete (__gthread_key_t key)
535 return (TlsFree (key) != 0) ? 0 : (int) GetLastError ();
538 static inline void *
539 __gthread_getspecific (__gthread_key_t key)
541 DWORD lasterror;
542 void *ptr;
544 lasterror = GetLastError ();
546 ptr = TlsGetValue (key);
548 SetLastError (lasterror);
550 return ptr;
553 static inline int
554 __gthread_setspecific (__gthread_key_t key, const void *ptr)
556 return (TlsSetValue (key, (void*) ptr) != 0) ? 0 : (int) GetLastError ();
559 static inline void
560 __gthread_mutex_init_function (__gthread_mutex_t *mutex)
562 mutex->counter = -1;
563 mutex->sema = CreateSemaphore (NULL, 0, 65535, NULL);
566 static inline int
567 __gthread_mutex_lock (__gthread_mutex_t *mutex)
569 int status = 0;
571 if (__gthread_active_p ())
573 if (InterlockedIncrement (&mutex->counter) == 0 ||
574 WaitForSingleObject (mutex->sema, INFINITE) == WAIT_OBJECT_0)
575 status = 0;
576 else
578 /* WaitForSingleObject returns WAIT_FAILED, and we can only do
579 some best-effort cleanup here. */
580 InterlockedDecrement (&mutex->counter);
581 status = 1;
584 return status;
587 static inline int
588 __gthread_mutex_trylock (__gthread_mutex_t *mutex)
590 int status = 0;
592 if (__gthread_active_p ())
594 if (__GTHR_W32_InterlockedCompareExchange (&mutex->counter, 0, -1) < 0)
595 status = 0;
596 else
597 status = 1;
599 return status;
602 static inline int
603 __gthread_mutex_unlock (__gthread_mutex_t *mutex)
605 if (__gthread_active_p ())
607 if (InterlockedDecrement (&mutex->counter) >= 0)
608 return ReleaseSemaphore (mutex->sema, 1, NULL) ? 0 : 1;
610 return 0;
613 #endif /* __GTHREAD_HIDE_WIN32API */
615 #ifdef __cplusplus
617 #endif
619 #endif /* _LIBOBJC */
621 #endif /* ! GCC_GTHR_WIN32_H */