PointerConformances.swift.gyb

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

  atomicTypes = [
    "UnsafeRawPointer",
    "UnsafeMutableRawPointer",
    "UnsafePointer",
    "UnsafeMutablePointer",
    "Unmanaged",
  ]
}%
${autogenerated_warning()}

#if ATOMICS_NATIVE_BUILTINS
import Swift
#else
import _AtomicsShims
#endif

% for swiftType in atomicTypes:
extension ${swiftType}: AtomicValue {
  @frozen
  public struct AtomicRepresentation {
    public typealias Value = ${swiftType}

#if ATOMICS_NATIVE_BUILTINS
    @usableFromInline
    internal typealias _Storage = Int
#else
    @usableFromInline
    internal typealias _Storage = _AtomicIntStorage
#endif

    @usableFromInline
    internal let _storage: _Storage

    @inline(__always) @_alwaysEmitIntoClient
    public init(_ value: Value) {
#if ATOMICS_NATIVE_BUILTINS
      _storage = Self._encode(value)
#else
      _storage = _sa_prepare_Int(Self._encode(value))
#endif
    }

    @inline(__always) @_alwaysEmitIntoClient
    public func dispose() -> Value {
#if ATOMICS_NATIVE_BUILTINS
      return Self._decode(_storage)
#else
      let v = _sa_dispose_Int(_storage)
      return Self._decode(v)
#endif
    }
  }
}

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

  @_transparent @_alwaysEmitIntoClient
  internal static func _decode(_ bitPattern: Int) -> Value {
    % if swiftType == "Unmanaged":
    return Unmanaged.fromOpaque(UnsafeRawPointer(bitPattern: bitPattern)!)
    % else:
    return ${swiftType}(bitPattern: bitPattern)!
    % end
  }

  @_transparent @_alwaysEmitIntoClient
  internal static func _encode(_ value: Value) -> Int {
    % if swiftType == "Unmanaged":
    return Int(bitPattern: value.toOpaque())
    % else:
    return Int(bitPattern: value)
    % end
  }
}

extension ${swiftType}.AtomicRepresentation: AtomicStorage {
  @_semantics("atomics.requires_constant_orderings")
  @_transparent @_alwaysEmitIntoClient
  public static func atomicLoad(
    at pointer: UnsafeMutablePointer<Self>,
    ordering: AtomicLoadOrdering
  ) -> Value {
    _decode(_extract(pointer)._atomicLoad(ordering: ordering))
  }

  @_semantics("atomics.requires_constant_orderings")
  @_transparent @_alwaysEmitIntoClient
  public static func atomicStore(
    _ desired: Value,
    at pointer: UnsafeMutablePointer<Self>,
    ordering: AtomicStoreOrdering
  ) {
    _extract(pointer)._atomicStore(_encode(desired), ordering: ordering)
  }

  @_semantics("atomics.requires_constant_orderings")
  @_transparent @_alwaysEmitIntoClient
  public static func atomicExchange(
    _ desired: Value,
    at pointer: UnsafeMutablePointer<Self>,
    ordering: AtomicUpdateOrdering
  ) -> Value {
    let v = _extract(pointer)._atomicExchange(
      _encode(desired), ordering: ordering)
    return _decode(v)
  }

  @_semantics("atomics.requires_constant_orderings")
  @_transparent @_alwaysEmitIntoClient
  public static func atomicCompareExchange(
    expected: Value,
    desired: Value,
    at pointer: UnsafeMutablePointer<Self>,
    ordering: AtomicUpdateOrdering
  ) -> (exchanged: Bool, original: Value) {
    let (exchanged, original) = _extract(pointer)._atomicCompareExchange(
      expected: _encode(expected),
      desired: _encode(desired),
      ordering: ordering)
    return (exchanged, _decode(original))
  }

  @_semantics("atomics.requires_constant_orderings")
  @_transparent @_alwaysEmitIntoClient
  public static func atomicCompareExchange(
    expected: Value,
    desired: Value,
    at pointer: UnsafeMutablePointer<Self>,
    successOrdering: AtomicUpdateOrdering,
    failureOrdering: AtomicLoadOrdering
  ) -> (exchanged: Bool, original: Value) {
    let (exchanged, original) = _extract(pointer)._atomicCompareExchange(
      expected: _encode(expected),
      desired: _encode(desired),
      successOrdering: successOrdering,
      failureOrdering: failureOrdering)
    return (exchanged, _decode(original))
  }

  @_semantics("atomics.requires_constant_orderings")
  @_transparent @_alwaysEmitIntoClient
  public static func atomicWeakCompareExchange(
    expected: Value,
    desired: Value,
    at pointer: UnsafeMutablePointer<Self>,
    successOrdering: AtomicUpdateOrdering,
    failureOrdering: AtomicLoadOrdering
  ) -> (exchanged: Bool, original: Value) {
    let (exchanged, original) = _extract(pointer)._atomicWeakCompareExchange(
      expected: _encode(expected),
      desired: _encode(desired),
      successOrdering: successOrdering,
      failureOrdering: failureOrdering)
    return (exchanged, _decode(original))
  }
}
% end


