libstdc++-v3/libsupc++/guard.cc

   1 // Copyright (C) 2002, 2004, 2006, 2008, 2009, 2010, 2011
   2 // Free Software Foundation, Inc.
   3 //
   4 // This file is part of GCC.
   5 //
   6 // GCC is free software; you can redistribute it and/or modify
   7 // it under the terms of the GNU General Public License as published by
   8 // the Free Software Foundation; either version 3, or (at your option)
   9 // any later version.
  10
  11 // GCC is distributed in the hope that it will be useful,
  12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 // GNU General Public License for more details.
  15
  16 // Under Section 7 of GPL version 3, you are granted additional
  17 // permissions described in the GCC Runtime Library Exception, version
  18 // 3.1, as published by the Free Software Foundation.
  19
  20 // You should have received a copy of the GNU General Public License and
  21 // a copy of the GCC Runtime Library Exception along with this program;
  22 // see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
  23 // <http://www.gnu.org/licenses/>.
  24
  25 // Written by Mark Mitchell, CodeSourcery LLC, <mark@codesourcery.com>
  26 // Thread support written by Jason Merrill, Red Hat Inc. <jason@redhat.com>
  27
  28 #include <bits/c++config.h>
  29 #include <cxxabi.h>
  30 #include <exception>
  31 #include <new>
  32 #include <ext/atomicity.h>
  33 #include <ext/concurrence.h>
  34 #if defined(__GTHREADS) && defined(__GTHREAD_HAS_COND) \
  35     && defined(_GLIBCXX_ATOMIC_BUILTINS_4) && defined(_GLIBCXX_HAVE_LINUX_FUTEX)
  36 # include <climits>
  37 # include <syscall.h>
  38 # include <unistd.h>
  39 # define _GLIBCXX_USE_FUTEX
  40 # define _GLIBCXX_FUTEX_WAIT 0
  41 # define _GLIBCXX_FUTEX_WAKE 1
  42 #endif
  43
  44 // The IA64/generic ABI uses the first byte of the guard variable.
  45 // The ARM EABI uses the least significant bit.
  46
  47 // Thread-safe static local initialization support.
  48 #ifdef __GTHREADS
  49 # ifndef _GLIBCXX_USE_FUTEX
  50 namespace
  51 {
  52   // A single mutex controlling all static initializations.
  53   static __gnu_cxx::__recursive_mutex* static_mutex;
  54
  55   typedef char fake_recursive_mutex[sizeof(__gnu_cxx::__recursive_mutex)]
  56   __attribute__ ((aligned(__alignof__(__gnu_cxx::__recursive_mutex))));
  57   fake_recursive_mutex fake_mutex;
  58
  59   static void init()
  60   { static_mutex =  new (&fake_mutex) __gnu_cxx::__recursive_mutex(); }
  61
  62   __gnu_cxx::__recursive_mutex&
  63   get_static_mutex()
  64   {
  65     static __gthread_once_t once = __GTHREAD_ONCE_INIT;
  66     __gthread_once(&once, init);
  67     return *static_mutex;
  68   }
  69
  70   // Simple wrapper for exception safety.
  71   struct mutex_wrapper
  72   {
  73     bool unlock;
  74     mutex_wrapper() : unlock(true)
  75     { get_static_mutex().lock(); }
  76
  77     ~mutex_wrapper()
  78     {
  79       if (unlock)
  80         static_mutex->unlock();
  81     }
  82   };
  83 }
  84 # endif
  85
  86 # if defined(__GTHREAD_HAS_COND) && !defined(_GLIBCXX_USE_FUTEX)
  87 namespace
  88 {
  89   // A single condition variable controlling all static initializations.
  90   static __gnu_cxx::__cond* static_cond;
  91
  92   // using a fake type to avoid initializing a static class.
  93   typedef char fake_cond_t[sizeof(__gnu_cxx::__cond)]
  94   __attribute__ ((aligned(__alignof__(__gnu_cxx::__cond))));
  95   fake_cond_t fake_cond;
  96
  97   static void init_static_cond()
  98   { static_cond =  new (&fake_cond) __gnu_cxx::__cond(); }
  99
 100   __gnu_cxx::__cond&
 101   get_static_cond()
 102   {
 103     static __gthread_once_t once = __GTHREAD_ONCE_INIT;
 104     __gthread_once(&once, init_static_cond);
 105     return *static_cond;
 106   }
 107 }
 108 # endif
 109
 110 # ifndef _GLIBCXX_GUARD_TEST_AND_ACQUIRE
 111 inline bool
 112 __test_and_acquire (__cxxabiv1::__guard *g)
 113 {
 114   bool b = _GLIBCXX_GUARD_TEST (g);
 115   _GLIBCXX_READ_MEM_BARRIER;
 116   return b;
 117 }
 118 #  define _GLIBCXX_GUARD_TEST_AND_ACQUIRE(G) __test_and_acquire (G)
 119 # endif
 120
 121 # ifndef _GLIBCXX_GUARD_SET_AND_RELEASE
 122 inline void
 123 __set_and_release (__cxxabiv1::__guard *g)
 124 {
 125   _GLIBCXX_WRITE_MEM_BARRIER;
 126   _GLIBCXX_GUARD_SET (g);
 127 }
 128 #  define _GLIBCXX_GUARD_SET_AND_RELEASE(G) __set_and_release (G)
 129 # endif
 130
 131 #else /* !__GTHREADS */
 132
 133 # undef _GLIBCXX_GUARD_TEST_AND_ACQUIRE
 134 # undef _GLIBCXX_GUARD_SET_AND_RELEASE
 135 # define _GLIBCXX_GUARD_SET_AND_RELEASE(G) _GLIBCXX_GUARD_SET (G)
 136
 137 #endif /* __GTHREADS */
 138
 139 //
 140 // Here are C++ run-time routines for guarded initialization of static
 141 // variables. There are 4 scenarios under which these routines are called:
 142 //
 143 //   1. Threads not supported (__GTHREADS not defined)
 144 //   2. Threads are supported but not enabled at run-time.
 145 //   3. Threads enabled at run-time but __gthreads_* are not fully POSIX.
 146 //   4. Threads enabled at run-time and __gthreads_* support all POSIX threads
 147 //      primitives we need here.
 148 //
 149 // The old code supported scenarios 1-3 but was broken since it used a global
 150 // mutex for all threads and had the mutex locked during the whole duration of
 151 // initialization of a guarded static variable. The following created a
 152 // dead-lock with the old code.
 153 //
 154 //      Thread 1 acquires the global mutex.
 155 //      Thread 1 starts initializing static variable.
 156 //      Thread 1 creates thread 2 during initialization.
 157 //      Thread 2 attempts to acquire mutex to initialize another variable.
 158 //      Thread 2 blocks since thread 1 is locking the mutex.
 159 //      Thread 1 waits for result from thread 2 and also blocks. A deadlock.
 160 //
 161 // The new code here can handle this situation and thus is more robust. However,
 162 // we need to use the POSIX thread condition variable, which is not supported
 163 // in all platforms, notably older versions of Microsoft Windows. The gthr*.h
 164 // headers define a symbol __GTHREAD_HAS_COND for platforms that support POSIX
 165 // like condition variables. For platforms that do not support condition
 166 // variables, we need to fall back to the old code.
 167
 168 // If _GLIBCXX_USE_FUTEX, no global mutex or condition variable is used,
 169 // only atomic operations are used together with futex syscall.
 170 // Valid values of the first integer in guard are:
 171 // 0                              No thread encountered the guarded init
 172 //                                yet or it has been aborted.
 173 // _GLIBCXX_GUARD_BIT             The guarded static var has been successfully
 174 //                                initialized.
 175 // _GLIBCXX_GUARD_PENDING_BIT     The guarded static var is being initialized
 176 //                                and no other thread is waiting for its
 177 //                                initialization.
 178 // (_GLIBCXX_GUARD_PENDING_BIT    The guarded static var is being initialized
 179 //  | _GLIBCXX_GUARD_WAITING_BIT) and some other threads are waiting until
 180 //                                it is initialized.
 181
 182 namespace __cxxabiv1
 183 {
 184 #ifdef _GLIBCXX_USE_FUTEX
 185   namespace
 186   {
 187     static inline int __guard_test_bit (const int __byte, const int __val)
 188     {
 189       union { int __i; char __c[sizeof (int)]; } __u = { 0 };
 190       __u.__c[__byte] = __val;
 191       return __u.__i;
 192     }
 193   }
 194 #endif
 195
 196   static inline int
 197   init_in_progress_flag(__guard* g)
 198   { return ((char *)g)[1]; }
 199
 200   static inline void
 201   set_init_in_progress_flag(__guard* g, int v)
 202   { ((char *)g)[1] = v; }
 203
 204   static inline void
 205   throw_recursive_init_exception()
 206   {
 207 #ifdef __EXCEPTIONS
 208         throw __gnu_cxx::recursive_init_error();
 209 #else
 210         // Use __builtin_trap so we don't require abort().
 211         __builtin_trap();
 212 #endif
 213   }
 214
 215   // acquire() is a helper function used to acquire guard if thread support is
 216   // not compiled in or is compiled in but not enabled at run-time.
 217   static int
 218   acquire(__guard *g)
 219   {
 220     // Quit if the object is already initialized.
 221     if (_GLIBCXX_GUARD_TEST(g))
 222       return 0;
 223
 224     if (init_in_progress_flag(g))
 225       throw_recursive_init_exception();
 226
 227     set_init_in_progress_flag(g, 1);
 228     return 1;
 229   }
 230
 231   extern "C"
 232   int __cxa_guard_acquire (__guard *g)
 233   {
 234 #ifdef __GTHREADS
 235     // If the target can reorder loads, we need to insert a read memory
 236     // barrier so that accesses to the guarded variable happen after the
 237     // guard test.
 238     if (_GLIBCXX_GUARD_TEST_AND_ACQUIRE (g))
 239       return 0;
 240
 241 # ifdef _GLIBCXX_USE_FUTEX
 242     // If __sync_* and futex syscall are supported, don't use any global
 243     // mutex.
 244     if (__gthread_active_p ())
 245       {
 246         int *gi = (int *) (void *) g;
 247         const int guard_bit = _GLIBCXX_GUARD_BIT;
 248         const int pending_bit = _GLIBCXX_GUARD_PENDING_BIT;
 249         const int waiting_bit = _GLIBCXX_GUARD_WAITING_BIT;
 250
 251         while (1)
 252           {
 253             int old = __sync_val_compare_and_swap (gi, 0, pending_bit);
 254             if (old == 0)
 255               return 1; // This thread should do the initialization.
 256
 257             if (old == guard_bit)
 258               return 0; // Already initialized.
 259
 260             if (old == pending_bit)
 261               {
 262                 int newv = old | waiting_bit;
 263                 if (__sync_val_compare_and_swap (gi, old, newv) != old)
 264                   continue;
 265
 266                 old = newv;
 267               }
 268
 269             syscall (SYS_futex, gi, _GLIBCXX_FUTEX_WAIT, old, 0);
 270           }
 271       }
 272 # else
 273     if (__gthread_active_p ())
 274       {
 275         mutex_wrapper mw;
 276
 277         while (1)       // When this loop is executing, mutex is locked.
 278           {
 279 #  ifdef __GTHREAD_HAS_COND
 280             // The static is already initialized.
 281             if (_GLIBCXX_GUARD_TEST(g))
 282               return 0; // The mutex will be unlocked via wrapper
 283
 284             if (init_in_progress_flag(g))
 285               {
 286                 // The guarded static is currently being initialized by
 287                 // another thread, so we release mutex and wait for the
 288                 // condition variable. We will lock the mutex again after
 289                 // this.
 290                 get_static_cond().wait_recursive(&get_static_mutex());
 291               }
 292             else
 293               {
 294                 set_init_in_progress_flag(g, 1);
 295                 return 1; // The mutex will be unlocked via wrapper.
 296               }
 297 #  else
 298             // This provides compatibility with older systems not supporting
 299             // POSIX like condition variables.
 300             if (acquire(g))
 301               {
 302                 mw.unlock = false;
 303                 return 1; // The mutex still locked.
 304               }
 305             return 0; // The mutex will be unlocked via wrapper.
 306 #  endif
 307           }
 308       }
 309 # endif
 310 #endif
 311
 312     return acquire (g);
 313   }
 314
 315   extern "C"
 316   void __cxa_guard_abort (__guard *g) throw ()
 317   {
 318 #ifdef _GLIBCXX_USE_FUTEX
 319     // If __sync_* and futex syscall are supported, don't use any global
 320     // mutex.
 321     if (__gthread_active_p ())
 322       {
 323         int *gi = (int *) (void *) g;
 324         const int waiting_bit = _GLIBCXX_GUARD_WAITING_BIT;
 325         int old = __sync_lock_test_and_set (gi, 0);
 326
 327         if ((old & waiting_bit) != 0)
 328           syscall (SYS_futex, gi, _GLIBCXX_FUTEX_WAKE, INT_MAX);
 329         return;
 330       }
 331 #elif defined(__GTHREAD_HAS_COND)
 332     if (__gthread_active_p())
 333       {
 334         mutex_wrapper mw;
 335
 336         set_init_in_progress_flag(g, 0);
 337
 338         // If we abort, we still need to wake up all other threads waiting for
 339         // the condition variable.
 340         get_static_cond().broadcast();
 341         return;
 342       }
 343 #endif
 344
 345     set_init_in_progress_flag(g, 0);
 346 #if defined(__GTHREADS) && !defined(__GTHREAD_HAS_COND)
 347     // This provides compatibility with older systems not supporting POSIX like
 348     // condition variables.
 349     if (__gthread_active_p ())
 350       static_mutex->unlock();
 351 #endif
 352   }
 353
 354   extern "C"
 355   void __cxa_guard_release (__guard *g) throw ()
 356   {
 357 #ifdef _GLIBCXX_USE_FUTEX
 358     // If __sync_* and futex syscall are supported, don't use any global
 359     // mutex.
 360     if (__gthread_active_p ())
 361       {
 362         int *gi = (int *) (void *) g;
 363         const int guard_bit = _GLIBCXX_GUARD_BIT;
 364         const int waiting_bit = _GLIBCXX_GUARD_WAITING_BIT;
 365         int old = __sync_lock_test_and_set (gi, guard_bit);
 366
 367         if ((old & waiting_bit) != 0)
 368           syscall (SYS_futex, gi, _GLIBCXX_FUTEX_WAKE, INT_MAX);
 369         return;
 370       }
 371 #elif defined(__GTHREAD_HAS_COND)
 372     if (__gthread_active_p())
 373       {
 374         mutex_wrapper mw;
 375
 376         set_init_in_progress_flag(g, 0);
 377         _GLIBCXX_GUARD_SET_AND_RELEASE(g);
 378
 379         get_static_cond().broadcast();
 380         return;
 381       }
 382 #endif
 383
 384     set_init_in_progress_flag(g, 0);
 385     _GLIBCXX_GUARD_SET_AND_RELEASE (g);
 386
 387 #if defined(__GTHREADS) && !defined(__GTHREAD_HAS_COND)
 388     // This provides compatibility with older systems not supporting POSIX like
 389     // condition variables.
 390     if (__gthread_active_p())
 391       static_mutex->unlock();
 392 #endif
 393   }
 394 }