2011-08-04 Paolo Carlini <paolo.carlini@oracle.com>

	* src/atomic.cc: Use noexcept.
	* include/std/atomic: Likewise.
	* include/bits/atomic_0.h: Likewise.
	* include/bits/atomic_2.h: Likewise.
	* include/bits/atomic_base.h: Likewise.


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

1 files changed, 205 insertions, 189 deletions

diff --git a/libstdc++-v3/include/std/atomic b/libstdc++-v3/include/std/atomic
index a19891dbdbc..b3fa7d8120b 100644
--- a/libstdc++-v3/include/std/atomic
+++ b/libstdc++-v3/include/std/atomic
@@ -59,92 +59,93 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     __atomic_base<bool>	_M_base;
 
   public:
-    atomic_bool() = default;
-    ~atomic_bool() = default;
+    atomic_bool() noexcept = default;
+    ~atomic_bool() noexcept = default;
     atomic_bool(const atomic_bool&) = delete;
     atomic_bool& operator=(const atomic_bool&) = delete;
     atomic_bool& operator=(const atomic_bool&) volatile = delete;
 
-    constexpr atomic_bool(bool __i) : _M_base(__i) { }
+    constexpr atomic_bool(bool __i) noexcept : _M_base(__i) { }
 
     bool
-    operator=(bool __i)
+    operator=(bool __i) noexcept
     { return _M_base.operator=(__i); }
 
-    operator bool() const
+    operator bool() const noexcept
     { return _M_base.load(); }
 
-    operator bool() const volatile
+    operator bool() const volatile noexcept
     { return _M_base.load(); }
 
     bool
-    is_lock_free() const { return _M_base.is_lock_free(); }
+    is_lock_free() const noexcept { return _M_base.is_lock_free(); }
 
     bool
-    is_lock_free() const volatile { return _M_base.is_lock_free(); }
+    is_lock_free() const volatile noexcept { return _M_base.is_lock_free(); }
 
     void
-    store(bool __i, memory_order __m = memory_order_seq_cst)
+    store(bool __i, memory_order __m = memory_order_seq_cst) noexcept
     { _M_base.store(__i, __m); }
 
     void
-    store(bool __i, memory_order __m = memory_order_seq_cst) volatile
+    store(bool __i, memory_order __m = memory_order_seq_cst) volatile noexcept
     { _M_base.store(__i, __m); }
 
     bool
-    load(memory_order __m = memory_order_seq_cst) const
+    load(memory_order __m = memory_order_seq_cst) const noexcept
     { return _M_base.load(__m); }
 
     bool
-    load(memory_order __m = memory_order_seq_cst) const volatile
+    load(memory_order __m = memory_order_seq_cst) const volatile noexcept
     { return _M_base.load(__m); }
 
     bool
-    exchange(bool __i, memory_order __m = memory_order_seq_cst)
+    exchange(bool __i, memory_order __m = memory_order_seq_cst) noexcept
     { return _M_base.exchange(__i, __m); }
 
     bool
-    exchange(bool __i, memory_order __m = memory_order_seq_cst) volatile
+    exchange(bool __i,
+	     memory_order __m = memory_order_seq_cst) volatile noexcept
     { return _M_base.exchange(__i, __m); }
 
     bool
     compare_exchange_weak(bool& __i1, bool __i2, memory_order __m1,
-			  memory_order __m2)
+			  memory_order __m2) noexcept
     { return _M_base.compare_exchange_weak(__i1, __i2, __m1, __m2); }
 
     bool
     compare_exchange_weak(bool& __i1, bool __i2, memory_order __m1,
-			  memory_order __m2) volatile
+			  memory_order __m2) volatile noexcept
     { return _M_base.compare_exchange_weak(__i1, __i2, __m1, __m2); }
 
     bool
     compare_exchange_weak(bool& __i1, bool __i2,
-			  memory_order __m = memory_order_seq_cst)
+			  memory_order __m = memory_order_seq_cst) noexcept
     { return _M_base.compare_exchange_weak(__i1, __i2, __m); }
 
     bool
     compare_exchange_weak(bool& __i1, bool __i2,
-			  memory_order __m = memory_order_seq_cst) volatile
+		     memory_order __m = memory_order_seq_cst) volatile noexcept
     { return _M_base.compare_exchange_weak(__i1, __i2, __m); }
 
     bool
     compare_exchange_strong(bool& __i1, bool __i2, memory_order __m1,
-			    memory_order __m2)
+			    memory_order __m2) noexcept
     { return _M_base.compare_exchange_strong(__i1, __i2, __m1, __m2); }
 
     bool
     compare_exchange_strong(bool& __i1, bool __i2, memory_order __m1,
-			    memory_order __m2) volatile
+			    memory_order __m2) volatile noexcept
     { return _M_base.compare_exchange_strong(__i1, __i2, __m1, __m2); }
 
     bool
     compare_exchange_strong(bool& __i1, bool __i2,
-			    memory_order __m = memory_order_seq_cst)
+			    memory_order __m = memory_order_seq_cst) noexcept
     { return _M_base.compare_exchange_strong(__i1, __i2, __m); }
 
     bool
     compare_exchange_strong(bool& __i1, bool __i2,
-			    memory_order __m = memory_order_seq_cst) volatile
+		    memory_order __m = memory_order_seq_cst) volatile noexcept
     { return _M_base.compare_exchange_strong(__i1, __i2, __m); }
   };
 
