[clang] [compiler-rt] [llvm] [TSan][ObjC] Make TSan able to detect races on 'nonatomic, copy' properties (PR #238426)

Dan Blackwell via cfe-commits cfe-commits at lists.llvm.org
Thu Nov 5 10:01:15 PST 2026


https://github.com/DanBlackwell updated https://github.com/llvm/llvm-project/pull/238426

>From 45cc7b32524d19467a403c997a6fcaf32279adad Mon Sep 17 00:00:00 2001
From: Dan Blackwell <dan_blackwell at apple.com>
Date: Fri, 30 Oct 2026 10:31:53 -0700
Subject: [PATCH] [TSan][ObjC] Make TSan able to detect races on 'nonatomic,
 copy' properties

Currently TSan is not able to observe the write that occurs when a property marked as copy
occurs in Objective-C code, resulting in false negatives.

This patch fixes that by modifying the instrumentation pass to insert the required TSan
runtime calls before the associated Objective-C runtime calls.

Assisted by LLMs

rdar://191638298
---
 .../sanitize-thread-copy-property.m           | 21 +++++
 .../tsan/Darwin/objc-copy-property-race.mm    | 93 +++++++++++++++++++
 .../Instrumentation/ThreadSanitizer.cpp       | 76 ++++++++++++++-
 .../ThreadSanitizer/objc-set-property.ll      | 70 ++++++++++++++
 4 files changed, 259 insertions(+), 1 deletion(-)
 create mode 100644 clang/test/CodeGenObjC/sanitize-thread-copy-property.m
 create mode 100644 compiler-rt/test/tsan/Darwin/objc-copy-property-race.mm
 create mode 100644 llvm/test/Instrumentation/ThreadSanitizer/objc-set-property.ll

diff --git a/clang/test/CodeGenObjC/sanitize-thread-copy-property.m b/clang/test/CodeGenObjC/sanitize-thread-copy-property.m
new file mode 100644
index 00000000000000..72195fb65033f1
--- /dev/null
+++ b/clang/test/CodeGenObjC/sanitize-thread-copy-property.m
@@ -0,0 +1,21 @@
+// RUN: %clang_cc1 -triple arm64-apple-macosx11.0.0 -fobjc-runtime=macosx-11.0.0 -O0 -emit-llvm -fobjc-arc -fsanitize=thread -o - %s | FileCheck %s
+// RUN: %clang_cc1 -triple arm64-apple-macosx11.0.0 -fobjc-runtime=macosx-11.0.0 -O1 -emit-llvm -fobjc-arc -fsanitize=thread -o - %s | FileCheck %s
+
+__attribute__((objc_root_class))
+ at interface CopyContainer {
+  Class _isa;
+}
+ at property(nonatomic, copy) id nonatomicCopyProp;
+ at property(atomic, copy) id atomicCopyProp;
+ at end
+
+// CHECK-LABEL: define internal void @"\01-[CopyContainer setNonatomicCopyProp:]"(
+// CHECK: [[ADDR:%.*]] = getelementptr i8, ptr [[SELF:%.*]], i64 {{.*}}
+// CHECK-NEXT: call void @__tsan_write8(ptr [[ADDR]])
+// CHECK-NEXT: {{(tail )?}}call void @objc_setProperty_nonatomic_copy(ptr noundef [[SELF]], ptr noundef {{.*}}, ptr noundef {{.*}}, i64 noundef {{.*}})
+
+// CHECK-LABEL: define internal void @"\01-[CopyContainer setAtomicCopyProp:]"(
+// CHECK-NOT: call void @__tsan_write8
+// CHECK: {{(tail )?}}call void @objc_setProperty_atomic_copy(
+ at implementation CopyContainer
+ at end
diff --git a/compiler-rt/test/tsan/Darwin/objc-copy-property-race.mm b/compiler-rt/test/tsan/Darwin/objc-copy-property-race.mm
new file mode 100644
index 00000000000000..f11ec45106c1ad
--- /dev/null
+++ b/compiler-rt/test/tsan/Darwin/objc-copy-property-race.mm
@@ -0,0 +1,93 @@
+// Verify that ThreadSanitizer detects data races on Objective-C synthesized
+// (nonatomic, copy) properties at both -O0 and -O2, and does not report races
+// on (atomic, copy) properties.
+
+// RUN: %clangxx_tsan %s -o %t_O0 -O0 -fobjc-arc -framework Foundation
+// RUN: %deflake %run %t_O0 2>&1 | FileCheck %s
+
+// RUN: %clangxx_tsan %s -o %t_O2 -O2 -fobjc-arc -framework Foundation
+// RUN: %deflake %run %t_O2 2>&1 | FileCheck %s
+
+#import <Foundation/Foundation.h>
+#import "../test.h"
+
+ at interface CopyContainer : NSObject
+ at property(nonatomic, copy) NSString *text;
+ at property(nonatomic, copy) NSString *readWriteText;
+ at property(atomic, copy) NSString *atomicText;
+ at end
+
+ at implementation CopyContainer
+ at end
+
+int main() {
+  @autoreleasepool {
+    CopyContainer *c = [CopyContainer new];
+    NSString *s1 = [NSString stringWithFormat:@"hello-non-tagged-string-%d", 1];
+    NSString *s2 = [NSString stringWithFormat:@"world-non-tagged-string-%d", 2];
+    dispatch_queue_t q =
+        dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
+
+    // 1. Concurrent access to an (atomic, copy) property must not race.
+    {
+      barrier_init(&barrier, 2);
+      dispatch_group_t group = dispatch_group_create();
+      dispatch_group_async(group, q, ^{
+        c.atomicText = s1;
+        barrier_wait(&barrier);
+      });
+      dispatch_group_async(group, q, ^{
+        barrier_wait(&barrier);
+        c.atomicText = s2;
+      });
+      dispatch_group_wait(group, DISPATCH_TIME_FOREVER);
+      NSLog(@"Atomic write completed.");
+    }
+
+    // 2. Write-vs-Write race on a (nonatomic, copy) property.
+    {
+      barrier_init(&barrier, 2);
+      dispatch_group_t group = dispatch_group_create();
+      dispatch_group_async(group, q, ^{
+        c.text = s1;
+        barrier_wait(&barrier);
+      });
+      dispatch_group_async(group, q, ^{
+        barrier_wait(&barrier);
+        c.text = s2;
+      });
+      dispatch_group_wait(group, DISPATCH_TIME_FOREVER);
+    }
+
+    // 3. Read-vs-Write race (getter vs setter) on a (nonatomic, copy) property.
+    {
+      c.readWriteText = s1;
+      barrier_init(&barrier, 2);
+      dispatch_group_t group = dispatch_group_create();
+      dispatch_group_async(group, q, ^{
+        c.readWriteText = s2;
+        barrier_wait(&barrier);
+      });
+      dispatch_group_async(group, q, ^{
+        barrier_wait(&barrier);
+        (void)c.readWriteText;
+      });
+      dispatch_group_wait(group, DISPATCH_TIME_FOREVER);
+    }
+  }
+  return 0;
+}
+
+// CHECK-NOT: setAtomicText:
+// CHECK: Atomic write completed.
+// CHECK: WARNING: ThreadSanitizer: data race
+// CHECK:   Write of size 8 at {{0x[0-9a-f]+}} by thread T{{[0-9]+}}:
+// CHECK:     #0 -[CopyContainer setText:]
+// CHECK:   Previous write of size 8 at {{0x[0-9a-f]+}} by thread T{{[0-9]+}}:
+// CHECK:     #0 -[CopyContainer setText:]
+
+// CHECK: WARNING: ThreadSanitizer: data race
+// CHECK:   Read of size 8 at {{0x[0-9a-f]+}} by thread T{{[0-9]+}}:
+// CHECK:     #0 -[CopyContainer readWriteText]
+// CHECK:   Previous write of size 8 at {{0x[0-9a-f]+}} by thread T{{[0-9]+}}:
+// CHECK:     #0 -[CopyContainer setReadWriteText:]
diff --git a/llvm/lib/Transforms/Instrumentation/ThreadSanitizer.cpp b/llvm/lib/Transforms/Instrumentation/ThreadSanitizer.cpp
index a2ea0a011e9399..c1e36511f9c9ab 100644
--- a/llvm/lib/Transforms/Instrumentation/ThreadSanitizer.cpp
+++ b/llvm/lib/Transforms/Instrumentation/ThreadSanitizer.cpp
@@ -104,6 +104,7 @@ struct ThreadSanitizer {
   bool instrumentLoadOrStore(const InstructionInfo &II, const DataLayout &DL);
   bool instrumentAtomic(Instruction *I, const DataLayout &DL);
   bool instrumentMemIntrinsic(Instruction *I);
+  bool instrumentObjCSetProperty(CallBase *CB, const DataLayout &DL);
   void chooseInstructionsToInstrument(SmallVectorImpl<Instruction *> &Local,
                                       SmallVectorImpl<InstructionInfo> &All,
                                       const DataLayout &DL);
@@ -139,6 +140,9 @@ struct ThreadSanitizer {
   FunctionCallee TsanVptrUpdate;
   FunctionCallee TsanVptrLoad;
   FunctionCallee MemmoveFn, MemcpyFn, MemsetFn;
+  Function *ObjCSetPropertyNonAtomicFn = nullptr;
+  Function *ObjCSetPropertyNonAtomicCopyFn = nullptr;
+  Function *ObjCSetPropertyFn = nullptr;
 };
 
 void insertModuleCtor(Module &M) {
@@ -313,6 +317,11 @@ void ThreadSanitizer::initialize(Module &M, const TargetLibraryInfo &TLI) {
       "__tsan_memset",
       TLI.getAttrList(&Ctx, {1}, /*Signed=*/true, /*Ret=*/false, Attr),
       IRB.getPtrTy(), IRB.getPtrTy(), IRB.getInt32Ty(), IntptrTy);
+
+  ObjCSetPropertyNonAtomicFn = M.getFunction("objc_setProperty_nonatomic");
+  ObjCSetPropertyNonAtomicCopyFn =
+      M.getFunction("objc_setProperty_nonatomic_copy");
+  ObjCSetPropertyFn = M.getFunction("objc_setProperty");
 }
 
 static bool isVtableAccess(Instruction *I) {
@@ -485,9 +494,13 @@ bool ThreadSanitizer::sanitizeFunction(Function &F,
   SmallVector<Instruction*, 8> LocalLoadsAndStores;
   SmallVector<Instruction*, 8> AtomicAccesses;
   SmallVector<Instruction*, 8> MemIntrinCalls;
+  SmallVector<CallBase *, 8> ObjCSetPropertyCalls;
   bool Res = false;
   bool HasCalls = false;
   bool SanitizeFunction = F.hasFnAttribute(Attribute::SanitizeThread);
+  const bool HasObjCSetProperty = ObjCSetPropertyNonAtomicFn ||
+                                  ObjCSetPropertyNonAtomicCopyFn ||
+                                  ObjCSetPropertyFn;
   const DataLayout &DL = F.getDataLayout();
 
   // Traverse all instructions, collect loads/stores/returns, check for calls.
@@ -505,6 +518,14 @@ bool ThreadSanitizer::sanitizeFunction(Function &F,
           maybeMarkSanitizerLibraryCallNoBuiltin(CI, &TLI);
         if (isa<MemIntrinsic>(Inst))
           MemIntrinCalls.push_back(&Inst);
+        else if (HasObjCSetProperty) {
+          auto *CB = cast<CallBase>(&Inst);
+          Value *Callee = CB->getCalledOperand();
+          if (Callee == ObjCSetPropertyNonAtomicFn ||
+              Callee == ObjCSetPropertyNonAtomicCopyFn ||
+              Callee == ObjCSetPropertyFn)
+            ObjCSetPropertyCalls.push_back(CB);
+        }
         HasCalls = true;
         chooseInstructionsToInstrument(LocalLoadsAndStores, AllLoadsAndStores,
                                        DL);
@@ -518,10 +539,14 @@ bool ThreadSanitizer::sanitizeFunction(Function &F,
   // (e.g. variables that do not escape, etc).
 
   // Instrument memory accesses only if we want to report bugs in the function.
-  if (Opts.tsan_instrument_memory_accesses && SanitizeFunction)
+  if (Opts.tsan_instrument_memory_accesses && SanitizeFunction) {
     for (const auto &II : AllLoadsAndStores) {
       Res |= instrumentLoadOrStore(II, DL);
     }
+    for (auto *CB : ObjCSetPropertyCalls) {
+      Res |= instrumentObjCSetProperty(CB, DL);
+    }
+  }
 
   // Instrument atomic memory accesses in any case (they can be used to
   // implement synchronization).
@@ -681,6 +706,55 @@ bool ThreadSanitizer::instrumentMemIntrinsic(Instruction *I) {
   return false;
 }
 
+bool ThreadSanitizer::instrumentObjCSetProperty(CallBase *CB,
+                                                const DataLayout &DL) {
+  Value *Callee = CB->getCalledOperand();
+  Value *Self = nullptr;
+  Value *NewValue = nullptr;
+  Value *Offset = nullptr;
+  if (Callee == ObjCSetPropertyNonAtomicFn ||
+      Callee == ObjCSetPropertyNonAtomicCopyFn) {
+    // void objc_setProperty_nonatomic[_copy](id self, SEL _cmd, id newValue,
+    //                                        ptrdiff_t offset)
+    if (CB->arg_size() != 4)
+      return false;
+    Self = CB->getArgOperand(0);
+    NewValue = CB->getArgOperand(2);
+    Offset = CB->getArgOperand(3);
+  } else if (Callee == ObjCSetPropertyFn) {
+    // void objc_setProperty(id self, SEL _cmd, ptrdiff_t offset, id newValue,
+    //                       BOOL atomic, BOOL shouldCopy)
+    if (CB->arg_size() != 6)
+      return false;
+    auto *AtomicCI = dyn_cast<ConstantInt>(CB->getArgOperand(4));
+    if (!AtomicCI || !AtomicCI->isZero())
+      return false;
+    Self = CB->getArgOperand(0);
+    Offset = CB->getArgOperand(2);
+    NewValue = CB->getArgOperand(3);
+  } else {
+    return false;
+  }
+
+  if (!Self->getType()->isPointerTy() || !NewValue->getType()->isPointerTy() ||
+      !Offset->getType()->isIntegerTy())
+    return false;
+  if (!shouldInstrumentReadWriteFromAddress(CB->getModule(), Self))
+    return false;
+
+  InstrumentationIRBuilder IRB(CB);
+  Value *Addr = IRB.CreatePtrAdd(Self, Offset);
+  int Idx = getMemoryAccessFuncIndex(IRB.getPtrTy(), Addr, DL);
+  if (Idx < 0)
+    return false;
+
+  // First the old value at Addr is read, then the new value is stored there;
+  // TSan only needs to know about the write.
+  IRB.CreateCall(TsanWrite[Idx], Addr);
+  NumInstrumentedWrites++;
+  return true;
+}
+
 // Both llvm and ThreadSanitizer atomic operations are based on C++11/C1x
 // standards.  For background see C++11 standard.  A slightly older, publicly
 // available draft of the standard (not entirely up-to-date, but close enough
diff --git a/llvm/test/Instrumentation/ThreadSanitizer/objc-set-property.ll b/llvm/test/Instrumentation/ThreadSanitizer/objc-set-property.ll
new file mode 100644
index 00000000000000..d622b19c1299b7
--- /dev/null
+++ b/llvm/test/Instrumentation/ThreadSanitizer/objc-set-property.ll
@@ -0,0 +1,70 @@
+; RUN: opt < %s -passes=tsan -S | FileCheck %s
+
+target datalayout = "e-m:o-i64:64-i128:128-n32:64-S128"
+
+declare void @objc_setProperty_nonatomic(ptr, ptr, ptr, i64) nounwind
+declare void @objc_setProperty_nonatomic_copy(ptr, ptr, ptr, i64) nounwind
+declare void @objc_setProperty_atomic_copy(ptr, ptr, ptr, i64) nounwind
+declare void @objc_setProperty(ptr, ptr, i64, ptr, i1, i1) nounwind
+
+; CHECK-LABEL: define void @test_set_property_nonatomic_copy(
+; CHECK: [[ADDR:%.*]] = getelementptr i8, ptr %self, i64 %offset
+; CHECK-NEXT: call void @__tsan_write8(ptr [[ADDR]])
+; CHECK-NEXT: call void @objc_setProperty_nonatomic_copy(ptr %self, ptr %cmd, ptr %val, i64 %offset)
+define void @test_set_property_nonatomic_copy(ptr %self, ptr %cmd, ptr %val, i64 %offset) nounwind sanitize_thread {
+  call void @objc_setProperty_nonatomic_copy(ptr %self, ptr %cmd, ptr %val, i64 %offset)
+  ret void
+}
+
+; CHECK-LABEL: define void @test_set_property_nonatomic(
+; CHECK: [[ADDR:%.*]] = getelementptr i8, ptr %self, i64 %offset
+; CHECK-NEXT: call void @__tsan_write8(ptr [[ADDR]])
+; CHECK-NEXT: call void @objc_setProperty_nonatomic(ptr %self, ptr %cmd, ptr %val, i64 %offset)
+define void @test_set_property_nonatomic(ptr %self, ptr %cmd, ptr %val, i64 %offset) nounwind sanitize_thread {
+  call void @objc_setProperty_nonatomic(ptr %self, ptr %cmd, ptr %val, i64 %offset)
+  ret void
+}
+
+; CHECK-LABEL: define void @test_set_property_generic_nonatomic(
+; CHECK: [[ADDR:%.*]] = getelementptr i8, ptr %self, i64 %offset
+; CHECK-NEXT: call void @__tsan_write8(ptr [[ADDR]])
+; CHECK-NEXT: call void @objc_setProperty(ptr %self, ptr %cmd, i64 %offset, ptr %val, i1 false, i1 true)
+define void @test_set_property_generic_nonatomic(ptr %self, ptr %cmd, i64 %offset, ptr %val) nounwind sanitize_thread {
+  call void @objc_setProperty(ptr %self, ptr %cmd, i64 %offset, ptr %val, i1 false, i1 true)
+  ret void
+}
+
+; CHECK-LABEL: define void @test_set_property_generic_atomic(
+; CHECK-NOT: __tsan_write8
+; CHECK: call void @objc_setProperty(ptr %self, ptr %cmd, i64 %offset, ptr %val, i1 true, i1 true)
+define void @test_set_property_generic_atomic(ptr %self, ptr %cmd, i64 %offset, ptr %val) nounwind sanitize_thread {
+  call void @objc_setProperty(ptr %self, ptr %cmd, i64 %offset, ptr %val, i1 true, i1 true)
+  ret void
+}
+
+; Clang never emits a non-constant 'atomic' argument for synthesized setters,
+; but user code could theoretically call objc_setProperty directly with a
+; runtime boolean.
+; CHECK-LABEL: define void @test_set_property_generic_nonconstant_atomic(
+; CHECK-NOT: __tsan_write8
+; CHECK: call void @objc_setProperty(ptr %self, ptr %cmd, i64 %offset, ptr %val, i1 %atomic, i1 true)
+define void @test_set_property_generic_nonconstant_atomic(ptr %self, ptr %cmd, i64 %offset, ptr %val, i1 %atomic) nounwind sanitize_thread {
+  call void @objc_setProperty(ptr %self, ptr %cmd, i64 %offset, ptr %val, i1 %atomic, i1 true)
+  ret void
+}
+
+; CHECK-LABEL: define void @test_set_property_atomic_copy(
+; CHECK-NOT: __tsan_write8
+; CHECK: call void @objc_setProperty_atomic_copy(ptr %self, ptr %cmd, ptr %val, i64 %offset)
+define void @test_set_property_atomic_copy(ptr %self, ptr %cmd, ptr %val, i64 %offset) nounwind sanitize_thread {
+  call void @objc_setProperty_atomic_copy(ptr %self, ptr %cmd, ptr %val, i64 %offset)
+  ret void
+}
+
+; CHECK-LABEL: define void @test_no_sanitize_thread(
+; CHECK-NOT: __tsan_write8
+; CHECK: call void @objc_setProperty_nonatomic_copy(ptr %self, ptr %cmd, ptr %val, i64 %offset)
+define void @test_no_sanitize_thread(ptr %self, ptr %cmd, ptr %val, i64 %offset) nounwind {
+  call void @objc_setProperty_nonatomic_copy(ptr %self, ptr %cmd, ptr %val, i64 %offset)
+  ret void
+}



More information about the cfe-commits mailing list