2011-05-25 Paolo Carlini <paolo.carlini@oracle.com>

	* include/std/thread: Use noexcept throughout per the FDIS.
	* include/std/mutex: Likewise.

git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@174202 138bc75d-0d04-0410-961f-82ee72b054a4

diff --git a/libstdc++-v3/ChangeLog b/libstdc++-v3/ChangeLog
index 75eb538..b823090 100644 (file)
--- a/libstdc++-v3/ChangeLog
+++ b/libstdc++-v3/ChangeLog
@@ -1,3 +1,8 @@
+2011-05-25  Paolo Carlini  <paolo.carlini@oracle.com>
+
+       * include/std/thread: Use noexcept throughout per the FDIS.
+       * include/std/mutex: Likewise.
+

 2011-05-24  Paolo Carlini  <paolo.carlini@oracle.com>
 
        * testsuite/20_util/duration/arithmetic/dr2020.cc: Fix typo.
 2011-05-24  Paolo Carlini  <paolo.carlini@oracle.com>
 
        * testsuite/20_util/duration/arithmetic/dr2020.cc: Fix typo.

diff --git a/libstdc++-v3/include/std/mutex b/libstdc++-v3/include/std/mutex
index 36f894e..de16cd3 100644 (file)
--- a/libstdc++-v3/include/std/mutex
+++ b/libstdc++-v3/include/std/mutex
@@ -1,6 +1,6 @@
 // <mutex> -*- C++ -*-
 
 // <mutex> -*- C++ -*-
 

-// Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
+// Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011

 // Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free


@@ -70,9 +70,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     typedef __native_type*                     native_handle_type;
 
 #ifdef __GTHREAD_MUTEX_INIT
     typedef __native_type*                     native_handle_type;
 
 #ifdef __GTHREAD_MUTEX_INIT

-    constexpr mutex() : _M_mutex(__GTHREAD_MUTEX_INIT) { }
+    constexpr mutex() noexcept : _M_mutex(__GTHREAD_MUTEX_INIT) { }

 #else
 #else

-    mutex()
+    mutex() noexcept

     {
       // XXX EAGAIN, ENOMEM, EPERM, EBUSY(may), EINVAL(may)
       __GTHREAD_MUTEX_INIT_FUNCTION(&_M_mutex);
     {
       // XXX EAGAIN, ENOMEM, EPERM, EBUSY(may), EINVAL(may)
       __GTHREAD_MUTEX_INIT_FUNCTION(&_M_mutex);


@@ -95,7 +95,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     }
 
     bool
     }
 
     bool

-    try_lock()
+    try_lock() noexcept

     {
       // XXX EINVAL, EAGAIN, EBUSY
       return !__gthread_mutex_trylock(&_M_mutex);
     {
       // XXX EINVAL, EAGAIN, EBUSY
       return !__gthread_mutex_trylock(&_M_mutex);


@@ -188,7 +188,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     }
 
     bool
     }
 
     bool

-    try_lock()
+    try_lock() noexcept

     {
       // XXX EINVAL, EAGAIN, EBUSY
       return !__gthread_recursive_mutex_trylock(&_M_mutex);
     {
       // XXX EINVAL, EAGAIN, EBUSY
       return !__gthread_recursive_mutex_trylock(&_M_mutex);


@@ -247,7 +247,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     }
 
     bool
     }
 
     bool

-    try_lock()
+    try_lock() noexcept

     {
       // XXX EINVAL, EAGAIN, EBUSY
       return !__gthread_mutex_trylock(&_M_mutex);
     {
       // XXX EINVAL, EAGAIN, EBUSY
       return !__gthread_mutex_trylock(&_M_mutex);


@@ -354,7 +354,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     }
 
     bool
     }
 
     bool

-    try_lock()
+    try_lock() noexcept

     {
       // XXX EINVAL, EAGAIN, EBUSY
       return !__gthread_recursive_mutex_trylock(&_M_mutex);
     {
       // XXX EINVAL, EAGAIN, EBUSY
       return !__gthread_recursive_mutex_trylock(&_M_mutex);


@@ -464,7 +464,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     public:
       typedef _Mutex mutex_type;
 
     public:
       typedef _Mutex mutex_type;
 

-      unique_lock()
+      unique_lock() noexcept

       : _M_device(0), _M_owns(false)
       { }
 
       : _M_device(0), _M_owns(false)
       { }
 


@@ -475,7 +475,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
        _M_owns = true;
       }
 
        _M_owns = true;
       }
 

