From 34cb4444363862f9b7cdba79146916b2acf90ebd Mon Sep 17 00:00:00 2001
From: Jeremy Schonfeld <jschonfeld@apple.com>
Date: Mon, 21 Oct 2024 14:57:01 -0700
Subject: [PATCH 1/2] Ensure NSLock/NSThread don't have stored properties with
 CoreFoundation types

---
 Sources/Foundation/NSLock.swift | 4 ++++
 Sources/Foundation/Thread.swift | 6 ++++++
 2 files changed, 10 insertions(+)

diff --git a/Sources/Foundation/NSLock.swift b/Sources/Foundation/NSLock.swift
index fe1d08b775..207ccd966e 100644
--- a/Sources/Foundation/NSLock.swift
+++ b/Sources/Foundation/NSLock.swift
@@ -11,6 +11,10 @@
 
 #if canImport(Glibc)
 import Glibc
+
+// Favor the Glibc declarations over the CoreFoundation declarations to ensure that stored properties use types from publicly imported modules
+typealias pthread_mutex_t = Glibc.pthread_mutex_t
+typealias pthread_cond_t = Glibc.pthread_cond_t
 #endif
 
 #if os(Windows)
diff --git a/Sources/Foundation/Thread.swift b/Sources/Foundation/Thread.swift
index 5e79579c62..5ffd592e71 100644
--- a/Sources/Foundation/Thread.swift
+++ b/Sources/Foundation/Thread.swift
@@ -15,8 +15,14 @@ import WinSDK
 
 #if canImport(Glibc)
 import Glibc
+
+// Favor the Glibc declarations over the CoreFoundation declarations to ensure that stored properties use types from publicly imported modules
+typealias pthread_t = Glibc.pthread_t
 #elseif canImport(Musl)
 import Musl
+
+// Favor the Musl declarations over the CoreFoundation declarations to ensure that stored properties use types from publicly imported modules
+typealias pthread_t = Musl.pthread_t
 #endif
 
 // WORKAROUND_SR9811

From 70d2bd82e51f4c9f24725be19fc5c70224841055 Mon Sep 17 00:00:00 2001
From: Jeremy Schonfeld <jschonfeld@apple.com>
Date: Tue, 22 Oct 2024 10:50:54 -0700
Subject: [PATCH 2/2] Store UnsafeMutableRawPointer/Any instead of concrete c
 types

---
 Sources/Foundation/NSLock.swift | 97 +++++++++++++++++++++++----------
 Sources/Foundation/Thread.swift | 53 +++++++++++++-----
 2 files changed, 108 insertions(+), 42 deletions(-)

diff --git a/Sources/Foundation/NSLock.swift b/Sources/Foundation/NSLock.swift
index 207ccd966e..6e953c0ad8 100644
--- a/Sources/Foundation/NSLock.swift
+++ b/Sources/Foundation/NSLock.swift
@@ -11,10 +11,6 @@
 
 #if canImport(Glibc)
 import Glibc
-
-// Favor the Glibc declarations over the CoreFoundation declarations to ensure that stored properties use types from publicly imported modules
-typealias pthread_mutex_t = Glibc.pthread_mutex_t
-typealias pthread_cond_t = Glibc.pthread_cond_t
 #endif
 
 #if os(Windows)
