URL
https://opencores.org/ocsvn/openrisc/openrisc/trunk
Subversion Repositories openrisc
[/] [openrisc/] [tags/] [gnu-src/] [gcc-4.5.1/] [gcc-4.5.1-or32-1.0rc3/] [libstdc++-v3/] [src/] [mutex.cc] - Rev 516
Compare with Previous | Blame | View Log
// 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(); #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