Make tsan tests more portable

[maxim-kuvyrkov]

Summary

... by avoiding potential races when scanning stdout and stderr output.

[maxim-kuvyrkov]

This patch improves sanitizer testsuite to avoid sporadic failures, especially when [cross-]testing on a remote machine.

There are several unstable sanitizer tests in LLVM testsuite (e.g., tsan/aligned_vs_unaligned_race.C), and the instability comes from the test doing this:

printf("Pass\n");
// CHECK: ThreadSanitizer: data race
// CHECK: Pass

. Thread sanitizer prints its data to stderr, and then printf prints to stdout. The testcase expects stderr to be flushed before stdout, and "Pass" to be at the end of the output. AFAIK, that works fine in native/local environment, but fails in remote testing from time to time. The failure case happens when stdout output is printed before stderr output. This is, likely, because there is no strict ordering of stdout and stderr when remote testing.

[rengolin]

there is no strict ordering of stdout and stderr when remote testing.

AFAIK, there is no strict ordering of stdout and stderr, period.

This is not a matter of flushing stdout, because there's still the concurrency issue between out and err. I believe this patch is correct, but I'll leave others more experienced in TSAN to approve.

cheers,
--renato

[dvyukov]

LGTM
Thanks for fixing this!

[maxim-kuvyrkov]

Renato, would you please commit this for me?

[rengolin]

Sure! Committed in r262476.

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");
+    printf(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