@@ -54,24 +50,37 @@ private typealias _ConditionVariablePointer = UnsafeMutablePointer<pthread_cond_
 #endif
 
 open class NSLock: NSObject, NSLocking, @unchecked Sendable {
-    internal var mutex = _MutexPointer.allocate(capacity: 1)
+    private let _mutex = UnsafeMutableRawPointer(_MutexPointer.allocate(capacity: 1))
+    
+    private var mutex: _MutexPointer {
+        _mutex.assumingMemoryBound(to: _MutexPointer.Pointee.self)
+    }
+    
 #if os(macOS) || os(iOS) || os(Windows)
-    private var timeoutCond = _ConditionVariablePointer.allocate(capacity: 1)
-    private var timeoutMutex = _MutexPointer.allocate(capacity: 1)
+    private let _timeoutCond = UnsafeMutableRawPointer(_ConditionVariablePointer.allocate(capacity: 1))
+    private let _timeoutMutex = UnsafeMutableRawPointer(_MutexPointer.allocate(capacity: 1))
+    
+    private var timeoutCond: _ConditionVariablePointer {
+        _timeoutCond.assumingMemoryBound(to: _ConditionVariablePointer.Pointee.self)
+    }
+    
+    private var timeoutMutex: _MutexPointer {
+        _timeoutMutex.assumingMemoryBound(to: _MutexPointer.Pointee.self)
+    }
 #endif
 
     public override init() {
 #if !SWIFT_CORELIBS_FOUNDATION_HAS_THREADS
         // noop on no thread platforms
 #elseif os(Windows)
-        InitializeSRWLock(mutex)
-        InitializeConditionVariable(timeoutCond)
-        InitializeSRWLock(timeoutMutex)
+        InitializeSRWLock(_mutex.assumingMemoryBound(to: _MutexPointer.Pointee.self))
+        InitializeConditionVariable(_timeoutCond.assumingMemoryBound(to: _ConditionVariablePointer.Pointee.self))
+        InitializeSRWLock(_timeoutMutex.assumingMemoryBound(to: _MutexPointer.Pointee.self))
 #else
-        pthread_mutex_init(mutex, nil)
+        pthread_mutex_init(_mutex.assumingMemoryBound(to: _MutexPointer.Pointee.self), nil)
 #if os(macOS) || os(iOS)
-        pthread_cond_init(timeoutCond, nil)
-        pthread_mutex_init(timeoutMutex, nil)
+        pthread_cond_init(_timeoutCond.assumingMemoryBound(to: _ConditionVariablePointer.Pointee.self), nil)
+        pthread_mutex_init(_timeoutMutex.assumingMemoryBound(to: _MutexPointer.Pointee.self), nil)
 #endif
 #endif
     }
@@ -176,7 +185,16 @@ extension NSLock {
 open class NSConditionLock : NSObject, NSLocking, @unchecked Sendable {
     internal var _cond = NSCondition()
     internal var _value: Int
-    internal var _thread: _swift_CFThreadRef?
+    internal var __thread: Any?
+    
+    internal var _thread: _swift_CFThreadRef? {
+        get {
+            __thread as! _swift_CFThreadRef?
+        }
+        set {
+            __thread = newValue
+        }
+    }
     
     public convenience override init() {
         self.init(condition: 0)
@@ -276,10 +294,23 @@ open class NSConditionLock : NSObject, NSLocking, @unchecked Sendable {
 #endif
 
 open class NSRecursiveLock: NSObject, NSLocking, @unchecked Sendable {
-    internal var mutex = _RecursiveMutexPointer.allocate(capacity: 1)
+    private let _mutex = UnsafeMutableRawPointer(_MutexPointer.allocate(capacity: 1))
+    
+    private var mutex: _MutexPointer {
+        _mutex.assumingMemoryBound(to: _MutexPointer.Pointee.self)
+    }
+    
 #if os(macOS) || os(iOS) || os(Windows)
-    private var timeoutCond = _ConditionVariablePointer.allocate(capacity: 1)
-    private var timeoutMutex = _MutexPointer.allocate(capacity: 1)
+    private let _timeoutCond = UnsafeMutableRawPointer(_ConditionVariablePointer.allocate(capacity: 1))
+    private let _timeoutMutex = UnsafeMutableRawPointer(_MutexPointer.allocate(capacity: 1))
+    
+    private var timeoutCond: _ConditionVariablePointer {
+        _timeoutCond.assumingMemoryBound(to: _ConditionVariablePointer.Pointee.self)
+    }
+    
+    private var timeoutMutex: _MutexPointer {
+        _timeoutMutex.assumingMemoryBound(to: _MutexPointer.Pointee.self)
+    }
 #endif
 
     public override init() {
@@ -287,9 +318,9 @@ open class NSRecursiveLock: NSObject, NSLocking, @unchecked Sendable {
 #if !SWIFT_CORELIBS_FOUNDATION_HAS_THREADS
         // noop on no thread platforms
 #elseif os(Windows)
-        InitializeCriticalSection(mutex)
-        InitializeConditionVariable(timeoutCond)
-        InitializeSRWLock(timeoutMutex)
+        InitializeCriticalSection(_mutex.assumingMemoryBound(to: _MutexPointer.Pointee.self))
+        InitializeConditionVariable(_timeoutCond.assumingMemoryBound(to: _ConditionVariablePointer.Pointee.self))
+        InitializeSRWLock(_timeoutMutex.assumingMemoryBound(to: _MutexPointer.Pointee.self))
 #else
 #if CYGWIN || os(OpenBSD)
         var attrib : pthread_mutexattr_t? = nil
@@ -304,11 +335,11 @@ open class NSRecursiveLock: NSObject, NSLocking, @unchecked Sendable {
             let type = Int32(PTHREAD_MUTEX_RECURSIVE)
 #endif
             pthread_mutexattr_settype(attrs, type)
-            pthread_mutex_init(mutex, attrs)
+            pthread_mutex_init(_mutex.assumingMemoryBound(to: _MutexPointer.Pointee.self), attrs)
         }
 #if os(macOS) || os(iOS)
-        pthread_cond_init(timeoutCond, nil)
-        pthread_mutex_init(timeoutMutex, nil)
+        pthread_cond_init(_timeoutCond.assumingMemoryBound(to: _ConditionVariablePointer.Pointee.self), nil)
+        pthread_mutex_init(_timeoutMutex.assumingMemoryBound(to: _MutexPointer.Pointee.self), nil)
 #endif
 #endif
     }
@@ -402,18 +433,26 @@ open class NSRecursiveLock: NSObject, NSLocking, @unchecked Sendable {
 }
 
 open class NSCondition: NSObject, NSLocking, @unchecked Sendable {
-    internal var mutex = _MutexPointer.allocate(capacity: 1)
-    internal var cond = _ConditionVariablePointer.allocate(capacity: 1)
+    private let _mutex = UnsafeMutableRawPointer(_MutexPointer.allocate(capacity: 1))
+    private let _cond = UnsafeMutableRawPointer(_ConditionVariablePointer.allocate(capacity: 1))
+    
+    private var mutex: _MutexPointer {
+        _mutex.assumingMemoryBound(to: _MutexPointer.Pointee.self)
+    }
+    
+    private var cond: _ConditionVariablePointer {
+        _cond.assumingMemoryBound(to: _ConditionVariablePointer.Pointee.self)
+    }
 
     public override init() {
 #if !SWIFT_CORELIBS_FOUNDATION_HAS_THREADS
         // noop on no thread platforms
 #elseif os(Windows)
-        InitializeSRWLock(mutex)
-        InitializeConditionVariable(cond)
+        InitializeSRWLock(_mutex.assumingMemoryBound(to: _MutexPointer.Pointee.self))
+        InitializeConditionVariable(_cond.assumingMemoryBound(to: _ConditionVariablePointer.Pointee.self))
 #else
-        pthread_mutex_init(mutex, nil)
-        pthread_cond_init(cond, nil)
+        pthread_mutex_init(_mutex.assumingMemoryBound(to: _MutexPointer.Pointee.self), nil)
+        pthread_cond_init(_cond.assumingMemoryBound(to: _ConditionVariablePointer.Pointee.self), nil)
 #endif
     }
     
diff --git a/Sources/Foundation/Thread.swift b/Sources/Foundation/Thread.swift
index 5ffd592e71..b2f68e0994 100644
--- a/Sources/Foundation/Thread.swift
+++ b/Sources/Foundation/Thread.swift
@@ -15,14 +15,8 @@ import WinSDK
 
 #if canImport(Glibc)
 import Glibc
-
-// Favor the Glibc declarations over the CoreFoundation declarations to ensure that stored properties use types from publicly imported modules
-typealias pthread_t = Glibc.pthread_t
 #elseif canImport(Musl)
 import Musl
-
-// Favor the Musl declarations over the CoreFoundation declarations to ensure that stored properties use types from publicly imported modules
-typealias pthread_t = Musl.pthread_t
 #endif
 
 // WORKAROUND_SR9811
@@ -216,24 +210,51 @@ open class Thread : NSObject {
     }
 
     internal var _main: () -> Void = {}
-    private var _thread: _swift_CFThreadRef? = nil
+    private var __thread: Any? = nil
+    
+    private var _thread: _swift_CFThreadRef? {
+        get {
+            __thread as! _swift_CFThreadRef?
+        }
+        set {
+            __thread = newValue
+        }
+    }
 
 #if os(Windows) && !CYGWIN
     private class NonexportedAttrStorage {
-        var value = _CFThreadAttributes(dwSizeOfAttributes: DWORD(MemoryLayout<_CFThreadAttributes>.size),
+        var value: Any = _CFThreadAttributes(dwSizeOfAttributes: DWORD(MemoryLayout<_CFThreadAttributes>.size),
                             dwThreadStackReservation: 0)
     }
 
     private let _attrStorage = NonexportedAttrStorage()
 
     internal final var _attr: _CFThreadAttributes {
-        get { _attrStorage.value }
+        get { _attrStorage.value as! _CFThreadAttributes }
         set { _attrStorage.value = newValue }
     }
 #elseif CYGWIN || os(OpenBSD)
-    internal var _attr : pthread_attr_t? = nil
+    internal var __attr : Any? = nil
+    
+    internal var _attr: pthread_attr_t? {
+        get {
+            __attr as! pthread_attr_t?
+        }
+        set {
+            __attr = newValue
+        }
+    }
 #else
-    internal var _attr = pthread_attr_t()
+    internal var __attr : Any = pthread_attr_t()
+    
+    internal var _attr: pthread_attr_t {
+        get {
+            __attr as! pthread_attr_t
+        }
+        set {
+            __attr = newValue
+        }
+    }
 #endif
     internal var _status = _NSThreadStatus.initialized
     internal var _cancelled = false
@@ -245,16 +266,22 @@ open class Thread : NSObject {
 
     internal init(thread: _swift_CFThreadRef) {
         // Note: even on Darwin this is a non-optional _CFThreadRef; this is only used for valid threads, which are never null pointers.
-        _thread = thread
+        __thread = thread
     }
 
     public override init() {
 #if !os(Windows)
-        let _ = withUnsafeMutablePointer(to: &_attr) { attr in
+        #if os(OpenBSD)
+        var attr: pthread_attr_t? = nil
+        #else
+        var attr = pthread_attr_t()
+        #endif
+        let _ = withUnsafeMutablePointer(to: &attr) { attr in
             pthread_attr_init(attr)
             pthread_attr_setscope(attr, Int32(PTHREAD_SCOPE_SYSTEM))
             pthread_attr_setdetachstate(attr, Int32(PTHREAD_CREATE_DETACHED))
         }
+        __attr = attr
 #endif
     }