libgcc/config/gthr-rtems.h

   1 /* RTEMS threads compatibility routines for libgcc2 and libobjc.
   2    by: Rosimildo da Silva( rdasilva@connecttel.com ) */
   3 /* Compile this one with gcc.  */
   4 /* Copyright (C) 1997-2018 Free Software Foundation, Inc.
   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 3, 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 Under Section 7 of GPL version 3, you are granted additional
  19 permissions described in the GCC Runtime Library Exception, version
  20 3.1, as published by the Free Software Foundation.
  21
  22 You should have received a copy of the GNU General Public License and
  23 a copy of the GCC Runtime Library Exception along with this program;
  24 see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
  25 <http://www.gnu.org/licenses/>.  */
  26
  27 #ifndef GCC_GTHR_RTEMS_H
  28 #define GCC_GTHR_RTEMS_H
  29
  30 #include <sys/lock.h>
  31 #include <pthread.h>
  32 #include <sched.h>
  33
  34 #ifdef __cplusplus
  35 extern "C" {
  36 #endif
  37
  38 #define __GTHREADS 1
  39 #define __GTHREADS_CXX0X 1
  40 #define __GTHREAD_HAS_COND 1
  41
  42 typedef pthread_t __gthread_t;
  43 typedef pthread_key_t __gthread_key_t;
  44 typedef pthread_once_t __gthread_once_t;
  45 typedef struct _Mutex_Control __gthread_mutex_t;
  46 typedef struct _Mutex_recursive_Control __gthread_recursive_mutex_t;
  47 typedef struct _Condition_Control __gthread_cond_t;
  48 typedef struct timespec __gthread_time_t;
  49
  50 #define __GTHREAD_ONCE_INIT PTHREAD_ONCE_INIT
  51 #define __GTHREAD_MUTEX_INIT _MUTEX_INITIALIZER
  52 #define __GTHREAD_MUTEX_INIT_FUNCTION _Mutex_Initialize
  53 #define __GTHREAD_RECURSIVE_MUTEX_INIT _MUTEX_RECURSIVE_INITIALIZER
  54 #define __GTHREAD_RECURSIVE_MUTEX_INIT_FUNCTION _Mutex_recursive_Initialize
  55 #define __GTHREAD_COND_INIT _CONDITION_INITIALIZER
  56 #define __GTHREAD_COND_INIT_FUNCTION _Condition_Initialize
  57 #define __GTHREAD_TIME_INIT {0, 0}
  58
  59 static inline int
  60 __gthread_active_p (void)
  61 {
  62   return 1;
  63 }
  64
  65 static inline int
  66 __gthread_create (__gthread_t *__threadid, void *(*__func) (void *),
  67                   void *__args)
  68 {
  69   return pthread_create (__threadid, NULL, __func, __args);
  70 }
  71
  72 static inline int
  73 __gthread_join (__gthread_t __threadid, void **__value_ptr)
  74 {
  75   return pthread_join (__threadid, __value_ptr);
  76 }
  77
  78 static inline int
  79 __gthread_detach (__gthread_t __threadid)
  80 {
  81   return pthread_detach (__threadid);
  82 }
  83
  84 static inline int
  85 __gthread_equal (__gthread_t __t1, __gthread_t __t2)
  86 {
  87   return pthread_equal (__t1, __t2);
  88 }
  89
  90 static inline __gthread_t
  91 __gthread_self (void)
  92 {
  93   return pthread_self ();
  94 }
  95
  96 static inline int
  97 __gthread_yield (void)
  98 {
  99   return sched_yield ();
 100 }
 101
 102 static inline int
 103 __gthread_once (__gthread_once_t *__once, void (*__func) (void))
 104 {
 105    return pthread_once (__once, __func);
 106 }
 107
 108 static inline int
 109 __gthread_key_create (__gthread_key_t *__key, void (*__dtor) (void *))
 110 {
 111   return pthread_key_create (__key, __dtor);
 112 }
 113
 114 static inline int
 115 __gthread_key_delete (__gthread_key_t __key)
 116 {
 117   return pthread_key_delete (__key);
 118 }
 119
 120 static inline void *
 121 __gthread_getspecific (__gthread_key_t __key)
 122 {
 123   return pthread_getspecific (__key);
 124 }
 125
 126 static inline int
 127 __gthread_setspecific (__gthread_key_t __key, const void *__ptr)
 128 {
 129   return pthread_setspecific (__key, __ptr);
 130 }
 131
 132 static inline int
 133 __gthread_mutex_lock (__gthread_mutex_t *__mutex)
 134 {
 135   _Mutex_Acquire (__mutex);
 136   return 0;
 137 }
 138
 139 static inline int
 140 __gthread_mutex_trylock (__gthread_mutex_t *__mutex)
 141 {
 142   return _Mutex_Try_acquire (__mutex);
 143 }
 144
 145 static inline int
 146 __gthread_mutex_timedlock (__gthread_mutex_t *__mutex,
 147                            const __gthread_time_t *__abs_timeout)
 148 {
 149   return _Mutex_Acquire_timed (__mutex, __abs_timeout);
 150 }
 151
 152 static inline int
 153 __gthread_mutex_unlock (__gthread_mutex_t *__mutex)
 154 {
 155   _Mutex_Release (__mutex);
 156   return 0;
 157 }
 158
 159 static inline int
 160 __gthread_mutex_destroy (__gthread_mutex_t *__mutex)
 161 {
 162   _Mutex_Destroy (__mutex);
 163   return 0;
 164 }
 165
 166 static inline int
 167 __gthread_recursive_mutex_lock (__gthread_recursive_mutex_t *__mutex)
 168 {
 169   _Mutex_recursive_Acquire (__mutex);
 170   return 0;
 171 }
 172
 173 static inline int
 174 __gthread_recursive_mutex_trylock (__gthread_recursive_mutex_t *__mutex)
 175 {
 176   return _Mutex_recursive_Try_acquire (__mutex);
 177 }
 178
 179 static inline int
 180 __gthread_recursive_mutex_timedlock (__gthread_recursive_mutex_t *__mutex,
 181                                      const __gthread_time_t *__abs_timeout)
 182 {
 183   return _Mutex_recursive_Acquire_timed (__mutex, __abs_timeout);
 184 }
 185
 186 static inline int
 187 __gthread_recursive_mutex_unlock (__gthread_recursive_mutex_t *__mutex)
 188 {
 189   _Mutex_recursive_Release (__mutex);
 190   return 0;
 191 }
 192
 193 static inline int
 194 __gthread_recursive_mutex_destroy (__gthread_recursive_mutex_t *__mutex)
 195 {
 196   _Mutex_recursive_Destroy (__mutex);
 197   return 0;
 198 }
 199
 200 static inline int
 201 __gthread_cond_broadcast (__gthread_cond_t *__cond)
 202 {
 203   _Condition_Broadcast (__cond);
 204   return 0;
 205 }
 206
 207 static inline int
 208 __gthread_cond_signal (__gthread_cond_t *__cond)
 209 {
 210   _Condition_Signal (__cond);
 211   return 0;
 212 }
 213
 214 static inline int
 215 __gthread_cond_wait (__gthread_cond_t *__cond, __gthread_mutex_t *__mutex)
 216 {
 217   _Condition_Wait (__cond, __mutex);
 218   return 0;
 219 }
 220
 221 static inline int
 222 __gthread_cond_timedwait (__gthread_cond_t *__cond, __gthread_mutex_t *__mutex,
 223                           const __gthread_time_t *__abs_timeout)
 224 {
 225   return _Condition_Wait_timed (__cond, __mutex, __abs_timeout);
 226 }
 227
 228 static inline int
 229 __gthread_cond_wait_recursive (__gthread_cond_t *__cond,
 230                                __gthread_recursive_mutex_t *__mutex)
 231 {
 232   _Condition_Wait_recursive (__cond, __mutex);
 233   return 0;
 234 }
 235
 236 static inline int
 237 __gthread_cond_destroy (__gthread_cond_t *__cond)
 238 {
 239   _Condition_Destroy (__cond);
 240   return 0;
 241 }
 242
 243 #ifdef __cplusplus
 244 }
 245 #endif
 246
 247 #endif /* ! GCC_GTHR_RTEMS_H */