Make tsan tests more portable (take 2)

[maxim-kuvyrkov]

Summary

This is a re-submission of http://reviews.llvm.org/D17757, which was reverted, with a typo fixed. The only change is "printf (stderr,...)" -> "fprintf (stderr,...)" in longjmp2.cc.

[maxim-kuvyrkov]

Ping.

[dvyukov]

LGTM

[rengolin]

Closed by commit r266294.

test/tsan/Linux/user_malloc.cc

 // RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
 #include <stdio.h>
 
 // Defined by tsan.
 extern "C" void *__interceptor_malloc(unsigned long size);
 extern "C" void __interceptor_free(void *p);
 
 extern "C" void *malloc(unsigned long size) {
   static int first = 0;
   if (__sync_lock_test_and_set(&first, 1) == 0)
-    printf("user malloc\n");
+    fprintf(stderr, "user malloc\n");
   return __interceptor_malloc(size);
 }
 
 extern "C" void free(void *p) {
   __interceptor_free(p);
 }
 
 int main() {
   volatile char *p = (char*)malloc(10);
   p[0] = 0;
   free((void*)p);
 }
 
 // CHECK: user malloc
 // CHECK-NOT: ThreadSanitizer
 

test/tsan/aligned_vs_unaligned_race.cc

 
 int main() {
   barrier_init(&barrier, 2);
   pthread_t t[2];
   pthread_create(&t[0], NULL, Thread1, NULL);
   pthread_create(&t[1], NULL, Thread2, NULL);
   pthread_join(t[0], NULL);
   pthread_join(t[1], NULL);
-  printf("Pass\n");
+  fprintf(stderr, "Pass\n");
   // CHECK: ThreadSanitizer: data race
   // CHECK: Pass
   return 0;
 }

test/tsan/benign_race.cc

WTFAnnotateBenignRaceSized(__FILE__, __LINE__,
                              &WTFGlobal, sizeof(WTFGlobal),
                              "Race on WTFGlobal");
   pthread_t t;
   pthread_create(&t, 0, Thread, 0);
   barrier_wait(&barrier);
   Global = 43;
   WTFGlobal = 143;
   pthread_join(t, 0);
-  printf("OK\n");
+  fprintf(stderr, "OK\n");
 }
 
 // CHECK-NOT: WARNING: ThreadSanitizer: data race

test/tsan/blacklist.cc

 }
 
 int main() {
   pthread_t t[2];
   pthread_create(&t[0], NULL, Thread1, NULL);
   pthread_create(&t[1], NULL, Blacklisted_Thread2, NULL);
   pthread_join(t[0], NULL);
   pthread_join(t[1], NULL);
-  printf("PASS\n");
+  fprintf(stderr, "PASS\n");
   return 0;
 }
 
 // CHECK-NOT: ThreadSanitizer: data race

test/tsan/blacklist2.cc

 
 int main() {
   barrier_init(&barrier, 2);
   pthread_t t[2];
   pthread_create(&t[0], NULL, Thread1, NULL);
   pthread_create(&t[1], NULL, Blacklisted_Thread2, NULL);
   pthread_join(t[0], NULL);
   pthread_join(t[1], NULL);
-  printf("PASS\n");
+  fprintf(stderr, "PASS\n");
   return 0;
 }

test/tsan/dl_iterate_phdr.cc

for (int i = 0; i < 1000; i++) {
     void *lib = dlopen(path.c_str(), RTLD_NOW);
     if (!lib) {
       printf("error in dlopen: %s\n", dlerror());
       return 1;
     }
     dlclose(lib);
   }
   pthread_join(th, 0);
-  printf("DONE\n");
+  fprintf(stderr, "DONE\n");
   return 0;
 }
 
 #endif  // BUILD_SO
 
 // CHECK-NOT: WARNING: ThreadSanitizer: data race
 // CHECK: DONE

test/tsan/fd_close_norace.cc

 
 int main() {
   barrier_init(&barrier, 2);
   pthread_t t[2];
   pthread_create(&t[0], NULL, Thread1, NULL);
   pthread_create(&t[1], NULL, Thread2, NULL);
   pthread_join(t[0], NULL);
   pthread_join(t[1], NULL);
-  printf("OK\n");
+  fprintf(stderr, "OK\n");
 }
 
 // CHECK-NOT: WARNING: ThreadSanitizer: data race
 
 

