[tsan] Fix interceptor names in lit tests for OS X

[kubamracek]

Summary

On OS X, the interceptors' function names start with "wrap_", e.g. wrap_malloc. This patch modifies the lit tests that expect to find an intercepted function's name on a stack trace to allow having a prefix.

[dvyukov]

Fix call of RenderFrame in PrintStack in tsan_report.cc instead.

Originally, that code stripped prefixes of functions defined in tsan_interceptors.cc only. That logic seems to get lost at some point. So now we will strip interceptor_/wrap_ from all functions (including user ones). If that becomes a problem, we need to fix the stripping logic.

[kubamracek]

Closing this revision, http://reviews.llvm.org/D14512 supersedes this.

[glider]

Not that this makes any difference now, but I think there should be no user functions starting with two underscores (and thus no functions starting with wrap or intercept)

[kubamracek]

In D14431#287949, @glider wrote:

Not that this makes any difference now, but I think there should be no user functions starting with two underscores (and thus no functions starting with wrap or intercept)

Just FYI, the OS X wrap_ prefix doesn't have the two underscores.

[glider]

Ah, that's right. Then Dima's comment is valid, and mine is not.

test/tsan/fd_location.cc

int main() {
   pthread_create(&t[0], NULL, Thread1, NULL);
   pthread_create(&t[1], NULL, Thread2, NULL);
   pthread_join(t[0], NULL);
   pthread_join(t[1], NULL);
 }
 
 // CHECK: WARNING: ThreadSanitizer: data race
 // CHECK:   Location is file descriptor {{[0-9]+}} created by main thread at:
-// CHECK:     #0 pipe
+// CHECK:     #0 {{.*pipe}}
 // CHECK:     #1 main
 

test/tsan/fd_pipe_race.cc

int main() {
   pthread_create(&t[0], NULL, Thread1, NULL);
   pthread_create(&t[1], NULL, Thread2, NULL);
   pthread_join(t[0], NULL);
   pthread_join(t[1], NULL);
 }
 
 // CHECK: WARNING: ThreadSanitizer: data race
 // CHECK:   Write of size 8
-// CHECK:     #0 close
+// CHECK:     #0 {{.*close}}
 // CHECK:     #1 Thread2
 // CHECK:   Previous read of size 8
-// CHECK:     #0 write
+// CHECK:     #0 {{.*write}}
 // CHECK:     #1 Thread1
 
 

test/tsan/free_race.c

int main() {
   return 0;
 }
 
 // CHECK-NOZUPP: WARNING: ThreadSanitizer: heap-use-after-free
 // CHECK-NOZUPP:   Write of size 4 at {{.*}} by main thread{{.*}}:
 // CHECK-NOZUPP:     #0 Thread2
 // CHECK-NOZUPP:     #1 main
 // CHECK-NOZUPP:   Previous write of size 8 at {{.*}} by thread T1{{.*}}:
-// CHECK-NOZUPP:     #0 free
+// CHECK-NOZUPP:     #0 {{.*free}}
 // CHECK-NOZUPP:     #{{(1|2)}} Thread1
 // CHECK-NOZUPP: SUMMARY: ThreadSanitizer: heap-use-after-free{{.*}}Thread2
 // CHECK-SUPP:   ThreadSanitizer: Matched 1 suppressions
 // CHECK-SUPP:    1 race:^Thread2$

test/tsan/free_race2.c

int main() {
   return 0;
 }
 
 // CHECK: WARNING: ThreadSanitizer: heap-use-after-free
 // CHECK:   Write of size 4 at {{.*}} by main thread:
 // CHECK:     #0 bar
 // CHECK:     #1 main
 // CHECK:   Previous write of size 8 at {{.*}} by main thread:
-// CHECK:     #0 free
+// CHECK:     #0 {{.*free}}
 // CHECK:     #{{1|2}} foo
 // CHECK:     #{{2|3}} main

test/tsan/inlined_memcpy_race.cc

int main() {
   pthread_create(&t[1], NULL, MemSetThread, x);
   pthread_join(t[0], NULL);
   pthread_join(t[1], NULL);
   printf("PASS\n");
   return 0;
 }
 
 // CHECK: WARNING: ThreadSanitizer: data race
-// CHECK:   #0 memset
+// CHECK:   #0 {{.*memset}}
 // CHECK:   #1 MemSetThread
 // CHECK:  Previous write
-// CHECK:   #0 memcpy
+// CHECK:   #0 {{.*memcpy}}
 // CHECK:   #1 MemCpyThread
 

test/tsan/inlined_memcpy_race2.cc

int main() {
   pthread_join(t[0], NULL);
   pthread_join(t[1], NULL);
 
   printf("PASS\n");
   return 0;
 }
 
 // CHECK: WARNING: ThreadSanitizer: data race
