[stdlib] Implement Atomics module

stdlib/public/Atomics/AtomicInteger.swift

@@ -0,0 +1,106 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2020 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 Swift
+
+@available(macOS 9999, iOS 9999, watchOS 9999, tvOS 9999, *)
+public protocol AtomicInteger: AtomicValue, FixedWidthInteger
+where _AtomicStorage: _PrimitiveAtomicInteger {}
+
+@available(macOS 9999, iOS 9999, watchOS 9999, tvOS 9999, *)
+public protocol _PrimitiveAtomicInteger: _PrimitiveAtomic {
+  /// Perform an atomic wrapping increment operation on the value referenced by
+  /// `pointer` and return the original value, applying the specified memory
+  /// ordering.
+  ///
+  /// Note: This operation silently wraps around on overflow, like the
+  /// `&+=` operator does on integer values.
+  ///
+  /// - Parameter operand: The value to add to the current value.
+  /// - Parameter pointer: A memory location previously initialized with a value
+  ///   returned by `prepareAtomicStorage(for:)`.
+  /// - Parameter ordering: The memory ordering to apply on this operation.
+  /// - Returns: The original value before the operation.
+  @_semantics("atomics.requires_constant_orderings")
+  static func _atomicLoadThenWrappingIncrement(
+    by operand: Self,
+    at pointer: UnsafeMutablePointer<Self>,
+    ordering: AtomicUpdateOrdering
+  ) -> Self
+
+  /// Perform an atomic wrapping decrement operation on the value referenced by
+  /// `pointer` and return the original value, applying the specified memory
+  /// ordering.
+  ///
+  /// Note: This operation silently wraps around on overflow, like the
+  /// `&-=` operator does on integer values.
+  ///
+  /// - Parameter operand: The value to subtract from the current value.
+  /// - Parameter pointer: A memory location previously initialized with a value
+  ///   returned by `prepareAtomicStorage(for:)`.
+  /// - Parameter ordering: The memory ordering to apply on this operation.
+  /// - Returns: The original value before the operation.
+  @_semantics("atomics.requires_constant_orderings")
+  static func _atomicLoadThenWrappingDecrement(
+    by operand: Self,
+    at pointer: UnsafeMutablePointer<Self>,
+    ordering: AtomicUpdateOrdering
+  ) -> Self
+
+  /// Perform an atomic bitwise AND operation on the value referenced by
+  /// `pointer` and return the original value, applying the specified memory
+  /// ordering.
+  ///
+  /// - Parameter operand: An integer value.
+  /// - Parameter pointer: A memory location previously initialized with a value
+  ///   returned by `prepareAtomicStorage(for:)`.
+  /// - Parameter ordering: The memory ordering to apply on this operation.
+  /// - Returns: The original value before the operation.
+  @_semantics("atomics.requires_constant_orderings")
+  static func _atomicLoadThenBitwiseAnd(
+    with operand: Self,
+    at pointer: UnsafeMutablePointer<Self>,
+    ordering: AtomicUpdateOrdering
+  ) -> Self
+
+  /// Perform an atomic bitwise OR operation on the value referenced by
+  /// `pointer` and return the original value, applying the specified memory
+  /// ordering.
+  ///
+  /// - Parameter operand: An integer value.
+  /// - Parameter pointer: A memory location previously initialized with a value
+  ///   returned by `prepareAtomicStorage(for:)`.
+  /// - Parameter ordering: The memory ordering to apply on this operation.
+  /// - Returns: The original value before the operation.
+  @_semantics("atomics.requires_constant_orderings")
+  static func _atomicLoadThenBitwiseOr(
+    with operand: Self,
+    at pointer: UnsafeMutablePointer<Self>,
+    ordering: AtomicUpdateOrdering
+  ) -> Self
+
+  /// Perform an atomic bitwise XOR operation on the value referenced by
+  /// `pointer` and return the original value, applying the specified memory
+  /// ordering.
+  ///
+  /// - Parameter operand: An integer value.
+  /// - Parameter pointer: A memory location previously initialized with a value
+  ///   returned by `prepareAtomicStorage(for:)`.
+  /// - Parameter ordering: The memory ordering to apply on this operation.
+  /// - Returns: The original value before the operation.
+  @_semantics("atomics.requires_constant_orderings")
+  static func _atomicLoadThenBitwiseXor(
+    with operand: Self,
+    at pointer: UnsafeMutablePointer<Self>,
+    ordering: AtomicUpdateOrdering
+  ) -> Self
+}

stdlib/public/Atomics/AtomicIntegerConformances.swift.gyb

