From f9c4249c8e377ce72d05fc1943e124f2ff4c0425 Mon Sep 17 00:00:00 2001
From: Andrey Semashev <andrey.semashev@gmail.com>
Date: Sat, 23 Feb 2013 14:21:19 +0000
Subject: [PATCH] 1. Fixed compilation with MSVC 2003. 2. Fixed incorrect
 reinterpret_casts in constexpr constructors that could result in buffer
 overruns. The initializing constructors for non-integral atomics are not
 constexpr yet because memcpy must be used inside. 3. Made atomic_flag default
 constructors constexpr. This is not by the standard but we do not implement
 ATOMIC_FLAG_INIT yet, so the default constructor is needed and it should be
 constexpr when possible. 4. Fixed a few syntax errors and cleaned up the code
 a bit. 5. Moved operator value_type() to the interface class in order not to
 duplicate it in base_atomic specializations. 6. The return type of
 operator=() changed to follow the standard.

[SVN r83096]
---
 include/boost/atomic/atomic.hpp               | 43 +++++++--
 include/boost/atomic/detail/base.hpp          | 37 +++-----
 include/boost/atomic/detail/cas32strong.hpp   | 55 ++++++-----
 include/boost/atomic/detail/cas32weak.hpp     | 58 ++++++-----
 include/boost/atomic/detail/cas64strong.hpp   | 29 +++---
 include/boost/atomic/detail/gcc-alpha.hpp     | 22 +++--
 include/boost/atomic/detail/gcc-armv6plus.hpp |  5 +-
 include/boost/atomic/detail/gcc-cas.hpp       |  5 +-
 include/boost/atomic/detail/gcc-ppc.hpp       | 95 +++++++++++--------
 include/boost/atomic/detail/gcc-sparcv9.hpp   | 65 +++++++------
 include/boost/atomic/detail/gcc-x86.hpp       | 76 +++++++++------
 include/boost/atomic/detail/generic-cas.hpp   | 15 ++-
 include/boost/atomic/detail/interlocked.hpp   | 24 ++---
 include/boost/atomic/detail/linux-arm.hpp     |  5 +-
 include/boost/atomic/detail/windows.hpp       | 85 +++++++++++------
 15 files changed, 376 insertions(+), 243 deletions(-)

diff --git a/include/boost/atomic/atomic.hpp b/include/boost/atomic/atomic.hpp
index ee04772..003d2f7 100644
--- a/include/boost/atomic/atomic.hpp
+++ b/include/boost/atomic/atomic.hpp
@@ -17,6 +17,10 @@
 #include <boost/atomic/detail/platform.hpp>
 #include <boost/atomic/detail/type-classification.hpp>
 #include <boost/type_traits/is_signed.hpp>
+#if defined(BOOST_MSVC) && BOOST_MSVC < 1400
+#include <boost/type_traits/is_integral.hpp>
+#include <boost/mpl/and.hpp>
+#endif
 
 #ifdef BOOST_ATOMIC_HAS_PRAGMA_ONCE
 #pragma once
@@ -83,23 +87,48 @@ inline void atomic_signal_fence(memory_order order)
 
 template<typename T>
 class atomic :
