AtomicBool.swift.gyb

//===----------------------------------------------------------------------===//
//
// This source file is part of the Swift Atomics open source project
//
// Copyright (c) 2020-2021 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
//
//===----------------------------------------------------------------------===//

%{
  from gyb_utils import (
    autogenerated_warning, loadOrderings, storeOrderings, updateOrderings,
    boolOperations, lowerFirst, argLabel, shimOrders)
}%
${autogenerated_warning()}

import _AtomicsShims

extension Bool: AtomicValue {
  @frozen
  public struct AtomicRepresentation {
    public typealias Value = Bool
    @usableFromInline
    internal var _storage: _AtomicBoolStorage

    @inline(__always) @_alwaysEmitIntoClient
    public init(_ value: Bool) {
      _storage = _sa_prepare_Bool(value)
    }

    @inline(__always) @_alwaysEmitIntoClient
    public func dispose() -> Value {
      _sa_dispose_Bool(_storage)
    }
  }
}

extension Bool.AtomicRepresentation {
  @_transparent @_alwaysEmitIntoClient
  @usableFromInline
  static func _extract(
    _ ptr: UnsafeMutablePointer<Self>
  ) -> UnsafeMutablePointer<_AtomicBoolStorage> {
    // `Self` is layout-compatible with its only stored property.
    return UnsafeMutableRawPointer(ptr)
      .assumingMemoryBound(to: _AtomicBoolStorage.self)
  }
}

extension Bool.AtomicRepresentation: AtomicStorage {
  @_semantics("atomics.requires_constant_orderings")
  @_transparent @_alwaysEmitIntoClient
  public static func atomicLoad(
    at pointer: UnsafeMutablePointer<Bool.AtomicRepresentation>,
    ordering: AtomicLoadOrdering
  ) -> Bool {
    switch ordering {
% for (swiftOrder, shimOrder) in loadOrderings:
    case .${swiftOrder}:
      return _sa_load_${shimOrder}_Bool(_extract(pointer))
% end
    default:
      fatalError("Unsupported ordering")
    }
  }

  @_semantics("atomics.requires_constant_orderings")
  @_transparent @_alwaysEmitIntoClient
  public static func atomicStore(
    _ desired: __owned Bool,
    at pointer: UnsafeMutablePointer<Bool.AtomicRepresentation>,
    ordering: AtomicStoreOrdering
  ) {
    switch ordering {
% for (swiftOrder, shimOrder) in storeOrderings:
    case .${swiftOrder}:
      _sa_store_${shimOrder}_Bool(_extract(pointer), desired)
% end
    default:
      fatalError("Unsupported ordering")
    }
  }

  @_semantics("atomics.requires_constant_orderings")
  @_transparent @_alwaysEmitIntoClient
  public static func atomicExchange(
    _ desired: __owned Bool,
    at pointer: UnsafeMutablePointer<Bool.AtomicRepresentation>,
    ordering: AtomicUpdateOrdering
  ) -> Bool {
    switch ordering {
% for (swiftOrder, shimOrder, _) in updateOrderings:
    case .${swiftOrder}:
      return _sa_exchange_${shimOrder}_Bool(_extract(pointer), desired)
% end
    default:
      fatalError("Unsupported ordering")
    }
  }

  @_semantics("atomics.requires_constant_orderings")
  @_transparent @_alwaysEmitIntoClient
  public static func atomicCompareExchange(
    expected: Bool,
    desired: __owned Bool,
    at pointer: UnsafeMutablePointer<Bool.AtomicRepresentation>,
    ordering: AtomicUpdateOrdering
  ) -> (exchanged: Bool, original: Bool) {
    var expected = expected
    let exchanged: Bool
    switch ordering {
% for (swiftOrder, shimOrder, failOrder) in updateOrderings:
    case .${swiftOrder}:
      exchanged = _sa_cmpxchg_strong_${shimOrder}_${failOrder}_Bool(
        _extract(pointer),
        &expected, desired)
% end
    default:
      fatalError("Unsupported ordering")
    }
    return (exchanged, expected)
  }

  @_semantics("atomics.requires_constant_orderings")
  @_transparent @_alwaysEmitIntoClient
  public static func atomicCompareExchange(
    expected: Bool,
    desired: __owned Bool,
    at pointer: UnsafeMutablePointer<Bool.AtomicRepresentation>,
    successOrdering: AtomicUpdateOrdering,
    failureOrdering: AtomicLoadOrdering
  ) -> (exchanged: Bool, original: Bool) {
    var expected = expected
    let exchanged: Bool
    // FIXME: stdatomic.h (and LLVM underneath) doesn't support
    // arbitrary ordering combinations yet, so upgrade the success
    // ordering when necessary so that it is at least as "strong" as
    // the failure case.
    switch (successOrdering, failureOrdering) {
% for (swiftSuccess, shimSuccess, _) in updateOrderings:
%   for (swiftFailure, shimFailure) in loadOrderings:
    case (.${swiftSuccess}, .${swiftFailure}):
      exchanged = _sa_cmpxchg_strong_${shimOrders(shimSuccess, shimFailure)}_Bool(
        _extract(pointer),
        &expected,
        desired)
%   end
% end
    default:
      fatalError("Unsupported ordering")
    }
    return (exchanged, expected)
  }