@@ -158,73 +159,77 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       _Tp _M_i;
 
     public:
-      atomic() = default;
-      ~atomic() = default;
+      atomic() noexcept = default;
+      ~atomic() noexcept = default;
       atomic(const atomic&) = delete;
       atomic& operator=(const atomic&) = delete;
       atomic& operator=(const atomic&) volatile = delete;
 
-      constexpr atomic(_Tp __i) : _M_i(__i) { }
+      constexpr atomic(_Tp __i) noexcept : _M_i(__i) { }
 
-      operator _Tp() const;
+      operator _Tp() const noexcept;
 
-      operator _Tp() const volatile;
+      operator _Tp() const volatile noexcept;
 
       _Tp
-      operator=(_Tp __i) { store(__i); return __i; }
+      operator=(_Tp __i) noexcept { store(__i); return __i; }
 
       _Tp
-      operator=(_Tp __i) volatile { store(__i); return __i; }
+      operator=(_Tp __i) volatile noexcept { store(__i); return __i; }
 
       bool
-      is_lock_free() const;
+      is_lock_free() const noexcept;
 
       bool
-      is_lock_free() const volatile;
+      is_lock_free() const volatile noexcept;
 
       void
-      store(_Tp, memory_order = memory_order_seq_cst);
+      store(_Tp, memory_order = memory_order_seq_cst) noexcept;
 
       void
-      store(_Tp, memory_order = memory_order_seq_cst) volatile;
+      store(_Tp, memory_order = memory_order_seq_cst) volatile noexcept;
 
       _Tp
-      load(memory_order = memory_order_seq_cst) const;
+      load(memory_order = memory_order_seq_cst) const noexcept;
 
       _Tp
-      load(memory_order = memory_order_seq_cst) const volatile;
+      load(memory_order = memory_order_seq_cst) const volatile noexcept;
 
       _Tp
-      exchange(_Tp __i, memory_order = memory_order_seq_cst);
+      exchange(_Tp __i, memory_order = memory_order_seq_cst) noexcept;
 
       _Tp
-      exchange(_Tp __i, memory_order = memory_order_seq_cst) volatile;
+      exchange(_Tp __i, memory_order = memory_order_seq_cst) volatile noexcept;
 
       bool
-      compare_exchange_weak(_Tp&, _Tp, memory_order, memory_order);
+      compare_exchange_weak(_Tp&, _Tp, memory_order, memory_order) noexcept;
 
       bool
-      compare_exchange_weak(_Tp&, _Tp, memory_order, memory_order) volatile;
+      compare_exchange_weak(_Tp&, _Tp, memory_order,
+			    memory_order) volatile noexcept;
 
       bool
-      compare_exchange_weak(_Tp&, _Tp, memory_order = memory_order_seq_cst);
+      compare_exchange_weak(_Tp&, _Tp,
+			    memory_order = memory_order_seq_cst) noexcept;
 
       bool
       compare_exchange_weak(_Tp&, _Tp,
-			    memory_order = memory_order_seq_cst) volatile;
+		       memory_order = memory_order_seq_cst) volatile noexcept;
 
       bool
-      compare_exchange_strong(_Tp&, _Tp, memory_order, memory_order);
+      compare_exchange_strong(_Tp&, _Tp, memory_order, memory_order) noexcept;
 
       bool
-      compare_exchange_strong(_Tp&, _Tp, memory_order, memory_order) volatile;
+      compare_exchange_strong(_Tp&, _Tp, memory_order,
+			      memory_order) volatile noexcept;
 
       bool
-      compare_exchange_strong(_Tp&, _Tp, memory_order = memory_order_seq_cst);
+      compare_exchange_strong(_Tp&, _Tp,
+			      memory_order = memory_order_seq_cst) noexcept;
 
       bool
       compare_exchange_strong(_Tp&, _Tp,
-			      memory_order = memory_order_seq_cst) volatile;
+		       memory_order = memory_order_seq_cst) volatile noexcept;
     };
 
 
@@ -236,123 +241,126 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       typedef __atomic_base<_Tp*>	__base_type;
       __base_type			_M_b;
 
-      atomic() = default;
-      ~atomic() = default;
+      atomic() noexcept = default;
+      ~atomic() noexcept = default;
       atomic(const atomic&) = delete;
       atomic& operator=(const atomic&) = delete;
       atomic& operator=(const atomic&) volatile = delete;
 
-      constexpr atomic(__pointer_type __p) : _M_b(__p) { }
+      constexpr atomic(__pointer_type __p) noexcept : _M_b(__p) { }
 
-      operator __pointer_type() const
+      operator __pointer_type() const noexcept
       { return __pointer_type(_M_b); }
 
-      operator __pointer_type() const volatile
+      operator __pointer_type() const volatile noexcept
       { return __pointer_type(_M_b); }
 
       __pointer_type
-      operator=(__pointer_type __p)
+      operator=(__pointer_type __p) noexcept
       { return _M_b.operator=(__p); }
 
       __pointer_type
-      operator=(__pointer_type __p) volatile
+      operator=(__pointer_type __p) volatile noexcept
       { return _M_b.operator=(__p); }
 
       __pointer_type
-      operator++(int)
+      operator++(int) noexcept
       { return _M_b++; }
 
       __pointer_type
-      operator++(int) volatile
+      operator++(int) volatile noexcept
       { return _M_b++; }
 
       __pointer_type
