Subzero. Removes X8664_STACK_HACK from the crosstests.

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 158 matching lines @@
   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)
-void AllocStackForThread(uint32 m, pthread_attr_t *attr) {
-  static const uint32_t ThreadStackBase = 0x60000000;
-  static const uint32_t ThreadStackSize = 4 << 20; // 4MB.
-  if (pthread_attr_setstack(
-          attr, xAllocStack(ThreadStackBase - 2 * m * ThreadStackSize,
-                            ThreadStackSize),
-          ThreadStackSize) != 0) {
-    std::cout << "pthread_attr_setstack: " << strerror(errno) << "\n";
-    abort();
-  }
-}
-#endif // X8664_STACK_HACK
-
 template <typename Type>
 void testAtomicRMWThreads(volatile Type *AtomicLoc, size_t &TotalTests,
                           size_t &Passes, size_t &Failures) {
   typedef Type (*FuncType)(bool, volatile Type *, Type);
   static struct {
     const char *Name;
     FuncType FuncLlc;
     FuncType FuncSz;
   } Funcs[] = {
 #define X(inst)                                                                \
@@ skipping 20 matching lines @@
                                      Value2};
         ++TotalTests;
         const size_t NumThreads = 4;
         pthread_t t[NumThreads];
         pthread_attr_t attr[NumThreads];
 
         // Try N threads w/ just Llc.
         *AtomicLoc = Value1;
         for (size_t m = 0; m < NumThreads; ++m) {
           pthread_attr_init(&attr[m]);
-          AllocStackForThread(m, &attr[m]);
           if (pthread_create(&t[m], &attr[m], &threadWrapper<Type>,
                              reinterpret_cast<void *>(&TDataLlc)) != 0) {
             std::cout << "pthread_create failed w/ " << strerror(errno) << "\n";
             abort();
           }
         }
         for (size_t m = 0; m < NumThreads; ++m) {
           pthread_join(t[m], NULL);
         }
         Type ResultLlc = *AtomicLoc;
 
         // Try N threads w/ both Sz and Llc.
         *AtomicLoc = Value1;
         for (size_t m = 0; m < NumThreads; ++m) {
           pthread_attr_init(&attr[m]);
-          AllocStackForThread(m, &attr[m]);
           if (pthread_create(&t[m], &attr[m], &threadWrapper<Type>,
                              m % 2 == 0
                                  ? reinterpret_cast<void *>(&TDataLlc)
                                  : reinterpret_cast<void *>(&TDataSz)) != 0) {
             ++Failures;
             std::cout << "pthread_create failed w/ " << strerror(errno) << "\n";
             abort();
           }
         }
         for (size_t m = 0; m < NumThreads; ++m) {
@@ skipping 13 matching lines @@
                     << (8 * sizeof(Type)) << "(" << static_cast<uint64>(Value1)
                     << ", " << static_cast<uint64>(Value2)
                     << "): llc=" << static_cast<uint64>(ResultLlc)
                     << " mixed=" << static_cast<uint64>(ResultMixed) << "\n";
         }
       }
     }
   }
 }
 
-#ifdef X8664_STACK_HACK
-extern "C" int wrapped_main(int argc, char *argv[]) {
-#else  // !defined(X8664_STACK_HACK)
 int main(int argc, char *argv[]) {
-#endif // X8664_STACK_HACK
   size_t TotalTests = 0;
   size_t Passes = 0;
   size_t Failures = 0;
 
   testAtomicRMW<uint8_t>(&AtomicLocs.l8, TotalTests, Passes, Failures);
   testAtomicRMW<uint16_t>(&AtomicLocs.l16, TotalTests, Passes, Failures);
   testAtomicRMW<uint32_t>(&AtomicLocs.l32, TotalTests, Passes, Failures);
   testAtomicRMW<uint64>(&AtomicLocs.l64, TotalTests, Passes, Failures);
   testValCompareAndSwap<uint8_t>(&AtomicLocs.l8, TotalTests, Passes, Failures);
   testValCompareAndSwap<uint16_t>(&AtomicLocs.l16, TotalTests, Passes,
                                   Failures);
   testValCompareAndSwap<uint32_t>(&AtomicLocs.l32, TotalTests, Passes,
                                   Failures);
   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;
 }