-      unique_lock(mutex_type& __m, defer_lock_t)
+      unique_lock(mutex_type& __m, defer_lock_t) noexcept

       : _M_device(&__m), _M_owns(false)
       { }
 
       : _M_device(&__m), _M_owns(false)
       { }
 


@@ -510,14 +510,14 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       unique_lock(const unique_lock&) = delete;
       unique_lock& operator=(const unique_lock&) = delete;
 
       unique_lock(const unique_lock&) = delete;
       unique_lock& operator=(const unique_lock&) = delete;
 

-      unique_lock(unique_lock&& __u)
+      unique_lock(unique_lock&& __u) noexcept

       : _M_device(__u._M_device), _M_owns(__u._M_owns)
       {
        __u._M_device = 0;
        __u._M_owns = false;
       }
 
       : _M_device(__u._M_device), _M_owns(__u._M_owns)
       {
        __u._M_device = 0;
        __u._M_owns = false;
       }
 

-      unique_lock& operator=(unique_lock&& __u)
+      unique_lock& operator=(unique_lock&& __u) noexcept

       {
        if(_M_owns)
          unlock();
       {
        if(_M_owns)
          unlock();


@@ -601,14 +601,14 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       }
 
       void
       }
 
       void

-      swap(unique_lock& __u)
+      swap(unique_lock& __u) noexcept

       {
        std::swap(_M_device, __u._M_device);
        std::swap(_M_owns, __u._M_owns);
       }
 
       mutex_type*
       {
        std::swap(_M_device, __u._M_device);
        std::swap(_M_owns, __u._M_owns);
       }
 
       mutex_type*

-      release()
+      release() noexcept

       {
        mutex_type* __ret = _M_device;
        _M_device = 0;
       {
        mutex_type* __ret = _M_device;
        _M_device = 0;


@@ -617,14 +617,14 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       }
 
       bool
       }
 
       bool

-      owns_lock() const
+      owns_lock() const noexcept

       { return _M_owns; }
 
       { return _M_owns; }
 

-      explicit operator bool() const
+      explicit operator bool() const noexcept

       { return owns_lock(); }
 
       mutex_type*
       { return owns_lock(); }
 
       mutex_type*

-      mutex() const
+      mutex() const noexcept

       { return _M_device; }
 
     private:
       { return _M_device; }
 
     private:


@@ -634,7 +634,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
   template<typename _Mutex>
     inline void
 
   template<typename _Mutex>
     inline void

-    swap(unique_lock<_Mutex>& __x, unique_lock<_Mutex>& __y)
+    swap(unique_lock<_Mutex>& __x, unique_lock<_Mutex>& __y) noexcept

     { __x.swap(__y); }
 
   template<int _Idx>
     { __x.swap(__y); }
 
   template<int _Idx>


@@ -759,7 +759,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     __native_type  _M_once;
 
   public:
     __native_type  _M_once;
 
   public:

-    constexpr once_flag() : _M_once(__GTHREAD_ONCE_INIT) { }
+    constexpr once_flag() noexcept : _M_once(__GTHREAD_ONCE_INIT) { }

 
     once_flag(const once_flag&) = delete;
     once_flag& operator=(const once_flag&) = delete;
 
     once_flag(const once_flag&) = delete;
     once_flag& operator=(const once_flag&) = delete;

diff --git a/libstdc++-v3/include/std/thread b/libstdc++-v3/include/std/thread
index de58e81..4fa5e50 100644 (file)
--- a/libstdc++-v3/include/std/thread
+++ b/libstdc++-v3/include/std/thread
@@ -72,7 +72,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       native_handle_type       _M_thread;
 
     public:
       native_handle_type       _M_thread;
 
     public:

-      id() : _M_thread() { }
+      id() noexcept : _M_thread() { }

 
       explicit
       id(native_handle_type __id) : _M_thread(__id) { }
 
       explicit
       id(native_handle_type __id) : _M_thread(__id) { }


@@ -82,11 +82,11 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       friend class hash<thread::id>;
 
       friend bool
       friend class hash<thread::id>;
 
       friend bool