-      operator--(int)
+      operator--(int) noexcept
       { return _M_b--; }
 
       __pointer_type
-      operator--(int) volatile
+      operator--(int) volatile noexcept
       { return _M_b--; }
 
       __pointer_type
-      operator++()
+      operator++() noexcept
       { return ++_M_b; }
 
       __pointer_type
-      operator++() volatile
+      operator++() volatile noexcept
       { return ++_M_b; }
 
       __pointer_type
-      operator--()
+      operator--() noexcept
       { return --_M_b; }
 
       __pointer_type
-      operator--() volatile
+      operator--() volatile noexcept
       { return --_M_b; }
 
       __pointer_type
-      operator+=(ptrdiff_t __d)
+      operator+=(ptrdiff_t __d) noexcept
       { return _M_b.operator+=(__d); }
 
       __pointer_type
-      operator+=(ptrdiff_t __d) volatile
+      operator+=(ptrdiff_t __d) volatile noexcept
       { return _M_b.operator+=(__d); }
 
       __pointer_type
-      operator-=(ptrdiff_t __d)
+      operator-=(ptrdiff_t __d) noexcept
       { return _M_b.operator-=(__d); }
 
       __pointer_type
-      operator-=(ptrdiff_t __d) volatile
+      operator-=(ptrdiff_t __d) volatile noexcept
       { return _M_b.operator-=(__d); }
 
       bool
-      is_lock_free() const
+      is_lock_free() const noexcept
       { return _M_b.is_lock_free(); }
 
       bool
-      is_lock_free() const volatile
+      is_lock_free() const volatile noexcept
       { return _M_b.is_lock_free(); }
 
       void
-      store(__pointer_type __p, memory_order __m = memory_order_seq_cst)
+      store(__pointer_type __p,
+	    memory_order __m = memory_order_seq_cst) noexcept
       { return _M_b.store(__p, __m); }
 
       void
       store(__pointer_type __p,
-	    memory_order __m = memory_order_seq_cst) volatile
+	    memory_order __m = memory_order_seq_cst) volatile noexcept
       { return _M_b.store(__p, __m); }
 
       __pointer_type
-      load(memory_order __m = memory_order_seq_cst) const
+      load(memory_order __m = memory_order_seq_cst) const noexcept
       { return _M_b.load(__m); }
 
       __pointer_type
-      load(memory_order __m = memory_order_seq_cst) const volatile
+      load(memory_order __m = memory_order_seq_cst) const volatile noexcept
       { return _M_b.load(__m); }
 
       __pointer_type
-      exchange(__pointer_type __p, memory_order __m = memory_order_seq_cst)
+      exchange(__pointer_type __p,
+	       memory_order __m = memory_order_seq_cst) noexcept
       { return _M_b.exchange(__p, __m); }
 
       __pointer_type
       exchange(__pointer_type __p,
-	       memory_order __m = memory_order_seq_cst) volatile
+	       memory_order __m = memory_order_seq_cst) volatile noexcept
       { return _M_b.exchange(__p, __m); }
 
       bool
       compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2,
-			    memory_order __m1, memory_order __m2)
+			    memory_order __m1, memory_order __m2) noexcept
       { return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); }
 
       bool
       compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2,
-			    memory_order __m1, memory_order __m2) volatile
+			    memory_order __m1,
+			    memory_order __m2) volatile noexcept
       { return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); }
 
       bool
       compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2,
-			    memory_order __m = memory_order_seq_cst)
+			    memory_order __m = memory_order_seq_cst) noexcept
       {
 	return compare_exchange_weak(__p1, __p2, __m,
 				     __calculate_memory_order(__m));
@@ -360,7 +368,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
       bool
       compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2,
-			    memory_order __m = memory_order_seq_cst) volatile
+		    memory_order __m = memory_order_seq_cst) volatile noexcept
       {
 	return compare_exchange_weak(__p1, __p2, __m,
 				     __calculate_memory_order(__m));
@@ -368,17 +376,18 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
       bool
       compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
-			      memory_order __m1, memory_order __m2)
+			      memory_order __m1, memory_order __m2) noexcept
       { return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); }
 
       bool
       compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
-			      memory_order __m1, memory_order __m2) volatile
+			      memory_order __m1,
+			      memory_order __m2) volatile noexcept
       { return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); }
 
       bool
       compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
-			      memory_order __m = memory_order_seq_cst)
+			      memory_order __m = memory_order_seq_cst) noexcept
       {
 	return _M_b.compare_exchange_strong(__p1, __p2, __m,
 					    __calculate_memory_order(__m));
@@ -386,28 +395,30 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
       bool
       compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
-			      memory_order __m = memory_order_seq_cst) volatile
+		    memory_order __m = memory_order_seq_cst) volatile noexcept
       {
 	return _M_b.compare_exchange_strong(__p1, __p2, __m,
 					    __calculate_memory_order(__m));
       }
 
       __pointer_type
-      fetch_add(ptrdiff_t __d, memory_order __m = memory_order_seq_cst)
+      fetch_add(ptrdiff_t __d,
+		memory_order __m = memory_order_seq_cst) noexcept
       { return _M_b.fetch_add(__d, __m); }
 
       __pointer_type
       fetch_add(ptrdiff_t __d,
-		memory_order __m = memory_order_seq_cst) volatile
+		memory_order __m = memory_order_seq_cst) volatile noexcept
       { return _M_b.fetch_add(__d, __m); }
 
       __pointer_type
