Use libpthread primitives for OpenBSD mutexes.

There has been some discussion as to whether this is the right approach,
centered around internal pointers in the underlying mutex structure.
After much thought, let's commit this for now. The argument:

* While it is true that OpenBSD has futex(2) and in fact is used in
  the underlying implementations in Dispatch. I'm not confident right now
  creating robust locking primitives by hand from futexes.
  It would be ideal to just delegate all of this to Dispatch, but
  Dispatch doesn't expose a ready-use API for mutexes. Cobbling one
  together might be possible, but that would take some time and finesse.

* While recent versions of C and C++ have language support for mutexes,
  they are implemented in many cases by libpthread anyway, so there
  is nothing inherently gained right now by not using the pthread API
  other than portability.

* While the concern for internal pointers for the pthread API is
  important, the OpenBSD is mitigated by the fact that pthread_mutex_t is
  pointer-valued on the platform. The concern that this might not always
  be the case is mitigated by the fact that this commit does not attempt
  to use the pthread implementation as a catch-all for all platforms.

* The alternative is to use MutexUnavailable, but given Foundation has
  some dependencies on Mutex, this may cause problems elsewhere
  throughout the port.

Author: 3405691582

stdlib/public/Synchronization/CMakeLists.txt

@@ -80,6 +80,13 @@ set(SWIFT_SYNCHRONIZATION_WINDOWS_SOURCES
   Mutex/WindowsImpl.swift
 )
 
+# OpenBSD sources
+
+set(SWIFT_SYNCHRONIZATION_OPENBSD_SOURCES
+  Mutex/Mutex.swift
+  Mutex/OpenBSDImpl.swift
+)
+
 set(SWIFT_SYNCHRNOIZATION_SWIFT_FLAGS
   ${SWIFT_STANDARD_LIBRARY_SWIFT_FLAGS}
   "-enable-builtin-module"
@@ -115,6 +122,8 @@ add_swift_target_library(swiftSynchronization ${SWIFT_STDLIB_LIBRARY_BUILD_TYPES
     ${SWIFT_SYNCHRONIZATION_WINDOWS_SOURCES}
   SWIFT_SOURCES_DEPENDS_FREEBSD
     ${SWIFT_SYNCHRONIZATION_FREEBSD_SOURCES}
+  SWIFT_SOURCES_DEPENDS_OPENBSD
+    ${SWIFT_SYNCHRONIZATION_OPENBSD_SOURCES}
   SWIFT_SOURCES_DEPENDS_FREESTANDING
     Mutex/MutexUnavailable.swift
 
@@ -140,6 +149,8 @@ add_swift_target_library(swiftSynchronization ${SWIFT_STDLIB_LIBRARY_BUILD_TYPES
     WinSDK
   SWIFT_MODULE_DEPENDS_FREEBSD
     Glibc
+  SWIFT_MODULE_DEPENDS_OPENBSD
+    Glibc
 
   SWIFT_COMPILE_FLAGS
     ${SWIFT_SYNCHRNOIZATION_SWIFT_FLAGS}

stdlib/public/Synchronization/Mutex/OpenBSDImpl.swift

@@ -0,0 +1,58 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift Atomics open source project
+//
+// Copyright (c) 2024 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+import Glibc
+
+@available(SwiftStdlib 6.0, *)
+@frozen
+@_staticExclusiveOnly
+public struct _MutexHandle: ~Copyable {
+  @usableFromInline
+  let value: _Cell<pthread_mutex_t?>
+
+  @available(SwiftStdlib 6.0, *)
+  @_alwaysEmitIntoClient
+  @_transparent
+  public init() {
+    var mx = pthread_mutex_t(bitPattern: 0)
+    pthread_mutex_init(&mx, nil)
+    value = _Cell(mx)
+  }
+
+  @available(SwiftStdlib 6.0, *)
+  @_alwaysEmitIntoClient
+  @_transparent
+  internal borrowing func _lock() {
+    pthread_mutex_lock(value._address)
+  }
+
+  @available(SwiftStdlib 6.0, *)
+  @_alwaysEmitIntoClient
+  @_transparent
+  internal borrowing func _tryLock() -> Bool {
+    pthread_mutex_trylock(value._address) != 0
+  }
+
+  @available(SwiftStdlib 6.0, *)
+  @_alwaysEmitIntoClient
+  @_transparent
+  internal borrowing func _unlock() {
+    pthread_mutex_unlock(value._address)
+  }
+
+  @available(SwiftStdlib 6.0, *)
+  @_alwaysEmitIntoClient
+  @_transparent
+  deinit {
+    pthread_mutex_destroy(value._address)
+  }
+}