-      operator==(thread::id __x, thread::id __y)
+      operator==(thread::id __x, thread::id __y) noexcept

       { return __gthread_equal(__x._M_thread, __y._M_thread); }
 
       friend bool
       { return __gthread_equal(__x._M_thread, __y._M_thread); }
 
       friend bool

-      operator<(thread::id __x, thread::id __y)
+      operator<(thread::id __x, thread::id __y) noexcept

       { return __x._M_thread < __y._M_thread; }
 
       template<class _CharT, class _Traits>
       { return __x._M_thread < __y._M_thread; }
 
       template<class _CharT, class _Traits>


@@ -121,11 +121,11 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     id                         _M_id;
 
   public:
     id                         _M_id;
 
   public:

-    thread() = default;
+    thread() noexcept = default;

     thread(thread&) = delete;
     thread(const thread&) = delete;
 
     thread(thread&) = delete;
     thread(const thread&) = delete;
 

-    thread(thread&& __t)
+    thread(thread&& __t) noexcept

     { swap(__t); }
 
     template<typename _Callable, typename... _Args>
     { swap(__t); }
 
     template<typename _Callable, typename... _Args>


@@ -145,7 +145,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
     thread& operator=(const thread&) = delete;
 
 
     thread& operator=(const thread&) = delete;
 

-    thread& operator=(thread&& __t)
+    thread& operator=(thread&& __t) noexcept

     {
       if (joinable())
        std::terminate();
     {
       if (joinable())
        std::terminate();


@@ -154,11 +154,11 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     }
 
     void
     }
 
     void

-    swap(thread& __t)
+    swap(thread& __t) noexcept

     { std::swap(_M_id, __t._M_id); }
 
     bool
     { std::swap(_M_id, __t._M_id); }
 
     bool

-    joinable() const
+    joinable() const noexcept

     { return !(_M_id == id()); }
 
     void
     { return !(_M_id == id()); }
 
     void


@@ -168,7 +168,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     detach();
 
     thread::id
     detach();
 
     thread::id

-    get_id() const
+    get_id() const noexcept

     { return _M_id; }
 
     /** @pre thread is joinable
     { return _M_id; }
 
     /** @pre thread is joinable


@@ -179,7 +179,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
     // Returns a value that hints at the number of hardware thread contexts.
     static unsigned int
 
     // Returns a value that hints at the number of hardware thread contexts.
     static unsigned int

-    hardware_concurrency()
+    hardware_concurrency() noexcept

     { return 0; }
 
   private:
     { return 0; }
 
   private:


@@ -198,23 +198,23 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
   inline thread::_Impl_base::~_Impl_base() = default;
 
   inline void
   inline thread::_Impl_base::~_Impl_base() = default;
 
   inline void

-  swap(thread& __x, thread& __y)
+  swap(thread& __x, thread& __y) noexcept

   { __x.swap(__y); }
 
   inline bool
   { __x.swap(__y); }
 
   inline bool

-  operator!=(thread::id __x, thread::id __y)
+  operator!=(thread::id __x, thread::id __y) noexcept

   { return !(__x == __y); }
 
   inline bool
   { return !(__x == __y); }
 
   inline bool

-  operator<=(thread::id __x, thread::id __y)
+  operator<=(thread::id __x, thread::id __y) noexcept

   { return !(__y < __x); }
 
   inline bool
   { return !(__y < __x); }
 
   inline bool

-  operator>(thread::id __x, thread::id __y)
+  operator>(thread::id __x, thread::id __y) noexcept

   { return __y < __x; }
 
   inline bool
   { return __y < __x; }
 
   inline bool

-  operator>=(thread::id __x, thread::id __y)
+  operator>=(thread::id __x, thread::id __y) noexcept

   { return !(__x < __y); }
 
   // DR 889.
   { return !(__x < __y); }
 
   // DR 889.


@@ -250,12 +250,12 @@ _GLIBCXX_END_NAMESPACE_VERSION
 
     /// get_id
     inline thread::id
 
     /// get_id
     inline thread::id

-    get_id() { return thread::id(__gthread_self()); }
+    get_id() noexcept { return thread::id(__gthread_self()); }

 
 #ifdef _GLIBCXX_USE_SCHED_YIELD
     /// yield
     inline void
 
 #ifdef _GLIBCXX_USE_SCHED_YIELD
     /// yield
     inline void

-    yield()
+    yield() noexcept

     { __gthread_yield(); }
 #endif
 
     { __gthread_yield(); }
 #endif