-      fetch_sub(ptrdiff_t __d, memory_order __m = memory_order_seq_cst)
+      fetch_sub(ptrdiff_t __d,
+		memory_order __m = memory_order_seq_cst) noexcept
       { return _M_b.fetch_sub(__d, __m); }
 
       __pointer_type
       fetch_sub(ptrdiff_t __d,
-		memory_order __m = memory_order_seq_cst) volatile
+		memory_order __m = memory_order_seq_cst) volatile noexcept
       { return _M_b.fetch_sub(__d, __m); }
     };
 
@@ -419,13 +430,13 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       typedef bool 			__integral_type;
       typedef atomic_bool 		__base_type;
 
-      atomic() = default;
-      ~atomic() = default;
+      atomic() noexcept = default;
+      ~atomic() noexcept = default;
       atomic(const atomic&) = delete;
       atomic& operator=(const atomic&) = delete;
       atomic& operator=(const atomic&) volatile = delete;
 
-      constexpr atomic(__integral_type __i) : __base_type(__i) { }
+      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
 
       using __base_type::operator __integral_type;
       using __base_type::operator=;
@@ -438,13 +449,13 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       typedef char 			__integral_type;
       typedef atomic_char 		__base_type;
 
-      atomic() = default;
-      ~atomic() = default;
+      atomic() noexcept = default;
+      ~atomic() noexcept = default;
       atomic(const atomic&) = delete;
       atomic& operator=(const atomic&) = delete;
       atomic& operator=(const atomic&) volatile = delete;
 
-      constexpr atomic(__integral_type __i) : __base_type(__i) { }
+      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
 
       using __base_type::operator __integral_type;
       using __base_type::operator=;
@@ -457,13 +468,13 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       typedef signed char 		__integral_type;
       typedef atomic_schar 		__base_type;
 
-      atomic() = default;
-      ~atomic() = default;
+      atomic() noexcept= default;
+      ~atomic() noexcept = default;
       atomic(const atomic&) = delete;
       atomic& operator=(const atomic&) = delete;
       atomic& operator=(const atomic&) volatile = delete;
 
-      constexpr atomic(__integral_type __i) : __base_type(__i) { }
+      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
 
       using __base_type::operator __integral_type;
       using __base_type::operator=;
@@ -476,13 +487,13 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       typedef unsigned char 		__integral_type;
       typedef atomic_uchar 		__base_type;
 
-      atomic() = default;
-      ~atomic() = default;
+      atomic() noexcept= default;
+      ~atomic() noexcept = default;
       atomic(const atomic&) = delete;
       atomic& operator=(const atomic&) = delete;
       atomic& operator=(const atomic&) volatile = delete;
 
-      constexpr atomic(__integral_type __i) : __base_type(__i) { }
+      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
 
       using __base_type::operator __integral_type;
       using __base_type::operator=;
@@ -495,13 +506,13 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       typedef short 			__integral_type;
       typedef atomic_short 		__base_type;
 
-      atomic() = default;
-      ~atomic() = default;
+      atomic() noexcept = default;
+      ~atomic() noexcept = default;
       atomic(const atomic&) = delete;
       atomic& operator=(const atomic&) = delete;
       atomic& operator=(const atomic&) volatile = delete;
 
-      constexpr atomic(__integral_type __i) : __base_type(__i) { }
+      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
 
       using __base_type::operator __integral_type;
       using __base_type::operator=;
@@ -514,13 +525,13 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       typedef unsigned short 	      	__integral_type;
       typedef atomic_ushort 		__base_type;
 
-      atomic() = default;
-      ~atomic() = default;
+      atomic() noexcept = default;
+      ~atomic() noexcept = default;
       atomic(const atomic&) = delete;
       atomic& operator=(const atomic&) = delete;
       atomic& operator=(const atomic&) volatile = delete;
 
-      constexpr atomic(__integral_type __i) : __base_type(__i) { }
+      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
 
       using __base_type::operator __integral_type;
       using __base_type::operator=;
@@ -533,13 +544,13 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       typedef int 			__integral_type;
       typedef atomic_int 		__base_type;
 
-      atomic() = default;
-      ~atomic() = default;
+      atomic() noexcept = default;
+      ~atomic() noexcept = default;
       atomic(const atomic&) = delete;
       atomic& operator=(const atomic&) = delete;
       atomic& operator=(const atomic&) volatile = delete;
 
-      constexpr atomic(__integral_type __i) : __base_type(__i) { }
+      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
 
       using __base_type::operator __integral_type;
       using __base_type::operator=;
@@ -552,13 +563,13 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       typedef unsigned int		__integral_type;
       typedef atomic_uint 		__base_type;
 
-      atomic() = default;
-      ~atomic() = default;
+      atomic() noexcept = default;
+      ~atomic() noexcept = default;
       atomic(const atomic&) = delete;
       atomic& operator=(const atomic&) = delete;
       atomic& operator=(const atomic&) volatile = delete;
 
-      constexpr atomic(__integral_type __i) : __base_type(__i) { }
+      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
 
       using __base_type::operator __integral_type;
       using __base_type::operator=;
@@ -571,13 +582,13 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       typedef long 			__integral_type;
       typedef atomic_long 		__base_type;
 
-      atomic() = default;
-      ~atomic() = default;
+      atomic() noexcept = default;
+      ~atomic() noexcept = default;
       atomic(const atomic&) = delete;
       atomic& operator=(const atomic&) = delete;
       atomic& operator=(const atomic&) volatile = delete;
 
