From patchwork Wed Jan 6 13:07:01 2016 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Jonathan Wakely X-Patchwork-Id: 563932 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Received: from sourceware.org (server1.sourceware.org [209.132.180.131]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by ozlabs.org (Postfix) with ESMTPS id BF9D7140180 for ; Thu, 7 Jan 2016 00:07:16 +1100 (AEDT) Authentication-Results: ozlabs.org; dkim=pass (1024-bit key; unprotected) header.d=gcc.gnu.org header.i=@gcc.gnu.org header.b=ssarAOlu; dkim-atps=neutral DomainKey-Signature: a=rsa-sha1; c=nofws; d=gcc.gnu.org; h=list-id :list-unsubscribe:list-archive:list-post:list-help:sender:date :from:to:cc:subject:message-id:mime-version:content-type; q=dns; s=default; b=FahU3C2S86BbSNUr1DSmAvQ8aW90Sd/8BecmZzRHXv9U2G4nmF o1rmfI4Kzy/6TAC7YjkC3qFOsoNcSESrVp/4PN8vuRg6+Z7OGtirSfWxIzM8m4+M 8TFMDwqRafIkPfFmlKGOQu5FSLxQNZXBdSrV+b2WNWZUXOPwZcXrfABgo= DKIM-Signature: v=1; a=rsa-sha1; c=relaxed; d=gcc.gnu.org; h=list-id :list-unsubscribe:list-archive:list-post:list-help:sender:date :from:to:cc:subject:message-id:mime-version:content-type; s= default; bh=CGauHSw6UcRaOyJ3d+JPI02SlfQ=; b=ssarAOlu5bQrXJkzWf2S Q+2qSh+TwBRL3ozPXYmQfGRYCacJUnILBZYps4kCzDHlQCcMLqDzSVzu2SJ1JERh F+Htl50cVinSExJuFlkg1pUP1hDBXyCmRD1l92p5oEWUvxCJI24A3TweKJaxURqS 9x351cII/tQ9R5wOtk90cCw= Received: (qmail 42657 invoked by alias); 6 Jan 2016 13:07:09 -0000 Mailing-List: contact gcc-patches-help@gcc.gnu.org; run by ezmlm Precedence: bulk List-Id: List-Unsubscribe: List-Archive: List-Post: List-Help: Sender: gcc-patches-owner@gcc.gnu.org Delivered-To: mailing list gcc-patches@gcc.gnu.org Received: (qmail 42636 invoked by uid 89); 6 Jan 2016 13:07:07 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-0.8 required=5.0 tests=AWL, BAYES_20, RP_MATCHES_RCVD, SPF_HELO_PASS autolearn=ham version=3.3.2 spammy=unlock, releasing, acquire, UD:lock X-Spam-User: qpsmtpd, 2 recipients X-HELO: mx1.redhat.com Received: from mx1.redhat.com (HELO mx1.redhat.com) (209.132.183.28) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with (AES256-GCM-SHA384 encrypted) ESMTPS; Wed, 06 Jan 2016 13:07:04 +0000 Received: from int-mx14.intmail.prod.int.phx2.redhat.com (int-mx14.intmail.prod.int.phx2.redhat.com [10.5.11.27]) by mx1.redhat.com (Postfix) with ESMTPS id 461D74C38A; Wed, 6 Jan 2016 13:07:03 +0000 (UTC) Received: from localhost (ovpn-116-77.ams2.redhat.com [10.36.116.77]) by int-mx14.intmail.prod.int.phx2.redhat.com (8.14.4/8.14.4) with ESMTP id u06D71fH031311; Wed, 6 Jan 2016 08:07:02 -0500 Date: Wed, 6 Jan 2016 13:07:01 +0000 From: Jonathan Wakely To: libstdc++@gcc.gnu.org, gcc-patches@gcc.gnu.org Cc: Matthias Klose Subject: [patch] Rename bits/mutex.h to avoid clashing with glibc Message-ID: <20160106130045.GA8785@redhat.com> MIME-Version: 1.0 Content-Disposition: inline X-Clacks-Overhead: GNU Terry Pratchett User-Agent: Mutt/1.5.24 (2015-08-30) Matthias discovered that the new header I created on trunk clashes with a libc header on GNU/Hurd, so this patch renames it to something unique. Tested powerpc64le-linux, committed to trunk. commit cd573d5d7d0a13be626619fa4b663941e86cdf98 Author: Jonathan Wakely Date: Wed Jan 6 12:43:07 2016 +0000 Rename bits/mutex.h to avoid clashing with glibc * include/Makefile.am: Adjust. * include/Makefile.in: Regenerate. * include/bits/mutex.h: Rename to bits/std_mutex.h. * include/std/condition_variable: Adjust include. * include/std/mutex: Likewise. diff --git a/libstdc++-v3/include/Makefile.am b/libstdc++-v3/include/Makefile.am index e657420..b0a9373 100644 --- a/libstdc++-v3/include/Makefile.am +++ b/libstdc++-v3/include/Makefile.am @@ -122,7 +122,7 @@ bits_headers = \ ${bits_srcdir}/mask_array.h \ ${bits_srcdir}/memoryfwd.h \ ${bits_srcdir}/move.h \ - ${bits_srcdir}/mutex.h \ + ${bits_srcdir}/std_mutex.h \ ${bits_srcdir}/ostream.tcc \ ${bits_srcdir}/ostream_insert.h \ ${bits_srcdir}/parse_numbers.h \ diff --git a/libstdc++-v3/include/bits/mutex.h b/libstdc++-v3/include/bits/mutex.h deleted file mode 100644 index 67b7825..0000000 --- a/libstdc++-v3/include/bits/mutex.h +++ /dev/null @@ -1,373 +0,0 @@ -// std::mutex implementation -*- C++ -*- - -// Copyright (C) 2003-2016 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 -// . - -/** @file bits/mutex.h - * This is an internal header file, included by other library headers. - * Do not attempt to use it directly. @headername{mutex} - */ - -#ifndef _GLIBCXX_MUTEX_H -#define _GLIBCXX_MUTEX_H 1 - -#pragma GCC system_header - -#if __cplusplus < 201103L -# include -#else - -#include -#include -#include -#include // for std::swap - -#ifdef _GLIBCXX_USE_C99_STDINT_TR1 - -namespace std _GLIBCXX_VISIBILITY(default) -{ -_GLIBCXX_BEGIN_NAMESPACE_VERSION - - /** - * @defgroup mutexes Mutexes - * @ingroup concurrency - * - * Classes for mutex support. - * @{ - */ - -#ifdef _GLIBCXX_HAS_GTHREADS - // Common base class for std::mutex and std::timed_mutex - class __mutex_base - { - protected: - typedef __gthread_mutex_t __native_type; - -#ifdef __GTHREAD_MUTEX_INIT - __native_type _M_mutex = __GTHREAD_MUTEX_INIT; - - constexpr __mutex_base() noexcept = default; -#else - __native_type _M_mutex; - - __mutex_base() noexcept - { - // XXX EAGAIN, ENOMEM, EPERM, EBUSY(may), EINVAL(may) - __GTHREAD_MUTEX_INIT_FUNCTION(&_M_mutex); - } - - ~__mutex_base() noexcept { __gthread_mutex_destroy(&_M_mutex); } -#endif - - __mutex_base(const __mutex_base&) = delete; - __mutex_base& operator=(const __mutex_base&) = delete; - }; - - /// The standard mutex type. - class mutex : private __mutex_base - { - public: - typedef __native_type* native_handle_type; - -#ifdef __GTHREAD_MUTEX_INIT - constexpr -#endif - mutex() noexcept = default; - ~mutex() = default; - - mutex(const mutex&) = delete; - mutex& operator=(const mutex&) = delete; - - void - lock() - { - int __e = __gthread_mutex_lock(&_M_mutex); - - // EINVAL, EAGAIN, EBUSY, EINVAL, EDEADLK(may) - if (__e) - __throw_system_error(__e); - } - - bool - try_lock() noexcept - { - // XXX EINVAL, EAGAIN, EBUSY - return !__gthread_mutex_trylock(&_M_mutex); - } - - void - unlock() - { - // XXX EINVAL, EAGAIN, EPERM - __gthread_mutex_unlock(&_M_mutex); - } - - native_handle_type - native_handle() - { return &_M_mutex; } - }; - -#endif // _GLIBCXX_HAS_GTHREADS - - /// Do not acquire ownership of the mutex. - struct defer_lock_t { explicit defer_lock_t() = default; }; - - /// Try to acquire ownership of the mutex without blocking. - struct try_to_lock_t { explicit try_to_lock_t() = default; }; - - /// Assume the calling thread has already obtained mutex ownership - /// and manage it. - struct adopt_lock_t { explicit adopt_lock_t() = default; }; - - /// Tag used to prevent a scoped lock from acquiring ownership of a mutex. - constexpr defer_lock_t defer_lock { }; - - /// Tag used to prevent a scoped lock from blocking if a mutex is locked. - constexpr try_to_lock_t try_to_lock { }; - - /// Tag used to make a scoped lock take ownership of a locked mutex. - constexpr adopt_lock_t adopt_lock { }; - - /** @brief A simple scoped lock type. - * - * A lock_guard controls mutex ownership within a scope, releasing - * ownership in the destructor. - */ - template - class lock_guard - { - public: - typedef _Mutex mutex_type; - - explicit lock_guard(mutex_type& __m) : _M_device(__m) - { _M_device.lock(); } - - lock_guard(mutex_type& __m, adopt_lock_t) : _M_device(__m) - { } // calling thread owns mutex - - ~lock_guard() - { _M_device.unlock(); } - - lock_guard(const lock_guard&) = delete; - lock_guard& operator=(const lock_guard&) = delete; - - private: - mutex_type& _M_device; - }; - - /** @brief A movable scoped lock type. - * - * A unique_lock controls mutex ownership within a scope. Ownership of the - * mutex can be delayed until after construction and can be transferred - * to another unique_lock by move construction or move assignment. If a - * mutex lock is owned when the destructor runs ownership will be released. - */ - template - class unique_lock - { - public: - typedef _Mutex mutex_type; - - unique_lock() noexcept - : _M_device(0), _M_owns(false) - { } - - explicit unique_lock(mutex_type& __m) - : _M_device(std::__addressof(__m)), _M_owns(false) - { - lock(); - _M_owns = true; - } - - unique_lock(mutex_type& __m, defer_lock_t) noexcept - : _M_device(std::__addressof(__m)), _M_owns(false) - { } - - unique_lock(mutex_type& __m, try_to_lock_t) - : _M_device(std::__addressof(__m)), _M_owns(_M_device->try_lock()) - { } - - unique_lock(mutex_type& __m, adopt_lock_t) - : _M_device(std::__addressof(__m)), _M_owns(true) - { - // XXX calling thread owns mutex - } - - template - unique_lock(mutex_type& __m, - const chrono::time_point<_Clock, _Duration>& __atime) - : _M_device(std::__addressof(__m)), - _M_owns(_M_device->try_lock_until(__atime)) - { } - - template - unique_lock(mutex_type& __m, - const chrono::duration<_Rep, _Period>& __rtime) - : _M_device(std::__addressof(__m)), - _M_owns(_M_device->try_lock_for(__rtime)) - { } - - ~unique_lock() - { - if (_M_owns) - unlock(); - } - - unique_lock(const unique_lock&) = delete; - unique_lock& operator=(const unique_lock&) = delete; - - unique_lock(unique_lock&& __u) noexcept - : _M_device(__u._M_device), _M_owns(__u._M_owns) - { - __u._M_device = 0; - __u._M_owns = false; - } - - unique_lock& operator=(unique_lock&& __u) noexcept - { - if(_M_owns) - unlock(); - - unique_lock(std::move(__u)).swap(*this); - - __u._M_device = 0; - __u._M_owns = false; - - return *this; - } - - void - lock() - { - if (!_M_device) - __throw_system_error(int(errc::operation_not_permitted)); - else if (_M_owns) - __throw_system_error(int(errc::resource_deadlock_would_occur)); - else - { - _M_device->lock(); - _M_owns = true; - } - } - - bool - try_lock() - { - if (!_M_device) - __throw_system_error(int(errc::operation_not_permitted)); - else if (_M_owns) - __throw_system_error(int(errc::resource_deadlock_would_occur)); - else - { - _M_owns = _M_device->try_lock(); - return _M_owns; - } - } - - template - bool - try_lock_until(const chrono::time_point<_Clock, _Duration>& __atime) - { - if (!_M_device) - __throw_system_error(int(errc::operation_not_permitted)); - else if (_M_owns) - __throw_system_error(int(errc::resource_deadlock_would_occur)); - else - { - _M_owns = _M_device->try_lock_until(__atime); - return _M_owns; - } - } - - template - bool - try_lock_for(const chrono::duration<_Rep, _Period>& __rtime) - { - if (!_M_device) - __throw_system_error(int(errc::operation_not_permitted)); - else if (_M_owns) - __throw_system_error(int(errc::resource_deadlock_would_occur)); - else - { - _M_owns = _M_device->try_lock_for(__rtime); - return _M_owns; - } - } - - void - unlock() - { - if (!_M_owns) - __throw_system_error(int(errc::operation_not_permitted)); - else if (_M_device) - { - _M_device->unlock(); - _M_owns = false; - } - } - - void - swap(unique_lock& __u) noexcept - { - std::swap(_M_device, __u._M_device); - std::swap(_M_owns, __u._M_owns); - } - - mutex_type* - release() noexcept - { - mutex_type* __ret = _M_device; - _M_device = 0; - _M_owns = false; - return __ret; - } - - bool - owns_lock() const noexcept - { return _M_owns; } - - explicit operator bool() const noexcept - { return owns_lock(); } - - mutex_type* - mutex() const noexcept - { return _M_device; } - - private: - mutex_type* _M_device; - bool _M_owns; // XXX use atomic_bool - }; - - /// Swap overload for unique_lock objects. - template - inline void - swap(unique_lock<_Mutex>& __x, unique_lock<_Mutex>& __y) noexcept - { __x.swap(__y); } - - // @} group mutexes -_GLIBCXX_END_NAMESPACE_VERSION -} // namespace -#endif // _GLIBCXX_USE_C99_STDINT_TR1 - -#endif // C++11 - -#endif // _GLIBCXX_MUTEX_H diff --git a/libstdc++-v3/include/bits/std_mutex.h b/libstdc++-v3/include/bits/std_mutex.h new file mode 100644 index 0000000..67b7825 --- /dev/null +++ b/libstdc++-v3/include/bits/std_mutex.h @@ -0,0 +1,373 @@ +// std::mutex implementation -*- C++ -*- + +// Copyright (C) 2003-2016 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 +// . + +/** @file bits/mutex.h + * This is an internal header file, included by other library headers. + * Do not attempt to use it directly. @headername{mutex} + */ + +#ifndef _GLIBCXX_MUTEX_H +#define _GLIBCXX_MUTEX_H 1 + +#pragma GCC system_header + +#if __cplusplus < 201103L +# include +#else + +#include +#include +#include +#include // for std::swap + +#ifdef _GLIBCXX_USE_C99_STDINT_TR1 + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + /** + * @defgroup mutexes Mutexes + * @ingroup concurrency + * + * Classes for mutex support. + * @{ + */ + +#ifdef _GLIBCXX_HAS_GTHREADS + // Common base class for std::mutex and std::timed_mutex + class __mutex_base + { + protected: + typedef __gthread_mutex_t __native_type; + +#ifdef __GTHREAD_MUTEX_INIT + __native_type _M_mutex = __GTHREAD_MUTEX_INIT; + + constexpr __mutex_base() noexcept = default; +#else + __native_type _M_mutex; + + __mutex_base() noexcept + { + // XXX EAGAIN, ENOMEM, EPERM, EBUSY(may), EINVAL(may) + __GTHREAD_MUTEX_INIT_FUNCTION(&_M_mutex); + } + + ~__mutex_base() noexcept { __gthread_mutex_destroy(&_M_mutex); } +#endif + + __mutex_base(const __mutex_base&) = delete; + __mutex_base& operator=(const __mutex_base&) = delete; + }; + + /// The standard mutex type. + class mutex : private __mutex_base + { + public: + typedef __native_type* native_handle_type; + +#ifdef __GTHREAD_MUTEX_INIT + constexpr +#endif + mutex() noexcept = default; + ~mutex() = default; + + mutex(const mutex&) = delete; + mutex& operator=(const mutex&) = delete; + + void + lock() + { + int __e = __gthread_mutex_lock(&_M_mutex); + + // EINVAL, EAGAIN, EBUSY, EINVAL, EDEADLK(may) + if (__e) + __throw_system_error(__e); + } + + bool + try_lock() noexcept + { + // XXX EINVAL, EAGAIN, EBUSY + return !__gthread_mutex_trylock(&_M_mutex); + } + + void + unlock() + { + // XXX EINVAL, EAGAIN, EPERM + __gthread_mutex_unlock(&_M_mutex); + } + + native_handle_type + native_handle() + { return &_M_mutex; } + }; + +#endif // _GLIBCXX_HAS_GTHREADS + + /// Do not acquire ownership of the mutex. + struct defer_lock_t { explicit defer_lock_t() = default; }; + + /// Try to acquire ownership of the mutex without blocking. + struct try_to_lock_t { explicit try_to_lock_t() = default; }; + + /// Assume the calling thread has already obtained mutex ownership + /// and manage it. + struct adopt_lock_t { explicit adopt_lock_t() = default; }; + + /// Tag used to prevent a scoped lock from acquiring ownership of a mutex. + constexpr defer_lock_t defer_lock { }; + + /// Tag used to prevent a scoped lock from blocking if a mutex is locked. + constexpr try_to_lock_t try_to_lock { }; + + /// Tag used to make a scoped lock take ownership of a locked mutex. + constexpr adopt_lock_t adopt_lock { }; + + /** @brief A simple scoped lock type. + * + * A lock_guard controls mutex ownership within a scope, releasing + * ownership in the destructor. + */ + template + class lock_guard + { + public: + typedef _Mutex mutex_type; + + explicit lock_guard(mutex_type& __m) : _M_device(__m) + { _M_device.lock(); } + + lock_guard(mutex_type& __m, adopt_lock_t) : _M_device(__m) + { } // calling thread owns mutex + + ~lock_guard() + { _M_device.unlock(); } + + lock_guard(const lock_guard&) = delete; + lock_guard& operator=(const lock_guard&) = delete; + + private: + mutex_type& _M_device; + }; + + /** @brief A movable scoped lock type. + * + * A unique_lock controls mutex ownership within a scope. Ownership of the + * mutex can be delayed until after construction and can be transferred + * to another unique_lock by move construction or move assignment. If a + * mutex lock is owned when the destructor runs ownership will be released. + */ + template + class unique_lock + { + public: + typedef _Mutex mutex_type; + + unique_lock() noexcept + : _M_device(0), _M_owns(false) + { } + + explicit unique_lock(mutex_type& __m) + : _M_device(std::__addressof(__m)), _M_owns(false) + { + lock(); + _M_owns = true; + } + + unique_lock(mutex_type& __m, defer_lock_t) noexcept + : _M_device(std::__addressof(__m)), _M_owns(false) + { } + + unique_lock(mutex_type& __m, try_to_lock_t) + : _M_device(std::__addressof(__m)), _M_owns(_M_device->try_lock()) + { } + + unique_lock(mutex_type& __m, adopt_lock_t) + : _M_device(std::__addressof(__m)), _M_owns(true) + { + // XXX calling thread owns mutex + } + + template + unique_lock(mutex_type& __m, + const chrono::time_point<_Clock, _Duration>& __atime) + : _M_device(std::__addressof(__m)), + _M_owns(_M_device->try_lock_until(__atime)) + { } + + template + unique_lock(mutex_type& __m, + const chrono::duration<_Rep, _Period>& __rtime) + : _M_device(std::__addressof(__m)), + _M_owns(_M_device->try_lock_for(__rtime)) + { } + + ~unique_lock() + { + if (_M_owns) + unlock(); + } + + unique_lock(const unique_lock&) = delete; + unique_lock& operator=(const unique_lock&) = delete; + + unique_lock(unique_lock&& __u) noexcept + : _M_device(__u._M_device), _M_owns(__u._M_owns) + { + __u._M_device = 0; + __u._M_owns = false; + } + + unique_lock& operator=(unique_lock&& __u) noexcept + { + if(_M_owns) + unlock(); + + unique_lock(std::move(__u)).swap(*this); + + __u._M_device = 0; + __u._M_owns = false; + + return *this; + } + + void + lock() + { + if (!_M_device) + __throw_system_error(int(errc::operation_not_permitted)); + else if (_M_owns) + __throw_system_error(int(errc::resource_deadlock_would_occur)); + else + { + _M_device->lock(); + _M_owns = true; + } + } + + bool + try_lock() + { + if (!_M_device) + __throw_system_error(int(errc::operation_not_permitted)); + else if (_M_owns) + __throw_system_error(int(errc::resource_deadlock_would_occur)); + else + { + _M_owns = _M_device->try_lock(); + return _M_owns; + } + } + + template + bool + try_lock_until(const chrono::time_point<_Clock, _Duration>& __atime) + { + if (!_M_device) + __throw_system_error(int(errc::operation_not_permitted)); + else if (_M_owns) + __throw_system_error(int(errc::resource_deadlock_would_occur)); + else + { + _M_owns = _M_device->try_lock_until(__atime); + return _M_owns; + } + } + + template + bool + try_lock_for(const chrono::duration<_Rep, _Period>& __rtime) + { + if (!_M_device) + __throw_system_error(int(errc::operation_not_permitted)); + else if (_M_owns) + __throw_system_error(int(errc::resource_deadlock_would_occur)); + else + { + _M_owns = _M_device->try_lock_for(__rtime); + return _M_owns; + } + } + + void + unlock() + { + if (!_M_owns) + __throw_system_error(int(errc::operation_not_permitted)); + else if (_M_device) + { + _M_device->unlock(); + _M_owns = false; + } + } + + void + swap(unique_lock& __u) noexcept + { + std::swap(_M_device, __u._M_device); + std::swap(_M_owns, __u._M_owns); + } + + mutex_type* + release() noexcept + { + mutex_type* __ret = _M_device; + _M_device = 0; + _M_owns = false; + return __ret; + } + + bool + owns_lock() const noexcept + { return _M_owns; } + + explicit operator bool() const noexcept + { return owns_lock(); } + + mutex_type* + mutex() const noexcept + { return _M_device; } + + private: + mutex_type* _M_device; + bool _M_owns; // XXX use atomic_bool + }; + + /// Swap overload for unique_lock objects. + template + inline void + swap(unique_lock<_Mutex>& __x, unique_lock<_Mutex>& __y) noexcept + { __x.swap(__y); } + + // @} group mutexes +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace +#endif // _GLIBCXX_USE_C99_STDINT_TR1 + +#endif // C++11 + +#endif // _GLIBCXX_MUTEX_H diff --git a/libstdc++-v3/include/std/condition_variable b/libstdc++-v3/include/std/condition_variable index 677b2a8..62a7ee1 100644 --- a/libstdc++-v3/include/std/condition_variable +++ b/libstdc++-v3/include/std/condition_variable @@ -36,7 +36,7 @@ #else #include -#include +#include #include #include #include diff --git a/libstdc++-v3/include/std/mutex b/libstdc++-v3/include/std/mutex index 9ac1d27..1f4da57 100644 --- a/libstdc++-v3/include/std/mutex +++ b/libstdc++-v3/include/std/mutex @@ -41,7 +41,7 @@ #include #include #include -#include +#include #if ! _GTHREAD_USE_MUTEX_TIMEDLOCK # include # include