  @_semantics("atomics.requires_constant_orderings")
  @_transparent @_alwaysEmitIntoClient
  public static func atomicWeakCompareExchange(
    expected: Bool,
    desired: __owned Bool,
    at pointer: UnsafeMutablePointer<Bool.AtomicRepresentation>,
    successOrdering: AtomicUpdateOrdering,
    failureOrdering: AtomicLoadOrdering
  ) -> (exchanged: Bool, original: Bool) {
    var expected = expected
    let exchanged: Bool
    // FIXME: stdatomic.h (and LLVM underneath) doesn't support
    // arbitrary ordering combinations yet, so upgrade the success
    // ordering when necessary so that it is at least as "strong" as
    // the failure case.
    switch (successOrdering, failureOrdering) {
% for (swiftSuccess, shimSuccess, _) in updateOrderings:
%   for (swiftFailure, shimFailure) in loadOrderings:
    case (.${swiftSuccess}, .${swiftFailure}):
      exchanged = _sa_cmpxchg_weak_${shimOrders(shimSuccess, shimFailure)}_Bool(
        _extract(pointer),
        &expected,
        desired)
%   end
% end
    default:
      fatalError("Unsupported ordering")
    }
    return (exchanged, expected)
  }
}


// MARK: - Additional operations

extension Bool.AtomicRepresentation {
% for (name, cname, op, label, doc) in boolOperations:
  /// Perform an atomic ${doc} operation on the value referenced by
  /// `pointer` and return the original value, applying the specified memory
  /// ordering.
  ///
  /// - Parameter operand: A boolean value.
  /// - Parameter pointer: A memory location previously initialized with a value
  ///   returned by `prepareAtomicRepresentation(for:)`.
  /// - Parameter ordering: The memory ordering to apply on this operation.
  /// - Returns: The original value before the operation.
  @_semantics("atomics.requires_constant_orderings")
  @_transparent @_alwaysEmitIntoClient
  public static func atomicLoadThen${name}(
    ${label} operand: Value,
    at pointer: UnsafeMutablePointer<Self>,
    ordering: AtomicUpdateOrdering
  ) -> Value {
    switch ordering {
% for (swiftOrder, shimOrder, _) in updateOrderings:
    case .${swiftOrder}:
      return _sa_fetch_${cname}_${shimOrder}_Bool(
        _extract(pointer),
        operand)
% end
    default:
      fatalError("Unsupported ordering")
    }
  }
% end
}

% for construct in ["UnsafeAtomic", "ManagedAtomic"]:
extension ${construct} where Value == Bool {
% for (name, cname, op, label, doc) in boolOperations:
  /// Perform an atomic ${doc} operation and return the original value, applying
  /// the specified memory ordering.
  ///
  /// - Parameter operand: A boolean value.
  /// - Parameter ordering: The memory ordering to apply on this operation.
  /// - Returns: The original value before the operation.
  @_semantics("atomics.requires_constant_orderings")
  @_transparent @_alwaysEmitIntoClient
  public func loadThen${name}(
    ${label} operand: Value,
    ordering: AtomicUpdateOrdering
  ) -> Value {
    Value.AtomicRepresentation.atomicLoadThen${name}(
      ${argLabel(label)}operand,
      at: _ptr,
      ordering: ordering)
  }
% end
}

extension ${construct} where Value == Bool {
% for (name, cname, op, label, doc) in boolOperations:
  /// Perform an atomic ${doc} operation and return the original value, applying
  /// the specified memory ordering.
  ///
  /// - Parameter operand: A boolean value.
  /// - Parameter ordering: The memory ordering to apply on this operation.
  /// - Returns: The original value before the operation.
  @_semantics("atomics.requires_constant_orderings")
  @_transparent @_alwaysEmitIntoClient
  public func ${lowerFirst(name)}ThenLoad(
    ${label} operand: Value,
    ordering: AtomicUpdateOrdering
  ) -> Value {
    let original = Value.AtomicRepresentation.atomicLoadThen${name}(
      ${argLabel(label)}operand,
      at: _ptr,
      ordering: ordering)
    return original ${op} operand
  }
% end
}
% end