-      constexpr atomic(__integral_type __i) : __base_type(__i) { }
+      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
 
       using __base_type::operator __integral_type;
       using __base_type::operator=;
@@ -590,13 +601,13 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       typedef unsigned long 		__integral_type;
       typedef atomic_ulong 		__base_type;
 
-      atomic() = default;
-      ~atomic() = default;
+      atomic() noexcept = default;
+      ~atomic() noexcept = default;
       atomic(const atomic&) = delete;
       atomic& operator=(const atomic&) = delete;
       atomic& operator=(const atomic&) volatile = delete;
 
-      constexpr atomic(__integral_type __i) : __base_type(__i) { }
+      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
 
       using __base_type::operator __integral_type;
       using __base_type::operator=;
@@ -609,13 +620,13 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       typedef long long 		__integral_type;
       typedef atomic_llong 		__base_type;
 
-      atomic() = default;
-      ~atomic() = default;
+      atomic() noexcept = default;
+      ~atomic() noexcept = default;
       atomic(const atomic&) = delete;
       atomic& operator=(const atomic&) = delete;
       atomic& operator=(const atomic&) volatile = delete;
 
-      constexpr atomic(__integral_type __i) : __base_type(__i) { }
+      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
 
       using __base_type::operator __integral_type;
       using __base_type::operator=;
@@ -628,13 +639,13 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       typedef unsigned long long       	__integral_type;
       typedef atomic_ullong 		__base_type;
 
-      atomic() = default;
-      ~atomic() = default;
+      atomic() noexcept = default;
+      ~atomic() noexcept = default;
       atomic(const atomic&) = delete;
       atomic& operator=(const atomic&) = delete;
       atomic& operator=(const atomic&) volatile = delete;
 
-      constexpr atomic(__integral_type __i) : __base_type(__i) { }
+      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
 
       using __base_type::operator __integral_type;
       using __base_type::operator=;
@@ -647,13 +658,13 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       typedef wchar_t 			__integral_type;
       typedef atomic_wchar_t 		__base_type;
 
-      atomic() = default;
-      ~atomic() = default;
+      atomic() noexcept = default;
+      ~atomic() noexcept = default;
       atomic(const atomic&) = delete;
       atomic& operator=(const atomic&) = delete;
       atomic& operator=(const atomic&) volatile = delete;
 
-      constexpr atomic(__integral_type __i) : __base_type(__i) { }
+      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
 
       using __base_type::operator __integral_type;
       using __base_type::operator=;
@@ -666,13 +677,13 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       typedef char16_t 			__integral_type;
       typedef atomic_char16_t 		__base_type;
 
-      atomic() = default;
-      ~atomic() = default;
+      atomic() noexcept = default;
+      ~atomic() noexcept = default;
       atomic(const atomic&) = delete;
       atomic& operator=(const atomic&) = delete;
       atomic& operator=(const atomic&) volatile = delete;
 
-      constexpr atomic(__integral_type __i) : __base_type(__i) { }
+      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
 
       using __base_type::operator __integral_type;
       using __base_type::operator=;
@@ -685,13 +696,13 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       typedef char32_t 			__integral_type;
       typedef atomic_char32_t 		__base_type;
 
-      atomic() = default;
-      ~atomic() = default;
+      atomic() noexcept = default;
+      ~atomic() noexcept = default;
       atomic(const atomic&) = delete;
       atomic& operator=(const atomic&) = delete;
       atomic& operator=(const atomic&) volatile = delete;
 
-      constexpr atomic(__integral_type __i) : __base_type(__i) { }
+      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
 
       using __base_type::operator __integral_type;
       using __base_type::operator=;
@@ -700,104 +711,109 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
   // Function definitions, atomic_flag operations.
   inline bool
-  atomic_flag_test_and_set_explicit(atomic_flag* __a, memory_order __m)
+  atomic_flag_test_and_set_explicit(atomic_flag* __a,
+				    memory_order __m) noexcept
   { return __a->test_and_set(__m); }
 
   inline bool
   atomic_flag_test_and_set_explicit(volatile atomic_flag* __a,
-				    memory_order __m)
+				    memory_order __m) noexcept
   { return __a->test_and_set(__m); }
 
   inline void
-  atomic_flag_clear_explicit(atomic_flag* __a, memory_order __m)
+  atomic_flag_clear_explicit(atomic_flag* __a, memory_order __m) noexcept
   { __a->clear(__m); }
 
   inline void
-  atomic_flag_clear_explicit(volatile atomic_flag* __a, memory_order __m)
+  atomic_flag_clear_explicit(volatile atomic_flag* __a,
+			     memory_order __m) noexcept
   { __a->clear(__m); }
 
   inline bool
-  atomic_flag_test_and_set(atomic_flag* __a)
+  atomic_flag_test_and_set(atomic_flag* __a) noexcept
   { return atomic_flag_test_and_set_explicit(__a, memory_order_seq_cst); }
 
   inline bool
-  atomic_flag_test_and_set(volatile atomic_flag* __a)
+  atomic_flag_test_and_set(volatile atomic_flag* __a) noexcept
   { return atomic_flag_test_and_set_explicit(__a, memory_order_seq_cst); }
 
   inline void
-  atomic_flag_clear(atomic_flag* __a)
+  atomic_flag_clear(atomic_flag* __a) noexcept
   { atomic_flag_clear_explicit(__a, memory_order_seq_cst); }
 
   inline void