-    public atomics::detail::base_atomic<T, typename atomics::detail::classify<T>::type, atomics::detail::storage_size_of<T>::value, boost::is_signed<T>::value >
+    public atomics::detail::base_atomic<
+        T,
+        typename atomics::detail::classify<T>::type,
+        atomics::detail::storage_size_of<T>::value,
+#if !defined(BOOST_MSVC) || BOOST_MSVC >= 1400
+        boost::is_signed<T>::value
+#else
+        // MSVC 2003 has problems instantiating is_signed on non-itegral types
+        mpl::and_< boost::is_integral<T>, boost::is_signed<T> >::value
+#endif
+    >
 {
 private:
     typedef T value_type;
-    typedef atomics::detail::base_atomic<T, typename atomics::detail::classify<T>::type, atomics::detail::storage_size_of<T>::value, boost::is_signed<T>::value > super;
+    typedef atomics::detail::base_atomic<
+        T,
+        typename atomics::detail::classify<T>::type,
+        atomics::detail::storage_size_of<T>::value,
+#if !defined(BOOST_MSVC) || BOOST_MSVC >= 1400
+        boost::is_signed<T>::value
+#else
+        // MSVC 2003 has problems instantiating is_signed on non-itegral types
+        mpl::and_< boost::is_integral<T>, boost::is_signed<T> >::value
+#endif
+    > super;
 public:
     atomic(void) BOOST_NOEXCEPT : super() {}
-    BOOST_CONSTEXPR atomic(value_type v) BOOST_NOEXCEPT: super(v) {}
+    BOOST_CONSTEXPR atomic(value_type v) BOOST_NOEXCEPT : super(v) {}
 
-    atomic & operator=(value_type v) volatile BOOST_NOEXCEPT
+    value_type operator=(value_type v) volatile BOOST_NOEXCEPT
     {
-        super::operator=(v);
-        return *const_cast<atomic *>(this);
+        this->store(v);
+        return v;
+    }
+
+    operator value_type(void) volatile const BOOST_NOEXCEPT
+    {
+        return this->load();
     }
 
-private:
 #ifdef BOOST_NO_CXX11_DELETED_FUNCTIONS
+private:
     atomic(const atomic &) /* =delete */ ;
     atomic & operator=(const atomic &) volatile /* =delete */ ;
 #else
diff --git a/include/boost/atomic/detail/base.hpp b/include/boost/atomic/detail/base.hpp
index 38ef8f9..c0c4549 100644
--- a/include/boost/atomic/detail/base.hpp
+++ b/include/boost/atomic/detail/base.hpp
@@ -24,18 +24,6 @@
 #endif
 
 #define BOOST_ATOMIC_DECLARE_BASE_OPERATORS \
-    operator value_type(void) volatile const BOOST_NOEXCEPT \
-    { \
-        return load(memory_order_seq_cst); \
-    } \
-     \
-    this_type & \
-    operator=(value_type v) volatile BOOST_NOEXCEPT \
-    { \
-        store(v, memory_order_seq_cst); \
-        return *const_cast<this_type *>(this); \
-    } \
-     \
     bool \
     compare_exchange_strong( \
         value_type & expected, \
@@ -53,7 +41,6 @@
     { \
         return compare_exchange_weak(expected, desired, order, calculate_failure_order(order)); \
     } \
-     \
 
 #define BOOST_ATOMIC_DECLARE_ADDITIVE_OPERATORS \
     value_type \
@@ -138,7 +125,8 @@ calculate_failure_order(memory_order order)
 }
 
 template<typename T, typename C, unsigned int Size, bool Sign>
-class base_atomic {
+class base_atomic
+{
 private:
     typedef base_atomic this_type;
     typedef T value_type;
@@ -148,8 +136,7 @@ private:
 public:
     base_atomic(void) {}
 
-    BOOST_CONSTEXPR base_atomic(value_type v) BOOST_NOEXCEPT:
-        v_(v)
+    BOOST_CONSTEXPR explicit base_atomic(value_type const& v) BOOST_NOEXCEPT : v_(v)
     {}
 
     void
@@ -224,8 +211,7 @@ public:
 private:
     char * storage_ptr() volatile const BOOST_NOEXCEPT
     {
-        const char volatile * ptr = reinterpret_cast<const char volatile *>(&v_);
-        return const_cast<char *>(ptr);
+        return const_cast<char *>(&reinterpret_cast<char const volatile &>(v_));
     }
 
     base_atomic(const base_atomic &) /* = delete */ ;
@@ -235,14 +221,15 @@ private:
 };
 
 template<typename T, unsigned int Size, bool Sign>
-class base_atomic<T, int, Size, Sign> {
+class base_atomic<T, int, Size, Sign>
+{
 private:
     typedef base_atomic this_type;
     typedef T value_type;
     typedef T difference_type;
     typedef lockpool::scoped_lock guard_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type v) BOOST_NOEXCEPT: v_(v) {}
+    BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
     base_atomic(void) {}
 
     void
@@ -360,14 +347,15 @@ private:
 };
 
 template<typename T, unsigned int Size, bool Sign>
-class base_atomic<T *, void *, Size, Sign> {
+class base_atomic<T *, void *, Size, Sign>
+{
 private:
     typedef base_atomic this_type;
     typedef T * value_type;
     typedef ptrdiff_t difference_type;
     typedef lockpool::scoped_lock guard_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type v) BOOST_NOEXCEPT: v_(v) {}
+    BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
     base_atomic(void) {}
 
     void
@@ -452,13 +440,14 @@ private:
 };
 
 template<unsigned int Size, bool Sign>
-class base_atomic<void *, void *, Size, Sign> {
+class base_atomic<void *, void *, Size, Sign>
+{
 private:
     typedef base_atomic this_type;
     typedef void * value_type;
     typedef lockpool::scoped_lock guard_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type v) BOOST_NOEXCEPT: v_(v) {}
+    BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
     base_atomic(void) {}
 
     void
diff --git a/include/boost/atomic/detail/cas32strong.hpp b/include/boost/atomic/detail/cas32strong.hpp
index aba8289..909a4a4 100644
--- a/include/boost/atomic/detail/cas32strong.hpp
+++ b/include/boost/atomic/detail/cas32strong.hpp
@@ -29,13 +29,14 @@ namespace detail {
 /* integral types */
 
 template<typename T, bool Sign>
-class base_atomic<T, int, 1, Sign> {
+class base_atomic<T, int, 1, Sign>
+{
     typedef base_atomic this_type;
     typedef T value_type;
     typedef T difference_type;
     typedef uint32_t storage_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type v) BOOST_NOEXCEPT: v_(v) {}
+    BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
     base_atomic(void) {}
 
     void
@@ -156,13 +157,14 @@ private:
 };
 
 template<typename T, bool Sign>
-class base_atomic<T, int, 2, Sign> {
+class base_atomic<T, int, 2, Sign>
+{
     typedef base_atomic this_type;
     typedef T value_type;
     typedef T difference_type;
     typedef uint32_t storage_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type v) BOOST_NOEXCEPT: v_(v) {}
+    BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
     base_atomic(void) {}
 
     void
@@ -283,12 +285,13 @@ private:
 };
 
 template<typename T, bool Sign>
-class base_atomic<T, int, 4, Sign> {
+class base_atomic<T, int, 4, Sign>
+{
     typedef base_atomic this_type;
     typedef T value_type;
     typedef T difference_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type v) BOOST_NOEXCEPT: v_(v) {}
+    BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
     base_atomic(void) {}
 
     void
@@ -407,12 +410,13 @@ private:
 /* pointer types */
 
 template<bool Sign>
-class base_atomic<void *, void *, 4, Sign> {
+class base_atomic<void *, void *, 4, Sign>
+{
     typedef base_atomic this_type;
     typedef void * value_type;
     typedef ptrdiff_t difference_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type v) BOOST_NOEXCEPT: v_(v) {}
+    BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
     base_atomic(void) {}
 
     void
@@ -502,12 +506,13 @@ private:
 };
 
 template<typename T, bool Sign>
-class base_atomic<T *, void *, 4, Sign> {
+class base_atomic<T *, void *, 4, Sign>
+{
     typedef base_atomic this_type;
     typedef T * value_type;
     typedef ptrdiff_t difference_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type v) BOOST_NOEXCEPT: v_(v) {}
+    BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
     base_atomic(void) {}
 
     void
@@ -599,14 +604,16 @@ private:
 /* generic types */
 
 template<typename T, bool Sign>
-class base_atomic<T, void, 1, Sign> {
+class base_atomic<T, void, 1, Sign>
+{
     typedef base_atomic this_type;
     typedef T value_type;
     typedef uint32_t storage_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type const& v) BOOST_NOEXCEPT:
-        v_(*reinterpret_cast<storage_type*>(&v))
-    {}
+    explicit base_atomic(value_type const& v) BOOST_NOEXCEPT : v_(0)
+    {
+        memcpy(&v_, &v, sizeof(value_type));
+    }
 
     base_atomic(void) {}
 
@@ -688,14 +695,16 @@ private:
 };
 
 template<typename T, bool Sign>
-class base_atomic<T, void, 2, Sign> {
+class base_atomic<T, void, 2, Sign>
+{
     typedef base_atomic this_type;
     typedef T value_type;
     typedef uint32_t storage_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type const& v) BOOST_NOEXCEPT:
-        v_(*reinterpret_cast<storage_type*>(&v))
-    {}
+    explicit base_atomic(value_type const& v) BOOST_NOEXCEPT : v_(0)
+    {
+        memcpy(&v_, &v, sizeof(value_type));
+    }
 
     base_atomic(void) {}
 
@@ -778,14 +787,16 @@ private:
 };
 
 template<typename T, bool Sign>
-class base_atomic<T, void, 4, Sign> {
+class base_atomic<T, void, 4, Sign>
+{
     typedef base_atomic this_type;
     typedef T value_type;
     typedef uint32_t storage_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type const& v) BOOST_NOEXCEPT:
-        v_(*reinterpret_cast<storage_type*>(&v))
-    {}
+    explicit base_atomic(value_type const& v) BOOST_NOEXCEPT : v_(0)
+    {
+        memcpy(&v_, &v, sizeof(value_type));
+    }
 
     base_atomic(void) {}
 
diff --git a/include/boost/atomic/detail/cas32weak.hpp b/include/boost/atomic/detail/cas32weak.hpp
index 204e33d..a808e31 100644
--- a/include/boost/atomic/detail/cas32weak.hpp
+++ b/include/boost/atomic/detail/cas32weak.hpp
@@ -26,13 +26,14 @@ namespace detail {
 /* integral types */
 
 template<typename T, bool Sign>
-class base_atomic<T, int, 1, Sign> {
+class base_atomic<T, int, 1, Sign>
+{
     typedef base_atomic this_type;
     typedef T value_type;
     typedef T difference_type;
     typedef uint32_t storage_type;
 public:
-    BOOST_CONSTEXPR base_atomic BOOST_NOEXCEPT: v_(v) {}
+    BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
     base_atomic(void) {}
 
     void
@@ -161,13 +162,14 @@ private:
 };
 
 template<typename T, bool Sign>
-class base_atomic<T, int, 2, Sign> {
+class base_atomic<T, int, 2, Sign>
+{
     typedef base_atomic this_type;
     typedef T value_type;
     typedef T difference_type;
     typedef uint32_t storage_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type v) BOOST_NOEXCEPT: v_(v) {}
+    BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
     base_atomic(void) {}
 
     void
@@ -296,12 +298,13 @@ private:
 };
 
 template<typename T, bool Sign>
-class base_atomic<T, int, 4, Sign> {
+class base_atomic<T, int, 4, Sign>
+{
     typedef base_atomic this_type;
     typedef T value_type;
     typedef T difference_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type v) BOOST_NOEXCEPT: v_(v) {}
+    BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
     base_atomic(void) {}
 
     void
@@ -428,12 +431,13 @@ private:
 /* pointer types */
 
 template<bool Sign>
-class base_atomic<void *, void *, 4, Sign> {
+class base_atomic<void *, void *, 4, Sign>
+{
     typedef base_atomic this_type;
     typedef void * value_type;
     typedef ptrdiff_t difference_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type v) BOOST_NOEXCEPT: v_(v) {}
+    BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
     base_atomic(void) {}
 
     void
@@ -513,12 +517,13 @@ private:
 };
 
 template<typename T, bool Sign>
-class base_atomic<T *, void *, 4, Sign> {
+class base_atomic<T *, void *, 4, Sign>
+{
     typedef base_atomic this_type;
     typedef T * value_type;
     typedef ptrdiff_t difference_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type v) BOOST_NOEXCEPT: v_(v) {}
+    BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
     base_atomic(void) {}
 
     void
@@ -618,14 +623,17 @@ private:
 /* generic types */
 
 template<typename T, bool Sign>
-class base_atomic<T, void, 1, Sign> {
+class base_atomic<T, void, 1, Sign>
+{
     typedef base_atomic this_type;
     typedef T value_type;
     typedef uint32_t storage_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type const& v) BOOST_NOEXCEPT:
-        v_(*reinterpret_cast<storage_type*>(&v))
-    {}
+    explicit base_atomic(value_type const& v) BOOST_NOEXCEPT : v_(0)
+    {
+        memcpy(&v_, &v, sizeof(value_type));
+    }
+
     base_atomic(void) {}
 
     void
@@ -715,14 +723,17 @@ private:
 };
 
 template<typename T, bool Sign>
-class base_atomic<T, void, 2, Sign> {
+class base_atomic<T, void, 2, Sign>
+{
     typedef base_atomic this_type;
     typedef T value_type;
     typedef uint32_t storage_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type const& v) BOOST_NOEXCEPT:
-        v_(*reinterpret_cast<storage_type*>(&v))
-    {}
+    explicit base_atomic(value_type const& v) BOOST_NOEXCEPT : v_(0)
+    {
+        memcpy(&v_, &v, sizeof(value_type));
+    }
+
     base_atomic(void) {}
 
     void
@@ -812,14 +823,17 @@ private:
 };
 
 template<typename T, bool Sign>
-class base_atomic<T, void, 4, Sign> {
+class base_atomic<T, void, 4, Sign>
+{
     typedef base_atomic this_type;
     typedef T value_type;
     typedef uint32_t storage_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type const& v) BOOST_NOEXCEPT:
-        v_(*reinterpret_cast<storage_type*>(&v))
-    {}
+    explicit base_atomic(value_type const& v) BOOST_NOEXCEPT : v_(0)
+    {
+        memcpy(&v_, &v, sizeof(value_type));
+    }
+
     base_atomic(void) {}
 
     void
diff --git a/include/boost/atomic/detail/cas64strong.hpp b/include/boost/atomic/detail/cas64strong.hpp
index 8d31e6d..41cb522 100644
--- a/include/boost/atomic/detail/cas64strong.hpp
+++ b/include/boost/atomic/detail/cas64strong.hpp
@@ -29,12 +29,13 @@ namespace detail {
 /* integral types */
 
 template<typename T, bool Sign>
-class base_atomic<T, int, 8, Sign> {
+class base_atomic<T, int, 8, Sign>
+{
     typedef base_atomic this_type;
     typedef T value_type;
     typedef T difference_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type v) BOOST_NOEXCEPT: v_(v) {}
+    BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
     base_atomic(void) {}
 
     void
@@ -153,12 +154,13 @@ private:
 /* pointer types */
 
 template<bool Sign>
-class base_atomic<void *, void *, 8, Sign> {
+class base_atomic<void *, void *, 8, Sign>
+{
     typedef base_atomic this_type;
     typedef void * value_type;
     typedef ptrdiff_t difference_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type v) BOOST_NOEXCEPT: v_(v) {}
+    BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
     base_atomic(void) {}
 
     void
@@ -248,12 +250,13 @@ private:
 };
 
 template<typename T, bool Sign>
-class base_atomic<T *, void *, 8, Sign> {
+class base_atomic<T *, void *, 8, Sign>
+{
     typedef base_atomic this_type;
     typedef T * value_type;
     typedef ptrdiff_t difference_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type v) BOOST_NOEXCEPT: v_(v) {}
+    BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
     base_atomic(void) {}
 
     void
@@ -345,21 +348,23 @@ private:
 /* generic types */
 
 template<typename T, bool Sign>
-class base_atomic<T, void, 8, Sign> {
+class base_atomic<T, void, 8, Sign>
+{
     typedef base_atomic this_type;
     typedef T value_type;
     typedef uint64_t storage_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type v) BOOST_NOEXCEPT:
-        v_(*reinterpret_cast<storage_type*>(&v))
-    {}
+    explicit base_atomic(value_type const& v) BOOST_NOEXCEPT : v_(0)
+    {
+        memcpy(&v_, &v, sizeof(value_type));
+    }
     base_atomic(void) {}
 
     void
     store(value_type const& value, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
     {
         storage_type value_s = 0;
-        memcpy(&value_s, &value, sizeof(value_s));
+        memcpy(&value_s, &value, sizeof(value_type));
         platform_fence_before_store(order);
         platform_store64(value_s, &v_);
         platform_fence_after_store(order);
@@ -371,7 +376,7 @@ public:
         storage_type value_s = platform_load64(&v_);
         platform_fence_after_load(order);
         value_type value;
-        memcpy(&value, &value_s, sizeof(value_s));
+        memcpy(&value, &value_s, sizeof(value_type));
         return value;
     }
 
diff --git a/include/boost/atomic/detail/gcc-alpha.hpp b/include/boost/atomic/detail/gcc-alpha.hpp
index f9acdb8..360a9db 100644
--- a/include/boost/atomic/detail/gcc-alpha.hpp
+++ b/include/boost/atomic/detail/gcc-alpha.hpp
@@ -88,7 +88,8 @@ inline void platform_atomic_thread_fence(memory_order order)
 }
 
 template<typename T>
-class atomic_alpha_32 {
+class atomic_alpha_32
+{
 public:
     typedef T integral_type;
     BOOST_CONSTEXPR atomic_alpha_32(T v) BOOST_NOEXCEPT: i(v) {}
@@ -204,7 +205,8 @@ private:
 };
 
 template<typename T>
-class atomic_alpha_64 {
+class atomic_alpha_64
+{
 public:
     typedef T integral_type;
     BOOST_CONSTEXPR atomic_alpha_64(T v) BOOST_NOEXCEPT: i(v) {}
@@ -320,7 +322,9 @@ private:
 };
 
 template<typename T>
-class platform_atomic_integral<T, 4> : public build_atomic_from_typical<build_exchange<atomic_alpha_32<T> > > {
+class platform_atomic_integral<T, 4> :
+    public build_atomic_from_typical<build_exchange<atomic_alpha_32<T> > >
+{
 public:
     typedef build_atomic_from_typical<build_exchange<atomic_alpha_32<T> > > super;
     BOOST_CONSTEXPR platform_atomic_integral(T v) BOOST_NOEXCEPT: super(v) {}
@@ -328,7 +332,9 @@ public:
 };
 
 template<typename T>
-class platform_atomic_integral<T, 8> : public build_atomic_from_typical<build_exchange<atomic_alpha_64<T> > > {
+class platform_atomic_integral<T, 8> :
+    public build_atomic_from_typical<build_exchange<atomic_alpha_64<T> > >
+{
 public:
     typedef build_atomic_from_typical<build_exchange<atomic_alpha_64<T> > > super;
     BOOST_CONSTEXPR platform_atomic_integral(T v) BOOST_NOEXCEPT: super(v) {}
@@ -336,7 +342,9 @@ public:
 };
 
 template<typename T>
-class platform_atomic_integral<T, 1>: public build_atomic_from_larger_type<atomic_alpha_32<uint32_t>, T> {
+class platform_atomic_integral<T, 1> :
+    public build_atomic_from_larger_type<atomic_alpha_32<uint32_t>, T>
+{
 public:
     typedef build_atomic_from_larger_type<atomic_alpha_32<uint32_t>, T> super;
     BOOST_CONSTEXPR platform_atomic_integral(T v) BOOST_NOEXCEPT: super(v) {}
@@ -344,7 +352,9 @@ public:
 };
 
 template<typename T>
-class platform_atomic_integral<T, 2>: public build_atomic_from_larger_type<atomic_alpha_32<uint32_t>, T> {
+class platform_atomic_integral<T, 2> :
+    public build_atomic_from_larger_type<atomic_alpha_32<uint32_t>, T>
+{
 public:
     typedef build_atomic_from_larger_type<atomic_alpha_32<uint32_t>, T> super;
     BOOST_CONSTEXPR platform_atomic_integral(T v) BOOST_NOEXCEPT: super(v) {}
diff --git a/include/boost/atomic/detail/gcc-armv6plus.hpp b/include/boost/atomic/detail/gcc-armv6plus.hpp
index 3019f76..c11e5cd 100644
--- a/include/boost/atomic/detail/gcc-armv6plus.hpp
+++ b/include/boost/atomic/detail/gcc-armv6plus.hpp
@@ -192,13 +192,14 @@ atomic_signal_fence(memory_order)
     __asm__ __volatile__ ("" ::: "memory");
 }
 
-class atomic_flag {
+class atomic_flag
+{
 private:
     atomic_flag(const atomic_flag &) /* = delete */ ;
     atomic_flag & operator=(const atomic_flag &) /* = delete */ ;
     uint32_t v_;
 public:
-    atomic_flag(void) BOOST_NOEXCEPT: v_(false) {}
+    BOOST_CONSTEXPR atomic_flag(void) BOOST_NOEXCEPT : v_(0) {}
 
     void
     clear(memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
diff --git a/include/boost/atomic/detail/gcc-cas.hpp b/include/boost/atomic/detail/gcc-cas.hpp
index 85d6458..446da37 100644
--- a/include/boost/atomic/detail/gcc-cas.hpp
+++ b/include/boost/atomic/detail/gcc-cas.hpp
@@ -102,13 +102,14 @@ platform_cmpxchg32_strong(T & expected, T desired, volatile T * ptr)
     return success;
 }
 
-class atomic_flag {
+class atomic_flag
+{
 private:
     atomic_flag(const atomic_flag &) /* = delete */ ;
     atomic_flag & operator=(const atomic_flag &) /* = delete */ ;
     uint32_t v_;
 public:
-    atomic_flag(void) BOOST_NOEXCEPT: v_(false) {}
+    BOOST_CONSTEXPR atomic_flag(void) BOOST_NOEXCEPT : v_(0) {}
 
     void
     clear(memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
diff --git a/include/boost/atomic/detail/gcc-ppc.hpp b/include/boost/atomic/detail/gcc-ppc.hpp
index 613da71..ed975d7 100644
--- a/include/boost/atomic/detail/gcc-ppc.hpp
+++ b/include/boost/atomic/detail/gcc-ppc.hpp
@@ -105,13 +105,14 @@ ppc_fence_after_store(memory_order order)
 }
 }
 
-class atomic_flag {
+class atomic_flag
+{
 private:
     atomic_flag(const atomic_flag &) /* = delete */ ;
     atomic_flag & operator=(const atomic_flag &) /* = delete */ ;
     uint32_t v_;
 public:
-    atomic_flag(void) BOOST_NOEXCEPT: v_(false) {}
+    BOOST_CONSTEXPR atomic_flag(void) BOOST_NOEXCEPT : v_(0) {}
 
     void
     clear(memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
@@ -196,13 +197,14 @@ namespace detail {
 /* integral types */
 
 template<typename T>
-class base_atomic<T, int, 1, true> {
+class base_atomic<T, int, 1, true>
+{
     typedef base_atomic this_type;
     typedef T value_type;
     typedef int32_t storage_type;
     typedef T difference_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type v) BOOST_NOEXCEPT: v_(v) {}
+    BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
     base_atomic(void) {}
 
     void
@@ -416,13 +418,14 @@ private:
 };
 
 template<typename T>
-class base_atomic<T, int, 1, false> {
+class base_atomic<T, int, 1, false>
+{
     typedef base_atomic this_type;
     typedef T value_type;
     typedef uint32_t storage_type;
     typedef T difference_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type v) : v_(v) {}
+    BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
     base_atomic(void) {}
 
     void
@@ -637,13 +640,14 @@ private:
 };
 
 template<typename T>
-class base_atomic<T, int, 2, true> {
+class base_atomic<T, int, 2, true>
+{
     typedef base_atomic this_type;
     typedef T value_type;
     typedef int32_t storage_type;
     typedef T difference_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type v) : v_(v) {}
+    BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
     base_atomic(void) {}
 
     void
@@ -858,13 +862,14 @@ private:
 };
 
 template<typename T>
-class base_atomic<T, int, 2, false> {
+class base_atomic<T, int, 2, false>
+{
     typedef base_atomic this_type;
     typedef T value_type;
     typedef uint32_t storage_type;
     typedef T difference_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type v) : v_(v) {}
+    BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
     base_atomic(void) {}
 
     void
@@ -1079,12 +1084,13 @@ private:
 };
 
 template<typename T, bool Sign>
-class base_atomic<T, int, 4, Sign> {
+class base_atomic<T, int, 4, Sign>
+{
     typedef base_atomic this_type;
     typedef T value_type;
     typedef T difference_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type v) : v_(v) {}
+    BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
     base_atomic(void) {}
 
     void
@@ -1295,12 +1301,13 @@ private:
 #if defined(__powerpc64__)
 
 template<typename T, bool Sign>
-class base_atomic<T, int, 8, Sign> {
+class base_atomic<T, int, 8, Sign>
+{
     typedef base_atomic this_type;
     typedef T value_type;
     typedef T difference_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type v) : v_(v) {}
+    BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
     base_atomic(void) {}
 
     void
@@ -1515,11 +1522,12 @@ private:
 #if !defined(__powerpc64__)
 
 template<bool Sign>
-class base_atomic<void *, void *, 4, Sign> {
+class base_atomic<void *, void *, 4, Sign>
+{
     typedef base_atomic this_type;
     typedef void * value_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type v) : v_(v) {}
+    BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
     base_atomic(void) {}
 
     void
@@ -1643,12 +1651,13 @@ private:
 };
 
 template<typename T, bool Sign>
-class base_atomic<T *, void *, 4, Sign> {
+class base_atomic<T *, void *, 4, Sign>
+{
     typedef base_atomic this_type;
     typedef T * value_type;
     typedef ptrdiff_t difference_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type v) : v_(v) {}
+    BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
     base_atomic(void) {}
 
     void
@@ -1812,11 +1821,12 @@ private:
 #else
 
 template<bool Sign>
-class base_atomic<void *, void *, 8, Sign> {
+class base_atomic<void *, void *, 8, Sign>
+{
     typedef base_atomic this_type;
     typedef void * value_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type v) : v_(v) {}
+    BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
     base_atomic(void) {}
 
     void
@@ -1940,12 +1950,13 @@ private:
 };
 
 template<typename T, bool Sign>
-class base_atomic<T *, void *, 8, Sign> {
+class base_atomic<T *, void *, 8, Sign>
+{
     typedef base_atomic this_type;
     typedef T * value_type;
     typedef ptrdiff_t difference_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type v) : v_(v) {}
+    BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
     base_atomic(void) {}
 
     void
@@ -2111,14 +2122,16 @@ private:
 /* generic */
 
 template<typename T, bool Sign>
-class base_atomic<T, void, 1, Sign> {
+class base_atomic<T, void, 1, Sign>
+{
     typedef base_atomic this_type;
     typedef T value_type;
     typedef uint32_t storage_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type const& v) BOOST_NOEXCEPT:
-        v_(*reinterpret_cast<storage_type*>(&v))
-    {}
+    explicit base_atomic(value_type const& v) BOOST_NOEXCEPT : v_(0)
+    {
+        memcpy(&v_, &v, sizeof(value_type));
+    }
     base_atomic(void) {}
 
     void
@@ -2260,14 +2273,16 @@ private:
 };
 
 template<typename T, bool Sign>
-class base_atomic<T, void, 2, Sign> {
+class base_atomic<T, void, 2, Sign>
+{
     typedef base_atomic this_type;
     typedef T value_type;
     typedef uint32_t storage_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type const& v) BOOST_NOEXCEPT:
-        v_(*reinterpret_cast<storage_type*>(&v))
-    {}
+    explicit base_atomic(value_type const& v) BOOST_NOEXCEPT : v_(0)
+    {
+        memcpy(&v_, &v, sizeof(value_type));
+    }
 
     base_atomic(void) {}
 
@@ -2410,14 +2425,16 @@ private:
 };
 
 template<typename T, bool Sign>
-class base_atomic<T, void, 4, Sign> {
+class base_atomic<T, void, 4, Sign>
+{
     typedef base_atomic this_type;
     typedef T value_type;
     typedef uint32_t storage_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type const& v) BOOST_NOEXCEPT:
-        v_(*reinterpret_cast<storage_type*>(&v))
-    {}
+    explicit base_atomic(value_type const& v) BOOST_NOEXCEPT : v_(0)
+    {
+        memcpy(&v_, &v, sizeof(value_type));
+    }
 
     base_atomic(void) {}
 
@@ -2562,14 +2579,16 @@ private:
 #if defined(__powerpc64__)
 
 template<typename T, bool Sign>
-class base_atomic<T, void, 8, Sign> {
+class base_atomic<T, void, 8, Sign>
+{
     typedef base_atomic this_type;
     typedef T value_type;
     typedef uint64_t storage_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type const& v) BOOST_NOEXCEPT:
-        v_(*reinterpret_cast<storage_type*>(&v))
-    {}
+    explicit base_atomic(value_type const& v) BOOST_NOEXCEPT : v_(0)
+    {
+        memcpy(&v_, &v, sizeof(value_type));
+    }
 
     base_atomic(void) {}
 
diff --git a/include/boost/atomic/detail/gcc-sparcv9.hpp b/include/boost/atomic/detail/gcc-sparcv9.hpp
index d9fb004..81fe729 100644
--- a/include/boost/atomic/detail/gcc-sparcv9.hpp
+++ b/include/boost/atomic/detail/gcc-sparcv9.hpp
@@ -83,13 +83,14 @@ platform_fence_after_load(memory_order order)
 }
 }
 
-class atomic_flag {
+class atomic_flag
+{
 private:
     atomic_flag(const atomic_flag &) /* = delete */ ;
     atomic_flag & operator=(const atomic_flag &) /* = delete */ ;
     uint32_t v_;
 public:
-    atomic_flag(void) : v_(false) {}
+    BOOST_CONSTEXPR atomic_flag(void) BOOST_NOEXCEPT : v_(0) {}
 
     void
     clear(memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
@@ -100,7 +101,7 @@ public:
     }
 
     bool
-    test_and_set(memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT BOOST_NOEXCEPT
+    test_and_set(memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
     {
         atomics::detail::platform_fence_before(order);
         uint32_t tmp = 1;
@@ -174,13 +175,14 @@ namespace detail {
 /* integral types */
 
 template<typename T>
-class base_atomic<T, int, 1, true> {
+class base_atomic<T, int, 1, true>
+{
     typedef base_atomic this_type;
     typedef T value_type;
     typedef T difference_type;
     typedef int32_t storage_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type v) : v_(v) {}
+    BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
     base_atomic(void) {}
 
     void
@@ -192,7 +194,7 @@ public:
     }
 
     value_type
-    load(memory_order order = memory_order_seq_cst)const volatile BOOST_NOEXCEPT
+    load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT
     {
         value_type v = const_cast<const volatile storage_type &>(v_);
         platform_fence_after_load(order);
@@ -296,13 +298,14 @@ private:
 };
 
 template<typename T>
-class base_atomic<T, int, 1, false> {
+class base_atomic<T, int, 1, false>
+{
     typedef base_atomic this_type;
     typedef T value_type;
     typedef T difference_type;
     typedef uint32_t storage_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type v) : v_(v) {}
+    BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
     base_atomic(void) {}
 
     void
@@ -314,7 +317,7 @@ public:
     }
 
     value_type
-    load(memory_order order = memory_order_seq_cst)const volatile BOOST_NOEXCEPT
+    load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT
     {
         value_type v = const_cast<const volatile storage_type &>(v_);
         platform_fence_after_load(order);
@@ -418,13 +421,14 @@ private:
 };
 
 template<typename T>
-class base_atomic<T, int, 2, true> {
+class base_atomic<T, int, 2, true>
+{
     typedef base_atomic this_type;
     typedef T value_type;
     typedef T difference_type;
     typedef int32_t storage_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type v) : v_(v) {}
+    BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
     base_atomic(void) {}
 
     void
@@ -436,7 +440,7 @@ public:
     }
 
     value_type
-    load(memory_order order = memory_order_seq_cst)const volatile BOOST_NOEXCEPT
+    load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT
     {
         value_type v = const_cast<const volatile storage_type &>(v_);
         platform_fence_after_load(order);
@@ -540,13 +544,14 @@ private:
 };
 
 template<typename T>
-class base_atomic<T, int, 2, false> {
+class base_atomic<T, int, 2, false>
+{
     typedef base_atomic this_type;
     typedef T value_type;
     typedef T difference_type;
     typedef uint32_t storage_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type v) : v_(v) {}
+    BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
     base_atomic(void) {}
 
     void
@@ -558,7 +563,7 @@ public:
     }
 
     value_type
-    load(memory_order order = memory_order_seq_cst)const volatile BOOST_NOEXCEPT
+    load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT
     {
         value_type v = const_cast<const volatile storage_type &>(v_);
         platform_fence_after_load(order);
@@ -662,12 +667,13 @@ private:
 };
 
 template<typename T, bool Sign>
-class base_atomic<T, int, 4, Sign> {
+class base_atomic<T, int, 4, Sign>
+{
     typedef base_atomic this_type;
     typedef T value_type;
     typedef T difference_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type v) : v_(v) {}
+    BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
     base_atomic(void) {}
 
     void
@@ -783,11 +789,12 @@ private:
 /* pointer types */
 
 template<bool Sign>
-class base_atomic<void *, void *, 4, Sign> {
+class base_atomic<void *, void *, 4, Sign>
+{
     typedef base_atomic this_type;
     typedef void * value_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type v) : v_(v) {}
+    BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
     base_atomic(void) {}
 
     void
@@ -858,12 +865,13 @@ private:
 };
 
 template<typename T, bool Sign>
-class base_atomic<T *, void *, 4, Sign> {
+class base_atomic<T *, void *, 4, Sign>
+{
     typedef base_atomic this_type;
     typedef T * value_type;
     typedef ptrdiff_t difference_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type v) : v_(v) {}
+    BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
     base_atomic(void) {}
 
     void
@@ -955,12 +963,13 @@ private:
 /* generic types */
 
 template<typename T, bool Sign>
-class base_atomic<T, void, 1, Sign> {
+class base_atomic<T, void, 1, Sign>
+{
     typedef base_atomic this_type;
     typedef T value_type;
     typedef uint32_t storage_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type const& v) : v_(0)
+    BOOST_CONSTEXPR explicit base_atomic(value_type const& v) BOOST_NOEXCEPT : v_(0)
     {
         memcpy(&v_, &v, sizeof(value_type));
     }
@@ -1044,12 +1053,13 @@ private:
 };
 
 template<typename T, bool Sign>
-class base_atomic<T, void, 2, Sign> {
+class base_atomic<T, void, 2, Sign>
+{
     typedef base_atomic this_type;
     typedef T value_type;
     typedef uint32_t storage_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type const& v) : v_(0)
+    BOOST_CONSTEXPR explicit base_atomic(value_type const& v) BOOST_NOEXCEPT : v_(0)
     {
         memcpy(&v_, &v, sizeof(value_type));
     }
@@ -1133,12 +1143,13 @@ private:
 };
 
 template<typename T, bool Sign>
-class base_atomic<T, void, 4, Sign> {
+class base_atomic<T, void, 4, Sign>
+{
     typedef base_atomic this_type;
     typedef T value_type;
     typedef uint32_t storage_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type const& v) : v_(0)
+    BOOST_CONSTEXPR explicit base_atomic(value_type const& v) BOOST_NOEXCEPT : v_(0)
     {
         memcpy(&v_, &v, sizeof(value_type));
     }
diff --git a/include/boost/atomic/detail/gcc-x86.hpp b/include/boost/atomic/detail/gcc-x86.hpp
index 119fd34..222821f 100644
--- a/include/boost/atomic/detail/gcc-x86.hpp
+++ b/include/boost/atomic/detail/gcc-x86.hpp
@@ -151,7 +151,7 @@ private:
     atomic_flag & operator=(const atomic_flag &) /* = delete */ ;
     uint32_t v_;
 public:
-    atomic_flag(void) : v_(0) {}
+    BOOST_CONSTEXPR atomic_flag(void) BOOST_NOEXCEPT : v_(0) {}
 
     bool
     test_and_set(memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
@@ -246,12 +246,13 @@ namespace atomics {
 namespace detail {
 
 template<typename T, bool Sign>
-class base_atomic<T, int, 1, Sign> {
+class base_atomic<T, int, 1, Sign>
+{
     typedef base_atomic this_type;
     typedef T value_type;
     typedef T difference_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type v) BOOST_NOEXCEPT: v_(v) {}
+    BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
     base_atomic(void) {}
 
     void
@@ -383,12 +384,13 @@ private:
 };
 
 template<typename T, bool Sign>
-class base_atomic<T, int, 2, Sign> {
+class base_atomic<T, int, 2, Sign>
+{
     typedef base_atomic this_type;
     typedef T value_type;
     typedef T difference_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type v) BOOST_NOEXCEPT: v_(v) {}
+    BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
     base_atomic(void) {}
 
     void
@@ -520,12 +522,13 @@ private:
 };
 
 template<typename T, bool Sign>
-class base_atomic<T, int, 4, Sign> {
+class base_atomic<T, int, 4, Sign>
+{
     typedef base_atomic this_type;
     typedef T value_type;
     typedef T difference_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type v) BOOST_NOEXCEPT: v_(v) {}
+    BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
     base_atomic(void) {}
 
     void
@@ -658,12 +661,13 @@ private:
 
 #if defined(__x86_64__)
 template<typename T, bool Sign>
-class base_atomic<T, int, 8, Sign> {
+class base_atomic<T, int, 8, Sign>
+{
     typedef base_atomic this_type;
     typedef T value_type;
     typedef T difference_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type v) BOOST_NOEXCEPT: v_(v) {}
+    BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
     base_atomic(void) {}
 
     void
@@ -801,11 +805,12 @@ private:
 #if !defined(__x86_64__)
 
 template<bool Sign>
-class base_atomic<void *, void *, 4, Sign> {
+class base_atomic<void *, void *, 4, Sign>
+{
     typedef base_atomic this_type;
     typedef void * value_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type v) BOOST_NOEXCEPT: v_(v) {}
+    BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
     base_atomic(void) {}
 
     void
@@ -878,12 +883,13 @@ private:
 };
 
 template<typename T, bool Sign>
-class base_atomic<T *, void *, 4, Sign> {
+class base_atomic<T *, void *, 4, Sign>
+{
     typedef base_atomic this_type;
     typedef T * value_type;
     typedef ptrdiff_t difference_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type v) BOOST_NOEXCEPT: v_(v) {}
+    BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
     base_atomic(void) {}
 
     void
@@ -985,11 +991,12 @@ private:
 #else
 
 template<bool Sign>
-class base_atomic<void *, void *, 8, Sign> {
+class base_atomic<void *, void *, 8, Sign>
+{
     typedef base_atomic this_type;
     typedef void * value_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type v) BOOST_NOEXCEPT: v_(v) {}
+    BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
     base_atomic(void) {}
 
     void
@@ -1062,12 +1069,13 @@ private:
 };
 
 template<typename T, bool Sign>
-class base_atomic<T *, void *, 8, Sign> {
+class base_atomic<T *, void *, 8, Sign>
+{
     typedef base_atomic this_type;
     typedef T * value_type;
     typedef ptrdiff_t difference_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type v) BOOST_NOEXCEPT: v_(v) {}
+    BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
     base_atomic(void) {}
 
     void
@@ -1169,13 +1177,14 @@ private:
 #endif
 
 template<typename T, bool Sign>
-class base_atomic<T, void, 1, Sign> {
+class base_atomic<T, void, 1, Sign>
+{
     typedef base_atomic this_type;
     typedef T value_type;
     typedef uint8_t storage_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type v) BOOST_NOEXCEPT:
-        v_(*reinterpret_cast<uint8_t*>(&v))
+    BOOST_CONSTEXPR explicit base_atomic(value_type const& v) BOOST_NOEXCEPT :
+        v_(reinterpret_cast<storage_type const&>(v))
     {}
     base_atomic(void) {}
 
@@ -1268,13 +1277,14 @@ private:
 };
 
 template<typename T, bool Sign>
-class base_atomic<T, void, 2, Sign> {
+class base_atomic<T, void, 2, Sign>
+{
     typedef base_atomic this_type;
     typedef T value_type;
     typedef uint16_t storage_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type v) BOOST_NOEXCEPT:
-        v_(*reinterpret_cast<uint16_t*>(&v))
+    BOOST_CONSTEXPR explicit base_atomic(value_type const& v) BOOST_NOEXCEPT :
+        v_(reinterpret_cast<storage_type const&>(v))
     {}
     base_atomic(void) {}
 
@@ -1367,14 +1377,16 @@ private:
 };
 
 template<typename T, bool Sign>
-class base_atomic<T, void, 4, Sign> {
+class base_atomic<T, void, 4, Sign>
+{
     typedef base_atomic this_type;
     typedef T value_type;
     typedef uint32_t storage_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type v) BOOST_NOEXCEPT
-        : v_(*reinterpret_cast<uint32_t*>(&v))
-    {}
+    explicit base_atomic(value_type const& v) BOOST_NOEXCEPT : v_(0)
+    {
+        memcpy(&v_, &v, sizeof(value_type));
+    }
     base_atomic(void) {}
 
     void
@@ -1467,14 +1479,16 @@ private:
 
 #if defined(__x86_64__)
 template<typename T, bool Sign>
-class base_atomic<T, void, 8, Sign> {
+class base_atomic<T, void, 8, Sign>
+{
     typedef base_atomic this_type;
     typedef T value_type;
     typedef uint64_t storage_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type v) BOOST_NOEXCEPT:
-        v_(*reinterpret_cast<storage_type*>(&v))
-    {}
+    explicit base_atomic(value_type const& v) BOOST_NOEXCEPT : v_(0)
+    {
+        memcpy(&tmp, &v, sizeof(value_type));
+    }
     base_atomic(void) {}
 
     void
diff --git a/include/boost/atomic/detail/generic-cas.hpp b/include/boost/atomic/detail/generic-cas.hpp
index d87c87d..f8cc3cc 100644
--- a/include/boost/atomic/detail/generic-cas.hpp
+++ b/include/boost/atomic/detail/generic-cas.hpp
@@ -118,7 +118,8 @@ namespace detail {
 
 #ifdef BOOST_ATOMIC_HAVE_CAS32
 template<typename T>
-class atomic_generic_cas32 {
+class atomic_generic_cas32
+{
 private:
     typedef atomic_generic_cas32 this_type;
 public:
@@ -168,7 +169,9 @@ private:
 };
 
 template<typename T>
-class platform_atomic_integral<T, 4> : public build_atomic_from_exchange<atomic_generic_cas32<T> > {
+class platform_atomic_integral<T, 4> :
+    public build_atomic_from_exchange<atomic_generic_cas32<T> >
+{
 public:
     typedef build_atomic_from_exchange<atomic_generic_cas32<T> > super;
     explicit platform_atomic_integral(T v) : super(v) {}
@@ -176,7 +179,9 @@ public:
 };
 
 template<typename T>
-class platform_atomic_integral<T, 1>: public build_atomic_from_larger_type<atomic_generic_cas32<int32_t>, T> {
+class platform_atomic_integral<T, 1> :
+   public build_atomic_from_larger_type<atomic_generic_cas32<int32_t>, T>
+{
 public:
     typedef build_atomic_from_larger_type<atomic_generic_cas32<int32_t>, T> super;
 
@@ -185,7 +190,9 @@ public:
 };
 
 template<typename T>
-class platform_atomic_integral<T, 2>: public build_atomic_from_larger_type<atomic_generic_cas32<int32_t>, T> {
+class platform_atomic_integral<T, 2> :
+    public build_atomic_from_larger_type<atomic_generic_cas32<int32_t>, T>
+{
 public:
     typedef build_atomic_from_larger_type<atomic_generic_cas32<int32_t>, T> super;
 
diff --git a/include/boost/atomic/detail/interlocked.hpp b/include/boost/atomic/detail/interlocked.hpp
index 84a7131..2cf21a1 100644
--- a/include/boost/atomic/detail/interlocked.hpp
+++ b/include/boost/atomic/detail/interlocked.hpp
@@ -2,7 +2,7 @@
 #define BOOST_ATOMIC_DETAIL_INTERLOCKED_HPP
 
 //  Copyright (c) 2009 Helge Bahmann
-//  Copyright (c) 2012 Andrey Semashev
+//  Copyright (c) 2012, 2013 Andrey Semashev
 //
 //  Distributed under the Boost Software License, Version 1.0.
 //  See accompanying file LICENSE_1_0.txt or copy at
@@ -14,7 +14,7 @@
 #pragma once
 #endif
 
-#if defined(_WIN32_WCE)
+#if defined(_WIN32_WCE) || (defined(_MSC_VER) && _MSC_VER < 1400)
 
 #include <boost/detail/interlocked.hpp>
 
@@ -25,30 +25,24 @@
 #define BOOST_ATOMIC_INTERLOCKED_EXCHANGE_POINTER(dest, newval) BOOST_INTERLOCKED_EXCHANGE_POINTER(dest, newval)
 #define BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD_POINTER(dest, byte_offset) ((void*)BOOST_INTERLOCKED_EXCHANGE_ADD((long*)(dest), byte_offset))
 
-#elif defined(_MSC_VER)
+#elif defined(_MSC_VER) && _MSC_VER >= 1400
 
 #include <intrin.h>
 
 #pragma intrinsic(_InterlockedCompareExchange)
 #pragma intrinsic(_InterlockedExchangeAdd)
 #pragma intrinsic(_InterlockedExchange)
-
-#define BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE(dest, exchange, compare) _InterlockedCompareExchange((long*)(dest), (long)(exchange), (long)(compare))
-#define BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD(dest, addend) _InterlockedExchangeAdd((long*)(dest), (long)(addend))
-#define BOOST_ATOMIC_INTERLOCKED_EXCHANGE(dest, newval) _InterlockedExchange((long*)(dest), (long)(newval))
-
-#if _MSC_VER >= 1400
-
 #pragma intrinsic(_InterlockedAnd)
 #pragma intrinsic(_InterlockedOr)
 #pragma intrinsic(_InterlockedXor)
 
+#define BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE(dest, exchange, compare) _InterlockedCompareExchange((long*)(dest), (long)(exchange), (long)(compare))
+#define BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD(dest, addend) _InterlockedExchangeAdd((long*)(dest), (long)(addend))
+#define BOOST_ATOMIC_INTERLOCKED_EXCHANGE(dest, newval) _InterlockedExchange((long*)(dest), (long)(newval))
 #define BOOST_ATOMIC_INTERLOCKED_AND(dest, arg) _InterlockedAnd((long*)(dest), (long)(arg))
 #define BOOST_ATOMIC_INTERLOCKED_OR(dest, arg) _InterlockedOr((long*)(dest), (long)(arg))
 #define BOOST_ATOMIC_INTERLOCKED_XOR(dest, arg) _InterlockedXor((long*)(dest), (long)(arg))
 
-#endif // _MSC_VER >= 1400
-
 #if _MSC_VER >= 1600
 
 // MSVC 2010 and later provide intrinsics for 8 and 16 bit integers.
@@ -108,15 +102,15 @@
 #define BOOST_ATOMIC_INTERLOCKED_EXCHANGE_POINTER(dest, newval) _InterlockedExchangePointer((void**)(dest), (void*)(newval))
 #define BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD_POINTER(dest, byte_offset) ((void*)BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD64((long*)(dest), byte_offset))
 
-#else // defined(_M_AMD64)
+#else // defined(_M_AMD64) || defined(_M_IA64)
 
 #define BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE_POINTER(dest, exchange, compare) ((void*)_InterlockedCompareExchange((long*)(dest), (long)(exchange), (long)(compare)))
 #define BOOST_ATOMIC_INTERLOCKED_EXCHANGE_POINTER(dest, newval) ((void*)_InterlockedExchange((long*)(dest), (long)(newval)))
 #define BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD_POINTER(dest, byte_offset) ((void*)BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD((long*)(dest), byte_offset))
 
-#endif // defined(_M_AMD64)
+#endif // defined(_M_AMD64) || defined(_M_IA64)
 
-#else // defined(_MSC_VER)
+#else // defined(_MSC_VER) && _MSC_VER >= 1400
 
 #if defined(BOOST_USE_WINDOWS_H)
 
diff --git a/include/boost/atomic/detail/linux-arm.hpp b/include/boost/atomic/detail/linux-arm.hpp
index f66fa8a..af1606e 100644
--- a/include/boost/atomic/detail/linux-arm.hpp
+++ b/include/boost/atomic/detail/linux-arm.hpp
@@ -133,13 +133,14 @@ atomic_signal_fence(memory_order)
     __asm__ __volatile__ ("" ::: "memory");
 }
 
-class atomic_flag {
+class atomic_flag
+{
 private:
     atomic_flag(const atomic_flag &) /* = delete */ ;
     atomic_flag & operator=(const atomic_flag &) /* = delete */ ;
     uint32_t v_;
 public:
-    atomic_flag(void) BOOST_NOEXCEPT: v_(false) {}
+    BOOST_CONSTEXPR atomic_flag(void) BOOST_NOEXCEPT : v_(0) {}
 
     void
     clear(memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
diff --git a/include/boost/atomic/detail/windows.hpp b/include/boost/atomic/detail/windows.hpp
index c044419..e01c6a5 100644
--- a/include/boost/atomic/detail/windows.hpp
+++ b/include/boost/atomic/detail/windows.hpp
@@ -3,7 +3,7 @@
 
 //  Copyright (c) 2009 Helge Bahmann
 //  Copyright (c) 2012 Andrey Semashev
-//  Copyright (c) 2013 Tim Blechmann
+//  Copyright (c) 2013 Tim Blechmann, Andrey Semashev
 //
 //  Distributed under the Boost Software License, Version 1.0.
 //  See accompanying file LICENSE_1_0.txt or copy at
@@ -25,10 +25,6 @@
 #pragma warning(disable: 4100)
 #endif
 
-namespace boost {
-namespace atomics {
-namespace detail {
-
 #if defined(_MSC_VER) && (defined(_M_AMD64) || defined(_M_IX86))
 extern "C" void _mm_pause(void);
 #pragma intrinsic(_mm_pause)
@@ -43,6 +39,23 @@ extern "C" void _mm_mfence(void);
 #pragma intrinsic(_mm_mfence)
 #endif
 
+// Define compiler barriers
+#if defined(__INTEL_COMPILER)
+#define BOOST_ATOMIC_COMPILER_BARRIER __memory_barrier();
+#elif defined(_MSC_VER) && _MSC_VER >= 1310 && !defined(_WIN32_WCE)
+extern "C" void _ReadWriteBarrier(void);
+#pragma intrinsic(_ReadWriteBarrier)
+#define BOOST_ATOMIC_COMPILER_BARRIER() _ReadWriteBarrier()
+#endif
+
+#ifndef BOOST_ATOMIC_COMPILER_BARRIER
+#define BOOST_ATOMIC_COMPILER_BARRIER()
+#endif
+
+namespace boost {
+namespace atomics {
+namespace detail {
+
 BOOST_FORCEINLINE void hardware_full_fence(void)
 {
 #if defined(_MSC_VER) && (defined(_M_AMD64) || (defined(_M_IX86) && defined(_M_IX86_FP) && _M_IX86_FP >= 2))
@@ -58,41 +71,41 @@ BOOST_FORCEINLINE void hardware_full_fence(void)
 #if defined(_MSC_VER) && _MSC_VER >= 1310 && !defined(_WIN32_WCE)
 extern "C" void _ReadWriteBarrier();
 #pragma intrinsic(_ReadWriteBarrier)
-#define BOOST_ATOMIC_READ_WRITE_BARRIER() _ReadWriteBarrier()
+#define BOOST_ATOMIC_COMPILER_BARRIER() _ReadWriteBarrier()
 #endif
 
-#ifndef BOOST_ATOMIC_READ_WRITE_BARRIER
-#define BOOST_ATOMIC_READ_WRITE_BARRIER()
+#ifndef BOOST_ATOMIC_COMPILER_BARRIER
+#define BOOST_ATOMIC_COMPILER_BARRIER()
 #endif
 
 BOOST_FORCEINLINE void
 platform_fence_before(memory_order)
 {
-    BOOST_ATOMIC_READ_WRITE_BARRIER();
+    BOOST_ATOMIC_COMPILER_BARRIER();
 }
 
 BOOST_FORCEINLINE void
 platform_fence_after(memory_order)
 {
-    BOOST_ATOMIC_READ_WRITE_BARRIER();
+    BOOST_ATOMIC_COMPILER_BARRIER();
 }
 
 BOOST_FORCEINLINE void
 platform_fence_before_store(memory_order)
 {
-    BOOST_ATOMIC_READ_WRITE_BARRIER();
+    BOOST_ATOMIC_COMPILER_BARRIER();
 }
 
 BOOST_FORCEINLINE void
 platform_fence_after_store(memory_order)
 {
-    BOOST_ATOMIC_READ_WRITE_BARRIER();
+    BOOST_ATOMIC_COMPILER_BARRIER();
 }
 
 BOOST_FORCEINLINE void
 platform_fence_after_load(memory_order order)
 {
-    BOOST_ATOMIC_READ_WRITE_BARRIER();
+    BOOST_ATOMIC_COMPILER_BARRIER();
 
     // On x86 and x86_64 there is no need for a hardware barrier,
     // even if seq_cst memory order is requested, because all
@@ -113,7 +126,7 @@ platform_fence_after_load(memory_order order)
 BOOST_FORCEINLINE void
 atomic_thread_fence(memory_order order)
 {
-    BOOST_ATOMIC_READ_WRITE_BARRIER();
+    BOOST_ATOMIC_COMPILER_BARRIER();
     if (order == memory_order_seq_cst)
         atomics::detail::hardware_full_fence();
 }
@@ -122,10 +135,10 @@ atomic_thread_fence(memory_order order)
 BOOST_FORCEINLINE void
 atomic_signal_fence(memory_order)
 {
-    BOOST_ATOMIC_READ_WRITE_BARRIER();
+    BOOST_ATOMIC_COMPILER_BARRIER();
 }
 
-#undef BOOST_ATOMIC_READ_WRITE_BARRIER
+#undef BOOST_ATOMIC_COMPILER_BARRIER
 
 class atomic_flag
 {
@@ -134,7 +147,7 @@ private:
     atomic_flag & operator=(const atomic_flag &) /* = delete */ ;
     uint32_t v_;
 public:
-    atomic_flag(void) BOOST_NOEXCEPT : v_(0) {}
+    BOOST_CONSTEXPR atomic_flag(void) BOOST_NOEXCEPT : v_(0) {}
 
     bool
     test_and_set(memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
@@ -196,7 +209,7 @@ class base_atomic<T, int, 1, Sign>
 #endif
     typedef T difference_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type v) BOOST_NOEXCEPT: v_(v) {}
+    BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT: v_(v) {}
     base_atomic(void) {}
 
     void
@@ -382,7 +395,7 @@ class base_atomic<T, int, 2, Sign>
 #endif
     typedef T difference_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type v) BOOST_NOEXCEPT: v_(v) {}
+    BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT: v_(v) {}
     base_atomic(void) {}
 
     void
@@ -560,7 +573,7 @@ class base_atomic<T, int, 4, Sign>
     typedef value_type storage_type;
     typedef T difference_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type v) BOOST_NOEXCEPT: v_(v) {}
+    BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT: v_(v) {}
     base_atomic(void) {}
 
     void
@@ -713,7 +726,7 @@ class base_atomic<T, int, 8, Sign>
     typedef value_type storage_type;
     typedef T difference_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type v) BOOST_NOEXCEPT: v_(v) {}
+    BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT: v_(v) {}
     base_atomic(void) {}
 
     void
@@ -867,7 +880,7 @@ class base_atomic<void*, void*, sizeof_pointer, Sign>
     typedef base_atomic this_type;
     typedef void* value_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type v) BOOST_NOEXCEPT: v_(v) {}
+    BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT: v_(v) {}
     base_atomic(void) {}
 
     void
@@ -939,7 +952,7 @@ class base_atomic<T*, void*, sizeof_pointer, Sign>
     typedef T* value_type;
     typedef ptrdiff_t difference_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type v) BOOST_NOEXCEPT: v_(v) {}
+    BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT: v_(v) {}
     base_atomic(void) {}
 
     void
@@ -1040,9 +1053,16 @@ class base_atomic<T, void, 1, Sign>
     typedef uint32_t storage_type;
 #endif
 public:
-    BOOST_CONSTEXPR base_atomic(value_type const& v) BOOST_NOEXCEPT:
-        v_(*reinterpret_cast<storage_type*>(&v))
-    {}
+#ifdef BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE8
+    BOOST_CONSTEXPR explicit base_atomic(value_type const& v) BOOST_NOEXCEPT : v_(reinterpret_cast< storage_type const& >(v))
+    {
+    }
+#else
+    explicit base_atomic(value_type const& v) BOOST_NOEXCEPT : v_(0)
+    {
+        memcpy(&v_, &v, sizeof(value_type));
+    }
+#endif
     base_atomic(void) {}
 
     void
@@ -1144,9 +1164,16 @@ class base_atomic<T, void, 2, Sign>
     typedef uint32_t storage_type;
 #endif
 public:
-    BOOST_CONSTEXPR base_atomic(value_type const& v) BOOST_NOEXCEPT:
-        v_(*reinterpret_cast<storage_type*>(&v))
-    {}
+#ifdef BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE16
+    BOOST_CONSTEXPR explicit base_atomic(value_type const& v) BOOST_NOEXCEPT : v_(reinterpret_cast< storage_type const& >(v))
+    {
+    }
+#else
+    explicit base_atomic(value_type const& v) BOOST_NOEXCEPT : v_(0)
+    {
+        memcpy(&v_, &v, sizeof(value_type));
+    }
+#endif
 
     base_atomic(void) {}