test/tsan/fd_close_norace2.cc

int main() {
   if (pipe(pipes))
     return 1;
   pthread_t t;
   pthread_create(&t, 0, Thread, 0);
   // send shutdown signal
   while (write(pipes[1], &t, 1) != 1) {
   }
   pthread_join(t, 0);
-  printf("OK\n");
+  fprintf(stderr, "OK\n");
 }
 
 // CHECK-NOT: WARNING: ThreadSanitizer: data race
 // CHECK: OK

test/tsan/fd_dup_norace.cc

 int main() {
   fds[0] = open("/dev/random", O_RDONLY);
   fds[1] = dup2(fds[0], 100);
   pthread_t t[2];
   pthread_create(&t[0], NULL, Thread1, NULL);
   pthread_create(&t[1], NULL, Thread2, NULL);
   pthread_join(t[0], NULL);
   pthread_join(t[1], NULL);
-  printf("OK\n");
+  fprintf(stderr, "OK\n");
 }
 
 // CHECK-NOT: WARNING: ThreadSanitizer: data race

test/tsan/fd_dup_norace2.cc

int main() {
   pthread_create(&th, 0, Thread, 0);
   if (dup2(fd2, fd) == -1)
     exit(printf("dup2 failed\n"));
   pthread_join(th, 0);
   if (close(fd) == -1)
     exit(printf("close failed\n"));
   if (close(fd2) == -1)
     exit(printf("close failed\n"));
-  printf("DONE\n");
+  fprintf(stderr, "DONE\n");
 }
 
 // CHECK-NOT: WARNING: ThreadSanitizer: data race
 // CHECK: DONE

test/tsan/fd_dup_race.cc

int main() {
   if (fd == -1 || fd2 == -1)
     exit(printf("open failed\n"));
   pthread_t th;
   pthread_create(&th, 0, Thread, 0);
   if (dup2(fd2, fd) == -1)
     exit(printf("dup2 failed\n"));
   barrier_wait(&barrier);
   pthread_join(th, 0);
-  printf("DONE\n");
+  fprintf(stderr, "DONE\n");
 }
 
 // CHECK: WARNING: ThreadSanitizer: data race

test/tsan/fd_pipe_norace.cc

 
 int main() {
   pipe(fds);
   pthread_t t[2];
   pthread_create(&t[0], NULL, Thread1, NULL);
   pthread_create(&t[1], NULL, Thread2, NULL);
   pthread_join(t[0], NULL);
   pthread_join(t[1], NULL);
-  printf("OK\n");
+  fprintf(stderr, "OK\n");
 }
 
 // CHECK-NOT: WARNING: ThreadSanitizer: data race

test/tsan/fd_socket_connect_norace.cc

int main() {
   listen(s, 10);
   pthread_t t;
   pthread_create(&t, 0, ClientThread, 0);
   int c = accept(s, 0, 0);
   X = 42;
   pthread_join(t, 0);
   close(c);
   close(s);
-  printf("OK\n");
+  fprintf(stderr, "OK\n");
 }
 
 // CHECK-NOT: WARNING: ThreadSanitizer: data race
 

test/tsan/fd_socket_norace.cc

int main() {
   int c = accept(s, 0, 0);
   char buf;
   while (read(c, &buf, 1) != 1) {
   }
   X = 43;
   close(c);
   close(s);
   pthread_join(t, 0);
-  printf("OK\n");
+  fprintf(stderr, "OK\n");
 }
 
 // CHECK-NOT: WARNING: ThreadSanitizer: data race
 

test/tsan/fd_socketpair_norace.cc

 
 int main() {
   socketpair(AF_UNIX, SOCK_STREAM, 0, fds);
   pthread_t t[2];
   pthread_create(&t[0], NULL, Thread1, NULL);
   pthread_create(&t[1], NULL, Thread2, NULL);
   pthread_join(t[0], NULL);
   pthread_join(t[1], NULL);
-  printf("OK\n");
+  fprintf(stderr, "OK\n");
 }
 
 // CHECK-NOT: WARNING: ThreadSanitizer: data race