-// CHECK:   #0 memset
+// CHECK:   #0 {{.*memset}}
 // CHECK:   #1 MemSetThread
 // CHECK:  Previous write
-// CHECK:   #0 memmove
+// CHECK:   #0 {{.*memmove}}
 // CHECK:   #1 MemMoveThread

test/tsan/memcmp_race.cc

int main() {
   pthread_join(t[0], NULL);
   pthread_join(t[1], NULL);
   return 0;
 }
 
 // CHECK: addr=[[ADDR:0x[0-9,a-f]+]]
 // CHECK: WARNING: ThreadSanitizer: data race
 // CHECK:   Write of size 1 at [[ADDR]] by thread T2:
-// CHECK:     #0 memcpy
+// CHECK:     #0 {{.*memcpy}}
 // CHECK:     #1 Thread2
 // CHECK:   Previous read of size 1 at [[ADDR]] by thread T1:
-// CHECK:     #0 memcmp
+// CHECK:     #0 {{.*memcmp}}
 // CHECK:     #1 Thread1

test/tsan/memcpy_race.cc

int main() {
   pthread_join(t[0], NULL);
   pthread_join(t[1], NULL);
   return 0;
 }
 
 // CHECK: addr=[[ADDR:0x[0-9,a-f]+]]
 // CHECK: WARNING: ThreadSanitizer: data race
 // CHECK:   Write of size 1 at [[ADDR]] by thread T2:
-// CHECK:     #0 memcpy
+// CHECK:     #0 {{.*memcpy}}
 // CHECK:     #1 Thread2
 // CHECK:   Previous write of size 1 at [[ADDR]] by thread T1:
-// CHECK:     #0 memcpy
+// CHECK:     #0 {{.*memcpy}}
 // CHECK:     #1 Thread1

test/tsan/mutex_destroy_locked.cc

 // RUN: %clangxx_tsan -O1 %s -o %t && %deflake %run %t | FileCheck %s
 #include <pthread.h>
 #include <unistd.h>
 
 int main() {
   pthread_mutex_t m;
   pthread_mutex_init(&m, 0);
   pthread_mutex_lock(&m);
   pthread_mutex_destroy(&m);
   return 0;
 }
 
 // CHECK: WARNING: ThreadSanitizer: destroy of a locked mutex
-// CHECK:     #0 pthread_mutex_destroy
+// CHECK:     #0 {{.*pthread_mutex_destroy}}
 // CHECK:     #1 main
 // CHECK:   and:
-// CHECK:     #0 pthread_mutex_lock
+// CHECK:     #0 {{.*pthread_mutex_lock}}
 // CHECK:     #1 main
 // CHECK:   Mutex {{.*}} created at:
-// CHECK:     #0 pthread_mutex_init
+// CHECK:     #0 {{.*pthread_mutex_init}}
 // CHECK:     #1 main
 // CHECK: SUMMARY: ThreadSanitizer: destroy of a locked mutex{{.*}}main

test/tsan/mutexset1.cc

 
 int main() {
   barrier_init(&barrier, 2);
   // CHECK: WARNING: ThreadSanitizer: data race
   // CHECK:   Write of size 4 at {{.*}} by thread T1
   // CHECK:                         (mutexes: write [[M1:M[0-9]+]]):
   // CHECK:   Previous write of size 4 at {{.*}} by thread T2:
   // CHECK:   Mutex [[M1]] (0x{{.*}}) created at:
-  // CHECK:     #0 pthread_mutex_init
+  // CHECK:     #0 {{.*pthread_mutex_init}}
   // CHECK:     #1 main {{.*}}/mutexset1.cc:[[@LINE+1]]
   pthread_mutex_init(&mtx, 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);
   pthread_mutex_destroy(&mtx);
 }

test/tsan/mutexset2.cc

 
 int main() {
   barrier_init(&barrier, 2);
   // CHECK: WARNING: ThreadSanitizer: data race
   // CHECK:   Write of size 4 at {{.*}} by thread T2:
   // CHECK:   Previous write of size 4 at {{.*}} by thread T1
   // CHECK:                     (mutexes: write [[M1:M[0-9]+]]):
   // CHECK:   Mutex [[M1]] (0x{{.*}}) created at:
-  // CHECK:     #0 pthread_mutex_init
+  // CHECK:     #0 {{.*pthread_mutex_init}}
   // CHECK:     #1 main {{.*}}/mutexset2.cc:[[@LINE+1]]
   pthread_mutex_init(&mtx, 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);
   pthread_mutex_destroy(&mtx);
 }