@@ -0,0 +1,241 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2020 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
+//
+//===----------------------------------------------------------------------===//
+
+%{
+  def atomicTypes():
+    return [
+      # Swift    Builtin  Getter
+      ("Int",    "Word",  "_builtinWordValue"),
+      ("UInt",   "Word",  "_builtinWordValue"),
+      ("Int64",  "Int64", "_value"),
+      ("UInt64", "Int64", "_value"),
+      ("Int32",  "Int32", "_value"),
+      ("UInt32", "Int32", "_value"),
+      ("Int16",  "Int16", "_value"),
+      ("UInt16", "Int16", "_value"),
+      ("Int8",   "Int8",  "_value"),
+      ("UInt8",  "Int8",  "_value"),
+    ]
+
+  def rmwOrderings():
+    return [
+      # Swift enum case,         llvm name,   failure name
+      ('relaxed',                'monotonic', 'monotonic'),
+      ('acquiring',              'acquire',   'acquire'),
+      ('releasing',              'release',   'monotonic'),
+      ('acquiringAndReleasing',  'acqrel',    'acquire'),
+      ('sequentiallyConsistent', 'seqcst',    'seqcst'),
+    ]
+
+  def loadOrderings():
+    return [
+      # Swift enum case,         llvm name
+      ('relaxed',                'monotonic'),
+      ('acquiring',              'acquire'),
+      ('sequentiallyConsistent', 'seqcst'),
+    ]
+
+  def storeOrderings():
+    return [
+      # Swift enum case,         llvm name
+      ('relaxed',                'monotonic'),
+      ('releasing',              'release'),
+      ('sequentiallyConsistent', 'seqcst'),
+    ]
+
+  def caseStatementForOrdering(ordering):
+      return "case .{}".format(ordering)
+
+  # FIXME: Swift should provide intrinsics for arbitrary ordering pairs
+  def llvmOrders(rmw, load): # See llvm/Support/AtomicOrdering.h
+    def max(rmw, load):
+      if load == "acquire":
+        if rmw == "monotonic":
+          return "acquire"
+        if rmw == "release":
+          return "acqrel"
+      if load == "seqcst":
+        return "seqcst"
+      return rmw
+    return max(rmw, load) + "_" + load
+
+  def lowerFirst(str):
+    return str[:1].lower() + str[1:] if str else ""
+
+  def argLabel(label):
+    return label + ": " if label <> "_" else ""
+
+  integerOperations = [
+    # Swift name,         llvm name,  operator, label,  doc
+    ('WrappingIncrement', 'add',      '&+',     "by",   "wrapping add"),
+    ('WrappingDecrement', 'sub',      '&-',     "by",   "wrapping subtract"),
+    ('BitwiseAnd',        'and',      '&',      "with", "bitwise and"),
+    ('BitwiseOr',         'or',       '|',      "with", "bitwise or"),
+    ('BitwiseXor',        'xor',      '^',      "with", "bitwise xor")
+  ]
+}%
+
+import Swift
+
+% for (swiftType, builtinType, getter) in atomicTypes():
+@available(macOS 9999, iOS 9999, watchOS 9999, tvOS 9999, *)
+extension ${swiftType}: _PrimitiveAtomic {
+  @_semantics("atomics.requires_constant_orderings")
+  @_transparent @_alwaysEmitIntoClient
+  public static func _atomicLoad(
+    at pointer: UnsafeMutablePointer<${swiftType}>,
+    ordering: AtomicLoadOrdering
+  ) -> ${swiftType} {
+    switch ordering {
+%   for (swiftOrder, llvmOrder) in loadOrderings():
+    ${caseStatementForOrdering(swiftOrder)}:
+      return ${swiftType}(Builtin.atomicload_${llvmOrder}_${builtinType}(
+          pointer._rawValue))
+%   end
+    default:
+      Builtin.unreachable()
+    }
+  }
+
+  @_semantics("atomics.requires_constant_orderings")
+  @_transparent @_alwaysEmitIntoClient
+  public static func _atomicStore(
+    _ desired: ${swiftType},
+    at pointer: UnsafeMutablePointer<${swiftType}>,
+    ordering: AtomicStoreOrdering
+  ) {
+    switch ordering {
+%   for (swiftOrder, llvmOrder) in storeOrderings():
+    ${caseStatementForOrdering(swiftOrder)}:
+      Builtin.atomicstore_${llvmOrder}_${builtinType}(
+        pointer._rawValue,
+        desired.${getter})
+%   end
+    default:
+      Builtin.unreachable()
+    }
+  }
+
+  @_semantics("atomics.requires_constant_orderings")
+  @_transparent @_alwaysEmitIntoClient
+  public static func _atomicExchange(
+    _ desired: ${swiftType},
+    at pointer: UnsafeMutablePointer<${swiftType}>,
+    ordering: AtomicUpdateOrdering
+  ) -> ${swiftType} {
+    switch ordering {
+%   for (swiftOrder, llvmOrder, _) in rmwOrderings():
+    ${caseStatementForOrdering(swiftOrder)}:
+      return ${swiftType}(Builtin.atomicrmw_xchg_${llvmOrder}_${builtinType}(
+          pointer._rawValue, desired.${getter}))
+%   end
+    default:
+      Builtin.unreachable()
+    }
+  }
+
+  @_semantics("atomics.requires_constant_orderings")
+  @_transparent @_alwaysEmitIntoClient
+  public static func _atomicCompareExchange(
+    expected: ${swiftType},
+    desired: ${swiftType},
+    at pointer: UnsafeMutablePointer<${swiftType}>,
+    ordering: AtomicUpdateOrdering
+  ) -> (exchanged: Bool, original: ${swiftType}) {
+    switch ordering {
+%   for (swiftOrder, llvmOrder, failureOrder) in rmwOrderings():
+    ${caseStatementForOrdering(swiftOrder)}:
+      let (oldValue, won) = Builtin.cmpxchg_${llvmOrder}_${failureOrder}_${builtinType}(
+        pointer._rawValue, expected.${getter}, desired.${getter})
+      return (Bool(_builtinBooleanLiteral: won), ${swiftType}(oldValue))
+%   end
+    default:
+      Builtin.unreachable()
+    }
+  }
+
+  @_semantics("atomics.requires_constant_orderings")
+  @_transparent @_alwaysEmitIntoClient
+  public static func _atomicCompareExchange(
+    expected: ${swiftType},
+    desired: ${swiftType},
+    at pointer: UnsafeMutablePointer<${swiftType}>,
+    successOrdering: AtomicUpdateOrdering,
+    failureOrdering: AtomicLoadOrdering
+  ) -> (exchanged: Bool, original: ${swiftType}) {
+    switch (successOrdering, failureOrdering) {
+% for (swiftSuccess, llvmSuccess, _) in rmwOrderings():
+%   for (swiftFailure, llvmFailure) in loadOrderings():
+    case (.${swiftSuccess}, .${swiftFailure}):
+      let (oldValue, won) = Builtin.cmpxchg_${llvmOrders(llvmSuccess, llvmFailure)}_${builtinType}(
+        pointer._rawValue, expected.${getter}, desired.${getter})
+      return (Bool(_builtinBooleanLiteral: won), ${swiftType}(oldValue))
+%   end
+% end
+    default:
+      Builtin.unreachable()
+    }
+  }
+
+  @_semantics("atomics.requires_constant_orderings")
+  @_transparent @_alwaysEmitIntoClient
+  public static func _atomicWeakCompareExchange(
+    expected: ${swiftType},
+    desired: ${swiftType},
+    at pointer: UnsafeMutablePointer<${swiftType}>,
+    successOrdering: AtomicUpdateOrdering,
+    failureOrdering: AtomicLoadOrdering
+  ) -> (exchanged: Bool, original: ${swiftType}) {
+    switch (successOrdering, failureOrdering) {
+% for (swiftSuccess, llvmSuccess, _) in rmwOrderings():
+%   for (swiftFailure, llvmFailure) in loadOrderings():
+    case (.${swiftSuccess}, .${swiftFailure}):
+      let (oldValue, won) = Builtin.cmpxchg_${llvmOrders(llvmSuccess, llvmFailure)}_weak_${builtinType}(
+        pointer._rawValue, expected.${getter}, desired.${getter})
+      return (Bool(_builtinBooleanLiteral: won), ${swiftType}(oldValue))
+%   end
+% end
+    default:
+      Builtin.unreachable()
+    }
+  }
+}
+
+@available(macOS 9999, iOS 9999, watchOS 9999, tvOS 9999, *)
+extension ${swiftType}: AtomicInteger {
+    public typealias _AtomicStorage = ${swiftType}
+}
+
+@available(macOS 9999, iOS 9999, watchOS 9999, tvOS 9999, *)
+extension ${swiftType}: _PrimitiveAtomicInteger {
+% for (name, llvmop, op, label, doc) in integerOperations:
+% defaultValue = " = 1" if label <> "" else ""
+  @_semantics("atomics.requires_constant_orderings")
+  @_transparent @_alwaysEmitIntoClient
+  @discardableResult
+  public static func _atomicLoadThen${name}(
+    ${label} operand: Self${defaultValue},
+    at pointer: UnsafeMutablePointer<Self>,
+    ordering: AtomicUpdateOrdering
+  ) -> Self {
+    switch ordering {
+    % for (swiftOrder, llvmOrder, _) in rmwOrderings():
+    ${caseStatementForOrdering(swiftOrder)}:
+      return Self(Builtin.atomicrmw_${llvmop}_${llvmOrder}_${builtinType}(
+        pointer._rawValue, operand.${getter}))
+    % end
+    default:
+      Builtin.unreachable()
+    }
+  }
+% end
+}