src/third_party/libc++abi/trunk/src/cxa_guard.cpp

   1 //===---------------------------- cxa_guard.cpp ---------------------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is dual licensed under the MIT and the University of Illinois Open
   6 // Source Licenses. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #include "abort_message.h"
  11 #include "config.h"
  12
  13 #if !LIBCXXABI_SINGLE_THREADED
  14 #  include <pthread.h>
  15 #endif
  16 #include <stdint.h>
  17
  18 /*
  19     This implementation must be careful to not call code external to this file
  20     which will turn around and try to call __cxa_guard_acquire reentrantly.
  21     For this reason, the headers of this file are as restricted as possible.
  22     Previous implementations of this code for __APPLE__ have used
  23     pthread_mutex_lock and the abort_message utility without problem.  This
  24     implementation also uses pthread_cond_wait which has tested to not be a
  25     problem.
  26 */
  27
  28 namespace __cxxabiv1
  29 {
  30
  31 namespace
  32 {
  33
  34 #if __arm__
  35
  36 // A 32-bit, 4-byte-aligned static data value. The least significant 2 bits must
  37 // be statically initialized to 0.
  38 typedef uint32_t guard_type;
  39
  40 // Test the lowest bit.
  41 inline bool is_initialized(guard_type* guard_object) {
  42     return (*guard_object) & 1;
  43 }
  44
  45 inline void set_initialized(guard_type* guard_object) {
  46     *guard_object |= 1;
  47 }
  48
  49 #else
  50
  51 typedef uint64_t guard_type;
  52
  53 bool is_initialized(guard_type* guard_object) {
  54     char* initialized = (char*)guard_object;
  55     return *initialized;
  56 }
  57
  58 void set_initialized(guard_type* guard_object) {
  59     char* initialized = (char*)guard_object;
  60     *initialized = 1;
  61 }
  62
  63 #endif
  64
  65 #if !LIBCXXABI_SINGLE_THREADED
  66 pthread_mutex_t guard_mut = PTHREAD_MUTEX_INITIALIZER;
  67 pthread_cond_t  guard_cv  = PTHREAD_COND_INITIALIZER;
  68 #endif
  69
  70 #if defined(__APPLE__) && !defined(__arm__)
  71
  72 typedef uint32_t lock_type;
  73
  74 #if __LITTLE_ENDIAN__
  75
  76 inline
  77 lock_type
  78 get_lock(uint64_t x)
  79 {
  80     return static_cast<lock_type>(x >> 32);
  81 }
  82
  83 inline
  84 void
  85 set_lock(uint64_t& x, lock_type y)
  86 {
  87     x = static_cast<uint64_t>(y) << 32;
  88 }
  89
  90 #else  // __LITTLE_ENDIAN__
  91
  92 inline
  93 lock_type
  94 get_lock(uint64_t x)
  95 {
  96     return static_cast<lock_type>(x);
  97 }
  98
  99 inline
 100 void
 101 set_lock(uint64_t& x, lock_type y)
 102 {
 103     x = y;
 104 }
 105
 106 #endif  // __LITTLE_ENDIAN__
 107
 108 #else  // !__APPLE__ || __arm__
 109
 110 typedef bool lock_type;
 111
 112 inline
 113 lock_type
 114 get_lock(uint64_t x)
 115 {
 116     union
 117     {
 118         uint64_t guard;
 119         uint8_t lock[2];
 120     } f = {x};
 121     return f.lock[1] != 0;
 122 }
 123
 124 inline
 125 void
 126 set_lock(uint64_t& x, lock_type y)
 127 {
 128     union
 129     {
 130         uint64_t guard;
 131         uint8_t lock[2];
 132     } f = {0};
 133     f.lock[1] = y;
 134     x = f.guard;
 135 }
 136
 137 inline
 138 lock_type
 139 get_lock(uint32_t x)
 140 {
 141     union
 142     {
 143         uint32_t guard;
 144         uint8_t lock[2];
 145     } f = {x};
 146     return f.lock[1] != 0;
 147 }
 148
 149 inline
 150 void
 151 set_lock(uint32_t& x, lock_type y)
 152 {
 153     union
 154     {
 155         uint32_t guard;
 156         uint8_t lock[2];
 157     } f = {0};
 158     f.lock[1] = y;
 159     x = f.guard;
 160 }
 161
 162 #endif  // __APPLE__
 163
 164 }  // unnamed namespace
 165
 166 extern "C"
 167 {
 168
 169 #if LIBCXXABI_SINGLE_THREADED
 170 int __cxa_guard_acquire(guard_type* guard_object)
 171 {
 172     return !is_initialized(guard_object);
 173 }
 174
 175 void __cxa_guard_release(guard_type* guard_object)
 176 {
 177     *guard_object = 0;
 178     set_initialized(guard_object);
 179 }
 180
 181 void __cxa_guard_abort(guard_type* guard_object)
 182 {
 183     *guard_object = 0;
 184 }
 185
 186 #else // !LIBCXXABI_SINGLE_THREADED
 187
 188 int __cxa_guard_acquire(guard_type* guard_object)
 189 {
 190     char* initialized = (char*)guard_object;
 191     if (pthread_mutex_lock(&guard_mut))
 192         abort_message("__cxa_guard_acquire failed to acquire mutex");
 193     int result = *initialized == 0;
 194     if (result)
 195     {
 196 #if defined(__APPLE__) && !defined(__arm__)
 197         const lock_type id = pthread_mach_thread_np(pthread_self());
 198         lock_type lock = get_lock(*guard_object);
 199         if (lock)
 200         {
 201             // if this thread set lock for this same guard_object, abort
 202             if (lock == id)
 203                 abort_message("__cxa_guard_acquire detected deadlock");
 204             do
 205             {
 206                 if (pthread_cond_wait(&guard_cv, &guard_mut))
 207                     abort_message("__cxa_guard_acquire condition variable wait failed");
 208                 lock = get_lock(*guard_object);
 209             } while (lock);
 210             result = !is_initialized(guard_object);
 211             if (result)
 212                 set_lock(*guard_object, id);
 213         }
 214         else
 215             set_lock(*guard_object, id);
 216 #else  // !__APPLE__ || __arm__
 217         while (get_lock(*guard_object))
 218             if (pthread_cond_wait(&guard_cv, &guard_mut))
 219                 abort_message("__cxa_guard_acquire condition variable wait failed");
 220         result = *initialized == 0;
 221         if (result)
 222             set_lock(*guard_object, true);
 223 #endif  // !__APPLE__ || __arm__
 224     }
 225     if (pthread_mutex_unlock(&guard_mut))
 226         abort_message("__cxa_guard_acquire failed to release mutex");
 227     return result;
 228 }
 229
 230 void __cxa_guard_release(guard_type* guard_object)
 231 {
 232     if (pthread_mutex_lock(&guard_mut))
 233         abort_message("__cxa_guard_release failed to acquire mutex");
 234     *guard_object = 0;
 235     set_initialized(guard_object);
 236     if (pthread_mutex_unlock(&guard_mut))
 237         abort_message("__cxa_guard_release failed to release mutex");
 238     if (pthread_cond_broadcast(&guard_cv))
 239         abort_message("__cxa_guard_release failed to broadcast condition variable");
 240 }
 241
 242 void __cxa_guard_abort(guard_type* guard_object)
 243 {
 244     if (pthread_mutex_lock(&guard_mut))
 245         abort_message("__cxa_guard_abort failed to acquire mutex");
 246     *guard_object = 0;
 247     if (pthread_mutex_unlock(&guard_mut))
 248         abort_message("__cxa_guard_abort failed to release mutex");
 249     if (pthread_cond_broadcast(&guard_cv))
 250         abort_message("__cxa_guard_abort failed to broadcast condition variable");
 251 }
 252
 253 #endif // !LIBCXXABI_SINGLE_THREADED
 254
 255 }  // extern "C"
 256
 257 }  // __cxxabiv1