-  atomic_flag_clear(volatile atomic_flag* __a)
+  atomic_flag_clear(volatile atomic_flag* __a) noexcept
   { atomic_flag_clear_explicit(__a, memory_order_seq_cst); }
 
 
   // Function templates generally applicable to atomic types.
   template<typename _ITp>
     inline bool
-    atomic_is_lock_free(const atomic<_ITp>* __a)
+    atomic_is_lock_free(const atomic<_ITp>* __a) noexcept
     { return __a->is_lock_free(); }
 
   template<typename _ITp>
     inline bool
-    atomic_is_lock_free(const volatile atomic<_ITp>* __a)
+    atomic_is_lock_free(const volatile atomic<_ITp>* __a) noexcept
     { return __a->is_lock_free(); }
 
   template<typename _ITp>
     inline void
-    atomic_init(atomic<_ITp>* __a, _ITp __i);
+    atomic_init(atomic<_ITp>* __a, _ITp __i) noexcept;
 
   template<typename _ITp>
     inline void
-    atomic_init(volatile atomic<_ITp>* __a, _ITp __i);
+    atomic_init(volatile atomic<_ITp>* __a, _ITp __i) noexcept;
 
   template<typename _ITp>
     inline void
-    atomic_store_explicit(atomic<_ITp>* __a, _ITp __i, memory_order __m)
+    atomic_store_explicit(atomic<_ITp>* __a, _ITp __i,
+			  memory_order __m) noexcept
     { __a->store(__i, __m); }
 
   template<typename _ITp>
     inline void
     atomic_store_explicit(volatile atomic<_ITp>* __a, _ITp __i,
-			  memory_order __m)
+			  memory_order __m) noexcept
     { __a->store(__i, __m); }
 
   template<typename _ITp>
     inline _ITp
-    atomic_load_explicit(const atomic<_ITp>* __a, memory_order __m)
+    atomic_load_explicit(const atomic<_ITp>* __a, memory_order __m) noexcept
     { return __a->load(__m); }
 
   template<typename _ITp>
     inline _ITp
     atomic_load_explicit(const volatile atomic<_ITp>* __a,
-			 memory_order __m)
+			 memory_order __m) noexcept
     { return __a->load(__m); }
 
   template<typename _ITp>
     inline _ITp
     atomic_exchange_explicit(atomic<_ITp>* __a, _ITp __i,
-			     memory_order __m)
+			     memory_order __m) noexcept
     { return __a->exchange(__i, __m); }
 
   template<typename _ITp>
     inline _ITp
     atomic_exchange_explicit(volatile atomic<_ITp>* __a, _ITp __i,
-			     memory_order __m)
+			     memory_order __m) noexcept
     { return __a->exchange(__i, __m); }
 
   template<typename _ITp>
     inline bool
     atomic_compare_exchange_weak_explicit(atomic<_ITp>* __a,
 					  _ITp* __i1, _ITp __i2,
-					  memory_order __m1, memory_order __m2)
+					  memory_order __m1,
+					  memory_order __m2) noexcept
     { return __a->compare_exchange_weak(*__i1, __i2, __m1, __m2); }
 
   template<typename _ITp>
     inline bool
     atomic_compare_exchange_weak_explicit(volatile atomic<_ITp>* __a,
 					  _ITp* __i1, _ITp __i2,
-					  memory_order __m1, memory_order __m2)
+					  memory_order __m1,
+					  memory_order __m2) noexcept
     { return __a->compare_exchange_weak(*__i1, __i2, __m1, __m2); }
 
   template<typename _ITp>
@@ -805,7 +821,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     atomic_compare_exchange_strong_explicit(atomic<_ITp>* __a,
 					    _ITp* __i1, _ITp __i2,
 					    memory_order __m1,
-					    memory_order __m2)
+					    memory_order __m2) noexcept
     { return __a->compare_exchange_strong(*__i1, __i2, __m1, __m2); }
 
   template<typename _ITp>
@@ -813,44 +829,44 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     atomic_compare_exchange_strong_explicit(volatile atomic<_ITp>* __a,
 					    _ITp* __i1, _ITp __i2,
 					    memory_order __m1,
-					    memory_order __m2)
+					    memory_order __m2) noexcept
     { return __a->compare_exchange_strong(*__i1, __i2, __m1, __m2); }
 
 
   template<typename _ITp>
     inline void
-    atomic_store(atomic<_ITp>* __a, _ITp __i)
+    atomic_store(atomic<_ITp>* __a, _ITp __i) noexcept
     { atomic_store_explicit(__a, __i, memory_order_seq_cst); }
 
   template<typename _ITp>
     inline void
-    atomic_store(volatile atomic<_ITp>* __a, _ITp __i)
+    atomic_store(volatile atomic<_ITp>* __a, _ITp __i) noexcept
     { atomic_store_explicit(__a, __i, memory_order_seq_cst); }
 
   template<typename _ITp>
     inline _ITp
-    atomic_load(const atomic<_ITp>* __a)
+    atomic_load(const atomic<_ITp>* __a) noexcept
     { return atomic_load_explicit(__a, memory_order_seq_cst); }
 
   template<typename _ITp>
     inline _ITp
-    atomic_load(const volatile atomic<_ITp>* __a)
+    atomic_load(const volatile atomic<_ITp>* __a) noexcept
     { return atomic_load_explicit(__a, memory_order_seq_cst); }
 
   template<typename _ITp>
     inline _ITp
