OSDN Git Service

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