test/tsan/ignore_race.cc

 
 int main() {
   barrier_init(&barrier, 2);
   pthread_t t;
   pthread_create(&t, 0, Thread, 0);
   barrier_wait(&barrier);
   Global = 43;
   pthread_join(t, 0);
-  printf("OK\n");
+  fprintf(stderr, "OK\n");
 }
 
 // CHECK-NOT: WARNING: ThreadSanitizer: data race

test/tsan/inlined_memcpy_race.cc

 int main() {
   barrier_init(&barrier, 2);
   pthread_t t[2];
   // Race on x between memcpy and memset
   pthread_create(&t[0], NULL, MemCpyThread, x);
   pthread_create(&t[1], NULL, MemSetThread, x);
   pthread_join(t[0], NULL);
   pthread_join(t[1], NULL);
-  printf("PASS\n");
+  fprintf(stderr, "PASS\n");
   return 0;
 }
 
 // CHECK: WARNING: ThreadSanitizer: data race
 // CHECK:   #0 memset
 // CHECK:   #1 MemSetThread
 // CHECK:  Previous write
 // CHECK:   #0 {{(memcpy|memmove)}}
 // CHECK:   #1 MemCpyThread
 

test/tsan/inlined_memcpy_race2.cc

int main() {
   barrier_init(&barrier, 2);
   pthread_t t[2];
   // Race on y between memmove and memset
   pthread_create(&t[0], NULL, MemMoveThread, y);
   pthread_create(&t[1], NULL, MemSetThread, y);
   pthread_join(t[0], NULL);
   pthread_join(t[1], NULL);
 
-  printf("PASS\n");
+  fprintf(stderr, "PASS\n");
   return 0;
 }
 
 // CHECK: WARNING: ThreadSanitizer: data race
 // CHECK:   #0 memset
 // CHECK:   #1 MemSetThread
 // CHECK:  Previous write
 // CHECK:   #0 memmove
 // CHECK:   #1 MemMoveThread

test/tsan/interface_atomic_test.c

 // Test that we can include header with TSan atomic interface.
 // RUN: %clang_tsan %s -o %t && %run %t | FileCheck %s
 #include <sanitizer/tsan_interface_atomic.h>
 #include <stdio.h>
 
 int main() {
   __tsan_atomic32 a;
   __tsan_atomic32_store(&a, 100, __tsan_memory_order_release);
   int res = __tsan_atomic32_load(&a, __tsan_memory_order_acquire);
   if (res == 100) {
     // CHECK: PASS
-    printf("PASS\n");
+    fprintf(stderr, "PASS\n");
     return 0;
   }
   return 1;
 }

test/tsan/java_alloc.cc

 int main() {
   jptr jheap = (jptr)malloc(kHeapSize + 8) + 8;
   __tsan_java_init(jheap, kHeapSize);
   pthread_t th;
   pthread_create(&th, 0, Thread, (void*)(jheap + kHeapSize / 4));
   stress(jheap);
   pthread_join(th, 0);
   if (__tsan_java_fini() != 0) {
-    printf("FAILED\n");
+    fprintf(stderr, "FAILED\n");
     return 1;
   }
-  printf("DONE\n");
+  fprintf(stderr, "DONE\n");
   return 0;
 }
 
 // CHECK-NOT: WARNING: ThreadSanitizer: data race
 // CHECK-NOT: FAILED
 // CHECK: DONE

test/tsan/java_heap_init.cc

int main() {
   __atomic_store_n((int*)jheap, 1, __ATOMIC_RELEASE);
   munmap((void*)jheap, kHeapSize);
   jheap = (jptr)mmap((void*)jheap, kHeapSize, PROT_READ | PROT_WRITE,
       MAP_ANON | MAP_PRIVATE, -1, 0);
   if (jheap == (jptr)MAP_FAILED)
     return printf("second mmap failed with %d\n", errno);
   __tsan_java_init(jheap, kHeapSize);
   __tsan_java_move(jheap + 16, jheap, 16);
-  printf("DONE\n");
+  fprintf(stderr, "DONE\n");
   return __tsan_java_fini();
 }
 
 // CHECK-NOT: WARNING: ThreadSanitizer: data race
 // CHECK: DONE

