[tsan] Enable ignore_noninstrumented_modules=1 on Darwin by default

[kubamracek]

Summary

TSan recently got the "ignore_noninstrumented_modules" flag, which disables tracking of read and writes that come from noninstrumented modules (via interceptors). This is a way of suppressing false positives coming from system libraries and other noninstrumented code. This patch turns this on by default on Darwin, where it's supposed to replace the previous solution, "ignore_interceptors_accesses", which disables tracking in *all* interceptors. The new approach should re-enable TSan's ability to find races via interceptors on Darwin.

[dvyukov]

test/tsan/lit.cfg

30

ignore_noninstrumented_modules=0 works because the generic tests use only libc and don't use any darwin-specific libraries, and tsan runtime handles most of the libc functions, right?

[kubamracek]

test/tsan/lit.cfg

30

That's correct. Libc doesn't really do any threading stuff unless you explicitly use pthread APIs. Darwin-specific libraries do (XPC, dispatch, NSOperationQueue, ...).

lib/tsan/rtl/tsan_flags.inc

TSAN_FLAG(int, io_sync, 1,
           "0 - no synchronization "
           "1 - reasonable level of synchronization (write->read)"
           "2 - global synchronization of all IO operations.")
 TSAN_FLAG(bool, die_after_fork, true,
           "Die after multi-threaded fork if the child creates new threads.")
 TSAN_FLAG(const char *, suppressions, "", "Suppressions file name.")
 TSAN_FLAG(bool, ignore_interceptors_accesses, false,
           "Ignore reads and writes from all interceptors.")
