Subzero. Enable Atomics in ARM.

crosstest/test_sync_atomic_main.cpp

 //===- subzero/crosstest/test_sync_atomic_main.cpp - Driver for tests -----===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // Driver for cross testing atomic intrinsics, via the sync builtins.
@@ skipping 74 matching lines @@
           Type ResultSz1 = Funcs[f].FuncSz(fetch_first, AtomicLoc, Value2);
           Type ResultSz2 = *AtomicLoc;
           *AtomicLoc = Value1;
           Type ResultLlc1 = Funcs[f].FuncLlc(fetch_first, AtomicLoc, Value2);
           Type ResultLlc2 = *AtomicLoc;
           if (ResultSz1 == ResultLlc1 && ResultSz2 == ResultLlc2) {
             ++Passes;
           } else {
             ++Failures;
             std::cout << "test_" << Funcs[f].Name << (CHAR_BIT * sizeof(Type))
-                      << "(" << static_cast<uint64>(Value1) << ", "
+                      << "(" << fetch_first << ", "
+                      << static_cast<uint64>(Value1) << ", "
                       << static_cast<uint64>(Value2)
                       << "): sz1=" << static_cast<uint64>(ResultSz1)
                       << " llc1=" << static_cast<uint64>(ResultLlc1)
                       << " sz2=" << static_cast<uint64>(ResultSz2)
                       << " llc2=" << static_cast<uint64>(ResultLlc2) << "\n";
           }
         }
       }
     }
   }
@@ skipping 26 matching lines @@
           *AtomicLoc = Value1;
           Type ResultLlc1 =
               Funcs[f].FuncLlc(AtomicLoc, flip ? Value2 : Value1, Value2);
           Type ResultLlc2 = *AtomicLoc;
           if (ResultSz1 == ResultLlc1 && ResultSz2 == ResultLlc2) {
             ++Passes;
           } else {
             ++Failures;
             std::cout << "test_" << Funcs[f].Name << (CHAR_BIT * sizeof(Type))
                       << "(" << static_cast<uint64>(Value1) << ", "
-                      << static_cast<uint64>(Value2)
+                      << static_cast<uint64>(Value2) << ", flip=" << flip
                       << "): sz1=" << static_cast<uint64>(ResultSz1)
                       << " llc1=" << static_cast<uint64>(ResultLlc1)
                       << " sz2=" << static_cast<uint64>(ResultSz2)
                       << " llc2=" << static_cast<uint64>(ResultLlc2) << "\n";
           }
         }
       }
     }
   }
 }
 
 template <typename Type> struct ThreadData {
   Type (*FuncPtr)(bool, volatile Type *, Type);
   bool Fetch;
   volatile Type *Ptr;
   Type Adjustment;
 };
 
 template <typename Type> void *threadWrapper(void *Data) {
-  const size_t NumReps = 8000;
+#ifdef ARM32
+  // Given that most of times these crosstests for ARM are run under qemu, we
+  // set a lower NumReps to allow crosstests to complete within a reasonable
+  // amount of time.
+  static const size_t NumReps = 1000;
+#else  // ARM32
+  static const size_t NumReps = 8000;
+#endif // ARM32
+
   ThreadData<Type> *TData = reinterpret_cast<ThreadData<Type> *>(Data);
   for (size_t i = 0; i < NumReps; ++i) {
     (void)TData->FuncPtr(TData->Fetch, TData->Ptr, TData->Adjustment);
   }
   return NULL;
 }
 
 #ifndef X8664_STACK_HACK
 void AllocStackForThread(uint32, pthread_attr_t *) {}
 #else  // defined(X8664_STACK_HACK)
@@ skipping 121 matching lines @@
   testValCompareAndSwap<uint64>(&AtomicLocs.l64, TotalTests, Passes, Failures);
   testAtomicRMWThreads<uint8_t>(&AtomicLocs.l8, TotalTests, Passes, Failures);
   testAtomicRMWThreads<uint16_t>(&AtomicLocs.l16, TotalTests, Passes, Failures);
   testAtomicRMWThreads<uint32_t>(&AtomicLocs.l32, TotalTests, Passes, Failures);
   testAtomicRMWThreads<uint64>(&AtomicLocs.l64, TotalTests, Passes, Failures);
 
   std::cout << "TotalTests=" << TotalTests << " Passes=" << Passes
             << " Failures=" << Failures << "\n";
   return Failures;
 }