-    atomic_exchange(atomic<_ITp>* __a, _ITp __i)
+    atomic_exchange(atomic<_ITp>* __a, _ITp __i) noexcept
     { return atomic_exchange_explicit(__a, __i, memory_order_seq_cst); }
 
   template<typename _ITp>
     inline _ITp
-    atomic_exchange(volatile atomic<_ITp>* __a, _ITp __i)
+    atomic_exchange(volatile atomic<_ITp>* __a, _ITp __i) noexcept
     { return atomic_exchange_explicit(__a, __i, memory_order_seq_cst); }
 
   template<typename _ITp>
     inline bool
     atomic_compare_exchange_weak(atomic<_ITp>* __a,
-				 _ITp* __i1, _ITp __i2)
+				 _ITp* __i1, _ITp __i2) noexcept
     {
       return atomic_compare_exchange_weak_explicit(__a, __i1, __i2,
 						   memory_order_seq_cst,
@@ -860,7 +876,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
   template<typename _ITp>
     inline bool
     atomic_compare_exchange_weak(volatile atomic<_ITp>* __a,
-				 _ITp* __i1, _ITp __i2)
+				 _ITp* __i1, _ITp __i2) noexcept
     {
       return atomic_compare_exchange_weak_explicit(__a, __i1, __i2,
 						   memory_order_seq_cst,
@@ -870,7 +886,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
   template<typename _ITp>
     inline bool
     atomic_compare_exchange_strong(atomic<_ITp>* __a,
-				   _ITp* __i1, _ITp __i2)
+				   _ITp* __i1, _ITp __i2) noexcept
     {
       return atomic_compare_exchange_strong_explicit(__a, __i1, __i2,
 						     memory_order_seq_cst,
@@ -880,7 +896,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
   template<typename _ITp>
     inline bool
     atomic_compare_exchange_strong(volatile atomic<_ITp>* __a,
-				   _ITp* __i1, _ITp __i2)
+				   _ITp* __i1, _ITp __i2) noexcept
     {
       return atomic_compare_exchange_strong_explicit(__a, __i1, __i2,
 						     memory_order_seq_cst,
@@ -894,111 +910,111 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
   template<typename _ITp>
     inline _ITp
     atomic_fetch_add_explicit(__atomic_base<_ITp>* __a, _ITp __i,
-			      memory_order __m)
+			      memory_order __m) noexcept
     { return __a->fetch_add(__i, __m); }
 
   template<typename _ITp>
     inline _ITp
     atomic_fetch_add_explicit(volatile __atomic_base<_ITp>* __a, _ITp __i,
-			      memory_order __m)
+			      memory_order __m) noexcept
     { return __a->fetch_add(__i, __m); }
 
   template<typename _ITp>
     inline _ITp
     atomic_fetch_sub_explicit(__atomic_base<_ITp>* __a, _ITp __i,
-			      memory_order __m)
+			      memory_order __m) noexcept
     { return __a->fetch_sub(__i, __m); }
 
   template<typename _ITp>
     inline _ITp
     atomic_fetch_sub_explicit(volatile __atomic_base<_ITp>* __a, _ITp __i,
-			      memory_order __m)
+			      memory_order __m) noexcept
     { return __a->fetch_sub(__i, __m); }
 
   template<typename _ITp>
     inline _ITp
     atomic_fetch_and_explicit(__atomic_base<_ITp>* __a, _ITp __i,
-			      memory_order __m)
+			      memory_order __m) noexcept
     { return __a->fetch_and(__i, __m); }
 
   template<typename _ITp>
     inline _ITp
     atomic_fetch_and_explicit(volatile __atomic_base<_ITp>* __a, _ITp __i,
-			      memory_order __m)
+			      memory_order __m) noexcept
     { return __a->fetch_and(__i, __m); }
 
   template<typename _ITp>
     inline _ITp
     atomic_fetch_or_explicit(__atomic_base<_ITp>* __a, _ITp __i,
-			     memory_order __m)
+			     memory_order __m) noexcept
     { return __a->fetch_or(__i, __m); }
 
   template<typename _ITp>
     inline _ITp
     atomic_fetch_or_explicit(volatile __atomic_base<_ITp>* __a, _ITp __i,
-			     memory_order __m)
+			     memory_order __m) noexcept
     { return __a->fetch_or(__i, __m); }
 
   template<typename _ITp>
     inline _ITp
     atomic_fetch_xor_explicit(__atomic_base<_ITp>* __a, _ITp __i,
-			      memory_order __m)
+			      memory_order __m) noexcept
     { return __a->fetch_xor(__i, __m); }
 
   template<typename _ITp>
     inline _ITp
     atomic_fetch_xor_explicit(volatile __atomic_base<_ITp>* __a, _ITp __i,
-			      memory_order __m)
+			      memory_order __m) noexcept
     { return __a->fetch_xor(__i, __m); }
 
   template<typename _ITp>
     inline _ITp
-    atomic_fetch_add(__atomic_base<_ITp>* __a, _ITp __i)
+    atomic_fetch_add(__atomic_base<_ITp>* __a, _ITp __i) noexcept
     { return atomic_fetch_add_explicit(__a, __i, memory_order_seq_cst); }
 
   template<typename _ITp>
     inline _ITp
