diff options
Diffstat (limited to 'gcc-4.4.3/libstdc++-v3/src/mutex.cc')
-rw-r--r-- | gcc-4.4.3/libstdc++-v3/src/mutex.cc | 101 |
1 files changed, 101 insertions, 0 deletions
diff --git a/gcc-4.4.3/libstdc++-v3/src/mutex.cc b/gcc-4.4.3/libstdc++-v3/src/mutex.cc new file mode 100644 index 000000000..fcc1eb97a --- /dev/null +++ b/gcc-4.4.3/libstdc++-v3/src/mutex.cc @@ -0,0 +1,101 @@ +// mutex -*- C++ -*- + +// Copyright (C) 2008, 2009 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// <http://www.gnu.org/licenses/>. + +#include <mutex> + +#if defined(_GLIBCXX_HAS_GTHREADS) && defined(_GLIBCXX_USE_C99_STDINT_TR1) +#ifndef _GLIBCXX_HAVE_TLS +namespace +{ + inline std::unique_lock<std::mutex>*& + __get_once_functor_lock_ptr() + { + static std::unique_lock<std::mutex>* __once_functor_lock_ptr = 0; + return __once_functor_lock_ptr; + } +} +#endif + +namespace std +{ + const defer_lock_t defer_lock = defer_lock_t(); + const try_to_lock_t try_to_lock = try_to_lock_t(); + const adopt_lock_t adopt_lock = adopt_lock_t(); + + const char* + lock_error::what() const throw() + { return "std::lock_error"; } + +#ifdef _GLIBCXX_HAVE_TLS + __thread void* __once_callable; + __thread void (*__once_call)(); +#else + // Explicit instantiation due to -fno-implicit-instantiation. + template class function<void()>; + function<void()> __once_functor; + + mutex& + __get_once_mutex() + { + static mutex once_mutex; + return once_mutex; + } + + // code linked against ABI 3.4.12 and later uses this + void + __set_once_functor_lock_ptr(unique_lock<mutex>* __ptr) + { + __get_once_functor_lock_ptr() = __ptr; + } + + // unsafe - retained for compatibility with ABI 3.4.11 + unique_lock<mutex>& + __get_once_functor_lock() + { + static unique_lock<mutex> once_functor_lock(__get_once_mutex(), defer_lock); + return once_functor_lock; + } +#endif + + extern "C" + { + void __once_proxy() + { +#ifndef _GLIBCXX_HAVE_TLS + function<void()> __once_call = std::move(__once_functor); + if (unique_lock<mutex>* __lock = __get_once_functor_lock_ptr()) + { + // caller is using new ABI and provided lock ptr + __get_once_functor_lock_ptr() = 0; + __lock->unlock(); + } + else + __get_once_functor_lock().unlock(); // global lock +#endif + __once_call(); + } + } +} + +#endif // _GLIBCXX_HAS_GTHREADS && _GLIBCXX_USE_C99_STDINT_TR1 |