home *** CD-ROM | disk | FTP | other *** search
/ Beginning C++ Through Gam…rogramming (2nd Edition) / BCGP2E.ISO / bloodshed / devcpp-4.9.9.2_setup.exe / gthr-default.h < prev    next >
C/C++ Source or Header  |  2005-01-29  |  15KB  |  622 lines
  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>.
  5.  
  6. This file is part of GCC.
  7.  
  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.
  12.  
  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.
  17.  
  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.  */
  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 GCC_GTHR_WIN32_H
  31. #define GCC_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 are currently using a special mutex instead of the Critical
  58.       Sections, since Win9x does not support TryEnterCriticalSection
  59.       (while NT does).
  60.  
  61.    The basic framework should work well enough. In the long term, GCC
  62.    needs to use Structured Exception Handling on Windows32.  */
  63.  
  64. #define __GTHREADS 1
  65.  
  66. #include <errno.h>
  67. #ifdef __MINGW32__
  68. #include <_mingw.h>
  69. #endif
  70.  
  71. #ifdef _LIBOBJC
  72.  
  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
  81.  
  82. /* Key structure for maintaining thread specific storage */
  83. static DWORD    __gthread_objc_data_tls = (DWORD) -1;
  84.  
  85. /* Backend initialization functions */
  86.  
  87. /* Initialize the threads subsystem.  */
  88. int
  89. __gthread_objc_init_thread_system (void)
  90. {
  91.   /* Initialize the thread storage key */
  92.   if ((__gthread_objc_data_tls = TlsAlloc ()) != (DWORD) -1)
  93.     return 0;
  94.   else
  95.     return -1;
  96. }
  97.  
  98. /* Close the threads subsystem.  */
  99. int
  100. __gthread_objc_close_thread_system (void)
  101. {
  102.   if (__gthread_objc_data_tls != (DWORD) -1)
  103.     TlsFree (__gthread_objc_data_tls);
  104.   return 0;
  105. }
  106.  
  107. /* Backend thread functions */
  108.  
  109. /* Create a new thread of execution.  */
  110. objc_thread_t
  111. __gthread_objc_thread_detach (void (*func)(void *arg), void *arg)
  112. {
  113.   DWORD    thread_id = 0;
  114.   HANDLE win32_handle;
  115.  
  116.   if (!(win32_handle = CreateThread (NULL, 0, (LPTHREAD_START_ROUTINE) func,
  117.                      arg, 0, &thread_id)))
  118.     thread_id = 0;
  119.  
  120.   return (objc_thread_t) thread_id;
  121. }
  122.  
  123. /* Set the current thread's priority.  */
  124. int
  125. __gthread_objc_thread_set_priority (int priority)
  126. {
  127.   int sys_priority = 0;
  128.  
  129.   switch (priority)
  130.     {
  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;
  141.     }
  142.  
  143.   /* Change priority */
  144.   if (SetThreadPriority (GetCurrentThread (), sys_priority))
  145.     return 0;
  146.   else
  147.     return -1;
  148. }
  149.  
  150. /* Return the current thread's priority.  */
  151. int
  152. __gthread_objc_thread_get_priority (void)
  153. {
  154.   int sys_priority;
  155.  
  156.   sys_priority = GetThreadPriority (GetCurrentThread ());
  157.  
  158.   switch (sys_priority)
  159.     {
  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;
  165.  
  166.     default:
  167.     case THREAD_PRIORITY_BELOW_NORMAL:
  168.       return OBJC_THREAD_BACKGROUND_PRIORITY;
  169.  
  170.     case THREAD_PRIORITY_IDLE:
  171.     case THREAD_PRIORITY_LOWEST:
  172.       return OBJC_THREAD_LOW_PRIORITY;
  173.     }
  174.  
  175.   /* Couldn't get priority.  */
  176.   return -1;
  177. }
  178.  
  179. /* Yield our process time to another thread.  */
  180. void
  181. __gthread_objc_thread_yield (void)
  182. {
  183.   Sleep (0);
  184. }
  185.  
  186. /* Terminate the current thread.  */
  187. int
  188. __gthread_objc_thread_exit (void)
  189. {
  190.   /* exit the thread */
  191.   ExitThread (__objc_thread_exit_status);
  192.  
  193.   /* Failed if we reached here */
  194.   return -1;
  195. }
  196.  
  197. /* Returns an integer value which uniquely describes a thread.  */
  198. objc_thread_t
  199. __gthread_objc_thread_id (void)
  200. {
  201.   return (objc_thread_t) GetCurrentThreadId ();
  202. }
  203.  
  204. /* Sets the thread's local storage pointer.  */
  205. int
  206. __gthread_objc_thread_set_data (void *value)
  207. {
  208.   if (TlsSetValue (__gthread_objc_data_tls, value))
  209.     return 0;
  210.   else
  211.     return -1;
  212. }
  213.  
  214. /* Returns the thread's local storage pointer.  */
  215. void *
  216. __gthread_objc_thread_get_data (void)
  217. {
  218.   DWORD lasterror;
  219.   void *ptr;
  220.  
  221.   lasterror = GetLastError ();
  222.  
  223.   ptr = TlsGetValue (__gthread_objc_data_tls);          /* Return thread data.  */
  224.  
  225.   SetLastError (lasterror);
  226.  
  227.   return ptr;
  228. }
  229.  
  230. /* Backend mutex functions */
  231.  
  232. /* Allocate a mutex.  */
  233. int
  234. __gthread_objc_mutex_allocate (objc_mutex_t mutex)
  235. {
  236.   if ((mutex->backend = (void *) CreateMutex (NULL, 0, NULL)) == NULL)
  237.     return -1;
  238.   else
  239.     return 0;
  240. }
  241.  
  242. /* Deallocate a mutex.  */
  243. int
  244. __gthread_objc_mutex_deallocate (objc_mutex_t mutex)
  245. {
  246.   CloseHandle ((HANDLE) (mutex->backend));
  247.   return 0;
  248. }
  249.  
  250. /* Grab a lock on a mutex.  */
  251. int
  252. __gthread_objc_mutex_lock (objc_mutex_t mutex)
  253. {
  254.   int status;
  255.  
  256.   status = WaitForSingleObject ((HANDLE) (mutex->backend), INFINITE);
  257.   if (status != WAIT_OBJECT_0 && status != WAIT_ABANDONED)
  258.     return -1;
  259.   else
  260.     return 0;
  261. }
  262.  
  263. /* Try to grab a lock on a mutex.  */
  264. int
  265. __gthread_objc_mutex_trylock (objc_mutex_t mutex)
  266. {
  267.   int status;
  268.  
  269.   status = WaitForSingleObject ((HANDLE) (mutex->backend), 0);
  270.   if (status != WAIT_OBJECT_0 && status != WAIT_ABANDONED)
  271.     return -1;
  272.   else
  273.     return 0;
  274. }
  275.  
  276. /* Unlock the mutex */
  277. int
  278. __gthread_objc_mutex_unlock (objc_mutex_t mutex)
  279. {
  280.   if (ReleaseMutex ((HANDLE) (mutex->backend)) == 0)
  281.     return -1;
  282.   else
  283.     return 0;
  284. }
  285.  
  286. /* Backend condition mutex functions */
  287.  
  288. /* Allocate a condition.  */
  289. int
  290. __gthread_objc_condition_allocate (objc_condition_t condition)
  291. {
  292.   /* Unimplemented.  */
  293.   return -1;
  294. }
  295.  
  296. /* Deallocate a condition.  */
  297. int
  298. __gthread_objc_condition_deallocate (objc_condition_t condition)
  299. {
  300.   /* Unimplemented.  */
  301.   return -1;
  302. }
  303.  
  304. /* Wait on the condition */
  305. int
  306. __gthread_objc_condition_wait (objc_condition_t condition, objc_mutex_t mutex)
  307. {
  308.   /* Unimplemented.  */
  309.   return -1;
  310. }
  311.  
  312. /* Wake up all threads waiting on this condition.  */
  313. int
  314. __gthread_objc_condition_broadcast (objc_condition_t condition)
  315. {
  316.   /* Unimplemented.  */
  317.   return -1;
  318. }
  319.  
  320. /* Wake up one thread waiting on this condition.  */
  321. int
  322. __gthread_objc_condition_signal (objc_condition_t condition)
  323. {
  324.   /* Unimplemented.  */
  325.   return -1;
  326. }
  327.  
  328. #else /* _LIBOBJC */
  329.  
  330. #ifdef __cplusplus
  331. extern "C" {
  332. #endif
  333.  
  334. typedef unsigned long __gthread_key_t;
  335.  
  336. typedef struct {
  337.   int done;
  338.   long started;
  339. } __gthread_once_t;
  340.  
  341. typedef struct {
  342.   long counter;
  343.   void *sema;
  344. } __gthread_mutex_t;
  345.  
  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}
  349.  
  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 */
  359.  
  360. #ifdef __GTHREAD_I486_INLINE_LOCK_PRIMITIVES
  361.  
  362. static inline long
  363. __gthr_i486_lock_cmp_xchg(long *dest, long xchg, long comperand)
  364. {
  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;
  373. }
  374.  
  375. #define __GTHR_W32_InterlockedCompareExchange __gthr_i486_lock_cmp_xchg
  376.  
  377. #else  /* __GTHREAD_I486_INLINE_LOCK_PRIMITIVES */
  378.  
  379. #define __GTHR_W32_InterlockedCompareExchange InterlockedCompareExchange
  380.  
  381. #endif /* __GTHREAD_I486_INLINE_LOCK_PRIMITIVES */
  382.  
  383. static inline int
  384. __gthread_active_p (void)
  385. {
  386. #ifdef MINGW32_SUPPORTS_MT_EH
  387.   return _CRT_MT;
  388. #else
  389.   return 1;
  390. #endif
  391. }
  392.  
  393. #if __GTHREAD_HIDE_WIN32API
  394.  
  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.  */
  398.  
  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 *);
  408.  
  409. static inline int
  410. __gthread_once (__gthread_once_t *once, void (*func) (void))
  411. {
  412.   if (__gthread_active_p ())
  413.     return __gthr_win32_once (once, func);
  414.   else
  415.     return -1;
  416. }
  417.  
  418. static inline int
  419. __gthread_key_create (__gthread_key_t *key, void (*dtor) (void *))
  420. {
  421.   return __gthr_win32_key_create (key, dtor);
  422. }
  423.  
  424. static inline int
  425. __gthread_key_delete (__gthread_key_t key)
  426. {
  427.   return __gthr_win32_key_delete (key);
  428. }
  429.  
  430. static inline void *
  431. __gthread_getspecific (__gthread_key_t key)
  432. {
  433.   return __gthr_win32_getspecific (key);
  434. }
  435.  
  436. static inline int
  437. __gthread_setspecific (__gthread_key_t key, const void *ptr)
  438. {
  439.   return __gthr_win32_setspecific (key, ptr);
  440. }
  441.  
  442. static inline void
  443. __gthread_mutex_init_function (__gthread_mutex_t *mutex)
  444. {
  445.   __gthr_win32_mutex_init_function (mutex);
  446. }
  447.  
  448. static inline int
  449. __gthread_mutex_lock (__gthread_mutex_t *mutex)
  450. {
  451.   if (__gthread_active_p ())
  452.     return __gthr_win32_mutex_lock (mutex);
  453.   else
  454.     return 0;
  455. }
  456.  
  457. static inline int
  458. __gthread_mutex_trylock (__gthread_mutex_t *mutex)
  459. {
  460.   if (__gthread_active_p ())
  461.     return __gthr_win32_mutex_trylock (mutex);
  462.   else
  463.     return 0;
  464. }
  465.  
  466. static inline int
  467. __gthread_mutex_unlock (__gthread_mutex_t *mutex)
  468. {
  469.   if (__gthread_active_p ())
  470.     return __gthr_win32_mutex_unlock (mutex);
  471.   else
  472.     return 0;
  473. }
  474.  
  475. #else /* ! __GTHREAD_HIDE_WIN32API */
  476.  
  477. #include <windows.h>
  478. #include <errno.h>
  479.  
  480. static inline int
  481. __gthread_once (__gthread_once_t *once, void (*func) (void))
  482. {
  483.   if (! __gthread_active_p ())
  484.     return -1;
  485.   else if (once == NULL || func == NULL)
  486.     return EINVAL;
  487.  
  488.   if (! once->done)
  489.     {
  490.       if (InterlockedIncrement (&(once->started)) == 0)
  491.     {
  492.       (*func) ();
  493.       once->done = TRUE;
  494.     }
  495.       else
  496.     {
  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);
  504.     }
  505.     }
  506.  
  507.   return 0;
  508. }
  509.  
  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 *))
  515. {
  516.   int status = 0;
  517.   DWORD tls_index = TlsAlloc ();
  518.   if (tls_index != 0xFFFFFFFF)
  519.     {
  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
  526.     }
  527.   else
  528.     status = (int) GetLastError ();
  529.   return status;
  530. }
  531.  
  532. static inline int
  533. __gthread_key_delete (__gthread_key_t key)
  534. {
  535.   return (TlsFree (key) != 0) ? 0 : (int) GetLastError ();
  536. }
  537.  
  538. static inline void *
  539. __gthread_getspecific (__gthread_key_t key)
  540. {
  541.   DWORD lasterror;
  542.   void *ptr;
  543.  
  544.   lasterror = GetLastError ();
  545.  
  546.   ptr = TlsGetValue (key);
  547.  
  548.   SetLastError (lasterror);
  549.  
  550.   return ptr;
  551. }
  552.  
  553. static inline int
  554. __gthread_setspecific (__gthread_key_t key, const void *ptr)
  555. {
  556.   return (TlsSetValue (key, (void*) ptr) != 0) ? 0 : (int) GetLastError ();
  557. }
  558.  
  559. static inline void
  560. __gthread_mutex_init_function (__gthread_mutex_t *mutex)
  561. {
  562.   mutex->counter = -1;
  563.   mutex->sema = CreateSemaphore (NULL, 0, 65535, NULL);
  564. }
  565.  
  566. static inline int
  567. __gthread_mutex_lock (__gthread_mutex_t *mutex)
  568. {
  569.   int status = 0;
  570.  
  571.   if (__gthread_active_p ())
  572.     {
  573.       if (InterlockedIncrement (&mutex->counter) == 0 ||
  574.       WaitForSingleObject (mutex->sema, INFINITE) == WAIT_OBJECT_0)
  575.     status = 0;
  576.       else
  577.     {
  578.       /* WaitForSingleObject returns WAIT_FAILED, and we can only do
  579.          some best-effort cleanup here.  */
  580.       InterlockedDecrement (&mutex->counter);
  581.       status = 1;
  582.     }
  583.     }
  584.   return status;
  585. }
  586.  
  587. static inline int
  588. __gthread_mutex_trylock (__gthread_mutex_t *mutex)
  589. {
  590.   int status = 0;
  591.  
  592.   if (__gthread_active_p ())
  593.     {
  594.       if (__GTHR_W32_InterlockedCompareExchange (&mutex->counter, 0, -1) < 0)
  595.     status = 0;
  596.       else
  597.     status = 1;
  598.     }
  599.   return status;
  600. }
  601.  
  602. static inline int
  603. __gthread_mutex_unlock (__gthread_mutex_t *mutex)
  604. {
  605.   if (__gthread_active_p ())
  606.     {
  607.       if (InterlockedDecrement (&mutex->counter) >= 0)
  608.     return ReleaseSemaphore (mutex->sema, 1, NULL) ? 0 : 1;
  609.     }
  610.   return 0;
  611. }
  612.  
  613. #endif /*  __GTHREAD_HIDE_WIN32API */
  614.  
  615. #ifdef __cplusplus
  616. }
  617. #endif
  618.  
  619. #endif /* _LIBOBJC */
  620.  
  621. #endif /* ! GCC_GTHR_WIN32_H */
  622.