-TSAN_FLAG(bool, ignore_noninstrumented_modules, false,
+TSAN_FLAG(bool, ignore_noninstrumented_modules, SANITIZER_MAC ? true : false,
           "Interceptors should only detect races when called from instrumented "
           "modules.")
 TSAN_FLAG(bool, shared_ptr_interceptor, true,
           "Track atomic reference counting in libc++ shared_ptr and weak_ptr.")

test/tsan/Darwin/dispatch_main.mm

 // Check that we don't crash when dispatch_main calls pthread_exit which
 // quits the main thread.
 
 // RUN: %clang_tsan %s -o %t -framework Foundation
-// RUN: %env_tsan_opts=ignore_interceptors_accesses=1 %run %t 2>&1 | FileCheck %s
+// RUN: %run %t 2>&1 | FileCheck %s
 
 #import <Foundation/Foundation.h>
 
 int main() {
   fprintf(stderr,"Hello world");
 
   dispatch_queue_t q = dispatch_queue_create("my.queue", DISPATCH_QUEUE_SERIAL);
 

test/tsan/Darwin/dispatch_once_deadlock.mm

 // Check that calling dispatch_once from a report callback works.
 
 // RUN: %clang_tsan %s -o %t -framework Foundation
-// RUN: %env_tsan_opts=ignore_interceptors_accesses=1 not %run %t 2>&1 | FileCheck %s
+// RUN: not %run %t 2>&1 | FileCheck %s
 
 #import <Foundation/Foundation.h>
 #import <pthread.h>
 
 long g = 0;
 long h = 0;
 void f() {
   static dispatch_once_t onceToken;

test/tsan/Darwin/gcd-after.mm

 // RUN: %clang_tsan %s -o %t -framework Foundation
-// RUN: %env_tsan_opts=ignore_interceptors_accesses=1 %run %t 2>&1 | FileCheck %s
+// RUN: %run %t 2>&1 | FileCheck %s
 
 #import <Foundation/Foundation.h>
 
 long my_global;
 long my_global2;
 
 void callback(void *context) {
   my_global2 = 42;

test/tsan/Darwin/gcd-apply-race.mm

 // RUN: %clang_tsan %s -o %t -framework Foundation
-// RUN: %env_tsan_opts=ignore_interceptors_accesses=1 %deflake %run %t 2>&1 | FileCheck %s
+// RUN: %deflake %run %t 2>&1 | FileCheck %s
 
 #import <Foundation/Foundation.h>
 
 #import "../test.h"
 
 long global;
 
 int main(int argc, const char *argv[]) {

test/tsan/Darwin/gcd-apply.mm

 // RUN: %clang_tsan %s -o %t -framework Foundation
-// RUN: %env_tsan_opts=ignore_interceptors_accesses=1 %run %t 2>&1 | FileCheck %s
+// RUN: %run %t 2>&1 | FileCheck %s
 
 #import <Foundation/Foundation.h>
 
 #import "../test.h"
 
 long global;
 long array[2];
 

test/tsan/Darwin/gcd-async-norace.mm

 // RUN: %clang_tsan %s -o %t -framework Foundation
-// RUN: %env_tsan_opts=ignore_interceptors_accesses=1 %run %t 2>&1 | FileCheck %s
+// RUN: %run %t 2>&1 | FileCheck %s
 
 #import <Foundation/Foundation.h>
 
 long global;
 
 int main() {
   NSLog(@"Hello world.");
 

test/tsan/Darwin/gcd-async-race.mm

 // RUN: %clang_tsan %s -o %t -framework Foundation
-// RUN: %env_tsan_opts=ignore_interceptors_accesses=1 %deflake %run %t 2>&1 | FileCheck %s
+// RUN: %deflake %run %t 2>&1 | FileCheck %s
 
 #import <Foundation/Foundation.h>
 
 #import "../test.h"
 
 long global;
 
 int main() {

test/tsan/Darwin/gcd-barrier-race.mm

 // RUN: %clang_tsan %s -o %t -framework Foundation
-// RUN: %env_tsan_opts=ignore_interceptors_accesses=1 %deflake %run %t 2>&1 | FileCheck %s
+// RUN: %deflake %run %t 2>&1 | FileCheck %s
 
 #import <Foundation/Foundation.h>
 
 #import "../test.h"
 
 long global;
 
 int main() {

test/tsan/Darwin/gcd-barrier.mm

 // RUN: %clang_tsan %s -o %t -framework Foundation
-// RUN: %env_tsan_opts=ignore_interceptors_accesses=1 %run %t 2>&1 | FileCheck %s
+// RUN: %run %t 2>&1 | FileCheck %s
 
 #import <Foundation/Foundation.h>
 
 #import "../test.h"
 
 long global;
 
 int main() {

test/tsan/Darwin/gcd-blocks.mm

 // RUN: %clangxx_tsan %s -o %t -framework Foundation
-// RUN: %env_tsan_opts=ignore_interceptors_accesses=1 %run %t 2>&1 | FileCheck %s
+// RUN: %run %t 2>&1 | FileCheck %s
 
 #import <Foundation/Foundation.h>
 
 int main() {
   fprintf(stderr, "start\n");
 
   dispatch_queue_t background_q = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
   dispatch_queue_t main_q = dispatch_get_main_queue();

test/tsan/Darwin/gcd-data.mm

 // RUN: %clang_tsan %s -o %t -framework Foundation
-// RUN: %env_tsan_opts=ignore_interceptors_accesses=1 %run %t 2>&1 | FileCheck %s
+// RUN: %run %t 2>&1 | FileCheck %s
 
 #import <Foundation/Foundation.h>
 
 long global;
 
 int main(int argc, const char *argv[]) {
   fprintf(stderr, "Hello world.\n");
 

test/tsan/Darwin/gcd-fd.mm

 // RUN: %clang_tsan %s -o %t -framework Foundation
-// RUN: %env_tsan_opts=ignore_interceptors_accesses=1 %run %t 2>&1 | FileCheck %s
+// RUN: %run %t 2>&1 | FileCheck %s
 
 #import <Foundation/Foundation.h>
 
 long my_global = 0;
 
 int main(int argc, const char *argv[]) {
   fprintf(stderr, "Hello world.\n");
 

test/tsan/Darwin/gcd-groups-destructor.mm

 // RUN: %clangxx_tsan %s -o %t -framework Foundation
-// RUN: %env_tsan_opts=ignore_interceptors_accesses=1 %run %t 2>&1 | FileCheck %s
+// RUN: %run %t 2>&1 | FileCheck %s
 
 #import <Foundation/Foundation.h>
 
 #import <memory>
 #import <stdatomic.h>
 
 _Atomic(long) destructor_counter = 0;
 

test/tsan/Darwin/gcd-groups-leave.mm

 // RUN: %clang_tsan %s -o %t -framework Foundation
-// RUN: %env_tsan_opts=ignore_interceptors_accesses=1 %run %t 2>&1 | FileCheck %s
+// RUN: %run %t 2>&1 | FileCheck %s
 
 #import <Foundation/Foundation.h>
 
 #import "../test.h"
 
 dispatch_semaphore_t sem;
 
 long global;

test/tsan/Darwin/gcd-groups-norace.mm

 // RUN: %clang_tsan %s -o %t -framework Foundation
-// RUN: %env_tsan_opts=ignore_interceptors_accesses=1 %run %t 2>&1 | FileCheck %s
+// RUN: %run %t 2>&1 | FileCheck %s
 
 #import <Foundation/Foundation.h>
 
 #import "../test.h"
 
 long global;
 
 int main() {

test/tsan/Darwin/gcd-groups-stress.mm

 // RUN: %clang_tsan %s -o %t -framework Foundation
-// RUN: %env_tsan_opts=ignore_interceptors_accesses=1 %run %t 2>&1 | FileCheck %s
+// RUN: %run %t 2>&1 | FileCheck %s
 
 #import <Foundation/Foundation.h>
 
 void notify_callback(void *context) {
   // Do nothing.
 }
 
 int main() {

test/tsan/Darwin/gcd-io-barrier-race.mm

 // RUN: %clang_tsan %s -o %t -framework Foundation
-// RUN: %env_tsan_opts=ignore_interceptors_accesses=1 %deflake %run %t 2>&1 | FileCheck %s
+// RUN: %deflake %run %t 2>&1 | FileCheck %s
 
 #import <Foundation/Foundation.h>
 
 #import "../test.h"
 
 dispatch_queue_t queue;
 dispatch_data_t data;
 dispatch_semaphore_t sem;

test/tsan/Darwin/gcd-io-barrier.mm

 // RUN: %clang_tsan %s -o %t -framework Foundation
-// RUN: %env_tsan_opts=ignore_interceptors_accesses=1 %run %t 2>&1 | FileCheck %s
+// RUN: %run %t 2>&1 | FileCheck %s
 
 #import <Foundation/Foundation.h>
 
 dispatch_queue_t queue;
 dispatch_data_t data;
 dispatch_semaphore_t sem;
 const char *path;
 

test/tsan/Darwin/gcd-io-cleanup.mm

 // RUN: %clang_tsan %s -o %t -framework Foundation
-// RUN: %env_tsan_opts=ignore_interceptors_accesses=1 %run %t 2>&1 | FileCheck %s
+// RUN: %run %t 2>&1 | FileCheck %s
 
 #import <Foundation/Foundation.h>
 
 long my_global = 0;
 
 int main(int argc, const char *argv[]) {
   fprintf(stderr, "Hello world.\n");
   

test/tsan/Darwin/gcd-io-race.mm

 // RUN: %clang_tsan %s -o %t -framework Foundation
-// RUN: %env_tsan_opts=ignore_interceptors_accesses=1 %deflake %run %t 2>&1 | FileCheck %s
+// RUN: %deflake %run %t 2>&1 | FileCheck %s
 
 // REQUIRES: disabled
 
 #import <Foundation/Foundation.h>
 
 #import "../test.h"
 
 dispatch_queue_t queue;

test/tsan/Darwin/gcd-io.mm

 // RUN: %clang_tsan %s -o %t -framework Foundation
-// RUN: %env_tsan_opts=ignore_interceptors_accesses=1 %run %t 2>&1 | FileCheck %s
+// RUN: %run %t 2>&1 | FileCheck %s
 
 #import <Foundation/Foundation.h>
 
 dispatch_queue_t queue;
 dispatch_data_t data;
 dispatch_semaphore_t sem;
 const char *path;
 

test/tsan/Darwin/gcd-once.mm

 // RUN: %clang_tsan %s -o %t -framework Foundation
-// RUN: %env_tsan_opts=ignore_interceptors_accesses=1 %run %t 2>&1 | FileCheck %s
+// RUN: %run %t 2>&1 | FileCheck %s
 
 #import <Foundation/Foundation.h>
 
 #import "../test.h"
 
 static const long kNumThreads = 4;
 
 long global;

test/tsan/Darwin/gcd-semaphore-norace.mm

 // RUN: %clang_tsan %s -o %t -framework Foundation
-// RUN: %env_tsan_opts=ignore_interceptors_accesses=1 %run %t 2>&1 | FileCheck %s
+// RUN: %run %t 2>&1 | FileCheck %s
 
 #import <Foundation/Foundation.h>
 
 long global;
 
 int main() {
     NSLog(@"Hello world.");
 

test/tsan/Darwin/gcd-serial-queue-norace.mm

 // RUN: %clang_tsan %s -o %t -framework Foundation
-// RUN: %env_tsan_opts=ignore_interceptors_accesses=1 %run %t 2>&1 | FileCheck %s
+// RUN: %run %t 2>&1 | FileCheck %s
 
 #import <Foundation/Foundation.h>
 
 #import "../test.h"
 
 long global;
 
 int main() {

test/tsan/Darwin/gcd-source-cancel.mm

 // RUN: %clang_tsan %s -o %t -framework Foundation
-// RUN: %env_tsan_opts=ignore_interceptors_accesses=1 %run %t 2>&1 | FileCheck %s
+// RUN: %run %t 2>&1 | FileCheck %s
 
 #import <Foundation/Foundation.h>
 
 long global;
 
 int main(int argc, const char *argv[]) {
   dispatch_queue_t queue =
       dispatch_queue_create("my.queue", DISPATCH_QUEUE_CONCURRENT);

test/tsan/Darwin/gcd-source-cancel2.mm

 // RUN: %clang_tsan %s -o %t -framework Foundation
-// RUN: %env_tsan_opts=ignore_interceptors_accesses=1 %run %t 2>&1 | FileCheck %s
+// RUN: %run %t 2>&1 | FileCheck %s
 
 #import <Foundation/Foundation.h>
 
 long global;
 
 void handler(void *arg) {
   fprintf(stderr, "global = %ld\n", global);
 

test/tsan/Darwin/gcd-source-event.mm

 // RUN: %clang_tsan %s -o %t -framework Foundation
-// RUN: %env_tsan_opts=ignore_interceptors_accesses=1 %run %t 2>&1 | FileCheck %s
+// RUN: %run %t 2>&1 | FileCheck %s
 
 #import <Foundation/Foundation.h>
 
 long global;
 
 int main(int argc, const char *argv[]) {
   dispatch_queue_t queue =
       dispatch_queue_create("my.queue", DISPATCH_QUEUE_CONCURRENT);

test/tsan/Darwin/gcd-source-event2.mm

 // RUN: %clang_tsan %s -o %t -framework Foundation
-// RUN: %env_tsan_opts=ignore_interceptors_accesses=1 %run %t 2>&1 | FileCheck %s
+// RUN: %run %t 2>&1 | FileCheck %s
 
 #import <Foundation/Foundation.h>
 
 long global;
 
 void handler(void *arg) {
   fprintf(stderr, "global = %ld\n", global);
 

test/tsan/Darwin/gcd-source-registration.mm

 // RUN: %clang_tsan %s -o %t -framework Foundation
-// RUN: %env_tsan_opts=ignore_interceptors_accesses=1 %run %t 2>&1 | FileCheck %s
+// RUN: %run %t 2>&1 | FileCheck %s
 
 #import <Foundation/Foundation.h>
 
 long global;
 
 int main(int argc, const char *argv[]) {
   dispatch_queue_t queue =
       dispatch_queue_create("my.queue", DISPATCH_QUEUE_CONCURRENT);

test/tsan/Darwin/gcd-source-registration2.mm

 // RUN: %clang_tsan %s -o %t -framework Foundation
-// RUN: %env_tsan_opts=ignore_interceptors_accesses=1 %run %t 2>&1 | FileCheck %s
+// RUN: %run %t 2>&1 | FileCheck %s
 
 #import <Foundation/Foundation.h>
 
 long global;
 
 void handler(void *arg) {
   fprintf(stderr, "global = %ld\n", global);
 

test/tsan/Darwin/gcd-source-serial.mm

 // RUN: %clang_tsan %s -o %t -framework Foundation
-// RUN: %env_tsan_opts=ignore_interceptors_accesses=1 %run %t 2>&1 | FileCheck %s
+// RUN: %run %t 2>&1 | FileCheck %s
 
 #import <Foundation/Foundation.h>
 
 long global;
 
 int main(int argc, const char *argv[]) {
   fprintf(stderr, "Hello world.\n");
 

test/tsan/Darwin/gcd-suspend.mm

 // RUN: %clang_tsan %s -o %t -framework Foundation
-// RUN: %env_tsan_opts=ignore_interceptors_accesses=1 %run %t 2>&1 | FileCheck %s
+// RUN: %run %t 2>&1 | FileCheck %s
 
 #import <Foundation/Foundation.h>
 
 long my_global = 0;
 
 int main(int argc, const char *argv[]) {
   fprintf(stderr, "Hello world.\n");
 

test/tsan/Darwin/gcd-sync-norace.mm

 // RUN: %clang_tsan %s -o %t -framework Foundation
-// RUN: %env_tsan_opts=ignore_interceptors_accesses=1 %run %t 2>&1 | FileCheck %s
+// RUN: %run %t 2>&1 | FileCheck %s
 
 #import <Foundation/Foundation.h>
 
 long global;
 
 static const long nIter = 1000;
 
 int main() {

test/tsan/Darwin/gcd-sync-race.mm

 // RUN: %clang_tsan %s -o %t -framework Foundation
-// RUN: %env_tsan_opts=ignore_interceptors_accesses=1 %deflake %run %t 2>&1 | FileCheck %s
+// RUN: %deflake %run %t 2>&1 | FileCheck %s
 
 #import <Foundation/Foundation.h>
 
 #import "../test.h"
 
 long global;
 
 int main() {

test/tsan/Darwin/gcd-target-queue-norace.mm

 // RUN: %clang_tsan %s -o %t -framework Foundation
-// RUN: %env_tsan_opts=ignore_interceptors_accesses=1 %run %t 2>&1 | FileCheck %s
+// RUN: %run %t 2>&1 | FileCheck %s
 
 #import <Foundation/Foundation.h>
 
 long global;
 
 int main(int argc, const char *argv[]) {
   dispatch_queue_t target_queue = dispatch_queue_create(NULL, DISPATCH_QUEUE_SERIAL);
   dispatch_queue_t q1 = dispatch_queue_create(NULL, DISPATCH_QUEUE_CONCURRENT);

test/tsan/Darwin/ignore-noninstrumented.mm

 // Check that ignore_noninstrumented_modules=1 supresses races from system libraries on OS X.
 
 // RUN: %clang_tsan %s -o %t -framework Foundation
 
 // Check that without the flag, there are false positives.
-// RUN: %deflake %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-RACE
+// RUN: %env_tsan_opts=ignore_noninstrumented_modules=0 %deflake %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-RACE
 
 // With ignore_noninstrumented_modules=1, no races are reported.
 // RUN: %env_tsan_opts=ignore_noninstrumented_modules=1 %run %t 2>&1 | FileCheck %s
 
 // With ignore_noninstrumented_modules=1, races in user's code are still reported.
 // RUN: %env_tsan_opts=ignore_noninstrumented_modules=1 %deflake %run %t race 2>&1 | FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-RACE
 
 #import <Foundation/Foundation.h>

test/tsan/Darwin/ignored-interceptors.mm

 // Check that ignore_interceptors_accesses=1 supresses reporting races from
 // system libraries on OS X. There are currently false positives coming from
 // libxpc, libdispatch, CoreFoundation and others, because these libraries use
 // TSan-invisible atomics as synchronization.
 
 // RUN: %clang_tsan %s -o %t -framework Foundation
 
 // Check that without the flag, there are false positives.
-// RUN: %deflake %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-RACE
+// RUN: %env_tsan_opts=ignore_noninstrumented_modules=0 %deflake %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-RACE
 
 // With ignore_interceptors_accesses=1, no races are reported.
-// RUN: %env_tsan_opts=ignore_interceptors_accesses=1 %run %t 2>&1 | FileCheck %s
+// RUN: %env_tsan_opts=ignore_noninstrumented_modules=0:ignore_interceptors_accesses=1 %run %t 2>&1 | FileCheck %s
 
 // With ignore_interceptors_accesses=1, races in user's code are still reported.
-// RUN: %env_tsan_opts=ignore_interceptors_accesses=1 %deflake %run %t race 2>&1 | FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-RACE
+// RUN: %env_tsan_opts=ignore_noninstrumented_modules=0:ignore_interceptors_accesses=1 %deflake %run %t race 2>&1 | FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-RACE
 
 #import <Foundation/Foundation.h>
 
 #import "../test.h"
 
 long global;
 
 void *Thread1(void *x) {

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

 // RUN: %clangxx_tsan %s -o %t -framework Foundation -std=c++11
-// RUN: %env_tsan_opts=ignore_interceptors_accesses=1 %run %t 2>&1 | FileCheck %s
+// RUN: %run %t 2>&1 | FileCheck %s
 
 #import <Foundation/Foundation.h>
 
 #import <iostream>
 #import <thread>
 
 long my_global;
 std::once_flag once_token;

test/tsan/Darwin/libcxx-future.mm

 // RUN: %clangxx_tsan %s -o %t
-// RUN: %env_tsan_opts=ignore_interceptors_accesses=1 %run %t 2>&1 | FileCheck %s
+// RUN: %run %t 2>&1 | FileCheck %s
 
 #include <iostream>
 #include <future>
 #include <vector>
 
 int main(int argc, const char *argv[]) {
   fprintf(stderr, "Hello world.\n");
 

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

 // RUN: %clangxx_tsan %s -o %t -framework Foundation
-// RUN: %env_tsan_opts=ignore_interceptors_accesses=1 %run %t 2>&1 | FileCheck %s
+// RUN: %run %t 2>&1 | FileCheck %s
 
 #import <Foundation/Foundation.h>
 
 #import <memory>
 
 struct InnerStruct {
   ~InnerStruct() {
     fprintf(stderr, "~InnerStruct\n");

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

 // RUN: %clangxx_tsan %s -o %t -framework Foundation
-// RUN: %env_tsan_opts=ignore_interceptors_accesses=1 %run %t 2>&1 | FileCheck %s
+// RUN: %run %t 2>&1 | FileCheck %s
 
 #import <Foundation/Foundation.h>
 
 #import <assert.h>
 #import <memory>
 #import <stdatomic.h>
 
 _Atomic(long) shared_call_counter = 0;

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

 // RUN: %clangxx_tsan %s -o %t -framework Foundation
-// RUN: %env_tsan_opts=ignore_interceptors_accesses=1 %run %t 2>&1 | FileCheck %s
+// RUN: %run %t 2>&1 | FileCheck %s
 
 #import <Foundation/Foundation.h>
 
 #import <memory>
 
 #import "../test.h"
 
 long my_global;

test/tsan/Darwin/lit.local.cfg

 def getRoot(config):
   if not config.parent:
     return config
   return getRoot(config.parent)
 
 root = getRoot(config)
 
 if root.host_os not in ['Darwin']:
   config.unsupported = True
+
+config.environment['TSAN_OPTIONS'] += ':ignore_noninstrumented_modules=1'

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

 // RUN: %clang_tsan %s -lc++ -fobjc-arc -lobjc -o %t -framework Foundation
-// RUN: %env_tsan_opts=ignore_interceptors_accesses=1 %run %t 2>&1 | FileCheck %s
+// RUN: %run %t 2>&1 | FileCheck %s
 
 // Check that we do not report races between:
 // - Object retain and initialize
 // - Object release and dealloc
 // - Object release and .cxx_destruct
 
 #import <Foundation/Foundation.h>
 #include "../test.h"

test/tsan/Darwin/objc-double-property.mm

-// RUN: %clangxx_tsan -O0 %s -o %t -framework Foundation && %env_tsan_opts=ignore_interceptors_accesses=1 %run %t 2>&1 | FileCheck %s
-// RUN: %clangxx_tsan -O1 %s -o %t -framework Foundation && %env_tsan_opts=ignore_interceptors_accesses=1 %run %t 2>&1 | FileCheck %s
-// RUN: %clangxx_tsan -O2 %s -o %t -framework Foundation && %env_tsan_opts=ignore_interceptors_accesses=1 %run %t 2>&1 | FileCheck %s
-// RUN: %clangxx_tsan -O3 %s -o %t -framework Foundation && %env_tsan_opts=ignore_interceptors_accesses=1 %run %t 2>&1 | FileCheck %s
+// RUN: %clangxx_tsan -O0 %s -o %t -framework Foundation && %run %t 2>&1 | FileCheck %s
+// RUN: %clangxx_tsan -O1 %s -o %t -framework Foundation && %run %t 2>&1 | FileCheck %s
+// RUN: %clangxx_tsan -O2 %s -o %t -framework Foundation && %run %t 2>&1 | FileCheck %s
+// RUN: %clangxx_tsan -O3 %s -o %t -framework Foundation && %run %t 2>&1 | FileCheck %s
 
 #import <Foundation/Foundation.h>
 
 @interface MyClass : NSObject
 @property float a;
 @property double b;
 @property long double c;
 @end

test/tsan/Darwin/objc-simple.mm

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

test/tsan/Darwin/xpc-race.mm

 // RUN: %clang_tsan %s -o %t -framework Foundation
-// RUN: %env_tsan_opts=ignore_interceptors_accesses=1 %deflake %run %t 2>&1 | FileCheck %s
+// RUN: %deflake %run %t 2>&1 | FileCheck %s
 
 #import <Foundation/Foundation.h>
 #import <xpc/xpc.h>
 
 #import "../test.h"
 
 long global;
 

test/tsan/Darwin/xpc.mm

 // RUN: %clang_tsan %s -o %t -framework Foundation
-// RUN: %env_tsan_opts=ignore_interceptors_accesses=1 %run %t 2>&1 | FileCheck %s
+// RUN: %run %t 2>&1 | FileCheck %s
 
 #import <Foundation/Foundation.h>
 #import <xpc/xpc.h>
 
 long global;
 
 int main(int argc, const char *argv[]) {
   @autoreleasepool {

test/tsan/lit.cfg

 
 # Setup environment variables for running ThreadSanitizer.
 default_tsan_opts = "atexit_sleep_ms=0"
 
 if config.host_os == 'Darwin':
   # On Darwin, we default to `abort_on_error=1`, which would make tests run
   # much slower. Let's override this and run lit tests with 'abort_on_error=0'.
   default_tsan_opts += ':abort_on_error=0'
+  # On Darwin, we default to ignore_noninstrumented_modules=1, which also
+  # suppresses some races the tests are supposed to find. Let's run without this
+  # setting, but turn it back on for Darwin tests (see Darwin/lit.local.cfg).
+  default_tsan_opts += ':ignore_noninstrumented_modules=0'
 
 # Platform-specific default TSAN_OPTIONS for lit tests.
 if default_tsan_opts:
   config.environment['TSAN_OPTIONS'] = default_tsan_opts
   default_tsan_opts += ':'
 config.substitutions.append(('%env_tsan_opts=',
                              'env TSAN_OPTIONS=' + default_tsan_opts))