gcc/gthr-win32.h

   1 /* Threads compatibility routines for libgcc2 and libobjc.  */
   2 /* Compile this one with gcc.  */
   3 /* Copyright (C) 1999, 2000 Free Software Foundation, Inc.
   4    Contributed by Mumit Khan <khan@xraylith.wisc.edu>.
   5
   6 This file is part of GNU CC.
   7
   8 GNU CC is free software; you can redistribute it and/or modify
   9 it under the terms of the GNU General Public License as published by
  10 the Free Software Foundation; either version 2, or (at your option)
  11 any later version.
  12
  13 GNU CC is distributed in the hope that it will be useful,
  14 but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 GNU General Public License for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with GNU CC; see the file COPYING.  If not, write to
  20 the Free Software Foundation, 59 Temple Place - Suite 330,
  21 Boston, MA 02111-1307, USA.  */
  22
  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.  */
  29
  30 #ifndef __gthr_win32_h
  31 #define __gthr_win32_h
  32
  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.
  36
  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).
  41
  42       This memory leak may be significant for long-running applications
  43       that make heavy use of C++ EH.
  44
  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.
  52
  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).
  56
  57    3. We might consider using Critical Sections instead of Windows32
  58       mutexes for better performance, but emulating __gthread_mutex_trylock
  59       interface becomes more complicated (Win9x does not support
  60       TryEnterCriticalSectioni, while NT does).
  61
  62    The basic framework should work well enough. In the long term, GCC
  63    needs to use Structured Exception Handling on Windows32.  */
  64
  65 #define __GTHREADS 1
  66
  67 #include <windows.h>
  68
  69 #ifdef _LIBOBJC
  70
  71 /* Key structure for maintaining thread specific storage */
  72 static DWORD    __gthread_objc_data_tls = (DWORD)-1;
  73
  74 /* Backend initialization functions */
  75
  76 /* Initialize the threads subsystem. */
  77 int
  78 __gthread_objc_init_thread_system(void)
  79 {
  80   /* Initialize the thread storage key */
  81   if ((__gthread_objc_data_tls = TlsAlloc()) != (DWORD)-1)
  82     return 0;
  83   else
  84     return -1;
  85 }
  86
  87 /* Close the threads subsystem. */
  88 int
  89 __gthread_objc_close_thread_system(void)
  90 {
  91   if (__gthread_objc_data_tls != (DWORD)-1)
  92     TlsFree(__gthread_objc_data_tls);
  93   return 0;
  94 }
  95
  96 /* Backend thread functions */
  97
  98 /* Create a new thread of execution. */
  99 objc_thread_t
 100 __gthread_objc_thread_detach(void (*func)(void *arg), void *arg)
 101 {
 102   DWORD thread_id = 0;
 103   HANDLE win32_handle;
 104
 105   if (!(win32_handle = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)func,
 106                                    arg, 0, &thread_id)))
 107     thread_id = 0;
 108
 109   return (objc_thread_t)thread_id;
 110 }
 111
 112 /* Set the current thread's priority. */
 113 int
 114 __gthread_objc_thread_set_priority(int priority)
 115 {
 116   int sys_priority = 0;
 117
 118   switch (priority)
 119     {
 120     case OBJC_THREAD_INTERACTIVE_PRIORITY:
 121       sys_priority = THREAD_PRIORITY_NORMAL;
 122       break;
 123     default:
 124     case OBJC_THREAD_BACKGROUND_PRIORITY:
 125       sys_priority = THREAD_PRIORITY_BELOW_NORMAL;
 126       break;
 127     case OBJC_THREAD_LOW_PRIORITY:
 128       sys_priority = THREAD_PRIORITY_LOWEST;
 129       break;
 130     }
 131
 132   /* Change priority */
 133   if (SetThreadPriority(GetCurrentThread(), sys_priority))
 134     return 0;
 135   else
 136     return -1;
 137 }
 138
 139 /* Return the current thread's priority. */
 140 int
 141 __gthread_objc_thread_get_priority(void)
 142 {
 143   int sys_priority;
 144
 145   sys_priority = GetThreadPriority(GetCurrentThread());
 146
 147   switch (sys_priority)
 148     {
 149     case THREAD_PRIORITY_HIGHEST:
 150     case THREAD_PRIORITY_TIME_CRITICAL:
 151     case THREAD_PRIORITY_ABOVE_NORMAL:
 152     case THREAD_PRIORITY_NORMAL:
 153       return OBJC_THREAD_INTERACTIVE_PRIORITY;
 154
 155     default:
 156     case THREAD_PRIORITY_BELOW_NORMAL:
 157       return OBJC_THREAD_BACKGROUND_PRIORITY;
 158
 159     case THREAD_PRIORITY_IDLE:
 160     case THREAD_PRIORITY_LOWEST:
 161       return OBJC_THREAD_LOW_PRIORITY;
 162     }
 163
 164   /* Couldn't get priority. */
 165   return -1;
 166 }
 167
 168 /* Yield our process time to another thread. */
 169 void
 170 __gthread_objc_thread_yield(void)
 171 {
 172   Sleep(0);
 173 }
 174
 175 /* Terminate the current thread. */
 176 int
 177 __gthread_objc_thread_exit(void)
 178 {
 179   /* exit the thread */
 180   ExitThread(__gthread_objc_thread_exit_status);
 181
 182   /* Failed if we reached here */
 183   return -1;
 184 }
 185
 186 /* Returns an integer value which uniquely describes a thread. */
 187 objc_thread_t
 188 __gthread_objc_thread_id(void)
 189 {
 190   return (objc_thread_t)GetCurrentThreadId();
 191 }
 192
 193 /* Sets the thread's local storage pointer. */
 194 int
 195 __gthread_objc_thread_set_data(void *value)
 196 {
 197   if (TlsSetValue(__gthread_objc_data_tls, value))
 198     return 0;
 199   else
 200     return -1;
 201 }
 202
 203 /* Returns the thread's local storage pointer. */
 204 void *
 205 __gthread_objc_thread_get_data(void)
 206 {
 207   DWORD lasterror;
 208   void *ptr;
 209
 210   lasterror = GetLastError();
 211
 212   ptr = TlsGetValue(__gthread_objc_data_tls);          /* Return thread data.      */
 213
 214   SetLastError( lasterror );
 215
 216   return ptr;
 217 }
 218
 219 /* Backend mutex functions */
 220
 221 /* Allocate a mutex. */
 222 int
 223 __gthread_objc_mutex_allocate(objc_mutex_t mutex)
 224 {
 225   if ((mutex->backend = (void *)CreateMutex(NULL, 0, NULL)) == NULL)
 226     return -1;
 227   else
 228     return 0;
 229 }
 230
 231 /* Deallocate a mutex. */
 232 int
 233 __gthread_objc_mutex_deallocate(objc_mutex_t mutex)
 234 {
 235   CloseHandle((HANDLE)(mutex->backend));
 236   return 0;
 237 }
 238
 239 /* Grab a lock on a mutex. */
 240 int
 241 __gthread_objc_mutex_lock(objc_mutex_t mutex)
 242 {
 243   int status;
 244
 245   status = WaitForSingleObject((HANDLE)(mutex->backend), INFINITE);
 246   if (status != WAIT_OBJECT_0 && status != WAIT_ABANDONED)
 247     return -1;
 248   else
 249     return 0;
 250 }
 251
 252 /* Try to grab a lock on a mutex. */
 253 int
 254 __gthread_objc_mutex_trylock(objc_mutex_t mutex)
 255 {
 256   int status;
 257
 258   status = WaitForSingleObject((HANDLE)(mutex->backend), 0);
 259   if (status != WAIT_OBJECT_0 && status != WAIT_ABANDONED)
 260     return -1;
 261   else
 262     return 0;
 263 }
 264
 265 /* Unlock the mutex */
 266 int
 267 __gthread_objc_mutex_unlock(objc_mutex_t mutex)
 268 {
 269   if (ReleaseMutex((HANDLE)(mutex->backend)) == 0)
 270     return -1;
 271   else
 272     return 0;
 273 }
 274
 275 /* Backend condition mutex functions */
 276
 277 /* Allocate a condition. */
 278 int
 279 __gthread_objc_condition_allocate(objc_condition_t condition)
 280 {
 281   /* Unimplemented. */
 282   return -1;
 283 }
 284
 285 /* Deallocate a condition. */
 286 int
 287 __gthread_objc_condition_deallocate(objc_condition_t condition)
 288 {
 289   /* Unimplemented. */
 290   return -1;
 291 }
 292
 293 /* Wait on the condition */
 294 int
 295 __gthread_objc_condition_wait(objc_condition_t condition, objc_mutex_t mutex)
 296 {
 297   /* Unimplemented. */
 298   return -1;
 299 }
 300
 301 /* Wake up all threads waiting on this condition. */
 302 int
 303 __gthread_objc_condition_broadcast(objc_condition_t condition)
 304 {
 305   /* Unimplemented. */
 306   return -1;
 307 }
 308
 309 /* Wake up one thread waiting on this condition. */
 310 int
 311 __gthread_objc_condition_signal(objc_condition_t condition)
 312 {
 313   /* Unimplemented. */
 314   return -1;
 315 }
 316
 317 #else /* _LIBOBJC */
 318
 319 #ifdef __MINGW32__
 320 #include <_mingw.h>
 321 #endif
 322
 323 typedef DWORD __gthread_key_t;
 324
 325 typedef struct {
 326   int done;
 327   long started;
 328 } __gthread_once_t;
 329
 330 typedef HANDLE __gthread_mutex_t;
 331
 332 #define __GTHREAD_ONCE_INIT {FALSE, -1}
 333 #define __GTHREAD_MUTEX_INIT_FUNCTION __gthread_mutex_init_function
 334
 335 #if __MINGW32_MAJOR_VERSION >= 1 || \
 336   (__MINGW32_MAJOR_VERSION == 0 && __MINGW32_MINOR_VERSION > 2)
 337 #define MINGW32_SUPPORTS_MT_EH 1
 338 extern int __mingwthr_key_dtor PARAMS ((DWORD, void (*) (void *)));
 339 /* Mingw runtime >= v0.3 provides a magic variable that is set to non-zero
 340    if -mthreads option was specified, or 0 otherwise. This is to get around
 341    the lack of weak symbols in PE-COFF.  */
 342 extern int _CRT_MT;
 343 #endif
 344
 345 static inline int
 346 __gthread_active_p (void)
 347 {
 348 #ifdef MINGW32_SUPPORTS_MT_EH
 349   return _CRT_MT;
 350 #else
 351   return 1;
 352 #endif
 353 }
 354
 355 static inline int
 356 __gthread_once (__gthread_once_t *once, void (*func) (void))
 357 {
 358   if (! __gthread_active_p ())
 359     return -1;
 360   else if (once == NULL || func == NULL)
 361     return EINVAL;
 362
 363   if (! once->done)
 364     {
 365       if (InterlockedIncrement (&(once->started)) == 0)
 366         {
 367           (*func) ();
 368           once->done = TRUE;
 369         }
 370       else
 371         {
 372           /* Another thread is currently executing the code, so wait for it
 373              to finish; yield the CPU in the meantime.  If performance
 374              does become an issue, the solution is to use an Event that
 375              we wait on here (and set above), but that implies a place to
 376              create the event before this routine is called.  */
 377           while (! once->done)
 378             Sleep (0);
 379         }
 380     }
 381
 382   return 0;
 383 }
 384
 385 /* Windows32 thread local keys don't support destructors; this leads to
 386    leaks, especially in threaded applications making extensive use of
 387    C++ EH. Mingw uses a thread-support DLL to work-around this problem.  */
 388 static inline int
 389 __gthread_key_create (__gthread_key_t *key, void (*dtor) (void *))
 390 {
 391   int status = 0;
 392   DWORD tls_index = TlsAlloc ();
 393   if (tls_index != 0xFFFFFFFF)
 394     {
 395       *key = tls_index;
 396 #ifdef MINGW32_SUPPORTS_MT_EH
 397       /* Mingw runtime will run the dtors in reverse order for each thread
 398          when the thread exits.  */
 399       status = __mingwthr_key_dtor (*key, dtor);
 400 #endif
 401     }
 402   else
 403     status = (int) GetLastError ();
 404   return status;
 405 }
 406
 407 /* Currently, this routine is called only for Mingw runtime, and if
 408    -mthreads option is chosen to link in the thread support DLL.  */
 409 static inline int
 410 __gthread_key_dtor (__gthread_key_t key, void *ptr)
 411 {
 412   /* Nothing needed. */
 413   return 0;
 414 }
 415
 416 static inline int
 417 __gthread_key_delete (__gthread_key_t key)
 418 {
 419   return (TlsFree (key) != 0) ? 0 : (int) GetLastError ();
 420 }
 421
 422 static inline void *
 423 __gthread_getspecific (__gthread_key_t key)
 424 {
 425   DWORD lasterror;
 426   void *ptr;
 427
 428   lasterror = GetLastError();
 429
 430   ptr = TlsGetValue(key);
 431
 432   SetLastError( lasterror );
 433
 434   return ptr;
 435 }
 436
 437 static inline int
 438 __gthread_setspecific (__gthread_key_t key, const void *ptr)
 439 {
 440   return (TlsSetValue (key, (void*) ptr) != 0) ? 0 : (int) GetLastError ();
 441 }
 442
 443 static inline void
 444 __gthread_mutex_init_function (__gthread_mutex_t *mutex)
 445 {
 446   /* Create unnamed mutex with default security attr and no initial owner.  */
 447   *mutex = CreateMutex (NULL, 0, NULL);
 448 }
 449
 450 static inline int
 451 __gthread_mutex_lock (__gthread_mutex_t *mutex)
 452 {
 453   int status = 0;
 454
 455   if (__gthread_active_p ())
 456     {
 457       if (WaitForSingleObject (*mutex, INFINITE) == WAIT_OBJECT_0)
 458         status = 0;
 459       else
 460         status = 1;
 461     }
 462   return status;
 463 }
 464
 465 static inline int
 466 __gthread_mutex_trylock (__gthread_mutex_t *mutex)
 467 {
 468   int status = 0;
 469
 470   if (__gthread_active_p ())
 471     {
 472       if (WaitForSingleObject (*mutex, 0) == WAIT_OBJECT_0)
 473         status = 0;
 474       else
 475         status = 1;
 476     }
 477   return status;
 478 }
 479
 480 static inline int
 481 __gthread_mutex_unlock (__gthread_mutex_t *mutex)
 482 {
 483   if (__gthread_active_p ())
 484     return (ReleaseMutex (*mutex) != 0) ? 0 : 1;
 485   else
 486     return 0;
 487 }
 488
 489 #endif /* _LIBOBJC */
 490
 491 #endif /* not __gthr_win32_h */
 492