[TSan][libdispatch] Port gcd-sync-block-copy.mm to C++

[yln]

Summary

Apparently, it makes a difference on where a block lives depending on if
it's passed "inline" versus assigned and then passed via a variable.
Both tests in this commit now give a signal, if Block_copy is used in
dispatch_sync.

Since these tests use different mechanisms (Objective-C retain versus
C++ copy constructor) as proxies to observe if the block was copied, we
should keep both of them.

Commit, that first avoided the unnecessary copy:
faef7d034a9ec6cb757137adce8e8670ec6c2d7b

[kubamracek]

compiler-rt/test/tsan/Darwin/gcd-sync-block-copy.mm

3–6 ↗

(On Diff #194974)

What is this change doing?

[yln]

compiler-rt/test/tsan/Darwin/gcd-sync-block-copy.mm

3–6 ↗

(On Diff #194974)

It's just changing to compile both binaries first, (instead of compile, check, compile, check) so that it is easier to debug/compare outputs in case the FileCheck fails. Also reformat line, so it's obvious that the only difference between those two line is -fno-sanitize=thread.

compiler-rt/trunk/test/tsan/Darwin/gcd-sync-block-copy.mm

 // This test verifies that dispatch_sync() doesn't actually copy the block under TSan (without TSan, it doesn't).
 
-// RUN: %clang_tsan -fno-sanitize=thread %s -o %t_no_tsan -framework Foundation
-// RUN: %run %t_no_tsan 2>&1 | FileCheck %s
-
+// RUN: %clang_tsan %s -o %t_no_tsan   -framework Foundation -fno-sanitize=thread
 // RUN: %clang_tsan %s -o %t_with_tsan -framework Foundation
+
+// RUN: %run %t_no_tsan   2>&1 | FileCheck %s
 // RUN: %run %t_with_tsan 2>&1 | FileCheck %s
 
 #import <Foundation/Foundation.h>
 
 @interface MyClass : NSObject
 @end
 
 @implementation MyClass
 - (instancetype)retain {
   // Copying the dispatch_sync'd block below will increment the retain count of
   // this object. Abort if that happens.
   abort();
 }
 @end
 
 int main(int argc, const char* argv[]) {
   dispatch_queue_t q = dispatch_queue_create("my.queue", NULL);
   id object = [[MyClass alloc] init];
+  void (^block)(void) = ^ {
+    NSLog(@"%@", object);
+  };
   dispatch_sync(q, ^{
     NSLog(@"%@", object);
   });
+  dispatch_sync(q, block);
   [object release];
   NSLog(@"Done.");
   return 0;
 }
 
 // CHECK: Done.
 // CHECK-NOT: WARNING: ThreadSanitizer

compiler-rt/trunk/test/tsan/libdispatch/sync-block-copy.cc

+// This test verifies that dispatch_sync() doesn't actually copy the block under TSan (without TSan, it doesn't).
+
+// RUN: %clangxx_tsan %s -o %t_no_tsan -fno-sanitize=thread
+// RUN: %clangxx_tsan %s -o %t_with_tsan
+
+// RUN: %run %t_no_tsan   2>&1 | FileCheck %s
+// RUN: %run %t_with_tsan 2>&1 | FileCheck %s --implicit-check-not='ThreadSanitizer'
+
+#include <dispatch/dispatch.h>
+
+#include <stdio.h>
+
+struct MyClass {
+  static int copyCount;
+  static void printCopyCount() {
+    fprintf(stderr, "copyCount = %d\n", copyCount);
+  }
+  MyClass(){};
+  MyClass(const MyClass &obj) { copyCount++; };
+  void foo() const {
+    fprintf(stderr, "MyClass::foo\n");
+  }
+};
+int MyClass::copyCount = 0;
+
+int main(int argc, const char* argv[]) {
+  dispatch_queue_t q = dispatch_queue_create("my.queue", NULL);
+  MyClass obj;
+  MyClass::printCopyCount();
+  void (^block)(void) = ^{
+    obj.foo();
+  };
+  MyClass::printCopyCount();
+  dispatch_sync(q, block);
+  MyClass::printCopyCount();
+
+  fprintf(stderr, "Done.\n");
+  return 0;
+}
+
+// CHECK: copyCount = 0
+// CHECK: copyCount = 1
+// CHECK: MyClass::foo
+// CHECK: copyCount = 1
+// CHECK: Done.