test/tsan/java_lock_move.cc

int main() {
   pthread_create(&th, 0, Thread, 0);
   __tsan_java_mutex_lock(lockaddr);
   *(int*)varaddr = 43;
   __tsan_java_mutex_unlock(lockaddr);
   __tsan_java_move(varaddr, varaddr2, kBlockSize);
   barrier_wait(&barrier);
   pthread_join(th, 0);
   __tsan_java_free(varaddr2, kBlockSize);
-  printf("DONE\n");
+  fprintf(stderr, "DONE\n");
   return __tsan_java_fini();
 }
 
 // CHECK-NOT: WARNING: ThreadSanitizer: data race
 // CHECK: DONE

test/tsan/java_lock_rec.cc

 // RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
 #include "java.h"
 
 jptr varaddr;
 jptr lockaddr;
 
 void *Thread(void *p) {
   __tsan_java_mutex_lock(lockaddr);
   __tsan_java_mutex_lock(lockaddr);
   *(int*)varaddr = 42;
   int rec = __tsan_java_mutex_unlock_rec(lockaddr);
   if (rec != 2) {
-    printf("FAILED 0 rec=%d\n", rec);
+    fprintf(stderr, "FAILED 0 rec=%d\n", rec);
     exit(1);
   }
   barrier_wait(&barrier);
   barrier_wait(&barrier);
   __tsan_java_mutex_lock_rec(lockaddr, rec);
   if (*(int*)varaddr != 43) {
-    printf("FAILED 3 var=%d\n", *(int*)varaddr);
+    fprintf(stderr, "FAILED 3 var=%d\n", *(int*)varaddr);
     exit(1);
   }
   __tsan_java_mutex_unlock(lockaddr);
   __tsan_java_mutex_unlock(lockaddr);
   return 0;
 }
 
 int main() {
   barrier_init(&barrier, 2);
   int const kHeapSize = 1024 * 1024;
   jptr jheap = (jptr)malloc(kHeapSize + 8) + 8;
   __tsan_java_init(jheap, kHeapSize);
   const int kBlockSize = 16;
   __tsan_java_alloc(jheap, kBlockSize);
   varaddr = jheap;
   *(int*)varaddr = 0;
   lockaddr = jheap + 8;
   pthread_t th;
   pthread_create(&th, 0, Thread, 0);
   barrier_wait(&barrier);
   __tsan_java_mutex_lock(lockaddr);
   if (*(int*)varaddr != 42) {
-    printf("FAILED 1 var=%d\n", *(int*)varaddr);
+    fprintf(stderr, "FAILED 1 var=%d\n", *(int*)varaddr);
     exit(1);
   }
   *(int*)varaddr = 43;
   __tsan_java_mutex_unlock(lockaddr);
   barrier_wait(&barrier);
   pthread_join(th, 0);
   __tsan_java_free(jheap, kBlockSize);
-  printf("DONE\n");
+  fprintf(stderr, "DONE\n");
   return __tsan_java_fini();
 }
 
 // CHECK-NOT: WARNING: ThreadSanitizer: data race
 // CHECK-NOT: FAILED
 // CHECK: DONE

