Subzero. ARM32. Refactors atomic intrinsics lowering.

crosstest/test_sync_atomic.cpp

 //===- subzero/crosstest/test_sync_atomic.cpp - Implementation for tests --===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This aims to test that all the atomic RMW instructions and compare and swap
@@ skipping 29 matching lines @@
     type sum = 0;                                                              \
     for (size_t i = 0; i < buf_size; ++i) {                                    \
       sum += buf[i];                                                           \
     }                                                                          \
     return sum;                                                                \
   }                                                                            \
   type test_const_##inst(bool fetch, volatile type *ptr, type ign) {           \
     if (fetch) {                                                               \
       return __sync_fetch_and_##inst(ptr, 42);                                 \
     } else {                                                                   \
-      return __sync_##inst##_and_fetch(ptr, 99);                               \
+      const type value = static_cast<type>(0xaaaaaaaaaaaaaaaaull);             \
+      return __sync_##inst##_and_fetch(ptr, value);                            \
     }                                                                          \
   }
 
 FOR_ALL_RMWOP_TYPES(X)
 #undef X
 
 #define X(type)                                                                \
   type test_val_cmp_swap(volatile type *ptr, type oldval, type newval) {       \
     return __sync_val_compare_and_swap(ptr, oldval, newval);                   \
   }                                                                            \
   type test_val_cmp_swap_loop(volatile type *ptr, type oldval, type newval) {  \
     type prev;                                                                 \
     type succeeded_first_try = 1;                                              \
     while (1) {                                                                \
       prev = __sync_val_compare_and_swap(ptr, oldval, newval);                 \
       if (prev == oldval)                                                      \
         break;                                                                 \
       succeeded_first_try = 0;                                                 \
       oldval = prev;                                                           \
     }                                                                          \
     return succeeded_first_try;                                                \
   }
 
 ATOMIC_TYPE_TABLE
 #undef X