[Exclusivity] Teach separate-stored-property relaxation about TSan instrumentation

The compile-time exclusivity diagnostics explicitly allow conflicting accesses
to a struct when it can prove that the two accesses are used to project addresses
for separate stored properties. Unfortunately, the logic that detects this special
case gets confused by Thread Sanitizer's SIL-level instrumentation. This causes
the exclusivity diagnostics to have false positives when TSan is enabled.

To fix this, teach the AccessSummaryAnalysis to ignore TSan builtins when
determining whether an access has a single projected subpath.

rdar://problem/40455335

Author: devincoughlin

lib/SILOptimizer/Analysis/AccessSummaryAnalysis.cpp

@@ -11,6 +11,7 @@
 //===----------------------------------------------------------------------===//
 
 #define DEBUG_TYPE "sil-access-summary-analysis"
+#include "swift/SIL/InstructionUtils.h"
 #include "swift/SIL/SILArgument.h"
 #include "swift/SILOptimizer/Analysis/AccessSummaryAnalysis.h"
 #include "swift/SILOptimizer/Analysis/FunctionOrder.h"
@@ -489,6 +490,12 @@ getSingleAddressProjectionUser(SingleValueInstruction *I) {
     if (isa<BeginAccessInst>(I) && isa<EndAccessInst>(User))
       continue;
 
+    // Ignore sanitizer instrumentation when looking for a single projection
+    // user. This ensures that we're able to find a single projection subpath
+    // even when sanitization is enabled.
+    if (isSanitizerInstrumentation(User))
+      continue;
+
     // We have more than a single user so bail.
     if (SingleUser)
       return std::make_pair(nullptr, 0);

test/SILOptimizer/access_summary_analysis.sil

@@ -174,6 +174,24 @@ bb0(%0 : @trivial $*StructWithStoredProperties):
   return %7 : $()
 }
 
+// CHECK-LABEL: @accessSeparateStoredPropertiesOfSameCaptureWithTSanInstrumentation
+// CHECK-NEXT: ([.f modify, .g read])
+sil private @accessSeparateStoredPropertiesOfSameCaptureWithTSanInstrumentation : $@convention(thin) (@inout_aliasable StructWithStoredProperties) -> () {
+bb0(%0 : @trivial $*StructWithStoredProperties):
+  %1 = begin_access [modify] [unknown] %0: $*StructWithStoredProperties
+  %2 = builtin "tsanInoutAccess"(%1 : $*StructWithStoredProperties) : $()
+  %3 = struct_element_addr %1 : $*StructWithStoredProperties, #StructWithStoredProperties.f
+  %4 = builtin "tsanInoutAccess"(%3 : $*Int) : $()
+  end_access %1 : $*StructWithStoredProperties
+  %6 = begin_access [read] [unknown] %0: $*StructWithStoredProperties
+  %7 = builtin "tsanInoutAccess"(%6 : $*StructWithStoredProperties) : $()
+  %8 = struct_element_addr %6 : $*StructWithStoredProperties, #StructWithStoredProperties.g
+  %9 = builtin "tsanInoutAccess"(%8 : $*Int) : $()
+  end_access %6 : $*StructWithStoredProperties
+  %11 = tuple ()
+  return %11 : $()
+}
+
 // CHECK-LABEL: @addressToPointerOfStructElementAddr
 // CHECK-NEXT: ([])
 // This mirrors the code pattern for materializeForSet on a struct stored

test/Sanitizers/tsan-static-exclusivity.swift

@@ -0,0 +1,28 @@
+// RUN: %target-swift-frontend -enforce-exclusivity=checked -sanitize=thread -emit-sil -primary-file %s -o /dev/null -verify
+// REQUIRES: tsan_runtime
+
+
+struct OtherStruct {
+  mutating
+  func mutableTakingClosure(_ c: () -> Void) { }
+}
+
+struct StructAndInt {
+    var s = OtherStruct()
+    var f = 42
+}
+
+func testStoredPropertyRelaxationInClosure() {
+    var l = StructAndInt()
+    l.s.mutableTakingClosure {
+        _ = l.f // no-diagnostic
+    }
+}
+
+func takesInouts(_ p1: inout Int, _ p2: inout OtherStruct) { }
+
+func testStoredPropertyRelaxationInInout() {
+    var l = StructAndInt()
+    takesInouts(&l.f, &l.s) // no-diagnostic
+}
+