test/tsan/java_lock_rec_race.cc

 // RUN: %clangxx_tsan -O1 %s -o %t && %deflake %run %t | FileCheck %s
 #include "java.h"
 
 jptr varaddr;
 jptr lockaddr;
 
 void *Thread(void *p) {
   __tsan_java_mutex_lock(lockaddr);
   __tsan_java_mutex_lock(lockaddr);
   __tsan_java_mutex_lock(lockaddr);
   int rec = __tsan_java_mutex_unlock_rec(lockaddr);
   if (rec != 3) {
-    printf("FAILED 0 rec=%d\n", rec);
+    fprintf(stderr, "FAILED 0 rec=%d\n", rec);
     exit(1);
   }
   *(int*)varaddr = 42;
   barrier_wait(&barrier);
   barrier_wait(&barrier);
   __tsan_java_mutex_lock_rec(lockaddr, rec);
   __tsan_java_mutex_unlock(lockaddr);
   __tsan_java_mutex_unlock(lockaddr);
int main() {
   pthread_create(&th, 0, Thread, 0);
   barrier_wait(&barrier);
   __tsan_java_mutex_lock(lockaddr);
   *(int*)varaddr = 43;
   __tsan_java_mutex_unlock(lockaddr);
   barrier_wait(&barrier);
   pthread_join(th, 0);
   __tsan_java_free(jheap, kBlockSize);
-  printf("DONE\n");
+  fprintf(stderr, "DONE\n");
   return __tsan_java_fini();
 }
 
 // CHECK: WARNING: ThreadSanitizer: data race
 // CHECK-NOT: FAILED
 // CHECK: DONE

test/tsan/java_move_overlap.cc

int main(int argc, char **argv) {
   __tsan_java_mutex_lock(lockaddr2_old);
   *(char*)varaddr2_old = 43;
   __tsan_java_mutex_unlock(lockaddr2_old);
 
   __tsan_java_move(varaddr1_old, varaddr1_new, kBlockSize);
   barrier_wait(&barrier);
   pthread_join(th, 0);
   __tsan_java_free(varaddr1_new, kBlockSize);
-  printf("DONE\n");
+  fprintf(stderr, "DONE\n");
   return __tsan_java_fini();
 }
 
 // CHECK-NOT: WARNING: ThreadSanitizer: data race
 // CHECK: DONE

test/tsan/java_move_overlap_race.cc

int main(int argc, char **argv) {
 
   *(int*)varaddr1_old = 43;
   *(int*)varaddr2_old = 43;
 
   __tsan_java_move(varaddr1_old, varaddr1_new, kBlockSize);
   barrier_wait(&barrier);
   pthread_join(th, 0);
   __tsan_java_free(varaddr1_new, kBlockSize);
-  printf("DONE\n");
+  fprintf(stderr, "DONE\n");
   return __tsan_java_fini();
 }
 
 // CHECK: WARNING: ThreadSanitizer: data race
 // CHECK: WARNING: ThreadSanitizer: data race
 // CHECK: DONE

test/tsan/java_rwlock.cc

int main() {
   pthread_t th;
   pthread_create(&th, 0, Thread, 0);
   __tsan_java_mutex_lock(lockaddr);
   *(int*)varaddr = 43;
   __tsan_java_mutex_unlock(lockaddr);
   barrier_wait(&barrier);
   pthread_join(th, 0);
   __tsan_java_free(jheap, kBlockSize);
-  printf("DONE\n");
+  fprintf(stderr, "DONE\n");
   return __tsan_java_fini();
 }
 
 // CHECK-NOT: WARNING: ThreadSanitizer: data race
 // CHECK: DONE

test/tsan/longjmp.cc

 // RUN: %clang_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
 
 // Longjmp assembly has not been implemented for mips64 yet
 // XFAIL: mips64
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <setjmp.h>
 
 int foo(jmp_buf env) {
   longjmp(env, 42);
 }
 
 int main() {
   jmp_buf env;
   if (setjmp(env) == 42) {
-    printf("JUMPED\n");
+    fprintf(stderr, "JUMPED\n");
     return 0;
   }
   foo(env);
-  printf("FAILED\n");
+  fprintf(stderr, "FAILED\n");
   return 0;
 }
 
 // CHECK-NOT: FAILED
 // CHECK: JUMPED

test/tsan/longjmp2.cc

int foo(sigjmp_buf env) {
   printf("env=%p\n", env);
   siglongjmp(env, 42);
 }
 
 int main() {
   sigjmp_buf env;
   printf("env=%p\n", env);
   if (sigsetjmp(env, 1) == 42) {
-    printf("JUMPED\n");
+    fprintf(stderr, "JUMPED\n");
     return 0;
   }
   foo(env);
-  printf("FAILED\n");
+  fprintf(stderr, "FAILED\n");
   return 0;
 }
 
 // CHECK-NOT: FAILED
 // CHECK: JUMPED

test/tsan/longjmp3.cc

 
 void mymain() {
   jmp_buf env;
   if (setjmp(env) == 42) {
     badguy();
     return;
   }
   foo(env);
-  printf("FAILED\n");
+  fprintf(stderr, "FAILED\n");
 }
 
 int main() {
   volatile int x = 42;
   mymain();
   return x;
 }
 
 // CHECK-NOT: FAILED
 // CHECK: WARNING: ThreadSanitizer: destroy of a locked mutex
 // CHECK:   #0 pthread_mutex_destroy
 // CHECK:   #1 badguy
 // CHECK:   #2 mymain
 // CHECK:   #3 main
 

test/tsan/longjmp4.cc

 
 void mymain() {
   jmp_buf env;
   if (setjmp(env) == 42) {
     badguy();
     return;
   }
   foo(env);
-  printf("FAILED\n");
+  fprintf(stderr, "FAILED\n");
 }
 
 int main() {
   volatile int x = 42;
   mymain();
   return x;
 }
 
 // CHECK-NOT: FAILED
 // CHECK: WARNING: ThreadSanitizer: destroy of a locked mutex
 // CHECK:   #0 pthread_mutex_destroy
 // CHECK:   #1 badguy
 // CHECK:   #2 mymain
 // CHECK:   #3 main
 

test/tsan/malloc_overflow.cc

 // RUN: %clangxx_tsan -O1 %s -o %t
 // RUN: %env_tsan_opts=allocator_may_return_null=1 %run %t 2>&1 | FileCheck %s
 #include <stdio.h>
 #include <stdlib.h>
 
 int main() {
   void *p = malloc((size_t)-1);
   if (p != 0)
-    printf("FAIL malloc(-1) = %p\n", p);
+    fprintf(stderr, "FAIL malloc(-1) = %p\n", p);
   p = malloc((size_t)-1 / 2);
   if (p != 0)
-    printf("FAIL malloc(-1/2) = %p\n", p);
+    fprintf(stderr, "FAIL malloc(-1/2) = %p\n", p);
   p = calloc((size_t)-1, (size_t)-1);
   if (p != 0)
-    printf("FAIL calloc(-1, -1) = %p\n", p);
+    fprintf(stderr, "FAIL calloc(-1, -1) = %p\n", p);
   p = calloc((size_t)-1 / 2, (size_t)-1 / 2);
   if (p != 0)
-    printf("FAIL calloc(-1/2, -1/2) = %p\n", p);
-  printf("OK\n");
+    fprintf(stderr, "FAIL calloc(-1/2, -1/2) = %p\n", p);
+  fprintf(stderr, "OK\n");
 }
 
 // CHECK-NOT: FAIL
 // CHECK-NOT: failed to allocate

test/tsan/race_on_speculative_load.cc

 
 int main() {
   barrier_init(&barrier, 2);
   pthread_t t;
   pthread_create(&t, 0, Thread1, 0);
   g = 1;
   barrier_wait(&barrier);
   pthread_join(t, 0);
-  printf("PASS\n");
+  fprintf(stderr, "PASS\n");
   // CHECK-NOT: ThreadSanitizer: data race
   // CHECK: PASS
 }

test/tsan/static_init1.cc

 }
 
 int main() {
   pthread_t t[2];
   pthread_create(&t[0], 0, Thread, 0);
   pthread_create(&t[1], 0, Thread, 0);
   pthread_join(t[0], 0);
   pthread_join(t[1], 0);
-  printf("PASS\n");
+  fprintf(stderr, "PASS\n");
 }
 
 // CHECK-NOT: WARNING: ThreadSanitizer: data race