test/tsan/mutexset3.cc

 
 int main() {
   barrier_init(&barrier, 2);
   // CHECK: WARNING: ThreadSanitizer: data race
   // CHECK: Write of size 4 at {{.*}} by thread T1
   // CHECK:               (mutexes: write [[M1:M[0-9]+]], write [[M2:M[0-9]+]]):
   // CHECK:   Previous write of size 4 at {{.*}} by thread T2:
   // CHECK:   Mutex [[M1]] (0x{{.*}}) created at:
-  // CHECK:     #0 pthread_mutex_init
+  // CHECK:     #0 {{.*pthread_mutex_init}}
   // CHECK:     #1 main {{.*}}/mutexset3.cc:[[@LINE+4]]
   // CHECK:   Mutex [[M2]] (0x{{.*}}) created at:
-  // CHECK:     #0 pthread_mutex_init
+  // CHECK:     #0 {{.*pthread_mutex_init}}
   // CHECK:     #1 main {{.*}}/mutexset3.cc:[[@LINE+2]]
   pthread_mutex_init(&mtx1, 0);
   pthread_mutex_init(&mtx2, 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);
   pthread_mutex_destroy(&mtx1);
   pthread_mutex_destroy(&mtx2);
 }

test/tsan/mutexset4.cc

 
 int main() {
   barrier_init(&barrier, 2);
   // CHECK: WARNING: ThreadSanitizer: data race
   // CHECK:   Write of size 4 at {{.*}} by thread T2:
   // CHECK:   Previous write of size 4 at {{.*}} by thread T1
   // CHECK:                 (mutexes: write [[M1:M[0-9]+]], write [[M2:M[0-9]+]]):
   // CHECK:   Mutex [[M1]] (0x{{.*}}) created at:
-  // CHECK:     #0 pthread_mutex_init
+  // CHECK:     #0 {{.*pthread_mutex_init}}
   // CHECK:     #1 main {{.*}}/mutexset4.cc:[[@LINE+4]]
   // CHECK:   Mutex [[M2]] (0x{{.*}}) created at:
-  // CHECK:     #0 pthread_mutex_init
+  // CHECK:     #0 {{.*pthread_mutex_init}}
   // CHECK:     #1 main {{.*}}/mutexset4.cc:[[@LINE+2]]
   pthread_mutex_init(&mtx1, 0);
   pthread_mutex_init(&mtx2, 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);
   pthread_mutex_destroy(&mtx1);
   pthread_mutex_destroy(&mtx2);
 }

test/tsan/mutexset8.cc

 
 int main() {
   barrier_init(&barrier, 2);
   // CHECK: WARNING: ThreadSanitizer: data race
   // CHECK:   Write of size 4 at {{.*}} by thread T1
   // CHECK:                         (mutexes: write [[M1:M[0-9]+]]):
   // CHECK:   Previous write of size 4 at {{.*}} by thread T2:
   // CHECK:   Mutex [[M1]] (0x{{.*}}) created at:
-  // CHECK:     #0 pthread_mutex_init
+  // CHECK:     #0 {{.*pthread_mutex_init}}
   // CHECK:     #1 main {{.*}}/mutexset8.cc
   mtx = new pthread_mutex_t;
   pthread_mutex_init(mtx, 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);
   pthread_mutex_destroy(mtx);
   delete mtx;
 }

test/tsan/race_on_heap.cc

int main() {
   pthread_join(t[1], 0);
   return 0;
 }
 
 // CHECK: addr=[[ADDR:0x[0-9,a-f]+]]
 // CHECK: WARNING: ThreadSanitizer: data race
 // ...
 // CHECK: Location is heap block of size 99 at [[ADDR]] allocated by thread T1:
-// CHCEK:     #0 malloc
+// CHCEK:     #0 {{.*malloc}}
 // CHECK:     #{{1|2}} alloc
 // CHECK:     #{{2|3}} AllocThread
 // ...
 // CHECK:   Thread T1 (tid={{.*}}, finished) created by main thread at:
-// CHECK:     #0 pthread_create
+// CHECK:     #0 {{.*pthread_create}}
 // CHECK:     #1 main

test/tsan/race_on_mutex.c

int main() {
   pthread_join(t[0], NULL);
   pthread_join(t[1], NULL);
   pthread_mutex_destroy(&Mtx);
   return 0;
 }
 
 // CHECK:      WARNING: ThreadSanitizer: data race
 // CHECK-NEXT:   Atomic read of size 1 at {{.*}} by thread T2:
-// CHECK-NEXT:     #0 pthread_mutex_lock
+// CHECK-NEXT:     #0 {{.*pthread_mutex_lock}}
 // CHECK-NEXT:     #1 Thread2{{.*}} {{.*}}race_on_mutex.c:18{{(:3)?}} ({{.*}})
 // CHECK:        Previous write of size 1 at {{.*}} by thread T1:
