This is an archive of the discontinued LLVM Phabricator instance.

Differential D60575

[TSan][libdispatch] Use FileCheck's --implicit-check-not=...
AbandonedPublic

Authored by yln on Apr 11 2019, 12:49 PM.

Details

Reviewers
kubamracek
dcoughlin
jfb
dvyukov
Summary

Use FileCheck's --implicit-check-not='ThreadSanitizer' which increases
the strictness of our tests a bit.

CHECK: start
CHECK-NOT: ThreadSanitizer
CHECK: done

With --implicit-check-not='ThreadSanitizer' the above is turned into:

CHECK-NOT: ThreadSanitizer
CHECK: start
CHECK-NOT: ThreadSanitizer
CHECK: done
CHECK-NOT: ThreadSanitizer

Diff Detail

Event Timeline

yln created this revision.Apr 11 2019, 12:49 PM
Herald added projects: Restricted Project, Restricted Project. · View Herald TranscriptApr 11 2019, 12:49 PM
Herald added subscribers: llvm-commits, Restricted Project, kubamracek. · View Herald Transcript
Harbormaster completed remote builds in B30384: Diff 194734.Apr 11 2019, 12:51 PM
yln added reviewers: kubamracek, dcoughlin.Apr 11 2019, 12:51 PM
kubamracek added a comment.Apr 12 2019, 1:05 PM

I like this change, but there's no reason to apply it specifically to the Darwin tests, right? Can you apply it to all TSan tests?

yln updated this revision to Diff 194989.Apr 12 2019, 5:44 PM

Extend to most TSan tests that matched "CHECK-NOT:.*ThreadSanitizer".
Skipped big, complicated tests with multiple run lines and CHECK prefixes.

Some tests only have a lone CHECK-NOT: directive. For those, I added
the --implict-check-not part (for consistency), but did not remove the
check.

I will run this on my Linux VM machine before pushing. Let's hope that it
doesn't create too much churn on the build bots.

Adding Dmitry as a reviewer.

Herald added a reviewer: jfb. · View Herald TranscriptApr 12 2019, 5:44 PM
Herald added a subscriber: christof. · View Herald Transcript
Harbormaster completed remote builds in B30484: Diff 194989.Apr 12 2019, 5:44 PM
Herald added a subscriber: dexonsmith. · View Herald TranscriptApr 12 2019, 5:44 PM
yln added a reviewer: dvyukov.Apr 12 2019, 5:44 PM
yln updated this revision to Diff 194990.Apr 12 2019, 6:00 PM

Update comment.

Harbormaster completed remote builds in B30485: Diff 194990.Apr 12 2019, 6:03 PM
kubamracek added inline comments.Apr 15 2019, 10:23 AM
compiler-rt/test/tsan/atomic_norace.cc
62

Should this be removed now?

compiler-rt/test/tsan/benign_race.cc
39

Same here... and in other files.

yln marked an inline comment as done.Apr 15 2019, 10:38 AM
yln added inline comments.
compiler-rt/test/tsan/atomic_norace.cc
62

Some tests only have a lone CHECK-NOT: directive. For those the --implicit-check-not does not increase strictness. I added the --implict-check-not part for consistency (maybe someone changes te test or copies and extends it), but did not remove the check.

I can also remove lone "CHECK-NOT"s if you prefer.

yln added a comment.May 8 2019, 6:00 PM

@dvyukov, what do you think?

yln abandoned this revision.May 16 2019, 11:56 AM

Revision Contents

PathSize
compiler-rt/
test/
tsan/
Darwin/
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
4 lines
3 lines
3 lines
Linux/
4 lines
4 lines
4 lines
3 lines
3 lines
3 lines
4 lines
4 lines
2 lines
3 lines
2 lines
2 lines
5 lines
6 lines
3 lines
3 lines
3 lines
3 lines
2 lines
3 lines
2 lines
3 lines
2 lines
2 lines
2 lines
2 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
2 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
5 lines
3 lines
3 lines
libcxx/
3 lines
libdispatch/
3 lines
3 lines
3 lines
4 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
2 lines
3 lines
4 lines
3 lines
4 lines
4 lines
4 lines
3 lines
4 lines
3 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
2 lines
2 lines
3 lines
7 lines
3 lines
3 lines
3 lines

Diff 194990

compiler-rt/test/tsan/Darwin/external-ignore-noninstrumented.cc

// RUN: %clangxx_tsan -shared %p/external-lib.cc -fno-sanitize=thread -DUSE_TSAN_CALLBACKS \ // RUN: %clangxx_tsan -shared %p/external-lib.cc -fno-sanitize=thread -DUSE_TSAN_CALLBACKS \
// RUN: -o %t-lib.dylib -install_name @rpath/`basename %t-lib.dylib` // RUN: -o %t-lib.dylib -install_name @rpath/`basename %t-lib.dylib`
// RUN: %clangxx_tsan -shared %p/external-noninstrumented-module.cc %t-lib.dylib -fno-sanitize=thread \ // RUN: %clangxx_tsan -shared %p/external-noninstrumented-module.cc %t-lib.dylib -fno-sanitize=thread \
// RUN: -o %t-module.dylib -install_name @rpath/`basename %t-module.dylib` // RUN: -o %t-module.dylib -install_name @rpath/`basename %t-module.dylib`
// RUN: %clangxx_tsan %s %t-module.dylib -o %t // RUN: %clangxx_tsan %s %t-module.dylib -o %t
// RUN: %run %t 2>&1 | FileCheck %s // RUN: %run %t 2>&1 | FileCheck %s --implicit-check-not='ThreadSanitizer'
#include <stdio.h> #include <stdio.h>
extern "C" void NonInstrumentedModule(); extern "C" void NonInstrumentedModule();
int main(int argc, char *argv[]) { int main(int argc, char *argv[]) {
NonInstrumentedModule(); NonInstrumentedModule();
fprintf(stderr, "Done.\n"); fprintf(stderr, "Done.\n");
} }
// CHECK-NOT: WARNING: ThreadSanitizer
// CHECK: Done. // CHECK: Done.

compiler-rt/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). // This test verifies that dispatch_sync() doesn't actually copy the block under TSan (without TSan, it doesn't).
// RUN: %clang_tsan %s -o %t_no_tsan -framework Foundation -fno-sanitize=thread // RUN: %clang_tsan %s -o %t_no_tsan -framework Foundation -fno-sanitize=thread
// RUN: %clang_tsan %s -o %t_with_tsan -framework Foundation // RUN: %clang_tsan %s -o %t_with_tsan -framework Foundation
// RUN: %run %t_no_tsan 2>&1 | FileCheck %s // RUN: %run %t_no_tsan 2>&1 | FileCheck %s
// RUN: %run %t_with_tsan 2>&1 | FileCheck %s // RUN: %run %t_with_tsan 2>&1 | FileCheck %s --implicit-check-not='ThreadSanitizer'
#import <Foundation/Foundation.h> #import <Foundation/Foundation.h>
@interface MyClass : NSObject @interface MyClass : NSObject
@end @end
@implementation MyClass @implementation MyClass
- (instancetype)retain { - (instancetype)retain {
Show All 14 Linesint main(int argc, const char* argv[]) {
}); });
dispatch_sync(q, block); dispatch_sync(q, block);
[object release]; [object release];
NSLog(@"Done."); NSLog(@"Done.");
return 0; return 0;
} }
// CHECK: Done. // CHECK: Done.
// CHECK-NOT: WARNING: ThreadSanitizer

compiler-rt/test/tsan/Darwin/libcxx-call-once.mm

// RUN: %clangxx_tsan %s -o %t -framework Foundation -std=c++11 // RUN: %clangxx_tsan %s -o %t -framework Foundation -std=c++11
// RUN: %run %t 2>&1 | FileCheck %s // RUN: %run %t 2>&1 | FileCheck %s --implicit-check-not='ThreadSanitizer'
#import <Foundation/Foundation.h> #import <Foundation/Foundation.h>
#import <iostream> #import <iostream>
#import <thread> #import <thread>
long my_global; long my_global;
std::once_flag once_token; std::once_flag once_token;
Show All 14 Linesint main(int argc, const char *argv[]) {
std::thread t2(thread_func); std::thread t2(thread_func);
t1.join(); t1.join();
t2.join(); t2.join();
fprintf(stderr, "Done.\n"); fprintf(stderr, "Done.\n");
} }
// CHECK: Hello world. // CHECK: Hello world.
// CHECK-NOT: WARNING: ThreadSanitizer
// CHECK: Done. // CHECK: Done.

compiler-rt/test/tsan/Darwin/libcxx-future.mm

// RUN: %clangxx_tsan %s -o %t // RUN: %clangxx_tsan %s -o %t
// RUN: %run %t 2>&1 | FileCheck %s // RUN: %run %t 2>&1 | FileCheck %s --implicit-check-not='ThreadSanitizer'
#include <iostream> #include <iostream>
#include <future> #include <future>
#include <vector> #include <vector>
int main(int argc, const char *argv[]) { int main(int argc, const char *argv[]) {
fprintf(stderr, "Hello world.\n"); fprintf(stderr, "Hello world.\n");
Show All 10 Linesint main(int argc, const char *argv[]) {
for (auto &t : threads) { for (auto &t : threads) {
t.join(); t.join();
} }
fprintf(stderr, "Done.\n"); fprintf(stderr, "Done.\n");
} }
// CHECK: Hello world. // CHECK: Hello world.
// CHECK-NOT: WARNING: ThreadSanitizer
// CHECK: Done. // CHECK: Done.

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

// RUN: %clangxx_tsan %s -o %t -framework Foundation // RUN: %clangxx_tsan %s -o %t -framework Foundation
// RUN: %run %t 2>&1 | FileCheck %s // RUN: %run %t 2>&1 | FileCheck %s --implicit-check-not='ThreadSanitizer'
#import <Foundation/Foundation.h> #import <Foundation/Foundation.h>
#import <memory> #import <memory>
struct InnerStruct { struct InnerStruct {
~InnerStruct() { ~InnerStruct() {
fprintf(stderr, "~InnerStruct\n"); fprintf(stderr, "~InnerStruct\n");
Show All 17 Linesint main(int argc, const char *argv[]) {
fprintf(stderr, "Done.\n"); fprintf(stderr, "Done.\n");
} }
// CHECK: Hello world. // CHECK: Hello world.
// CHECK: ~MyStruct // CHECK: ~MyStruct
// CHECK: ~InnerStruct // CHECK: ~InnerStruct
// CHECK: Done. // CHECK: Done.
// CHECK-NOT: WARNING: ThreadSanitizer

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

// RUN: %clangxx_tsan %s -o %t -framework Foundation // RUN: %clangxx_tsan %s -o %t -framework Foundation
// RUN: %run %t 2>&1 | FileCheck %s // RUN: %run %t 2>&1 | FileCheck %s --implicit-check-not='ThreadSanitizer'
#import <Foundation/Foundation.h> #import <Foundation/Foundation.h>
#import <assert.h> #import <assert.h>
#import <memory> #import <memory>
#import <stdatomic.h> #import <stdatomic.h>
_Atomic(long) shared_call_counter = 0; _Atomic(long) shared_call_counter = 0;
▲ Show 20 Lines • Show All 56 Lines • ▼ Show 20 Linesint main(int argc, const char *argv[]) {
fprintf(stderr, "Done.\n"); fprintf(stderr, "Done.\n");
} }
// CHECK: Hello world. // CHECK: Hello world.
// CHECK: shared_call_counter = 1000000 // CHECK: shared_call_counter = 1000000
// CHECK: destructor_counter = 1000 // CHECK: destructor_counter = 1000
// CHECK: Done. // CHECK: Done.
// CHECK-NOT: WARNING: ThreadSanitizer

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

// RUN: %clangxx_tsan %s -o %t -framework Foundation // RUN: %clangxx_tsan %s -o %t -framework Foundation
// RUN: %run %t 2>&1 | FileCheck %s // RUN: %run %t 2>&1 | FileCheck %s --implicit-check-not='ThreadSanitizer'
#import <Foundation/Foundation.h> #import <Foundation/Foundation.h>
#import <memory> #import <memory>
#import "../test.h" #import "../test.h"
long my_global; long my_global;
Show All 31 Linesint main(int argc, const char *argv[]) {
barrier_wait(&barrier); barrier_wait(&barrier);
shared.reset(); shared.reset();
fprintf(stderr, "Done.\n"); fprintf(stderr, "Done.\n");
} }
// CHECK: Hello world. // CHECK: Hello world.
// CHECK: Done. // CHECK: Done.
// CHECK-NOT: WARNING: ThreadSanitizer

compiler-rt/test/tsan/Darwin/norace-objcxx-run-time.mm

// RUN: %clang_tsan %s -lc++ -fobjc-arc -lobjc -o %t -framework Foundation %darwin_min_target_with_full_runtime_arc_support // RUN: %clang_tsan %s -lc++ -fobjc-arc -lobjc -o %t -framework Foundation %darwin_min_target_with_full_runtime_arc_support
// RUN: %run %t 2>&1 | FileCheck %s // RUN: %run %t 2>&1 | FileCheck %s --implicit-check-not='ThreadSanitizer'
// Check that we do not report races between: // Check that we do not report races between:
// - Object retain and initialize // - Object retain and initialize
// - Object release and dealloc // - Object release and dealloc
// - Object release and .cxx_destruct // - Object release and .cxx_destruct
#import <Foundation/Foundation.h> #import <Foundation/Foundation.h>
#include "../test.h" #include "../test.h"
▲ Show 20 Lines • Show All 94 Lines • ▼ Show 20 Lines [tcxxdo accessMember];
}); });
} }
barrier_wait(&barrier2); barrier_wait(&barrier2);
NSLog(@"Done."); NSLog(@"Done.");
return 0; return 0;
} }
// CHECK: Done. // CHECK: Done.
// CHECK-NOT: ThreadSanitizer: data race

compiler-rt/test/tsan/Darwin/objc-simple.mm