test/tsan/static_init2.cc

 }
 
 int main() {
   pthread_t t[2];
   pthread_create(&t[0], 0, Thread, 0);
   pthread_create(&t[1], 0, Thread, 0);
   pthread_join(t[0], 0);
   pthread_join(t[1], 0);
-  printf("PASS\n");
+  fprintf(stderr, "PASS\n");
 }
 
 // CHECK-NOT: WARNING: ThreadSanitizer: data race

test/tsan/static_init4.cc

 }
 
 int main() {
   pthread_t t[2];
   pthread_create(&t[0], 0, Thread1, 0);
   pthread_create(&t[1], 0, Thread1, 0);
   pthread_join(t[0], 0);
   pthread_join(t[1], 0);
-  printf("PASS\n");
+  fprintf(stderr, "PASS\n");
 }
 
 // CHECK-NOT: WARNING: ThreadSanitizer: data race

test/tsan/static_init5.cc

 }
 
 int main() {
   pthread_t t[2];
   pthread_create(&t[0], 0, Thread1, 0);
   pthread_create(&t[1], 0, Thread1, 0);
   pthread_join(t[0], 0);
   pthread_join(t[1], 0);
-  printf("PASS\n");
+  fprintf(stderr, "PASS\n");
 }
 
 // CHECK-NOT: WARNING: ThreadSanitizer: data race