-    atomic_fetch_add(volatile __atomic_base<_ITp>* __a, _ITp __i)
+    atomic_fetch_add(volatile __atomic_base<_ITp>* __a, _ITp __i) noexcept
     { return atomic_fetch_add_explicit(__a, __i, memory_order_seq_cst); }
 
   template<typename _ITp>
     inline _ITp
-    atomic_fetch_sub(__atomic_base<_ITp>* __a, _ITp __i)
+    atomic_fetch_sub(__atomic_base<_ITp>* __a, _ITp __i) noexcept
     { return atomic_fetch_sub_explicit(__a, __i, memory_order_seq_cst); }
 
   template<typename _ITp>
     inline _ITp
-    atomic_fetch_sub(volatile __atomic_base<_ITp>* __a, _ITp __i)
+    atomic_fetch_sub(volatile __atomic_base<_ITp>* __a, _ITp __i) noexcept
     { return atomic_fetch_sub_explicit(__a, __i, memory_order_seq_cst); }
 
   template<typename _ITp>
     inline _ITp
-    atomic_fetch_and(__atomic_base<_ITp>* __a, _ITp __i)
+    atomic_fetch_and(__atomic_base<_ITp>* __a, _ITp __i) noexcept
     { return atomic_fetch_and_explicit(__a, __i, memory_order_seq_cst); }
 
   template<typename _ITp>
     inline _ITp
-    atomic_fetch_and(volatile __atomic_base<_ITp>* __a, _ITp __i)
+    atomic_fetch_and(volatile __atomic_base<_ITp>* __a, _ITp __i) noexcept
     { return atomic_fetch_and_explicit(__a, __i, memory_order_seq_cst); }
 
   template<typename _ITp>
     inline _ITp
-    atomic_fetch_or(__atomic_base<_ITp>* __a, _ITp __i)
+    atomic_fetch_or(__atomic_base<_ITp>* __a, _ITp __i) noexcept
     { return atomic_fetch_or_explicit(__a, __i, memory_order_seq_cst); }
 
   template<typename _ITp>
     inline _ITp
-    atomic_fetch_or(volatile __atomic_base<_ITp>* __a, _ITp __i)
+    atomic_fetch_or(volatile __atomic_base<_ITp>* __a, _ITp __i) noexcept
     { return atomic_fetch_or_explicit(__a, __i, memory_order_seq_cst); }
 
   template<typename _ITp>
     inline _ITp
-    atomic_fetch_xor(__atomic_base<_ITp>* __a, _ITp __i)
+    atomic_fetch_xor(__atomic_base<_ITp>* __a, _ITp __i) noexcept
     { return atomic_fetch_xor_explicit(__a, __i, memory_order_seq_cst); }
 
   template<typename _ITp>
     inline _ITp
-    atomic_fetch_xor(volatile __atomic_base<_ITp>* __a, _ITp __i)
+    atomic_fetch_xor(volatile __atomic_base<_ITp>* __a, _ITp __i) noexcept
     { return atomic_fetch_xor_explicit(__a, __i, memory_order_seq_cst); }
 
 
@@ -1006,45 +1022,45 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
   template<typename _ITp>
     inline _ITp*
     atomic_fetch_add_explicit(atomic<_ITp*>* __a, ptrdiff_t __d,
-			      memory_order __m)
+			      memory_order __m) noexcept
     { return __a->fetch_add(__d, __m); }
 
   template<typename _ITp>
     inline _ITp*
     atomic_fetch_add_explicit(volatile atomic<_ITp*>* __a, ptrdiff_t __d,
-			      memory_order __m)
+			      memory_order __m) noexcept
     { return __a->fetch_add(__d, __m); }
 
   template<typename _ITp>
     inline _ITp*
-    atomic_fetch_add(volatile atomic<_ITp*>* __a, ptrdiff_t __d)
+    atomic_fetch_add(volatile atomic<_ITp*>* __a, ptrdiff_t __d) noexcept
     { return __a->fetch_add(__d); }
 
   template<typename _ITp>
     inline _ITp*
-    atomic_fetch_add(atomic<_ITp*>* __a, ptrdiff_t __d)
+    atomic_fetch_add(atomic<_ITp*>* __a, ptrdiff_t __d) noexcept
     { return __a->fetch_add(__d); }
 
   template<typename _ITp>
     inline _ITp*
     atomic_fetch_sub_explicit(volatile atomic<_ITp*>* __a,
-			      ptrdiff_t __d, memory_order __m)
+			      ptrdiff_t __d, memory_order __m) noexcept
     { return __a->fetch_sub(__d, __m); }
 
   template<typename _ITp>
     inline _ITp*
     atomic_fetch_sub_explicit(atomic<_ITp*>* __a, ptrdiff_t __d,
-			      memory_order __m)
+			      memory_order __m) noexcept
     { return __a->fetch_sub(__d, __m); }
 
   template<typename _ITp>
     inline _ITp*
-    atomic_fetch_sub(volatile atomic<_ITp*>* __a, ptrdiff_t __d)
+    atomic_fetch_sub(volatile atomic<_ITp*>* __a, ptrdiff_t __d) noexcept
     { return __a->fetch_sub(__d); }
 
   template<typename _ITp>
     inline _ITp*
-    atomic_fetch_sub(atomic<_ITp*>* __a, ptrdiff_t __d)
+    atomic_fetch_sub(atomic<_ITp*>* __a, ptrdiff_t __d) noexcept
     { return __a->fetch_sub(__d); }
   // @} group atomics