// Test that a simple Obj-C program runs and exits without any warnings. // Test that a simple Obj-C program runs and exits without any warnings.
// RUN: %clang_tsan %s -o %t -framework Foundation // RUN: %clang_tsan %s -o %t -framework Foundation
// RUN: %run %t 2>&1 | FileCheck %s // RUN: %run %t 2>&1 | FileCheck %s --implicit-check-not='ThreadSanitizer'
#import <Foundation/Foundation.h> #import <Foundation/Foundation.h>
int main() { int main() {
NSLog(@"Hello world"); NSLog(@"Hello world");
} }
// CHECK: Hello world // CHECK: Hello world
// CHECK-NOT: WARNING: ThreadSanitizer

compiler-rt/test/tsan/Darwin/objc-synchronize-nested-recursive.mm

// RUN: %clangxx_tsan %s -o %t -framework Foundation -fobjc-arc %darwin_min_target_with_full_runtime_arc_support // RUN: %clangxx_tsan %s -o %t -framework Foundation -fobjc-arc %darwin_min_target_with_full_runtime_arc_support
// RUN: %run %t 2>&1 | FileCheck %s // RUN: %run %t 2>&1 | FileCheck %s --implicit-check-not='ThreadSanitizer'
#import <Foundation/Foundation.h> #import <Foundation/Foundation.h>
int main() { int main() {
@autoreleasepool { @autoreleasepool {
NSObject* obj1 = [NSObject new]; NSObject* obj1 = [NSObject new];
NSObject* obj2 = [NSObject new]; NSObject* obj2 = [NSObject new];
Show All 13 Lines// CHECK: nested 1-2-1-2
} }
} }
} }
} }
} }
NSLog(@"PASS"); NSLog(@"PASS");
// CHECK-NOT: ThreadSanitizer
// CHECK: PASS // CHECK: PASS
return 0; return 0;
} }

compiler-rt/test/tsan/Darwin/objc-synchronize-tagged.mm

// RUN: %clangxx_tsan %s -o %t -framework Foundation -fobjc-arc %darwin_min_target_with_full_runtime_arc_support // RUN: %clangxx_tsan %s -o %t -framework Foundation -fobjc-arc %darwin_min_target_with_full_runtime_arc_support
// RUN: %run %t 2>&1 | FileCheck %s // RUN: %run %t 2>&1 | FileCheck %s --implicit-check-not='ThreadSanitizer'
#import <Foundation/Foundation.h> #import <Foundation/Foundation.h>
NSString *tagged_string = nil; NSString *tagged_string = nil;
@interface MyClass : NSObject { @interface MyClass : NSObject {
long field; long field;
} }
▲ Show 20 Lines • Show All 43 Lines • ▼ Show 20 Lines for (int j = 0; j < 100; ++j) {
(void)x; (void)x;
} }
} }
dispatch_group_wait(group, DISPATCH_TIME_FOREVER); dispatch_group_wait(group, DISPATCH_TIME_FOREVER);
NSLog(@"Hello world"); NSLog(@"Hello world");
} }
// CHECK: Hello world // CHECK: Hello world
// CHECK-NOT: WARNING: ThreadSanitizer

compiler-rt/test/tsan/Darwin/objc-synchronize.mm

// RUN: %clangxx_tsan %s -o %t -framework Foundation -fobjc-arc %darwin_min_target_with_full_runtime_arc_support // RUN: %clangxx_tsan %s -o %t -framework Foundation -fobjc-arc %darwin_min_target_with_full_runtime_arc_support
// RUN: %run %t 2>&1 | FileCheck %s // RUN: %run %t 2>&1 | FileCheck %s --implicit-check-not='ThreadSanitizer'
#import <Foundation/Foundation.h> #import <Foundation/Foundation.h>
@interface MyClass : NSObject { @interface MyClass : NSObject {
long field; long field;
} }
@property (nonatomic, readonly) long value; @property (nonatomic, readonly) long value;
@end @end
Show All 38 Lines for (int j = 0; j < 100; ++j) {
(void)x; (void)x;
} }
} }
dispatch_group_wait(group, DISPATCH_TIME_FOREVER); dispatch_group_wait(group, DISPATCH_TIME_FOREVER);
NSLog(@"Hello world"); NSLog(@"Hello world");
} }
// CHECK: Hello world // CHECK: Hello world
// CHECK-NOT: WARNING: ThreadSanitizer

compiler-rt/test/tsan/Darwin/osatomics-add.mm

// RUN: %clangxx_tsan %s -o %t -framework Foundation -std=c++11 // RUN: %clangxx_tsan %s -o %t -framework Foundation -std=c++11
// RUN: %run %t 2>&1 | FileCheck %s // RUN: %run %t 2>&1 | FileCheck %s --implicit-check-not='ThreadSanitizer'
#import <Foundation/Foundation.h> #import <Foundation/Foundation.h>
#import <libkern/OSAtomic.h> #import <libkern/OSAtomic.h>
#include <thread> #include <thread>
volatile int64_t retainCount = 0; volatile int64_t retainCount = 0;
Show All 29 Linesint main(int argc, const char * argv[]) {
fprintf(stderr, "end, g = %ld\n", g); fprintf(stderr, "end, g = %ld\n", g);
return 0; return 0;
} }
// CHECK: start // CHECK: start
// CHECK: end, g = 42 // CHECK: end, g = 42
// CHECK-NOT: WARNING: ThreadSanitizer

compiler-rt/test/tsan/Darwin/osatomics-list.mm

// RUN: %clangxx_tsan %s -o %t -framework Foundation -std=c++11 // RUN: %clangxx_tsan %s -o %t -framework Foundation -std=c++11
// RUN: %run %t 2>&1 | FileCheck %s // RUN: %run %t 2>&1 | FileCheck %s --implicit-check-not='ThreadSanitizer'
#import <Foundation/Foundation.h> #import <Foundation/Foundation.h>
#import <libkern/OSAtomic.h> #import <libkern/OSAtomic.h>
#include <thread> #include <thread>
#include "../test.h" #include "../test.h"
Show All 24 Linesint main(int argc, const char *argv[]) {
fprintf(stderr, "done\n"); fprintf(stderr, "done\n");
return 0; return 0;
} }
// CHECK: data = 42 // CHECK: data = 42
// CHECK: done // CHECK: done
// CHECK-NOT: WARNING: ThreadSanitizer

compiler-rt/test/tsan/Darwin/osspinlock-norace.cc

// RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not='ThreadSanitizer'
#include <pthread.h> #include <pthread.h>
#include <stdint.h> #include <stdint.h>
#include <stdio.h> #include <stdio.h>
typedef int32_t OSSpinLock; typedef int32_t OSSpinLock;
extern "C" void OSSpinLockLock(OSSpinLock *); extern "C" void OSSpinLockLock(OSSpinLock *);
extern "C" void OSSpinLockUnlock(OSSpinLock *); extern "C" void OSSpinLockUnlock(OSSpinLock *);
Show All 16 Linesint main() {
pthread_join(t[0], NULL); pthread_join(t[0], NULL);
pthread_join(t[1], NULL); pthread_join(t[1], NULL);
fprintf(stderr, "Done.\n"); fprintf(stderr, "Done.\n");
} }
// CHECK: Hello world. // CHECK: Hello world.
// CHECK: Done. // CHECK: Done.
// CHECK-NOT: WARNING: ThreadSanitizer

compiler-rt/test/tsan/Darwin/signals-blocked.cc

// RUN: %clangxx_tsan %s -o %t && %run %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not='ThreadSanitizer'
#include <pthread.h> #include <pthread.h>
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <signal.h> #include <signal.h>
#include <sys/types.h> #include <sys/types.h>
#include <sys/time.h> #include <sys/time.h>
#include <unistd.h> #include <unistd.h>
▲ Show 20 Lines • Show All 54 Lines • ▼ Show 20 Linesint main() {
pthread_t th; pthread_t th;
pthread_create(&th, 0, thr, 0); pthread_create(&th, 0, thr, 0);
pthread_join(th, 0); pthread_join(th, 0);
fprintf(stderr, "DONE\n"); fprintf(stderr, "DONE\n");
return 0; return 0;
} }
// CHECK-NOT: WARNING: ThreadSanitizer:
// CHECK: SIGNAL DELIVERED // CHECK: SIGNAL DELIVERED
// CHECK: DONE // CHECK: DONE
// CHECK-NOT: WARNING: ThreadSanitizer:

compiler-rt/test/tsan/Darwin/xpc-cancel.mm

// RUN: %clang_tsan %s -o %t -framework Foundation // RUN: %clang_tsan %s -o %t -framework Foundation
// RUN: %run %t 2>&1 | FileCheck %s // RUN: %run %t 2>&1 | FileCheck %s --implicit-check-not='ThreadSanitizer'
// UNSUPPORTED: ios // UNSUPPORTED: ios
#import <Foundation/Foundation.h> #import <Foundation/Foundation.h>
#import <xpc/xpc.h> #import <xpc/xpc.h>
long global; long global;
Show All 19 Linesint main(int argc, const char *argv[]) {
xpc_connection_cancel(server_conn); xpc_connection_cancel(server_conn);
CFRunLoopRun(); CFRunLoopRun();
fprintf(stderr, "Done.\n"); fprintf(stderr, "Done.\n");
} }
// CHECK: Hello world. // CHECK: Hello world.
// CHECK-NOT: WARNING: ThreadSanitizer
// CHECK: Done. // CHECK: Done.

compiler-rt/test/tsan/Darwin/xpc.mm

// RUN: %clang_tsan %s -o %t -framework Foundation // RUN: %clang_tsan %s -o %t -framework Foundation
// RUN: %run %t 2>&1 | FileCheck %s // RUN: %run %t 2>&1 | FileCheck %s --implicit-check-not='ThreadSanitizer'
// UNSUPPORTED: ios // UNSUPPORTED: ios
#import <Foundation/Foundation.h> #import <Foundation/Foundation.h>
#import <xpc/xpc.h> #import <xpc/xpc.h>
long global; long global;
▲ Show 20 Lines • Show All 57 Lines • ▼ Show 20 Lines @autoreleasepool {
CFRunLoopRun(); CFRunLoopRun();
NSLog(@"Done."); NSLog(@"Done.");
} }
return 0; return 0;
} }
// CHECK: Done. // CHECK: Done.
// CHECK-NOT: WARNING: ThreadSanitizer

compiler-rt/test/tsan/Linux/mutex_robust.cc

// RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not='ThreadSanitizer'
#include <pthread.h> #include <pthread.h>
#include <stdlib.h> #include <stdlib.h>
#include <stdio.h> #include <stdio.h>
#include <unistd.h> #include <unistd.h>
#include <errno.h> #include <errno.h>
pthread_mutex_t m; pthread_mutex_t m;
Show All 14 Lines if (pthread_mutex_lock(&m) != EOWNERDEAD) {
fprintf(stderr, "not EOWNERDEAD\n"); fprintf(stderr, "not EOWNERDEAD\n");
exit(1); exit(1);
} }
pthread_join(th, 0); pthread_join(th, 0);
fprintf(stderr, "DONE\n"); fprintf(stderr, "DONE\n");
} }
// This is a correct code, and tsan must not bark. // This is a correct code, and tsan must not bark.
// CHECK-NOT: WARNING: ThreadSanitizer
// CHECK-NOT: EOWNERDEAD // CHECK-NOT: EOWNERDEAD
// CHECK: DONE // CHECK: DONE
// CHECK-NOT: WARNING: ThreadSanitizer

compiler-rt/test/tsan/Linux/thread_timedjoin.c

// RUN: %clang_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s // RUN: %clang_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not='ThreadSanitizer'
#define _GNU_SOURCE #define _GNU_SOURCE
#include "../test.h" #include "../test.h"
#include <errno.h> #include <errno.h>
int var; int var;
void *Thread(void *x) { void *Thread(void *x) {
barrier_wait(&barrier); barrier_wait(&barrier);
Show All 19 Linesint main() {
clock_gettime(CLOCK_REALTIME, &ts); clock_gettime(CLOCK_REALTIME, &ts);
ts.tv_sec += 10000; ts.tv_sec += 10000;
check(pthread_timedjoin_np(t, 0, &ts), 0); check(pthread_timedjoin_np(t, 0, &ts), 0);
var = 2; var = 2;
fprintf(stderr, "PASS\n"); fprintf(stderr, "PASS\n");
return 0; return 0;
} }
// CHECK-NOT: WARNING: ThreadSanitizer: data race
// CHECK-NOT: WARNING: ThreadSanitizer: thread leak
// CHECK: PASS // CHECK: PASS

compiler-rt/test/tsan/Linux/thread_tryjoin.c

// RUN: %clang_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s // RUN: %clang_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not='ThreadSanitizer'
#define _GNU_SOURCE #define _GNU_SOURCE
#include "../test.h" #include "../test.h"
#include <errno.h> #include <errno.h>
int var; int var;
void *Thread(void *x) { void *Thread(void *x) {
barrier_wait(&barrier); barrier_wait(&barrier);
Show All 21 Lines for (;;) {
check(res); check(res);
pthread_yield(); pthread_yield();
} }
var = 2; var = 2;
fprintf(stderr, "PASS\n"); fprintf(stderr, "PASS\n");
return 0; return 0;
} }
// CHECK-NOT: WARNING: ThreadSanitizer: data race
// CHECK-NOT: WARNING: ThreadSanitizer: thread leak
// CHECK: PASS // CHECK: PASS

compiler-rt/test/tsan/Linux/user_fopen.cc

// RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not='ThreadSanitizer'
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
// Defined by tsan. // Defined by tsan.
extern "C" FILE *__interceptor_fopen(const char *file, const char *mode); extern "C" FILE *__interceptor_fopen(const char *file, const char *mode);
extern "C" int __interceptor_fileno(FILE *f); extern "C" int __interceptor_fileno(FILE *f);
extern "C" FILE *fopen(const char *file, const char *mode) { extern "C" FILE *fopen(const char *file, const char *mode) {
Show All 15 Linesint main() {
if (f) { if (f) {
char buf; char buf;
fread(&buf, 1, 1, f); fread(&buf, 1, 1, f);
fclose(f); fclose(f);
} }
} }
// CHECK: user fopen // CHECK: user fopen
// CHECK-NOT: ThreadSanitizer

compiler-rt/test/tsan/Linux/user_malloc.cc

// RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not='ThreadSanitizer'
// UNSUPPORTED: powerpc64le // UNSUPPORTED: powerpc64le
// FIXME: Remove the test or find how to fix this. // FIXME: Remove the test or find how to fix this.
// On some distributions, probably with newer glibc, tsan initialization calls // On some distributions, probably with newer glibc, tsan initialization calls
// dlsym which then calls malloc and crashes because of tsan is not initialized. // dlsym which then calls malloc and crashes because of tsan is not initialized.
// UNSUPPORTED: linux // UNSUPPORTED: linux
Show All 16 Lines
int main() { int main() {
volatile char *p = (char*)malloc(10); volatile char *p = (char*)malloc(10);
p[0] = 0; p[0] = 0;
free((void*)p); free((void*)p);
} }
// CHECK: user malloc // CHECK: user malloc
// CHECK-NOT: ThreadSanitizer

compiler-rt/test/tsan/annotate_happens_before.cc

// RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not='ThreadSanitizer'
#include "test.h" #include "test.h"
/* /*
Annotations usage example. Annotations usage example.
Tsan does not see synchronization in barrier_wait. Tsan does not see synchronization in barrier_wait.
ANNOTATE_HAPPENS_BEFORE/AFTER communicate the synchronization to tsan ANNOTATE_HAPPENS_BEFORE/AFTER communicate the synchronization to tsan
and prevent the race report. and prevent the race report.
Show All 37 Linesint main() {
pthread_create(&t[0], NULL, Thread1, NULL); pthread_create(&t[0], NULL, Thread1, NULL);
pthread_create(&t[1], NULL, Thread2, NULL); pthread_create(&t[1], NULL, Thread2, NULL);
pthread_join(t[0], NULL); pthread_join(t[0], NULL);
pthread_join(t[1], NULL); pthread_join(t[1], NULL);
fprintf(stderr, "DONE\n"); fprintf(stderr, "DONE\n");
return 0; return 0;
} }
// CHECK-NOT: WARNING: ThreadSanitizer: data race
// CHECK: DONE // CHECK: DONE

compiler-rt/test/tsan/atexit2.cc

// RUN: %clang_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s // RUN: %clang_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not='ThreadSanitizer'
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
int n; int n;
const int N = 10000; const int N = 10000;
static void atexit1() { static void atexit1() {
n++; n++;
} }
static void atexit0() { static void atexit0() {
fprintf(stderr, "run count: %d\n", n); fprintf(stderr, "run count: %d\n", n);
} }
int main() { int main() {
atexit(atexit0); atexit(atexit0);
for (int i = 0; i < N; i++) for (int i = 0; i < N; i++)
atexit(atexit1); atexit(atexit1);
} }
// CHECK-NOT: FATAL: ThreadSanitizer
// CHECK-NOT: WARNING: ThreadSanitizer
// CHECK: run count: 10000 // CHECK: run count: 10000

compiler-rt/test/tsan/atexit3.cc

// RUN: %clang_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s // RUN: %clang_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not='ThreadSanitizer'
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
static void atexit5() { static void atexit5() {
fprintf(stderr, "5"); fprintf(stderr, "5");
} }
Show All 21 Linesint main() {
atexit(atexit0); atexit(atexit0);
atexit(atexit1); atexit(atexit1);
atexit(atexit2); atexit(atexit2);
atexit(atexit3); atexit(atexit3);
atexit(atexit4); atexit(atexit4);
atexit(atexit5); atexit(atexit5);
} }
// CHECK-NOT: FATAL: ThreadSanitizer
// CHECK-NOT: WARNING: ThreadSanitizer
// CHECK: 54321 // CHECK: 54321

compiler-rt/test/tsan/atomic_norace.cc

// RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not='ThreadSanitizer'
#include "test.h" #include "test.h"
const int kTestCount = 4; const int kTestCount = 4;
typedef long long T; typedef long long T;
T atomics[kTestCount * 2]; T atomics[kTestCount * 2];
void Test(int test, T *p, bool main_thread) { void Test(int test, T *p, bool main_thread) {
volatile T sink; volatile T sink;
▲ Show 20 Lines • Show All 44 Lines • ▼ Show 20 Linesint main() {
} }
for (int i = 0; i < kTestCount; i++) { for (int i = 0; i < kTestCount; i++) {
Test(i, &atomics[kTestCount + i], true); Test(i, &atomics[kTestCount + i], true);
} }
barrier_wait(&barrier); barrier_wait(&barrier);
pthread_join(t, 0); pthread_join(t, 0);
} }
// CHECK-NOT: ThreadSanitizer: data race // CHECK-NOT: ThreadSanitizer: data race
kubamracekUnsubmitted
Not Done
ReplyInline Actions

Should this be removed now?

kubamracek: Should this be removed now?
ylnAuthorUnsubmitted
Done
ReplyInline Actions

Some tests only have a lone CHECK-NOT: directive. For those the --implicit-check-not does not increase strictness. I added the --implict-check-not part for consistency (maybe someone changes te test or copies and extends it), but did not remove the check.

I can also remove lone "CHECK-NOT"s if you prefer.

yln: Some tests only have a lone CHECK-NOT: directive. For those the `--implicit-check-not` does not…

compiler-rt/test/tsan/barrier.cc

// RUN: %clang_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s // RUN: %clang_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not='ThreadSanitizer'
// CHECK-NOT: ThreadSanitizer: data race
// CHECK: DONE // CHECK: DONE
// pthread barriers are not available on OS X // pthread barriers are not available on OS X
// UNSUPPORTED: darwin // UNSUPPORTED: darwin
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <pthread.h> #include <pthread.h>
Show All 30 Lines

compiler-rt/test/tsan/benign_race.cc

// RUN: %clang_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s // RUN: %clang_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not='ThreadSanitizer'
#include "test.h" #include "test.h"
int Global; int Global;
int WTFGlobal; int WTFGlobal;
extern "C" { extern "C" {
void AnnotateBenignRaceSized(const char *f, int l, void AnnotateBenignRaceSized(const char *f, int l,
void *mem, unsigned int size, const char *desc); void *mem, unsigned int size, const char *desc);
Show All 21 Linesint main() {
pthread_create(&t, 0, Thread, 0); pthread_create(&t, 0, Thread, 0);
barrier_wait(&barrier); barrier_wait(&barrier);
Global = 43; Global = 43;
WTFGlobal = 143; WTFGlobal = 143;
pthread_join(t, 0); pthread_join(t, 0);
fprintf(stderr, "OK\n"); fprintf(stderr, "OK\n");
} }
// CHECK-NOT: WARNING: ThreadSanitizer: data race // CHECK-NOT: WARNING: ThreadSanitizer: data race
kubamracekUnsubmitted
Not Done
ReplyInline Actions

Same here... and in other files.

kubamracek: Same here... and in other files.

compiler-rt/test/tsan/blacklist.cc

// Test blacklist functionality for TSan. // Test blacklist functionality for TSan.
// RUN: echo "fun:*Blacklisted_Thread2*" > %t.blacklist // RUN: echo "fun:*Blacklisted_Thread2*" > %t.blacklist
// RUN: %clangxx_tsan -O1 %s -fsanitize-blacklist=%t.blacklist -o %t && %run %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -fsanitize-blacklist=%t.blacklist -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not='ThreadSanitizer'
#include <pthread.h> #include <pthread.h>
#include <stdio.h> #include <stdio.h>
int Global; int Global;
void *Thread1(void *x) { void *Thread1(void *x) {
Global++; Global++;
return NULL; return NULL;
Show All 18 Lines

compiler-rt/test/tsan/cond.c

// RUN: %clang_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s // RUN: %clang_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not='ThreadSanitizer'
// CHECK-NOT: WARNING: ThreadSanitizer: data race
// CHECK-NOT: ThreadSanitizer WARNING: double lock
// CHECK-NOT: ThreadSanitizer WARNING: mutex unlock by another thread
// CHECK: OK // CHECK: OK
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <pthread.h> #include <pthread.h>
pthread_mutex_t m; pthread_mutex_t m;
pthread_cond_t c; pthread_cond_t c;
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

compiler-rt/test/tsan/cond_destruction.cc

// RUN: %clangxx_tsan -O1 %s -o %t // RUN: %clangxx_tsan -O1 %s -o %t
// RUN: %run %t 2>&1 | FileCheck %s // RUN: %run %t 2>&1 | FileCheck %s --implicit-check-not='ThreadSanitizer'
// RUN: %run %t arg 2>&1 | FileCheck %s // RUN: %run %t arg 2>&1 | FileCheck %s --implicit-check-not='ThreadSanitizer'
// RUN: %run %t arg arg 2>&1 | FileCheck %s // RUN: %run %t arg arg 2>&1 | FileCheck %s --implicit-check-not='ThreadSanitizer'
#include "test.h" #include "test.h"
// Test for destruction of pthread_cond_t. // Test for destruction of pthread_cond_t.
// POSIX states that it is safe to destroy a condition variable upon which no // POSIX states that it is safe to destroy a condition variable upon which no
// threads are currently blocked. That is, it is not necessary to wait untill // threads are currently blocked. That is, it is not necessary to wait untill
// other threads return from pthread_cond_wait, they just need to be unblocked. // other threads return from pthread_cond_wait, they just need to be unblocked.
pthread_mutex_t m; pthread_mutex_t m;
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

compiler-rt/test/tsan/custom_mutex3.cc

// RUN: %clangxx_tsan -O1 --std=c++11 %s -o %t // RUN: %clangxx_tsan -O1 --std=c++11 %s -o %t
// RUN: %env_tsan_opts=report_destroy_locked=0 %run %t 2>&1 | FileCheck %s // RUN: %env_tsan_opts=report_destroy_locked=0 %run %t 2>&1 | FileCheck %s --implicit-check-not='ThreadSanitizer'
#include "custom_mutex.h" #include "custom_mutex.h"
// Regression test for a bug. // Regression test for a bug.
// Thr1 destroys a locked mutex, previously such mutex was not removed from // Thr1 destroys a locked mutex, previously such mutex was not removed from
// sync map and as the result subsequent uses of a mutex located at the same // sync map and as the result subsequent uses of a mutex located at the same
// address caused false race reports. // address caused false race reports.
Mutex mu(false, __tsan_mutex_write_reentrant); Mutex mu(false, __tsan_mutex_write_reentrant);
Show All 26 Linesint main() {
data++; data++;
mu.Unlock(); mu.Unlock();
barrier_wait(&barrier); barrier_wait(&barrier);
pthread_join(th, 0); pthread_join(th, 0);
fprintf(stderr, "DONE\n"); fprintf(stderr, "DONE\n");
return 0; return 0;
} }
// CHECK-NOT: WARNING: ThreadSanitizer: data race
// CHECK: DONE // CHECK: DONE

compiler-rt/test/tsan/default_options.cc

// RUN: %clang_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s // RUN: %clang_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not='ThreadSanitizer'
#include <pthread.h> #include <pthread.h>
#include <stdio.h> #include <stdio.h>
extern "C" const char *__tsan_default_options() { extern "C" const char *__tsan_default_options() {
return "report_bugs=0"; return "report_bugs=0";
} }
int Global; int Global;
Show All 13 Linesint main() {
pthread_create(&t[0], NULL, Thread1, NULL); pthread_create(&t[0], NULL, Thread1, NULL);
pthread_create(&t[1], NULL, Thread2, NULL); pthread_create(&t[1], NULL, Thread2, NULL);
pthread_join(t[0], NULL); pthread_join(t[0], NULL);
pthread_join(t[1], NULL); pthread_join(t[1], NULL);
fprintf(stderr, "DONE\n"); fprintf(stderr, "DONE\n");
return 0; return 0;
} }
// CHECK-NOT: WARNING: ThreadSanitizer: data race
// CHECK: DONE // CHECK: DONE

compiler-rt/test/tsan/dl_iterate_phdr.cc

// RUN: %clangxx_tsan -O1 %s -DBUILD_SO -fPIC -shared -o %t-so.so // RUN: %clangxx_tsan -O1 %s -DBUILD_SO -fPIC -shared -o %t-so.so
// RUN: %clangxx_tsan -O1 %s %link_libcxx_tsan -o %t && %run %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s %link_libcxx_tsan -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not='ThreadSanitizer'
// dl_iterate_phdr doesn't exist on OS X. // dl_iterate_phdr doesn't exist on OS X.
// UNSUPPORTED: darwin // UNSUPPORTED: darwin
#ifdef BUILD_SO #ifdef BUILD_SO
#include "test.h" #include "test.h"
Show All 37 Linesint main(int argc, char *argv[]) {
} }
pthread_join(th, 0); pthread_join(th, 0);
fprintf(stderr, "DONE\n"); fprintf(stderr, "DONE\n");
return 0; return 0;
} }
#endif // BUILD_SO #endif // BUILD_SO
// CHECK-NOT: WARNING: ThreadSanitizer: data race
// CHECK: DONE // CHECK: DONE

compiler-rt/test/tsan/dtls.c

// RUN: %clang_tsan %s -o %t // RUN: %clang_tsan %s -o %t
// RUN: %clang_tsan %s -DBUILD_SO -fPIC -o %t-so.so -shared // RUN: %clang_tsan %s -DBUILD_SO -fPIC -o %t-so.so -shared
// RUN: %run %t 2>&1 | FileCheck %s // RUN: %run %t 2>&1 | FileCheck %s --implicit-check-not='ThreadSanitizer'
// XFAIL: netbsd // XFAIL: netbsd
// Test that tsan cleans up dynamic TLS memory between reuse. // Test that tsan cleans up dynamic TLS memory between reuse.
#include "test.h" #include "test.h"
#ifndef BUILD_SO #ifndef BUILD_SO
#include <assert.h> #include <assert.h>
▲ Show 20 Lines • Show All 42 Lines • ▼ Show 20 Lines
} }
#else // BUILD_SO #else // BUILD_SO
__thread long huge_thread_local_array[1 << 17]; __thread long huge_thread_local_array[1 << 17];
long *GetTls() { long *GetTls() {
return &huge_thread_local_array[0]; return &huge_thread_local_array[0];
} }
#endif #endif
// CHECK-NOT: ThreadSanitizer: data race
// CHECK: DONE // CHECK: DONE

compiler-rt/test/tsan/fd_close_norace.cc

// RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not='ThreadSanitizer'
#include "test.h" #include "test.h"
#include <sys/types.h> #include <sys/types.h>
#include <sys/stat.h> #include <sys/stat.h>
#include <fcntl.h> #include <fcntl.h>
void *Thread1(void *x) { void *Thread1(void *x) {
int f = open("/dev/random", O_RDONLY); int f = open("/dev/random", O_RDONLY);
close(f); close(f);
Show All 24 Lines

compiler-rt/test/tsan/fd_close_norace2.cc

// RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not='ThreadSanitizer'
#include <pthread.h> #include <pthread.h>
#include <stdio.h> #include <stdio.h>
#include <unistd.h> #include <unistd.h>
int pipes[2]; int pipes[2];
void *Thread(void *x) { void *Thread(void *x) {
// wait for shutown signal // wait for shutown signal
Show All 11 Linesint main() {
pthread_create(&t, 0, Thread, 0); pthread_create(&t, 0, Thread, 0);
// send shutdown signal // send shutdown signal
while (write(pipes[1], &t, 1) != 1) { while (write(pipes[1], &t, 1) != 1) {
} }
pthread_join(t, 0); pthread_join(t, 0);
fprintf(stderr, "OK\n"); fprintf(stderr, "OK\n");
} }
// CHECK-NOT: WARNING: ThreadSanitizer: data race
// CHECK: OK // CHECK: OK

compiler-rt/test/tsan/fd_dup_norace.cc

// RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not='ThreadSanitizer'
#include <pthread.h> #include <pthread.h>
#include <stdio.h> #include <stdio.h>
#include <unistd.h> #include <unistd.h>
#include <sys/types.h> #include <sys/types.h>
#include <sys/stat.h> #include <sys/stat.h>
#include <fcntl.h> #include <fcntl.h>
int fds[2]; int fds[2];
Show All 25 Lines

compiler-rt/test/tsan/fd_dup_norace2.cc

// RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not='ThreadSanitizer'
#include "test.h" #include "test.h"
#include <sys/types.h> #include <sys/types.h>
#include <sys/stat.h> #include <sys/stat.h>
#include <fcntl.h> #include <fcntl.h>
#include <errno.h> #include <errno.h>
// dup2(oldfd, newfd) races with read(newfd). // dup2(oldfd, newfd) races with read(newfd).
// This is not reported as race because: // This is not reported as race because:
▲ Show 20 Lines • Show All 41 Lines • ▼ Show 20 Linesint main() {
pthread_join(th, 0); pthread_join(th, 0);
if (close(fd) == -1) if (close(fd) == -1)
exit(printf("close failed\n")); exit(printf("close failed\n"));
if (close(fd2) == -1) if (close(fd2) == -1)
exit(printf("close failed\n")); exit(printf("close failed\n"));
fprintf(stderr, "DONE\n"); fprintf(stderr, "DONE\n");
} }
// CHECK-NOT: WARNING: ThreadSanitizer: data race
// CHECK: DONE // CHECK: DONE

compiler-rt/test/tsan/fd_pipe_norace.cc

// RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not='ThreadSanitizer'
#include <pthread.h> #include <pthread.h>
#include <stdio.h> #include <stdio.h>
#include <unistd.h> #include <unistd.h>
int fds[2]; int fds[2];
int X; int X;
void *Thread1(void *x) { void *Thread1(void *x) {
Show All 24 Lines

compiler-rt/test/tsan/fd_socket_connect_norace.cc

// RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not='ThreadSanitizer'
#include <arpa/inet.h> #include <arpa/inet.h>
#include <assert.h> #include <assert.h>
#include <netinet/in.h> #include <netinet/in.h>
#include <pthread.h> #include <pthread.h>
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <sys/socket.h> #include <sys/socket.h>
#include <sys/types.h> #include <sys/types.h>
▲ Show 20 Lines • Show All 53 Lines • Show Last 20 Lines

compiler-rt/test/tsan/fd_socket_norace.cc

// RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not='ThreadSanitizer'
#include <arpa/inet.h> #include <arpa/inet.h>
#include <assert.h> #include <assert.h>
#include <netinet/in.h> #include <netinet/in.h>
#include <pthread.h> #include <pthread.h>
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <sys/socket.h> #include <sys/socket.h>
#include <sys/types.h> #include <sys/types.h>
▲ Show 20 Lines • Show All 60 Lines • Show Last 20 Lines

compiler-rt/test/tsan/fd_socketpair_norace.cc

// RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not='ThreadSanitizer'
#include <pthread.h> #include <pthread.h>
#include <stdio.h> #include <stdio.h>
#include <unistd.h> #include <unistd.h>
#include <sys/types.h> #include <sys/types.h>
#include <sys/socket.h> #include <sys/socket.h>
int fds[2]; int fds[2];
int X; int X;
Show All 28 Lines

compiler-rt/test/tsan/fiber_asm.cc

// RUN: %clang_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s // RUN: %clang_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not='ThreadSanitizer'
// REQUIRES: x86_64-target-arch // REQUIRES: x86_64-target-arch
// UNSUPPORTED: darwin // UNSUPPORTED: darwin
#include "test.h" #include "test.h"
struct ucontext { struct ucontext {
void *sp; void *sp;
void *fiber; void *fiber;
}; };
▲ Show 20 Lines • Show All 67 Lines • ▼ Show 20 Lines
int main() { int main() {
ucontext_init(&uc, stack, sizeof(stack), func, 0); ucontext_init(&uc, stack, sizeof(stack), func, 0);
ucontext_switch(&orig_uc, &uc); ucontext_switch(&orig_uc, &uc);
ucontext_free(&uc); ucontext_free(&uc);
fprintf(stderr, "PASS\n"); fprintf(stderr, "PASS\n");
return 0; return 0;
} }
// CHECK-NOT: WARNING: ThreadSanitizer:
// CHECK: PASS // CHECK: PASS

compiler-rt/test/tsan/fiber_from_thread.cc

// RUN: %clang_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s // RUN: %clang_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not='ThreadSanitizer'
// UNSUPPORTED: darwin // UNSUPPORTED: darwin
#include "test.h" #include "test.h"
#include <ucontext.h> #include <ucontext.h>
char stack[64 * 1024] __attribute__((aligned(16))); char stack[64 * 1024] __attribute__((aligned(16)));
ucontext_t uc, orig_uc1, orig_uc2; ucontext_t uc, orig_uc1, orig_uc2;
void *fiber, *orig_fiber1, *orig_fiber2; void *fiber, *orig_fiber1, *orig_fiber2;
Show All 29 Linesint main() {
__tsan_switch_to_fiber(orig_fiber2, 0); __tsan_switch_to_fiber(orig_fiber2, 0);
swapcontext(&orig_uc1, &orig_uc2); swapcontext(&orig_uc1, &orig_uc2);
var = 3; var = 3;
__tsan_destroy_fiber(fiber); __tsan_destroy_fiber(fiber);
fprintf(stderr, "PASS\n"); fprintf(stderr, "PASS\n");
return 0; return 0;
} }
// CHECK-NOT: WARNING: ThreadSanitizer:
// CHECK: PASS // CHECK: PASS

compiler-rt/test/tsan/fiber_longjmp.cc

// RUN: %clang_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s // RUN: %clang_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not='ThreadSanitizer'
// UNSUPPORTED: darwin // UNSUPPORTED: darwin
#include "test.h" #include "test.h"
#include <setjmp.h> #include <setjmp.h>
#include <ucontext.h> #include <ucontext.h>
char stack[64 * 1024] __attribute__((aligned(16))); char stack[64 * 1024] __attribute__((aligned(16)));
sigjmp_buf jmpbuf, orig_jmpbuf[2]; sigjmp_buf jmpbuf, orig_jmpbuf[2];
▲ Show 20 Lines • Show All 61 Lines • ▼ Show 20 Lines for (unsigned i = 0; i < N; i++) {
barrier_wait(&barrier); barrier_wait(&barrier);
} }
pthread_join(t, 0); pthread_join(t, 0);
__tsan_destroy_fiber(fiber); __tsan_destroy_fiber(fiber);
fprintf(stderr, "PASS\n"); fprintf(stderr, "PASS\n");
return 0; return 0;
} }
// CHECK-NOT: WARNING: ThreadSanitizer:
// CHECK: PASS // CHECK: PASS

compiler-rt/test/tsan/fiber_simple.cc

// RUN: %clang_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s // RUN: %clang_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not='ThreadSanitizer'
// UNSUPPORTED: darwin // UNSUPPORTED: darwin
#include "test.h" #include "test.h"
#include <ucontext.h> #include <ucontext.h>
char stack[64 * 1024] __attribute__((aligned(16))); char stack[64 * 1024] __attribute__((aligned(16)));
ucontext_t uc, orig_uc; ucontext_t uc, orig_uc;
void *fiber, *orig_fiber; void *fiber, *orig_fiber;
Show All 17 Linesint main() {
var = 2; var = 2;
__tsan_switch_to_fiber(fiber, 0); __tsan_switch_to_fiber(fiber, 0);
swapcontext(&orig_uc, &uc); swapcontext(&orig_uc, &uc);
__tsan_destroy_fiber(fiber); __tsan_destroy_fiber(fiber);
fprintf(stderr, "PASS\n"); fprintf(stderr, "PASS\n");
return 0; return 0;
} }
// CHECK-NOT: WARNING: ThreadSanitizer:
// CHECK: PASS // CHECK: PASS

compiler-rt/test/tsan/fiber_two_threads.cc

// RUN: %clang_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s // RUN: %clang_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not='ThreadSanitizer'
// UNSUPPORTED: darwin // UNSUPPORTED: darwin
#include "test.h" #include "test.h"
#include <ucontext.h> #include <ucontext.h>
char stack[64 * 1024] __attribute__((aligned(16))); char stack[64 * 1024] __attribute__((aligned(16)));
ucontext_t uc, orig_uc[2]; ucontext_t uc, orig_uc[2];
void *fiber, *orig_fiber[2]; void *fiber, *orig_fiber[2];
▲ Show 20 Lines • Show All 43 Lines • ▼ Show 20 Lines for (unsigned i = 0; i < N; i++) {
barrier_wait(&barrier); barrier_wait(&barrier);
} }
pthread_join(t, 0); pthread_join(t, 0);
__tsan_destroy_fiber(fiber); __tsan_destroy_fiber(fiber);
fprintf(stderr, "PASS\n"); fprintf(stderr, "PASS\n");
return 0; return 0;
} }
// CHECK-NOT: WARNING: ThreadSanitizer:
// CHECK: PASS // CHECK: PASS

compiler-rt/test/tsan/ignore_free.cc

// RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not='ThreadSanitizer'
#include "test.h" #include "test.h"
extern "C" { extern "C" {
void AnnotateIgnoreReadsBegin(const char *f, int l); void AnnotateIgnoreReadsBegin(const char *f, int l);
void AnnotateIgnoreReadsEnd(const char *f, int l); void AnnotateIgnoreReadsEnd(const char *f, int l);
void AnnotateIgnoreWritesBegin(const char *f, int l); void AnnotateIgnoreWritesBegin(const char *f, int l);
void AnnotateIgnoreWritesEnd(const char *f, int l); void AnnotateIgnoreWritesEnd(const char *f, int l);
} }
Show All 15 Linesint main() {
free(p); free(p);
AnnotateIgnoreReadsEnd(__FILE__, __LINE__); AnnotateIgnoreReadsEnd(__FILE__, __LINE__);
AnnotateIgnoreWritesEnd(__FILE__, __LINE__); AnnotateIgnoreWritesEnd(__FILE__, __LINE__);
pthread_join(t, 0); pthread_join(t, 0);
fprintf(stderr, "OK\n"); fprintf(stderr, "OK\n");
return 0; return 0;
} }
// CHECK-NOT: WARNING: ThreadSanitizer: data race
// CHECK: OK // CHECK: OK

compiler-rt/test/tsan/ignore_malloc.cc

// RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not='ThreadSanitizer'
#include "test.h" #include "test.h"
extern "C" { extern "C" {
void AnnotateIgnoreReadsBegin(const char *f, int l); void AnnotateIgnoreReadsBegin(const char *f, int l);
void AnnotateIgnoreReadsEnd(const char *f, int l); void AnnotateIgnoreReadsEnd(const char *f, int l);
void AnnotateIgnoreWritesBegin(const char *f, int l); void AnnotateIgnoreWritesBegin(const char *f, int l);
void AnnotateIgnoreWritesEnd(const char *f, int l); void AnnotateIgnoreWritesEnd(const char *f, int l);
} }
Show All 16 Linesint main() {
AnnotateIgnoreWritesEnd(__FILE__, __LINE__); AnnotateIgnoreWritesEnd(__FILE__, __LINE__);
__atomic_store_n(&g, p, __ATOMIC_RELAXED); __atomic_store_n(&g, p, __ATOMIC_RELAXED);
pthread_join(t, 0); pthread_join(t, 0);
delete p; delete p;
fprintf(stderr, "OK\n"); fprintf(stderr, "OK\n");
return 0; return 0;
} }
// CHECK-NOT: WARNING: ThreadSanitizer: data race
// CHECK: OK // CHECK: OK

compiler-rt/test/tsan/ignore_race.cc

// RUN: %clang_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s // RUN: %clang_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not='ThreadSanitizer'
#include "test.h" #include "test.h"
int Global; int Global;
extern "C" void AnnotateIgnoreWritesBegin(const char *f, int l); extern "C" void AnnotateIgnoreWritesBegin(const char *f, int l);
extern "C" void AnnotateIgnoreWritesEnd(const char *f, int l); extern "C" void AnnotateIgnoreWritesEnd(const char *f, int l);
extern "C" void AnnotateIgnoreReadsBegin(const char *f, int l); extern "C" void AnnotateIgnoreReadsBegin(const char *f, int l);
extern "C" void AnnotateIgnoreReadsEnd(const char *f, int l); extern "C" void AnnotateIgnoreReadsEnd(const char *f, int l);
Show All 22 Lines

compiler-rt/test/tsan/java_alloc.cc

// RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not='ThreadSanitizer'
#include "java.h" #include "java.h"
int const kHeapSize = 1024 * 1024; int const kHeapSize = 1024 * 1024;
void stress(jptr addr) { void stress(jptr addr) {
for (jptr sz = 8; sz <= 32; sz <<= 1) { for (jptr sz = 8; sz <= 32; sz <<= 1) {
for (jptr i = 0; i < kHeapSize / 4 / sz; i++) { for (jptr i = 0; i < kHeapSize / 4 / sz; i++) {
__tsan_java_alloc(addr + i * sz, sz); __tsan_java_alloc(addr + i * sz, sz);
Show All 18 Linesint main() {
if (__tsan_java_fini() != 0) { if (__tsan_java_fini() != 0) {
fprintf(stderr, "FAILED\n"); fprintf(stderr, "FAILED\n");
return 1; return 1;
} }
fprintf(stderr, "DONE\n"); fprintf(stderr, "DONE\n");
return 0; return 0;
} }
// CHECK-NOT: WARNING: ThreadSanitizer: data race
// CHECK-NOT: FAILED // CHECK-NOT: FAILED
// CHECK: DONE // CHECK: DONE

compiler-rt/test/tsan/java_finalizer.cc

// RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not='ThreadSanitizer'
#include "java.h" #include "java.h"
void *Thread(void *p) { void *Thread(void *p) {
barrier_wait(&barrier); barrier_wait(&barrier);
__tsan_java_finalize(); __tsan_java_finalize();
*(int*)p = 42; *(int*)p = 42;
return 0; return 0;
} }
Show All 10 Linesint main() {
*(int*)jheap = 43; *(int*)jheap = 43;
barrier_wait(&barrier); barrier_wait(&barrier);
pthread_join(th, 0); pthread_join(th, 0);
__tsan_java_free(jheap, kBlockSize); __tsan_java_free(jheap, kBlockSize);
fprintf(stderr, "DONE\n"); fprintf(stderr, "DONE\n");
return __tsan_java_fini(); return __tsan_java_fini();
} }
// CHECK-NOT: WARNING: ThreadSanitizer: data race
// CHECK: DONE // CHECK: DONE

compiler-rt/test/tsan/java_heap_init.cc

// RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not='ThreadSanitizer'
#include "java.h" #include "java.h"
#include <errno.h> #include <errno.h>
#include <sys/mman.h> #include <sys/mman.h>
int main() { int main() {
// Test that munmap interceptor resets meta shadow for the memory range. // Test that munmap interceptor resets meta shadow for the memory range.
// Previously __tsan_java_move failed because it encountered non-zero meta // Previously __tsan_java_move failed because it encountered non-zero meta
// shadow for the destination. // shadow for the destination.
Show All 9 Linesint main() {
if (jheap == (jptr)MAP_FAILED) if (jheap == (jptr)MAP_FAILED)
return printf("second mmap failed with %d\n", errno); return printf("second mmap failed with %d\n", errno);
__tsan_java_init(jheap, kHeapSize); __tsan_java_init(jheap, kHeapSize);
__tsan_java_move(jheap + 16, jheap, 16); __tsan_java_move(jheap + 16, jheap, 16);
fprintf(stderr, "DONE\n"); fprintf(stderr, "DONE\n");
return __tsan_java_fini(); return __tsan_java_fini();
} }
// CHECK-NOT: WARNING: ThreadSanitizer: data race
// CHECK: DONE // CHECK: DONE

compiler-rt/test/tsan/java_lock.cc

// RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not='ThreadSanitizer'
#include "java.h" #include "java.h"
jptr varaddr; jptr varaddr;
jptr lockaddr; jptr lockaddr;
void *Thread(void *p) { void *Thread(void *p) {
barrier_wait(&barrier); barrier_wait(&barrier);
__tsan_java_mutex_lock(lockaddr); __tsan_java_mutex_lock(lockaddr);
Show All 18 Linesint main() {
__tsan_java_mutex_unlock(lockaddr); __tsan_java_mutex_unlock(lockaddr);
barrier_wait(&barrier); barrier_wait(&barrier);
pthread_join(th, 0); pthread_join(th, 0);
__tsan_java_free(jheap, kBlockSize); __tsan_java_free(jheap, kBlockSize);
fprintf(stderr, "DONE\n"); fprintf(stderr, "DONE\n");
return __tsan_java_fini(); return __tsan_java_fini();
} }
// CHECK-NOT: WARNING: ThreadSanitizer: data race
// CHECK: DONE // CHECK: DONE

compiler-rt/test/tsan/java_lock_move.cc

// RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not='ThreadSanitizer'
#include "java.h" #include "java.h"
jptr varaddr; jptr varaddr;
jptr lockaddr; jptr lockaddr;
jptr varaddr2; jptr varaddr2;
jptr lockaddr2; jptr lockaddr2;
void *Thread(void *p) { void *Thread(void *p) {
Show All 24 Linesint main() {
__tsan_java_move(varaddr, varaddr2, kBlockSize); __tsan_java_move(varaddr, varaddr2, kBlockSize);
barrier_wait(&barrier); barrier_wait(&barrier);
pthread_join(th, 0); pthread_join(th, 0);
__tsan_java_free(varaddr2, kBlockSize); __tsan_java_free(varaddr2, kBlockSize);
fprintf(stderr, "DONE\n"); fprintf(stderr, "DONE\n");
return __tsan_java_fini(); return __tsan_java_fini();
} }
// CHECK-NOT: WARNING: ThreadSanitizer: data race
// CHECK: DONE // CHECK: DONE

compiler-rt/test/tsan/java_lock_rec.cc

// RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not='ThreadSanitizer'
#include "java.h" #include "java.h"
jptr varaddr; jptr varaddr;
jptr lockaddr; jptr lockaddr;
void *Thread(void *p) { void *Thread(void *p) {
__tsan_java_mutex_lock(lockaddr); __tsan_java_mutex_lock(lockaddr);
__tsan_java_mutex_lock(lockaddr); __tsan_java_mutex_lock(lockaddr);
Show All 37 Linesint main() {
__tsan_java_mutex_unlock(lockaddr); __tsan_java_mutex_unlock(lockaddr);
barrier_wait(&barrier); barrier_wait(&barrier);
pthread_join(th, 0); pthread_join(th, 0);
__tsan_java_free(jheap, kBlockSize); __tsan_java_free(jheap, kBlockSize);
fprintf(stderr, "DONE\n"); fprintf(stderr, "DONE\n");
return __tsan_java_fini(); return __tsan_java_fini();
} }
// CHECK-NOT: WARNING: ThreadSanitizer: data race
// CHECK-NOT: FAILED // CHECK-NOT: FAILED
// CHECK: DONE // CHECK: DONE

compiler-rt/test/tsan/java_move_overlap.cc

// RUN: %clangxx_tsan -O1 %s -o %t // RUN: %clangxx_tsan -O1 %s -o %t
// RUN: %run %t 2>&1 | FileCheck %s // RUN: %run %t 2>&1 | FileCheck %s --implicit-check-not='ThreadSanitizer'
// RUN: %run %t arg 2>&1 | FileCheck %s // RUN: %run %t arg 2>&1 | FileCheck %s --implicit-check-not='ThreadSanitizer'
#include "java.h" #include "java.h"
jptr varaddr1_old; jptr varaddr1_old;
jptr varaddr2_old; jptr varaddr2_old;
jptr lockaddr1_old; jptr lockaddr1_old;
jptr lockaddr2_old; jptr lockaddr2_old;
jptr varaddr1_new; jptr varaddr1_new;
jptr varaddr2_new; jptr varaddr2_new;
▲ Show 20 Lines • Show All 53 Lines • ▼ Show 20 Linesint main(int argc, char **argv) {
__tsan_java_move(varaddr1_old, varaddr1_new, kBlockSize); __tsan_java_move(varaddr1_old, varaddr1_new, kBlockSize);
barrier_wait(&barrier); barrier_wait(&barrier);
pthread_join(th, 0); pthread_join(th, 0);
__tsan_java_free(varaddr1_new, kBlockSize); __tsan_java_free(varaddr1_new, kBlockSize);
fprintf(stderr, "DONE\n"); fprintf(stderr, "DONE\n");
return __tsan_java_fini(); return __tsan_java_fini();
} }
// CHECK-NOT: WARNING: ThreadSanitizer: data race
// CHECK: DONE // CHECK: DONE

compiler-rt/test/tsan/java_rwlock.cc

// RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not='ThreadSanitizer'
#include "java.h" #include "java.h"
jptr varaddr; jptr varaddr;
jptr lockaddr; jptr lockaddr;
void *Thread(void *p) { void *Thread(void *p) {
barrier_wait(&barrier); barrier_wait(&barrier);
__tsan_java_mutex_read_lock(lockaddr); __tsan_java_mutex_read_lock(lockaddr);
Show All 18 Linesint main() {
__tsan_java_mutex_unlock(lockaddr); __tsan_java_mutex_unlock(lockaddr);
barrier_wait(&barrier); barrier_wait(&barrier);
pthread_join(th, 0); pthread_join(th, 0);
__tsan_java_free(jheap, kBlockSize); __tsan_java_free(jheap, kBlockSize);
fprintf(stderr, "DONE\n"); fprintf(stderr, "DONE\n");
return __tsan_java_fini(); return __tsan_java_fini();
} }
// CHECK-NOT: WARNING: ThreadSanitizer: data race
// CHECK: DONE // CHECK: DONE

compiler-rt/test/tsan/java_volatile.cc

// RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not='ThreadSanitizer'
#include "java.h" #include "java.h"
jptr varaddr; jptr varaddr;
jptr lockaddr; jptr lockaddr;
void *Thread(void *p) { void *Thread(void *p) {
while (__atomic_load_n((int*)lockaddr, __ATOMIC_RELAXED) == 0) while (__atomic_load_n((int*)lockaddr, __ATOMIC_RELAXED) == 0)
usleep(1000); // spin-wait usleep(1000); // spin-wait
Show All 23 Linesint main() {
__tsan_java_release_store(lockaddr); __tsan_java_release_store(lockaddr);
__atomic_store_n((int*)lockaddr, 1, __ATOMIC_RELAXED); __atomic_store_n((int*)lockaddr, 1, __ATOMIC_RELAXED);
pthread_join(th, 0); pthread_join(th, 0);
__tsan_java_free(jheap, kBlockSize); __tsan_java_free(jheap, kBlockSize);
fprintf(stderr, "DONE\n"); fprintf(stderr, "DONE\n");
return __tsan_java_fini(); return __tsan_java_fini();
} }
// CHECK-NOT: WARNING: ThreadSanitizer: data race
// CHECK: DONE // CHECK: DONE

compiler-rt/test/tsan/libcxx/std_shared_ptr.cc

// RUN: %clangxx_tsan -O1 %s %link_libcxx_tsan -o %t && %run %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s %link_libcxx_tsan -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not='ThreadSanitizer'
#include <stdio.h> #include <stdio.h>
#include <memory> #include <memory>
#include <thread> #include <thread>
int main() { int main() {
int v1 = 0; int v1 = 0;
int v2 = 0; int v2 = 0;
std::thread t1; std::thread t1;
std::thread t2; std::thread t2;
{ {
auto thingy = std::make_shared<int>(42); auto thingy = std::make_shared<int>(42);
t1 = std::thread([thingy, &v1] { v1 = *thingy; }); t1 = std::thread([thingy, &v1] { v1 = *thingy; });
t2 = std::thread([thingy, &v2] { v2 = *thingy; }); t2 = std::thread([thingy, &v2] { v2 = *thingy; });
} }
t1.join(); t1.join();
t2.join(); t2.join();
printf("%d %d\n", v1, v2); printf("%d %d\n", v1, v2);
// CHECK-NOT: ThreadSanitizer: data race
// CHECK: 42 42 // CHECK: 42 42
return 0; return 0;
} }

compiler-rt/test/tsan/libdispatch/after.c

// RUN: %clang_tsan %s -o %t // RUN: %clang_tsan %s -o %t
// RUN: %run %t 2>&1 | FileCheck %s // RUN: %run %t 2>&1 | FileCheck %s --implicit-check-not='ThreadSanitizer'
#include "dispatch/dispatch.h" #include "dispatch/dispatch.h"
#include <stdio.h> #include <stdio.h>
long my_global; long my_global;
long my_global2; long my_global2;
dispatch_semaphore_t done; dispatch_semaphore_t done;
Show All 23 Linesint main(int argc, const char *argv[]) {
dispatch_semaphore_wait(done, DISPATCH_TIME_FOREVER); dispatch_semaphore_wait(done, DISPATCH_TIME_FOREVER);
dispatch_semaphore_wait(done, DISPATCH_TIME_FOREVER); dispatch_semaphore_wait(done, DISPATCH_TIME_FOREVER);
fprintf(stderr, "done\n"); fprintf(stderr, "done\n");
return 0; return 0;
} }
// CHECK: start // CHECK: start
// CHECK: done // CHECK: done
// CHECK-NOT: WARNING: ThreadSanitizer

compiler-rt/test/tsan/libdispatch/async-norace.c

// RUN: %clang_tsan %s -o %t // RUN: %clang_tsan %s -o %t
// RUN: %run %t 2>&1 | FileCheck %s // RUN: %run %t 2>&1 | FileCheck %s --implicit-check-not='ThreadSanitizer'
#include "dispatch/dispatch.h" #include "dispatch/dispatch.h"
#include <stdio.h> #include <stdio.h>
long global; long global;
int main() { int main() {
fprintf(stderr, "Hello world.\n"); fprintf(stderr, "Hello world.\n");
dispatch_semaphore_t done = dispatch_semaphore_create(0); dispatch_semaphore_t done = dispatch_semaphore_create(0);
global = 42; global = 42;
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{ dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
global = 43; global = 43;
dispatch_semaphore_signal(done); dispatch_semaphore_signal(done);
}); });
dispatch_semaphore_wait(done, DISPATCH_TIME_FOREVER); dispatch_semaphore_wait(done, DISPATCH_TIME_FOREVER);
fprintf(stderr, "Done.\n"); fprintf(stderr, "Done.\n");
} }
// CHECK: Hello world. // CHECK: Hello world.
// CHECK: Done. // CHECK: Done.
// CHECK-NOT: WARNING: ThreadSanitizer

compiler-rt/test/tsan/libdispatch/barrier.c

// RUN: %clang_tsan %s -o %t // RUN: %clang_tsan %s -o %t
// RUN: %run %t 2>&1 | FileCheck %s // RUN: %run %t 2>&1 | FileCheck %s --implicit-check-not='ThreadSanitizer'
#include "dispatch/dispatch.h" #include "dispatch/dispatch.h"
#include "../test.h" #include "../test.h"
long global; long global;
int main() { int main() {
Show All 28 Linesint main() {
}); });
dispatch_semaphore_wait(done, DISPATCH_TIME_FOREVER); dispatch_semaphore_wait(done, DISPATCH_TIME_FOREVER);
fprintf(stderr, "Done.\n"); fprintf(stderr, "Done.\n");
} }
// CHECK: Hello world. // CHECK: Hello world.
// CHECK: Done. // CHECK: Done.
// CHECK-NOT: WARNING: ThreadSanitizer

compiler-rt/test/tsan/libdispatch/blocks.c

// RUN: %clang_tsan %s -o %t // RUN: %clang_tsan %s -o %t
// RUN: %run %t 2>&1 | FileCheck %s // RUN: %run %t 2>&1 | FileCheck %s --implicit-check-not='ThreadSanitizer'
#include "dispatch/dispatch.h" #include "dispatch/dispatch.h"
#include <stdio.h> #include <stdio.h>
#include <assert.h> #include <assert.h>
int main() { int main() {
fprintf(stderr, "start\n"); fprintf(stderr, "start\n");
Show All 17 Linesint main() {
dispatch_semaphore_wait(done, DISPATCH_TIME_FOREVER); dispatch_semaphore_wait(done, DISPATCH_TIME_FOREVER);
fprintf(stderr, "done\n"); fprintf(stderr, "done\n");
} }
// CHECK: start // CHECK: start
// CHECK: block_var = 42 // CHECK: block_var = 42
// CHECK: done // CHECK: done
// CHECK-NOT: WARNING: ThreadSanitizer
// CHECK-NOT: CHECK failed

compiler-rt/test/tsan/libdispatch/fd.c

// RUN: %clang_tsan %s -o %t // RUN: %clang_tsan %s -o %t
// RUN: %run %t 2>&1 | FileCheck %s // RUN: %run %t 2>&1 | FileCheck %s --implicit-check-not='ThreadSanitizer'
#include <dispatch/dispatch.h> #include <dispatch/dispatch.h>
#include <stdio.h> #include <stdio.h>
long my_global = 0; long my_global = 0;
int main(int argc, const char *argv[]) { int main(int argc, const char *argv[]) {
▲ Show 20 Lines • Show All 42 Lines • ▼ Show 20 Linesint main(int argc, const char *argv[]) {
dispatch_semaphore_wait(sem, DISPATCH_TIME_FOREVER); dispatch_semaphore_wait(sem, DISPATCH_TIME_FOREVER);
my_global++; my_global++;
fprintf(stderr, "Done.\n"); fprintf(stderr, "Done.\n");
return 0; return 0;
} }
// CHECK: Hello world. // CHECK: Hello world.
// CHECK-NOT: WARNING: ThreadSanitizer
// CHECK: Done. // CHECK: Done.

compiler-rt/test/tsan/libdispatch/groups-norace.c

// RUN: %clang_tsan %s -o %t // RUN: %clang_tsan %s -o %t
// RUN: %run %t 2>&1 | FileCheck %s // RUN: %run %t 2>&1 | FileCheck %s --implicit-check-not='ThreadSanitizer'
#include "dispatch/dispatch.h" #include "dispatch/dispatch.h"
#include <stdio.h> #include <stdio.h>
long global; long global;
int main() { int main() {
Show All 32 Linesint main() {
}); });
dispatch_semaphore_wait(done, DISPATCH_TIME_FOREVER); dispatch_semaphore_wait(done, DISPATCH_TIME_FOREVER);
fprintf(stderr, "Done.\n"); fprintf(stderr, "Done.\n");
} }
// CHECK: Hello world. // CHECK: Hello world.
// CHECK: Done. // CHECK: Done.
// CHECK-NOT: WARNING: ThreadSanitizer

compiler-rt/test/tsan/libdispatch/io-barrier.c

// RUN: %clang_tsan %s -o %t // RUN: %clang_tsan %s -o %t
// RUN: %run %t 2>&1 | FileCheck %s // RUN: %run %t 2>&1 | FileCheck %s --implicit-check-not='ThreadSanitizer'
#include <dispatch/dispatch.h> #include <dispatch/dispatch.h>
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
dispatch_queue_t queue; dispatch_queue_t queue;
dispatch_data_t data; dispatch_data_t data;
Show All 30 Linesint main(int argc, const char *argv[]) {
dispatch_semaphore_wait(sem, DISPATCH_TIME_FOREVER); dispatch_semaphore_wait(sem, DISPATCH_TIME_FOREVER);
dispatch_io_close(channel, 0); dispatch_io_close(channel, 0);
fprintf(stderr, "Done.\n"); fprintf(stderr, "Done.\n");
return 0; return 0;
} }
// CHECK: Hello world. // CHECK: Hello world.
// CHECK-NOT: WARNING: ThreadSanitizer
// CHECK: Done. // CHECK: Done.

compiler-rt/test/tsan/libdispatch/io-cleanup.c

// RUN: %clang_tsan %s -o %t // RUN: %clang_tsan %s -o %t
// RUN: %run %t 2>&1 | FileCheck %s // RUN: %run %t 2>&1 | FileCheck %s --implicit-check-not='ThreadSanitizer'
#include <dispatch/dispatch.h> #include <dispatch/dispatch.h>
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
long my_global = 0; long my_global = 0;
Show All 38 Linesint main(int argc, const char *argv[]) {
dispatch_io_close(other_channel, 0); dispatch_io_close(other_channel, 0);
dispatch_semaphore_wait(sem, DISPATCH_TIME_FOREVER); dispatch_semaphore_wait(sem, DISPATCH_TIME_FOREVER);
fprintf(stderr, "Done.\n"); fprintf(stderr, "Done.\n");
return 0; return 0;
} }
// CHECK: Hello world. // CHECK: Hello world.
// CHECK-NOT: WARNING: ThreadSanitizer
// CHECK: Done. // CHECK: Done.

compiler-rt/test/tsan/libdispatch/io.c

// RUN: %clang_tsan %s -o %t // RUN: %clang_tsan %s -o %t
// RUN: %run %t 2>&1 | FileCheck %s // RUN: %run %t 2>&1 | FileCheck %s --implicit-check-not='ThreadSanitizer'
#include <dispatch/dispatch.h> #include <dispatch/dispatch.h>
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
dispatch_queue_t queue; dispatch_queue_t queue;
dispatch_data_t data; dispatch_data_t data;
▲ Show 20 Lines • Show All 99 Lines • ▼ Show 20 Linesint main(int argc, const char *argv[]) {
test_dispatch_io_read(); test_dispatch_io_read();
test_dispatch_read(); test_dispatch_read();
fprintf(stderr, "Done.\n"); fprintf(stderr, "Done.\n");
return 0; return 0;
} }
// CHECK: Hello world. // CHECK: Hello world.
// CHECK-NOT: WARNING: ThreadSanitizer
// CHECK: Done. // CHECK: Done.

compiler-rt/test/tsan/libdispatch/serial-queue-norace.c

// RUN: %clang_tsan %s -o %t // RUN: %clang_tsan %s -o %t
// RUN: %run %t 2>&1 | FileCheck %s // RUN: %run %t 2>&1 | FileCheck %s --implicit-check-not='ThreadSanitizer'
#include "dispatch/dispatch.h" #include "dispatch/dispatch.h"
#include <stdio.h> #include <stdio.h>
long global; long global;
int main() { int main() {
Show All 19 Linesint main() {
}); });
dispatch_semaphore_wait(done, DISPATCH_TIME_FOREVER); dispatch_semaphore_wait(done, DISPATCH_TIME_FOREVER);
fprintf(stderr, "Done.\n"); fprintf(stderr, "Done.\n");
} }
// CHECK: Hello world. // CHECK: Hello world.
// CHECK: Done. // CHECK: Done.
// CHECK-NOT: WARNING: ThreadSanitizer

compiler-rt/test/tsan/libdispatch/source-cancel.c

// RUN: %clang_tsan %s -o %t // RUN: %clang_tsan %s -o %t
// RUN: %run %t 2>&1 | FileCheck %s // RUN: %run %t 2>&1 | FileCheck %s --implicit-check-not='ThreadSanitizer'
#include "dispatch/dispatch.h" #include "dispatch/dispatch.h"
#include <stdio.h> #include <stdio.h>
long global; long global;
int main(int argc, const char *argv[]) { int main(int argc, const char *argv[]) {
Show All 19 Linesint main(int argc, const char *argv[]) {
dispatch_cancel(source); dispatch_cancel(source);
dispatch_semaphore_wait(done, DISPATCH_TIME_FOREVER); dispatch_semaphore_wait(done, DISPATCH_TIME_FOREVER);
return 0; return 0;
} }
// CHECK: global = 42 // CHECK: global = 42
// CHECK-NOT: WARNING: ThreadSanitizer

compiler-rt/test/tsan/libdispatch/source-cancel2.c

// RUN: %clang_tsan %s -o %t // RUN: %clang_tsan %s -o %t
// RUN: %run %t 2>&1 | FileCheck %s // RUN: %run %t 2>&1 | FileCheck %s --implicit-check-not='ThreadSanitizer'
#include "dispatch/dispatch.h" #include "dispatch/dispatch.h"
#include <stdio.h> #include <stdio.h>
long global; long global;
dispatch_semaphore_t done; dispatch_semaphore_t done;
Show All 22 Linesint main(int argc, const char *argv[]) {
dispatch_cancel(source); dispatch_cancel(source);
dispatch_semaphore_wait(done, DISPATCH_TIME_FOREVER); dispatch_semaphore_wait(done, DISPATCH_TIME_FOREVER);
return 0; return 0;
} }
// CHECK: global = 42 // CHECK: global = 42
// CHECK-NOT: WARNING: ThreadSanitizer

compiler-rt/test/tsan/libdispatch/source-event.c

// RUN: %clang_tsan %s -o %t // RUN: %clang_tsan %s -o %t
// RUN: %run %t 2>&1 | FileCheck %s // RUN: %run %t 2>&1 | FileCheck %s --implicit-check-not='ThreadSanitizer'
#include "dispatch/dispatch.h" #include "dispatch/dispatch.h"
#include <stdio.h> #include <stdio.h>
long global; long global;
int main(int argc, const char *argv[]) { int main(int argc, const char *argv[]) {
Show All 18 Linesint main(int argc, const char *argv[]) {
dispatch_resume(source); dispatch_resume(source);
dispatch_semaphore_wait(done, DISPATCH_TIME_FOREVER); dispatch_semaphore_wait(done, DISPATCH_TIME_FOREVER);
return 0; return 0;
} }
// CHECK: global = 42 // CHECK: global = 42
// CHECK-NOT: WARNING: ThreadSanitizer

compiler-rt/test/tsan/libdispatch/source-event2.c

// RUN: %clang_tsan %s -o %t // RUN: %clang_tsan %s -o %t
// RUN: %run %t 2>&1 | FileCheck %s // RUN: %run %t 2>&1 | FileCheck %s --implicit-check-not='ThreadSanitizer'
#include "dispatch/dispatch.h" #include "dispatch/dispatch.h"
#include <stdio.h> #include <stdio.h>
long global; long global;
dispatch_semaphore_t done; dispatch_semaphore_t done;
Show All 21 Linesint main(int argc, const char *argv[]) {
dispatch_resume(source); dispatch_resume(source);
dispatch_semaphore_wait(done, DISPATCH_TIME_FOREVER); dispatch_semaphore_wait(done, DISPATCH_TIME_FOREVER);
return 0; return 0;
} }
// CHECK: global = 42 // CHECK: global = 42
// CHECK-NOT: WARNING: ThreadSanitizer

compiler-rt/test/tsan/libdispatch/source-registration.c

// RUN: %clang_tsan %s -o %t // RUN: %clang_tsan %s -o %t
// RUN: %run %t 2>&1 | FileCheck %s // RUN: %run %t 2>&1 | FileCheck %s --implicit-check-not='ThreadSanitizer'
#include "dispatch/dispatch.h" #include "dispatch/dispatch.h"
#include <stdio.h> #include <stdio.h>
long global; long global;
int main(int argc, const char *argv[]) { int main(int argc, const char *argv[]) {
Show All 16 Linesint main(int argc, const char *argv[]) {
dispatch_resume(source); dispatch_resume(source);
dispatch_semaphore_wait(done, DISPATCH_TIME_FOREVER); dispatch_semaphore_wait(done, DISPATCH_TIME_FOREVER);
return 0; return 0;
} }
// CHECK: global = 42 // CHECK: global = 42
// CHECK-NOT: WARNING: ThreadSanitizer

compiler-rt/test/tsan/libdispatch/source-registration2.c

// RUN: %clang_tsan %s -o %t // RUN: %clang_tsan %s -o %t
// RUN: %run %t 2>&1 | FileCheck %s // RUN: %run %t 2>&1 | FileCheck %s --implicit-check-not='ThreadSanitizer'
#include "dispatch/dispatch.h" #include "dispatch/dispatch.h"
#include <stdio.h> #include <stdio.h>
long global; long global;
dispatch_semaphore_t done; dispatch_semaphore_t done;
Show All 19 Linesint main(int argc, const char *argv[]) {
dispatch_resume(source); dispatch_resume(source);
dispatch_semaphore_wait(done, DISPATCH_TIME_FOREVER); dispatch_semaphore_wait(done, DISPATCH_TIME_FOREVER);
return 0; return 0;
} }
// CHECK: global = 42 // CHECK: global = 42
// CHECK-NOT: WARNING: ThreadSanitizer

compiler-rt/test/tsan/libdispatch/sync-norace.c

// RUN: %clang_tsan %s -o %t // RUN: %clang_tsan %s -o %t
// RUN: %run %t 2>&1 | FileCheck %s // RUN: %run %t 2>&1 | FileCheck %s --implicit-check-not='ThreadSanitizer'
#include "dispatch/dispatch.h" #include "dispatch/dispatch.h"
#include <stdio.h> #include <stdio.h>
long global; long global;
static const long nIter = 1000; static const long nIter = 1000;
Show All 18 Linesint main() {
} }
dispatch_semaphore_wait(done, DISPATCH_TIME_FOREVER); dispatch_semaphore_wait(done, DISPATCH_TIME_FOREVER);
fprintf(stderr, "Done.\n"); fprintf(stderr, "Done.\n");
} }
// CHECK: Hello world. // CHECK: Hello world.
// CHECK: Done. // CHECK: Done.
// CHECK-NOT: WARNING: ThreadSanitizer

compiler-rt/test/tsan/libdispatch/target-queue-norace.c

// RUN: %clang_tsan %s -o %t // RUN: %clang_tsan %s -o %t
// RUN: %run %t 2>&1 | FileCheck %s // RUN: %run %t 2>&1 | FileCheck %s --implicit-check-not='ThreadSanitizer'
#include "dispatch/dispatch.h" #include "dispatch/dispatch.h"
#include <stdio.h> #include <stdio.h>
long global; long global;
int main(int argc, const char *argv[]) { int main(int argc, const char *argv[]) {
Show All 21 Lines for (int i = 0; i < 100000; i++) {
}); });
} }
dispatch_semaphore_wait(done, DISPATCH_TIME_FOREVER); dispatch_semaphore_wait(done, DISPATCH_TIME_FOREVER);
fprintf(stderr, "Done.\n"); fprintf(stderr, "Done.\n");
return 0; return 0;
} }
// CHECK-NOT: WARNING: ThreadSanitizer
// CHECK: Done. // CHECK: Done.

compiler-rt/test/tsan/mutex_annotations.cc

// RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not='ThreadSanitizer'
#include "test.h" #include "test.h"
// Test that a linker-initialized mutex can be created/destroyed while in use. // Test that a linker-initialized mutex can be created/destroyed while in use.
// Stub for testing, just invokes annotations. // Stub for testing, just invokes annotations.
// Meant to be synchronized externally with test barrier. // Meant to be synchronized externally with test barrier.
class Mutex { class Mutex {
public: public:
Show All 30 Linesint main() {
m.Lock(); m.Lock();
m.Destroy(); m.Destroy();
m.Unlock(); m.Unlock();
fprintf(stderr, "DONE\n"); fprintf(stderr, "DONE\n");
return 0; return 0;
} }
// CHECK-NOT: WARNING: ThreadSanitizer:
// CHECK: DONE // CHECK: DONE

compiler-rt/test/tsan/race_on_speculative_load.cc

// RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not='ThreadSanitizer'
// Regtest for https://github.com/google/sanitizers/issues/447 // Regtest for https://github.com/google/sanitizers/issues/447
// This is a correct program and tsan should not report a race. // This is a correct program and tsan should not report a race.
#include "test.h" #include "test.h"
int g; int g;
__attribute__((noinline)) __attribute__((noinline))
int foo(int cond) { int foo(int cond) {
if (cond) if (cond)
Show All 10 Lines
int main() { int main() {
barrier_init(&barrier, 2); barrier_init(&barrier, 2);
pthread_t t; pthread_t t;
pthread_create(&t, 0, Thread1, 0); pthread_create(&t, 0, Thread1, 0);
g = 1; g = 1;
barrier_wait(&barrier); barrier_wait(&barrier);
pthread_join(t, 0); pthread_join(t, 0);
fprintf(stderr, "PASS\n"); fprintf(stderr, "PASS\n");
// CHECK-NOT: ThreadSanitizer: data race
// CHECK: PASS // CHECK: PASS
} }

compiler-rt/test/tsan/race_top_suppression.cc

// RUN: echo "race_top:TopFunction" > %t.supp // RUN: echo "race_top:TopFunction" > %t.supp
// RUN: %clangxx_tsan -O1 %s -o %t // RUN: %clangxx_tsan -O1 %s -o %t
// RUN: %env_tsan_opts=suppressions='%t.supp' %run %t 2>&1 | FileCheck %s // RUN: %env_tsan_opts=suppressions='%t.supp' %run %t 2>&1 | FileCheck %s --implicit-check-not='ThreadSanitizer'
// RUN: rm %t.supp // RUN: rm %t.supp
#include "test.h" #include "test.h"
int Global; int Global;
void TopFunction(int *p) { void TopFunction(int *p) {
*p = 1; *p = 1;
} }
Show All 18 Lines

compiler-rt/test/tsan/real_deadlock_detector_stress_test.cc

// RUN: %clangxx_tsan -O1 %s %link_libcxx_tsan -o %t && %run %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s %link_libcxx_tsan -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not='ThreadSanitizer'
#include <pthread.h> #include <pthread.h>
#include <stdlib.h> #include <stdlib.h>
#include <stdio.h> #include <stdio.h>
#include <unistd.h> #include <unistd.h>
#include <time.h> #include <time.h>
#include <errno.h> #include <errno.h>
#include <vector> #include <vector>
▲ Show 20 Lines • Show All 167 Lines • ▼ Show 20 Linesint main() {
for (int i = 0; i < kThreads; i++) for (int i = 0; i < kThreads; i++)
pthread_create(&t[i], 0, Thread, (void*)(unsigned long)rand()); pthread_create(&t[i], 0, Thread, (void*)(unsigned long)rand());
for (int i = 0; i < kThreads; i++) for (int i = 0; i < kThreads; i++)
pthread_join(t[i], 0); pthread_join(t[i], 0);
fprintf(stderr, "DONE\n"); fprintf(stderr, "DONE\n");
return 0; return 0;
} }
// CHECK-NOT: WARNING: ThreadSanitizer
// CHECK: DONE // CHECK: DONE

compiler-rt/test/tsan/signal_block.cc

// RUN: %clang_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s // RUN: %clang_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not='ThreadSanitizer'
// Test that a signal is not delivered when it is blocked. // Test that a signal is not delivered when it is blocked.
#include "test.h" #include "test.h"
#include <semaphore.h> #include <semaphore.h>
#include <signal.h> #include <signal.h>
#include <errno.h> #include <errno.h>
Show All 40 Linesint main(int argc, char** argv) {
for (int i = 0; i < 100000; i++) for (int i = 0; i < 100000; i++)
pthread_kill(th, SIGUSR1); pthread_kill(th, SIGUSR1);
__atomic_store_n(&stop, 1, __ATOMIC_RELAXED); __atomic_store_n(&stop, 1, __ATOMIC_RELAXED);
pthread_join(th, 0); pthread_join(th, 0);
fprintf(stderr, "DONE\n"); fprintf(stderr, "DONE\n");
return 0; return 0;
} }
// CHECK-NOT: ThreadSanitizer CHECK
// CHECK-NOT: WARNING: ThreadSanitizer:
// CHECK: DONE // CHECK: DONE

compiler-rt/test/tsan/signal_longjmp.cc

// RUN: %clang_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s // RUN: %clang_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not='ThreadSanitizer'
// Test case for longjumping out of signal handler: // Test case for longjumping out of signal handler:
// https://github.com/google/sanitizers/issues/482 // https://github.com/google/sanitizers/issues/482
// This test fails on powerpc64 BE (VMA=44), a segmentation fault // This test fails on powerpc64 BE (VMA=44), a segmentation fault
// error happens at the second assignment // error happens at the second assignment
// "((volatile int *volatile)mem)[1] = 1". // "((volatile int *volatile)mem)[1] = 1".
// XFAIL: powerpc64-unknown-linux-gnu // XFAIL: powerpc64-unknown-linux-gnu
▲ Show 20 Lines • Show All 61 Lines • ▼ Show 20 Linesint main() {
free((void*)p); free((void*)p);
munmap(p, 4096); munmap(p, 4096);
fprintf(stderr, "DONE\n"); fprintf(stderr, "DONE\n");
return 0; return 0;
} }
// CHECK-NOT: WARNING: ThreadSanitizer
// CHECK: DONE // CHECK: DONE

compiler-rt/test/tsan/signal_recursive.cc

// RUN: %clang_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s // RUN: %clang_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not='ThreadSanitizer'
// Test case for recursive signal handlers, adopted from: // Test case for recursive signal handlers, adopted from:
// https://github.com/google/sanitizers/issues/478 // https://github.com/google/sanitizers/issues/478
// REQUIRES: disabled // REQUIRES: disabled
#include "test.h" #include "test.h"
#include <semaphore.h> #include <semaphore.h>
▲ Show 20 Lines • Show All 106 Lines • ▼ Show 20 Linesint main(int argc, const char *argv[]) {
CollectGarbage(busy_thread); CollectGarbage(busy_thread);
if (pthread_join(busy_thread, 0) != 0) if (pthread_join(busy_thread, 0) != 0)
fail("pthread_join failed"); fail("pthread_join failed");
fprintf(stderr, "DONE\n"); fprintf(stderr, "DONE\n");
return 0; return 0;
} }
// CHECK-NOT: FAILED // CHECK-NOT: FAILED
// CHECK-NOT: ThreadSanitizer CHECK failed
// CHECK-NOT: WARNING: ThreadSanitizer:
// CHECK: DONE // CHECK: DONE

compiler-rt/test/tsan/signal_reset.cc

// RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not='ThreadSanitizer'
// UNSUPPORTED: darwin // UNSUPPORTED: darwin
#include <pthread.h> #include <pthread.h>
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <signal.h> #include <signal.h>
#include <sys/types.h> #include <sys/types.h>
#include <sys/time.h> #include <sys/time.h>
#include <unistd.h> #include <unistd.h>
▲ Show 20 Lines • Show All 55 Lines • ▼ Show 20 Linesint main() {
pthread_join(th[1], 0); pthread_join(th[1], 0);
__atomic_store_n(&stop, 1, __ATOMIC_RELAXED); __atomic_store_n(&stop, 1, __ATOMIC_RELAXED);
pthread_join(th[0], 0); pthread_join(th[0], 0);
fprintf(stderr, "DONE\n"); fprintf(stderr, "DONE\n");
return 0; return 0;
} }
// CHECK-NOT: WARNING: ThreadSanitizer:
// CHECK: DONE // CHECK: DONE
// CHECK-NOT: WARNING: ThreadSanitizer:

compiler-rt/test/tsan/signal_sync.cc

// RUN: %clang_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s // RUN: %clang_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not='ThreadSanitizer'
// UNSUPPORTED: darwin // UNSUPPORTED: darwin
#include "test.h" #include "test.h"
#include <signal.h> #include <signal.h>
#include <sys/types.h> #include <sys/types.h>
#include <sys/time.h> #include <sys/time.h>
#include <errno.h> #include <errno.h>
volatile int X; volatile int X;
Show All 36 Linesint main() {
for (int i = 0; i < kThreads; i++) for (int i = 0; i < kThreads; i++)
pthread_join(th[i], 0); pthread_join(th[i], 0);
fprintf(stderr, "DONE\n"); fprintf(stderr, "DONE\n");
return 0; return 0;
} }
// CHECK-NOT: WARNING: ThreadSanitizer:
// CHECK: DONE // CHECK: DONE
// CHECK-NOT: WARNING: ThreadSanitizer:

compiler-rt/test/tsan/signal_sync2.cc

// RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not='ThreadSanitizer'
// UNSUPPORTED: darwin // UNSUPPORTED: darwin
#include <pthread.h> #include <pthread.h>
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <signal.h> #include <signal.h>
#include <sys/types.h> #include <sys/types.h>
#include <sys/time.h> #include <sys/time.h>
#include <unistd.h> #include <unistd.h>
▲ Show 20 Lines • Show All 58 Lines • ▼ Show 20 Lines for (int pos = 0; pos < kSignalCount; pos++) {
} }
} }
__atomic_store_n(&done, 1, __ATOMIC_RELAXED); __atomic_store_n(&done, 1, __ATOMIC_RELAXED);
pthread_join(th, 0); pthread_join(th, 0);
fprintf(stderr, "DONE\n"); fprintf(stderr, "DONE\n");
return 0; return 0;
} }
// CHECK-NOT: WARNING: ThreadSanitizer:
// CHECK: DONE // CHECK: DONE

compiler-rt/test/tsan/signal_thread.cc

// RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not='ThreadSanitizer'
// UNSUPPORTED: darwin // UNSUPPORTED: darwin
#include <pthread.h> #include <pthread.h>
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <signal.h> #include <signal.h>
#include <sys/types.h> #include <sys/types.h>
#include <sys/time.h> #include <sys/time.h>
#include <unistd.h> #include <unistd.h>
Show All 33 Lines for (int i = 0; i < 10000; i++) {
pthread_create(&th, 0, thr, 0); pthread_create(&th, 0, thr, 0);
pthread_join(th, 0); pthread_join(th, 0);
} }
fprintf(stderr, "DONE\n"); fprintf(stderr, "DONE\n");
return 0; return 0;
} }
// CHECK-NOT: WARNING: ThreadSanitizer:
// CHECK: DONE // CHECK: DONE
// CHECK-NOT: WARNING: ThreadSanitizer:

compiler-rt/test/tsan/signal_write.cc

// RUN: %clang_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s // RUN: %clang_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not='ThreadSanitizer'
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <signal.h> #include <signal.h>
#include <string.h> #include <string.h>
#include <sys/types.h> #include <sys/types.h>
#include <unistd.h> #include <unistd.h>
static void handler(int, siginfo_t*, void*) { static void handler(int, siginfo_t*, void*) {
const char *str = "HELLO FROM SIGNAL\n"; const char *str = "HELLO FROM SIGNAL\n";
write(2, str, strlen(str)); write(2, str, strlen(str));
} }
int main() { int main() {
struct sigaction act = {}; struct sigaction act = {};
act.sa_sigaction = &handler; act.sa_sigaction = &handler;
sigaction(SIGPROF, &act, 0); sigaction(SIGPROF, &act, 0);
kill(getpid(), SIGPROF); kill(getpid(), SIGPROF);
sleep(1); // let the signal handler run, can't use barrier in sig handler sleep(1); // let the signal handler run, can't use barrier in sig handler
fprintf(stderr, "DONE\n"); fprintf(stderr, "DONE\n");
return 0; return 0;
} }
// CHECK-NOT: WARNING: ThreadSanitizer
// CHECK: HELLO FROM SIGNAL // CHECK: HELLO FROM SIGNAL
// CHECK: DONE // CHECK: DONE

compiler-rt/test/tsan/stack_sync_reuse.cc

// RUN: %clang_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s // RUN: %clang_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not='ThreadSanitizer'
#include "test.h" #include "test.h"
// Test case https://github.com/google/sanitizers/issues/494 // Test case https://github.com/google/sanitizers/issues/494
// Tsan sees false HB edge on address pointed to by syncp variable. // Tsan sees false HB edge on address pointed to by syncp variable.
// It is false because when acquire is done syncp points to a var in one frame, // It is false because when acquire is done syncp points to a var in one frame,
// and during release it points to a var in a different frame. // and during release it points to a var in a different frame.
// The code is somewhat tricky because it prevents compiler from optimizing // The code is somewhat tricky because it prevents compiler from optimizing
// our accesses away, structured to not introduce other data races and // our accesses away, structured to not introduce other data races and
▲ Show 20 Lines • Show All 58 Lines • Show Last 20 Lines

compiler-rt/test/tsan/static_init1.cc

// RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not='ThreadSanitizer'
#include <pthread.h> #include <pthread.h>
#include <stdlib.h> #include <stdlib.h>
#include <stdio.h> #include <stdio.h>
struct P { struct P {
int x; int x;
int y; int y;
}; };
Show All 18 Lines

compiler-rt/test/tsan/static_init2.cc

// RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not='ThreadSanitizer'
#include <pthread.h> #include <pthread.h>
#include <stdlib.h> #include <stdlib.h>
#include <stdio.h> #include <stdio.h>
struct Cache { struct Cache {
int x; int x;
explicit Cache(int x) explicit Cache(int x)
: x(x) { : x(x) {
Show All 24 Lines

compiler-rt/test/tsan/static_init4.cc

// RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not='ThreadSanitizer'
#include <pthread.h> #include <pthread.h>
#include <stdlib.h> #include <stdlib.h>
#include <stdio.h> #include <stdio.h>
#include <sched.h> #include <sched.h>
struct Cache { struct Cache {
int x; int x;
explicit Cache(int x) explicit Cache(int x)
Show All 28 Lines

compiler-rt/test/tsan/static_init5.cc

// RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not='ThreadSanitizer'
#include <pthread.h> #include <pthread.h>
#include <stdlib.h> #include <stdlib.h>
#include <stdio.h> #include <stdio.h>
#include <sched.h> #include <sched.h>
struct Cache { struct Cache {
int x; int x;
explicit Cache(int x) explicit Cache(int x)
Show All 33 Lines

compiler-rt/test/tsan/static_init6.cc

// RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not='ThreadSanitizer'
#include <pthread.h> #include <pthread.h>
#include <stdlib.h> #include <stdlib.h>
#include <stdio.h> #include <stdio.h>
#include <sched.h> #include <sched.h>
struct Cache { struct Cache {
int x; int x;
explicit Cache(int x) explicit Cache(int x)
Show All 33 Lines

compiler-rt/test/tsan/suppressions_global.cc

// RUN: %clang_tsan -O1 %s -o %t && %env_tsan_opts=suppressions='%s.supp' %run %t 2>&1 | FileCheck %s // RUN: %clang_tsan -O1 %s -o %t && %env_tsan_opts=suppressions='%s.supp' %run %t 2>&1 | FileCheck %s --implicit-check-not='ThreadSanitizer'
#include <pthread.h> #include <pthread.h>
#include <stdio.h> #include <stdio.h>
int RacyGlobal; int RacyGlobal;
void *Thread1(void *x) { void *Thread1(void *x) {
RacyGlobal = 42; RacyGlobal = 42;
return NULL; return NULL;
Show All 10 Linesint main() {
pthread_create(&t[1], NULL, Thread2, NULL); pthread_create(&t[1], NULL, Thread2, NULL);
pthread_join(t[0], NULL); pthread_join(t[0], NULL);
pthread_join(t[1], NULL); pthread_join(t[1], NULL);
fprintf(stderr, "OK\n"); fprintf(stderr, "OK\n");
return 0; return 0;
} }
// CHECK-NOT: failed to open suppressions file // CHECK-NOT: failed to open suppressions file
// CHECK-NOT: WARNING: ThreadSanitizer: data race

compiler-rt/test/tsan/suppressions_mutex.cc

// RUN: %clang_tsan -O1 %s -o %t && %env_tsan_opts=suppressions='%s.supp' %run %t 2>&1 | FileCheck %s // RUN: %clang_tsan -O1 %s -o %t && %env_tsan_opts=suppressions='%s.supp' %run %t 2>&1 | FileCheck %s --implicit-check-not='ThreadSanitizer'
#include "test.h" #include "test.h"
void __attribute__((noinline)) suppress_this(pthread_mutex_t *mu) { void __attribute__((noinline)) suppress_this(pthread_mutex_t *mu) {
pthread_mutex_destroy(mu); pthread_mutex_destroy(mu);
} }
int main() { int main() {
pthread_mutex_t mu; pthread_mutex_t mu;
pthread_mutex_init(&mu, 0); pthread_mutex_init(&mu, 0);
pthread_mutex_lock(&mu); pthread_mutex_lock(&mu);
suppress_this(&mu); suppress_this(&mu);
fprintf(stderr, "DONE\n"); fprintf(stderr, "DONE\n");
return 0; return 0;
} }
// CHECK-NOT: failed to open suppressions file // CHECK-NOT: failed to open suppressions file
// CHECK-NOT: WARNING: ThreadSanitizer:
// CHECK: DONE // CHECK: DONE

compiler-rt/test/tsan/suppressions_race.cc

// RUN: %clang_tsan -O1 %s -o %t && %env_tsan_opts=suppressions='%s.supp' %run %t 2>&1 | FileCheck %s // RUN: %clang_tsan -O1 %s -o %t && %env_tsan_opts=suppressions='%s.supp' %run %t 2>&1 | FileCheck %s --implicit-check-not='ThreadSanitizer'
#include "test.h" #include "test.h"
int Global; int Global;
void *Thread1(void *x) { void *Thread1(void *x) {
barrier_wait(&barrier); barrier_wait(&barrier);
Global = 42; Global = 42;
return NULL; return NULL;
Show All 12 Linesint main() {
pthread_create(&t[1], NULL, Thread2, NULL); pthread_create(&t[1], NULL, Thread2, NULL);
pthread_join(t[0], NULL); pthread_join(t[0], NULL);
pthread_join(t[1], NULL); pthread_join(t[1], NULL);
fprintf(stderr, "OK\n"); fprintf(stderr, "OK\n");
return 0; return 0;
} }
// CHECK-NOT: failed to open suppressions file // CHECK-NOT: failed to open suppressions file
// CHECK-NOT: WARNING: ThreadSanitizer: data race

compiler-rt/test/tsan/suppressions_race2.cc

// RUN: %clang_tsan -O1 %s -o %t && %env_tsan_opts=suppressions='%s.supp' %run %t 2>&1 | FileCheck %s // RUN: %clang_tsan -O1 %s -o %t && %env_tsan_opts=suppressions='%s.supp' %run %t 2>&1 | FileCheck %s --implicit-check-not='ThreadSanitizer'
#include "test.h" #include "test.h"
int Global; int Global;
void *Thread1(void *x) { void *Thread1(void *x) {
Global = 42; Global = 42;
barrier_wait(&barrier); barrier_wait(&barrier);
return NULL; return NULL;
Show All 12 Linesint main() {
pthread_create(&t[1], NULL, Thread2, NULL); pthread_create(&t[1], NULL, Thread2, NULL);
pthread_join(t[0], NULL); pthread_join(t[0], NULL);
pthread_join(t[1], NULL); pthread_join(t[1], NULL);
fprintf(stderr, "OK\n"); fprintf(stderr, "OK\n");
return 0; return 0;
} }
// CHECK-NOT: failed to open suppressions file // CHECK-NOT: failed to open suppressions file
// CHECK-NOT: WARNING: ThreadSanitizer: data race

compiler-rt/test/tsan/thread_detach.c

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

compiler-rt/test/tsan/thread_detach2.c

// RUN: %clang_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s // RUN: %clang_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not='ThreadSanitizer'
#include "test.h" #include "test.h"
// Test for https://llvm.org/bugs/show_bug.cgi?id=23235 // Test for https://llvm.org/bugs/show_bug.cgi?id=23235
// The bug was that synchronization between thread creation and thread start // The bug was that synchronization between thread creation and thread start
// is not established if pthread_create is followed by pthread_detach. // is not established if pthread_create is followed by pthread_detach.
int x; int x;
Show All 9 Linesint main() {
x = 43; x = 43;
pthread_create(&t, 0, Thread, 0); pthread_create(&t, 0, Thread, 0);
pthread_detach(t); pthread_detach(t);
barrier_wait(&barrier); barrier_wait(&barrier);
fprintf(stderr, "PASS\n"); fprintf(stderr, "PASS\n");
return 0; return 0;
} }
// CHECK-NOT: WARNING: ThreadSanitizer: data race
// CHECK: PASS // CHECK: PASS

compiler-rt/test/tsan/thread_exit.c

// RUN: %clang_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s // RUN: %clang_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not='ThreadSanitizer'
// Crashes on powerpc64be // Crashes on powerpc64be
// UNSUPPORTED: powerpc64 // UNSUPPORTED: powerpc64
#include "test.h" #include "test.h"
int var; int var;
Show All 10 Linesint main() {
if (retval != &var) { if (retval != &var) {
fprintf(stderr, "Unexpected return value\n"); fprintf(stderr, "Unexpected return value\n");
exit(1); exit(1);
} }
fprintf(stderr, "PASS\n"); fprintf(stderr, "PASS\n");
return 0; return 0;
} }
// CHECK-NOT: WARNING: ThreadSanitizer:
// CHECK: PASS // CHECK: PASS

compiler-rt/test/tsan/thread_leak.c

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

compiler-rt/test/tsan/thread_leak2.c

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

compiler-rt/test/tsan/thread_leak4.c

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

compiler-rt/test/tsan/tsan-vs-gvn.cc

// RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not='ThreadSanitizer'
// RUN: %clangxx_tsan -O2 %s -o %t && %run %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O2 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not='ThreadSanitizer'
// RUN: %clangxx_tsan -O3 %s -o %t && %run %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O3 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not='ThreadSanitizer'
// //
// Check that load widening is not tsan-hostile. // Check that load widening is not tsan-hostile.
#include <pthread.h> #include <pthread.h>
#include <stdio.h> #include <stdio.h>
#include <string.h> #include <string.h>
struct { struct {
int i; int i;
Show All 17 Linesint main() {
memset(&S, 123, sizeof(S)); memset(&S, 123, sizeof(S));
pthread_create(&t[0], NULL, Thread1, NULL); pthread_create(&t[0], NULL, Thread1, NULL);
pthread_create(&t[1], NULL, Thread2, NULL); pthread_create(&t[1], NULL, Thread2, NULL);
pthread_join(t[0], NULL); pthread_join(t[0], NULL);
pthread_join(t[1], NULL); pthread_join(t[1], NULL);
fprintf(stderr, "PASS\n"); fprintf(stderr, "PASS\n");
} }
// CHECK-NOT: WARNING: ThreadSanitizer: data race
// CHECK: PASS // CHECK: PASS

compiler-rt/test/tsan/unaligned_norace.cc

// RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not='ThreadSanitizer'
#include <pthread.h> #include <pthread.h>
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <stdint.h> #include <stdint.h>
uint64_t objs[8*3*3*2][3]; uint64_t objs[8*3*3*2][3];
extern "C" { extern "C" {
▲ Show 20 Lines • Show All 65 Lines • ▼ Show 20 Lines
int main() { int main() {
pthread_t th; pthread_t th;
pthread_create(&th, 0, Thread, 0); pthread_create(&th, 0, Thread, 0);
Test(true); Test(true);
pthread_join(th, 0); pthread_join(th, 0);
fprintf(stderr, "OK\n"); fprintf(stderr, "OK\n");
} }
// CHECK-NOT: WARNING: ThreadSanitizer:
// CHECK: OK // CHECK: OK

compiler-rt/test/tsan/vfork.cc

// RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not='ThreadSanitizer'
#include <pthread.h> #include <pthread.h>
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <unistd.h> #include <unistd.h>
#include <sys/types.h> #include <sys/types.h>
int fds[2]; int fds[2];
int X; int X;
Show All 31 Linesint main() {
pthread_t t[2]; pthread_t t[2];
pthread_create(&t[0], NULL, Thread1, NULL); pthread_create(&t[0], NULL, Thread1, NULL);
pthread_create(&t[1], NULL, Thread2, NULL); pthread_create(&t[1], NULL, Thread2, NULL);
pthread_join(t[0], NULL); pthread_join(t[0], NULL);
pthread_join(t[1], NULL); pthread_join(t[1], NULL);
fprintf(stderr, "DONE\n"); fprintf(stderr, "DONE\n");
} }
// CHECK-NOT: WARNING: ThreadSanitizer: data race
// CHECK-NOT: FAIL to vfork // CHECK-NOT: FAIL to vfork
// CHECK: DONE // CHECK: DONE

compiler-rt/test/tsan/vptr_benign_race.cc

// RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not='ThreadSanitizer'
#include <pthread.h> #include <pthread.h>
#include <stdio.h> #include <stdio.h>
struct A { struct A {
A() { A() {
pthread_mutex_init(&m, 0); pthread_mutex_init(&m, 0);
pthread_cond_init(&c, 0); pthread_cond_init(&c, 0);
signaled = false; signaled = false;
▲ Show 20 Lines • Show All 41 Lines • ▼ Show 20 Linesint main() {
pthread_t t[2]; pthread_t t[2];
pthread_create(&t[0], NULL, Thread1, NULL); pthread_create(&t[0], NULL, Thread1, NULL);
pthread_create(&t[1], NULL, Thread2, NULL); pthread_create(&t[1], NULL, Thread2, NULL);
pthread_join(t[0], NULL); pthread_join(t[0], NULL);
pthread_join(t[1], NULL); pthread_join(t[1], NULL);
fprintf(stderr, "PASS\n"); fprintf(stderr, "PASS\n");
} }
// CHECK: PASS // CHECK: PASS
// CHECK-NOT: WARNING: ThreadSanitizer: data race