test/tsan/static_init6.cc

 }
 
 int main() {
   pthread_t t[2];
   pthread_create(&t[0], 0, Thread1, 0);
   pthread_create(&t[1], 0, Thread1, 0);
   pthread_join(t[0], 0);
   pthread_join(t[1], 0);
-  printf("PASS\n");
+  fprintf(stderr, "PASS\n");
 }
 
 // CHECK-NOT: WARNING: ThreadSanitizer: data race

test/tsan/sunrpc.cc

 }
 
 int main(int argc, char *argv[]) {
   pthread_t th[2];
   pthread_create(&th[0], 0, thr, 0);
   pthread_create(&th[1], 0, thr, 0);
   pthread_join(th[0], 0);
   pthread_join(th[1], 0);
-  printf("DONE\n");
+  fprintf(stderr, "DONE\n");
   // CHECK: DONE
   return 0;
 }

test/tsan/suppressions_global.cc

 }
 
 int main() {
   pthread_t t[2];
   pthread_create(&t[0], NULL, Thread1, NULL);
   pthread_create(&t[1], NULL, Thread2, NULL);
   pthread_join(t[0], NULL);
   pthread_join(t[1], NULL);
-  printf("OK\n");
+  fprintf(stderr, "OK\n");
   return 0;
 }
 
 // CHECK-NOT: failed to open suppressions file
 // CHECK-NOT: WARNING: ThreadSanitizer: data race
 

test/tsan/suppressions_race.cc

 
 int main() {
   barrier_init(&barrier, 2);
   pthread_t t[2];
   pthread_create(&t[0], NULL, Thread1, NULL);
   pthread_create(&t[1], NULL, Thread2, NULL);
   pthread_join(t[0], NULL);
   pthread_join(t[1], NULL);
-  printf("OK\n");
+  fprintf(stderr, "OK\n");
   return 0;
 }
 
 // CHECK-NOT: failed to open suppressions file
 // CHECK-NOT: WARNING: ThreadSanitizer: data race
 

test/tsan/suppressions_race2.cc

 
 int main() {
   barrier_init(&barrier, 2);
   pthread_t t[2];
   pthread_create(&t[0], NULL, Thread1, NULL);
   pthread_create(&t[1], NULL, Thread2, NULL);
   pthread_join(t[0], NULL);
   pthread_join(t[1], NULL);
-  printf("OK\n");
+  fprintf(stderr, "OK\n");
   return 0;
 }
 
 // CHECK-NOT: failed to open suppressions file
 // CHECK-NOT: WARNING: ThreadSanitizer: data race
 

test/tsan/thread_detach.c

 // RUN: %clang_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
 #include "test.h"
 
 void *Thread(void *x) {
   barrier_wait(&barrier);
   return 0;
 }
 
 int main() {
   barrier_init(&barrier, 2);
   pthread_t t;
   pthread_create(&t, 0, Thread, 0);
   barrier_wait(&barrier);
   pthread_detach(t);
-  printf("PASS\n");
+  fprintf(stderr, "PASS\n");
   return 0;
 }
 
 // CHECK-NOT: WARNING: ThreadSanitizer: thread leak
 // CHECK: PASS

test/tsan/thread_detach2.c

 
 int main() {
   barrier_init(&barrier, 2);
   pthread_t t;
   x = 43;
   pthread_create(&t, 0, Thread, 0);
   pthread_detach(t);
   barrier_wait(&barrier);
-  printf("PASS\n");
+  fprintf(stderr, "PASS\n");
   return 0;
 }
 
 // CHECK-NOT: WARNING: ThreadSanitizer: data race
 // CHECK: PASS

