Atomic<T>: Use pre-op assembler primitives

Use the pre-op assembler primitives that use one fewer register where
possible.

Note that this means that `++atomic;` or `atomic += 1;` will be more
efficient than `atomic++;` or `atomic->fetch_add(1);`.

The inline assembler can't detect that the return value of `atomic++;`
is not used and avoid the extra register.

Author: kjbracey

platform/Atomic.h

@@ -530,7 +530,7 @@ struct AtomicWithAdd : public AtomicBaseInt<T, A> {
     T operator++() volatile
     {
         A d = static_cast<A>(sizeof(StrideT));
-        return T(core_util_atomic_fetch_add(&this->u, d) + d);
+        return T(core_util_atomic_incr(&this->u, d));
     }
     T operator++(int) volatile
     {
@@ -540,7 +540,7 @@ struct AtomicWithAdd : public AtomicBaseInt<T, A> {
     T operator--() volatile
     {
         A d = static_cast<A>(sizeof(StrideT));
-        return T(core_util_atomic_fetch_sub(&this->u, d) - d);
+        return T(core_util_atomic_decr(&this->u, d));
     }
     T operator--(int) volatile
     {
@@ -560,7 +560,7 @@ struct AtomicWithAdd : public AtomicBaseInt<T, A> {
     T operator+=(DiffT arg) volatile
     {
         A d = static_cast<A>(arg * sizeof(StrideT));
-        return T(core_util_atomic_fetch_add(&this->u, d) + d);
+        return T(core_util_atomic_incr(&this->u, d));
     }
     T fetch_sub(DiffT arg) volatile
     {
@@ -575,7 +575,7 @@ struct AtomicWithAdd : public AtomicBaseInt<T, A> {
     T operator-=(DiffT arg) volatile
     {
         A d = static_cast<A>(arg * sizeof(StrideT));
-        return T(core_util_atomic_fetch_sub(&this->u, d) - d);
+        return T(core_util_atomic_decr(&this->u, d));
     }
 };
 
@@ -602,7 +602,7 @@ struct AtomicWithBitwise : public AtomicWithAdd<T, A> {
     T operator&=(T arg) volatile
     {
         A d = static_cast<A>(arg);
-        return static_cast<T>(core_util_atomic_fetch_and(&this->u, d) & d);
+        return static_cast<T>(core_util_atomic_and_fetch(&this->u, d));
     }
     T fetch_or(T arg) volatile
     {
@@ -617,7 +617,7 @@ struct AtomicWithBitwise : public AtomicWithAdd<T, A> {
     T operator|=(T arg) volatile
     {
         A d = static_cast<A>(arg);
-        return static_cast<T>(core_util_atomic_fetch_or(&this->u, d) | d);
+        return static_cast<T>(core_util_atomic_or_fetch(&this->u, d));
     }
     T fetch_xor(T arg) volatile
     {
@@ -632,7 +632,7 @@ struct AtomicWithBitwise : public AtomicWithAdd<T, A> {
     T operator^=(T arg) volatile
     {
         A d = static_cast<A>(arg);
-        return static_cast<T>(core_util_atomic_fetch_xor(&this->u, d) ^ d);
+        return static_cast<T>(core_util_atomic_xor_fetch(&this->u, d));
     }
 };