-// CHECK-NEXT:     #0 pthread_mutex_init {{.*}} ({{.*}})
+// CHECK-NEXT:     #0 {{.*pthread_mutex_init}} {{.*}} ({{.*}})
 // CHECK-NEXT:     #1 Thread1{{.*}} {{.*}}race_on_mutex.c:8{{(:3)?}} ({{.*}})

test/tsan/race_on_read.cc

int main() {
   pthread_join(t[0], NULL);
   pthread_join(t[1], NULL);
   close(fd);
   fprintf(stderr, "DONE\n");
 }
 
 // CHECK: WARNING: ThreadSanitizer: data race
 // CHECK:   Write of size 1
-// CHECK:     #0 read
+// CHECK:     #0 {{.*read}}
 // CHECK:   Previous write of size 1
-// CHECK:     #0 read
+// CHECK:     #0 {{.*read}}
 // CHECK: DONE
 

test/tsan/race_with_finished_thread.cc

 }
 
 // CHECK: WARNING: ThreadSanitizer: data race
 // CHECK:   Write of size 4 at {{.*}} by thread T2:
 // CHECK:   Previous write of size 4 at {{.*}} by thread T1:
 // CHECK:     #0 foobar
 // CHECK:     #1 Thread1
 // CHECK:   Thread T1 (tid={{.*}}, finished) created by main thread at:
-// CHECK:     #0 pthread_create
+// CHECK:     #0 {{.*pthread_create}}
 // CHECK:     #1 main

test/tsan/simple_stack.c

 // CHECK-NEXT:     #0 foo1{{.*}} {{.*}}simple_stack.c:7{{(:10)?}} ({{.*}})
 // CHECK-NEXT:     #1 bar1{{.*}} {{.*}}simple_stack.c:12{{(:3)?}} ({{.*}})
 // CHECK-NEXT:     #2 Thread1{{.*}} {{.*}}simple_stack.c:26{{(:3)?}} ({{.*}})
 // CHECK:        Previous read of size 4 at {{.*}} by thread T2:
 // CHECK-NEXT:     #0 foo2{{.*}} {{.*}}simple_stack.c:16{{(:20)?}} ({{.*}})
 // CHECK-NEXT:     #1 bar2{{.*}} {{.*}}simple_stack.c:21{{(:3)?}} ({{.*}})
 // CHECK-NEXT:     #2 Thread2{{.*}} {{.*}}simple_stack.c:31{{(:3)?}} ({{.*}})
 // CHECK:        Thread T1 (tid={{.*}}, running) created by main thread at:
-// CHECK-NEXT:     #0 pthread_create {{.*}} ({{.*}})
+// CHECK-NEXT:     #0 {{.*pthread_create}} {{.*}} ({{.*}})
 // CHECK-NEXT:     #1 StartThread{{.*}} {{.*}}simple_stack.c:37{{(:3)?}} ({{.*}})
 // CHECK-NEXT:     #2 main{{.*}} {{.*}}simple_stack.c:43{{(:3)?}} ({{.*}})
 // CHECK:        Thread T2 ({{.*}}) created by main thread at:
-// CHECK-NEXT:     #0 pthread_create {{.*}} ({{.*}})
+// CHECK-NEXT:     #0 {{.*pthread_create}} {{.*}} ({{.*}})
 // CHECK-NEXT:     #1 StartThread{{.*}} {{.*}}simple_stack.c:37{{(:3)?}} ({{.*}})
 // CHECK-NEXT:     #2 main{{.*}} {{.*}}simple_stack.c:44{{(:3)?}} ({{.*}})

test/tsan/sleep_sync.cc

int main() {
   barrier_wait(&barrier);
   pthread_join(t, 0);
   return 0;
 }
 
 // CHECK: WARNING: ThreadSanitizer: data race
 // ...
 // CHECK:   As if synchronized via sleep:
-// CHECK-NEXT:     #0 sleep
+// CHECK-NEXT:     #0 {{.*sleep}}
 // CHECK-NEXT:     #1 MySleep
 // CHECK-NEXT:     #2 Thread

test/tsan/thread_end_with_ignore.cc

 
 int main() {
   pthread_t t;
   pthread_create(&t, 0, Thread, 0);
   pthread_join(t, 0);
 }
 
 // CHECK: ThreadSanitizer: thread T1  finished with ignores enabled, created at:
-// CHECK:     #0 pthread_create
+// CHECK:     #0 {{.*pthread_create}}
 // CHECK:     #1 main
 // CHECK:   Ignore was enabled at:
 // CHECK:     #0 AnnotateIgnoreReadsBegin
 // CHECK:     #1 Thread