diff --git a/include/boost/atomic/atomic.hpp b/include/boost/atomic/atomic.hpp
index 8b0bdd1..2793dde 100644
--- a/include/boost/atomic/atomic.hpp
+++ b/include/boost/atomic/atomic.hpp
@@ -21,6 +21,7 @@
 #include <boost/atomic/atomic_flag.hpp>
 #include <boost/atomic/detail/atomic_template.hpp>
 #include <boost/atomic/detail/operations.hpp>
+#include <boost/atomic/detail/extra_operations.hpp>
 
 #ifdef BOOST_HAS_PRAGMA_ONCE
 #pragma once
diff --git a/include/boost/atomic/detail/atomic_template.hpp b/include/boost/atomic/detail/atomic_template.hpp
index 4091e9c..28de879 100644
--- a/include/boost/atomic/detail/atomic_template.hpp
+++ b/include/boost/atomic/detail/atomic_template.hpp
@@ -22,6 +22,7 @@
 #include <boost/atomic/detail/config.hpp>
 #include <boost/atomic/detail/bitwise_cast.hpp>
 #include <boost/atomic/detail/operations_fwd.hpp>
+#include <boost/atomic/detail/extra_operations_fwd.hpp>
 #include <boost/atomic/detail/type_traits/is_signed.hpp>
 #include <boost/atomic/detail/type_traits/is_integral.hpp>
 #include <boost/atomic/detail/type_traits/is_function.hpp>
@@ -231,6 +232,7 @@ public:
 
 protected:
     typedef atomics::detail::operations< storage_size_of< value_type >::value, boost::atomics::detail::is_signed< T >::value > operations;
+    typedef atomics::detail::extra_operations< operations, operations::storage_size, operations::is_signed > extra_operations;
     typedef value_type value_arg_type;
 
 public:
@@ -336,90 +338,90 @@ public:
     // Boost.Atomic extensions
     BOOST_FORCEINLINE value_type fetch_negate(memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
     {
-        return static_cast< value_type >(operations::fetch_negate(m_storage.value, order));
+        return static_cast< value_type >(extra_operations::fetch_negate(m_storage.value, order));
     }
 
     BOOST_FORCEINLINE value_type fetch_complement(memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
     {
-        return static_cast< value_type >(operations::fetch_complement(m_storage.value, order));
+        return static_cast< value_type >(extra_operations::fetch_complement(m_storage.value, order));
     }
 
     BOOST_FORCEINLINE void opaque_add(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
     {
-        operations::opaque_add(m_storage.value, static_cast< storage_type >(v), order);
+        extra_operations::opaque_add(m_storage.value, static_cast< storage_type >(v), order);
     }
 
     BOOST_FORCEINLINE void opaque_sub(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
     {
-        operations::opaque_sub(m_storage.value, static_cast< storage_type >(v), order);
+        extra_operations::opaque_sub(m_storage.value, static_cast< storage_type >(v), order);
     }
 
     BOOST_FORCEINLINE void opaque_negate(memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
     {
-        operations::opaque_negate(m_storage.value, order);
+        extra_operations::opaque_negate(m_storage.value, order);
     }
 
     BOOST_FORCEINLINE void opaque_and(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
     {
-        operations::opaque_and(m_storage.value, static_cast< storage_type >(v), order);
+        extra_operations::opaque_and(m_storage.value, static_cast< storage_type >(v), order);
     }
 
     BOOST_FORCEINLINE void opaque_or(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
     {
-        operations::opaque_or(m_storage.value, static_cast< storage_type >(v), order);
+        extra_operations::opaque_or(m_storage.value, static_cast< storage_type >(v), order);
     }
 
     BOOST_FORCEINLINE void opaque_xor(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
     {
-        operations::opaque_xor(m_storage.value, static_cast< storage_type >(v), order);
+        extra_operations::opaque_xor(m_storage.value, static_cast< storage_type >(v), order);
     }
 
     BOOST_FORCEINLINE void opaque_complement(memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
     {
-        operations::opaque_complement(m_storage.value, order);
+        extra_operations::opaque_complement(m_storage.value, order);
     }
 
     BOOST_FORCEINLINE bool add_and_test(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
     {
-        return operations::add_and_test(m_storage.value, static_cast< storage_type >(v), order);
+        return extra_operations::add_and_test(m_storage.value, static_cast< storage_type >(v), order);
     }
 
     BOOST_FORCEINLINE bool sub_and_test(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
     {
-        return operations::sub_and_test(m_storage.value, static_cast< storage_type >(v), order);
+        return extra_operations::sub_and_test(m_storage.value, static_cast< storage_type >(v), order);
     }
 
     BOOST_FORCEINLINE bool and_and_test(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
     {
-        return operations::and_and_test(m_storage.value, static_cast< storage_type >(v), order);
+        return extra_operations::and_and_test(m_storage.value, static_cast< storage_type >(v), order);
     }
 
     BOOST_FORCEINLINE bool or_and_test(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
     {
-        return operations::or_and_test(m_storage.value, static_cast< storage_type >(v), order);
+        return extra_operations::or_and_test(m_storage.value, static_cast< storage_type >(v), order);
     }
 
     BOOST_FORCEINLINE bool xor_and_test(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
     {
-        return operations::xor_and_test(m_storage.value, static_cast< storage_type >(v), order);
+        return extra_operations::xor_and_test(m_storage.value, static_cast< storage_type >(v), order);
     }
 
     BOOST_FORCEINLINE bool bit_test_and_set(unsigned int bit_number, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
     {
         BOOST_ASSERT(bit_number < sizeof(value_type) * 8u);
-        return operations::bit_test_and_set(m_storage.value, bit_number, order);
+        return extra_operations::bit_test_and_set(m_storage.value, bit_number, order);
     }
 
     BOOST_FORCEINLINE bool bit_test_and_reset(unsigned int bit_number, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
     {
         BOOST_ASSERT(bit_number < sizeof(value_type) * 8u);
-        return operations::bit_test_and_reset(m_storage.value, bit_number, order);
+        return extra_operations::bit_test_and_reset(m_storage.value, bit_number, order);
     }
 
     BOOST_FORCEINLINE bool bit_test_and_complement(unsigned int bit_number, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
     {
         BOOST_ASSERT(bit_number < sizeof(value_type) * 8u);
-        return operations::bit_test_and_complement(m_storage.value, bit_number, order);
+        return extra_operations::bit_test_and_complement(m_storage.value, bit_number, order);
     }
 
     // Operators
@@ -573,6 +575,7 @@ public:
 
 protected:
     typedef atomics::detail::operations< storage_size_of< value_type >::value, false > operations;
+    typedef atomics::detail::extra_operations< operations, operations::storage_size, operations::is_signed > extra_operations;
     typedef value_type value_arg_type;
 
 public:
@@ -665,22 +668,22 @@ public:
     // Boost.Atomic extensions
     BOOST_FORCEINLINE void opaque_add(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
     {
-        operations::opaque_add(m_storage.value, static_cast< storage_type >(v * sizeof(T)), order);
+        extra_operations::opaque_add(m_storage.value, static_cast< storage_type >(v * sizeof(T)), order);
     }
 
     BOOST_FORCEINLINE void opaque_sub(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
     {
-        operations::opaque_sub(m_storage.value, static_cast< storage_type >(v * sizeof(T)), order);
+        extra_operations::opaque_sub(m_storage.value, static_cast< storage_type >(v * sizeof(T)), order);
     }
 
     BOOST_FORCEINLINE bool add_and_test(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
     {
-        return operations::add_and_test(m_storage.value, static_cast< storage_type >(v * sizeof(T)), order);
+        return extra_operations::add_and_test(m_storage.value, static_cast< storage_type >(v * sizeof(T)), order);
     }
 
     BOOST_FORCEINLINE bool sub_and_test(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
     {
-        return operations::sub_and_test(m_storage.value, static_cast< storage_type >(v * sizeof(T)), order);
+        return extra_operations::sub_and_test(m_storage.value, static_cast< storage_type >(v * sizeof(T)), order);
     }
 
     // Operators
diff --git a/include/boost/atomic/detail/ext_ops_gcc_x86.hpp b/include/boost/atomic/detail/extra_ops_gcc_x86.hpp
similarity index 95%
rename from include/boost/atomic/detail/ext_ops_gcc_x86.hpp
rename to include/boost/atomic/detail/extra_ops_gcc_x86.hpp
index 8c824f7..b42d593 100644
--- a/include/boost/atomic/detail/ext_ops_gcc_x86.hpp
+++ b/include/boost/atomic/detail/extra_ops_gcc_x86.hpp
@@ -6,17 +6,20 @@
  * Copyright (c) 2015 Andrey Semashev
  */
 /*!
- * \file   atomic/detail/ext_ops_gcc_x86.hpp
+ * \file   atomic/detail/extra_ops_gcc_x86.hpp
  *
- * This header contains implementation of the extended atomic operations for x86.
+ * This header contains implementation of the extra atomic operations for x86.
  */
 
-#ifndef BOOST_ATOMIC_DETAIL_EXT_OPS_GCC_X86_HPP_INCLUDED_
-#define BOOST_ATOMIC_DETAIL_EXT_OPS_GCC_X86_HPP_INCLUDED_
+#ifndef BOOST_ATOMIC_DETAIL_EXTRA_OPS_GCC_X86_HPP_INCLUDED_
+#define BOOST_ATOMIC_DETAIL_EXTRA_OPS_GCC_X86_HPP_INCLUDED_
 
+#include <cstddef>
+#include <boost/cstdint.hpp>
 #include <boost/memory_order.hpp>
 #include <boost/atomic/detail/config.hpp>
 #include <boost/atomic/detail/storage_type.hpp>
+#include <boost/atomic/detail/extra_operations_fwd.hpp>
 #include <boost/atomic/capabilities.hpp>
 
 #ifdef BOOST_HAS_PRAGMA_ONCE
@@ -28,7 +31,7 @@ namespace atomics {
 namespace detail {
 
 template< typename Base >
-struct gcc_x86_extended_operations_common :
+struct gcc_x86_extra_operations_common :
     public Base
 {
     typedef Base base_type;
@@ -107,26 +110,23 @@ struct gcc_x86_extended_operations_common :
     }
 };
 
-template< std::size_t Size, bool Signed, typename Base >
-struct gcc_x86_extended_operations;
-
-template< bool Signed, typename Base >
-struct gcc_x86_extended_operations< 1u, Signed, Base > :
-    public gcc_x86_extended_operations_common< Base >
+template< typename Base, bool Signed >
+struct extra_operations< Base, 1u, Signed > :
+    public gcc_x86_extra_operations_common< Base >
 {
-    typedef gcc_x86_extended_operations_common< Base > base_type;
+    typedef gcc_x86_extra_operations_common< Base > base_type;
     typedef typename base_type::storage_type storage_type;
 
 #define BOOST_ATOMIC_DETAIL_CAS_LOOP(op, result)\
-    storage_type new_val;\
+    boost::uint32_t new_val;\
     __asm__ __volatile__\
     (\
         ".align 16\n\t"\
-        "1: mov %[res], %[new_val]\n\t"\
-        op " %[new_val]\n\t"\
-        "lock; cmpxchgb %[new_val], %[storage]\n\t"\
+        "1: movzbl %[res], %2\n\t"\
+        op " %b2\n\t"\
+        "lock; cmpxchgb %b2, %[storage]\n\t"\
         "jne 1b"\
-        : [res] "+a" (result), [storage] "+m" (storage), [new_val] "=&q" (new_val)\
+        : [res] "+a" (result), [storage] "+m" (storage), "=&q" (new_val)\
         : \
         : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC_COMMA "memory"\
     )
@@ -425,23 +425,23 @@ struct gcc_x86_extended_operations< 1u, Signed, Base > :
     }
 };
 
-template< bool Signed, typename Base >
-struct gcc_x86_extended_operations< 2u, Signed, Base > :
-    public gcc_x86_extended_operations_common< Base >
+template< typename Base, bool Signed >
+struct extra_operations< Base, 2u, Signed > :
+    public gcc_x86_extra_operations_common< Base >
 {
-    typedef gcc_x86_extended_operations_common< Base > base_type;
+    typedef gcc_x86_extra_operations_common< Base > base_type;
     typedef typename base_type::storage_type storage_type;
 
 #define BOOST_ATOMIC_DETAIL_CAS_LOOP(op, result)\
-    storage_type new_val;\
+    boost::uint32_t new_val;\
     __asm__ __volatile__\
     (\
         ".align 16\n\t"\
-        "1: mov %[res], %[new_val]\n\t"\
-        op " %[new_val]\n\t"\
-        "lock; cmpxchgw %[new_val], %[storage]\n\t"\
+        "1: movzwl %[res], %2\n\t"\
+        op " %w2\n\t"\
+        "lock; cmpxchgw %w2, %[storage]\n\t"\
         "jne 1b"\
-        : [res] "+a" (result), [storage] "+m" (storage), [new_val] "=&q" (new_val)\
+        : [res] "+a" (result), [storage] "+m" (storage), "=&q" (new_val)\
         : \
         : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC_COMMA "memory"\
     )
@@ -740,11 +740,11 @@ struct gcc_x86_extended_operations< 2u, Signed, Base > :
     }
 };
 
-template< bool Signed, typename Base >
-struct gcc_x86_extended_operations< 4u, Signed, Base > :
-    public gcc_x86_extended_operations_common< Base >
+template< typename Base, bool Signed >
+struct extra_operations< Base, 4u, Signed > :
+    public gcc_x86_extra_operations_common< Base >
 {
-    typedef gcc_x86_extended_operations_common< Base > base_type;
+    typedef gcc_x86_extra_operations_common< Base > base_type;
     typedef typename base_type::storage_type storage_type;
 
 #define BOOST_ATOMIC_DETAIL_CAS_LOOP(op, result)\
@@ -1057,11 +1057,11 @@ struct gcc_x86_extended_operations< 4u, Signed, Base > :
 
 #if defined(__x86_64__)
 
-template< bool Signed, typename Base >
-struct gcc_x86_extended_operations< 8u, Signed, Base > :
-    public gcc_x86_extended_operations_common< Base >
+template< typename Base, bool Signed >
+struct extra_operations< Base, 8u, Signed > :
+    public gcc_x86_extra_operations_common< Base >
 {
-    typedef gcc_x86_extended_operations_common< Base > base_type;
+    typedef gcc_x86_extra_operations_common< Base > base_type;
     typedef typename base_type::storage_type storage_type;
 
 #define BOOST_ATOMIC_DETAIL_CAS_LOOP(op, result)\
@@ -1378,4 +1378,4 @@ struct gcc_x86_extended_operations< 8u, Signed, Base > :
 } // namespace atomics
 } // namespace boost
 
-#endif // BOOST_ATOMIC_DETAIL_EXT_OPS_GCC_X86_HPP_INCLUDED_
+#endif // BOOST_ATOMIC_DETAIL_EXTRA_OPS_GCC_X86_HPP_INCLUDED_
diff --git a/include/boost/atomic/detail/ext_ops_generic.hpp b/include/boost/atomic/detail/extra_ops_generic.hpp
similarity index 91%
rename from include/boost/atomic/detail/ext_ops_generic.hpp
rename to include/boost/atomic/detail/extra_ops_generic.hpp
index 46a789e..ed25be6 100644
--- a/include/boost/atomic/detail/ext_ops_generic.hpp
+++ b/include/boost/atomic/detail/extra_ops_generic.hpp
@@ -6,17 +6,19 @@
  * Copyright (c) 2015 Andrey Semashev
  */
 /*!
- * \file   atomic/detail/ext_ops_generic.hpp
+ * \file   atomic/detail/extra_ops_generic.hpp
  *
- * This header contains generic implementation of the extended atomic operations.
+ * This header contains generic implementation of the extra atomic operations.
  */
 
-#ifndef BOOST_ATOMIC_DETAIL_EXT_OPS_GENERIC_HPP_INCLUDED_
-#define BOOST_ATOMIC_DETAIL_EXT_OPS_GENERIC_HPP_INCLUDED_
+#ifndef BOOST_ATOMIC_DETAIL_EXTRA_OPS_GENERIC_HPP_INCLUDED_
+#define BOOST_ATOMIC_DETAIL_EXTRA_OPS_GENERIC_HPP_INCLUDED_
 
+#include <cstddef>
 #include <boost/memory_order.hpp>
 #include <boost/atomic/detail/config.hpp>
 #include <boost/atomic/detail/storage_type.hpp>
+#include <boost/atomic/detail/extra_operations_fwd.hpp>
 #include <boost/atomic/capabilities.hpp>
 
 #ifdef BOOST_HAS_PRAGMA_ONCE
@@ -27,8 +29,9 @@ namespace boost {
 namespace atomics {
 namespace detail {
 
+// Default extra_operations template definition will be used unless specialized for a specific platform
 template< typename Base, std::size_t Size, bool Signed >
-struct generic_extended_operations :
+struct extra_operations :
     public Base
 {
     typedef Base base_type;
@@ -139,4 +142,4 @@ struct generic_extended_operations :
 } // namespace atomics
 } // namespace boost
 
-#endif // BOOST_ATOMIC_DETAIL_EXT_OPS_GENERIC_HPP_INCLUDED_
+#endif // BOOST_ATOMIC_DETAIL_EXTRA_OPS_GENERIC_HPP_INCLUDED_
diff --git a/include/boost/atomic/detail/ops_emulated.hpp b/include/boost/atomic/detail/ops_emulated.hpp
index e15f37a..437b62f 100644
--- a/include/boost/atomic/detail/ops_emulated.hpp
+++ b/include/boost/atomic/detail/ops_emulated.hpp
@@ -149,6 +149,9 @@ struct operations :
     public emulated_operations< typename make_storage_type< Size, Signed >::type >
 {
     typedef typename make_storage_type< Size, Signed >::aligned aligned_storage_type;
+
+    static BOOST_CONSTEXPR_OR_CONST std::size_t storage_size = Size;
+    static BOOST_CONSTEXPR_OR_CONST bool is_signed = Signed;
 };
 
 } // namespace detail
diff --git a/include/boost/atomic/detail/ops_gcc_alpha.hpp b/include/boost/atomic/detail/ops_gcc_alpha.hpp
index 5a9deb4..71846a8 100644
--- a/include/boost/atomic/detail/ops_gcc_alpha.hpp
+++ b/include/boost/atomic/detail/ops_gcc_alpha.hpp
@@ -16,6 +16,7 @@
 #ifndef BOOST_ATOMIC_DETAIL_OPS_GCC_ALPHA_HPP_INCLUDED_
 #define BOOST_ATOMIC_DETAIL_OPS_GCC_ALPHA_HPP_INCLUDED_
 
+#include <cstddef>
 #include <boost/memory_order.hpp>
 #include <boost/atomic/detail/config.hpp>
 #include <boost/atomic/detail/storage_type.hpp>
@@ -92,6 +93,9 @@ struct operations< 4u, Signed > :
     typedef typename make_storage_type< 4u, Signed >::type storage_type;
     typedef typename make_storage_type< 4u, Signed >::aligned aligned_storage_type;
 
+    static BOOST_CONSTEXPR_OR_CONST std::size_t storage_size = 4u;
+    static BOOST_CONSTEXPR_OR_CONST bool is_signed = Signed;
+
     static BOOST_FORCEINLINE void store(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
     {
         fence_before(order);
@@ -599,6 +603,9 @@ struct operations< 8u, Signed > :
     typedef typename make_storage_type< 8u, Signed >::type storage_type;
     typedef typename make_storage_type< 8u, Signed >::aligned aligned_storage_type;
 
+    static BOOST_CONSTEXPR_OR_CONST std::size_t storage_size = 8u;
+    static BOOST_CONSTEXPR_OR_CONST bool is_signed = Signed;
+
     static BOOST_FORCEINLINE void store(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
     {
         fence_before(order);
diff --git a/include/boost/atomic/detail/ops_gcc_arm.hpp b/include/boost/atomic/detail/ops_gcc_arm.hpp
index 86a75f5..4513abd 100644
--- a/include/boost/atomic/detail/ops_gcc_arm.hpp
+++ b/include/boost/atomic/detail/ops_gcc_arm.hpp
@@ -16,6 +16,7 @@
 #ifndef BOOST_ATOMIC_DETAIL_OPS_GCC_ARM_HPP_INCLUDED_
 #define BOOST_ATOMIC_DETAIL_OPS_GCC_ARM_HPP_INCLUDED_
 
+#include <cstddef>
 #include <boost/cstdint.hpp>
 #include <boost/memory_order.hpp>
 #include <boost/atomic/detail/config.hpp>
@@ -160,6 +161,9 @@ struct operations< 4u, Signed > :
     typedef typename make_storage_type< 4u, Signed >::type storage_type;
     typedef typename make_storage_type< 4u, Signed >::aligned aligned_storage_type;
 
+    static BOOST_CONSTEXPR_OR_CONST std::size_t storage_size = 4u;
+    static BOOST_CONSTEXPR_OR_CONST bool is_signed = Signed;
+
     static BOOST_FORCEINLINE void store(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
     {
         fence_before(order);
@@ -677,6 +681,9 @@ struct operations< 8u, Signed > :
     typedef typename make_storage_type< 8u, Signed >::type storage_type;
     typedef typename make_storage_type< 8u, Signed >::aligned aligned_storage_type;
 
+    static BOOST_CONSTEXPR_OR_CONST std::size_t storage_size = 8u;
+    static BOOST_CONSTEXPR_OR_CONST bool is_signed = Signed;
+
     static BOOST_FORCEINLINE void store(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
     {
         exchange(storage, v, order);
diff --git a/include/boost/atomic/detail/ops_gcc_atomic.hpp b/include/boost/atomic/detail/ops_gcc_atomic.hpp
index 4e1adae..25ed9fc 100644
--- a/include/boost/atomic/detail/ops_gcc_atomic.hpp
+++ b/include/boost/atomic/detail/ops_gcc_atomic.hpp
@@ -14,6 +14,7 @@
 #ifndef BOOST_ATOMIC_DETAIL_OPS_GCC_ATOMIC_HPP_INCLUDED_
 #define BOOST_ATOMIC_DETAIL_OPS_GCC_ATOMIC_HPP_INCLUDED_
 
+#include <cstddef>
 #include <boost/memory_order.hpp>
 #include <boost/atomic/detail/config.hpp>
 #include <boost/atomic/detail/storage_type.hpp>
@@ -172,6 +173,8 @@ template< bool Signed >
 struct operations< 16u, Signed > :
     public cas_based_operations< gcc_dcas_x86_64< Signed > >
 {
+    static BOOST_CONSTEXPR_OR_CONST std::size_t storage_size = 16u;
+    static BOOST_CONSTEXPR_OR_CONST bool is_signed = Signed;
 };
 
 #else
@@ -181,6 +184,9 @@ struct operations< 16u, Signed > :
     public gcc_atomic_operations< typename make_storage_type< 16u, Signed >::type >
 {
     typedef typename make_storage_type< 16u, Signed >::aligned aligned_storage_type;
+
+    static BOOST_CONSTEXPR_OR_CONST std::size_t storage_size = 16u;
+    static BOOST_CONSTEXPR_OR_CONST bool is_signed = Signed;
 };
 
 #endif
@@ -195,6 +201,8 @@ template< bool Signed >
 struct operations< 8u, Signed > :
     public cas_based_operations< gcc_dcas_x86< Signed > >
 {
+    static BOOST_CONSTEXPR_OR_CONST std::size_t storage_size = 8u;
+    static BOOST_CONSTEXPR_OR_CONST bool is_signed = Signed;
 };
 
 #elif (BOOST_ATOMIC_DETAIL_SIZEOF_LLONG == 8 && __GCC_ATOMIC_LLONG_LOCK_FREE != BOOST_ATOMIC_LLONG_LOCK_FREE) ||\
@@ -210,6 +218,9 @@ struct operations< 8u, Signed > :
     public extending_cas_based_operations< gcc_atomic_operations< typename make_storage_type< 16u, Signed >::type >, 8u, Signed >
 {
     typedef typename make_storage_type< 16u, Signed >::aligned aligned_storage_type;
+
+    static BOOST_CONSTEXPR_OR_CONST std::size_t storage_size = 8u;
+    static BOOST_CONSTEXPR_OR_CONST bool is_signed = Signed;
 };
 
 #else
@@ -219,6 +230,9 @@ struct operations< 8u, Signed > :
     public gcc_atomic_operations< typename make_storage_type< 8u, Signed >::type >
 {
     typedef typename make_storage_type< 8u, Signed >::aligned aligned_storage_type;
+
+    static BOOST_CONSTEXPR_OR_CONST std::size_t storage_size = 8u;
+    static BOOST_CONSTEXPR_OR_CONST bool is_signed = Signed;
 };
 
 #endif
@@ -240,6 +254,9 @@ struct operations< 4u, Signed > :
     public extending_cas_based_operations< gcc_atomic_operations< typename make_storage_type< 8u, Signed >::type >, 4u, Signed >
 {
     typedef typename make_storage_type< 8u, Signed >::aligned aligned_storage_type;
+
+    static BOOST_CONSTEXPR_OR_CONST std::size_t storage_size = 8u;
+    static BOOST_CONSTEXPR_OR_CONST bool is_signed = Signed;
 };
 
 #else // !defined(BOOST_ATOMIC_DETAIL_INT64_EXTENDED)
@@ -249,6 +266,9 @@ struct operations< 4u, Signed > :
     public extending_cas_based_operations< gcc_atomic_operations< typename make_storage_type< 16u, Signed >::type >, 4u, Signed >
 {
     typedef typename make_storage_type< 16u, Signed >::aligned aligned_storage_type;
+
+    static BOOST_CONSTEXPR_OR_CONST std::size_t storage_size = 16u;
+    static BOOST_CONSTEXPR_OR_CONST bool is_signed = Signed;
 };
 
 #endif // !defined(BOOST_ATOMIC_DETAIL_INT64_EXTENDED)
@@ -260,6 +280,9 @@ struct operations< 4u, Signed > :
     public gcc_atomic_operations< typename make_storage_type< 4u, Signed >::type >
 {
     typedef typename make_storage_type< 4u, Signed >::aligned aligned_storage_type;
+
+    static BOOST_CONSTEXPR_OR_CONST std::size_t storage_size = 4u;
+    static BOOST_CONSTEXPR_OR_CONST bool is_signed = Signed;
 };
 
 #endif
@@ -281,6 +304,9 @@ struct operations< 2u, Signed > :
     public extending_cas_based_operations< gcc_atomic_operations< typename make_storage_type< 4u, Signed >::type >, 2u, Signed >
 {
     typedef typename make_storage_type< 4u, Signed >::aligned aligned_storage_type;
+
+    static BOOST_CONSTEXPR_OR_CONST std::size_t storage_size = 4u;
+    static BOOST_CONSTEXPR_OR_CONST bool is_signed = Signed;
 };
 
 #elif !defined(BOOST_ATOMIC_DETAIL_INT64_EXTENDED)
@@ -290,6 +316,9 @@ struct operations< 2u, Signed > :
     public extending_cas_based_operations< gcc_atomic_operations< typename make_storage_type< 8u, Signed >::type >, 2u, Signed >
 {
     typedef typename make_storage_type< 8u, Signed >::aligned aligned_storage_type;
+
+    static BOOST_CONSTEXPR_OR_CONST std::size_t storage_size = 8u;
+    static BOOST_CONSTEXPR_OR_CONST bool is_signed = Signed;
 };
 
 #else
@@ -299,6 +328,9 @@ struct operations< 2u, Signed > :
     public extending_cas_based_operations< gcc_atomic_operations< typename make_storage_type< 16u, Signed >::type >, 2u, Signed >
 {
     typedef typename make_storage_type< 16u, Signed >::aligned aligned_storage_type;
+
+    static BOOST_CONSTEXPR_OR_CONST std::size_t storage_size = 16u;
+    static BOOST_CONSTEXPR_OR_CONST bool is_signed = Signed;
 };
 
 #endif
@@ -310,6 +342,9 @@ struct operations< 2u, Signed > :
     public gcc_atomic_operations< typename make_storage_type< 2u, Signed >::type >
 {
     typedef typename make_storage_type< 2u, Signed >::aligned aligned_storage_type;
+
+    static BOOST_CONSTEXPR_OR_CONST std::size_t storage_size = 2u;
+    static BOOST_CONSTEXPR_OR_CONST bool is_signed = Signed;
 };
 
 #endif
@@ -331,6 +366,9 @@ struct operations< 1u, Signed > :
     public extending_cas_based_operations< gcc_atomic_operations< typename make_storage_type< 2u, Signed >::type >, 1u, Signed >
 {
     typedef typename make_storage_type< 2u, Signed >::aligned aligned_storage_type;
+
+    static BOOST_CONSTEXPR_OR_CONST std::size_t storage_size = 2u;
+    static BOOST_CONSTEXPR_OR_CONST bool is_signed = Signed;
 };
 
 #elif !defined(BOOST_ATOMIC_DETAIL_INT32_EXTENDED)
@@ -340,6 +378,9 @@ struct operations< 1u, Signed > :
     public extending_cas_based_operations< gcc_atomic_operations< typename make_storage_type< 4u, Signed >::type >, 1u, Signed >
 {
     typedef typename make_storage_type< 4u, Signed >::aligned aligned_storage_type;
+
+    static BOOST_CONSTEXPR_OR_CONST std::size_t storage_size = 4u;
+    static BOOST_CONSTEXPR_OR_CONST bool is_signed = Signed;
 };
 
 #elif !defined(BOOST_ATOMIC_DETAIL_INT64_EXTENDED)
@@ -349,6 +390,9 @@ struct operations< 1u, Signed > :
     public extending_cas_based_operations< gcc_atomic_operations< typename make_storage_type< 8u, Signed >::type >, 1u, Signed >
 {
     typedef typename make_storage_type< 8u, Signed >::aligned aligned_storage_type;
+
+    static BOOST_CONSTEXPR_OR_CONST std::size_t storage_size = 8u;
+    static BOOST_CONSTEXPR_OR_CONST bool is_signed = Signed;
 };
 
 #else
@@ -358,6 +402,9 @@ struct operations< 1u, Signed > :
     public extending_cas_based_operations< gcc_atomic_operations< typename make_storage_type< 16u, Signed >::type >, 1u, Signed >
 {
     typedef typename make_storage_type< 16u, Signed >::aligned aligned_storage_type;
+
+    static BOOST_CONSTEXPR_OR_CONST std::size_t storage_size = 16u;
+    static BOOST_CONSTEXPR_OR_CONST bool is_signed = Signed;
 };
 
 #endif
@@ -369,6 +416,9 @@ struct operations< 1u, Signed > :
     public gcc_atomic_operations< typename make_storage_type< 1u, Signed >::type >
 {
     typedef typename make_storage_type< 1u, Signed >::aligned aligned_storage_type;
+
+    static BOOST_CONSTEXPR_OR_CONST std::size_t storage_size = 1u;
+    static BOOST_CONSTEXPR_OR_CONST bool is_signed = Signed;
 };
 
 #endif
diff --git a/include/boost/atomic/detail/ops_gcc_ppc.hpp b/include/boost/atomic/detail/ops_gcc_ppc.hpp
index 76eae4e..ca13553 100644
--- a/include/boost/atomic/detail/ops_gcc_ppc.hpp
+++ b/include/boost/atomic/detail/ops_gcc_ppc.hpp
@@ -16,6 +16,7 @@
 #ifndef BOOST_ATOMIC_DETAIL_OPS_GCC_PPC_HPP_INCLUDED_
 #define BOOST_ATOMIC_DETAIL_OPS_GCC_PPC_HPP_INCLUDED_
 
+#include <cstddef>
 #include <boost/memory_order.hpp>
 #include <boost/atomic/detail/config.hpp>
 #include <boost/atomic/detail/storage_type.hpp>
@@ -115,6 +116,9 @@ struct operations< 4u, Signed > :
     typedef typename make_storage_type< 4u, Signed >::type storage_type;
     typedef typename make_storage_type< 4u, Signed >::aligned aligned_storage_type;
 
+    static BOOST_CONSTEXPR_OR_CONST std::size_t storage_size = 4u;
+    static BOOST_CONSTEXPR_OR_CONST bool is_signed = Signed;
+
     static BOOST_FORCEINLINE void store(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
     {
         fence_before(order);
@@ -537,6 +541,9 @@ struct operations< 8u, Signed > :
     typedef typename make_storage_type< 8u, Signed >::type storage_type;
     typedef typename make_storage_type< 8u, Signed >::aligned aligned_storage_type;
 
+    static BOOST_CONSTEXPR_OR_CONST std::size_t storage_size = 8u;
+    static BOOST_CONSTEXPR_OR_CONST bool is_signed = Signed;
+
     static BOOST_FORCEINLINE void store(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
     {
         fence_before(order);
diff --git a/include/boost/atomic/detail/ops_gcc_sparc.hpp b/include/boost/atomic/detail/ops_gcc_sparc.hpp
index 08492ac..9191c13 100644
--- a/include/boost/atomic/detail/ops_gcc_sparc.hpp
+++ b/include/boost/atomic/detail/ops_gcc_sparc.hpp
@@ -16,6 +16,7 @@
 #ifndef BOOST_ATOMIC_DETAIL_OPS_GCC_SPARC_HPP_INCLUDED_
 #define BOOST_ATOMIC_DETAIL_OPS_GCC_SPARC_HPP_INCLUDED_
 
+#include <cstddef>
 #include <boost/memory_order.hpp>
 #include <boost/atomic/detail/config.hpp>
 #include <boost/atomic/detail/storage_type.hpp>
@@ -66,6 +67,9 @@ struct gcc_sparc_cas32 :
     typedef typename make_storage_type< 4u, Signed >::type storage_type;
     typedef typename make_storage_type< 4u, Signed >::aligned aligned_storage_type;
 
+    static BOOST_CONSTEXPR_OR_CONST std::size_t storage_size = 4u;
+    static BOOST_CONSTEXPR_OR_CONST bool is_signed = Signed;
+
     static BOOST_FORCEINLINE void store(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
     {
         fence_before(order);
@@ -147,6 +151,9 @@ struct gcc_sparc_cas64 :
     typedef typename make_storage_type< 8u, Signed >::type storage_type;
     typedef typename make_storage_type< 8u, Signed >::aligned aligned_storage_type;
 
+    static BOOST_CONSTEXPR_OR_CONST std::size_t storage_size = 8u;
+    static BOOST_CONSTEXPR_OR_CONST bool is_signed = Signed;
+
     static BOOST_FORCEINLINE void store(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
     {
         fence_before(order);
diff --git a/include/boost/atomic/detail/ops_gcc_sync.hpp b/include/boost/atomic/detail/ops_gcc_sync.hpp
index a9a9ae2..2a075bc 100644
--- a/include/boost/atomic/detail/ops_gcc_sync.hpp
+++ b/include/boost/atomic/detail/ops_gcc_sync.hpp
@@ -16,6 +16,7 @@
 #ifndef BOOST_ATOMIC_DETAIL_OPS_GCC_SYNC_HPP_INCLUDED_
 #define BOOST_ATOMIC_DETAIL_OPS_GCC_SYNC_HPP_INCLUDED_
 
+#include <cstddef>
 #include <boost/memory_order.hpp>
 #include <boost/atomic/detail/config.hpp>
 #include <boost/atomic/detail/storage_type.hpp>
@@ -164,15 +165,22 @@ struct operations< 1u, Signed > :
 {
 #if defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_1)
     typedef typename make_storage_type< 1u, Signed >::aligned aligned_storage_type;
+    static BOOST_CONSTEXPR_OR_CONST std::size_t storage_size = 1u;
 #elif defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2)
     typedef typename make_storage_type< 2u, Signed >::aligned aligned_storage_type;
+    static BOOST_CONSTEXPR_OR_CONST std::size_t storage_size = 2u;
 #elif defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4)
     typedef typename make_storage_type< 4u, Signed >::aligned aligned_storage_type;
+    static BOOST_CONSTEXPR_OR_CONST std::size_t storage_size = 4u;
 #elif defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8)
     typedef typename make_storage_type< 8u, Signed >::aligned aligned_storage_type;
+    static BOOST_CONSTEXPR_OR_CONST std::size_t storage_size = 8u;
 #else
     typedef typename make_storage_type< 16u, Signed >::aligned aligned_storage_type;
+    static BOOST_CONSTEXPR_OR_CONST std::size_t storage_size = 16u;
 #endif
+
+    static BOOST_CONSTEXPR_OR_CONST bool is_signed = Signed;
 };
 #endif
 
@@ -191,13 +199,19 @@ struct operations< 2u, Signed > :
 {
 #if defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2)
     typedef typename make_storage_type< 2u, Signed >::aligned aligned_storage_type;
+    static BOOST_CONSTEXPR_OR_CONST std::size_t storage_size = 2u;
 #elif defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4)
     typedef typename make_storage_type< 4u, Signed >::aligned aligned_storage_type;
+    static BOOST_CONSTEXPR_OR_CONST std::size_t storage_size = 4u;
 #elif defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8)
     typedef typename make_storage_type< 8u, Signed >::aligned aligned_storage_type;
+    static BOOST_CONSTEXPR_OR_CONST std::size_t storage_size = 8u;
 #else
     typedef typename make_storage_type< 16u, Signed >::aligned aligned_storage_type;
+    static BOOST_CONSTEXPR_OR_CONST std::size_t storage_size = 16u;
 #endif
+
+    static BOOST_CONSTEXPR_OR_CONST bool is_signed = Signed;
 };
 #endif
 
@@ -214,11 +228,16 @@ struct operations< 4u, Signed > :
 {
 #if defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4)
     typedef typename make_storage_type< 4u, Signed >::aligned aligned_storage_type;
+    static BOOST_CONSTEXPR_OR_CONST std::size_t storage_size = 4u;
 #elif defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8)
     typedef typename make_storage_type< 8u, Signed >::aligned aligned_storage_type;
+    static BOOST_CONSTEXPR_OR_CONST std::size_t storage_size = 8u;
 #else
     typedef typename make_storage_type< 16u, Signed >::aligned aligned_storage_type;
+    static BOOST_CONSTEXPR_OR_CONST std::size_t storage_size = 16u;
 #endif
+
+    static BOOST_CONSTEXPR_OR_CONST bool is_signed = Signed;
 };
 #endif
 
@@ -233,9 +252,13 @@ struct operations< 8u, Signed > :
 {
 #if defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8)
     typedef typename make_storage_type< 8u, Signed >::aligned aligned_storage_type;
+    static BOOST_CONSTEXPR_OR_CONST std::size_t storage_size = 8u;
 #else
     typedef typename make_storage_type< 16u, Signed >::aligned aligned_storage_type;
+    static BOOST_CONSTEXPR_OR_CONST std::size_t storage_size = 16u;
 #endif
+
+    static BOOST_CONSTEXPR_OR_CONST bool is_signed = Signed;
 };
 #endif
 
@@ -245,6 +268,9 @@ struct operations< 16u, Signed > :
     public gcc_sync_operations< typename make_storage_type< 16u, Signed >::type >
 {
     typedef typename make_storage_type< 16u, Signed >::aligned aligned_storage_type;
+
+    static BOOST_CONSTEXPR_OR_CONST std::size_t storage_size = 16u;
+    static BOOST_CONSTEXPR_OR_CONST bool is_signed = Signed;
 };
 #endif
 
diff --git a/include/boost/atomic/detail/ops_gcc_x86.hpp b/include/boost/atomic/detail/ops_gcc_x86.hpp
index 74e45c1..f66a266 100644
--- a/include/boost/atomic/detail/ops_gcc_x86.hpp
+++ b/include/boost/atomic/detail/ops_gcc_x86.hpp
@@ -16,6 +16,7 @@
 #ifndef BOOST_ATOMIC_DETAIL_OPS_GCC_X86_HPP_INCLUDED_
 #define BOOST_ATOMIC_DETAIL_OPS_GCC_X86_HPP_INCLUDED_
 
+#include <cstddef>
 #include <boost/memory_order.hpp>
 #include <boost/atomic/detail/config.hpp>
 #include <boost/atomic/detail/storage_type.hpp>
@@ -114,6 +115,9 @@ struct operations< 1u, Signed > :
     typedef typename base_type::storage_type storage_type;
     typedef typename make_storage_type< 1u, Signed >::aligned aligned_storage_type;
 
+    static BOOST_CONSTEXPR_OR_CONST std::size_t storage_size = 1u;
+    static BOOST_CONSTEXPR_OR_CONST bool is_signed = Signed;
+
     static BOOST_FORCEINLINE storage_type fetch_add(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT
     {
         __asm__ __volatile__
@@ -201,6 +205,9 @@ struct operations< 2u, Signed > :
     typedef typename base_type::storage_type storage_type;
     typedef typename make_storage_type< 2u, Signed >::aligned aligned_storage_type;
 
+    static BOOST_CONSTEXPR_OR_CONST std::size_t storage_size = 2u;
+    static BOOST_CONSTEXPR_OR_CONST bool is_signed = Signed;
+
     static BOOST_FORCEINLINE storage_type fetch_add(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT
     {
         __asm__ __volatile__
@@ -288,6 +295,9 @@ struct operations< 4u, Signed > :
     typedef typename base_type::storage_type storage_type;
     typedef typename make_storage_type< 4u, Signed >::aligned aligned_storage_type;
 
+    static BOOST_CONSTEXPR_OR_CONST std::size_t storage_size = 4u;
+    static BOOST_CONSTEXPR_OR_CONST bool is_signed = Signed;
+
     static BOOST_FORCEINLINE storage_type fetch_add(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT
     {
         __asm__ __volatile__
@@ -373,6 +383,8 @@ template< bool Signed >
 struct operations< 8u, Signed > :
     public cas_based_operations< gcc_dcas_x86< Signed > >
 {
+    static BOOST_CONSTEXPR_OR_CONST std::size_t storage_size = 8u;
+    static BOOST_CONSTEXPR_OR_CONST bool is_signed = Signed;
 };
 
 #elif defined(__x86_64__)
@@ -385,6 +397,9 @@ struct operations< 8u, Signed > :
     typedef typename base_type::storage_type storage_type;
     typedef typename make_storage_type< 8u, Signed >::aligned aligned_storage_type;
 
+    static BOOST_CONSTEXPR_OR_CONST std::size_t storage_size = 8u;
+    static BOOST_CONSTEXPR_OR_CONST bool is_signed = Signed;
+
     static BOOST_FORCEINLINE storage_type fetch_add(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT
     {
         __asm__ __volatile__
@@ -472,6 +487,8 @@ template< bool Signed >
 struct operations< 16u, Signed > :
     public cas_based_operations< gcc_dcas_x86_64< Signed > >
 {
+    static BOOST_CONSTEXPR_OR_CONST std::size_t storage_size = 16u;
+    static BOOST_CONSTEXPR_OR_CONST bool is_signed = Signed;
 };
 
 #endif // defined(BOOST_ATOMIC_DETAIL_X86_HAS_CMPXCHG16B)
diff --git a/include/boost/atomic/detail/ops_linux_arm.hpp b/include/boost/atomic/detail/ops_linux_arm.hpp
index c26bc2c..840c125 100644
--- a/include/boost/atomic/detail/ops_linux_arm.hpp
+++ b/include/boost/atomic/detail/ops_linux_arm.hpp
@@ -18,6 +18,7 @@
 #ifndef BOOST_ATOMIC_DETAIL_OPS_LINUX_ARM_HPP_INCLUDED_
 #define BOOST_ATOMIC_DETAIL_OPS_LINUX_ARM_HPP_INCLUDED_
 
+#include <cstddef>
 #include <boost/memory_order.hpp>
 #include <boost/atomic/detail/config.hpp>
 #include <boost/atomic/detail/storage_type.hpp>
@@ -91,6 +92,9 @@ struct linux_arm_cas :
     typedef typename make_storage_type< 4u, Signed >::type storage_type;
     typedef typename make_storage_type< 4u, Signed >::aligned aligned_storage_type;
 
+    static BOOST_CONSTEXPR_OR_CONST std::size_t storage_size = 4u;
+    static BOOST_CONSTEXPR_OR_CONST bool is_signed = Signed;
+
     static BOOST_FORCEINLINE void store(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
     {
         fence_before_store(order);
diff --git a/include/boost/atomic/detail/ops_msvc_arm.hpp b/include/boost/atomic/detail/ops_msvc_arm.hpp
index e0a709c..a0cfe81 100644
--- a/include/boost/atomic/detail/ops_msvc_arm.hpp
+++ b/include/boost/atomic/detail/ops_msvc_arm.hpp
@@ -17,6 +17,7 @@
 #define BOOST_ATOMIC_DETAIL_OPS_MSVC_ARM_HPP_INCLUDED_
 
 #include <intrin.h>
+#include <cstddef>
 #include <boost/memory_order.hpp>
 #include <boost/atomic/detail/config.hpp>
 #include <boost/atomic/detail/interlocked.hpp>
@@ -134,6 +135,9 @@ struct operations< 1u, Signed > :
     typedef typename base_type::storage_type storage_type;
     typedef typename make_storage_type< 1u, Signed >::aligned aligned_storage_type;
 
+    static BOOST_CONSTEXPR_OR_CONST std::size_t storage_size = 1u;
+    static BOOST_CONSTEXPR_OR_CONST bool is_signed = Signed;
+
     static BOOST_FORCEINLINE void store(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
     {
         base_type::fence_before_store(order);
@@ -300,6 +304,9 @@ struct operations< 2u, Signed > :
     typedef typename base_type::storage_type storage_type;
     typedef typename make_storage_type< 2u, Signed >::aligned aligned_storage_type;
 
+    static BOOST_CONSTEXPR_OR_CONST std::size_t storage_size = 2u;
+    static BOOST_CONSTEXPR_OR_CONST bool is_signed = Signed;
+
     static BOOST_FORCEINLINE void store(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
     {
         base_type::fence_before_store(order);
@@ -466,6 +473,9 @@ struct operations< 4u, Signed > :
     typedef typename base_type::storage_type storage_type;
     typedef typename make_storage_type< 4u, Signed >::aligned aligned_storage_type;
 
+    static BOOST_CONSTEXPR_OR_CONST std::size_t storage_size = 4u;
+    static BOOST_CONSTEXPR_OR_CONST bool is_signed = Signed;
+
     static BOOST_FORCEINLINE void store(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
     {
         base_type::fence_before_store(order);
@@ -632,6 +642,9 @@ struct operations< 8u, Signed > :
     typedef typename base_type::storage_type storage_type;
     typedef typename make_storage_type< 8u, Signed >::aligned aligned_storage_type;
 
+    static BOOST_CONSTEXPR_OR_CONST std::size_t storage_size = 8u;
+    static BOOST_CONSTEXPR_OR_CONST bool is_signed = Signed;
+
     static BOOST_FORCEINLINE void store(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
     {
         base_type::fence_before_store(order);
diff --git a/include/boost/atomic/detail/ops_msvc_x86.hpp b/include/boost/atomic/detail/ops_msvc_x86.hpp
index 6236624..85bed28 100644
--- a/include/boost/atomic/detail/ops_msvc_x86.hpp
+++ b/include/boost/atomic/detail/ops_msvc_x86.hpp
@@ -16,6 +16,7 @@
 #ifndef BOOST_ATOMIC_DETAIL_OPS_MSVC_X86_HPP_INCLUDED_
 #define BOOST_ATOMIC_DETAIL_OPS_MSVC_X86_HPP_INCLUDED_
 
+#include <cstddef>
 #include <boost/memory_order.hpp>
 #include <boost/atomic/detail/config.hpp>
 #include <boost/atomic/detail/interlocked.hpp>
@@ -164,6 +165,9 @@ struct operations< 4u, Signed > :
     typedef typename base_type::storage_type storage_type;
     typedef typename make_storage_type< 4u, Signed >::aligned aligned_storage_type;
 
+    static BOOST_CONSTEXPR_OR_CONST std::size_t storage_size = 4u;
+    static BOOST_CONSTEXPR_OR_CONST bool is_signed = Signed;
+
     static BOOST_FORCEINLINE storage_type fetch_add(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT
     {
         return static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD(&storage, v));
@@ -236,6 +240,9 @@ struct operations< 1u, Signed > :
     typedef typename base_type::storage_type storage_type;
     typedef typename make_storage_type< 1u, Signed >::aligned aligned_storage_type;
 
+    static BOOST_CONSTEXPR_OR_CONST std::size_t storage_size = 1u;
+    static BOOST_CONSTEXPR_OR_CONST bool is_signed = Signed;
+
     static BOOST_FORCEINLINE storage_type fetch_add(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT
     {
         return static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD8(&storage, v));
@@ -281,6 +288,9 @@ struct operations< 1u, Signed > :
     typedef typename base_type::storage_type storage_type;
     typedef typename make_storage_type< 1u, Signed >::aligned aligned_storage_type;
 
+    static BOOST_CONSTEXPR_OR_CONST std::size_t storage_size = 1u;
+    static BOOST_CONSTEXPR_OR_CONST bool is_signed = Signed;
+
     static BOOST_FORCEINLINE storage_type fetch_add(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
     {
         base_type::fence_before(order);
@@ -422,6 +432,9 @@ struct operations< 2u, Signed > :
     typedef typename base_type::storage_type storage_type;
     typedef typename make_storage_type< 2u, Signed >::aligned aligned_storage_type;
 
+    static BOOST_CONSTEXPR_OR_CONST std::size_t storage_size = 2u;
+    static BOOST_CONSTEXPR_OR_CONST bool is_signed = Signed;
+
     static BOOST_FORCEINLINE storage_type fetch_add(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT
     {
         return static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD16(&storage, v));
@@ -467,6 +480,9 @@ struct operations< 2u, Signed > :
     typedef typename base_type::storage_type storage_type;
     typedef typename make_storage_type< 2u, Signed >::aligned aligned_storage_type;
 
+    static BOOST_CONSTEXPR_OR_CONST std::size_t storage_size = 2u;
+    static BOOST_CONSTEXPR_OR_CONST bool is_signed = Signed;
+
     static BOOST_FORCEINLINE storage_type fetch_add(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
     {
         base_type::fence_before(order);
@@ -609,6 +625,9 @@ struct msvc_dcas_x86
 
     static BOOST_CONSTEXPR_OR_CONST bool is_always_lock_free = true;
 
+    static BOOST_CONSTEXPR_OR_CONST std::size_t storage_size = 8u;
+    static BOOST_CONSTEXPR_OR_CONST bool is_signed = Signed;
+
     // Intel 64 and IA-32 Architectures Software Developer's Manual, Volume 3A, 8.1.1. Guaranteed Atomic Operations:
     //
     // The Pentium processor (and newer processors since) guarantees that the following additional memory operations will always be carried out atomically:
@@ -812,6 +831,9 @@ struct operations< 8u, Signed > :
     typedef typename base_type::storage_type storage_type;
     typedef typename make_storage_type< 8u, Signed >::aligned aligned_storage_type;
 
+    static BOOST_CONSTEXPR_OR_CONST std::size_t storage_size = 8u;
+    static BOOST_CONSTEXPR_OR_CONST bool is_signed = Signed;
+
     static BOOST_FORCEINLINE storage_type fetch_add(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT
     {
         return static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD64(&storage, v));
@@ -859,6 +881,9 @@ struct msvc_dcas_x86_64
 
     static BOOST_CONSTEXPR_OR_CONST bool is_always_lock_free = true;
 
+    static BOOST_CONSTEXPR_OR_CONST std::size_t storage_size = 16u;
+    static BOOST_CONSTEXPR_OR_CONST bool is_signed = Signed;
+
     static BOOST_FORCEINLINE void store(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT
     {
         storage_type value = const_cast< storage_type& >(storage);
diff --git a/include/boost/atomic/detail/ops_windows.hpp b/include/boost/atomic/detail/ops_windows.hpp
index 50d951d..29bd380 100644
--- a/include/boost/atomic/detail/ops_windows.hpp
+++ b/include/boost/atomic/detail/ops_windows.hpp
@@ -23,6 +23,7 @@
 #ifndef BOOST_ATOMIC_DETAIL_OPS_WINDOWS_HPP_INCLUDED_
 #define BOOST_ATOMIC_DETAIL_OPS_WINDOWS_HPP_INCLUDED_
 
+#include <cstddef>
 #include <boost/memory_order.hpp>
 #include <boost/atomic/detail/config.hpp>
 #include <boost/atomic/detail/interlocked.hpp>
@@ -109,6 +110,9 @@ struct operations< 4u, Signed > :
     typedef typename base_type::storage_type storage_type;
     typedef typename make_storage_type< 4u, Signed >::aligned aligned_storage_type;
 
+    static BOOST_CONSTEXPR_OR_CONST std::size_t storage_size = 4u;
+    static BOOST_CONSTEXPR_OR_CONST bool is_signed = Signed;
+
     static BOOST_FORCEINLINE storage_type fetch_add(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
     {
         base_type::fence_before(order);
diff --git a/include/boost/atomic/detail/platform.hpp b/include/boost/atomic/detail/platform.hpp
index a95ec53..07118d5 100644
--- a/include/boost/atomic/detail/platform.hpp
+++ b/include/boost/atomic/detail/platform.hpp
@@ -30,6 +30,7 @@
 #if defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__))
 
 #define BOOST_ATOMIC_DETAIL_PLATFORM gcc_x86
+#define BOOST_ATOMIC_DETAIL_EXTRA_BACKEND gcc_x86
 
 #elif defined(__GNUC__) && (defined(__POWERPC__) || defined(__PPC__))
 
@@ -126,7 +127,12 @@
 #define BOOST_ATOMIC_EMULATED
 #endif
 
-#define BOOST_ATOMIC_DETAIL_PLATFROM_HEADER(prefix) <BOOST_JOIN(prefix, BOOST_ATOMIC_DETAIL_PLATFROM).hpp>
+#if !defined(BOOST_ATOMIC_DETAIL_EXTRA_BACKEND)
+#define BOOST_ATOMIC_DETAIL_EXTRA_BACKEND generic
+#define BOOST_ATOMIC_DETAIL_EXTRA_BACKEND_GENERIC
+#endif
+
 #define BOOST_ATOMIC_DETAIL_BACKEND_HEADER(prefix) <BOOST_JOIN(prefix, BOOST_ATOMIC_DETAIL_BACKEND).hpp>
+#define BOOST_ATOMIC_DETAIL_EXTRA_BACKEND_HEADER(prefix) <BOOST_JOIN(prefix, BOOST_ATOMIC_DETAIL_EXTRA_BACKEND).hpp>
 
 #endif // BOOST_ATOMIC_DETAIL_PLATFORM_HPP_INCLUDED_
diff --git a/include/boost/atomic/detail/storage_type.hpp b/include/boost/atomic/detail/storage_type.hpp
index 59e6901..d4d07f2 100644
--- a/include/boost/atomic/detail/storage_type.hpp
+++ b/include/boost/atomic/detail/storage_type.hpp
@@ -224,7 +224,9 @@ struct make_storage_type< 16u, true >
 
 struct BOOST_ATOMIC_DETAIL_MAY_ALIAS storage128_t
 {
-    boost::uint64_t data[2];
+    typedef boost::uint64_t BOOST_ATOMIC_DETAIL_MAY_ALIAS element_type;
+
+    element_type data[2];
 
     BOOST_FORCEINLINE bool operator! () const BOOST_NOEXCEPT
     {