[compiler-rt] Fix issue with compiler-rt tests mixing <atomic> and <stdatomic.h>

[ldionne]

Summary

Since D97044, libc++ implements <stdatomic.h>, which is not compatible
with the <atomic> header in C++03 mode. To fix the tests, avoid using
<stdatomic.h> at all, since it is not strictly required.

rdar://92867529

[ldionne]

I'll ship this right now to unbreak the Green Dragon build (I've verified this locally). If reviewers have comments, I'll be happy to address them post-review. I'd just like to fix the build before leaving for the week-end.

[kubamracek]

LGTM.

compiler-rt/test/tsan/Darwin/libcxx-shared-ptr-stress.mm

 // RUN: %clangxx_tsan %s -o %t -framework Foundation
 // RUN: %run %t 2>&1 | FileCheck %s
 
 #import <Foundation/Foundation.h>
 
-#import <assert.h>
+#import <atomic>
+#import <cassert>
+#import <cstdio>
 #import <memory>
-#import <stdatomic.h>
 
-_Atomic(long) shared_call_counter = 0;
-_Atomic(long) weak_call_counter = 0;
-_Atomic(long) destructor_counter = 0;
-_Atomic(long) weak_destroyed_counter = 0;
+std::atomic<long> shared_call_counter(0);
+std::atomic<long> weak_call_counter(0);
+std::atomic<long> destructor_counter(0);
+std::atomic<long> weak_destroyed_counter(0);
 
 struct MyStruct {
-  _Atomic(long) self_counter = 0;
+  std::atomic<long> self_counter;
+  MyStruct() : self_counter(0) { }
   virtual void shared_call() {
-    atomic_fetch_add_explicit(&self_counter, 1, memory_order_relaxed);
-    atomic_fetch_add_explicit(&shared_call_counter, 1, memory_order_relaxed);
+    std::atomic_fetch_add_explicit(&self_counter, 1, std::memory_order_relaxed);
+    std::atomic_fetch_add_explicit(&shared_call_counter, 1, std::memory_order_relaxed);
   }
   virtual void weak_call() {
-    atomic_fetch_add_explicit(&weak_call_counter, 1, memory_order_relaxed);
+    std::atomic_fetch_add_explicit(&weak_call_counter, 1, std::memory_order_relaxed);
   }
   virtual ~MyStruct() {
     long n = self_counter;
     assert(n == 1000);
-    atomic_fetch_add_explicit(&destructor_counter, 1, memory_order_relaxed);
+    std::atomic_fetch_add_explicit(&destructor_counter, 1, std::memory_order_relaxed);
   }
 };
 
 int main(int argc, const char *argv[]) {
-  fprintf(stderr, "Hello world.\n");
+  std::fprintf(stderr, "Hello world.\n");
 
   dispatch_queue_t q = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
 
   dispatch_group_t g = dispatch_group_create();
 
   for (int i = 0; i < 1000; i++) {
     std::shared_ptr<MyStruct> shared(new MyStruct());
     std::weak_ptr<MyStruct> weak(shared);
 
     dispatch_group_async(g, q, ^{
       for (int j = 0; j < 1000; j++) {
         std::shared_ptr<MyStruct> shared_copy(shared);
         shared_copy->shared_call();
       }
     });
     dispatch_group_async(g, q, ^{
       for (int j = 0; j < 1000; j++) {
         std::shared_ptr<MyStruct> weak_copy = weak.lock();
         if (weak_copy) {
           weak_copy->weak_call();
         } else {
-          atomic_fetch_add_explicit(&weak_destroyed_counter, 1, memory_order_relaxed);
+          std::atomic_fetch_add_explicit(&weak_destroyed_counter, 1, std::memory_order_relaxed);
           break;
         }
       }
     });
   }
 
   dispatch_group_wait(g, DISPATCH_TIME_FOREVER);
 
-  fprintf(stderr, "shared_call_counter = %ld\n", shared_call_counter);
-  fprintf(stderr, "weak_call_counter = %ld\n", weak_call_counter);
-  fprintf(stderr, "destructor_counter = %ld\n", destructor_counter);
-  fprintf(stderr, "weak_destroyed_counter = %ld\n", weak_destroyed_counter);
+  std::fprintf(stderr, "shared_call_counter = %ld\n", shared_call_counter.load());
+  std::fprintf(stderr, "weak_call_counter = %ld\n", weak_call_counter.load());
+  std::fprintf(stderr, "destructor_counter = %ld\n", destructor_counter.load());
+  std::fprintf(stderr, "weak_destroyed_counter = %ld\n", weak_destroyed_counter.load());
 
-  fprintf(stderr, "Done.\n");
+  std::fprintf(stderr, "Done.\n");
 }
 
 // CHECK: Hello world.
 // CHECK: shared_call_counter = 1000000
 // CHECK: destructor_counter = 1000
 // CHECK: Done.
 // CHECK-NOT: WARNING: ThreadSanitizer

compiler-rt/test/tsan/libdispatch/groups-destructor.cpp

 // RUN: %clangxx_tsan %s %link_libcxx_tsan -o %t
 // RUN: %run %t 2>&1 | FileCheck %s --implicit-check-not='ThreadSanitizer'
 
 #include <dispatch/dispatch.h>
 
-#include <memory>
-#include <stdatomic.h>
+#include <atomic>
 #include <cstdio>
+#include <memory>
 
-_Atomic(long) destructor_counter = 0;
+std::atomic<long> destructor_counter(0);
 
 struct MyStruct {
   virtual ~MyStruct() {
     usleep(10000);
-    atomic_fetch_add_explicit(&destructor_counter, 1, memory_order_relaxed);
+    std::atomic_fetch_add_explicit(&destructor_counter, 1, std::memory_order_relaxed);
   }
 };
 
 int main(int argc, const char *argv[]) {
-  fprintf(stderr, "Hello world.\n");
+  std::fprintf(stderr, "Hello world.\n");
 
   dispatch_queue_t q = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
   dispatch_group_t g = dispatch_group_create();
 
   for (int i = 0; i < 100; i++) {
     std::shared_ptr<MyStruct> shared(new MyStruct());
 
     dispatch_group_async(g, q, ^{
       shared.get(); // just to make sure the object is captured by the block
     });
   }
 
   dispatch_group_wait(g, DISPATCH_TIME_FOREVER);
 
   if (destructor_counter != 100) {
-    abort();
+    std::abort();
   }
 
-  fprintf(stderr, "Done.\n");
+  std::fprintf(stderr, "Done.\n");
 }
 
 // CHECK: Hello world.
 // CHECK: Done.