Memory fences for non-Darwin, non-x86 platforms.

Package.swift

@@ -1,6 +1,6 @@
 import PackageDescription
 
-let package = Package(
+var package = Package(
     name: "ReactiveSwift",
     dependencies: [
         .Package(url: "https://github.com/antitypical/Result.git", majorVersion: 3),
@@ -9,3 +9,15 @@ let package = Package(
         "Sources/Deprecations+Removals.swift",
     ]
 )
+
+#if os(Linux)
+package.targets = [
+	Target(name: "ReactiveSwift", dependencies: ["ReactiveSwiftSupport"])
+]
+#endif
+
+#if os(macOS) || os(iOS) || os(tvOS) || os(watchOS)
+package.targets = [
+	Target(name: "ReactiveSwift", dependencies: [])
+]
+#endif

Sources/ReactiveSwift/MemoryOrdering.swift

@@ -0,0 +1,29 @@
+#if os(Linux)
+import ReactiveSwiftSupport
+#endif
+
+#if os(iOS) || os(tvOS) || os(watchOS)
+import Darwin.C.stdatomic
+#endif
+
+@inline(__always)
+internal func acquireFence() {
+	#if !(arch(x86_64) || arch(i386))
+		#if os(iOS) || os(tvOS) || os(watchOS)
+			atomic_thread_fence(memory_order_acquire)
+		#else
+			_reactiveSwift_acquire_fence()
+		#endif
+	#endif
+}
+
+@inline(__always)
+internal func releaseFence() {
+	#if !(arch(x86_64) || arch(i386))
+		#if os(iOS) || os(tvOS) || os(watchOS)
+			atomic_thread_fence(memory_order_release)
+		#else
+			_reactiveSwift_release_fence()
+		#endif
+	#endif
+}

Sources/Signal.swift → Sources/ReactiveSwift/Signal.swift

@@ -98,7 +98,7 @@ public final class Signal<Value, Error: Swift.Error> {
 				// occasionally one of the senders waiting on `sendLock`.
 				if let state = signal.state.swap(nil) {
 					terminationEvent = event
-					atomic_thread_fence(memory_order_release)
+					releaseFence()
 					terminationState = state
 
 					// Writes to `terminationState` are implicitly synchronized. So we do
@@ -116,7 +116,7 @@ public final class Signal<Value, Error: Swift.Error> {
 					// guaranteed to be blocked.
 					if sendLock.try() {
 						if !terminated, let state = terminationState {
-							atomic_thread_fence(memory_order_acquire)
+							acquireFence()
 							interrupt(state.observers, event: terminationEvent!)
 						}
 						sendLock.unlock()
@@ -136,7 +136,7 @@ public final class Signal<Value, Error: Swift.Error> {
 					// Check if a downstream consumer or a concurrent sender has
 					// interrupted the signal.
 					if let state = terminationState {
-						atomic_thread_fence(memory_order_acquire)
+						acquireFence()
 						interrupt(state.observers, event: terminationEvent!)
 						shouldDispose = true
 					}
@@ -156,7 +156,7 @@ public final class Signal<Value, Error: Swift.Error> {
 					// lock acquisition above succeeds. So we have to check again if the
 					// signal is really still alive.
 					if !terminated {
-						atomic_thread_fence(memory_order_acquire)
+						acquireFence()
 						interrupt(state.observers, event: terminationEvent!)
 						shouldDispose = true
 					}

Sources/ReactiveSwiftSupport/ReactiveSwiftSupport.c

@@ -0,0 +1,2 @@
+static void _reactiveSwift_release_fence(void) __attribute__((unused));
+static void _reactiveSwift_acquire_fence(void) __attribute__((unused));

Sources/ReactiveSwiftSupport/include/ReactiveSwiftSupport.h

@@ -0,0 +1,10 @@
+#import <stdatomic.h>
+#import <string.h>
+
+static void _reactiveSwift_release_fence() {
+	atomic_thread_fence(memory_order_release);
+}
+
+static void _reactiveSwift_acquire_fence() {
+	atomic_thread_fence(memory_order_acquire);
+}