% for swiftType in atomicTypes:
extension ${swiftType}: AtomicOptionalWrappable {
  @frozen
  public struct AtomicOptionalRepresentation {
    public typealias Value = ${swiftType}?

#if ATOMICS_NATIVE_BUILTINS
    @usableFromInline
    internal typealias _Storage = Int
#else
    @usableFromInline
    internal typealias _Storage = _AtomicIntStorage
#endif

    @usableFromInline
    internal let _storage: _Storage

    @inline(__always) @_alwaysEmitIntoClient
    public init(_ value: Value) {
#if ATOMICS_NATIVE_BUILTINS
      _storage = Self._encode(value)
#else
      _storage = _sa_prepare_Int(Self._encode(value))
#endif
    }

    @inline(__always) @_alwaysEmitIntoClient
    public func dispose() -> Value {
#if ATOMICS_NATIVE_BUILTINS
      return Self._decode(_storage)
#else
      let v = _sa_dispose_Int(_storage)
      return Self._decode(v)
#endif
    }
  }
}

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

  @_transparent @_alwaysEmitIntoClient
  internal static func _decode(_ bitPattern: Int) -> Value {
    % if swiftType == "Unmanaged":
    guard let opaque = UnsafeRawPointer(bitPattern: bitPattern) else {
      return nil
    }
    return Unmanaged.fromOpaque(opaque)
    % else:
    return ${swiftType}(bitPattern: bitPattern)
    % end
  }

  @_transparent @_alwaysEmitIntoClient
  internal static func _encode(_ value: Value) -> Int {
    guard let value = value else { return 0 }
    % if swiftType == "Unmanaged":
    return Int(bitPattern: value.toOpaque())
    % else:
    return Int(bitPattern: value)
    % end
  }
}

extension ${swiftType}.AtomicOptionalRepresentation: AtomicStorage {
  @_semantics("atomics.requires_constant_orderings")
  @_transparent @_alwaysEmitIntoClient
  public static func atomicLoad(
    at pointer: UnsafeMutablePointer<Self>,
    ordering: AtomicLoadOrdering
  ) -> Value {
    _decode(_extract(pointer)._atomicLoad(ordering: ordering))
  }

  @_semantics("atomics.requires_constant_orderings")
  @_transparent @_alwaysEmitIntoClient
  public static func atomicStore(
    _ desired: Value,
    at pointer: UnsafeMutablePointer<Self>,
    ordering: AtomicStoreOrdering
  ) {
    _extract(pointer)._atomicStore(_encode(desired), ordering: ordering)
  }

  @_semantics("atomics.requires_constant_orderings")
  @_transparent @_alwaysEmitIntoClient
  public static func atomicExchange(
    _ desired: Value,
    at pointer: UnsafeMutablePointer<Self>,
    ordering: AtomicUpdateOrdering
  ) -> Value {
    _decode(_extract(pointer)._atomicExchange(_encode(desired), ordering: ordering))
  }

  @_semantics("atomics.requires_constant_orderings")
  @_transparent @_alwaysEmitIntoClient
  public static func atomicCompareExchange(
    expected: Value,
    desired: Value,
    at pointer: UnsafeMutablePointer<Self>,
    ordering: AtomicUpdateOrdering
  ) -> (exchanged: Bool, original: Value) {
    let (exchanged, original) = _extract(pointer)._atomicCompareExchange(
      expected: _encode(expected),
      desired: _encode(desired),
      ordering: ordering)
    return (exchanged, _decode(original))
  }

  @_semantics("atomics.requires_constant_orderings")
  @_transparent @_alwaysEmitIntoClient
  public static func atomicCompareExchange(
    expected: Value,
    desired: Value,
    at pointer: UnsafeMutablePointer<Self>,
    successOrdering: AtomicUpdateOrdering,
    failureOrdering: AtomicLoadOrdering
  ) -> (exchanged: Bool, original: Value) {
    let (exchanged, original) = _extract(pointer)._atomicCompareExchange(
      expected: _encode(expected),
      desired: _encode(desired),
      successOrdering: successOrdering,
      failureOrdering: failureOrdering)
    return (exchanged, _decode(original))
  }

  @_semantics("atomics.requires_constant_orderings")
  @_transparent @_alwaysEmitIntoClient
  public static func atomicWeakCompareExchange(
    expected: Value,
    desired: Value,
    at pointer: UnsafeMutablePointer<Self>,
    successOrdering: AtomicUpdateOrdering,
    failureOrdering: AtomicLoadOrdering
  ) -> (exchanged: Bool, original: Value) {
    let (exchanged, original) = _extract(pointer)._atomicWeakCompareExchange(
      expected: _encode(expected),
      desired: _encode(desired),
      successOrdering: successOrdering,
      failureOrdering: failureOrdering)
    return (exchanged, _decode(original))
  }
}
% end