passenger 6.0.7 → 6.0.8

data/src/cxx_supportlib/vendor-modified/boost/atomic/detail/extra_ops_gcc_arm.hpp

@@ -19,11 +19,13 @@
 #include <boost/memory_order.hpp>
 #include <boost/atomic/detail/config.hpp>
 #include <boost/atomic/detail/platform.hpp>
-#include <boost/atomic/detail/storage_type.hpp>
+#include <boost/atomic/detail/storage_traits.hpp>
 #include <boost/atomic/detail/extra_operations_fwd.hpp>
 #include <boost/atomic/detail/extra_ops_generic.hpp>
 #include <boost/atomic/detail/ops_gcc_arm_common.hpp>
-#include <boost/atomic/capabilities.hpp>
+#include <boost/atomic/detail/gcc_arm_asm_common.hpp>
+#include <boost/atomic/detail/capabilities.hpp>
+#include <boost/atomic/detail/header.hpp>
 
 #ifdef BOOST_HAS_PRAGMA_ONCE
 #pragma once
@@ -34,7 +36,7 @@ namespace atomics {
 namespace detail {
 
 template< typename Base >
-struct gcc_arm_extra_operations_common :
+struct extra_operations_gcc_arm_common :
     public Base
 {
     typedef Base base_type;
@@ -87,32 +89,32 @@ struct gcc_arm_extra_operations_common :
 };
 
 template< typename Base, std::size_t Size, bool Signed >
-struct gcc_arm_extra_operations;
+struct extra_operations_gcc_arm;
 
 #if defined(BOOST_ATOMIC_DETAIL_ARM_HAS_LDREXB_STREXB)
 
 template< typename Base, bool Signed >
-struct gcc_arm_extra_operations< Base, 1u, Signed > :
-    public generic_extra_operations< Base, 1u, Signed >
+struct extra_operations_gcc_arm< Base, 1u, Signed > :
+    public extra_operations_generic< Base, 1u, Signed >
 {
-    typedef generic_extra_operations< Base, 1u, Signed > base_type;
+    typedef extra_operations_generic< Base, 1u, Signed > base_type;
     typedef typename base_type::storage_type storage_type;
-    typedef typename make_storage_type< 4u >::type extended_storage_type;
+    typedef typename storage_traits< 4u >::type extended_storage_type;
 
     static BOOST_FORCEINLINE storage_type fetch_negate(storage_type volatile& storage, memory_order order) BOOST_NOEXCEPT
     {
-        gcc_arm_operations_base::fence_before(order);
+        core_arch_operations_gcc_arm_base::fence_before(order);
         uint32_t tmp;
         extended_storage_type original, result;
         __asm__ __volatile__
         (
             BOOST_ATOMIC_DETAIL_ARM_ASM_START(%[tmp])
-            "1:\n"
-            "ldrexb   %[original], %[storage]\n"           // original = zero_extend(*(&storage))
-            "rsb      %[result], %[original], #0\n"        // result = 0 - original
-            "strexb   %[tmp], %[result], %[storage]\n"     // *(&storage) = result, tmp = store failed
-            "teq      %[tmp], #0\n"                        // flags = tmp==0
-            "bne      1b\n"                                // if (!flags.equal) goto retry
+            "1:\n\t"
+            "ldrexb   %[original], %[storage]\n\t"           // original = zero_extend(*(&storage))
+            "rsb      %[result], %[original], #0\n\t"        // result = 0 - original
+            "strexb   %[tmp], %[result], %[storage]\n\t"     // *(&storage) = result, tmp = store failed
+            "teq      %[tmp], #0\n\t"                        // flags = tmp==0
+            "bne      1b\n\t"                                // if (!flags.equal) goto retry
             BOOST_ATOMIC_DETAIL_ARM_ASM_END(%[tmp])
             : [original] "=&r" (original),  // %0
               [result] "=&r" (result),      // %1
@@ -121,24 +123,24 @@ struct gcc_arm_extra_operations< Base, 1u, Signed > :
             :
             : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC
         );
-        gcc_arm_operations_base::fence_after(order);
+        core_arch_operations_gcc_arm_base::fence_after(order);
         return static_cast< storage_type >(original);
     }
 
     static BOOST_FORCEINLINE storage_type negate(storage_type volatile& storage, memory_order order) BOOST_NOEXCEPT
     {
-        gcc_arm_operations_base::fence_before(order);
+        core_arch_operations_gcc_arm_base::fence_before(order);
         uint32_t tmp;
         extended_storage_type original, result;
         __asm__ __volatile__
         (
             BOOST_ATOMIC_DETAIL_ARM_ASM_START(%[tmp])
-            "1:\n"
-            "ldrexb   %[original], %[storage]\n"           // original = zero_extend(*(&storage))
-            "rsb      %[result], %[original], #0\n"        // result = 0 - original
-            "strexb   %[tmp], %[result], %[storage]\n"     // *(&storage) = result, tmp = store failed
-            "teq      %[tmp], #0\n"                        // flags = tmp==0
-            "bne      1b\n"                                // if (!flags.equal) goto retry
+            "1:\n\t"
+            "ldrexb   %[original], %[storage]\n\t"           // original = zero_extend(*(&storage))
+            "rsb      %[result], %[original], #0\n\t"        // result = 0 - original
+            "strexb   %[tmp], %[result], %[storage]\n\t"     // *(&storage) = result, tmp = store failed
+            "teq      %[tmp], #0\n\t"                        // flags = tmp==0
+            "bne      1b\n\t"                                // if (!flags.equal) goto retry
             BOOST_ATOMIC_DETAIL_ARM_ASM_END(%[tmp])
             : [original] "=&r" (original),  // %0
               [result] "=&r" (result),      // %1
@@ -147,24 +149,24 @@ struct gcc_arm_extra_operations< Base, 1u, Signed > :
             :
             : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC
         );
-        gcc_arm_operations_base::fence_after(order);
+        core_arch_operations_gcc_arm_base::fence_after(order);
         return static_cast< storage_type >(result);
     }
 
     static BOOST_FORCEINLINE storage_type add(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
     {
-        gcc_arm_operations_base::fence_before(order);
+        core_arch_operations_gcc_arm_base::fence_before(order);
         uint32_t tmp;
         extended_storage_type original, result;
         __asm__ __volatile__
         (
             BOOST_ATOMIC_DETAIL_ARM_ASM_START(%[tmp])
-            "1:\n"
-            "ldrexb   %[original], %[storage]\n"           // original = zero_extend(*(&storage))
-            "add      %[result], %[original], %[value]\n"  // result = original + value
-            "strexb   %[tmp], %[result], %[storage]\n"     // *(&storage) = result, tmp = store failed
-            "teq      %[tmp], #0\n"                        // flags = tmp==0
-            "bne      1b\n"                                // if (!flags.equal) goto retry
+            "1:\n\t"
+            "ldrexb   %[original], %[storage]\n\t"           // original = zero_extend(*(&storage))
+            "add      %[result], %[original], %[value]\n\t"  // result = original + value
+            "strexb   %[tmp], %[result], %[storage]\n\t"     // *(&storage) = result, tmp = store failed
+            "teq      %[tmp], #0\n\t"                        // flags = tmp==0
+            "bne      1b\n\t"                                // if (!flags.equal) goto retry
             BOOST_ATOMIC_DETAIL_ARM_ASM_END(%[tmp])
             : [original] "=&r" (original),  // %0
               [result] "=&r" (result),      // %1
@@ -173,24 +175,24 @@ struct gcc_arm_extra_operations< Base, 1u, Signed > :
             : [value] "Ir" (v)              // %4
             : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC
         );
-        gcc_arm_operations_base::fence_after(order);
+        core_arch_operations_gcc_arm_base::fence_after(order);
         return static_cast< storage_type >(result);
     }
 
     static BOOST_FORCEINLINE storage_type sub(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
     {
-        gcc_arm_operations_base::fence_before(order);
+        core_arch_operations_gcc_arm_base::fence_before(order);
         uint32_t tmp;
         extended_storage_type original, result;
         __asm__ __volatile__
         (
             BOOST_ATOMIC_DETAIL_ARM_ASM_START(%[tmp])
-            "1:\n"
-            "ldrexb   %[original], %[storage]\n"           // original = zero_extend(*(&storage))
-            "sub      %[result], %[original], %[value]\n"  // result = original - value
-            "strexb   %[tmp], %[result], %[storage]\n"     // *(&storage) = result, tmp = store failed
-            "teq      %[tmp], #0\n"                        // flags = tmp==0
-            "bne      1b\n"                                // if (!flags.equal) goto retry
+            "1:\n\t"
+            "ldrexb   %[original], %[storage]\n\t"           // original = zero_extend(*(&storage))
+            "sub      %[result], %[original], %[value]\n\t"  // result = original - value
+            "strexb   %[tmp], %[result], %[storage]\n\t"     // *(&storage) = result, tmp = store failed
+            "teq      %[tmp], #0\n\t"                        // flags = tmp==0
+            "bne      1b\n\t"                                // if (!flags.equal) goto retry
             BOOST_ATOMIC_DETAIL_ARM_ASM_END(%[tmp])
             : [original] "=&r" (original),  // %0
               [result] "=&r" (result),      // %1
@@ -199,24 +201,24 @@ struct gcc_arm_extra_operations< Base, 1u, Signed > :
             : [value] "Ir" (v)              // %4
             : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC
         );
-        gcc_arm_operations_base::fence_after(order);
+        core_arch_operations_gcc_arm_base::fence_after(order);
         return static_cast< storage_type >(result);
     }
 
     static BOOST_FORCEINLINE storage_type bitwise_and(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
     {
-        gcc_arm_operations_base::fence_before(order);
+        core_arch_operations_gcc_arm_base::fence_before(order);
         uint32_t tmp;
         extended_storage_type original, result;
         __asm__ __volatile__
         (
             BOOST_ATOMIC_DETAIL_ARM_ASM_START(%[tmp])
-            "1:\n"
-            "ldrexb   %[original], %[storage]\n"           // original = zero_extend(*(&storage))
-            "and      %[result], %[original], %[value]\n"  // result = original & value
-            "strexb   %[tmp], %[result], %[storage]\n"     // *(&storage) = result, tmp = store failed
-            "teq      %[tmp], #0\n"                        // flags = tmp==0
-            "bne      1b\n"                                // if (!flags.equal) goto retry
+            "1:\n\t"
+            "ldrexb   %[original], %[storage]\n\t"           // original = zero_extend(*(&storage))
+            "and      %[result], %[original], %[value]\n\t"  // result = original & value
+            "strexb   %[tmp], %[result], %[storage]\n\t"     // *(&storage) = result, tmp = store failed
+            "teq      %[tmp], #0\n\t"                        // flags = tmp==0
+            "bne      1b\n\t"                                // if (!flags.equal) goto retry
             BOOST_ATOMIC_DETAIL_ARM_ASM_END(%[tmp])
             : [original] "=&r" (original),  // %0
               [result] "=&r" (result),      // %1
@@ -225,24 +227,24 @@ struct gcc_arm_extra_operations< Base, 1u, Signed > :
             : [value] "Ir" (v)              // %4
             : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC
         );
-        gcc_arm_operations_base::fence_after(order);
+        core_arch_operations_gcc_arm_base::fence_after(order);
         return static_cast< storage_type >(result);
     }
 
     static BOOST_FORCEINLINE storage_type bitwise_or(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
     {
-        gcc_arm_operations_base::fence_before(order);
+        core_arch_operations_gcc_arm_base::fence_before(order);
         uint32_t tmp;
         extended_storage_type original, result;
         __asm__ __volatile__
         (
             BOOST_ATOMIC_DETAIL_ARM_ASM_START(%[tmp])
-            "1:\n"
-            "ldrexb   %[original], %[storage]\n"           // original = zero_extend(*(&storage))
-            "orr      %[result], %[original], %[value]\n"  // result = original | value
-            "strexb   %[tmp], %[result], %[storage]\n"     // *(&storage) = result, tmp = store failed
-            "teq      %[tmp], #0\n"                        // flags = tmp==0
-            "bne      1b\n"                                // if (!flags.equal) goto retry
+            "1:\n\t"
+            "ldrexb   %[original], %[storage]\n\t"           // original = zero_extend(*(&storage))
+            "orr      %[result], %[original], %[value]\n\t"  // result = original | value
+            "strexb   %[tmp], %[result], %[storage]\n\t"     // *(&storage) = result, tmp = store failed
+            "teq      %[tmp], #0\n\t"                        // flags = tmp==0
+            "bne      1b\n\t"                                // if (!flags.equal) goto retry
             BOOST_ATOMIC_DETAIL_ARM_ASM_END(%[tmp])
             : [original] "=&r" (original),  // %0
               [result] "=&r" (result),      // %1
@@ -251,24 +253,24 @@ struct gcc_arm_extra_operations< Base, 1u, Signed > :
             : [value] "Ir" (v)              // %4
             : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC
         );
-        gcc_arm_operations_base::fence_after(order);
+        core_arch_operations_gcc_arm_base::fence_after(order);
         return static_cast< storage_type >(result);
     }
 
     static BOOST_FORCEINLINE storage_type bitwise_xor(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
     {
-        gcc_arm_operations_base::fence_before(order);
+        core_arch_operations_gcc_arm_base::fence_before(order);
         uint32_t tmp;
         extended_storage_type original, result;
         __asm__ __volatile__
         (
             BOOST_ATOMIC_DETAIL_ARM_ASM_START(%[tmp])
-            "1:\n"
-            "ldrexb   %[original], %[storage]\n"           // original = zero_extend(*(&storage))
-            "eor      %[result], %[original], %[value]\n"  // result = original ^ value
-            "strexb   %[tmp], %[result], %[storage]\n"     // *(&storage) = result, tmp = store failed
-            "teq      %[tmp], #0\n"                        // flags = tmp==0
-            "bne      1b\n"                                // if (!flags.equal) goto retry
+            "1:\n\t"
+            "ldrexb   %[original], %[storage]\n\t"           // original = zero_extend(*(&storage))
+            "eor      %[result], %[original], %[value]\n\t"  // result = original ^ value
+            "strexb   %[tmp], %[result], %[storage]\n\t"     // *(&storage) = result, tmp = store failed
+            "teq      %[tmp], #0\n\t"                        // flags = tmp==0
+            "bne      1b\n\t"                                // if (!flags.equal) goto retry
             BOOST_ATOMIC_DETAIL_ARM_ASM_END(%[tmp])
             : [original] "=&r" (original),  // %0
               [result] "=&r" (result),      // %1
@@ -277,24 +279,24 @@ struct gcc_arm_extra_operations< Base, 1u, Signed > :
             : [value] "Ir" (v)              // %4
             : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC
         );
-        gcc_arm_operations_base::fence_after(order);
+        core_arch_operations_gcc_arm_base::fence_after(order);
         return static_cast< storage_type >(result);
     }
 
     static BOOST_FORCEINLINE storage_type fetch_complement(storage_type volatile& storage, memory_order order) BOOST_NOEXCEPT
     {
-        gcc_arm_operations_base::fence_before(order);
+        core_arch_operations_gcc_arm_base::fence_before(order);
         uint32_t tmp;
         extended_storage_type original, result;
         __asm__ __volatile__
         (
             BOOST_ATOMIC_DETAIL_ARM_ASM_START(%[tmp])
-            "1:\n"
-            "ldrexb   %[original], %[storage]\n"           // original = zero_extend(*(&storage))
-            "mvn      %[result], %[original]\n"            // result = NOT original
-            "strexb   %[tmp], %[result], %[storage]\n"     // *(&storage) = result, tmp = store failed
-            "teq      %[tmp], #0\n"                        // flags = tmp==0
-            "bne      1b\n"                                // if (!flags.equal) goto retry
+            "1:\n\t"
+            "ldrexb   %[original], %[storage]\n\t"           // original = zero_extend(*(&storage))
+            "mvn      %[result], %[original]\n\t"            // result = NOT original
+            "strexb   %[tmp], %[result], %[storage]\n\t"     // *(&storage) = result, tmp = store failed
+            "teq      %[tmp], #0\n\t"                        // flags = tmp==0
+            "bne      1b\n\t"                                // if (!flags.equal) goto retry
             BOOST_ATOMIC_DETAIL_ARM_ASM_END(%[tmp])
             : [original] "=&r" (original),  // %0
               [result] "=&r" (result),      // %1
@@ -303,24 +305,24 @@ struct gcc_arm_extra_operations< Base, 1u, Signed > :
             :
             : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC
         );
-        gcc_arm_operations_base::fence_after(order);
+        core_arch_operations_gcc_arm_base::fence_after(order);
         return static_cast< storage_type >(original);
     }
 
     static BOOST_FORCEINLINE storage_type bitwise_complement(storage_type volatile& storage, memory_order order) BOOST_NOEXCEPT
     {
-        gcc_arm_operations_base::fence_before(order);
+        core_arch_operations_gcc_arm_base::fence_before(order);
         uint32_t tmp;
         extended_storage_type original, result;
         __asm__ __volatile__
         (
             BOOST_ATOMIC_DETAIL_ARM_ASM_START(%[tmp])
-            "1:\n"
-            "ldrexb   %[original], %[storage]\n"           // original = zero_extend(*(&storage))
-            "mvn      %[result], %[original]\n"            // result = NOT original
-            "strexb   %[tmp], %[result], %[storage]\n"     // *(&storage) = result, tmp = store failed
-            "teq      %[tmp], #0\n"                        // flags = tmp==0
-            "bne      1b\n"                                // if (!flags.equal) goto retry
+            "1:\n\t"
+            "ldrexb   %[original], %[storage]\n\t"           // original = zero_extend(*(&storage))
+            "mvn      %[result], %[original]\n\t"            // result = NOT original
+            "strexb   %[tmp], %[result], %[storage]\n\t"     // *(&storage) = result, tmp = store failed
+            "teq      %[tmp], #0\n\t"                        // flags = tmp==0
+            "bne      1b\n\t"                                // if (!flags.equal) goto retry
             BOOST_ATOMIC_DETAIL_ARM_ASM_END(%[tmp])
             : [original] "=&r" (original),  // %0
               [result] "=&r" (result),      // %1
@@ -329,14 +331,14 @@ struct gcc_arm_extra_operations< Base, 1u, Signed > :
             :
             : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC
         );
-        gcc_arm_operations_base::fence_after(order);
+        core_arch_operations_gcc_arm_base::fence_after(order);
         return static_cast< storage_type >(result);
     }
 };
 
 template< typename Base, bool Signed >
 struct extra_operations< Base, 1u, Signed, true > :
-    public gcc_arm_extra_operations_common< gcc_arm_extra_operations< Base, 1u, Signed > >
+    public extra_operations_gcc_arm_common< extra_operations_gcc_arm< Base, 1u, Signed > >
 {
 };
 
@@ -345,27 +347,27 @@ struct extra_operations< Base, 1u, Signed, true > :
 #if defined(BOOST_ATOMIC_DETAIL_ARM_HAS_LDREXH_STREXH)
 
 template< typename Base, bool Signed >
-struct gcc_arm_extra_operations< Base, 2u, Signed > :
-    public generic_extra_operations< Base, 2u, Signed >
+struct extra_operations_gcc_arm< Base, 2u, Signed > :
+    public extra_operations_generic< Base, 2u, Signed >
 {
-    typedef generic_extra_operations< Base, 2u, Signed > base_type;
+    typedef extra_operations_generic< Base, 2u, Signed > base_type;
     typedef typename base_type::storage_type storage_type;
-    typedef typename make_storage_type< 4u >::type extended_storage_type;
+    typedef typename storage_traits< 4u >::type extended_storage_type;
 
     static BOOST_FORCEINLINE storage_type fetch_negate(storage_type volatile& storage, memory_order order) BOOST_NOEXCEPT
     {
-        gcc_arm_operations_base::fence_before(order);
+        core_arch_operations_gcc_arm_base::fence_before(order);
         uint32_t tmp;
         extended_storage_type original, result;
         __asm__ __volatile__
         (
             BOOST_ATOMIC_DETAIL_ARM_ASM_START(%[tmp])
-            "1:\n"
-            "ldrexh   %[original], %[storage]\n"           // original = zero_extend(*(&storage))
-            "rsb      %[result], %[original], #0\n"        // result = 0 - original
-            "strexh   %[tmp], %[result], %[storage]\n"     // *(&storage) = result, tmp = store failed
-            "teq      %[tmp], #0\n"                        // flags = tmp==0
-            "bne      1b\n"                                // if (!flags.equal) goto retry
+            "1:\n\t"
+            "ldrexh   %[original], %[storage]\n\t"           // original = zero_extend(*(&storage))
+            "rsb      %[result], %[original], #0\n\t"        // result = 0 - original
+            "strexh   %[tmp], %[result], %[storage]\n\t"     // *(&storage) = result, tmp = store failed
+            "teq      %[tmp], #0\n\t"                        // flags = tmp==0
+            "bne      1b\n\t"                                // if (!flags.equal) goto retry
             BOOST_ATOMIC_DETAIL_ARM_ASM_END(%[tmp])
             : [original] "=&r" (original),  // %0
               [result] "=&r" (result),      // %1
@@ -374,24 +376,24 @@ struct gcc_arm_extra_operations< Base, 2u, Signed > :
             :
             : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC
         );
-        gcc_arm_operations_base::fence_after(order);
+        core_arch_operations_gcc_arm_base::fence_after(order);
         return static_cast< storage_type >(original);
     }
 
     static BOOST_FORCEINLINE storage_type negate(storage_type volatile& storage, memory_order order) BOOST_NOEXCEPT
     {
-        gcc_arm_operations_base::fence_before(order);
+        core_arch_operations_gcc_arm_base::fence_before(order);
         uint32_t tmp;
         extended_storage_type original, result;
         __asm__ __volatile__
         (
             BOOST_ATOMIC_DETAIL_ARM_ASM_START(%[tmp])
-            "1:\n"
-            "ldrexh   %[original], %[storage]\n"           // original = zero_extend(*(&storage))
-            "rsb      %[result], %[original], #0\n"        // result = 0 - original
-            "strexh   %[tmp], %[result], %[storage]\n"     // *(&storage) = result, tmp = store failed
-            "teq      %[tmp], #0\n"                        // flags = tmp==0
-            "bne      1b\n"                                // if (!flags.equal) goto retry
+            "1:\n\t"
+            "ldrexh   %[original], %[storage]\n\t"           // original = zero_extend(*(&storage))
+            "rsb      %[result], %[original], #0\n\t"        // result = 0 - original
+            "strexh   %[tmp], %[result], %[storage]\n\t"     // *(&storage) = result, tmp = store failed
+            "teq      %[tmp], #0\n\t"                        // flags = tmp==0
+            "bne      1b\n\t"                                // if (!flags.equal) goto retry
             BOOST_ATOMIC_DETAIL_ARM_ASM_END(%[tmp])
             : [original] "=&r" (original),  // %0
               [result] "=&r" (result),      // %1
@@ -400,24 +402,24 @@ struct gcc_arm_extra_operations< Base, 2u, Signed > :
             :
             : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC
         );
-        gcc_arm_operations_base::fence_after(order);
+        core_arch_operations_gcc_arm_base::fence_after(order);
         return static_cast< storage_type >(result);
     }
 
     static BOOST_FORCEINLINE storage_type add(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
     {
-        gcc_arm_operations_base::fence_before(order);
+        core_arch_operations_gcc_arm_base::fence_before(order);
         uint32_t tmp;
         extended_storage_type original, result;
         __asm__ __volatile__
         (
             BOOST_ATOMIC_DETAIL_ARM_ASM_START(%[tmp])
-            "1:\n"
-            "ldrexh   %[original], %[storage]\n"           // original = zero_extend(*(&storage))
-            "add      %[result], %[original], %[value]\n"  // result = original + value
-            "strexh   %[tmp], %[result], %[storage]\n"     // *(&storage) = result, tmp = store failed
-            "teq      %[tmp], #0\n"                        // flags = tmp==0
-            "bne      1b\n"                                // if (!flags.equal) goto retry
+            "1:\n\t"
+            "ldrexh   %[original], %[storage]\n\t"           // original = zero_extend(*(&storage))
+            "add      %[result], %[original], %[value]\n\t"  // result = original + value
+            "strexh   %[tmp], %[result], %[storage]\n\t"     // *(&storage) = result, tmp = store failed
+            "teq      %[tmp], #0\n\t"                        // flags = tmp==0
+            "bne      1b\n\t"                                // if (!flags.equal) goto retry
             BOOST_ATOMIC_DETAIL_ARM_ASM_END(%[tmp])
             : [original] "=&r" (original),  // %0
               [result] "=&r" (result),      // %1
@@ -426,24 +428,24 @@ struct gcc_arm_extra_operations< Base, 2u, Signed > :
             : [value] "Ir" (v)              // %4
             : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC
         );
-        gcc_arm_operations_base::fence_after(order);
+        core_arch_operations_gcc_arm_base::fence_after(order);
         return static_cast< storage_type >(result);
     }
 
     static BOOST_FORCEINLINE storage_type sub(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
     {
-        gcc_arm_operations_base::fence_before(order);
+        core_arch_operations_gcc_arm_base::fence_before(order);
         uint32_t tmp;
         extended_storage_type original, result;
         __asm__ __volatile__
         (
             BOOST_ATOMIC_DETAIL_ARM_ASM_START(%[tmp])
-            "1:\n"
-            "ldrexh   %[original], %[storage]\n"           // original = zero_extend(*(&storage))
-            "sub      %[result], %[original], %[value]\n"  // result = original - value
-            "strexh   %[tmp], %[result], %[storage]\n"     // *(&storage) = result, tmp = store failed
-            "teq      %[tmp], #0\n"                        // flags = tmp==0
-            "bne      1b\n"                                // if (!flags.equal) goto retry
+            "1:\n\t"
+            "ldrexh   %[original], %[storage]\n\t"           // original = zero_extend(*(&storage))
+            "sub      %[result], %[original], %[value]\n\t"  // result = original - value
+            "strexh   %[tmp], %[result], %[storage]\n\t"     // *(&storage) = result, tmp = store failed
+            "teq      %[tmp], #0\n\t"                        // flags = tmp==0
+            "bne      1b\n\t"                                // if (!flags.equal) goto retry
             BOOST_ATOMIC_DETAIL_ARM_ASM_END(%[tmp])
             : [original] "=&r" (original),  // %0
               [result] "=&r" (result),      // %1
@@ -452,24 +454,24 @@ struct gcc_arm_extra_operations< Base, 2u, Signed > :
             : [value] "Ir" (v)              // %4
             : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC
         );
-        gcc_arm_operations_base::fence_after(order);
+        core_arch_operations_gcc_arm_base::fence_after(order);
         return static_cast< storage_type >(result);
     }
 
     static BOOST_FORCEINLINE storage_type bitwise_and(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
     {
-        gcc_arm_operations_base::fence_before(order);
+        core_arch_operations_gcc_arm_base::fence_before(order);
         uint32_t tmp;
         extended_storage_type original, result;
         __asm__ __volatile__
         (
             BOOST_ATOMIC_DETAIL_ARM_ASM_START(%[tmp])
-            "1:\n"
-            "ldrexh   %[original], %[storage]\n"           // original = zero_extend(*(&storage))
-            "and      %[result], %[original], %[value]\n"  // result = original & value
-            "strexh   %[tmp], %[result], %[storage]\n"     // *(&storage) = result, tmp = store failed
-            "teq      %[tmp], #0\n"                        // flags = tmp==0
-            "bne      1b\n"                                // if (!flags.equal) goto retry
+            "1:\n\t"
+            "ldrexh   %[original], %[storage]\n\t"           // original = zero_extend(*(&storage))
+            "and      %[result], %[original], %[value]\n\t"  // result = original & value
+            "strexh   %[tmp], %[result], %[storage]\n\t"     // *(&storage) = result, tmp = store failed
+            "teq      %[tmp], #0\n\t"                        // flags = tmp==0
+            "bne      1b\n\t"                                // if (!flags.equal) goto retry
             BOOST_ATOMIC_DETAIL_ARM_ASM_END(%[tmp])
             : [original] "=&r" (original),  // %0
               [result] "=&r" (result),      // %1
@@ -478,24 +480,24 @@ struct gcc_arm_extra_operations< Base, 2u, Signed > :
             : [value] "Ir" (v)              // %4
             : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC
         );
-        gcc_arm_operations_base::fence_after(order);
+        core_arch_operations_gcc_arm_base::fence_after(order);
         return static_cast< storage_type >(result);
     }
 
     static BOOST_FORCEINLINE storage_type bitwise_or(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
     {
-        gcc_arm_operations_base::fence_before(order);
+        core_arch_operations_gcc_arm_base::fence_before(order);
         uint32_t tmp;
         extended_storage_type original, result;
         __asm__ __volatile__
         (
             BOOST_ATOMIC_DETAIL_ARM_ASM_START(%[tmp])
-            "1:\n"
-            "ldrexh   %[original], %[storage]\n"           // original = zero_extend(*(&storage))
-            "orr      %[result], %[original], %[value]\n"  // result = original | value
-            "strexh   %[tmp], %[result], %[storage]\n"     // *(&storage) = result, tmp = store failed
-            "teq      %[tmp], #0\n"                        // flags = tmp==0
-            "bne      1b\n"                                // if (!flags.equal) goto retry
+            "1:\n\t"
+            "ldrexh   %[original], %[storage]\n\t"           // original = zero_extend(*(&storage))
+            "orr      %[result], %[original], %[value]\n\t"  // result = original | value
+            "strexh   %[tmp], %[result], %[storage]\n\t"     // *(&storage) = result, tmp = store failed
+            "teq      %[tmp], #0\n\t"                        // flags = tmp==0
+            "bne      1b\n\t"                                // if (!flags.equal) goto retry
             BOOST_ATOMIC_DETAIL_ARM_ASM_END(%[tmp])
             : [original] "=&r" (original),  // %0
               [result] "=&r" (result),      // %1
@@ -504,24 +506,24 @@ struct gcc_arm_extra_operations< Base, 2u, Signed > :
             : [value] "Ir" (v)              // %4
             : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC
         );
-        gcc_arm_operations_base::fence_after(order);
+        core_arch_operations_gcc_arm_base::fence_after(order);
         return static_cast< storage_type >(result);
     }
 
     static BOOST_FORCEINLINE storage_type bitwise_xor(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
     {
-        gcc_arm_operations_base::fence_before(order);
+        core_arch_operations_gcc_arm_base::fence_before(order);
         uint32_t tmp;
         extended_storage_type original, result;
         __asm__ __volatile__
         (
             BOOST_ATOMIC_DETAIL_ARM_ASM_START(%[tmp])
-            "1:\n"
-            "ldrexh   %[original], %[storage]\n"           // original = zero_extend(*(&storage))
-            "eor      %[result], %[original], %[value]\n"  // result = original ^ value
-            "strexh   %[tmp], %[result], %[storage]\n"     // *(&storage) = result, tmp = store failed
-            "teq      %[tmp], #0\n"                        // flags = tmp==0
-            "bne      1b\n"                                // if (!flags.equal) goto retry
+            "1:\n\t"
+            "ldrexh   %[original], %[storage]\n\t"           // original = zero_extend(*(&storage))
+            "eor      %[result], %[original], %[value]\n\t"  // result = original ^ value
+            "strexh   %[tmp], %[result], %[storage]\n\t"     // *(&storage) = result, tmp = store failed
+            "teq      %[tmp], #0\n\t"                        // flags = tmp==0
+            "bne      1b\n\t"                                // if (!flags.equal) goto retry
             BOOST_ATOMIC_DETAIL_ARM_ASM_END(%[tmp])
             : [original] "=&r" (original),  // %0
               [result] "=&r" (result),      // %1
@@ -530,24 +532,24 @@ struct gcc_arm_extra_operations< Base, 2u, Signed > :
             : [value] "Ir" (v)              // %4
             : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC
         );
-        gcc_arm_operations_base::fence_after(order);
+        core_arch_operations_gcc_arm_base::fence_after(order);
         return static_cast< storage_type >(result);
     }
 
     static BOOST_FORCEINLINE storage_type fetch_complement(storage_type volatile& storage, memory_order order) BOOST_NOEXCEPT
     {
-        gcc_arm_operations_base::fence_before(order);
+        core_arch_operations_gcc_arm_base::fence_before(order);
         uint32_t tmp;
         extended_storage_type original, result;
         __asm__ __volatile__
         (
             BOOST_ATOMIC_DETAIL_ARM_ASM_START(%[tmp])
-            "1:\n"
-            "ldrexh   %[original], %[storage]\n"           // original = zero_extend(*(&storage))
-            "mvn      %[result], %[original]\n"            // result = NOT original
-            "strexh   %[tmp], %[result], %[storage]\n"     // *(&storage) = result, tmp = store failed
-            "teq      %[tmp], #0\n"                        // flags = tmp==0
-            "bne      1b\n"                                // if (!flags.equal) goto retry
+            "1:\n\t"
+            "ldrexh   %[original], %[storage]\n\t"           // original = zero_extend(*(&storage))
+            "mvn      %[result], %[original]\n\t"            // result = NOT original
+            "strexh   %[tmp], %[result], %[storage]\n\t"     // *(&storage) = result, tmp = store failed
+            "teq      %[tmp], #0\n\t"                        // flags = tmp==0
+            "bne      1b\n\t"                                // if (!flags.equal) goto retry
             BOOST_ATOMIC_DETAIL_ARM_ASM_END(%[tmp])
             : [original] "=&r" (original),  // %0
               [result] "=&r" (result),      // %1
@@ -556,24 +558,24 @@ struct gcc_arm_extra_operations< Base, 2u, Signed > :
             :
             : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC
         );
-        gcc_arm_operations_base::fence_after(order);
+        core_arch_operations_gcc_arm_base::fence_after(order);
         return static_cast< storage_type >(original);
     }
 
     static BOOST_FORCEINLINE storage_type bitwise_complement(storage_type volatile& storage, memory_order order) BOOST_NOEXCEPT
     {
-        gcc_arm_operations_base::fence_before(order);
+        core_arch_operations_gcc_arm_base::fence_before(order);
         uint32_t tmp;
         extended_storage_type original, result;
         __asm__ __volatile__
         (
             BOOST_ATOMIC_DETAIL_ARM_ASM_START(%[tmp])
-            "1:\n"
-            "ldrexh   %[original], %[storage]\n"           // original = zero_extend(*(&storage))
-            "mvn      %[result], %[original]\n"            // result = NOT original
-            "strexh   %[tmp], %[result], %[storage]\n"     // *(&storage) = result, tmp = store failed
-            "teq      %[tmp], #0\n"                        // flags = tmp==0
-            "bne      1b\n"                                // if (!flags.equal) goto retry
+            "1:\n\t"
+            "ldrexh   %[original], %[storage]\n\t"           // original = zero_extend(*(&storage))
+            "mvn      %[result], %[original]\n\t"            // result = NOT original
+            "strexh   %[tmp], %[result], %[storage]\n\t"     // *(&storage) = result, tmp = store failed
+            "teq      %[tmp], #0\n\t"                        // flags = tmp==0
+            "bne      1b\n\t"                                // if (!flags.equal) goto retry
             BOOST_ATOMIC_DETAIL_ARM_ASM_END(%[tmp])
             : [original] "=&r" (original),  // %0
               [result] "=&r" (result),      // %1
@@ -582,40 +584,40 @@ struct gcc_arm_extra_operations< Base, 2u, Signed > :
             :
             : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC
         );
-        gcc_arm_operations_base::fence_after(order);
+        core_arch_operations_gcc_arm_base::fence_after(order);
         return static_cast< storage_type >(result);
     }
 };
 
 template< typename Base, bool Signed >
 struct extra_operations< Base, 2u, Signed, true > :
-    public gcc_arm_extra_operations_common< gcc_arm_extra_operations< Base, 2u, Signed > >
+    public extra_operations_gcc_arm_common< extra_operations_gcc_arm< Base, 2u, Signed > >
 {
 };
 
 #endif // defined(BOOST_ATOMIC_DETAIL_ARM_HAS_LDREXH_STREXH)
 
 template< typename Base, bool Signed >
-struct gcc_arm_extra_operations< Base, 4u, Signed > :
-    public generic_extra_operations< Base, 4u, Signed >
+struct extra_operations_gcc_arm< Base, 4u, Signed > :
+    public extra_operations_generic< Base, 4u, Signed >
 {
-    typedef generic_extra_operations< Base, 4u, Signed > base_type;
+    typedef extra_operations_generic< Base, 4u, Signed > base_type;
     typedef typename base_type::storage_type storage_type;
 
     static BOOST_FORCEINLINE storage_type fetch_negate(storage_type volatile& storage, memory_order order) BOOST_NOEXCEPT
     {
-        gcc_arm_operations_base::fence_before(order);
+        core_arch_operations_gcc_arm_base::fence_before(order);
         uint32_t tmp;
         storage_type original, result;
         __asm__ __volatile__
         (
             BOOST_ATOMIC_DETAIL_ARM_ASM_START(%[tmp])
-            "1:\n"
-            "ldrex    %[original], %[storage]\n"           // original = *(&storage)
-            "rsb      %[result], %[original], #0\n"        // result = 0 - original
-            "strex    %[tmp], %[result], %[storage]\n"     // *(&storage) = result, tmp = store failed
-            "teq      %[tmp], #0\n"                        // flags = tmp==0
-            "bne      1b\n"                                // if (!flags.equal) goto retry
+            "1:\n\t"
+            "ldrex    %[original], %[storage]\n\t"           // original = *(&storage)
+            "rsb      %[result], %[original], #0\n\t"        // result = 0 - original
+            "strex    %[tmp], %[result], %[storage]\n\t"     // *(&storage) = result, tmp = store failed
+            "teq      %[tmp], #0\n\t"                        // flags = tmp==0
+            "bne      1b\n\t"                                // if (!flags.equal) goto retry
             BOOST_ATOMIC_DETAIL_ARM_ASM_END(%[tmp])
             : [original] "=&r" (original),  // %0
               [result] "=&r" (result),      // %1
@@ -624,24 +626,24 @@ struct gcc_arm_extra_operations< Base, 4u, Signed > :
             :
             : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC
         );
-        gcc_arm_operations_base::fence_after(order);
+        core_arch_operations_gcc_arm_base::fence_after(order);
         return original;
     }
 
     static BOOST_FORCEINLINE storage_type negate(storage_type volatile& storage, memory_order order) BOOST_NOEXCEPT
     {
-        gcc_arm_operations_base::fence_before(order);
+        core_arch_operations_gcc_arm_base::fence_before(order);
         uint32_t tmp;
         storage_type original, result;
         __asm__ __volatile__
         (
             BOOST_ATOMIC_DETAIL_ARM_ASM_START(%[tmp])
-            "1:\n"
-            "ldrex    %[original], %[storage]\n"           // original = *(&storage)
-            "rsb      %[result], %[original], #0\n"        // result = 0 - original
-            "strex    %[tmp], %[result], %[storage]\n"     // *(&storage) = result, tmp = store failed
-            "teq      %[tmp], #0\n"                        // flags = tmp==0
-            "bne      1b\n"                                // if (!flags.equal) goto retry
+            "1:\n\t"
+            "ldrex    %[original], %[storage]\n\t"           // original = *(&storage)
+            "rsb      %[result], %[original], #0\n\t"        // result = 0 - original
+            "strex    %[tmp], %[result], %[storage]\n\t"     // *(&storage) = result, tmp = store failed
+            "teq      %[tmp], #0\n\t"                        // flags = tmp==0
+            "bne      1b\n\t"                                // if (!flags.equal) goto retry
             BOOST_ATOMIC_DETAIL_ARM_ASM_END(%[tmp])
             : [original] "=&r" (original),  // %0
               [result] "=&r" (result),      // %1
@@ -650,24 +652,24 @@ struct gcc_arm_extra_operations< Base, 4u, Signed > :
             :
             : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC
         );
-        gcc_arm_operations_base::fence_after(order);
+        core_arch_operations_gcc_arm_base::fence_after(order);
         return result;
     }
 
     static BOOST_FORCEINLINE storage_type add(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
     {
-        gcc_arm_operations_base::fence_before(order);
+        core_arch_operations_gcc_arm_base::fence_before(order);
         uint32_t tmp;
         storage_type original, result;
         __asm__ __volatile__
         (
             BOOST_ATOMIC_DETAIL_ARM_ASM_START(%[tmp])
-            "1:\n"
-            "ldrex   %[original], %[storage]\n"           // original = *(&storage)
-            "add     %[result], %[original], %[value]\n"  // result = original + value
-            "strex   %[tmp], %[result], %[storage]\n"     // *(&storage) = result, tmp = store failed
-            "teq     %[tmp], #0\n"                        // flags = tmp==0
-            "bne     1b\n"                                // if (!flags.equal) goto retry
+            "1:\n\t"
+            "ldrex   %[original], %[storage]\n\t"           // original = *(&storage)
+            "add     %[result], %[original], %[value]\n\t"  // result = original + value
+            "strex   %[tmp], %[result], %[storage]\n\t"     // *(&storage) = result, tmp = store failed
+            "teq     %[tmp], #0\n\t"                        // flags = tmp==0
+            "bne     1b\n\t"                                // if (!flags.equal) goto retry
             BOOST_ATOMIC_DETAIL_ARM_ASM_END(%[tmp])
             : [original] "=&r" (original),  // %0
               [result] "=&r" (result),      // %1
@@ -676,24 +678,24 @@ struct gcc_arm_extra_operations< Base, 4u, Signed > :
             : [value] "Ir" (v)              // %4
             : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC
         );
-        gcc_arm_operations_base::fence_after(order);
+        core_arch_operations_gcc_arm_base::fence_after(order);
         return result;
     }
 
     static BOOST_FORCEINLINE storage_type sub(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
     {
-        gcc_arm_operations_base::fence_before(order);
+        core_arch_operations_gcc_arm_base::fence_before(order);
         uint32_t tmp;
         storage_type original, result;
         __asm__ __volatile__
         (
             BOOST_ATOMIC_DETAIL_ARM_ASM_START(%[tmp])
-            "1:\n"
-            "ldrex   %[original], %[storage]\n"           // original = *(&storage)
-            "sub     %[result], %[original], %[value]\n"  // result = original - value
-            "strex   %[tmp], %[result], %[storage]\n"     // *(&storage) = result, tmp = store failed
-            "teq     %[tmp], #0\n"                        // flags = tmp==0
-            "bne     1b\n"                                // if (!flags.equal) goto retry
+            "1:\n\t"
+            "ldrex   %[original], %[storage]\n\t"           // original = *(&storage)
+            "sub     %[result], %[original], %[value]\n\t"  // result = original - value
+            "strex   %[tmp], %[result], %[storage]\n\t"     // *(&storage) = result, tmp = store failed
+            "teq     %[tmp], #0\n\t"                        // flags = tmp==0
+            "bne     1b\n\t"                                // if (!flags.equal) goto retry
             BOOST_ATOMIC_DETAIL_ARM_ASM_END(%[tmp])
             : [original] "=&r" (original),  // %0
               [result] "=&r" (result),      // %1
@@ -702,24 +704,24 @@ struct gcc_arm_extra_operations< Base, 4u, Signed > :
             : [value] "Ir" (v)              // %4
             : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC
         );
-        gcc_arm_operations_base::fence_after(order);
+        core_arch_operations_gcc_arm_base::fence_after(order);
         return result;
     }
 
     static BOOST_FORCEINLINE storage_type bitwise_and(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
     {
-        gcc_arm_operations_base::fence_before(order);
+        core_arch_operations_gcc_arm_base::fence_before(order);
         uint32_t tmp;
         storage_type original, result;
         __asm__ __volatile__
         (
             BOOST_ATOMIC_DETAIL_ARM_ASM_START(%[tmp])
-            "1:\n"
-            "ldrex   %[original], %[storage]\n"           // original = *(&storage)
-            "and     %[result], %[original], %[value]\n"  // result = original & value
-            "strex   %[tmp], %[result], %[storage]\n"     // *(&storage) = result, tmp = store failed
-            "teq     %[tmp], #0\n"                        // flags = tmp==0
-            "bne     1b\n"                                // if (!flags.equal) goto retry
+            "1:\n\t"
+            "ldrex   %[original], %[storage]\n\t"           // original = *(&storage)
+            "and     %[result], %[original], %[value]\n\t"  // result = original & value
+            "strex   %[tmp], %[result], %[storage]\n\t"     // *(&storage) = result, tmp = store failed
+            "teq     %[tmp], #0\n\t"                        // flags = tmp==0
+            "bne     1b\n\t"                                // if (!flags.equal) goto retry
             BOOST_ATOMIC_DETAIL_ARM_ASM_END(%[tmp])
             : [original] "=&r" (original),  // %0
               [result] "=&r" (result),      // %1
@@ -728,24 +730,24 @@ struct gcc_arm_extra_operations< Base, 4u, Signed > :
             : [value] "Ir" (v)              // %4
             : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC
         );
-        gcc_arm_operations_base::fence_after(order);
+        core_arch_operations_gcc_arm_base::fence_after(order);
         return result;
     }
 
     static BOOST_FORCEINLINE storage_type bitwise_or(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
     {
-        gcc_arm_operations_base::fence_before(order);
+        core_arch_operations_gcc_arm_base::fence_before(order);
         uint32_t tmp;
         storage_type original, result;
         __asm__ __volatile__
         (
             BOOST_ATOMIC_DETAIL_ARM_ASM_START(%[tmp])
-            "1:\n"
-            "ldrex   %[original], %[storage]\n"           // original = *(&storage)
-            "orr     %[result], %[original], %[value]\n"  // result = original | value
-            "strex   %[tmp], %[result], %[storage]\n"     // *(&storage) = result, tmp = store failed
-            "teq     %[tmp], #0\n"                        // flags = tmp==0
-            "bne     1b\n"                                // if (!flags.equal) goto retry
+            "1:\n\t"
+            "ldrex   %[original], %[storage]\n\t"           // original = *(&storage)
+            "orr     %[result], %[original], %[value]\n\t"  // result = original | value
+            "strex   %[tmp], %[result], %[storage]\n\t"     // *(&storage) = result, tmp = store failed
+            "teq     %[tmp], #0\n\t"                        // flags = tmp==0
+            "bne     1b\n\t"                                // if (!flags.equal) goto retry
             BOOST_ATOMIC_DETAIL_ARM_ASM_END(%[tmp])
             : [original] "=&r" (original),  // %0
               [result] "=&r" (result),      // %1
@@ -754,24 +756,24 @@ struct gcc_arm_extra_operations< Base, 4u, Signed > :
             : [value] "Ir" (v)              // %4
             : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC
         );
-        gcc_arm_operations_base::fence_after(order);
+        core_arch_operations_gcc_arm_base::fence_after(order);
         return result;
     }
 
     static BOOST_FORCEINLINE storage_type bitwise_xor(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
     {
-        gcc_arm_operations_base::fence_before(order);
+        core_arch_operations_gcc_arm_base::fence_before(order);
         uint32_t tmp;
         storage_type original, result;
         __asm__ __volatile__
         (
             BOOST_ATOMIC_DETAIL_ARM_ASM_START(%[tmp])
-            "1:\n"
-            "ldrex   %[original], %[storage]\n"           // original = *(&storage)
-            "eor     %[result], %[original], %[value]\n"  // result = original ^ value
-            "strex   %[tmp], %[result], %[storage]\n"     // *(&storage) = result, tmp = store failed
-            "teq     %[tmp], #0\n"                        // flags = tmp==0
-            "bne     1b\n"                                // if (!flags.equal) goto retry
+            "1:\n\t"
+            "ldrex   %[original], %[storage]\n\t"           // original = *(&storage)
+            "eor     %[result], %[original], %[value]\n\t"  // result = original ^ value
+            "strex   %[tmp], %[result], %[storage]\n\t"     // *(&storage) = result, tmp = store failed
+            "teq     %[tmp], #0\n\t"                        // flags = tmp==0
+            "bne     1b\n\t"                                // if (!flags.equal) goto retry
             BOOST_ATOMIC_DETAIL_ARM_ASM_END(%[tmp])
             : [original] "=&r" (original),  // %0
               [result] "=&r" (result),      // %1
@@ -780,24 +782,24 @@ struct gcc_arm_extra_operations< Base, 4u, Signed > :
             : [value] "Ir" (v)              // %4
             : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC
         );
-        gcc_arm_operations_base::fence_after(order);
+        core_arch_operations_gcc_arm_base::fence_after(order);
         return result;
     }
 
     static BOOST_FORCEINLINE storage_type fetch_complement(storage_type volatile& storage, memory_order order) BOOST_NOEXCEPT
     {
-        gcc_arm_operations_base::fence_before(order);
+        core_arch_operations_gcc_arm_base::fence_before(order);
         uint32_t tmp;
         storage_type original, result;
         __asm__ __volatile__
         (
             BOOST_ATOMIC_DETAIL_ARM_ASM_START(%[tmp])
-            "1:\n"
-            "ldrex    %[original], %[storage]\n"           // original = *(&storage)
-            "mvn      %[result], %[original]\n"            // result = NOT original
-            "strex    %[tmp], %[result], %[storage]\n"     // *(&storage) = result, tmp = store failed
-            "teq      %[tmp], #0\n"                        // flags = tmp==0
-            "bne      1b\n"                                // if (!flags.equal) goto retry
+            "1:\n\t"
+            "ldrex    %[original], %[storage]\n\t"           // original = *(&storage)
+            "mvn      %[result], %[original]\n\t"            // result = NOT original
+            "strex    %[tmp], %[result], %[storage]\n\t"     // *(&storage) = result, tmp = store failed
+            "teq      %[tmp], #0\n\t"                        // flags = tmp==0
+            "bne      1b\n\t"                                // if (!flags.equal) goto retry
             BOOST_ATOMIC_DETAIL_ARM_ASM_END(%[tmp])
             : [original] "=&r" (original),  // %0
               [result] "=&r" (result),      // %1
@@ -806,24 +808,24 @@ struct gcc_arm_extra_operations< Base, 4u, Signed > :
             :
             : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC
         );
-        gcc_arm_operations_base::fence_after(order);
+        core_arch_operations_gcc_arm_base::fence_after(order);
         return original;
     }
 
     static BOOST_FORCEINLINE storage_type bitwise_complement(storage_type volatile& storage, memory_order order) BOOST_NOEXCEPT
     {
-        gcc_arm_operations_base::fence_before(order);
+        core_arch_operations_gcc_arm_base::fence_before(order);
         uint32_t tmp;
         storage_type original, result;
         __asm__ __volatile__
         (
             BOOST_ATOMIC_DETAIL_ARM_ASM_START(%[tmp])
-            "1:\n"
-            "ldrex    %[original], %[storage]\n"           // original = *(&storage)
-            "mvn      %[result], %[original]\n"            // result = NOT original
-            "strex    %[tmp], %[result], %[storage]\n"     // *(&storage) = result, tmp = store failed
-            "teq      %[tmp], #0\n"                        // flags = tmp==0
-            "bne      1b\n"                                // if (!flags.equal) goto retry
+            "1:\n\t"
+            "ldrex    %[original], %[storage]\n\t"           // original = *(&storage)
+            "mvn      %[result], %[original]\n\t"            // result = NOT original
+            "strex    %[tmp], %[result], %[storage]\n\t"     // *(&storage) = result, tmp = store failed
+            "teq      %[tmp], #0\n\t"                        // flags = tmp==0
+            "bne      1b\n\t"                                // if (!flags.equal) goto retry
             BOOST_ATOMIC_DETAIL_ARM_ASM_END(%[tmp])
             : [original] "=&r" (original),  // %0
               [result] "=&r" (result),      // %1
@@ -832,273 +834,277 @@ struct gcc_arm_extra_operations< Base, 4u, Signed > :
             :
             : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC
         );
-        gcc_arm_operations_base::fence_after(order);
+        core_arch_operations_gcc_arm_base::fence_after(order);
         return result;
     }
 };
 
 template< typename Base, bool Signed >
 struct extra_operations< Base, 4u, Signed, true > :
-    public gcc_arm_extra_operations_common< gcc_arm_extra_operations< Base, 4u, Signed > >
+    public extra_operations_gcc_arm_common< extra_operations_gcc_arm< Base, 4u, Signed > >
 {
 };
 
 #if defined(BOOST_ATOMIC_DETAIL_ARM_HAS_LDREXD_STREXD)
 
 template< typename Base, bool Signed >
-struct gcc_arm_extra_operations< Base, 8u, Signed > :
-    public generic_extra_operations< Base, 8u, Signed >
+struct extra_operations_gcc_arm< Base, 8u, Signed > :
+    public extra_operations_generic< Base, 8u, Signed >
 {
-    typedef generic_extra_operations< Base, 8u, Signed > base_type;
+    typedef extra_operations_generic< Base, 8u, Signed > base_type;
     typedef typename base_type::storage_type storage_type;
 
     static BOOST_FORCEINLINE storage_type fetch_negate(storage_type volatile& storage, memory_order order) BOOST_NOEXCEPT
     {
-        gcc_arm_operations_base::fence_before(order);
+        core_arch_operations_gcc_arm_base::fence_before(order);
         storage_type original, result;
         uint32_t tmp;
         __asm__ __volatile__
         (
             BOOST_ATOMIC_DETAIL_ARM_ASM_START(%0)
-            "1:\n"
-            "ldrexd  %1, %H1, [%3]\n"               // original = *(&storage)
-            "mvn     %2, %1\n"                      // result = NOT original
-            "mvn     %H2, %H1\n"
-            "adds    %2, %2, #1\n"                  // result = result + 1
-            "adc     %H2, %H2, #0\n"
-            "strexd  %0, %2, %H2, [%3]\n"           // *(&storage) = result, tmp = store failed
-            "teq     %0, #0\n"                      // flags = tmp==0
-            "bne     1b\n"                          // if (!flags.equal) goto retry
+            "1:\n\t"
+            "ldrexd  %1, %H1, %3\n\t"                 // original = *(&storage)
+            "mvn     %2, %1\n\t"                      // result = NOT original
+            "mvn     %H2, %H1\n\t"
+            "adds   " BOOST_ATOMIC_DETAIL_ARM_ASM_ARG_LO(2) ", " BOOST_ATOMIC_DETAIL_ARM_ASM_ARG_LO(2) ", #1\n\t" // result = result + 1
+            "adc    " BOOST_ATOMIC_DETAIL_ARM_ASM_ARG_HI(2) ", " BOOST_ATOMIC_DETAIL_ARM_ASM_ARG_HI(2) ", #0\n\t"
+            "strexd  %0, %2, %H2, %3\n\t"             // *(&storage) = result, tmp = store failed
+            "teq     %0, #0\n\t"                      // flags = tmp==0
+            "bne     1b\n\t"                          // if (!flags.equal) goto retry
             BOOST_ATOMIC_DETAIL_ARM_ASM_END(%0)
             : BOOST_ATOMIC_DETAIL_ARM_ASM_TMPREG_CONSTRAINT(tmp), // %0
               "=&r" (original),  // %1
-              "=&r" (result)     // %2
-            : "r" (&storage)     // %3
-            : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC_COMMA "memory"
+              "=&r" (result),    // %2
+              "+Q" (storage)     // %3
+            :
+            : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC
         );
-        gcc_arm_operations_base::fence_after(order);
+        core_arch_operations_gcc_arm_base::fence_after(order);
         return original;
     }
 
     static BOOST_FORCEINLINE storage_type negate(storage_type volatile& storage, memory_order order) BOOST_NOEXCEPT
     {
-        gcc_arm_operations_base::fence_before(order);
+        core_arch_operations_gcc_arm_base::fence_before(order);
         storage_type original, result;
         uint32_t tmp;
         __asm__ __volatile__
         (
             BOOST_ATOMIC_DETAIL_ARM_ASM_START(%0)
-            "1:\n"
-            "ldrexd  %1, %H1, [%3]\n"               // original = *(&storage)
-            "mvn     %2, %1\n"                      // result = NOT original
-            "mvn     %H2, %H1\n"
-            "adds    %2, %2, #1\n"                  // result = result + 1
-            "adc     %H2, %H2, #0\n"
-            "strexd  %0, %2, %H2, [%3]\n"           // *(&storage) = result, tmp = store failed
-            "teq     %0, #0\n"                      // flags = tmp==0
-            "bne     1b\n"                          // if (!flags.equal) goto retry
+            "1:\n\t"
+            "ldrexd  %1, %H1, %3\n\t"                 // original = *(&storage)
+            "mvn     %2, %1\n\t"                      // result = NOT original
+            "mvn     %H2, %H1\n\t"
+            "adds   " BOOST_ATOMIC_DETAIL_ARM_ASM_ARG_LO(2) ", " BOOST_ATOMIC_DETAIL_ARM_ASM_ARG_LO(2) ", #1\n\t" // result = result + 1
+            "adc    " BOOST_ATOMIC_DETAIL_ARM_ASM_ARG_HI(2) ", " BOOST_ATOMIC_DETAIL_ARM_ASM_ARG_HI(2) ", #0\n\t"
+            "strexd  %0, %2, %H2, %3\n\t"             // *(&storage) = result, tmp = store failed
+            "teq     %0, #0\n\t"                      // flags = tmp==0
+            "bne     1b\n\t"                          // if (!flags.equal) goto retry
             BOOST_ATOMIC_DETAIL_ARM_ASM_END(%0)
             : BOOST_ATOMIC_DETAIL_ARM_ASM_TMPREG_CONSTRAINT(tmp), // %0
               "=&r" (original),  // %1
-              "=&r" (result)     // %2
-            : "r" (&storage)     // %3
-            : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC_COMMA "memory"
+              "=&r" (result),    // %2
+              "+Q" (storage)     // %3
+            :
+            : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC
         );
-        gcc_arm_operations_base::fence_after(order);
+        core_arch_operations_gcc_arm_base::fence_after(order);
         return result;
     }
 
     static BOOST_FORCEINLINE storage_type add(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
     {
-        gcc_arm_operations_base::fence_before(order);
+        core_arch_operations_gcc_arm_base::fence_before(order);
         storage_type original, result;
         uint32_t tmp;
         __asm__ __volatile__
         (
             BOOST_ATOMIC_DETAIL_ARM_ASM_START(%0)
-            "1:\n"
-            "ldrexd  %1, %H1, [%3]\n"               // original = *(&storage)
-            "adds    %2, %1, %4\n"                  // result = original + value
-            "adc     %H2, %H1, %H4\n"
-            "strexd  %0, %2, %H2, [%3]\n"           // *(&storage) = result, tmp = store failed
-            "teq     %0, #0\n"                      // flags = tmp==0
-            "bne     1b\n"                          // if (!flags.equal) goto retry
+            "1:\n\t"
+            "ldrexd  %1, %H1, %3\n\t"                 // original = *(&storage)
+            "adds   " BOOST_ATOMIC_DETAIL_ARM_ASM_ARG_LO(2) ", " BOOST_ATOMIC_DETAIL_ARM_ASM_ARG_LO(1) ", " BOOST_ATOMIC_DETAIL_ARM_ASM_ARG_LO(4) "\n\t" // result = original + value
+            "adc    " BOOST_ATOMIC_DETAIL_ARM_ASM_ARG_HI(2) ", " BOOST_ATOMIC_DETAIL_ARM_ASM_ARG_HI(1) ", " BOOST_ATOMIC_DETAIL_ARM_ASM_ARG_HI(4) "\n\t"
+            "strexd  %0, %2, %H2, %3\n\t"             // *(&storage) = result, tmp = store failed
+            "teq     %0, #0\n\t"                      // flags = tmp==0
+            "bne     1b\n\t"                          // if (!flags.equal) goto retry
             BOOST_ATOMIC_DETAIL_ARM_ASM_END(%0)
             : BOOST_ATOMIC_DETAIL_ARM_ASM_TMPREG_CONSTRAINT(tmp), // %0
               "=&r" (original),  // %1
-              "=&r" (result)     // %2
-            : "r" (&storage),    // %3
-              "r" (v)            // %4
-            : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC_COMMA "memory"
+              "=&r" (result),    // %2
+              "+Q" (storage)     // %3
+            : "r" (v)            // %4
+            : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC
         );
-        gcc_arm_operations_base::fence_after(order);
+        core_arch_operations_gcc_arm_base::fence_after(order);
         return result;
     }
 
     static BOOST_FORCEINLINE storage_type sub(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
     {
-        gcc_arm_operations_base::fence_before(order);
+        core_arch_operations_gcc_arm_base::fence_before(order);
         storage_type original, result;
         uint32_t tmp;
         __asm__ __volatile__
         (
             BOOST_ATOMIC_DETAIL_ARM_ASM_START(%0)
-            "1:\n"
-            "ldrexd  %1, %H1, [%3]\n"               // original = *(&storage)
-            "subs    %2, %1, %4\n"                  // result = original - value
-            "sbc     %H2, %H1, %H4\n"
-            "strexd  %0, %2, %H2, [%3]\n"           // *(&storage) = result, tmp = store failed
-            "teq     %0, #0\n"                      // flags = tmp==0
-            "bne     1b\n"                          // if (!flags.equal) goto retry
+            "1:\n\t"
+            "ldrexd  %1, %H1, %3\n\t"                 // original = *(&storage)
+            "subs   " BOOST_ATOMIC_DETAIL_ARM_ASM_ARG_LO(2) ", " BOOST_ATOMIC_DETAIL_ARM_ASM_ARG_LO(1) ", " BOOST_ATOMIC_DETAIL_ARM_ASM_ARG_LO(4) "\n\t" // result = original - value
+            "sbc    " BOOST_ATOMIC_DETAIL_ARM_ASM_ARG_HI(2) ", " BOOST_ATOMIC_DETAIL_ARM_ASM_ARG_HI(1) ", " BOOST_ATOMIC_DETAIL_ARM_ASM_ARG_HI(4) "\n\t"
+            "strexd  %0, %2, %H2, %3\n\t"             // *(&storage) = result, tmp = store failed
+            "teq     %0, #0\n\t"                      // flags = tmp==0
+            "bne     1b\n\t"                          // if (!flags.equal) goto retry
             BOOST_ATOMIC_DETAIL_ARM_ASM_END(%0)
             : BOOST_ATOMIC_DETAIL_ARM_ASM_TMPREG_CONSTRAINT(tmp), // %0
               "=&r" (original),  // %1
-              "=&r" (result)     // %2
-            : "r" (&storage),    // %3
-              "r" (v)            // %4
-            : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC_COMMA "memory"
+              "=&r" (result),    // %2
+              "+Q" (storage)     // %3
+            : "r" (v)            // %4
+            : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC
         );
-        gcc_arm_operations_base::fence_after(order);
+        core_arch_operations_gcc_arm_base::fence_after(order);
         return result;
     }
 
     static BOOST_FORCEINLINE storage_type bitwise_and(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
     {
-        gcc_arm_operations_base::fence_before(order);
+        core_arch_operations_gcc_arm_base::fence_before(order);
         storage_type original, result;
         uint32_t tmp;
         __asm__ __volatile__
         (
             BOOST_ATOMIC_DETAIL_ARM_ASM_START(%0)
-            "1:\n"
-            "ldrexd  %1, %H1, [%3]\n"               // original = *(&storage)
-            "and     %2, %1, %4\n"                  // result = original & value
-            "and     %H2, %H1, %H4\n"
-            "strexd  %0, %2, %H2, [%3]\n"           // *(&storage) = result, tmp = store failed
-            "teq     %0, #0\n"                      // flags = tmp==0
-            "bne     1b\n"                          // if (!flags.equal) goto retry
+            "1:\n\t"
+            "ldrexd  %1, %H1, %3\n\t"                 // original = *(&storage)
+            "and     %2, %1, %4\n\t"                  // result = original & value
+            "and     %H2, %H1, %H4\n\t"
+            "strexd  %0, %2, %H2, %3\n\t"             // *(&storage) = result, tmp = store failed
+            "teq     %0, #0\n\t"                      // flags = tmp==0
+            "bne     1b\n\t"                          // if (!flags.equal) goto retry
             BOOST_ATOMIC_DETAIL_ARM_ASM_END(%0)
             : BOOST_ATOMIC_DETAIL_ARM_ASM_TMPREG_CONSTRAINT(tmp), // %0
               "=&r" (original),  // %1
-              "=&r" (result)     // %2
-            : "r" (&storage),    // %3
-              "r" (v)            // %4
-            : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC_COMMA "memory"
+              "=&r" (result),    // %2
+              "+Q" (storage)     // %3
+            : "r" (v)            // %4
+            : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC
         );
-        gcc_arm_operations_base::fence_after(order);
+        core_arch_operations_gcc_arm_base::fence_after(order);
         return result;
     }
 
     static BOOST_FORCEINLINE storage_type bitwise_or(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
     {
-        gcc_arm_operations_base::fence_before(order);
+        core_arch_operations_gcc_arm_base::fence_before(order);
         storage_type original, result;
         uint32_t tmp;
         __asm__ __volatile__
         (
             BOOST_ATOMIC_DETAIL_ARM_ASM_START(%0)
-            "1:\n"
-            "ldrexd  %1, %H1, [%3]\n"               // original = *(&storage)
-            "orr     %2, %1, %4\n"                  // result = original | value
-            "orr     %H2, %H1, %H4\n"
-            "strexd  %0, %2, %H2, [%3]\n"           // *(&storage) = result, tmp = store failed
-            "teq     %0, #0\n"                      // flags = tmp==0
-            "bne     1b\n"                          // if (!flags.equal) goto retry
+            "1:\n\t"
+            "ldrexd  %1, %H1, %3\n\t"                 // original = *(&storage)
+            "orr     %2, %1, %4\n\t"                  // result = original | value
+            "orr     %H2, %H1, %H4\n\t"
+            "strexd  %0, %2, %H2, %3\n\t"             // *(&storage) = result, tmp = store failed
+            "teq     %0, #0\n\t"                      // flags = tmp==0
+            "bne     1b\n\t"                          // if (!flags.equal) goto retry
             BOOST_ATOMIC_DETAIL_ARM_ASM_END(%0)
             : BOOST_ATOMIC_DETAIL_ARM_ASM_TMPREG_CONSTRAINT(tmp), // %0
               "=&r" (original),  // %1
-              "=&r" (result)     // %2
-            : "r" (&storage),    // %3
-              "r" (v)            // %4
-            : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC_COMMA "memory"
+              "=&r" (result),    // %2
+              "+Q" (storage)     // %3
+            : "r" (v)            // %4
+            : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC
         );
-        gcc_arm_operations_base::fence_after(order);
+        core_arch_operations_gcc_arm_base::fence_after(order);
         return result;
     }
 
     static BOOST_FORCEINLINE storage_type bitwise_xor(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
     {
-        gcc_arm_operations_base::fence_before(order);
+        core_arch_operations_gcc_arm_base::fence_before(order);
         storage_type original, result;
         uint32_t tmp;
         __asm__ __volatile__
         (
             BOOST_ATOMIC_DETAIL_ARM_ASM_START(%0)
-            "1:\n"
-            "ldrexd  %1, %H1, [%3]\n"               // original = *(&storage)
-            "eor     %2, %1, %4\n"                  // result = original ^ value
-            "eor     %H2, %H1, %H4\n"
-            "strexd  %0, %2, %H2, [%3]\n"           // *(&storage) = result, tmp = store failed
-            "teq     %0, #0\n"                      // flags = tmp==0
-            "bne     1b\n"                          // if (!flags.equal) goto retry
+            "1:\n\t"
+            "ldrexd  %1, %H1, %3\n\t"                 // original = *(&storage)
+            "eor     %2, %1, %4\n\t"                  // result = original ^ value
+            "eor     %H2, %H1, %H4\n\t"
+            "strexd  %0, %2, %H2, %3\n\t"             // *(&storage) = result, tmp = store failed
+            "teq     %0, #0\n\t"                      // flags = tmp==0
+            "bne     1b\n\t"                          // if (!flags.equal) goto retry
             BOOST_ATOMIC_DETAIL_ARM_ASM_END(%0)
             : BOOST_ATOMIC_DETAIL_ARM_ASM_TMPREG_CONSTRAINT(tmp), // %0
               "=&r" (original),  // %1
-              "=&r" (result)     // %2
-            : "r" (&storage),    // %3
-              "r" (v)            // %4
-            : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC_COMMA "memory"
+              "=&r" (result),    // %2
+              "+Q" (storage)     // %3
+            : "r" (v)            // %4
+            : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC
         );
-        gcc_arm_operations_base::fence_after(order);
+        core_arch_operations_gcc_arm_base::fence_after(order);
         return result;
     }
 
     static BOOST_FORCEINLINE storage_type fetch_complement(storage_type volatile& storage, memory_order order) BOOST_NOEXCEPT
     {
-        gcc_arm_operations_base::fence_before(order);
+        core_arch_operations_gcc_arm_base::fence_before(order);
         storage_type original, result;
         uint32_t tmp;
         __asm__ __volatile__
         (
             BOOST_ATOMIC_DETAIL_ARM_ASM_START(%0)
-            "1:\n"
-            "ldrexd  %1, %H1, [%3]\n"               // original = *(&storage)
-            "mvn     %2, %1\n"                      // result = NOT original
-            "mvn     %H2, %H1\n"
-            "strexd  %0, %2, %H2, [%3]\n"           // *(&storage) = result, tmp = store failed
-            "teq     %0, #0\n"                      // flags = tmp==0
-            "bne     1b\n"                          // if (!flags.equal) goto retry
+            "1:\n\t"
+            "ldrexd  %1, %H1, %3\n\t"                 // original = *(&storage)
+            "mvn     %2, %1\n\t"                      // result = NOT original
+            "mvn     %H2, %H1\n\t"
+            "strexd  %0, %2, %H2, %3\n\t"             // *(&storage) = result, tmp = store failed
+            "teq     %0, #0\n\t"                      // flags = tmp==0
+            "bne     1b\n\t"                          // if (!flags.equal) goto retry
             BOOST_ATOMIC_DETAIL_ARM_ASM_END(%0)
             : BOOST_ATOMIC_DETAIL_ARM_ASM_TMPREG_CONSTRAINT(tmp), // %0
               "=&r" (original),  // %1
-              "=&r" (result)     // %2
-            : "r" (&storage)     // %3
-            : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC_COMMA "memory"
+              "=&r" (result),    // %2
+              "+Q" (storage)     // %3
+            :
+            : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC
         );
-        gcc_arm_operations_base::fence_after(order);
+        core_arch_operations_gcc_arm_base::fence_after(order);
         return original;
     }
 
     static BOOST_FORCEINLINE storage_type bitwise_complement(storage_type volatile& storage, memory_order order) BOOST_NOEXCEPT
     {
-        gcc_arm_operations_base::fence_before(order);
+        core_arch_operations_gcc_arm_base::fence_before(order);
         storage_type original, result;
         uint32_t tmp;
         __asm__ __volatile__
         (
             BOOST_ATOMIC_DETAIL_ARM_ASM_START(%0)
-            "1:\n"
-            "ldrexd  %1, %H1, [%3]\n"               // original = *(&storage)
-            "mvn     %2, %1\n"                      // result = NOT original
-            "mvn     %H2, %H1\n"
-            "strexd  %0, %2, %H2, [%3]\n"           // *(&storage) = result, tmp = store failed
-            "teq     %0, #0\n"                      // flags = tmp==0
-            "bne     1b\n"                          // if (!flags.equal) goto retry
+            "1:\n\t"
+            "ldrexd  %1, %H1, %3\n\t"                 // original = *(&storage)
+            "mvn     %2, %1\n\t"                      // result = NOT original
+            "mvn     %H2, %H1\n\t"
+            "strexd  %0, %2, %H2, %3\n\t"             // *(&storage) = result, tmp = store failed
+            "teq     %0, #0\n\t"                      // flags = tmp==0
+            "bne     1b\n\t"                          // if (!flags.equal) goto retry
             BOOST_ATOMIC_DETAIL_ARM_ASM_END(%0)
             : BOOST_ATOMIC_DETAIL_ARM_ASM_TMPREG_CONSTRAINT(tmp), // %0
               "=&r" (original),  // %1
-              "=&r" (result)     // %2
-            : "r" (&storage)     // %3
-            : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC_COMMA "memory"
+              "=&r" (result),    // %2
+              "+Q" (storage)     // %3
+            :
+            : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC
         );
-        gcc_arm_operations_base::fence_after(order);
+        core_arch_operations_gcc_arm_base::fence_after(order);
         return result;
     }
 };
 
 template< typename Base, bool Signed >
 struct extra_operations< Base, 8u, Signed, true > :
-    public gcc_arm_extra_operations_common< gcc_arm_extra_operations< Base, 8u, Signed > >
+    public extra_operations_gcc_arm_common< extra_operations_gcc_arm< Base, 8u, Signed > >
 {
 };
 
@@ -1108,4 +1114,6 @@ struct extra_operations< Base, 8u, Signed, true > :
 } // namespace atomics
 } // namespace boost
 
+#include <boost/atomic/detail/footer.hpp>
+
 #endif // BOOST_ATOMIC_DETAIL_EXTRA_OPS_GCC_ARM_HPP_INCLUDED_