libstdc++
|
00001 /* Threads compatibility routines for libgcc2 and libobjc. 00002 Compile this one with gcc. 00003 Copyright (C) 2004, 2005, 2008, 2009 Free Software Foundation, Inc. 00004 00005 This file is part of GCC. 00006 00007 GCC is free software; you can redistribute it and/or modify it under 00008 the terms of the GNU General Public License as published by the Free 00009 Software Foundation; either version 3, or (at your option) any later 00010 version. 00011 00012 GCC is distributed in the hope that it will be useful, but WITHOUT ANY 00013 WARRANTY; without even the implied warranty of MERCHANTABILITY or 00014 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 00015 for more details. 00016 00017 Under Section 7 of GPL version 3, you are granted additional 00018 permissions described in the GCC Runtime Library Exception, version 00019 3.1, as published by the Free Software Foundation. 00020 00021 You should have received a copy of the GNU General Public License and 00022 a copy of the GCC Runtime Library Exception along with this program; 00023 see the files COPYING3 and COPYING.RUNTIME respectively. If not, see 00024 <http://www.gnu.org/licenses/>. */ 00025 00026 /* TPF needs its own version of gthr-*.h because TPF always links to 00027 the thread library. However, for performance reasons we still do not 00028 want to issue thread api calls unless a check is made to see that we 00029 are running as a thread. */ 00030 00031 #ifndef _GLIBCXX_GCC_GTHR_TPF_H 00032 #define _GLIBCXX_GCC_GTHR_TPF_H 00033 00034 /* POSIX threads specific definitions. 00035 Easy, since the interface is just one-to-one mapping. */ 00036 00037 #define __GTHREADS 1 00038 00039 /* Some implementations of <pthread.h> require this to be defined. */ 00040 #ifndef _REENTRANT 00041 #define _REENTRANT 1 00042 #endif 00043 00044 #include <pthread.h> 00045 #include <unistd.h> 00046 00047 typedef pthread_key_t __gthread_key_t; 00048 typedef pthread_once_t __gthread_once_t; 00049 typedef pthread_mutex_t __gthread_mutex_t; 00050 typedef pthread_mutex_t __gthread_recursive_mutex_t; 00051 00052 #if defined(PTHREAD_RECURSIVE_MUTEX_INITIALIZER) 00053 #define __GTHREAD_RECURSIVE_MUTEX_INIT PTHREAD_RECURSIVE_MUTEX_INITIALIZER 00054 #elif defined(PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP) 00055 #define __GTHREAD_RECURSIVE_MUTEX_INIT PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP 00056 #endif 00057 00058 #define __GTHREAD_MUTEX_INIT PTHREAD_MUTEX_INITIALIZER 00059 #define __GTHREAD_ONCE_INIT PTHREAD_ONCE_INIT 00060 #define __GTHREAD_RECURSIVE_MUTEX_INIT_FUNCTION __gthread_recursive_mutex_init_function 00061 00062 #define NOTATHREAD 00 00063 #define ECBBASEPTR (unsigned long int) *(unsigned int *)0x00000514u 00064 #define ECBPG2PTR ECBBASEPTR + 0x1000 00065 #define CE2THRCPTR *((unsigned char *)(ECBPG2PTR + 16)) 00066 #define __tpf_pthread_active() (CE2THRCPTR != NOTATHREAD) 00067 00068 #if __GXX_WEAK__ && _GLIBCXX_GTHREAD_USE_WEAK 00069 # define __gthrw(name) \ 00070 static __typeof(name) __gthrw_ ## name __attribute__ ((__weakref__(#name))); 00071 # define __gthrw_(name) __gthrw_ ## name 00072 #else 00073 # define __gthrw(name) 00074 # define __gthrw_(name) name 00075 #endif 00076 00077 __gthrw(pthread_once) 00078 __gthrw(pthread_key_create) 00079 __gthrw(pthread_key_delete) 00080 __gthrw(pthread_getspecific) 00081 __gthrw(pthread_setspecific) 00082 __gthrw(pthread_create) 00083 00084 __gthrw(pthread_mutex_lock) 00085 __gthrw(pthread_mutex_trylock) 00086 __gthrw(pthread_mutex_unlock) 00087 __gthrw(pthread_mutexattr_init) 00088 __gthrw(pthread_mutexattr_settype) 00089 __gthrw(pthread_mutexattr_destroy) 00090 __gthrw(pthread_mutex_init) 00091 __gthrw(pthread_mutex_destroy) 00092 00093 static inline int 00094 __gthread_active_p (void) 00095 { 00096 return 1; 00097 } 00098 00099 static inline int 00100 __gthread_once (__gthread_once_t *__once, void (*__func) (void)) 00101 { 00102 if (__tpf_pthread_active ()) 00103 return __gthrw_(pthread_once) (__once, __func); 00104 else 00105 return -1; 00106 } 00107 00108 static inline int 00109 __gthread_key_create (__gthread_key_t *__key, void (*__dtor) (void *)) 00110 { 00111 if (__tpf_pthread_active ()) 00112 return __gthrw_(pthread_key_create) (__key, __dtor); 00113 else 00114 return -1; 00115 } 00116 00117 static inline int 00118 __gthread_key_delete (__gthread_key_t __key) 00119 { 00120 if (__tpf_pthread_active ()) 00121 return __gthrw_(pthread_key_delete) (__key); 00122 else 00123 return -1; 00124 } 00125 00126 static inline void * 00127 __gthread_getspecific (__gthread_key_t __key) 00128 { 00129 if (__tpf_pthread_active ()) 00130 return __gthrw_(pthread_getspecific) (__key); 00131 else 00132 return NULL; 00133 } 00134 00135 static inline int 00136 __gthread_setspecific (__gthread_key_t __key, const void *__ptr) 00137 { 00138 if (__tpf_pthread_active ()) 00139 return __gthrw_(pthread_setspecific) (__key, __ptr); 00140 else 00141 return -1; 00142 } 00143 00144 static inline int 00145 __gthread_mutex_destroy (__gthread_mutex_t *__mutex) 00146 { 00147 if (__tpf_pthread_active ()) 00148 return __gthrw_(pthread_mutex_destroy) (__mutex); 00149 else 00150 return 0; 00151 } 00152 00153 static inline int 00154 __gthread_mutex_lock (__gthread_mutex_t *__mutex) 00155 { 00156 if (__tpf_pthread_active ()) 00157 return __gthrw_(pthread_mutex_lock) (__mutex); 00158 else 00159 return 0; 00160 } 00161 00162 static inline int 00163 __gthread_mutex_trylock (__gthread_mutex_t *__mutex) 00164 { 00165 if (__tpf_pthread_active ()) 00166 return __gthrw_(pthread_mutex_trylock) (__mutex); 00167 else 00168 return 0; 00169 } 00170 00171 static inline int 00172 __gthread_mutex_unlock (__gthread_mutex_t *__mutex) 00173 { 00174 if (__tpf_pthread_active ()) 00175 return __gthrw_(pthread_mutex_unlock) (__mutex); 00176 else 00177 return 0; 00178 } 00179 00180 static inline int 00181 __gthread_recursive_mutex_lock (__gthread_recursive_mutex_t *__mutex) 00182 { 00183 if (__tpf_pthread_active ()) 00184 return __gthread_mutex_lock (__mutex); 00185 else 00186 return 0; 00187 } 00188 00189 static inline int 00190 __gthread_recursive_mutex_trylock (__gthread_recursive_mutex_t *__mutex) 00191 { 00192 if (__tpf_pthread_active ()) 00193 return __gthread_mutex_trylock (__mutex); 00194 else 00195 return 0; 00196 } 00197 00198 static inline int 00199 __gthread_recursive_mutex_unlock (__gthread_recursive_mutex_t *__mutex) 00200 { 00201 if (__tpf_pthread_active ()) 00202 return __gthread_mutex_unlock (__mutex); 00203 else 00204 return 0; 00205 } 00206 00207 static inline int 00208 __gthread_recursive_mutex_init_function (__gthread_recursive_mutex_t *__mutex) 00209 { 00210 if (__tpf_pthread_active ()) 00211 { 00212 pthread_mutexattr_t __attr; 00213 int __r; 00214 00215 __r = __gthrw_(pthread_mutexattr_init) (&__attr); 00216 if (!__r) 00217 __r = __gthrw_(pthread_mutexattr_settype) (&__attr, 00218 PTHREAD_MUTEX_RECURSIVE); 00219 if (!__r) 00220 __r = __gthrw_(pthread_mutex_init) (__mutex, &__attr); 00221 if (!__r) 00222 __r = __gthrw_(pthread_mutexattr_destroy) (&__attr); 00223 return __r; 00224 } 00225 return 0; 00226 } 00227 00228 00229 #endif /* ! _GLIBCXX_GCC_GTHR_TPF_H */