test/tsan/thread_leak.c

 // RUN: %clang_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
 #include <pthread.h>
 #include <stdio.h>
 
 void *Thread(void *x) {
   return 0;
 }
 
 int main() {
   pthread_t t;
   pthread_create(&t, 0, Thread, 0);
   pthread_join(t, 0);
-  printf("PASS\n");
+  fprintf(stderr, "PASS\n");
   return 0;
 }
 
 // CHECK-NOT: WARNING: ThreadSanitizer: thread leak

test/tsan/thread_leak2.c

 // RUN: %clang_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
 #include <pthread.h>
 #include <stdio.h>
 
 void *Thread(void *x) {
   return 0;
 }
 
 int main() {
   pthread_t t;
   pthread_create(&t, 0, Thread, 0);
   pthread_detach(t);
-  printf("PASS\n");
+  fprintf(stderr, "PASS\n");
   return 0;
 }
 
 // CHECK-NOT: WARNING: ThreadSanitizer: thread leak

test/tsan/thread_leak4.c

 // RUN: %clang_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
 #include "test.h"
 
 void *Thread(void *x) {
   sleep(100);  // leave the thread "running"
   return 0;
 }
 
 int main() {
   pthread_t t;
   pthread_create(&t, 0, Thread, 0);
-  printf("DONE\n");
+  fprintf(stderr, "DONE\n");
   return 0;
 }
 
 // CHECK: DONE
 // CHECK-NOT: WARNING: ThreadSanitizer: thread leak
 

test/tsan/tsan-vs-gvn.cc

 
 int main() {
   pthread_t t[2];
   memset(&S, 123, sizeof(S));
   pthread_create(&t[0], NULL, Thread1, NULL);
   pthread_create(&t[1], NULL, Thread2, NULL);
   pthread_join(t[0], NULL);
   pthread_join(t[1], NULL);
-  printf("PASS\n");
+  fprintf(stderr, "PASS\n");
 }
 
 // CHECK-NOT: WARNING: ThreadSanitizer: data race
 // CHECK: PASS

test/tsan/unaligned_norace.cc

void *Thread(void *p) {
   return 0;
 }
 
 int main() {
   pthread_t th;
   pthread_create(&th, 0, Thread, 0);
   Test(true);
   pthread_join(th, 0);
-  printf("OK\n");
+  fprintf(stderr, "OK\n");
 }
 
 // CHECK-NOT: WARNING: ThreadSanitizer:
 // CHECK: OK

test/tsan/vfork.cc

void *Thread2(void *x) {
   X = 43;
   return NULL;
 }
 
 int main() {
   pipe(fds);
   int pid = vfork();
   if (pid < 0) {
-    printf("FAIL to vfork\n");
+    fprintf(stderr, "FAIL to vfork\n");
     exit(1);
   }
   if (pid == 0) {  // child
     // Closing of fds must not affect parent process.
     // Strictly saying this is undefined behavior, because vfork child is not
     // allowed to call any functions other than exec/exit. But this is what
     // openjdk does.
     close(fds[0]);
     close(fds[1]);
     _exit(0);
   }
   pthread_t t[2];
   pthread_create(&t[0], NULL, Thread1, NULL);
   pthread_create(&t[1], NULL, Thread2, NULL);
   pthread_join(t[0], NULL);
   pthread_join(t[1], NULL);
-  printf("DONE\n");
+  fprintf(stderr, "DONE\n");
 }
 
 // CHECK-NOT: WARNING: ThreadSanitizer: data race
 // CHECK-NOT: FAIL to vfork
 // CHECK: DONE

test/tsan/virtual_inheritance_compile_bug.cc

 // Regression test for https://github.com/google/sanitizers/issues/410.
 // The C++ variant is much more compact that the LLVM IR equivalent.
 
 // RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
 #include <stdio.h>
 struct AAA              {  virtual long aaa () { return 0; } };  // NOLINT
 struct BBB: virtual AAA { unsigned long bbb; };  // NOLINT
 struct CCC: virtual AAA { };
 struct DDD: CCC, BBB { DDD(); };  // NOLINT
 DDD::DDD()  { }
 int main() {
   DDD d;
-  printf("OK\n");
+  fprintf(stderr, "OK\n");
 }
 // CHECK: OK